ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
Public Member Functions | Private Attributes | List of all members
Radiation Class Reference

#include <ERF_Radiation.H>

Inheritance diagram for Radiation:
Inheritance graph
[legend]
Collaboration diagram for Radiation:
Collaboration graph
[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::iMultiFab *lmask, amrex::MultiFab *t_surf, amrex::Vector< amrex::MultiFab * > &lsm_input_ptrs, amrex::Vector< amrex::MultiFab * > &lsm_output_ptrs, amrex::MultiFab *qheating_rates, amrex::MultiFab *rad_fluxes, amrex::MultiFab *z_phys, amrex::MultiFab *lat_ptr, amrex::MultiFab *lon_ptr) 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::iMultiFab *lmask, amrex::MultiFab *t_surf, amrex::Vector< amrex::MultiFab * > &lsm_input_ptrs, amrex::MultiFab *qheating_rates, amrex::MultiFab *rad_fluxes, amrex::MultiFab *z_phys, amrex::MultiFab *lat, amrex::MultiFab *lon)
 
void alloc_buffers ()
 
void dealloc_buffers ()
 
void mf_to_kokkos_buffers (amrex::iMultiFab *lmask, amrex::MultiFab *t_surf, 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
 
amrex::Real m_rad_t_sfc = -1
 
amrex::MultiFab * m_cons_in = nullptr
 
amrex::MultiFab * m_qheating_rates = nullptr
 
amrex::MultiFab * m_rad_fluxes = nullptr
 
amrex::MultiFab * m_z_phys = nullptr
 
amrex::MultiFab * m_lat = nullptr
 
amrex::MultiFab * m_lon = nullptr
 
amrex::Real m_lat_cons = amrex::Real(39.809860)
 
amrex::Real m_lon_cons = -amrex::Real(98.555183)
 
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-g256-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 = amrex::Real(388.717e-6)
 
amrex::Vector< amrex::Real > m_o3vmr
 
amrex::Real m_n2ovmr = amrex::Real(323.141e-9)
 
amrex::Real m_covmr = amrex::Real(1.0e-7)
 
amrex::Real m_ch4vmr = amrex::Real(1807.851e-9)
 
amrex::Real m_o2vmr = amrex::Real(0.209448)
 
amrex::Real m_n2vmr = amrex::Real(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 = false
 
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 = -amrex::Real(9999.)
 
amrex::Real m_orbital_obliq = -amrex::Real(9999.)
 
amrex::Real m_orbital_mvelp = -amrex::Real(9999.)
 
amrex::Real m_fixed_total_solar_irradiance = -amrex::Real(9999.)
 
amrex::Real m_fixed_solar_zenith_angle = -amrex::Real(9999.)
 
int m_nswbands
 
int m_nlwbands
 
int m_nswgpts
 
int m_nlwgpts
 
int m_rad_freq_in_steps = 1
 
int m_ncol_chunk = 1024
 
int m_rad_nvar = 12
 
bool m_do_subcol_sampling = true
 
real1d_k o3_lay
 
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 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 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
 
real3d_k aero_tau_sw
 
real3d_k aero_ssa_sw
 
real3d_k aero_g_sw
 
real3d_k aero_tau_lw
 

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 
)
22 {
23  // Note that Kokkos is now initialized in main.cpp
24 
25  // Check if we have a valid moisture model
26  if (sc.moisture_type != MoistureType::None) { m_moist = true; }
27 
28  // Check if we have a moisture model with ice
29  if (sc.moisture_type == MoistureType::SAM) { m_ice = true; }
30 
31  // Check if we have a land surface model enabled
32  if (sc.lsm_type != LandSurfaceType::None) { m_lsm = true; }
33 
34  // Construct parser object for following reads
35  ParmParse pp("erf");
36 
37  // Must specify a surface temp (LSM can overwrite)
38  pp.get("rad_t_sfc", m_rad_t_sfc);
39 
40  // Radiation timestep, as a number of atm steps
41  pp.query("rad_freq_in_steps", m_rad_freq_in_steps);
42 
43  // Get nvar if specified
44  pp.query("rad_nvar", m_rad_nvar);
45  AMREX_ALWAYS_ASSERT_WITH_MESSAGE(m_rad_nvar >= 0,
46  "erf.rad_nvar must be greater than 0. "
47  "It controls the amount of memory allocated for temporaries with RRTMGP; "
48  "a value of 0 would allocate no memory.");
49 
50  // Number of columns per RRTMGP chunk (controls peak GPU memory)
51  pp.query("rad_ncol_chunk", m_ncol_chunk);
52  AMREX_ALWAYS_ASSERT_WITH_MESSAGE(m_ncol_chunk > 0,
53  "erf.rad_ncol_chunk must be a positive integer (default 5000). "
54  "It controls the number of columns processed per RRTMGP kernel launch; "
55  "a value of 0 or negative would produce an infinite loop.");
56 
57  // Flag to write fluxes to plt file
58  pp.query("rad_write_fluxes", m_rad_write_fluxes);
59 
60  // Do MCICA subcolumn sampling
61  pp.query("rad_do_subcol_sampling", m_do_subcol_sampling);
62 
63  // Determine orbital year. If orbital_year is negative, use current year
64  // from timestamp for orbital year; if positive, use provided orbital year
65  // for duration of simulation.
66  m_fixed_orbital_year = pp.query("rad_orbital_year", m_orbital_year);
67 
68  // Get orbital parameters from inputs file
69  pp.query("rad_orbital_eccentricity", m_orbital_eccen);
70  pp.query("rad_orbital_obliquity" , m_orbital_obliq);
71  pp.query("rad_orbital_mvelp" , m_orbital_mvelp);
72 
73  // Get a constant lat/lon for idealized simulations
74  pp.query("rad_cons_lat", m_lat_cons);
75  pp.query("rad_cons_lon", m_lon_cons);
76 
77  // Value for prescribing an invariant solar constant (i.e. total solar irradiance at
78  // TOA). Used for idealized experiments such as RCE. Disabled when value is less than zero
79  pp.query("fixed_total_solar_irradiance", m_fixed_total_solar_irradiance);
80 
81  // Determine whether or not we are using a fixed solar zenith angle (positive value)
82  pp.query("fixed_solar_zenith_angle", m_fixed_solar_zenith_angle);
83 
84  // Get prescribed surface values of greenhouse gases
85  pp.query("co2vmr", m_co2vmr);
86  pp.queryarr("o3vmr" , m_o3vmr );
87  pp.query("n2ovmr", m_n2ovmr);
88  pp.query("covmr" , m_covmr );
89  pp.query("ch4vmr", m_ch4vmr);
90  pp.query("o2vmr" , m_o2vmr );
91  pp.query("n2vmr" , m_n2vmr );
92 
93  // Aerosol forcing hook (not implemented). The aerosol arrays that used to be
94  // passed through rrtmgp_main were never populated with real data, so enabling
95  // this flag only ever multiplied radiation by zero aerosol optics. The hook is
96  // kept so a future SPA/prescribed-aerosol scheme can wire in without touching
97  // the ParmParse surface.
98  pp.query("rad_do_aerosol", m_do_aerosol_rad);
99  if (m_do_aerosol_rad) {
100  amrex::Abort("erf.rad_do_aerosol = true is not supported: aerosol forcing is "
101  "currently not implemented in the ERF RRTMGP interface. The hook "
102  "is retained for a future aerosol coupling; set rad_do_aerosol = "
103  "false (or remove it) to continue.");
104  }
105 
106  // Whether we do extra clean/clear sky calculations
107  pp.query("rad_extra_clnclrsky_diag", m_extra_clnclrsky_diag);
108  pp.query("rad_extra_clnsky_diag" , m_extra_clnsky_diag);
109 
110  // Parse path and file names
111  pp.query("rrtmgp_file_path" , rrtmgp_file_path);
112  pp.query("rrtmgp_coeffs_sw" , rrtmgp_coeffs_sw );
113  pp.query("rrtmgp_coeffs_lw" , rrtmgp_coeffs_lw );
114  pp.query("rrtmgp_cloud_optics_sw", rrtmgp_cloud_optics_sw);
115  pp.query("rrtmgp_cloud_optics_lw", rrtmgp_cloud_optics_lw);
116 
117  // Append file names to path
118  rrtmgp_coeffs_file_sw = rrtmgp_file_path + "/" + rrtmgp_coeffs_sw;
119  rrtmgp_coeffs_file_lw = rrtmgp_file_path + "/" + rrtmgp_coeffs_lw;
120  rrtmgp_cloud_optics_file_sw = rrtmgp_file_path + "/" + rrtmgp_cloud_optics_sw;
121  rrtmgp_cloud_optics_file_lw = rrtmgp_file_path + "/" + rrtmgp_cloud_optics_lw;
122 
123  // Get dimensions from lookup data
124  if (ParallelDescriptor::IOProcessor()) {
125  auto ncf_sw = ncutils::NCFile::open(rrtmgp_coeffs_file_sw, NC_CLOBBER | NC_NETCDF4);
126  m_nswbands = ncf_sw.dim("bnd").len();
127  m_nswgpts = ncf_sw.dim("gpt").len();
128  ncf_sw.close();
129 
130  auto ncf_lw = ncutils::NCFile::open(rrtmgp_coeffs_file_lw, NC_CLOBBER | NC_NETCDF4);
131  m_nlwbands = ncf_lw.dim("bnd").len();
132  m_nlwgpts = ncf_lw.dim("gpt").len();
133  ncf_lw.close();
134  }
135  int ioproc = ParallelDescriptor::IOProcessorNumber(); // I/O rank
136  ParallelDescriptor::Bcast(&m_nswbands, 1, ioproc);
137  ParallelDescriptor::Bcast(&m_nlwbands, 1, ioproc);
138  ParallelDescriptor::Bcast(&m_nswgpts, 1, ioproc);
139  ParallelDescriptor::Bcast(&m_nlwgpts, 1, ioproc);
140 
141  // Output for user
142  if (lev == 0) {
143  Print() << "Radiation interface constructed:\n";
144  Print() << "========================================================\n";
145  Print() << "Coeff SW file: " << rrtmgp_coeffs_file_sw << "\n";
146  Print() << "Coeff LW file: " << rrtmgp_coeffs_file_lw << "\n";
147  Print() << "Cloud SW file: " << rrtmgp_cloud_optics_file_sw << "\n";
148  Print() << "Cloud LW file: " << rrtmgp_cloud_optics_file_lw << "\n";
149  Print() << "Number of short/longwave bands: "
150  << m_nswbands << " " << m_nlwbands << "\n";
151  Print() << "Number of short/longwave gauss points: "
152  << m_nswgpts << " " << m_nlwgpts << "\n";
153  Print() << "========================================================\n";
154  }
155 }
pp
ParmParse pp("prob")
Radiation::rrtmgp_coeffs_file_sw
std::string rrtmgp_coeffs_file_sw
Definition: ERF_Radiation.H:292
Radiation::rrtmgp_coeffs_sw
std::string rrtmgp_coeffs_sw
Definition: ERF_Radiation.H:288
Radiation::m_rad_freq_in_steps
int m_rad_freq_in_steps
Definition: ERF_Radiation.H:373
Radiation::m_lon_cons
amrex::Real m_lon_cons
Definition: ERF_Radiation.H:281
Radiation::m_nswbands
int m_nswbands
Definition: ERF_Radiation.H:367
Radiation::m_do_aerosol_rad
bool m_do_aerosol_rad
Definition: ERF_Radiation.H:335
Radiation::rrtmgp_coeffs_lw
std::string rrtmgp_coeffs_lw
Definition: ERF_Radiation.H:289
Radiation::m_moist
bool m_moist
Definition: ERF_Radiation.H:243
Radiation::rrtmgp_cloud_optics_file_lw
std::string rrtmgp_cloud_optics_file_lw
Definition: ERF_Radiation.H:295
Radiation::m_lsm
bool m_lsm
Definition: ERF_Radiation.H:247
Radiation::m_do_subcol_sampling
bool m_do_subcol_sampling
Definition: ERF_Radiation.H:382
Radiation::m_rad_write_fluxes
bool m_rad_write_fluxes
Definition: ERF_Radiation.H:238
Radiation::rrtmgp_cloud_optics_file_sw
std::string rrtmgp_cloud_optics_file_sw
Definition: ERF_Radiation.H:294
Radiation::m_orbital_mvelp
amrex::Real m_orbital_mvelp
Definition: ERF_Radiation.H:355
Radiation::m_o3vmr
amrex::Vector< amrex::Real > m_o3vmr
Definition: ERF_Radiation.H:306
Radiation::rrtmgp_cloud_optics_sw
std::string rrtmgp_cloud_optics_sw
Definition: ERF_Radiation.H:290
Radiation::m_nlwgpts
int m_nlwgpts
Definition: ERF_Radiation.H:370
Radiation::rrtmgp_cloud_optics_lw
std::string rrtmgp_cloud_optics_lw
Definition: ERF_Radiation.H:291
Radiation::m_co2vmr
amrex::Real m_co2vmr
Definition: ERF_Radiation.H:305
Radiation::m_extra_clnsky_diag
bool m_extra_clnsky_diag
Definition: ERF_Radiation.H:338
Radiation::m_lat_cons
amrex::Real m_lat_cons
Definition: ERF_Radiation.H:280
Radiation::m_fixed_total_solar_irradiance
amrex::Real m_fixed_total_solar_irradiance
Definition: ERF_Radiation.H:360
Radiation::m_o2vmr
amrex::Real m_o2vmr
Definition: ERF_Radiation.H:310
Radiation::m_n2ovmr
amrex::Real m_n2ovmr
Definition: ERF_Radiation.H:307
Radiation::m_rad_t_sfc
amrex::Real m_rad_t_sfc
Definition: ERF_Radiation.H:261
Radiation::rrtmgp_file_path
std::string rrtmgp_file_path
Definition: ERF_Radiation.H:287
Radiation::m_nlwbands
int m_nlwbands
Definition: ERF_Radiation.H:368
Radiation::m_orbital_eccen
amrex::Real m_orbital_eccen
Definition: ERF_Radiation.H:353
Radiation::m_covmr
amrex::Real m_covmr
Definition: ERF_Radiation.H:308
Radiation::m_ncol_chunk
int m_ncol_chunk
Definition: ERF_Radiation.H:376
Radiation::rrtmgp_coeffs_file_lw
std::string rrtmgp_coeffs_file_lw
Definition: ERF_Radiation.H:293
Radiation::m_ch4vmr
amrex::Real m_ch4vmr
Definition: ERF_Radiation.H:309
Radiation::m_ice
bool m_ice
Definition: ERF_Radiation.H:244
Radiation::m_fixed_solar_zenith_angle
amrex::Real m_fixed_solar_zenith_angle
Definition: ERF_Radiation.H:364
Radiation::m_orbital_obliq
amrex::Real m_orbital_obliq
Definition: ERF_Radiation.H:354
Radiation::m_n2vmr
amrex::Real m_n2vmr
Definition: ERF_Radiation.H:311
Radiation::m_fixed_orbital_year
bool m_fixed_orbital_year
Definition: ERF_Radiation.H:352
Radiation::m_nswgpts
int m_nswgpts
Definition: ERF_Radiation.H:369
Radiation::m_extra_clnclrsky_diag
bool m_extra_clnclrsky_diag
Definition: ERF_Radiation.H:339
Radiation::m_rad_nvar
int m_rad_nvar
Definition: ERF_Radiation.H:379
Radiation::m_orbital_year
int m_orbital_year
Definition: ERF_Radiation.H:344
ncutils::NCFile::open
static NCFile open(const std::string &name, const int cmode=NC_NOWRITE)
Definition: ERF_NCInterface.cpp:707
SolverChoice::lsm_type
LandSurfaceType lsm_type
Definition: ERF_DataStruct.H:1392
SolverChoice::moisture_type
MoistureType moisture_type
Definition: ERF_DataStruct.H:1389
Here is the call graph for this function:

◆ ~Radiation()

Radiation::~Radiation ( )
inline
56  {
57  // Release k-distribution data and memory pool
58  if (rrtmgp::initialized) {
59  rrtmgp::rrtmgp_finalize();
60  }
61  // Note that Kokkos is now finalized in main.cpp
62  }
rrtmgp::rrtmgp_finalize
void rrtmgp_finalize()
Definition: ERF_RRTMGP_Interface.cpp:266
rrtmgp::initialized
bool initialized
Definition: ERF_RRTMGP_Interface.cpp:24
Here is the call graph for this function:

Member Function Documentation

◆ alloc_buffers()

void Radiation::alloc_buffers ( )
228 {
229  // 1d size (m_ngas)
230  const Real* mol_weight_gas_p = m_mol_weight_gas.data();
231  const std::string* gas_names_p = m_gas_names.data();
232  m_gas_mol_weights = real1d_k("m_gas_mol_weights", m_ngas);
233  realHost1d_k m_gas_mol_weights_h("m_gas_mol_weights_h", m_ngas);
234  gas_names_offset.clear(); gas_names_offset.resize(m_ngas);
235  std::string* gas_names_offset_p = gas_names_offset.data();
236  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Serial>(0, m_ngas),
237  [&] (int igas)
238  {
239  m_gas_mol_weights_h(igas) = mol_weight_gas_p[igas];
240  gas_names_offset_p[igas] = gas_names_p[igas];
241  });
242  Kokkos::deep_copy(m_gas_mol_weights, m_gas_mol_weights_h);
243 
244  // 1d size (1 or nlay)
245  m_o3_size = m_o3vmr.size();
246  AMREX_ALWAYS_ASSERT_WITH_MESSAGE(((m_o3_size==1) || (m_o3_size==m_nlay)),
247  "O3 VMR array must be length 1 or nlay");
248  Real* o3vmr_p = m_o3vmr.data();
249  o3_lay = real1d_k("o3_lay", m_o3_size);
250  realHost1d_k o3_lay_h("o3_lay_h", m_o3_size);
251  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Serial>(0, m_o3_size),
252  [&] (int io3)
253  {
254  o3_lay_h(io3) = o3vmr_p[io3];
255  });
256  Kokkos::deep_copy(o3_lay, o3_lay_h);
257 
258  // 1d size (ncol)
259  mu0 = real1d_k("mu0" , m_ncol);
260  sfc_alb_dir_vis = real1d_k("sfc_alb_dir_vis" , m_ncol);
261  sfc_alb_dir_nir = real1d_k("sfc_alb_dir_nir" , m_ncol);
262  sfc_alb_dif_vis = real1d_k("sfc_alb_dif_vis" , m_ncol);
263  sfc_alb_dif_nir = real1d_k("sfc_alb_dif_nir" , m_ncol);
264  sfc_flux_dir_vis = real1d_k("sfc_flux_dir_vis", m_ncol);
265  sfc_flux_dir_nir = real1d_k("sfc_flux_dir_nir", m_ncol);
266  sfc_flux_dif_vis = real1d_k("sfc_flux_dif_vis", m_ncol);
267  sfc_flux_dif_nir = real1d_k("sfc_flux_dif_nir", m_ncol);
268  lat = real1d_k("lat" , m_ncol);
269  lon = real1d_k("lon" , m_ncol);
270  sfc_emis = real1d_k("sfc_emis" , m_ncol);
271  t_sfc = real1d_k("t_sfc" , m_ncol);
272  lw_src = real1d_k("lw_src" , m_ncol);
273 
274  // 2d size (ncol, nlay)
275  r_lay = real2d_k("r_lay" , m_ncol, m_nlay);
276  p_lay = real2d_k("p_lay" , m_ncol, m_nlay);
277  t_lay = real2d_k("t_lay" , m_ncol, m_nlay);
278  z_del = real2d_k("z_del" , m_ncol, m_nlay);
279  qv_lay = real2d_k("qv" , m_ncol, m_nlay);
280  qc_lay = real2d_k("qc" , m_ncol, m_nlay);
281  qi_lay = real2d_k("qi" , m_ncol, m_nlay);
282  cldfrac_tot = real2d_k("cldfrac_tot" , m_ncol, m_nlay);
283  eff_radius_qc = real2d_k("eff_radius_qc", m_ncol, m_nlay);
284  eff_radius_qi = real2d_k("eff_radius_qi", m_ncol, m_nlay);
285  lwp = real2d_k("lwp" , m_ncol, m_nlay);
286  iwp = real2d_k("iwp" , m_ncol, m_nlay);
287  sw_heating = real2d_k("sw_heating" , m_ncol, m_nlay);
288  lw_heating = real2d_k("lw_heating" , m_ncol, m_nlay);
289  if (datalog_int > 0) {
290  sw_clrsky_heating = real2d_k("sw_clrsky_heating", m_ncol, m_nlay);
291  lw_clrsky_heating = real2d_k("lw_clrsky_heating", m_ncol, m_nlay);
292  }
293 
294  // 2d size (ncol, nlay+1)
295  d_tint = real2d_k("d_tint" , m_ncol, m_nlay+1);
296  p_lev = real2d_k("p_lev" , m_ncol, m_nlay+1);
297  t_lev = real2d_k("t_lev" , m_ncol, m_nlay+1);
298 
299  sw_flux_up = real2d_k("sw_flux_up" , m_ncol, m_nlay+1);
300  sw_flux_dn = real2d_k("sw_flux_dn" , m_ncol, m_nlay+1);
301  sw_flux_dn_dir = real2d_k("sw_flux_dn_dir" , m_ncol, m_nlay+1);
302 
303  lw_flux_up = real2d_k("lw_flux_up" , m_ncol, m_nlay+1);
304  lw_flux_dn = real2d_k("lw_flux_dn" , m_ncol, m_nlay+1);
305 
306  // Clear-sky flux arrays are always needed
307  if (datalog_int > 0) {
308  sw_clrsky_flux_up = real2d_k("sw_clrsky_flux_up" , m_ncol, m_nlay+1);
309  sw_clrsky_flux_dn = real2d_k("sw_clrsky_flux_dn" , m_ncol, m_nlay+1);
310  sw_clrsky_flux_dn_dir = real2d_k("sw_clrsky_flux_dn_dir", m_ncol, m_nlay+1);
311  lw_clrsky_flux_up = real2d_k("lw_clrsky_flux_up" , m_ncol, m_nlay+1);
312  lw_clrsky_flux_dn = real2d_k("lw_clrsky_flux_dn" , m_ncol, m_nlay+1);
313  } else {
314  sw_clrsky_flux_up = real2d_k("sw_clrsky_flux_up" , m_ncol_chunk, m_nlay+1);
315  sw_clrsky_flux_dn = real2d_k("sw_clrsky_flux_dn" , m_ncol_chunk, m_nlay+1);
316  sw_clrsky_flux_dn_dir = real2d_k("sw_clrsky_flux_dn_dir", m_ncol_chunk, m_nlay+1);
317  lw_clrsky_flux_up = real2d_k("lw_clrsky_flux_up" , m_ncol_chunk, m_nlay+1);
318  lw_clrsky_flux_dn = real2d_k("lw_clrsky_flux_dn" , m_ncol_chunk, m_nlay+1);
319  }
320 
321  // Clean-clear-sky diagnostic fluxes (only when enabled)
322  if (m_extra_clnclrsky_diag) {
323  sw_clnclrsky_flux_up = real2d_k("sw_clnclrsky_flux_up" , m_ncol, m_nlay+1);
324  sw_clnclrsky_flux_dn = real2d_k("sw_clnclrsky_flux_dn" , m_ncol, m_nlay+1);
325  sw_clnclrsky_flux_dn_dir = real2d_k("sw_clnclrsky_flux_dn_dir", m_ncol, m_nlay+1);
326  lw_clnclrsky_flux_up = real2d_k("lw_clnclrsky_flux_up" , m_ncol, m_nlay+1);
327  lw_clnclrsky_flux_dn = real2d_k("lw_clnclrsky_flux_dn" , m_ncol, m_nlay+1);
328  } else {
329  sw_clnclrsky_flux_up = real2d_k("sw_clnclrsky_flux_up" , 1, 1);
330  sw_clnclrsky_flux_dn = real2d_k("sw_clnclrsky_flux_dn" , 1, 1);
331  sw_clnclrsky_flux_dn_dir = real2d_k("sw_clnclrsky_flux_dn_dir", 1, 1);
332  lw_clnclrsky_flux_up = real2d_k("lw_clnclrsky_flux_up" , 1, 1);
333  lw_clnclrsky_flux_dn = real2d_k("lw_clnclrsky_flux_dn" , 1, 1);
334  }
335 
336  // Clean-sky diagnostic fluxes (only when enabled)
337  if (m_extra_clnsky_diag) {
338  sw_clnsky_flux_up = real2d_k("sw_clnsky_flux_up" , m_ncol, m_nlay+1);
339  sw_clnsky_flux_dn = real2d_k("sw_clnsky_flux_dn" , m_ncol, m_nlay+1);
340  sw_clnsky_flux_dn_dir = real2d_k("sw_clnsky_flux_dn_dir" , m_ncol, m_nlay+1);
341  lw_clnsky_flux_up = real2d_k("lw_clnsky_flux_up" , m_ncol, m_nlay+1);
342  lw_clnsky_flux_dn = real2d_k("lw_clnsky_flux_dn" , m_ncol, m_nlay+1);
343  } else {
344  sw_clnsky_flux_up = real2d_k("sw_clnsky_flux_up" , 1, 1);
345  sw_clnsky_flux_dn = real2d_k("sw_clnsky_flux_dn" , 1, 1);
346  sw_clnsky_flux_dn_dir = real2d_k("sw_clnsky_flux_dn_dir" , 1, 1);
347  lw_clnsky_flux_up = real2d_k("lw_clnsky_flux_up" , 1, 1);
348  lw_clnsky_flux_dn = real2d_k("lw_clnsky_flux_dn" , 1, 1);
349  }
350 
351  // 3d size (ncol_chunk, nlay+1, nswbands)
352  sw_bnd_flux_up = real3d_k("sw_bnd_flux_up" , m_ncol_chunk, m_nlay+1, m_nswbands);
353  sw_bnd_flux_dn = real3d_k("sw_bnd_flux_dn" , m_ncol_chunk, m_nlay+1, m_nswbands);
354  sw_bnd_flux_dir = real3d_k("sw_bnd_flux_dir", m_ncol_chunk, m_nlay+1, m_nswbands);
355  sw_bnd_flux_dif = real3d_k("sw_bnd_flux_dif", m_ncol_chunk, m_nlay+1, m_nswbands);
356 
357  // 3d size (ncol_chunk, nlay+1, nlwbands)
358  lw_bnd_flux_up = real3d_k("lw_bnd_flux_up" , m_ncol_chunk, m_nlay+1, m_nlwbands);
359  lw_bnd_flux_dn = real3d_k("lw_bnd_flux_dn" , m_ncol_chunk, m_nlay+1, m_nlwbands);
360 
361  // 2d size (ncol, nswbands)
362  sfc_alb_dir = real2d_k("sfc_alb_dir", m_ncol, m_nswbands);
363  sfc_alb_dif = real2d_k("sfc_alb_dif", m_ncol, m_nswbands);
364 
365  // Aerosol optical properties — allocated only when aerosol coupling is on.
366  // The flag gates allocation so today (coupling not implemented, abort fires
367  // in the constructor) these stay as empty Views and cost nothing. When a
368  // future aerosol scheme populates them, hook up the plumbing into
369  // rrtmgp_main as well.
370  if (m_do_aerosol_rad) {
371  aero_tau_sw = real3d_k("aero_tau_sw", m_ncol, m_nlay, m_nswbands);
372  aero_ssa_sw = real3d_k("aero_ssa_sw", m_ncol, m_nlay, m_nswbands);
373  aero_g_sw = real3d_k("aero_g_sw", m_ncol, m_nlay, m_nswbands);
374  aero_tau_lw = real3d_k("aero_tau_lw", m_ncol, m_nlay, m_nlwbands);
375  }
376 }
real1d_k
Kokkos::View< RealT *, KokkosDefaultDevice > real1d_k
Definition: ERF_Kokkos.H:18
real3d_k
Kokkos::View< RealT ***, layout_t, KokkosDefaultDevice > real3d_k
Definition: ERF_Kokkos.H:20
real2d_k
Kokkos::View< RealT **, layout_t, KokkosDefaultDevice > real2d_k
Definition: ERF_Kokkos.H:19
realHost1d_k
Kokkos::View< RealT *, KokkosHostDevice > realHost1d_k
Definition: ERF_Kokkos.H:16
Real
amrex::Real Real
Definition: ERF_ShocInterface.H:19
IRadiation::datalog_int
int datalog_int
Definition: ERF_RadiationInterface.H:88
Radiation::sw_bnd_flux_dn
real3d_k sw_bnd_flux_dn
Definition: ERF_Radiation.H:448
Radiation::lw_flux_up
real2d_k lw_flux_up
Definition: ERF_Radiation.H:428
Radiation::aero_tau_sw
real3d_k aero_tau_sw
Definition: ERF_Radiation.H:467
Radiation::m_o3_size
int m_o3_size
Definition: ERF_Radiation.H:315
Radiation::sw_bnd_flux_dir
real3d_k sw_bnd_flux_dir
Definition: ERF_Radiation.H:449
Radiation::sw_clnsky_flux_dn
real2d_k sw_clnsky_flux_dn
Definition: ERF_Radiation.H:437
Radiation::d_tint
real2d_k d_tint
Definition: ERF_Radiation.H:422
Radiation::lw_clnclrsky_flux_dn
real2d_k lw_clnclrsky_flux_dn
Definition: ERF_Radiation.H:440
Radiation::lwp
real2d_k lwp
Definition: ERF_Radiation.H:414
Radiation::lw_src
real1d_k lw_src
Definition: ERF_Radiation.H:401
Radiation::eff_radius_qi
real2d_k eff_radius_qi
Definition: ERF_Radiation.H:413
Radiation::m_gas_mol_weights
real1d_k m_gas_mol_weights
Definition: ERF_Radiation.H:316
Radiation::sw_heating
real2d_k sw_heating
Definition: ERF_Radiation.H:416
Radiation::lw_bnd_flux_dn
real3d_k lw_bnd_flux_dn
Definition: ERF_Radiation.H:454
Radiation::sw_bnd_flux_up
real3d_k sw_bnd_flux_up
Definition: ERF_Radiation.H:447
Radiation::qv_lay
real2d_k qv_lay
Definition: ERF_Radiation.H:408
Radiation::sw_clnclrsky_flux_dn_dir
real2d_k sw_clnclrsky_flux_dn_dir
Definition: ERF_Radiation.H:432
Radiation::sfc_flux_dif_vis
real1d_k sfc_flux_dif_vis
Definition: ERF_Radiation.H:395
Radiation::lw_clnclrsky_flux_up
real2d_k lw_clnclrsky_flux_up
Definition: ERF_Radiation.H:439
Radiation::lat
real1d_k lat
Definition: ERF_Radiation.H:397
Radiation::qi_lay
real2d_k qi_lay
Definition: ERF_Radiation.H:410
Radiation::sw_clrsky_flux_up
real2d_k sw_clrsky_flux_up
Definition: ERF_Radiation.H:433
Radiation::t_lev
real2d_k t_lev
Definition: ERF_Radiation.H:424
Radiation::o3_lay
real1d_k o3_lay
Definition: ERF_Radiation.H:385
Radiation::sfc_alb_dif_vis
real1d_k sfc_alb_dif_vis
Definition: ERF_Radiation.H:391
Radiation::mu0
real1d_k mu0
Definition: ERF_Radiation.H:388
Radiation::cldfrac_tot
real2d_k cldfrac_tot
Definition: ERF_Radiation.H:411
Radiation::sfc_flux_dir_nir
real1d_k sfc_flux_dir_nir
Definition: ERF_Radiation.H:394
Radiation::sw_clnclrsky_flux_up
real2d_k sw_clnclrsky_flux_up
Definition: ERF_Radiation.H:430
Radiation::aero_g_sw
real3d_k aero_g_sw
Definition: ERF_Radiation.H:469
Radiation::sw_flux_up
real2d_k sw_flux_up
Definition: ERF_Radiation.H:425
Radiation::sw_bnd_flux_dif
real3d_k sw_bnd_flux_dif
Definition: ERF_Radiation.H:450
Radiation::sfc_alb_dif
real2d_k sfc_alb_dif
Definition: ERF_Radiation.H:458
Radiation::sfc_alb_dif_nir
real1d_k sfc_alb_dif_nir
Definition: ERF_Radiation.H:392
Radiation::lw_clnsky_flux_dn
real2d_k lw_clnsky_flux_dn
Definition: ERF_Radiation.H:444
Radiation::p_lay
real2d_k p_lay
Definition: ERF_Radiation.H:405
Radiation::r_lay
real2d_k r_lay
Definition: ERF_Radiation.H:404
Radiation::m_ncol
int m_ncol
Definition: ERF_Radiation.H:325
Radiation::sw_flux_dn_dir
real2d_k sw_flux_dn_dir
Definition: ERF_Radiation.H:427
Radiation::m_mol_weight_gas
const std::vector< amrex::Real > m_mol_weight_gas
Definition: ERF_Radiation.H:301
Radiation::gas_names_offset
std::vector< std::string > gas_names_offset
Definition: ERF_Radiation.H:317
Radiation::sw_clrsky_flux_dn
real2d_k sw_clrsky_flux_dn
Definition: ERF_Radiation.H:434
Radiation::aero_ssa_sw
real3d_k aero_ssa_sw
Definition: ERF_Radiation.H:468
Radiation::sw_clnsky_flux_dn_dir
real2d_k sw_clnsky_flux_dn_dir
Definition: ERF_Radiation.H:438
Radiation::qc_lay
real2d_k qc_lay
Definition: ERF_Radiation.H:409
Radiation::lw_clrsky_flux_up
real2d_k lw_clrsky_flux_up
Definition: ERF_Radiation.H:441
Radiation::sw_flux_dn
real2d_k sw_flux_dn
Definition: ERF_Radiation.H:426
Radiation::lw_clrsky_flux_dn
real2d_k lw_clrsky_flux_dn
Definition: ERF_Radiation.H:442
Radiation::z_del
real2d_k z_del
Definition: ERF_Radiation.H:407
Radiation::aero_tau_lw
real3d_k aero_tau_lw
Definition: ERF_Radiation.H:470
Radiation::lw_flux_dn
real2d_k lw_flux_dn
Definition: ERF_Radiation.H:429
Radiation::sw_clrsky_flux_dn_dir
real2d_k sw_clrsky_flux_dn_dir
Definition: ERF_Radiation.H:435
Radiation::sfc_flux_dif_nir
real1d_k sfc_flux_dif_nir
Definition: ERF_Radiation.H:396
Radiation::m_ngas
int m_ngas
Definition: ERF_Radiation.H:298
Radiation::lw_heating
real2d_k lw_heating
Definition: ERF_Radiation.H:417
Radiation::sfc_alb_dir_nir
real1d_k sfc_alb_dir_nir
Definition: ERF_Radiation.H:390
Radiation::lw_clnsky_flux_up
real2d_k lw_clnsky_flux_up
Definition: ERF_Radiation.H:443
Radiation::sfc_alb_dir
real2d_k sfc_alb_dir
Definition: ERF_Radiation.H:457
Radiation::lon
real1d_k lon
Definition: ERF_Radiation.H:398
Radiation::sfc_emis
real1d_k sfc_emis
Definition: ERF_Radiation.H:399
Radiation::sw_clnsky_flux_up
real2d_k sw_clnsky_flux_up
Definition: ERF_Radiation.H:436
Radiation::m_nlay
int m_nlay
Definition: ERF_Radiation.H:326
Radiation::lw_bnd_flux_up
real3d_k lw_bnd_flux_up
Definition: ERF_Radiation.H:453
Radiation::sfc_alb_dir_vis
real1d_k sfc_alb_dir_vis
Definition: ERF_Radiation.H:389
Radiation::m_gas_names
const std::vector< std::string > m_gas_names
Definition: ERF_Radiation.H:299
Radiation::sw_clrsky_heating
real2d_k sw_clrsky_heating
Definition: ERF_Radiation.H:418
Radiation::t_lay
real2d_k t_lay
Definition: ERF_Radiation.H:406
Radiation::sfc_flux_dir_vis
real1d_k sfc_flux_dir_vis
Definition: ERF_Radiation.H:393
Radiation::iwp
real2d_k iwp
Definition: ERF_Radiation.H:415
Radiation::p_lev
real2d_k p_lev
Definition: ERF_Radiation.H:423
Radiation::lw_clrsky_heating
real2d_k lw_clrsky_heating
Definition: ERF_Radiation.H:419
Radiation::eff_radius_qc
real2d_k eff_radius_qc
Definition: ERF_Radiation.H:412
Radiation::t_sfc
real1d_k t_sfc
Definition: ERF_Radiation.H:400
Radiation::sw_clnclrsky_flux_dn
real2d_k sw_clnclrsky_flux_dn
Definition: ERF_Radiation.H:431

◆ dealloc_buffers()

void Radiation::dealloc_buffers ( )
380 {
381  // 1d size (m_ngas)
382  m_gas_mol_weights = real1d_k();
383 
384  // 1d size (1 or nlay)
385  o3_lay = real1d_k();
386 
387  // 1d size (ncol)
388  mu0 = real1d_k();
389  sfc_alb_dir_vis = real1d_k();
390  sfc_alb_dir_nir = real1d_k();
391  sfc_alb_dif_vis = real1d_k();
392  sfc_alb_dif_nir = real1d_k();
393  sfc_flux_dir_vis = real1d_k();
394  sfc_flux_dir_nir = real1d_k();
395  sfc_flux_dif_vis = real1d_k();
396  sfc_flux_dif_nir = real1d_k();
397  lat = real1d_k();
398  lon = real1d_k();
399  sfc_emis = real1d_k();
400  t_sfc = real1d_k();
401  lw_src = real1d_k();
402 
403  // 2d size (ncol, nlay)
404  r_lay = real2d_k();
405  p_lay = real2d_k();
406  t_lay = real2d_k();
407  z_del = real2d_k();
408  qv_lay = real2d_k();
409  qc_lay = real2d_k();
410  qi_lay = real2d_k();
411  cldfrac_tot = real2d_k();
412  eff_radius_qc = real2d_k();
413  eff_radius_qi = real2d_k();
414  lwp = real2d_k();
415  iwp = real2d_k();
416  sw_heating = real2d_k();
417  lw_heating = real2d_k();
418  sw_clrsky_heating = real2d_k();
419  lw_clrsky_heating = real2d_k();
420 
421  // 2d size (ncol, nlay+1)
422  d_tint = real2d_k();
423  p_lev = real2d_k();
424  t_lev = real2d_k();
425  sw_flux_up = real2d_k();
426  sw_flux_dn = real2d_k();
427  sw_flux_dn_dir = real2d_k();
428  lw_flux_up = real2d_k();
429  lw_flux_dn = real2d_k();
430  sw_clnclrsky_flux_up = real2d_k();
431  sw_clnclrsky_flux_dn = real2d_k();
432  sw_clnclrsky_flux_dn_dir = real2d_k();
433  sw_clrsky_flux_up = real2d_k();
434  sw_clrsky_flux_dn = real2d_k();
435  sw_clrsky_flux_dn_dir = real2d_k();
436  sw_clnsky_flux_up = real2d_k();
437  sw_clnsky_flux_dn = real2d_k();
438  sw_clnsky_flux_dn_dir = real2d_k();
439  lw_clnclrsky_flux_up = real2d_k();
440  lw_clnclrsky_flux_dn = real2d_k();
441  lw_clrsky_flux_up = real2d_k();
442  lw_clrsky_flux_dn = real2d_k();
443  lw_clnsky_flux_up = real2d_k();
444  lw_clnsky_flux_dn = real2d_k();
445 
446  // 3d size (ncol, nlay+1, nswbands)
447  sw_bnd_flux_up = real3d_k();
448  sw_bnd_flux_dn = real3d_k();
449  sw_bnd_flux_dir = real3d_k();
450  sw_bnd_flux_dif = real3d_k();
451 
452  // 3d size (ncol, nlay+1, nlwbands)
453  lw_bnd_flux_up = real3d_k();
454  lw_bnd_flux_dn = real3d_k();
455 
456  // 2d size (ncol, nswbands)
457  sfc_alb_dir = real2d_k();
458  sfc_alb_dif = real2d_k();
459 
460  // Aerosol scaffolding (no-op unless m_do_aerosol_rad enabled allocation above)
461  aero_tau_sw = real3d_k();
462  aero_ssa_sw = real3d_k();
463  aero_g_sw = real3d_k();
464  aero_tau_lw = real3d_k();
465 }

◆ finalize_impl()

void Radiation::finalize_impl ( amrex::Vector< amrex::MultiFab * > &  lsm_output_ptrs)
1366 {
1367  // Reset gas concentrations (k-dist data persists across steps)
1368  m_gas_concs.reset();
1369 
1370  // Fill the AMReX MFs from Kokkos Views
1371  kokkos_buffers_to_mf(lsm_output_ptrs);
1372 
1373  // Write fluxes if requested
1374  if (m_rad_write_fluxes) { write_rrtmgp_fluxes(); }
1375 
1376  // Fill output data for datalog before deallocating
1377  if (datalog_int > 0) {
1378  rrtmgp::compute_heating_rate(sw_clrsky_flux_up, sw_clrsky_flux_dn, r_lay, z_del, sw_clrsky_heating);
1379  rrtmgp::compute_heating_rate(lw_clrsky_flux_up, lw_clrsky_flux_dn, r_lay, z_del, lw_clrsky_heating);
1380  Kokkos::fence();
1381  populateDatalogMF();
1382  }
1383 
1384  // Deallocate the buffer arrays
1385  dealloc_buffers();
1386 }
Radiation::dealloc_buffers
void dealloc_buffers()
Definition: ERF_Radiation.cpp:379
Radiation::populateDatalogMF
void populateDatalogMF()
Definition: ERF_Radiation.cpp:800
Radiation::kokkos_buffers_to_mf
void kokkos_buffers_to_mf(amrex::Vector< amrex::MultiFab * > &lsm_output_ptrs)
Definition: ERF_Radiation.cpp:681
Radiation::m_gas_concs
GasConcsK< amrex::Real, layout_t, KokkosDefaultDevice > m_gas_concs
Definition: ERF_Radiation.H:319
Radiation::write_rrtmgp_fluxes
void write_rrtmgp_fluxes()
Definition: ERF_Radiation.cpp:760
rrtmgp::compute_heating_rate
void compute_heating_rate(View1 const &flux_up, View2 const &flux_dn, View3 const &rho, View4 const &dz, View5 &heating_rate)
Definition: ERF_RRTMGP_Utils.H:81

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.

190  {
191  return m_lsm_input_names;
192  }
Radiation::m_lsm_input_names
amrex::Vector< std::string > m_lsm_input_names
Definition: ERF_Radiation.H:250

◆ get_lsm_output_varnames()

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

Reimplemented from IRadiation.

198  {
199  return m_lsm_output_names;
200  }
Radiation::m_lsm_output_names
amrex::Vector< std::string > m_lsm_output_names
Definition: ERF_Radiation.H:255

◆ Init()

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

Implements IRadiation.

69  {
70  // Ensure the boxes span klo -> khi
71  int klo = geom.Domain().smallEnd(2);
72  int khi = geom.Domain().bigEnd(2);
73 
74  // Reset vector of offsets for columnar data
75  m_nlay = geom.Domain().length(2);
76 
77  m_ncol = 0;
78  m_col_offsets.clear();
79  m_col_offsets.resize(int(ba.size()));
80  for (amrex::MFIter mfi(*cons_in); mfi.isValid(); ++mfi) {
81  const amrex::Box& vbx = mfi.validbox();
82  AMREX_ALWAYS_ASSERT_WITH_MESSAGE((klo == vbx.smallEnd(2)) &&
83  (khi == vbx.bigEnd(2)),
84  "Vertical decomposition with radiation is not allowed.");
85  int nx = vbx.length(0);
86  int ny = vbx.length(1);
87  m_col_offsets[mfi.index()] = m_ncol;
88  m_ncol += nx * ny;
89  }
90 
91  m_ncol_chunk = amrex::min(m_ncol, m_ncol_chunk);
92  };
khi
const int khi
Definition: ERF_InitCustomPert_Bubble.H:21
Radiation::m_col_offsets
amrex::Vector< int > m_col_offsets
Definition: ERF_Radiation.H:329

◆ initialize_impl()

void Radiation::initialize_impl ( )
1042 {
1043  // Initialize gas concentrations for this step
1044  m_gas_concs.init(gas_names_offset, m_ncol, m_nlay);
1045 
1046  // Load k-distribution and cloud optics data only once.
1047  // These are static lookup tables that never change.
1048  // Size the memory pool for m_ncol_chunk (not min with current m_ncol) so that
1049  // the pool remains valid even if m_ncol grows after regridding/load balancing.
1050  if (!rrtmgp::initialized) {
1051  gas_concs_t gas_concs_pool;
1052  gas_concs_pool.init(gas_names_offset, m_ncol_chunk, m_nlay);
1053  rrtmgp::rrtmgp_initialize(gas_concs_pool,
1054  rrtmgp_coeffs_file_sw , rrtmgp_coeffs_file_lw ,
1055  rrtmgp_cloud_optics_file_sw, rrtmgp_cloud_optics_file_lw,
1056  m_rad_nvar);
1057  gas_concs_pool.reset();
1058  }
1059 }
gas_concs_t
GasConcsK< RealT, layout_t, KokkosDefaultDevice > gas_concs_t
Definition: ERF_RRTMGP_Interface.H:32
rrtmgp::rrtmgp_initialize
void rrtmgp_initialize(gas_concs_t &gas_concs_k, const std::string &coefficients_file_sw, const std::string &coefficients_file_lw, const std::string &cloud_optics_file_sw, const std::string &cloud_optics_file_lw, const int &nvar)
Definition: ERF_RRTMGP_Interface.cpp:229

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)
682 {
683  // Heating rate, fluxes, zenith, lsm ptrs
684 
685  Table2D<Real,Order::C> p_lay_tab(p_lay.data(), {0,0}, {static_cast<int>(p_lay.extent(0)),static_cast<int>(p_lay.extent(1))});
686  Table2D<Real,Order::C> sw_heating_tab(sw_heating.data(), {0,0}, {static_cast<int>(sw_heating.extent(0)),static_cast<int>(sw_heating.extent(1))});
687  Table2D<Real,Order::C> lw_heating_tab(lw_heating.data(), {0,0}, {static_cast<int>(lw_heating.extent(0)),static_cast<int>(lw_heating.extent(1))});
688  Table2D<Real,Order::C> sw_flux_up_tab(sw_flux_up.data(), {0,0}, {static_cast<int>(sw_flux_up.extent(0)),static_cast<int>(sw_flux_up.extent(1))});
689  Table2D<Real,Order::C> sw_flux_dn_tab(sw_flux_dn.data(), {0,0}, {static_cast<int>(sw_flux_dn.extent(0)),static_cast<int>(sw_flux_dn.extent(1))});
690  Table2D<Real,Order::C> lw_flux_up_tab(lw_flux_up.data(), {0,0}, {static_cast<int>(lw_flux_up.extent(0)),static_cast<int>(lw_flux_up.extent(1))});
691  Table2D<Real,Order::C> lw_flux_dn_tab(lw_flux_dn.data(), {0,0}, {static_cast<int>(lw_flux_dn.extent(0)),static_cast<int>(lw_flux_dn.extent(1))});
692 
693  TableData<Real,1> sfc_flux_sw_dn; sfc_flux_sw_dn.resize({0}, {static_cast<int>(sw_flux_dn.extent(0))});
694  TableData<Real,1> sfc_flux_lw_dn; sfc_flux_lw_dn.resize({0}, {static_cast<int>(lw_flux_dn.extent(0))});
695  Table1D<Real> sfc_flux_sw_dn_tab = sfc_flux_sw_dn.table();
696  Table1D<Real> sfc_flux_lw_dn_tab = sfc_flux_lw_dn.table();
697  Table1D<Real> sfc_flux_sw_dir_vis_tab(sfc_flux_dir_vis.data(), {0}, {static_cast<int>(sfc_flux_dir_vis.extent(0))});
698  Table1D<Real> sfc_flux_sw_dir_nir_tab(sfc_flux_dir_nir.data(), {0}, {static_cast<int>(sfc_flux_dir_nir.extent(0))});
699  Table1D<Real> sfc_flux_sw_dif_vis_tab(sfc_flux_dif_vis.data(), {0}, {static_cast<int>(sfc_flux_dif_vis.extent(0))});
700  Table1D<Real> sfc_flux_sw_dif_nir_tab(sfc_flux_dif_nir.data(), {0}, {static_cast<int>(sfc_flux_dif_nir.extent(0))});
701  Table1D<Real> mu0_tab(mu0.data(), {0}, {static_cast<int>(mu0.extent(0))});
702  Vector<Table1D<Real>> rrtmgp_out_vars = {mu0_tab , sfc_flux_sw_dn_tab ,
703  sfc_flux_sw_dir_vis_tab, sfc_flux_sw_dir_nir_tab,
704  sfc_flux_sw_dif_vis_tab, sfc_flux_sw_dif_nir_tab,
705  sfc_flux_lw_dn_tab };
706 
707  for (MFIter mfi(*m_cons_in); mfi.isValid(); ++mfi) {
708  const auto& vbx = mfi.validbox();
709  const auto& sbx = makeSlab(vbx,2,vbx.smallEnd(2));
710  const int nx = vbx.length(0);
711  const int imin = vbx.smallEnd(0);
712  const int jmin = vbx.smallEnd(1);
713  const int offset = m_col_offsets[mfi.index()];
714  const Array4<Real>& q_arr = m_qheating_rates->array(mfi);
715  const Array4<Real>& f_arr = m_rad_fluxes->array(mfi);
716  ParallelFor(vbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
717  {
718  // map [i,j,k] 0-based to [icol, ilay] 0-based
719  const int icol = (j-jmin)*nx + (i-imin) + offset;
720  const int ilay = k;
721 
722  // Temperature heating rate for SW and LW
723  q_arr(i,j,k,0) = sw_heating_tab(icol,ilay);
724  q_arr(i,j,k,1) = lw_heating_tab(icol,ilay);
725 
726  // Convert the dT/dz to dTheta/dz
727  Real iexner = one/getExnergivenP(Real(p_lay_tab(icol,ilay)), R_d/Cp_d);
728  q_arr(i,j,k,0) *= iexner;
729  q_arr(i,j,k,1) *= iexner;
730 
731  // Populate the fluxes
732  f_arr(i,j,k,0) = sw_flux_up_tab(icol,ilay);
733  f_arr(i,j,k,1) = sw_flux_dn_tab(icol,ilay);
734  f_arr(i,j,k,2) = lw_flux_up_tab(icol,ilay);
735  f_arr(i,j,k,3) = lw_flux_dn_tab(icol,ilay);
736 
737  if (k==0) {
738  sfc_flux_sw_dn_tab(icol) = sw_flux_dn_tab(icol,ilay);
739  sfc_flux_lw_dn_tab(icol) = lw_flux_dn_tab(icol,ilay);
740  }
741  });
742  for (int ivar(0); ivar<lsm_output_ptrs.size(); ivar++) {
743  if (lsm_output_ptrs[ivar]) {
744  auto rrtmgp_for_fill = rrtmgp_out_vars[ivar];
745  const Array4<Real>& lsm_out_arr = lsm_output_ptrs[ivar]->array(mfi);
746  ParallelFor(sbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
747  {
748  // map [i,j,k] 0-based to [icol, ilay] 0-based
749  const int icol = (j-jmin)*nx + (i-imin) + offset;
750 
751  // export the desired variable at surface
752  lsm_out_arr(i,j,k) = rrtmgp_for_fill(icol);
753  });
754  } // valid ptr
755  } // ivar
756  }// mfi
757 }
Cp_d
constexpr amrex::Real Cp_d
Definition: ERF_Constants.H:44
one
constexpr amrex::Real one
Definition: ERF_Constants.H:9
R_d
constexpr amrex::Real R_d
Definition: ERF_Constants.H:42
getExnergivenP
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real getExnergivenP(const amrex::Real P, const amrex::Real rdOcp)
Definition: ERF_EOS.H:141
ParallelFor
ParallelFor(grown_box, [=] AMREX_GPU_DEVICE(int i, int j, int k) { qrcuten_arr(i, j, k)=Real(0);qscuten_arr(i, j, k)=Real(0);qicuten_arr(i, j, k)=Real(0);})
offset
AMREX_FORCE_INLINE IntVect offset(const int face_dir, const int normal)
Definition: ERF_ReadBndryPlanes.cpp:28
Radiation::m_cons_in
amrex::MultiFab * m_cons_in
Definition: ERF_Radiation.H:264
Radiation::m_rad_fluxes
amrex::MultiFab * m_rad_fluxes
Definition: ERF_Radiation.H:270
Radiation::m_qheating_rates
amrex::MultiFab * m_qheating_rates
Definition: ERF_Radiation.H:267
Here is the call graph for this function:

◆ mf_to_kokkos_buffers()

void Radiation::mf_to_kokkos_buffers ( amrex::iMultiFab *  lmask,
amrex::MultiFab *  t_surf,
amrex::Vector< amrex::MultiFab * > &  lsm_input_ptrs 
)
472 {
473  Table2D<Real,Order::C> r_lay_tab(r_lay.data(), {0,0}, {static_cast<int>(r_lay.extent(0)),static_cast<int>(r_lay.extent(1))});
474  Table2D<Real,Order::C> p_lay_tab(p_lay.data(), {0,0}, {static_cast<int>(p_lay.extent(0)),static_cast<int>(p_lay.extent(1))});
475  Table2D<Real,Order::C> t_lay_tab(t_lay.data(), {0,0}, {static_cast<int>(t_lay.extent(0)),static_cast<int>(t_lay.extent(1))});
476  Table2D<Real,Order::C> z_del_tab(z_del.data(), {0,0}, {static_cast<int>(z_del.extent(0)),static_cast<int>(z_del.extent(1))});
477  Table2D<Real,Order::C> qv_lay_tab(qv_lay.data(), {0,0}, {static_cast<int>(qv_lay.extent(0)),static_cast<int>(qv_lay.extent(1))});
478  Table2D<Real,Order::C> qc_lay_tab(qc_lay.data(), {0,0}, {static_cast<int>(qc_lay.extent(0)),static_cast<int>(qc_lay.extent(1))});
479  Table2D<Real,Order::C> qi_lay_tab(qi_lay.data(), {0,0}, {static_cast<int>(qi_lay.extent(0)),static_cast<int>(qi_lay.extent(1))});
480  Table2D<Real,Order::C> cldfrac_tot_tab(cldfrac_tot.data(), {0,0}, {static_cast<int>(cldfrac_tot.extent(0)),static_cast<int>(cldfrac_tot.extent(1))});
481 
482  Table2D<Real,Order::C> lwp_tab(lwp.data(), {0,0}, {static_cast<int>(lwp.extent(0)),static_cast<int>(lwp.extent(1))});
483  Table2D<Real,Order::C> iwp_tab(iwp.data(), {0,0}, {static_cast<int>(iwp.extent(0)),static_cast<int>(iwp.extent(1))});
484  Table2D<Real,Order::C> eff_radius_qc_tab(eff_radius_qc.data(), {0,0}, {static_cast<int>(eff_radius_qc.extent(0)),static_cast<int>(eff_radius_qc.extent(1))});
485  Table2D<Real,Order::C> eff_radius_qi_tab(eff_radius_qi.data(), {0,0}, {static_cast<int>(eff_radius_qi.extent(0)),static_cast<int>(eff_radius_qi.extent(1))});
486 
487  Table2D<Real,Order::C> p_lev_tab(p_lev.data(), {0,0}, {static_cast<int>(p_lev.extent(0)),static_cast<int>(p_lev.extent(1))});
488  Table2D<Real,Order::C> t_lev_tab(t_lev.data(), {0,0}, {static_cast<int>(t_lev.extent(0)),static_cast<int>(t_lev.extent(1))});
489 
490  Table1D<Real> lat_tab(lat.data(), {0}, {static_cast<int>(lat.extent(0))});
491  Table1D<Real> lon_tab(lon.data(), {0}, {static_cast<int>(lon.extent(0))});
492  Table1D<Real> t_sfc_tab(t_sfc.data(), {0}, {static_cast<int>(t_sfc.extent(0))});
493 
494  bool moist = m_moist;
495  bool ice = m_ice;
496  const bool has_lsm = m_lsm;
497  const bool has_lat = m_lat;
498  const bool has_lon = m_lon;
499  const bool has_surflayer = (t_surf);
500  int ncol = m_ncol;
501  int nlay = m_nlay;
502  Real dz = m_geom.CellSize(2);
503  Real cons_lat = m_lat_cons;
504  Real cons_lon = m_lon_cons;
505  Real rad_t_sfc = m_rad_t_sfc;
506 
507  for (MFIter mfi(*m_cons_in); mfi.isValid(); ++mfi) {
508  const auto& vbx = mfi.validbox();
509  const int nx = vbx.length(0);
510  const int imin = vbx.smallEnd(0);
511  const int jmin = vbx.smallEnd(1);
512  const int offset = m_col_offsets[mfi.index()];
513  const Array4<const Real>& cons_arr = m_cons_in->const_array(mfi);
514  const Array4<const Real>& z_arr = (m_z_phys) ? m_z_phys->const_array(mfi) :
515  Array4<const Real>{};
516  const Array4<const Real>& lat_arr = (m_lat) ? m_lat->const_array(mfi) :
517  Array4<const Real>{};
518  const Array4<const Real>& lon_arr = (m_lon) ? m_lon->const_array(mfi) :
519  Array4<const Real>{};
520  ParallelFor(vbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
521  {
522  // map [i,j,k] 0-based to [icol, ilay] 0-based
523  const int icol = (j-jmin)*nx + (i-imin) + offset;
524  const int ilay = k;
525 
526  // EOS input (at CC)
527  Real r = cons_arr(i,j,k,Rho_comp);
528  Real rt = cons_arr(i,j,k,RhoTheta_comp);
529  Real qv = (moist) ? std::max(cons_arr(i,j,k,RhoQ1_comp)/r,Real(0.)) : Real(0.);
530  Real qc = (moist) ? std::max(cons_arr(i,j,k,RhoQ2_comp)/r,Real(0.)) : Real(0.);
531  Real qi = (ice) ? std::max(cons_arr(i,j,k,RhoQ3_comp)/r,Real(0.)) : Real(0.);
532 
533  // EOS avg to z-face
534  Real r_lo = cons_arr(i,j,k-1,Rho_comp);
535  Real rt_lo = cons_arr(i,j,k-1,RhoTheta_comp);
536  Real qv_lo = (moist) ? cons_arr(i,j,k-1,RhoQ1_comp)/r_lo : Real(0.);
537  Real dz_k = (z_arr) ? Real(0.125) * ( (z_arr(i ,j ,k+1) - z_arr(i ,j ,k))
538  + (z_arr(i+1,j ,k+1) - z_arr(i+1,j ,k))
539  + (z_arr(i ,j+1,k+1) - z_arr(i ,j+1,k))
540  + (z_arr(i+1,j+1,k+1) - z_arr(i+1,j+1,k)) ) : Real(0.5)*dz; // Dist from w-face to CC at k
541  Real dz_km1 = (z_arr) ? Real(0.125) * ( (z_arr(i ,j ,k ) - z_arr(i ,j ,k-1))
542  + (z_arr(i+1,j ,k ) - z_arr(i+1,j ,k-1))
543  + (z_arr(i ,j+1,k ) - z_arr(i ,j+1,k-1))
544  + (z_arr(i+1,j+1,k ) - z_arr(i+1,j+1,k-1)) ) : Real(0.5)*dz; // Dist from w-face to CC at k-1
545  Real r_avg = (dz_k*r + dz_km1*r_lo ) / (dz_k + dz_km1);
546  Real rt_avg = (dz_k*rt + dz_km1*rt_lo) / (dz_k + dz_km1);
547  Real qv_avg = (dz_k*qv + dz_km1*qv_lo) / (dz_k + dz_km1);
548 
549  // Views at CC
550  r_lay_tab(icol,ilay) = r;
551 
552  p_lay_tab(icol,ilay) = getPgivenRTh(rt, qv);
553  t_lay_tab(icol,ilay) = getTgivenRandRTh(r, rt, qv);
554  z_del_tab(icol,ilay) = (z_arr) ? Real(0.25) * ( (z_arr(i ,j ,k+1) - z_arr(i ,j ,k))
555  + (z_arr(i+1,j ,k+1) - z_arr(i+1,j ,k))
556  + (z_arr(i ,j+1,k+1) - z_arr(i ,j+1,k))
557  + (z_arr(i+1,j+1,k+1) - z_arr(i+1,j+1,k)) ) : dz;
558  qv_lay_tab(icol,ilay) = qv;
559  qc_lay_tab(icol,ilay) = qc;
560  qi_lay_tab(icol,ilay) = qi;
561  cldfrac_tot_tab(icol,ilay) = ((qc+qi)>Real(0.)) ? Real(1.) : Real(0.);
562 
563  // NOTE: These are populated in 'mixing_ratio_to_cloud_mass'
564  lwp_tab(icol,ilay) = Real(0.);
565  iwp_tab(icol,ilay) = Real(0.);
566 
567  // NOTE: These would be populated from P3 (we use the constants in p3_main_impl.hpp)
568  // NOTE: These are in units of micron!
569  eff_radius_qc_tab(icol,ilay) = (qc>Real(0.)) ? Real(10.0) : Real(0.);
570  eff_radius_qi_tab(icol,ilay) = (qi>Real(0.)) ? Real(25.0) : Real(0.);
571 
572  // Buffers on z-faces (nlay+1)
573  p_lev_tab(icol,ilay) = getPgivenRTh(rt_avg, qv_avg);
574  t_lev_tab(icol,ilay) = getTgivenRandRTh(r_avg, rt_avg, qv_avg);
575  if (ilay==(nlay-1)) {
576  Real r_hi = cons_arr(i,j,k+1,Rho_comp);
577  Real rt_hi = cons_arr(i,j,k+1,RhoTheta_comp);
578  Real qv_hi = (moist) ? std::max(cons_arr(i,j,k+1,RhoQ1_comp)/r_hi,Real(0.)) : Real(0.);
579  Real dz_kp1 = (z_arr) ? Real(0.125) * ( (z_arr(i ,j ,k+2) - z_arr(i ,j ,k+1))
580  + (z_arr(i+1,j ,k+2) - z_arr(i+1,j ,k+1))
581  + (z_arr(i ,j+1,k+2) - z_arr(i ,j+1,k+1))
582  + (z_arr(i+1,j+1,k+2) - z_arr(i+1,j+1,k+1)) ) : Real(0.5)*dz; // Dist from w-face to CC at k+1
583  r_avg = (dz_k*r + dz_kp1*r_hi ) / (dz_k + dz_kp1);
584  rt_avg = (dz_k*rt + dz_kp1*rt_hi) / (dz_k + dz_kp1);
585  qv_avg = (dz_k*qv + dz_kp1*qv_hi) / (dz_k + dz_kp1);
586  p_lev_tab(icol,ilay+1) = getPgivenRTh(rt_avg, qv_avg);
587  t_lev_tab(icol,ilay+1) = getTgivenRandRTh(r_avg, rt_avg, qv_avg);
588  }
589 
590  // 1D data structures
591  if (k==0) {
592  lat_tab(icol) = (has_lat) ? lat_arr(i,j,0) : cons_lat;
593  lon_tab(icol) = (has_lon) ? lon_arr(i,j,0) : cons_lon;
594  }
595 
596  });
597  } // mfi
598 
599  // Populate vars LSM would provide
600  if (!has_lsm && !has_surflayer) {
601  // Parsed surface temp
602  Kokkos::deep_copy(t_sfc, rad_t_sfc);
603 
604  // EAMXX dummy atmos constants
605  Kokkos::deep_copy(sfc_alb_dir_vis, Real(0.06));
606  Kokkos::deep_copy(sfc_alb_dir_nir, Real(0.06));
607  Kokkos::deep_copy(sfc_alb_dif_vis, Real(0.06));
608  Kokkos::deep_copy(sfc_alb_dif_nir, Real(0.06));
609 
610  // AML NOTE: These are not used in current EAMXX, I've left
611  // the code to plug into these if we need it.
612  //
613  // Current EAMXX constants
614  Kokkos::deep_copy(sfc_emis, Real(0.98));
615  Kokkos::deep_copy(lw_src , zero );
616  } else {
617  Vector<real1d_k> rrtmgp_in_vars = {t_sfc, sfc_emis,
618  sfc_alb_dir_vis, sfc_alb_dir_nir,
619  sfc_alb_dif_vis, sfc_alb_dif_nir};
620  Vector<Real> rrtmgp_default_vals = {rad_t_sfc, Real(0.98),
621  Real(0.06), Real(0.06),
622  Real(0.06), Real(0.06)};
623  for (int ivar(0); ivar<lsm_input_ptrs.size(); ivar++) {
624  auto rrtmgp_default_val = rrtmgp_default_vals[ivar];
625  auto rrtmgp_to_fill_k = rrtmgp_in_vars[ivar];
626  amrex::Table1D<amrex::Real> rrtmgp_to_fill(rrtmgp_to_fill_k.data(),
627  0, rrtmgp_to_fill_k.extent(0));
628  for (MFIter mfi(*m_cons_in); mfi.isValid(); ++mfi) {
629  const auto& vbx = mfi.validbox();
630  const auto& sbx = makeSlab(vbx,2,vbx.smallEnd(2));
631  const int nx = vbx.length(0);
632  const int imin = vbx.smallEnd(0);
633  const int jmin = vbx.smallEnd(1);
634  const int offset = m_col_offsets[mfi.index()];
635  const Array4<const int>& lmask_arr = (lmask) ? lmask->const_array(mfi) :
636  Array4<const int> {};
637  const Array4<const Real>& tsurf_arr = (t_surf) ? t_surf->const_array(mfi) :
638  Array4<const Real> {};
639  const Array4<const Real>& lsm_in_arr = (lsm_input_ptrs[ivar]) ? lsm_input_ptrs[ivar]->const_array(mfi) :
640  Array4<const Real> {};
641  ParallelFor(sbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
642  {
643  // map [i,j,k] 0-based to [icol, ilay] 0-based
644  const int icol = (j-jmin)*nx + (i-imin) + offset;
645 
646  // Check if over land
647  bool is_land = (lmask_arr) ? lmask_arr(i,j,k) : 1;
648 
649  // Check if valid LSM data
650  bool valid_lsm_data{false};
651  if (lsm_in_arr) { valid_lsm_data = (lsm_in_arr(i,j,k) >= Real(0.)); }
652 
653  // Have LSM and are over land
654  if (is_land && valid_lsm_data) {
655  rrtmgp_to_fill(icol) = lsm_in_arr(i,j,k);
656  }
657  // We have a SurfLayer (enforce consistency with temperature)
658  else if (tsurf_arr && (ivar==0)) {
659  rrtmgp_to_fill(icol) = tsurf_arr(i,j,k);
660  }
661  // Use the default value
662  else {
663  rrtmgp_to_fill(icol) = rrtmgp_default_val;
664  }
665  });
666  } //mfi
667  } // ivar
668  Kokkos::deep_copy(lw_src, zero );
669  } // have lsm
670 
671  // Enforce consistency between t_sfc and t_lev at bottom surface
672  Kokkos::parallel_for(Kokkos::RangePolicy(0, ncol),
673  KOKKOS_LAMBDA (int icol)
674  {
675  t_lev_tab(icol,0) = t_sfc_tab(icol);
676  });
677 }
zero
constexpr amrex::Real zero
Definition: ERF_Constants.H:8
getTgivenRandRTh
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real getTgivenRandRTh(const amrex::Real rho, const amrex::Real rhotheta, const amrex::Real qv=amrex::Real(0))
Definition: ERF_EOS.H:46
getPgivenRTh
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real getPgivenRTh(const amrex::Real rhotheta, const amrex::Real qv=amrex::Real(0))
Definition: ERF_EOS.H:81
Rho_comp
#define Rho_comp
Definition: ERF_IndexDefines.H:36
RhoTheta_comp
#define RhoTheta_comp
Definition: ERF_IndexDefines.H:37
RhoQ2_comp
#define RhoQ2_comp
Definition: ERF_IndexDefines.H:43
RhoQ3_comp
#define RhoQ3_comp
Definition: ERF_IndexDefines.H:44
RhoQ1_comp
#define RhoQ1_comp
Definition: ERF_IndexDefines.H:42
Radiation::m_lon
amrex::MultiFab * m_lon
Definition: ERF_Radiation.H:277
Radiation::m_z_phys
amrex::MultiFab * m_z_phys
Definition: ERF_Radiation.H:273
Radiation::m_geom
amrex::Geometry m_geom
Definition: ERF_Radiation.H:229
Radiation::m_lat
amrex::MultiFab * m_lat
Definition: ERF_Radiation.H:276
LsmVar_OceanSurf::t_surf
@ t_surf
Definition: ERF_OceanSurf.H:14
MicVar_Kess::qv
@ qv
Definition: ERF_Kessler.H:29
MicVar_SatAdj::qc
@ qc
Definition: ERF_SatAdj.H:40
MicVar_WSM6::qi
@ qi
Definition: ERF_WSM6.H:26
WSM6SedCellScratch::dz
@ dz
Definition: ERF_AdvanceWSM6.cpp:104
Here is the call graph for this function:

◆ populateDatalogMF()

void Radiation::populateDatalogMF ( )
801 {
802  Table2D<Real,Order::C> sw_flux_up_tab(sw_flux_up.data(), {0,0}, {static_cast<int>(sw_flux_up.extent(0)),static_cast<int>(sw_flux_up.extent(1))});
803  Table2D<Real,Order::C> sw_flux_dn_tab(sw_flux_dn.data(), {0,0}, {static_cast<int>(sw_flux_dn.extent(0)),static_cast<int>(sw_flux_dn.extent(1))});
804  Table2D<Real,Order::C> sw_flux_dn_dir_tab(sw_flux_dn_dir.data(), {0,0}, {static_cast<int>(sw_flux_dn_dir.extent(0)),static_cast<int>(sw_flux_dn_dir.extent(1))});
805  Table2D<Real,Order::C> lw_flux_up_tab(lw_flux_up.data(), {0,0}, {static_cast<int>(lw_flux_up.extent(0)),static_cast<int>(lw_flux_up.extent(1))});
806  Table2D<Real,Order::C> lw_flux_dn_tab(lw_flux_dn.data(), {0,0}, {static_cast<int>(lw_flux_dn.extent(0)),static_cast<int>(lw_flux_dn.extent(1))});
807 
808  Table2D<Real,Order::C> sw_clrsky_flux_up_tab(sw_clrsky_flux_up.data(), {0,0},
809  {static_cast<int>(sw_clrsky_flux_up.extent(0)),static_cast<int>(sw_clrsky_flux_up.extent(1))});
810  Table2D<Real,Order::C> sw_clrsky_flux_dn_tab(sw_clrsky_flux_dn.data(), {0,0},
811  {static_cast<int>(sw_clrsky_flux_dn.extent(0)),static_cast<int>(sw_clrsky_flux_dn.extent(1))});
812  Table2D<Real,Order::C> sw_clrsky_flux_dn_dir_tab(sw_clrsky_flux_dn_dir.data(), {0,0},
813  {static_cast<int>(sw_clrsky_flux_dn_dir.extent(0)),static_cast<int>(sw_clrsky_flux_dn_dir.extent(1))});
814  Table2D<Real,Order::C> lw_clrsky_flux_up_tab(lw_clrsky_flux_up.data(), {0,0},
815  {static_cast<int>(lw_clrsky_flux_up.extent(0)),static_cast<int>(lw_clrsky_flux_up.extent(1))});
816  Table2D<Real,Order::C> lw_clrsky_flux_dn_tab(lw_clrsky_flux_dn.data(), {0,0},
817  {static_cast<int>(lw_clrsky_flux_dn.extent(0)),static_cast<int>(lw_clrsky_flux_dn.extent(1))});
818  Table2D<Real,Order::C> sw_clrsky_heating_tab(sw_clrsky_heating.data(), {0,0},
819  {static_cast<int>(sw_clrsky_heating.extent(0)),static_cast<int>(sw_clrsky_heating.extent(1))});
820  Table2D<Real,Order::C> lw_clrsky_heating_tab(lw_clrsky_heating.data(), {0,0},
821  {static_cast<int>(lw_clrsky_heating.extent(0)),static_cast<int>(lw_clrsky_heating.extent(1))});
822  Table2D<Real,Order::C> sw_clnsky_flux_up_tab(sw_clnsky_flux_up.data(), {0,0},
823  {static_cast<int>(sw_clnsky_flux_up.extent(0)),static_cast<int>(sw_clnsky_flux_up.extent(1))});
824  Table2D<Real,Order::C> sw_clnsky_flux_dn_tab(sw_clnsky_flux_dn.data(), {0,0},
825  {static_cast<int>(sw_clnsky_flux_dn.extent(0)),static_cast<int>(sw_clnsky_flux_dn.extent(1))});
826  Table2D<Real,Order::C> sw_clnsky_flux_dn_dir_tab(sw_clnsky_flux_dn_dir.data(), {0,0},
827  {static_cast<int>(sw_clnsky_flux_dn_dir.extent(0)),static_cast<int>(sw_clnsky_flux_dn_dir.extent(1))});
828  Table2D<Real,Order::C> lw_clnsky_flux_up_tab(lw_clnsky_flux_up.data(), {0,0},
829  {static_cast<int>(lw_clnsky_flux_up.extent(0)),static_cast<int>(lw_clnsky_flux_up.extent(1))});
830  Table2D<Real,Order::C> lw_clnsky_flux_dn_tab(lw_clnsky_flux_dn.data(), {0,0},
831  {static_cast<int>(lw_clnsky_flux_dn.extent(0)),static_cast<int>(lw_clnsky_flux_dn.extent(1))});
832  Table2D<Real,Order::C> sw_clnclrsky_flux_up_tab(sw_clnclrsky_flux_up.data(), {0,0},
833  {static_cast<int>(sw_clnclrsky_flux_up.extent(0)),static_cast<int>(sw_clnclrsky_flux_up.extent(1))});
834  Table2D<Real,Order::C> sw_clnclrsky_flux_dn_tab(sw_clnclrsky_flux_dn.data(), {0,0},
835  {static_cast<int>(sw_clnclrsky_flux_dn.extent(0)),static_cast<int>(sw_clnclrsky_flux_dn.extent(1))});
836  Table2D<Real,Order::C> sw_clnclrsky_flux_dn_dir_tab(sw_clnclrsky_flux_dn_dir.data(), {0,0},
837  {static_cast<int>(sw_clnclrsky_flux_dn_dir.extent(0)),static_cast<int>(sw_clnclrsky_flux_dn_dir.extent(1))});
838  Table2D<Real,Order::C> lw_clnclrsky_flux_up_tab(lw_clnclrsky_flux_up.data(), {0,0},
839  {static_cast<int>(lw_clnclrsky_flux_up.extent(0)),static_cast<int>(lw_clnclrsky_flux_up.extent(1))});
840  Table2D<Real,Order::C> lw_clnclrsky_flux_dn_tab(lw_clnclrsky_flux_dn.data(), {0,0},
841  {static_cast<int>(lw_clnclrsky_flux_dn.extent(0)),static_cast<int>(lw_clnclrsky_flux_dn.extent(1))});
842 
843  Table1D<Real> mu0_tab(mu0.data(), {0}, {static_cast<int>(mu0.extent(0))});
844 
845  auto extra_clnsky_diag = m_extra_clnsky_diag;
846  auto extra_clnclrsky_diag = m_extra_clnclrsky_diag;
847 
848  for (MFIter mfi(datalog_mf); mfi.isValid(); ++mfi) {
849  const auto& vbx = mfi.validbox();
850  const int nx = vbx.length(0);
851  const int imin = vbx.smallEnd(0);
852  const int jmin = vbx.smallEnd(1);
853  const int offset = m_col_offsets[mfi.index()];
854  const Array4<Real>& dst_arr = datalog_mf.array(mfi);
855  const Array4<Real>& q_arr = m_qheating_rates->array(mfi);
856  ParallelFor(vbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
857  {
858  // map [i,j,k] 0-based to [icol, ilay] 0-based
859  const int icol = (j-jmin)*nx + (i-imin) + offset;
860  const int ilay = k;
861 
862  dst_arr(i,j,k,0) = q_arr(i, j, k, 0);
863  dst_arr(i,j,k,1) = q_arr(i, j, k, 1);
864 
865  // SW and LW fluxes
866  dst_arr(i,j,k,2) = sw_flux_up_tab(icol,ilay);
867  dst_arr(i,j,k,3) = sw_flux_dn_tab(icol,ilay);
868  dst_arr(i,j,k,4) = sw_flux_dn_dir_tab(icol,ilay);
869  dst_arr(i,j,k,5) = lw_flux_up_tab(icol,ilay);
870  dst_arr(i,j,k,6) = lw_flux_dn_tab(icol,ilay);
871 
872  // Cosine zenith angle
873  dst_arr(i,j,k,7) = mu0_tab(icol);
874 
875  // Clear sky heating rates and fluxes:
876  dst_arr(i,j,k,8) = sw_clrsky_heating_tab(icol, ilay);
877  dst_arr(i,j,k,9) = lw_clrsky_heating_tab(icol, ilay);
878 
879  dst_arr(i,j,k,10) = sw_clrsky_flux_up_tab(icol,ilay);
880  dst_arr(i,j,k,11) = sw_clrsky_flux_dn_tab(icol,ilay);
881  dst_arr(i,j,k,12) = sw_clrsky_flux_dn_dir_tab(icol,ilay);
882  dst_arr(i,j,k,13) = lw_clrsky_flux_up_tab(icol,ilay);
883  dst_arr(i,j,k,14) = lw_clrsky_flux_dn_tab(icol,ilay);
884 
885  // Clean sky fluxes:
886  if (extra_clnsky_diag) {
887  dst_arr(i,j,k,15) = sw_clnsky_flux_up_tab(icol,ilay);
888  dst_arr(i,j,k,16) = sw_clnsky_flux_dn_tab(icol,ilay);
889  dst_arr(i,j,k,17) = sw_clnsky_flux_dn_dir_tab(icol,ilay);
890  dst_arr(i,j,k,18) = lw_clnsky_flux_up_tab(icol,ilay);
891  dst_arr(i,j,k,19) = lw_clnsky_flux_dn_tab(icol,ilay);
892  }
893 
894  // Clean-clear sky fluxes:
895  if (extra_clnclrsky_diag) {
896  dst_arr(i,j,k,20) = sw_clnclrsky_flux_up_tab(icol,ilay);
897  dst_arr(i,j,k,21) = sw_clnclrsky_flux_dn_tab(icol,ilay);
898  dst_arr(i,j,k,22) = sw_clnclrsky_flux_dn_dir_tab(icol,ilay);
899  dst_arr(i,j,k,23) = lw_clnclrsky_flux_up_tab(icol,ilay);
900  dst_arr(i,j,k,24) = lw_clnclrsky_flux_dn_tab(icol,ilay);
901  }
902  });
903  }
904 }
Radiation::datalog_mf
amrex::MultiFab datalog_mf
Definition: ERF_Radiation.H:284
Here is the call graph for this function:

◆ rad_run_impl()

void Radiation::rad_run_impl ( amrex::Vector< amrex::MultiFab * > &  lsm_output_ptrs)
inline
175  {
176  if (m_update_rad) {
177  amrex::Print() << "Radiation advancing level " << m_lev << " at (YY-MM-DD SS) " << m_orbital_year << '-'
178  << m_orbital_mon << '-' << m_orbital_day << ' ' << m_orbital_sec << " ...";
179  this->initialize_impl();
180  this->run_impl();
181  this->finalize_impl(lsm_output_ptrs);
182  amrex::Print() << "DONE\n";
183  }
184  }
Radiation::initialize_impl
void initialize_impl()
Definition: ERF_Radiation.cpp:1041
Radiation::run_impl
void run_impl()
Definition: ERF_Radiation.cpp:1063
Radiation::m_orbital_mon
int m_orbital_mon
Definition: ERF_Radiation.H:345
Radiation::finalize_impl
void finalize_impl(amrex::Vector< amrex::MultiFab * > &lsm_output_ptrs)
Definition: ERF_Radiation.cpp:1365
Radiation::m_orbital_sec
int m_orbital_sec
Definition: ERF_Radiation.H:347
Radiation::m_lev
int m_lev
Definition: ERF_Radiation.H:217
Radiation::m_update_rad
bool m_update_rad
Definition: ERF_Radiation.H:235
Radiation::m_orbital_day
int m_orbital_day
Definition: ERF_Radiation.H:346

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::iMultiFab *  lmask,
amrex::MultiFab *  t_surf,
amrex::Vector< amrex::MultiFab * > &  lsm_input_ptrs,
amrex::Vector< amrex::MultiFab * > &  lsm_output_ptrs,
amrex::MultiFab *  qheating_rates,
amrex::MultiFab *  rad_fluxes,
amrex::MultiFab *  z_phys,
amrex::MultiFab *  lat_ptr,
amrex::MultiFab *  lon_ptr 
)
inlineoverridevirtual

Implements IRadiation.

112  {
113  set_grids(level, step, time, dt, ba, geom,
114  cons_in, lmask, t_surf,
115  lsm_input_ptrs, qheating_rates,
116  rad_fluxes, z_phys, lat_ptr, lon_ptr);
117  rad_run_impl(lsm_output_ptrs);
118  }
Radiation::set_grids
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::iMultiFab *lmask, amrex::MultiFab *t_surf, amrex::Vector< amrex::MultiFab * > &lsm_input_ptrs, amrex::MultiFab *qheating_rates, amrex::MultiFab *rad_fluxes, amrex::MultiFab *z_phys, amrex::MultiFab *lat, amrex::MultiFab *lon)
Definition: ERF_Radiation.cpp:158
Radiation::rad_run_impl
void rad_run_impl(amrex::Vector< amrex::MultiFab * > &lsm_output_ptrs)
Definition: ERF_Radiation.H:174
Here is the call graph for this function:

◆ run_impl()

void Radiation::run_impl ( )
1064 {
1065  // Local copies
1066  const auto ncol = m_ncol;
1067  const auto nlay = m_nlay;
1068  const auto nswbands = m_nswbands;
1069 
1070  // Compute orbital parameters; these are used both for computing
1071  // the solar zenith angle and also for computing total solar
1072  // irradiance scaling (tsi_scaling).
1073  double obliqr, lambm0, mvelpp;
1074  int orbital_year = m_orbital_year;
1075  double eccen = m_orbital_eccen;
1076  double obliq = m_orbital_obliq;
1077  double mvelp = m_orbital_mvelp;
1078  if (eccen >= 0 && obliq >= 0 && mvelp >= 0) {
1079  // fixed orbital parameters forced with orbital_year == ORB_UNDEF_INT
1080  orbital_year = ORB_UNDEF_INT;
1081  }
1082  orbital_params(orbital_year, eccen, obliq,
1083  mvelp, obliqr, lambm0, mvelpp);
1084 
1085  // Use the orbital parameters to calculate the solar declination and eccentricity factor
1086  double delta, eccf;
1087  // Want day + fraction; calday 1 == Jan 1 0Z
1088  static constexpr double dpy[] = {zero , Real(31.0), Real(59.0), Real(90.0), Real(120.0), Real(151.0),
1089  Real(181.0), Real(212.0), Real(243.0), Real(273.0), Real(304.0), Real(334.0)};
1090  bool leap = (m_orbital_year % 4 == 0 && (!(m_orbital_year % 100 == 0) || (m_orbital_year % 400 == 0))) ? true : false;
1091  double calday = one + dpy[m_orbital_mon-1] + (m_orbital_day-one) + m_orbital_sec/Real(86400.0);
1092  // add extra day if leap year and past February
1093  if (leap && m_orbital_mon>2) { calday += one; }
1094  orbital_decl(calday, eccen, mvelpp, lambm0, obliqr, delta, eccf);
1095 
1096  // Overwrite eccf if using a fixed solar constant.
1097  auto fixed_total_solar_irradiance = m_fixed_total_solar_irradiance;
1098  if (fixed_total_solar_irradiance >= 0){
1099  eccf = fixed_total_solar_irradiance/Real(1360.9);
1100  }
1101 
1102  // Precompute volume mixing ratio (VMR) for all gases
1103  //
1104  // H2O is obtained from qv.
1105  // O3 may be a constant or a 1D vector
1106  // All other comps are set to constants for now
1107  Vector<real2d_k> vmr_full_vec(m_ngas);
1108  for (int igas(0); igas < m_ngas; ++igas) {
1109  auto name = m_gas_names[igas];
1110  vmr_full_vec[igas] = real2d_k("vmr_full_" + name, ncol, nlay);
1111  auto tmp2d = vmr_full_vec[igas];
1112  auto gas_mol_weight = m_mol_weight_gas[igas];
1113  if (name == "H2O") {
1114  auto qv_lay_d = qv_lay;
1115  Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<2>>({0, 0}, {ncol, nlay}),
1116  KOKKOS_LAMBDA (int icol, int ilay)
1117  {
1118  tmp2d(icol,ilay) = qv_lay_d(icol,ilay) * mwdair/gas_mol_weight;
1119  });
1120  } else if (name == "CO2") {
1121  Kokkos::deep_copy(tmp2d, m_co2vmr);
1122  } else if (name == "O3") {
1123  if (m_o3_size==1) {
1124  Kokkos::deep_copy(tmp2d, m_o3vmr[0] );
1125  } else {
1126  auto o3_lay_d = o3_lay;
1127  Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<2>>({0, 0}, {ncol, nlay}),
1128  KOKKOS_LAMBDA (int icol, int ilay)
1129  {
1130  tmp2d(icol,ilay) = o3_lay_d(ilay);
1131  });
1132  }
1133  } else if (name == "N2O") {
1134  Kokkos::deep_copy(tmp2d, m_n2ovmr);
1135  } else if (name == "CO") {
1136  Kokkos::deep_copy(tmp2d, m_covmr );
1137  } else if (name == "CH4") {
1138  Kokkos::deep_copy(tmp2d, m_ch4vmr);
1139  } else if (name == "O2") {
1140  Kokkos::deep_copy(tmp2d, m_o2vmr );
1141  } else if (name == "N2") {
1142  Kokkos::deep_copy(tmp2d, m_n2vmr );
1143  } else {
1144  Abort("Radiation: Unknown gas component.");
1145  }
1146 
1147  // Populate GasConcs object
1148  m_gas_concs.set_vmr(name, tmp2d);
1149  Kokkos::fence();
1150  }
1151 
1152  // Populate mu0 1D array
1153  // This must be done on HOST and copied to device.
1154  auto h_mu0 = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), mu0);
1155  if (m_fixed_solar_zenith_angle > 0) {
1156  Kokkos::deep_copy(h_mu0, m_fixed_solar_zenith_angle);
1157  } else {
1158  auto h_lat = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), lat);
1159  auto h_lon = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), lon);
1160  double dt = double(m_dt);
1161  auto rad_freq_in_steps = m_rad_freq_in_steps;
1162  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Serial>(0, ncol),
1163  [&] (int icol)
1164  {
1165  // Convert lat/lon to radians
1166  double lat_col = h_lat(icol)*PI/Real(180.0);
1167  double lon_col = h_lon(icol)*PI/Real(180.0);
1168  double lcalday = calday;
1169  double ldelta = delta;
1170  double dt_avg = static_cast<double>(rad_freq_in_steps) * dt;
1171  h_mu0(icol) = Real(orbital_cos_zenith(lcalday, lat_col, lon_col, ldelta, dt_avg));
1172  });
1173  }
1174  Kokkos::deep_copy(mu0, h_mu0);
1175 
1176  // Compute layer cloud mass per unit area (populates lwp/iwp)
1177  rrtmgp::mixing_ratio_to_cloud_mass(qc_lay, cldfrac_tot, r_lay, z_del, lwp);
1178  rrtmgp::mixing_ratio_to_cloud_mass(qi_lay, cldfrac_tot, r_lay, z_del, iwp);
1179 
1180  // Convert to g/m2 (needed by RRTMGP)
1181  Table2D<Real,Order::C> lwp_tab(lwp.data(), {0,0}, {static_cast<int>(lwp.extent(0)),static_cast<int>(lwp.extent(1))});
1182  Table2D<Real,Order::C> iwp_tab(iwp.data(), {0,0}, {static_cast<int>(iwp.extent(0)),static_cast<int>(iwp.extent(1))});
1183  Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<2>>({0, 0}, {ncol, nlay}),
1184  KOKKOS_LAMBDA (int icol, int ilay)
1185  {
1186  lwp_tab(icol,ilay) *= Real(1.e3);
1187  iwp_tab(icol,ilay) *= Real(1.e3);
1188  });
1189 
1190  // -----------------------------------------------------------------------
1191  // Process radiation in column chunks to limit peak GPU memory.
1192  // Radiation columns are independent (no horizontal coupling), so
1193  // chunking produces bit-identical results.
1194  // -----------------------------------------------------------------------
1195  const int ncol_chunk = std::min(m_ncol_chunk, ncol);
1196  const int kbot = 0;
1197 
1198  for (int col_s = 0; col_s < ncol; col_s += ncol_chunk) {
1199  const int ncol_c = std::min(ncol_chunk, ncol - col_s);
1200  const int col_e = col_s + ncol_c;
1201  auto cr = std::make_pair(col_s, col_e);
1202 
1203  // --- Chunk subviews: 1D (ncol) ---
1204  real1d_k mu0_c (mu0.data() + col_s, ncol_c);
1205  real1d_k sfc_alb_dir_vis_c (sfc_alb_dir_vis.data() + col_s, ncol_c);
1206  real1d_k sfc_alb_dir_nir_c (sfc_alb_dir_nir.data() + col_s, ncol_c);
1207  real1d_k sfc_alb_dif_vis_c (sfc_alb_dif_vis.data() + col_s, ncol_c);
1208  real1d_k sfc_alb_dif_nir_c (sfc_alb_dif_nir.data() + col_s, ncol_c);
1209  real1d_k sfc_flux_dir_vis_c (sfc_flux_dir_vis.data() + col_s, ncol_c);
1210  real1d_k sfc_flux_dir_nir_c (sfc_flux_dir_nir.data() + col_s, ncol_c);
1211  real1d_k sfc_flux_dif_vis_c (sfc_flux_dif_vis.data() + col_s, ncol_c);
1212  real1d_k sfc_flux_dif_nir_c (sfc_flux_dif_nir.data() + col_s, ncol_c);
1213  real1d_k t_sfc_c (t_sfc.data() + col_s, ncol_c);
1214  real1d_k sfc_emis_c (sfc_emis.data() + col_s, ncol_c);
1215  real1d_k lw_src_c (lw_src.data() + col_s, ncol_c);
1216 
1217  // --- Chunk subviews: 2D (ncol, nlay) via LayoutRight pointer offset ---
1218  const int stride2_nlay = nlay;
1219  const int stride2_nlayp1 = nlay + 1;
1220  real2d_k p_lay_c (p_lay.data() + col_s*stride2_nlay, ncol_c, nlay);
1221  real2d_k t_lay_c (t_lay.data() + col_s*stride2_nlay, ncol_c, nlay);
1222  real2d_k r_lay_c (r_lay.data() + col_s*stride2_nlay, ncol_c, nlay);
1223  real2d_k z_del_c (z_del.data() + col_s*stride2_nlay, ncol_c, nlay);
1224  real2d_k lwp_c (lwp.data() + col_s*stride2_nlay, ncol_c, nlay);
1225  real2d_k iwp_c (iwp.data() + col_s*stride2_nlay, ncol_c, nlay);
1226  real2d_k eff_radius_qc_c(eff_radius_qc.data() + col_s*stride2_nlay, ncol_c, nlay);
1227  real2d_k eff_radius_qi_c(eff_radius_qi.data() + col_s*stride2_nlay, ncol_c, nlay);
1228  real2d_k cldfrac_tot_c (cldfrac_tot.data() + col_s*stride2_nlay, ncol_c, nlay);
1229  real2d_k sw_heating_c (sw_heating.data() + col_s*stride2_nlay, ncol_c, nlay);
1230  real2d_k lw_heating_c (lw_heating.data() + col_s*stride2_nlay, ncol_c, nlay);
1231 
1232  // --- Chunk subviews: 2D (ncol, nlay+1) ---
1233  real2d_k p_lev_c (p_lev.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1234  real2d_k t_lev_c (t_lev.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1235  real2d_k sw_flux_up_c (sw_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1236  real2d_k sw_flux_dn_c (sw_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1237  real2d_k sw_flux_dn_dir_c (sw_flux_dn_dir.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1238  real2d_k lw_flux_up_c (lw_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1239  real2d_k lw_flux_dn_c (lw_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1240  // Clear-sky flux subviews (always active)
1241  // NOTE: once on m_ncol_chunk if not writing a datalog
1242  real2d_k sw_clrsky_flux_up_c, sw_clrsky_flux_dn_c, sw_clrsky_flux_dn_dir_c;
1243  real2d_k lw_clrsky_flux_up_c, lw_clrsky_flux_dn_c;
1244  if (datalog_int > 0) {
1245  sw_clrsky_flux_up_c = real2d_k(sw_clrsky_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1246  sw_clrsky_flux_dn_c = real2d_k(sw_clrsky_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1247  sw_clrsky_flux_dn_dir_c = real2d_k(sw_clrsky_flux_dn_dir.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1248  lw_clrsky_flux_up_c = real2d_k(lw_clrsky_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1249  lw_clrsky_flux_dn_c = real2d_k(lw_clrsky_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1250  } else {
1251  sw_clrsky_flux_up_c = real2d_k(sw_clrsky_flux_up.data() , ncol_c, nlay+1);
1252  sw_clrsky_flux_dn_c = real2d_k(sw_clrsky_flux_dn.data() , ncol_c, nlay+1);
1253  sw_clrsky_flux_dn_dir_c = real2d_k(sw_clrsky_flux_dn_dir.data() , ncol_c, nlay+1);
1254  lw_clrsky_flux_up_c = real2d_k(lw_clrsky_flux_up.data() , ncol_c, nlay+1);
1255  lw_clrsky_flux_dn_c = real2d_k(lw_clrsky_flux_dn.data() , ncol_c, nlay+1);
1256  }
1257 
1258  // Diagnostic flux subviews (placeholder when disabled)
1259  real2d_k sw_clnclrsky_flux_up_c, sw_clnclrsky_flux_dn_c, sw_clnclrsky_flux_dn_dir_c;
1260  real2d_k lw_clnclrsky_flux_up_c, lw_clnclrsky_flux_dn_c;
1261  if (m_extra_clnclrsky_diag) {
1262  sw_clnclrsky_flux_up_c = real2d_k(sw_clnclrsky_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1263  sw_clnclrsky_flux_dn_c = real2d_k(sw_clnclrsky_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1264  sw_clnclrsky_flux_dn_dir_c = real2d_k(sw_clnclrsky_flux_dn_dir.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1265  lw_clnclrsky_flux_up_c = real2d_k(lw_clnclrsky_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1266  lw_clnclrsky_flux_dn_c = real2d_k(lw_clnclrsky_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1267  } else {
1268  sw_clnclrsky_flux_up_c = real2d_k("sw_clnclrsky_flux_up_c" , 1, 1);
1269  sw_clnclrsky_flux_dn_c = real2d_k("sw_clnclrsky_flux_dn_c" , 1, 1);
1270  sw_clnclrsky_flux_dn_dir_c = real2d_k("sw_clnclrsky_flux_dn_dir_c", 1, 1);
1271  lw_clnclrsky_flux_up_c = real2d_k("lw_clnclrsky_flux_up_c" , 1, 1);
1272  lw_clnclrsky_flux_dn_c = real2d_k("lw_clnclrsky_flux_dn_c" , 1, 1);
1273  }
1274 
1275  real2d_k sw_clnsky_flux_up_c, sw_clnsky_flux_dn_c, sw_clnsky_flux_dn_dir_c;
1276  real2d_k lw_clnsky_flux_up_c, lw_clnsky_flux_dn_c;
1277  if (m_extra_clnsky_diag) {
1278  sw_clnsky_flux_up_c = real2d_k(sw_clnsky_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1279  sw_clnsky_flux_dn_c = real2d_k(sw_clnsky_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1280  sw_clnsky_flux_dn_dir_c = real2d_k(sw_clnsky_flux_dn_dir.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1281  lw_clnsky_flux_up_c = real2d_k(lw_clnsky_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1282  lw_clnsky_flux_dn_c = real2d_k(lw_clnsky_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1283  } else {
1284  sw_clnsky_flux_up_c = real2d_k("sw_clnsky_flux_up_c" , 1, 1);
1285  sw_clnsky_flux_dn_c = real2d_k("sw_clnsky_flux_dn_c" , 1, 1);
1286  sw_clnsky_flux_dn_dir_c = real2d_k("sw_clnsky_flux_dn_dir_c", 1, 1);
1287  lw_clnsky_flux_up_c = real2d_k("lw_clnsky_flux_up_c" , 1, 1);
1288  lw_clnsky_flux_dn_c = real2d_k("lw_clnsky_flux_dn_c" , 1, 1);
1289  }
1290 
1291  // --- Chunk subviews: 2D (ncol, nswbands) ---
1292  real2d_k sfc_alb_dir_c(sfc_alb_dir.data() + col_s*nswbands, ncol_c, nswbands);
1293  real2d_k sfc_alb_dif_c(sfc_alb_dif.data() + col_s*nswbands, ncol_c, nswbands);
1294 
1295  // --- Chunk subviews: 3D (ncol, nlay+1, nbands) ---
1296  // NOTE: Allocate these once on m_ncol_chunk and use what we need in the chunk loop
1297  real3d_k sw_bnd_flux_up_c (sw_bnd_flux_up.data() , ncol_c, nlay+1, nswbands);
1298  real3d_k sw_bnd_flux_dn_c (sw_bnd_flux_dn.data() , ncol_c, nlay+1, nswbands);
1299  real3d_k sw_bnd_flux_dir_c(sw_bnd_flux_dir.data(), ncol_c, nlay+1, nswbands);
1300  real3d_k sw_bnd_flux_dif_c(sw_bnd_flux_dif.data(), ncol_c, nlay+1, nswbands);
1301  real3d_k lw_bnd_flux_up_c (lw_bnd_flux_up.data() , ncol_c, nlay+1, m_nlwbands);
1302  real3d_k lw_bnd_flux_dn_c (lw_bnd_flux_dn.data() , ncol_c, nlay+1, m_nlwbands);
1303 
1304  // --- Create chunk gas concentrations by subsetting from pre-fetched VMR ---
1305  gas_concs_t gas_concs_c;
1306  gas_concs_c.init(gas_names_offset, ncol_c, nlay);
1307  for (int igas = 0; igas < m_ngas; ++igas) {
1308  real2d_k vmr_c("vmr_c", ncol_c, nlay);
1309  auto vmr_full = vmr_full_vec[igas];
1310  auto cs = col_s;
1311  Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<2>>({0, 0}, {ncol_c, nlay}),
1312  KOKKOS_LAMBDA (int i, int j) {
1313  vmr_c(i, j) = vmr_full(cs + i, j);
1314  });
1315  gas_concs_c.set_vmr(m_gas_names[igas], vmr_c);
1316  }
1317 
1318  // Expand surface albedos along nswbands for this chunk
1319  rrtmgp::compute_band_by_band_surface_albedos(ncol_c, nswbands,
1320  sfc_alb_dir_vis_c, sfc_alb_dir_nir_c,
1321  sfc_alb_dif_vis_c, sfc_alb_dif_nir_c,
1322  sfc_alb_dir_c , sfc_alb_dif_c);
1323 
1324  // Run RRTMGP driver for this column chunk
1325  rrtmgp::rrtmgp_main(ncol_c, m_nlay,
1326  p_lay_c, t_lay_c,
1327  p_lev_c, t_lev_c,
1328  gas_concs_c,
1329  sfc_alb_dir_c, sfc_alb_dif_c, mu0_c,
1330  t_sfc_c, sfc_emis_c, lw_src_c,
1331  lwp_c, iwp_c, eff_radius_qc_c, eff_radius_qi_c, cldfrac_tot_c,
1332  sw_flux_up_c, sw_flux_dn_c, sw_flux_dn_dir_c,
1333  lw_flux_up_c, lw_flux_dn_c,
1334  sw_clnclrsky_flux_up_c, sw_clnclrsky_flux_dn_c, sw_clnclrsky_flux_dn_dir_c,
1335  sw_clrsky_flux_up_c, sw_clrsky_flux_dn_c, sw_clrsky_flux_dn_dir_c,
1336  sw_clnsky_flux_up_c, sw_clnsky_flux_dn_c, sw_clnsky_flux_dn_dir_c,
1337  lw_clnclrsky_flux_up_c, lw_clnclrsky_flux_dn_c,
1338  lw_clrsky_flux_up_c, lw_clrsky_flux_dn_c,
1339  lw_clnsky_flux_up_c, lw_clnsky_flux_dn_c,
1340  sw_bnd_flux_up_c, sw_bnd_flux_dn_c, sw_bnd_flux_dir_c,
1341  lw_bnd_flux_up_c, lw_bnd_flux_dn_c,
1342  eccf, m_extra_clnclrsky_diag, m_extra_clnsky_diag);
1343 
1344  // Compute heating rates for this chunk
1345  rrtmgp::compute_heating_rate(sw_flux_up_c, sw_flux_dn_c, r_lay_c, z_del_c, sw_heating_c);
1346  rrtmgp::compute_heating_rate(lw_flux_up_c, lw_flux_dn_c, r_lay_c, z_del_c, lw_heating_c);
1347 
1348  // Compute diffuse band fluxes and broadband surface fluxes for this chunk
1349  Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<3>>({0, 0, 0}, {ncol_c, nlay+1, nswbands}),
1350  KOKKOS_LAMBDA (int icol, int ilay, int ibnd)
1351  {
1352  sw_bnd_flux_dif_c(icol,ilay,ibnd) = sw_bnd_flux_dn_c(icol,ilay,ibnd) - sw_bnd_flux_dir_c(icol,ilay,ibnd);
1353  });
1354  rrtmgp::compute_broadband_surface_fluxes(ncol_c, kbot, nswbands,
1355  sw_bnd_flux_dir_c , sw_bnd_flux_dif_c ,
1356  sfc_flux_dir_vis_c, sfc_flux_dir_nir_c,
1357  sfc_flux_dif_vis_c, sfc_flux_dif_nir_c);
1358 
1359  gas_concs_c.reset();
1360  } // end column chunk loop
1361 }
ORB_UNDEF_INT
static constexpr int ORB_UNDEF_INT
Definition: ERF_Constants.H:128
mwdair
constexpr amrex::Real mwdair
Definition: ERF_Constants.H:96
PI
constexpr amrex::Real PI
Definition: ERF_Constants.H:37
orbital_cos_zenith
AMREX_GPU_HOST AMREX_FORCE_INLINE real orbital_cos_zenith(real &jday, real &lat, real &lon, real &declin, real dt_avg=-one, real uniform_angle=-one, real constant_zenith_angle_deg=-one)
Definition: ERF_OrbCosZenith.H:562
orbital_decl
AMREX_GPU_HOST AMREX_FORCE_INLINE void orbital_decl(real &calday, real &eccen, real &mvelpp, real &lambm0, real &obliqr, real &delta, real &eccf)
Definition: ERF_OrbCosZenith.H:15
orbital_params
AMREX_GPU_HOST AMREX_FORCE_INLINE void orbital_params(int &iyear_AD, real &eccen, real &obliq, real &mvelp, real &obliqr, real &lambm0, real &mvelpp)
Definition: ERF_OrbCosZenith.H:81
Radiation::m_dt
amrex::Real m_dt
Definition: ERF_Radiation.H:226
module_mp_morr_two_moment::cs
real(c_double), private cs
Definition: ERF_module_mp_morr_two_moment.F90:203
rrtmgp::rrtmgp_main
void rrtmgp_main(const int ncol, const int nlay, real2d_k &p_lay, real2d_k &t_lay, real2d_k &p_lev, real2d_k &t_lev, gas_concs_t &gas_concs, real2d_k &sfc_alb_dir, real2d_k &sfc_alb_dif, real1d_k &mu0, real1d_k &t_sfc, real1d_k &sfc_emis, real1d_k &lw_src, real2d_k &lwp, real2d_k &iwp, real2d_k &rel, real2d_k &rei, real2d_k &cldfrac, 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_dn_dir, real3d_k &lw_bnd_flux_up, real3d_k &lw_bnd_flux_dn, const RealT tsi_scaling, const bool extra_clnclrsky_diag, const bool extra_clnsky_diag)
Definition: ERF_RRTMGP_Interface.cpp:384
rrtmgp::compute_band_by_band_surface_albedos
void compute_band_by_band_surface_albedos(const int ncol, const int nswbands, real1d_k &sfc_alb_dir_vis, real1d_k &sfc_alb_dir_nir, real1d_k &sfc_alb_dif_vis, real1d_k &sfc_alb_dif_nir, real2d_k &sfc_alb_dir, real2d_k &sfc_alb_dif)
Definition: ERF_RRTMGP_Interface.cpp:282
rrtmgp::compute_broadband_surface_fluxes
void compute_broadband_surface_fluxes(const int ncol, const int kbot, const int nswbands, real3d_k &sw_bnd_flux_dir, real3d_k &sw_bnd_flux_dif, real1d_k &sfc_flux_dir_vis, real1d_k &sfc_flux_dir_nir, real1d_k &sfc_flux_dif_vis, real1d_k &sfc_flux_dif_nir)
Definition: ERF_RRTMGP_Interface.cpp:326
rrtmgp::mixing_ratio_to_cloud_mass
void mixing_ratio_to_cloud_mass(View1 const &mixing_ratio, View2 const &cloud_fraction, View3 const &rho, View4 const &dz, View5 const &cloud_mass)
Definition: ERF_RRTMGP_Utils.H:12

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::iMultiFab *  lmask,
amrex::MultiFab *  t_surf,
amrex::Vector< amrex::MultiFab * > &  lsm_input_ptrs,
amrex::MultiFab *  qheating_rates,
amrex::MultiFab *  rad_fluxes,
amrex::MultiFab *  z_phys,
amrex::MultiFab *  lat,
amrex::MultiFab *  lon 
)
174 {
175  // Set data members that may change
176  m_lev = level;
177  m_step = step;
178  m_time = time;
179  m_dt = dt;
180  m_geom = geom;
181  m_cons_in = cons_in;
182  m_qheating_rates = qheating_rates;
183  m_rad_fluxes = rad_fluxes;
184  m_z_phys = z_phys;
185  m_lat = lat;
186  m_lon = lon;
187 
188  // Update the day and month
189  time_t timestamp = time_t(time);
190  struct tm *timeinfo = gmtime(&timestamp);
191  if (m_fixed_orbital_year) {
192  m_orbital_mon = timeinfo->tm_mon + 1;
193  m_orbital_day = timeinfo->tm_mday;
194  m_orbital_sec = timeinfo->tm_hour*3600 + timeinfo->tm_min*60 + timeinfo->tm_sec;
195  } else {
196  m_orbital_year = timeinfo->tm_year + 1900;
197  m_orbital_mon = timeinfo->tm_mon + 1;
198  m_orbital_day = timeinfo->tm_mday;
199  m_orbital_sec = timeinfo->tm_hour*3600 + timeinfo->tm_min*60 + timeinfo->tm_sec;
200  }
201 
202  // Only allocate and proceed if we are going to update radiation
203  m_update_rad = false;
204  if (m_rad_freq_in_steps > 0) { m_update_rad = ( (m_step == 0) || (m_step % m_rad_freq_in_steps == 0) ); }
205 
206  if (m_update_rad) {
207  // Call to Init() has set the dimensions: ncol & nlay
208 
209  // Allocate the buffer arrays
210  alloc_buffers();
211 
212  // Fill the KOKKOS Views from AMReX MFs
213  mf_to_kokkos_buffers(lmask, t_surf, lsm_input_ptrs);
214 
215  // Initialize datalog MF on first step
216  if (m_first_step) {
217  m_first_step = false;
218  if (datalog_int > 0) {
219  datalog_mf.define(cons_in->boxArray(), cons_in->DistributionMap(), 25, 0);
220  datalog_mf.setVal(0.0);
221  }
222  }
223  }
224 }
Radiation::m_step
int m_step
Definition: ERF_Radiation.H:220
Radiation::mf_to_kokkos_buffers
void mf_to_kokkos_buffers(amrex::iMultiFab *lmask, amrex::MultiFab *t_surf, amrex::Vector< amrex::MultiFab * > &lsm_input_ptrs)
Definition: ERF_Radiation.cpp:469
Radiation::m_first_step
bool m_first_step
Definition: ERF_Radiation.H:240
Radiation::alloc_buffers
void alloc_buffers()
Definition: ERF_Radiation.cpp:227
Radiation::m_time
amrex::Real m_time
Definition: ERF_Radiation.H:223

Referenced by Run().

Here is the caller graph for this function:

◆ write_rrtmgp_fluxes()

void Radiation::write_rrtmgp_fluxes ( )
761 {
762  Table2D<Real,Order::C> sw_flux_up_tab(sw_flux_up.data(), {0,0}, {static_cast<int>(sw_flux_up.extent(0)),static_cast<int>(sw_flux_up.extent(1))});
763  Table2D<Real,Order::C> sw_flux_dn_tab(sw_flux_dn.data(), {0,0}, {static_cast<int>(sw_flux_dn.extent(0)),static_cast<int>(sw_flux_dn.extent(1))});
764  Table2D<Real,Order::C> sw_flux_dn_dir_tab(sw_flux_dn_dir.data(), {0,0}, {static_cast<int>(sw_flux_dn_dir.extent(0)),static_cast<int>(sw_flux_dn_dir.extent(1))});
765  Table2D<Real,Order::C> lw_flux_up_tab(lw_flux_up.data(), {0,0}, {static_cast<int>(lw_flux_up.extent(0)),static_cast<int>(lw_flux_up.extent(1))});
766  Table2D<Real,Order::C> lw_flux_dn_tab(lw_flux_dn.data(), {0,0}, {static_cast<int>(lw_flux_dn.extent(0)),static_cast<int>(lw_flux_dn.extent(1))});
767 
768  int n_fluxes = 5;
769  MultiFab mf_flux(m_cons_in->boxArray(), m_cons_in->DistributionMap(), n_fluxes, 0);
770 
771  for (MFIter mfi(mf_flux); mfi.isValid(); ++mfi) {
772  const auto& vbx = mfi.validbox();
773  const int nx = vbx.length(0);
774  const int imin = vbx.smallEnd(0);
775  const int jmin = vbx.smallEnd(1);
776  const int offset = m_col_offsets[mfi.index()];
777  const Array4<Real>& dst_arr = mf_flux.array(mfi);
778  ParallelFor(vbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
779  {
780  // map [i,j,k] 0-based to [icol, ilay] 0-based
781  const int icol = (j-jmin)*nx + (i-imin) + offset;
782  const int ilay = k;
783 
784  // SW and LW fluxes
785  dst_arr(i,j,k,0) = sw_flux_up_tab(icol,ilay);
786  dst_arr(i,j,k,1) = sw_flux_dn_tab(icol,ilay);
787  dst_arr(i,j,k,2) = sw_flux_dn_dir_tab(icol,ilay);
788  dst_arr(i,j,k,3) = lw_flux_up_tab(icol,ilay);
789  dst_arr(i,j,k,4) = lw_flux_dn_tab(icol,ilay);
790  });
791  }
792 
793 
794  std::string plotfilename = amrex::Concatenate("plt_rad", m_step, 5);
795  Vector<std::string> flux_names = {"sw_flux_up", "sw_flux_dn", "sw_flux_dir",
796  "lw_flux_up", "lw_flux_dn"};
797  WriteSingleLevelPlotfile(plotfilename, mf_flux, flux_names, m_geom, m_time, m_step);
798 }
Here is the call graph for this function:

◆ WriteDataLog()

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

Implements IRadiation.

907 {
908  constexpr int datwidth = 14;
909  constexpr int datprecision = 9;
910  constexpr int timeprecision = 13;
911 
912  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;
913  // Clear sky
914  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;
915  // Clean sky
916  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;
917  // Clean clear sky
918  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;
919 
920 
921  auto domain = m_geom.Domain();
922  h_avg_radqrsw = sumToLine(datalog_mf, 0, 1, domain, 2);
923  h_avg_radqrlw = sumToLine(datalog_mf, 1, 1, domain, 2);
924  h_avg_sw_up = sumToLine(datalog_mf, 2, 1, domain, 2);
925  h_avg_sw_dn = sumToLine(datalog_mf, 3, 1, domain, 2);
926  h_avg_sw_dn_dir = sumToLine(datalog_mf, 4, 1, domain, 2);
927  h_avg_lw_up = sumToLine(datalog_mf, 5, 1, domain, 2);
928  h_avg_lw_dn = sumToLine(datalog_mf, 6, 1, domain, 2);
929  h_avg_zenith = sumToLine(datalog_mf, 7, 1, domain, 2);
930 
931  h_avg_radqrcsw = sumToLine(datalog_mf, 8, 1, domain, 2);
932  h_avg_radqrclw = sumToLine(datalog_mf, 9, 1, domain, 2);
933  h_avg_sw_clr_up = sumToLine(datalog_mf, 10, 1, domain, 2);
934  h_avg_sw_clr_dn = sumToLine(datalog_mf, 11, 1, domain, 2);
935  h_avg_sw_clr_dn_dir = sumToLine(datalog_mf, 12, 1, domain, 2);
936  h_avg_lw_clr_up = sumToLine(datalog_mf, 13, 1, domain, 2);
937  h_avg_lw_clr_dn = sumToLine(datalog_mf, 14, 1, domain, 2);
938 
939  if (m_extra_clnsky_diag) {
940  h_avg_sw_cln_up = sumToLine(datalog_mf, 15, 1, domain, 2);
941  h_avg_sw_cln_dn = sumToLine(datalog_mf, 16, 1, domain, 2);
942  h_avg_sw_cln_dn_dir = sumToLine(datalog_mf, 17, 1, domain, 2);
943  h_avg_lw_cln_up = sumToLine(datalog_mf, 18, 1, domain, 2);
944  h_avg_lw_cln_dn = sumToLine(datalog_mf, 19, 1, domain, 2);
945  }
946 
947  if (m_extra_clnclrsky_diag) {
948  h_avg_sw_clnclr_up = sumToLine(datalog_mf, 20, 1, domain, 2);
949  h_avg_sw_clnclr_dn = sumToLine(datalog_mf, 21, 1, domain, 2);
950  h_avg_sw_clnclr_dn_dir = sumToLine(datalog_mf, 22, 1, domain, 2);
951  h_avg_lw_clnclr_up = sumToLine(datalog_mf, 23, 1, domain, 2);
952  h_avg_lw_clnclr_dn = sumToLine(datalog_mf, 24, 1, domain, 2);
953  }
954 
955  Real area_z = static_cast<Real>(domain.length(0)*domain.length(1));
956  int nz = domain.length(2);
957  for (int k = 0; k < nz; k++) {
958  h_avg_radqrsw[k] /= area_z;
959  h_avg_radqrlw[k] /= area_z;
960  h_avg_sw_up[k] /= area_z;
961  h_avg_sw_dn[k] /= area_z;
962  h_avg_sw_dn_dir[k] /= area_z;
963  h_avg_lw_up[k] /= area_z;
964  h_avg_lw_dn[k] /= area_z;
965  h_avg_zenith[k] /= area_z;
966 
967  h_avg_radqrcsw[k] /= area_z;
968  h_avg_radqrclw[k] /= area_z;
969  h_avg_sw_clr_up[k] /= area_z;
970  h_avg_sw_clr_dn[k] /= area_z;
971  h_avg_sw_clr_dn_dir[k] /= area_z;
972  h_avg_lw_clr_up[k] /= area_z;
973  h_avg_lw_clr_dn[k] /= area_z;
974  }
975 
976  if (m_extra_clnsky_diag) {
977  for (int k = 0; k < nz; k++) {
978  h_avg_sw_cln_up[k] /= area_z;
979  h_avg_sw_cln_dn[k] /= area_z;
980  h_avg_sw_cln_dn_dir[k] /= area_z;
981  h_avg_lw_cln_up[k] /= area_z;
982  h_avg_lw_cln_dn[k] /= area_z;
983  }
984  }
985 
986  if (m_extra_clnclrsky_diag) {
987  for (int k = 0; k < nz; k++) {
988  h_avg_sw_clnclr_up[k] /= area_z;
989  h_avg_sw_clnclr_dn[k] /= area_z;
990  h_avg_sw_clnclr_dn_dir[k] /= area_z;
991  h_avg_lw_clnclr_up[k] /= area_z;
992  h_avg_lw_clnclr_dn[k] /= area_z;
993  }
994  }
995 
996  if (ParallelDescriptor::IOProcessor()) {
997  std::ostream& log = *datalog;
998  if (log.good()) {
999 
1000  for (int k = 0; k < nz; k++)
1001  {
1002  Real z = k * m_geom.CellSize(2);
1003  log << std::setw(datwidth) << std::setprecision(timeprecision) << time << " "
1004  << std::setw(datwidth) << std::setprecision(datprecision) << z << " "
1005  << h_avg_radqrsw[k] << " " << h_avg_radqrlw[k] << " " << h_avg_sw_up[k] << " "
1006  << h_avg_sw_dn[k] << " " << h_avg_sw_dn_dir[k] << " " << h_avg_lw_up[k] << " "
1007  << h_avg_lw_dn[k] << " " << h_avg_zenith[k] << " "
1008  << h_avg_radqrcsw[k] << " " << h_avg_radqrclw[k] << " " << h_avg_sw_clr_up[k] << " "
1009  << h_avg_sw_clr_dn[k] << " " << h_avg_sw_clr_dn_dir[k] << " " << h_avg_lw_clr_up[k] << " "
1010  << h_avg_lw_clr_dn[k] << " ";
1011  if (m_extra_clnsky_diag) {
1012  log << h_avg_sw_cln_up[k] << " " << h_avg_sw_cln_dn[k] << " " << h_avg_sw_cln_dn_dir[k] << " "
1013  << h_avg_lw_cln_up[k] << " " << h_avg_lw_cln_dn[k] << " ";
1014  } else {
1015  log << zero << " " << zero << " " << zero << " " << zero << " " << zero << " ";
1016  }
1017 
1018  if (m_extra_clnclrsky_diag) {
1019  log << h_avg_sw_clnclr_up[k] << " " << h_avg_sw_clnclr_dn[k] << " " << h_avg_sw_clnclr_dn_dir[k] << " "
1020  << h_avg_lw_clnclr_up[k] << " " << h_avg_lw_clnclr_dn[k] << std::endl;
1021  } else {
1022  log << zero << " " << zero << " " << zero << " " << zero << " " << zero << std::endl;
1023  }
1024  }
1025  // Write top face values
1026  Real z = nz * m_geom.CellSize(2);
1027  log << std::setw(datwidth) << std::setprecision(timeprecision) << time << " "
1028  << std::setw(datwidth) << std::setprecision(datprecision) << z << " "
1029  << zero << " " << zero << " " << zero << " " << zero << " " << zero << " " << zero << " "
1030  << zero << " " << zero << " "
1031  << zero << " " << zero << " " << zero << " " << zero << " " << zero << " " << zero << " "
1032  << zero << " "
1033  << zero << " " << zero << " " << zero << " " << zero << " " << zero << " "
1034  << zero << " " << zero << " " << zero << " " << zero << " " << zero
1035  << std::endl;
1036  }
1037  }
1038 }
Coord::z
@ z
IRadiation::datalog
std::unique_ptr< std::fstream > datalog
Definition: ERF_RadiationInterface.H:85

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

◆ cldfrac_tot

real2d_k Radiation::cldfrac_tot
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

◆ gas_names_offset

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

◆ iwp

real2d_k Radiation::iwp
private

◆ lat

real1d_k Radiation::lat
private

◆ lon

real1d_k Radiation::lon
private

◆ 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 = amrex::Real(1807.851e-9)
private

◆ m_co2vmr

amrex::Real Radiation::m_co2vmr = amrex::Real(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 = amrex::Real(1.0e-7)
private

◆ m_do_aerosol_rad

bool Radiation::m_do_aerosol_rad = false
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 = -amrex::Real(9999.)
private

◆ m_fixed_total_solar_irradiance

amrex::Real Radiation::m_fixed_total_solar_irradiance = -amrex::Real(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 = amrex::Real(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 = -amrex::Real(98.555183)
private

◆ m_lsm

bool Radiation::m_lsm = false
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
private
Initial value:
= {"cos_zenith_angle" , "sw_flux_dn" ,
"sw_flux_dn_dir_vis", "sw_flux_dn_dir_nir",
"sw_flux_dn_dif_vis", "sw_flux_dn_dif_nir",
"lw_flux_dn"}

Referenced by get_lsm_output_varnames().

◆ 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:
= {amrex::Real(18.01528), amrex::Real(44.00950), amrex::Real(47.9982), amrex::Real(44.0128),
amrex::Real(28.01010), amrex::Real(16.04246), amrex::Real(31.9980), amrex::Real(28.0134)}

◆ m_n2ovmr

amrex::Real Radiation::m_n2ovmr = amrex::Real(323.141e-9)
private

◆ m_n2vmr

amrex::Real Radiation::m_n2vmr = amrex::Real(0.7906)
private

◆ m_ncol

int Radiation::m_ncol
private

Referenced by Init().

◆ m_ncol_chunk

int Radiation::m_ncol_chunk = 1024
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
private

◆ m_nlwgpts

int Radiation::m_nlwgpts
private

◆ m_nswbands

int Radiation::m_nswbands
private

◆ m_nswgpts

int Radiation::m_nswgpts
private

◆ m_o2vmr

amrex::Real Radiation::m_o2vmr = amrex::Real(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

Referenced by rad_run_impl().

◆ m_orbital_eccen

amrex::Real Radiation::m_orbital_eccen = -amrex::Real(9999.)
private

◆ m_orbital_mon

int Radiation::m_orbital_mon = -9999
private

Referenced by rad_run_impl().

◆ m_orbital_mvelp

amrex::Real Radiation::m_orbital_mvelp = -amrex::Real(9999.)
private

◆ m_orbital_obliq

amrex::Real Radiation::m_orbital_obliq = -amrex::Real(9999.)
private

◆ m_orbital_sec

int Radiation::m_orbital_sec = -9999
private

Referenced by rad_run_impl().

◆ m_orbital_year

int Radiation::m_orbital_year = -9999
private

Referenced by rad_run_impl().

◆ m_qheating_rates

amrex::MultiFab* Radiation::m_qheating_rates = nullptr
private

◆ m_rad_fluxes

amrex::MultiFab* Radiation::m_rad_fluxes = nullptr
private

◆ m_rad_freq_in_steps

int Radiation::m_rad_freq_in_steps = 1
private

◆ m_rad_nvar

int Radiation::m_rad_nvar = 12
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_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-g256-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

◆ z_del

real2d_k Radiation::z_del
private
The documentation for this class was generated from the following files: