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, double &time, const double &dt, const amrex::BoxArray &ba, amrex::Geometry &geom, amrex::MultiFab *cons_in, amrex::iMultiFab *lmask, amrex::MultiFab *t_surf, const amrex::Vector< const amrex::MultiFab * > &lsm_input_ptrs, const 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, const bool force_update, amrex::Real &declin, amrex::Real &calday) override
 
bool radiation_updated () const override
 Reports whether the last radiation call updated its outputs. More...
 
void set_grids (int &level, int &step, double &time, const double &dt, const amrex::BoxArray &ba, amrex::Geometry &geom, amrex::MultiFab *cons_in, amrex::iMultiFab *lmask, amrex::MultiFab *t_surf, const amrex::Vector< const amrex::MultiFab * > &lsm_input_ptrs, amrex::MultiFab *qheating_rates, amrex::MultiFab *rad_fluxes, amrex::MultiFab *z_phys, amrex::MultiFab *lat, amrex::MultiFab *lon, const bool force_update)
 
void alloc_buffers ()
 
void dealloc_buffers ()
 
void mf_to_kokkos_buffers (amrex::iMultiFab *lmask, amrex::MultiFab *t_surf, const amrex::Vector< const amrex::MultiFab * > &lsm_input_ptrs)
 
void kokkos_buffers_to_mf (const amrex::Vector< amrex::MultiFab * > &lsm_output_ptrs)
 
void write_rrtmgp_fluxes ()
 
void initialize_impl ()
 
void run_impl ()
 
void finalize_impl (const amrex::Vector< amrex::MultiFab * > &lsm_output_ptrs)
 
void rad_run_impl (const 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
 
bool is_nested_patch () const override
 
void populateDatalogMF ()
 
virtual void WriteDataLog (const double &time) override
 
- Public Member Functions inherited from IRadiation
virtual ~IRadiation ()=default
 
void setupDataLog ()
 
void setDataLogFrequency (const int nstep)
 
bool hasDatalog ()
 

Private Attributes

bool m_is_nested_patch = false
 
int m_lev
 
int m_step
 
double m_time
 
double m_dt
 
amrex::Geometry m_geom
 
amrex::BoxArray m_ba
 
bool m_update_rad = false
 
bool m_rad_write_fluxes = false
 
bool m_moist = false
 
bool m_ice = false
 
int m_qi_comp = -1
 
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::Real m_rdOcp = RdoCp
 
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 m_lon_cons
 
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 m_declin = 0.0
 
amrex::Real m_calday = 0.0
 
int m_nswbands
 
int m_nlwbands
 
int m_nswgpts
 
int m_nlwgpts
 
int m_rad_freq_in_steps
 
int m_ncol_chunk_requested = 1024
 
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 
)
87 {
88  // Note that Kokkos is now initialized in main.cpp
89  m_rdOcp = sc.rdOcp;
90 
91  // Check if we have a valid moisture model
92  if (sc.moisture_type != MoistureType::None) { m_moist = true; }
93 
94  // Cloud-ice support follows the configured moisture-component mapping.
95  m_qi_comp = sc.moisture_indices.qi;
96  m_ice = (m_qi_comp >= 0);
97 
98  // Check if we have a land surface model enabled
99  if (sc.lsm_type != LandSurfaceType::None) { m_lsm = true; }
100 
101  // Construct parser object for following reads
102  ParmParse pp("erf");
103 
104  // Must specify a surface temp (LSM can overwrite)
105  pp.get("rad_t_sfc", m_rad_t_sfc);
106 
107  // SolverChoice reads the sun, site and update interval once for RRTMGP
108  // and the optional topographic surface correction.
109  const auto& solar = sc.rrtmgpSolarChoice;
110  m_rad_freq_in_steps = solar.radiation_interval;
111  m_lat_cons = solar.latitude;
112  m_lon_cons = solar.longitude;
113  m_fixed_solar_zenith_angle = solar.fixed_mu;
114 
115  // Get nvar if specified
116  pp.queryAdd("rad_nvar", m_rad_nvar);
117  AMREX_ALWAYS_ASSERT_WITH_MESSAGE(m_rad_nvar >= 0,
118  "erf.rad_nvar must be greater than 0. "
119  "It controls the amount of memory allocated for temporaries with RRTMGP; "
120  "a value of 0 would allocate no memory.");
121 
122  // Number of columns per RRTMGP chunk (controls peak GPU memory)
123  pp.queryAdd("rad_ncol_chunk", m_ncol_chunk_requested);
124  AMREX_ALWAYS_ASSERT_WITH_MESSAGE(m_ncol_chunk_requested > 0,
125  "erf.rad_ncol_chunk must be a positive integer (default 1024). "
126  "It controls the number of columns processed per RRTMGP kernel launch; "
127  "a value of 0 or negative would produce an infinite loop.");
128  m_ncol_chunk = m_ncol_chunk_requested;
129 
130  // Flag to write fluxes to plt file
131  pp.queryAdd("rad_write_fluxes", m_rad_write_fluxes);
132 
133  // Do MCICA subcolumn sampling
134  pp.queryAdd("rad_do_subcol_sampling", m_do_subcol_sampling);
135 
136  // Determine orbital year. If orbital_year is negative, use current year
137  // from timestamp for orbital year; if non-negative, use provided orbital year
138  // for duration of simulation. Note that this is keyed off the value itself,
139  // not off whether the input was present, so that a negative value defers to
140  // the timestamp as documented.
141  pp.queryAdd("rad_orbital_year", m_orbital_year);
142  m_fixed_orbital_year = (m_orbital_year >= 0);
143 
144  // Get orbital parameters from inputs file
145  pp.queryAdd("rad_orbital_eccentricity", m_orbital_eccen);
146  pp.queryAdd("rad_orbital_obliquity" , m_orbital_obliq);
147  pp.queryAdd("rad_orbital_mvelp" , m_orbital_mvelp);
148 
149  // Value for prescribing an invariant solar constant (i.e. total solar irradiance at
150  // TOA). Used for idealized experiments such as RCE. Disabled when value is less than zero
151  pp.queryAdd("fixed_total_solar_irradiance", m_fixed_total_solar_irradiance);
152 
153  // The solar-input range checks live in RRTMGPSolarChoice::read. Surface
154  // temperature is still read and validated by this interface.
155  if (!std::isfinite(m_rad_t_sfc) || m_rad_t_sfc <= Real(0.0)) {
156  amrex::Abort("erf.rad_t_sfc = " + std::to_string(m_rad_t_sfc) +
157  " must be a positive temperature [K].");
158  }
159 
160  // Get prescribed surface values of greenhouse gases
161  pp.queryAdd("co2vmr", m_co2vmr);
162  pp.queryarr("o3vmr" , m_o3vmr );
163  pp.queryAdd("n2ovmr", m_n2ovmr);
164  pp.queryAdd("covmr" , m_covmr );
165  pp.queryAdd("ch4vmr", m_ch4vmr);
166  pp.queryAdd("o2vmr" , m_o2vmr );
167  pp.queryAdd("n2vmr" , m_n2vmr );
168 
169  // Aerosol forcing hook (not implemented). The aerosol arrays that used to be
170  // passed through rrtmgp_main were never populated with real data, so enabling
171  // this flag only ever multiplied radiation by zero aerosol optics. The hook is
172  // kept so a future SPA/prescribed-aerosol scheme can wire in without touching
173  // the ParmParse surface.
174  pp.queryAdd("rad_do_aerosol", m_do_aerosol_rad);
175  if (m_do_aerosol_rad) {
176  amrex::Abort("erf.rad_do_aerosol = true is not supported: aerosol forcing is "
177  "currently not implemented in the ERF RRTMGP interface. The hook "
178  "is retained for a future aerosol coupling; set rad_do_aerosol = "
179  "false (or remove it) to continue.");
180  }
181 
182  // Whether we do extra clean/clear sky calculations
183  pp.queryAdd("rad_extra_clnclrsky_diag", m_extra_clnclrsky_diag);
184  pp.queryAdd("rad_extra_clnsky_diag" , m_extra_clnsky_diag);
185 
186  // Parse path and file names
187  pp.queryAdd("rrtmgp_file_path" , rrtmgp_file_path);
188  pp.queryAdd("rrtmgp_coeffs_sw" , rrtmgp_coeffs_sw );
189  pp.queryAdd("rrtmgp_coeffs_lw" , rrtmgp_coeffs_lw );
190  pp.queryAdd("rrtmgp_cloud_optics_sw", rrtmgp_cloud_optics_sw);
191  pp.queryAdd("rrtmgp_cloud_optics_lw", rrtmgp_cloud_optics_lw);
192 
193  // Fail early, and with a message that names the missing files and the inputs that
194  // control them, rather than letting netCDF report a bare "No such file or directory"
195  // when the coefficients are opened just below (or, for the cloud optics files, much
196  // later inside rrtmgp_initialize). Every rank does this so that all of them abort.
197  check_rrtmgp_data_files(rrtmgp_file_path,
198  {{"rrtmgp_coeffs_sw" , rrtmgp_coeffs_sw },
199  {"rrtmgp_coeffs_lw" , rrtmgp_coeffs_lw },
200  {"rrtmgp_cloud_optics_sw", rrtmgp_cloud_optics_sw},
201  {"rrtmgp_cloud_optics_lw", rrtmgp_cloud_optics_lw}});
202 
203  // Append file names to path
204  rrtmgp_coeffs_file_sw = rrtmgp_file_path + "/" + rrtmgp_coeffs_sw;
205  rrtmgp_coeffs_file_lw = rrtmgp_file_path + "/" + rrtmgp_coeffs_lw;
206  rrtmgp_cloud_optics_file_sw = rrtmgp_file_path + "/" + rrtmgp_cloud_optics_sw;
207  rrtmgp_cloud_optics_file_lw = rrtmgp_file_path + "/" + rrtmgp_cloud_optics_lw;
208 
209  // Get dimensions from lookup data
210  if (ParallelDescriptor::IOProcessor()) {
211  auto ncf_sw = ncutils::NCFile::open(rrtmgp_coeffs_file_sw, NC_CLOBBER | NC_NETCDF4);
212  m_nswbands = ncf_sw.dim("bnd").len();
213  m_nswgpts = ncf_sw.dim("gpt").len();
214  ncf_sw.close();
215 
216  auto ncf_lw = ncutils::NCFile::open(rrtmgp_coeffs_file_lw, NC_CLOBBER | NC_NETCDF4);
217  m_nlwbands = ncf_lw.dim("bnd").len();
218  m_nlwgpts = ncf_lw.dim("gpt").len();
219  ncf_lw.close();
220  }
221  int ioproc = ParallelDescriptor::IOProcessorNumber(); // I/O rank
222  ParallelDescriptor::Bcast(&m_nswbands, 1, ioproc);
223  ParallelDescriptor::Bcast(&m_nlwbands, 1, ioproc);
224  ParallelDescriptor::Bcast(&m_nswgpts, 1, ioproc);
225  ParallelDescriptor::Bcast(&m_nlwgpts, 1, ioproc);
226 
227  // Output for user
228  if (lev == 0) {
229  Print() << "Radiation interface constructed:\n";
230  Print() << "========================================================\n";
231  Print() << "Coeff SW file: " << rrtmgp_coeffs_file_sw << "\n";
232  Print() << "Coeff LW file: " << rrtmgp_coeffs_file_lw << "\n";
233  Print() << "Cloud SW file: " << rrtmgp_cloud_optics_file_sw << "\n";
234  Print() << "Cloud LW file: " << rrtmgp_cloud_optics_file_lw << "\n";
235  Print() << "Number of short/longwave bands: "
236  << m_nswbands << " " << m_nlwbands << "\n";
237  Print() << "Number of short/longwave gauss points: "
238  << m_nswgpts << " " << m_nlwgpts << "\n";
239  Print() << "========================================================\n";
240  }
241 }
AMREX_ALWAYS_ASSERT_WITH_MESSAGE
AMREX_ALWAYS_ASSERT_WITH_MESSAGE(axis >=0 &&axis< AMREX_SPACEDIM, "prob.axis must be 0, 1 or 2")
pp
ParmParse pp("prob")
Real
amrex::Real Real
Definition: ERF_ShocInterface.H:19
Radiation::rrtmgp_coeffs_file_sw
std::string rrtmgp_coeffs_file_sw
Definition: ERF_Radiation.H:356
Radiation::rrtmgp_coeffs_sw
std::string rrtmgp_coeffs_sw
Definition: ERF_Radiation.H:352
Radiation::m_rad_freq_in_steps
int m_rad_freq_in_steps
Definition: ERF_Radiation.H:441
Radiation::m_lon_cons
amrex::Real m_lon_cons
Definition: ERF_Radiation.H:345
Radiation::m_nswbands
int m_nswbands
Definition: ERF_Radiation.H:435
Radiation::m_do_aerosol_rad
bool m_do_aerosol_rad
Definition: ERF_Radiation.H:399
Radiation::rrtmgp_coeffs_lw
std::string rrtmgp_coeffs_lw
Definition: ERF_Radiation.H:353
Radiation::m_moist
bool m_moist
Definition: ERF_Radiation.H:305
Radiation::rrtmgp_cloud_optics_file_lw
std::string rrtmgp_cloud_optics_file_lw
Definition: ERF_Radiation.H:359
Radiation::m_ncol_chunk_requested
int m_ncol_chunk_requested
Definition: ERF_Radiation.H:449
Radiation::m_lsm
bool m_lsm
Definition: ERF_Radiation.H:310
Radiation::m_do_subcol_sampling
bool m_do_subcol_sampling
Definition: ERF_Radiation.H:456
Radiation::m_rad_write_fluxes
bool m_rad_write_fluxes
Definition: ERF_Radiation.H:302
Radiation::m_qi_comp
int m_qi_comp
Definition: ERF_Radiation.H:307
Radiation::rrtmgp_cloud_optics_file_sw
std::string rrtmgp_cloud_optics_file_sw
Definition: ERF_Radiation.H:358
Radiation::m_orbital_mvelp
amrex::Real m_orbital_mvelp
Definition: ERF_Radiation.H:420
Radiation::m_o3vmr
amrex::Vector< amrex::Real > m_o3vmr
Definition: ERF_Radiation.H:370
Radiation::rrtmgp_cloud_optics_sw
std::string rrtmgp_cloud_optics_sw
Definition: ERF_Radiation.H:354
Radiation::m_nlwgpts
int m_nlwgpts
Definition: ERF_Radiation.H:438
Radiation::rrtmgp_cloud_optics_lw
std::string rrtmgp_cloud_optics_lw
Definition: ERF_Radiation.H:355
Radiation::m_co2vmr
amrex::Real m_co2vmr
Definition: ERF_Radiation.H:369
Radiation::m_extra_clnsky_diag
bool m_extra_clnsky_diag
Definition: ERF_Radiation.H:402
Radiation::m_lat_cons
amrex::Real m_lat_cons
Definition: ERF_Radiation.H:344
Radiation::m_fixed_total_solar_irradiance
amrex::Real m_fixed_total_solar_irradiance
Definition: ERF_Radiation.H:425
Radiation::m_o2vmr
amrex::Real m_o2vmr
Definition: ERF_Radiation.H:374
Radiation::m_n2ovmr
amrex::Real m_n2ovmr
Definition: ERF_Radiation.H:371
Radiation::m_rad_t_sfc
amrex::Real m_rad_t_sfc
Definition: ERF_Radiation.H:324
Radiation::rrtmgp_file_path
std::string rrtmgp_file_path
Definition: ERF_Radiation.H:351
Radiation::m_nlwbands
int m_nlwbands
Definition: ERF_Radiation.H:436
Radiation::m_orbital_eccen
amrex::Real m_orbital_eccen
Definition: ERF_Radiation.H:418
Radiation::m_covmr
amrex::Real m_covmr
Definition: ERF_Radiation.H:372
Radiation::m_ncol_chunk
int m_ncol_chunk
Definition: ERF_Radiation.H:450
Radiation::rrtmgp_coeffs_file_lw
std::string rrtmgp_coeffs_file_lw
Definition: ERF_Radiation.H:357
Radiation::m_ch4vmr
amrex::Real m_ch4vmr
Definition: ERF_Radiation.H:373
Radiation::m_ice
bool m_ice
Definition: ERF_Radiation.H:306
Radiation::m_fixed_solar_zenith_angle
amrex::Real m_fixed_solar_zenith_angle
Definition: ERF_Radiation.H:429
Radiation::m_orbital_obliq
amrex::Real m_orbital_obliq
Definition: ERF_Radiation.H:419
Radiation::m_n2vmr
amrex::Real m_n2vmr
Definition: ERF_Radiation.H:375
Radiation::m_fixed_orbital_year
bool m_fixed_orbital_year
Definition: ERF_Radiation.H:417
Radiation::m_nswgpts
int m_nswgpts
Definition: ERF_Radiation.H:437
Radiation::m_extra_clnclrsky_diag
bool m_extra_clnclrsky_diag
Definition: ERF_Radiation.H:403
Radiation::m_rdOcp
amrex::Real m_rdOcp
Definition: ERF_Radiation.H:325
Radiation::m_rad_nvar
int m_rad_nvar
Definition: ERF_Radiation.H:453
Radiation::m_orbital_year
int m_orbital_year
Definition: ERF_Radiation.H:408
LSM_Type::None
@ None
Definition: ERF_LSM_Types.H:6
MoistureComponentIndices::qi
int qi
cloud ice
Definition: ERF_DataStruct.H:264
SolverChoice::moisture_type
MoistureType moisture_type
Moisture or microphysics model.
Definition: ERF_DataStruct.H:2942
SolverChoice::rdOcp
amrex::Real rdOcp
Ratio of dry-air gas constant to c_p.
Definition: ERF_DataStruct.H:2738
SolverChoice::rrtmgpSolarChoice
RRTMGPSolarChoice rrtmgpSolarChoice
Definition: ERF_DataStruct.H:2623
SolverChoice::lsm_type
LandSurfaceType lsm_type
Land-surface model.
Definition: ERF_DataStruct.H:2953
SolverChoice::moisture_indices
MoistureComponentIndices moisture_indices
Index map of the moisture data carried by the active scheme: conserved-state components for the speci...
Definition: ERF_DataStruct.H:2993
Here is the call graph for this function:

◆ ~Radiation()

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

Member Function Documentation

◆ alloc_buffers()

void Radiation::alloc_buffers ( )
320 {
321  // 1d size (m_ngas)
322  const Real* mol_weight_gas_p = m_mol_weight_gas.data();
323  const std::string* gas_names_p = m_gas_names.data();
324  m_gas_mol_weights = real1d_k("m_gas_mol_weights", m_ngas);
325  realHost1d_k m_gas_mol_weights_h("m_gas_mol_weights_h", m_ngas);
326  gas_names_offset.clear(); gas_names_offset.resize(m_ngas);
327  std::string* gas_names_offset_p = gas_names_offset.data();
328  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Serial>(0, m_ngas),
329  [&] (int igas)
330  {
331  m_gas_mol_weights_h(igas) = mol_weight_gas_p[igas];
332  gas_names_offset_p[igas] = gas_names_p[igas];
333  });
334  Kokkos::deep_copy(m_gas_mol_weights, m_gas_mol_weights_h);
335 
336  // 1d size (1 or nlay)
337  m_o3_size = m_o3vmr.size();
338  AMREX_ALWAYS_ASSERT_WITH_MESSAGE(((m_o3_size==1) || (m_o3_size==m_nlay)),
339  "O3 VMR array must be length 1 or nlay");
340  Real* o3vmr_p = m_o3vmr.data();
341  o3_lay = real1d_k("o3_lay", m_o3_size);
342  realHost1d_k o3_lay_h("o3_lay_h", m_o3_size);
343  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Serial>(0, m_o3_size),
344  [&] (int io3)
345  {
346  o3_lay_h(io3) = o3vmr_p[io3];
347  });
348  Kokkos::deep_copy(o3_lay, o3_lay_h);
349 
350  // 1d size (ncol)
351  mu0 = real1d_k("mu0" , m_ncol);
352  sfc_alb_dir_vis = real1d_k("sfc_alb_dir_vis" , m_ncol);
353  sfc_alb_dir_nir = real1d_k("sfc_alb_dir_nir" , m_ncol);
354  sfc_alb_dif_vis = real1d_k("sfc_alb_dif_vis" , m_ncol);
355  sfc_alb_dif_nir = real1d_k("sfc_alb_dif_nir" , m_ncol);
356  sfc_flux_dir_vis = real1d_k("sfc_flux_dir_vis", m_ncol);
357  sfc_flux_dir_nir = real1d_k("sfc_flux_dir_nir", m_ncol);
358  sfc_flux_dif_vis = real1d_k("sfc_flux_dif_vis", m_ncol);
359  sfc_flux_dif_nir = real1d_k("sfc_flux_dif_nir", m_ncol);
360  lat = real1d_k("lat" , m_ncol);
361  lon = real1d_k("lon" , m_ncol);
362  sfc_emis = real1d_k("sfc_emis" , m_ncol);
363  t_sfc = real1d_k("t_sfc" , m_ncol);
364  lw_src = real1d_k("lw_src" , m_ncol);
365 
366  // 2d size (ncol, nlay)
367  r_lay = real2d_k("r_lay" , m_ncol, m_nlay);
368  p_lay = real2d_k("p_lay" , m_ncol, m_nlay);
369  t_lay = real2d_k("t_lay" , m_ncol, m_nlay);
370  z_del = real2d_k("z_del" , m_ncol, m_nlay);
371  qv_lay = real2d_k("qv" , m_ncol, m_nlay);
372  qc_lay = real2d_k("qc" , m_ncol, m_nlay);
373  qi_lay = real2d_k("qi" , m_ncol, m_nlay);
374  cldfrac_tot = real2d_k("cldfrac_tot" , m_ncol, m_nlay);
375  eff_radius_qc = real2d_k("eff_radius_qc", m_ncol, m_nlay);
376  eff_radius_qi = real2d_k("eff_radius_qi", m_ncol, m_nlay);
377  lwp = real2d_k("lwp" , m_ncol, m_nlay);
378  iwp = real2d_k("iwp" , m_ncol, m_nlay);
379  sw_heating = real2d_k("sw_heating" , m_ncol, m_nlay);
380  lw_heating = real2d_k("lw_heating" , m_ncol, m_nlay);
381  if (datalog_int > 0) {
382  sw_clrsky_heating = real2d_k("sw_clrsky_heating", m_ncol, m_nlay);
383  lw_clrsky_heating = real2d_k("lw_clrsky_heating", m_ncol, m_nlay);
384  }
385 
386  // 2d size (ncol, nlay+1)
387  d_tint = real2d_k("d_tint" , m_ncol, m_nlay+1);
388  p_lev = real2d_k("p_lev" , m_ncol, m_nlay+1);
389  t_lev = real2d_k("t_lev" , m_ncol, m_nlay+1);
390 
391  sw_flux_up = real2d_k("sw_flux_up" , m_ncol, m_nlay+1);
392  sw_flux_dn = real2d_k("sw_flux_dn" , m_ncol, m_nlay+1);
393  sw_flux_dn_dir = real2d_k("sw_flux_dn_dir" , m_ncol, m_nlay+1);
394 
395  lw_flux_up = real2d_k("lw_flux_up" , m_ncol, m_nlay+1);
396  lw_flux_dn = real2d_k("lw_flux_dn" , m_ncol, m_nlay+1);
397 
398  // Clear-sky flux arrays are always needed
399  if (datalog_int > 0) {
400  sw_clrsky_flux_up = real2d_k("sw_clrsky_flux_up" , m_ncol, m_nlay+1);
401  sw_clrsky_flux_dn = real2d_k("sw_clrsky_flux_dn" , m_ncol, m_nlay+1);
402  sw_clrsky_flux_dn_dir = real2d_k("sw_clrsky_flux_dn_dir", m_ncol, m_nlay+1);
403  lw_clrsky_flux_up = real2d_k("lw_clrsky_flux_up" , m_ncol, m_nlay+1);
404  lw_clrsky_flux_dn = real2d_k("lw_clrsky_flux_dn" , m_ncol, m_nlay+1);
405  } else {
406  // Use m_ncol_chunk_requested to prevent pool shrinkage after regrid
407  sw_clrsky_flux_up = real2d_k("sw_clrsky_flux_up" , m_ncol_chunk_requested, m_nlay+1);
408  sw_clrsky_flux_dn = real2d_k("sw_clrsky_flux_dn" , m_ncol_chunk_requested, m_nlay+1);
409  sw_clrsky_flux_dn_dir = real2d_k("sw_clrsky_flux_dn_dir", m_ncol_chunk_requested, m_nlay+1);
410  lw_clrsky_flux_up = real2d_k("lw_clrsky_flux_up" , m_ncol_chunk_requested, m_nlay+1);
411  lw_clrsky_flux_dn = real2d_k("lw_clrsky_flux_dn" , m_ncol_chunk_requested, m_nlay+1);
412  }
413 
414  // Clean-clear-sky diagnostic fluxes (only when enabled)
415  if (m_extra_clnclrsky_diag) {
416  sw_clnclrsky_flux_up = real2d_k("sw_clnclrsky_flux_up" , m_ncol, m_nlay+1);
417  sw_clnclrsky_flux_dn = real2d_k("sw_clnclrsky_flux_dn" , m_ncol, m_nlay+1);
418  sw_clnclrsky_flux_dn_dir = real2d_k("sw_clnclrsky_flux_dn_dir", m_ncol, m_nlay+1);
419  lw_clnclrsky_flux_up = real2d_k("lw_clnclrsky_flux_up" , m_ncol, m_nlay+1);
420  lw_clnclrsky_flux_dn = real2d_k("lw_clnclrsky_flux_dn" , m_ncol, m_nlay+1);
421  } else {
422  sw_clnclrsky_flux_up = real2d_k("sw_clnclrsky_flux_up" , 1, 1);
423  sw_clnclrsky_flux_dn = real2d_k("sw_clnclrsky_flux_dn" , 1, 1);
424  sw_clnclrsky_flux_dn_dir = real2d_k("sw_clnclrsky_flux_dn_dir", 1, 1);
425  lw_clnclrsky_flux_up = real2d_k("lw_clnclrsky_flux_up" , 1, 1);
426  lw_clnclrsky_flux_dn = real2d_k("lw_clnclrsky_flux_dn" , 1, 1);
427  }
428 
429  // Clean-sky diagnostic fluxes (only when enabled)
430  if (m_extra_clnsky_diag) {
431  sw_clnsky_flux_up = real2d_k("sw_clnsky_flux_up" , m_ncol, m_nlay+1);
432  sw_clnsky_flux_dn = real2d_k("sw_clnsky_flux_dn" , m_ncol, m_nlay+1);
433  sw_clnsky_flux_dn_dir = real2d_k("sw_clnsky_flux_dn_dir" , m_ncol, m_nlay+1);
434  lw_clnsky_flux_up = real2d_k("lw_clnsky_flux_up" , m_ncol, m_nlay+1);
435  lw_clnsky_flux_dn = real2d_k("lw_clnsky_flux_dn" , m_ncol, m_nlay+1);
436  } else {
437  sw_clnsky_flux_up = real2d_k("sw_clnsky_flux_up" , 1, 1);
438  sw_clnsky_flux_dn = real2d_k("sw_clnsky_flux_dn" , 1, 1);
439  sw_clnsky_flux_dn_dir = real2d_k("sw_clnsky_flux_dn_dir" , 1, 1);
440  lw_clnsky_flux_up = real2d_k("lw_clnsky_flux_up" , 1, 1);
441  lw_clnsky_flux_dn = real2d_k("lw_clnsky_flux_dn" , 1, 1);
442  }
443 
444  // 3d size (ncol_chunk, nlay+1, nswbands)
445  // Use m_ncol_chunk_requested to prevent pool shrinkage after regrid
446  sw_bnd_flux_up = real3d_k("sw_bnd_flux_up" , m_ncol_chunk_requested, m_nlay+1, m_nswbands);
447  sw_bnd_flux_dn = real3d_k("sw_bnd_flux_dn" , m_ncol_chunk_requested, m_nlay+1, m_nswbands);
448  sw_bnd_flux_dir = real3d_k("sw_bnd_flux_dir", m_ncol_chunk_requested, m_nlay+1, m_nswbands);
449  sw_bnd_flux_dif = real3d_k("sw_bnd_flux_dif", m_ncol_chunk_requested, m_nlay+1, m_nswbands);
450 
451  // 3d size (ncol_chunk, nlay+1, nlwbands)
452  // Use m_ncol_chunk_requested to prevent pool shrinkage after regrid
453  lw_bnd_flux_up = real3d_k("lw_bnd_flux_up" , m_ncol_chunk_requested, m_nlay+1, m_nlwbands);
454  lw_bnd_flux_dn = real3d_k("lw_bnd_flux_dn" , m_ncol_chunk_requested, m_nlay+1, m_nlwbands);
455 
456  // 2d size (ncol, nswbands)
457  sfc_alb_dir = real2d_k("sfc_alb_dir", m_ncol, m_nswbands);
458  sfc_alb_dif = real2d_k("sfc_alb_dif", m_ncol, m_nswbands);
459 
460  // Aerosol optical properties — allocated only when aerosol coupling is on.
461  // The flag gates allocation so today (coupling not implemented, abort fires
462  // in the constructor) these stay as empty Views and cost nothing. When a
463  // future aerosol scheme populates them, hook up the plumbing into
464  // rrtmgp_main as well.
465  if (m_do_aerosol_rad) {
466  aero_tau_sw = real3d_k("aero_tau_sw", m_ncol, m_nlay, m_nswbands);
467  aero_ssa_sw = real3d_k("aero_ssa_sw", m_ncol, m_nlay, m_nswbands);
468  aero_g_sw = real3d_k("aero_g_sw", m_ncol, m_nlay, m_nswbands);
469  aero_tau_lw = real3d_k("aero_tau_lw", m_ncol, m_nlay, m_nlwbands);
470  }
471 }
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
IRadiation::datalog_int
int datalog_int
Definition: ERF_RadiationInterface.H:105
Radiation::sw_bnd_flux_dn
real3d_k sw_bnd_flux_dn
Definition: ERF_Radiation.H:522
Radiation::lw_flux_up
real2d_k lw_flux_up
Definition: ERF_Radiation.H:502
Radiation::aero_tau_sw
real3d_k aero_tau_sw
Definition: ERF_Radiation.H:541
Radiation::m_o3_size
int m_o3_size
Definition: ERF_Radiation.H:379
Radiation::sw_bnd_flux_dir
real3d_k sw_bnd_flux_dir
Definition: ERF_Radiation.H:523
Radiation::sw_clnsky_flux_dn
real2d_k sw_clnsky_flux_dn
Definition: ERF_Radiation.H:511
Radiation::d_tint
real2d_k d_tint
Definition: ERF_Radiation.H:496
Radiation::lw_clnclrsky_flux_dn
real2d_k lw_clnclrsky_flux_dn
Definition: ERF_Radiation.H:514
Radiation::lwp
real2d_k lwp
Definition: ERF_Radiation.H:488
Radiation::lw_src
real1d_k lw_src
Definition: ERF_Radiation.H:475
Radiation::eff_radius_qi
real2d_k eff_radius_qi
Definition: ERF_Radiation.H:487
Radiation::m_gas_mol_weights
real1d_k m_gas_mol_weights
Definition: ERF_Radiation.H:380
Radiation::sw_heating
real2d_k sw_heating
Definition: ERF_Radiation.H:490
Radiation::lw_bnd_flux_dn
real3d_k lw_bnd_flux_dn
Definition: ERF_Radiation.H:528
Radiation::sw_bnd_flux_up
real3d_k sw_bnd_flux_up
Definition: ERF_Radiation.H:521
Radiation::qv_lay
real2d_k qv_lay
Definition: ERF_Radiation.H:482
Radiation::sw_clnclrsky_flux_dn_dir
real2d_k sw_clnclrsky_flux_dn_dir
Definition: ERF_Radiation.H:506
Radiation::sfc_flux_dif_vis
real1d_k sfc_flux_dif_vis
Definition: ERF_Radiation.H:469
Radiation::lw_clnclrsky_flux_up
real2d_k lw_clnclrsky_flux_up
Definition: ERF_Radiation.H:513
Radiation::lat
real1d_k lat
Definition: ERF_Radiation.H:471
Radiation::qi_lay
real2d_k qi_lay
Definition: ERF_Radiation.H:484
Radiation::sw_clrsky_flux_up
real2d_k sw_clrsky_flux_up
Definition: ERF_Radiation.H:507
Radiation::t_lev
real2d_k t_lev
Definition: ERF_Radiation.H:498
Radiation::o3_lay
real1d_k o3_lay
Definition: ERF_Radiation.H:459
Radiation::sfc_alb_dif_vis
real1d_k sfc_alb_dif_vis
Definition: ERF_Radiation.H:465
Radiation::mu0
real1d_k mu0
Definition: ERF_Radiation.H:462
Radiation::cldfrac_tot
real2d_k cldfrac_tot
Definition: ERF_Radiation.H:485
Radiation::sfc_flux_dir_nir
real1d_k sfc_flux_dir_nir
Definition: ERF_Radiation.H:468
Radiation::sw_clnclrsky_flux_up
real2d_k sw_clnclrsky_flux_up
Definition: ERF_Radiation.H:504
Radiation::aero_g_sw
real3d_k aero_g_sw
Definition: ERF_Radiation.H:543
Radiation::sw_flux_up
real2d_k sw_flux_up
Definition: ERF_Radiation.H:499
Radiation::sw_bnd_flux_dif
real3d_k sw_bnd_flux_dif
Definition: ERF_Radiation.H:524
Radiation::sfc_alb_dif
real2d_k sfc_alb_dif
Definition: ERF_Radiation.H:532
Radiation::sfc_alb_dif_nir
real1d_k sfc_alb_dif_nir
Definition: ERF_Radiation.H:466
Radiation::lw_clnsky_flux_dn
real2d_k lw_clnsky_flux_dn
Definition: ERF_Radiation.H:518
Radiation::p_lay
real2d_k p_lay
Definition: ERF_Radiation.H:479
Radiation::r_lay
real2d_k r_lay
Definition: ERF_Radiation.H:478
Radiation::m_ncol
int m_ncol
Definition: ERF_Radiation.H:389
Radiation::sw_flux_dn_dir
real2d_k sw_flux_dn_dir
Definition: ERF_Radiation.H:501
Radiation::m_mol_weight_gas
const std::vector< amrex::Real > m_mol_weight_gas
Definition: ERF_Radiation.H:365
Radiation::gas_names_offset
std::vector< std::string > gas_names_offset
Definition: ERF_Radiation.H:381
Radiation::sw_clrsky_flux_dn
real2d_k sw_clrsky_flux_dn
Definition: ERF_Radiation.H:508
Radiation::aero_ssa_sw
real3d_k aero_ssa_sw
Definition: ERF_Radiation.H:542
Radiation::sw_clnsky_flux_dn_dir
real2d_k sw_clnsky_flux_dn_dir
Definition: ERF_Radiation.H:512
Radiation::qc_lay
real2d_k qc_lay
Definition: ERF_Radiation.H:483
Radiation::lw_clrsky_flux_up
real2d_k lw_clrsky_flux_up
Definition: ERF_Radiation.H:515
Radiation::sw_flux_dn
real2d_k sw_flux_dn
Definition: ERF_Radiation.H:500
Radiation::lw_clrsky_flux_dn
real2d_k lw_clrsky_flux_dn
Definition: ERF_Radiation.H:516
Radiation::z_del
real2d_k z_del
Definition: ERF_Radiation.H:481
Radiation::aero_tau_lw
real3d_k aero_tau_lw
Definition: ERF_Radiation.H:544
Radiation::lw_flux_dn
real2d_k lw_flux_dn
Definition: ERF_Radiation.H:503
Radiation::sw_clrsky_flux_dn_dir
real2d_k sw_clrsky_flux_dn_dir
Definition: ERF_Radiation.H:509
Radiation::sfc_flux_dif_nir
real1d_k sfc_flux_dif_nir
Definition: ERF_Radiation.H:470
Radiation::m_ngas
int m_ngas
Definition: ERF_Radiation.H:362
Radiation::lw_heating
real2d_k lw_heating
Definition: ERF_Radiation.H:491
Radiation::sfc_alb_dir_nir
real1d_k sfc_alb_dir_nir
Definition: ERF_Radiation.H:464
Radiation::lw_clnsky_flux_up
real2d_k lw_clnsky_flux_up
Definition: ERF_Radiation.H:517
Radiation::sfc_alb_dir
real2d_k sfc_alb_dir
Definition: ERF_Radiation.H:531
Radiation::lon
real1d_k lon
Definition: ERF_Radiation.H:472
Radiation::sfc_emis
real1d_k sfc_emis
Definition: ERF_Radiation.H:473
Radiation::sw_clnsky_flux_up
real2d_k sw_clnsky_flux_up
Definition: ERF_Radiation.H:510
Radiation::m_nlay
int m_nlay
Definition: ERF_Radiation.H:390
Radiation::lw_bnd_flux_up
real3d_k lw_bnd_flux_up
Definition: ERF_Radiation.H:527
Radiation::sfc_alb_dir_vis
real1d_k sfc_alb_dir_vis
Definition: ERF_Radiation.H:463
Radiation::m_gas_names
const std::vector< std::string > m_gas_names
Definition: ERF_Radiation.H:363
Radiation::sw_clrsky_heating
real2d_k sw_clrsky_heating
Definition: ERF_Radiation.H:492
Radiation::t_lay
real2d_k t_lay
Definition: ERF_Radiation.H:480
Radiation::sfc_flux_dir_vis
real1d_k sfc_flux_dir_vis
Definition: ERF_Radiation.H:467
Radiation::iwp
real2d_k iwp
Definition: ERF_Radiation.H:489
Radiation::p_lev
real2d_k p_lev
Definition: ERF_Radiation.H:497
Radiation::lw_clrsky_heating
real2d_k lw_clrsky_heating
Definition: ERF_Radiation.H:493
Radiation::eff_radius_qc
real2d_k eff_radius_qc
Definition: ERF_Radiation.H:486
Radiation::t_sfc
real1d_k t_sfc
Definition: ERF_Radiation.H:474
Radiation::sw_clnclrsky_flux_dn
real2d_k sw_clnclrsky_flux_dn
Definition: ERF_Radiation.H:505
Here is the call graph for this function:

◆ dealloc_buffers()

void Radiation::dealloc_buffers ( )
475 {
476  // 1d size (m_ngas)
477  m_gas_mol_weights = real1d_k();
478 
479  // 1d size (1 or nlay)
480  o3_lay = real1d_k();
481 
482  // 1d size (ncol)
483  mu0 = real1d_k();
484  sfc_alb_dir_vis = real1d_k();
485  sfc_alb_dir_nir = real1d_k();
486  sfc_alb_dif_vis = real1d_k();
487  sfc_alb_dif_nir = real1d_k();
488  sfc_flux_dir_vis = real1d_k();
489  sfc_flux_dir_nir = real1d_k();
490  sfc_flux_dif_vis = real1d_k();
491  sfc_flux_dif_nir = real1d_k();
492  lat = real1d_k();
493  lon = real1d_k();
494  sfc_emis = real1d_k();
495  t_sfc = real1d_k();
496  lw_src = real1d_k();
497 
498  // 2d size (ncol, nlay)
499  r_lay = real2d_k();
500  p_lay = real2d_k();
501  t_lay = real2d_k();
502  z_del = real2d_k();
503  qv_lay = real2d_k();
504  qc_lay = real2d_k();
505  qi_lay = real2d_k();
506  cldfrac_tot = real2d_k();
507  eff_radius_qc = real2d_k();
508  eff_radius_qi = real2d_k();
509  lwp = real2d_k();
510  iwp = real2d_k();
511  sw_heating = real2d_k();
512  lw_heating = real2d_k();
513  sw_clrsky_heating = real2d_k();
514  lw_clrsky_heating = real2d_k();
515 
516  // 2d size (ncol, nlay+1)
517  d_tint = real2d_k();
518  p_lev = real2d_k();
519  t_lev = real2d_k();
520  sw_flux_up = real2d_k();
521  sw_flux_dn = real2d_k();
522  sw_flux_dn_dir = real2d_k();
523  lw_flux_up = real2d_k();
524  lw_flux_dn = real2d_k();
525  sw_clnclrsky_flux_up = real2d_k();
526  sw_clnclrsky_flux_dn = real2d_k();
527  sw_clnclrsky_flux_dn_dir = real2d_k();
528  sw_clrsky_flux_up = real2d_k();
529  sw_clrsky_flux_dn = real2d_k();
530  sw_clrsky_flux_dn_dir = real2d_k();
531  sw_clnsky_flux_up = real2d_k();
532  sw_clnsky_flux_dn = real2d_k();
533  sw_clnsky_flux_dn_dir = real2d_k();
534  lw_clnclrsky_flux_up = real2d_k();
535  lw_clnclrsky_flux_dn = real2d_k();
536  lw_clrsky_flux_up = real2d_k();
537  lw_clrsky_flux_dn = real2d_k();
538  lw_clnsky_flux_up = real2d_k();
539  lw_clnsky_flux_dn = real2d_k();
540 
541  // 3d size (ncol, nlay+1, nswbands)
542  sw_bnd_flux_up = real3d_k();
543  sw_bnd_flux_dn = real3d_k();
544  sw_bnd_flux_dir = real3d_k();
545  sw_bnd_flux_dif = real3d_k();
546 
547  // 3d size (ncol, nlay+1, nlwbands)
548  lw_bnd_flux_up = real3d_k();
549  lw_bnd_flux_dn = real3d_k();
550 
551  // 2d size (ncol, nswbands)
552  sfc_alb_dir = real2d_k();
553  sfc_alb_dif = real2d_k();
554 
555  // Aerosol scaffolding (no-op unless m_do_aerosol_rad enabled allocation above)
556  aero_tau_sw = real3d_k();
557  aero_ssa_sw = real3d_k();
558  aero_g_sw = real3d_k();
559  aero_tau_lw = real3d_k();
560 }

◆ finalize_impl()

void Radiation::finalize_impl ( const amrex::Vector< amrex::MultiFab * > &  lsm_output_ptrs)
1512 {
1513  // Reset gas concentrations (k-dist data persists across steps)
1514  m_gas_concs.reset();
1515 
1516  // Fill the AMReX MFs from Kokkos Views
1517  kokkos_buffers_to_mf(lsm_output_ptrs);
1518 
1519  // Write fluxes if requested
1520  if (m_rad_write_fluxes) { write_rrtmgp_fluxes(); }
1521 
1522  // Fill output data for datalog before deallocating
1523  if (datalog_int > 0) {
1524  rrtmgp::compute_heating_rate(sw_clrsky_flux_up, sw_clrsky_flux_dn, r_lay, z_del, sw_clrsky_heating);
1525  rrtmgp::compute_heating_rate(lw_clrsky_flux_up, lw_clrsky_flux_dn, r_lay, z_del, lw_clrsky_heating);
1526  Kokkos::fence();
1527  populateDatalogMF();
1528  }
1529 
1530  // Deallocate the buffer arrays
1531  dealloc_buffers();
1532 }
Radiation::dealloc_buffers
void dealloc_buffers()
Definition: ERF_Radiation.cpp:474
Radiation::populateDatalogMF
void populateDatalogMF()
Definition: ERF_Radiation.cpp:948
Radiation::kokkos_buffers_to_mf
void kokkos_buffers_to_mf(const amrex::Vector< amrex::MultiFab * > &lsm_output_ptrs)
Definition: ERF_Radiation.cpp:808
Radiation::m_gas_concs
GasConcsK< amrex::Real, layout_t, KokkosDefaultDevice > m_gas_concs
Definition: ERF_Radiation.H:383
Radiation::write_rrtmgp_fluxes
void write_rrtmgp_fluxes()
Definition: ERF_Radiation.cpp:908
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.

245  {
246  return m_lsm_input_names;
247  }
Radiation::m_lsm_input_names
amrex::Vector< std::string > m_lsm_input_names
Definition: ERF_Radiation.H:313

◆ get_lsm_output_varnames()

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

Reimplemented from IRadiation.

253  {
254  return m_lsm_output_names;
255  }
Radiation::m_lsm_output_names
amrex::Vector< std::string > m_lsm_output_names
Definition: ERF_Radiation.H:318

◆ Init()

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

Implements IRadiation.

68  {
69  // Check for nested patches: fine levels that don't reach the model top
70  // These need special handling since radiation requires complete atmospheric columns
71  int klo = geom.Domain().smallEnd(2);
72  int khi = geom.Domain().bigEnd(2);
73 
74  // Detect nested patches: a nested fine level doesn't span the full domain vertically.
75  // Use ba.minimalBox() which gives the bounding box of all grids on this level.
76  // If that box doesn't reach the domain top or bottom, it's a nested patch.
77  amrex::Box minimal_box = ba.minimalBox();
78  bool is_nested_patch = (minimal_box.smallEnd(2) > klo) || (minimal_box.bigEnd(2) < khi);
79 
80  // Update the nested patch flag - must be set/cleared on every Init call
81  // so that levels that stop being nested after regrid will resume radiation computation
82  m_is_nested_patch = is_nested_patch;
83 
84  // Skip radiation on nested patches - heating rates will be interpolated from coarser level
85  if (is_nested_patch) {
86  return;
87  }
88 
89  // Reset vector of offsets for columnar data
90  m_nlay = geom.Domain().length(2);
91 
92  m_ncol = 0;
93  m_col_offsets.clear();
94  m_col_offsets.resize(int(ba.size()));
95  for (amrex::MFIter mfi(*cons_in); mfi.isValid(); ++mfi) {
96  const amrex::Box& vbx = mfi.validbox();
97  // This assertion catches true vertical MPI decomposition (individual boxes that don't
98  // span the full domain height). The nested patch case is handled above by returning early.
99  AMREX_ALWAYS_ASSERT_WITH_MESSAGE((klo == vbx.smallEnd(2)) &&
100  (khi == vbx.bigEnd(2)),
101  "Vertical decomposition with radiation is not allowed.");
102  int nx = vbx.length(0);
103  int ny = vbx.length(1);
104  m_col_offsets[mfi.index()] = m_ncol;
105  m_ncol += nx * ny;
106  }
107 
108  // Recompute the effective chunk size from the user's request rather than
109  // clamping the stored value in place. Init() is called again for every
110  // MakeNewLevelFromScratch / MakeNewLevelFromCoarse / RemakeLevel on the same
111  // Radiation object, so an in-place clamp could only ever shrink: a rank that
112  // owned no boxes at some Init (m_ncol == 0) would pin the chunk size at zero
113  // and then spin forever in the run_impl chunk loop once a regrid handed it
114  // real boxes. Deriving from the immutable request instead lets the chunk size
115  // grow back. It is zero only when m_ncol is zero, and a rank with no columns
116  // does no radiation work.
117  m_ncol_chunk = amrex::min(m_ncol, m_ncol_chunk_requested);
118 
119  // NOTE: the buffers are deliberately NOT allocated here. set_grids() allocates them
120  // at the top of every Run() that actually updates radiation, and finalize_impl()
121  // frees them again at the end of it, which is what keeps only one level's worth
122  // of RRTMGP working memory resident at a time (see RRTMGP_Memory_Reduction.md).
123  // Allocating here as well would hold every level's buffers from the moment that
124  // level is created until its first Run, so the whole hierarchy would be live
125  // simultaneously at startup -- the peak the chunking exists to avoid.
126  };
nx
const int nx
Definition: ERF_InitCustomPertVels_CloudChamber.H:14
ny
const int ny
Definition: ERF_InitCustomPertVels_CloudChamber.H:15
khi
const int khi
Definition: ERF_InitCustomPert_Bubble.H:25
klo
const int klo
Definition: ERF_InitCustomPert_KE.H:9
Radiation::is_nested_patch
bool is_nested_patch() const override
Definition: ERF_Radiation.H:258
Radiation::m_is_nested_patch
bool m_is_nested_patch
Definition: ERF_Radiation.H:278
Radiation::m_col_offsets
amrex::Vector< int > m_col_offsets
Definition: ERF_Radiation.H:393
Here is the call graph for this function:

◆ initialize_impl()

void Radiation::initialize_impl ( )
1190 {
1191  // Initialize gas concentrations for this step
1192  m_gas_concs.init(gas_names_offset, m_ncol, m_nlay);
1193 
1194  // Load k-distribution and cloud optics data only once.
1195  // These are static lookup tables that never change.
1196  // Size the memory pool for the requested chunk size (not the effective one, and
1197  // not min with the current m_ncol) so that the pool remains valid even if m_ncol
1198  // grows after regridding/load balancing. The pool is created once and never
1199  // resized, whereas the effective chunk size is recomputed at every Init() and is
1200  // bounded above by the request.
1201  if (!rrtmgp::initialized) {
1202  gas_concs_t gas_concs_pool;
1203  gas_concs_pool.init(gas_names_offset, m_ncol_chunk_requested, m_nlay);
1204  rrtmgp::rrtmgp_initialize(gas_concs_pool,
1205  rrtmgp_coeffs_file_sw , rrtmgp_coeffs_file_lw ,
1206  rrtmgp_cloud_optics_file_sw, rrtmgp_cloud_optics_file_lw,
1207  m_rad_nvar);
1208  gas_concs_pool.reset();
1209  }
1210 }
gas_concs_t
GasConcsK< RealT, layout_t, KokkosDefaultDevice > gas_concs_t
Definition: ERF_RRTMGP_Interface.H:31
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:235

Referenced by rad_run_impl().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ is_nested_patch()

bool Radiation::is_nested_patch ( ) const
inlineoverridevirtual

Reimplemented from IRadiation.

259  {
260  return m_is_nested_patch;
261  }

Referenced by Init().

Here is the caller graph for this function:

◆ kokkos_buffers_to_mf()

void Radiation::kokkos_buffers_to_mf ( const amrex::Vector< amrex::MultiFab * > &  lsm_output_ptrs)
809 {
810  // The heating rates and fluxes read below were written by Kokkos kernels in run_impl().
811  // Kokkos launches on its own default instance while the ParallelFors here launch on
812  // amrex::Gpu::gpuStream(), and nothing orders the consumer against the producer: MFIter
813  // synchronizes the streams it used, but only after its own kernels, which is too late.
814  // This is the same cross-stream race that made radqrclw vary run to run in the datalog
815  // path (see section 7 of RRTMGP_Memory_Reduction.md); that fence guarded one call site,
816  // this one guards the hand-off that feeds qheating_rates and rad_fluxes back into the
817  // solution. No-op on a CPU build.
818  Kokkos::fence();
819 
820  // Heating rate, fluxes, zenith, lsm ptrs
821 
822  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))});
823  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))});
824  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))});
825  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))});
826  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))});
827  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))});
828  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))});
829 
830  TableData<Real,1> sfc_flux_sw_dn; sfc_flux_sw_dn.resize({0}, {static_cast<int>(sw_flux_dn.extent(0))});
831  TableData<Real,1> sfc_flux_lw_dn; sfc_flux_lw_dn.resize({0}, {static_cast<int>(lw_flux_dn.extent(0))});
832  Table1D<Real> sfc_flux_sw_dn_tab = sfc_flux_sw_dn.table();
833  Table1D<Real> sfc_flux_lw_dn_tab = sfc_flux_lw_dn.table();
834  Table1D<Real> sfc_flux_sw_dir_vis_tab(sfc_flux_dir_vis.data(), {0}, {static_cast<int>(sfc_flux_dir_vis.extent(0))});
835  Table1D<Real> sfc_flux_sw_dir_nir_tab(sfc_flux_dir_nir.data(), {0}, {static_cast<int>(sfc_flux_dir_nir.extent(0))});
836  Table1D<Real> sfc_flux_sw_dif_vis_tab(sfc_flux_dif_vis.data(), {0}, {static_cast<int>(sfc_flux_dif_vis.extent(0))});
837  Table1D<Real> sfc_flux_sw_dif_nir_tab(sfc_flux_dif_nir.data(), {0}, {static_cast<int>(sfc_flux_dif_nir.extent(0))});
838  Table1D<Real> mu0_tab(mu0.data(), {0}, {static_cast<int>(mu0.extent(0))});
839  Vector<Table1D<Real>> rrtmgp_out_vars = {mu0_tab , sfc_flux_sw_dn_tab ,
840  sfc_flux_sw_dir_vis_tab, sfc_flux_sw_dir_nir_tab,
841  sfc_flux_sw_dif_vis_tab, sfc_flux_sw_dif_nir_tab,
842  sfc_flux_lw_dn_tab };
843 
844  const Real rdOcp = m_rdOcp;
845  for (MFIter mfi(*m_cons_in); mfi.isValid(); ++mfi) {
846  const auto& vbx = mfi.validbox();
847  const auto& sbx = makeSlab(vbx,2,vbx.smallEnd(2));
848  const int nx = vbx.length(0);
849  const int imin = vbx.smallEnd(0);
850  const int jmin = vbx.smallEnd(1);
851  const int ktop = vbx.bigEnd(2);
852  const int offset = m_col_offsets[mfi.index()];
853  const Array4<Real>& q_arr = m_qheating_rates->array(mfi);
854  const Array4<Real>& f_arr = m_rad_fluxes->array(mfi);
855  ParallelFor(vbx, [=]
856  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  // Temperature heating rate for SW and LW
863  q_arr(i,j,k,0) = sw_heating_tab(icol,ilay);
864  q_arr(i,j,k,1) = lw_heating_tab(icol,ilay);
865 
866  // Convert the dT/dz to dTheta/dz
867  Real iexner = rrtmgp::inverse_exner(Real(p_lay_tab(icol,ilay)), rdOcp);
868  q_arr(i,j,k,0) *= iexner;
869  q_arr(i,j,k,1) *= iexner;
870 
871  // Populate the fluxes: level ilay is the lower interface of
872  // layer k, and the top-of-atmosphere level nlay goes into the
873  // z-ghost cell above the top layer (rad_fluxes has one).
874  f_arr(i,j,k,0) = sw_flux_up_tab(icol,ilay);
875  f_arr(i,j,k,1) = sw_flux_dn_tab(icol,ilay);
876  f_arr(i,j,k,2) = lw_flux_up_tab(icol,ilay);
877  f_arr(i,j,k,3) = lw_flux_dn_tab(icol,ilay);
878  if (k == ktop) {
879  f_arr(i,j,k+1,0) = sw_flux_up_tab(icol,ilay+1);
880  f_arr(i,j,k+1,1) = sw_flux_dn_tab(icol,ilay+1);
881  f_arr(i,j,k+1,2) = lw_flux_up_tab(icol,ilay+1);
882  f_arr(i,j,k+1,3) = lw_flux_dn_tab(icol,ilay+1);
883  }
884 
885  if (k==0) {
886  sfc_flux_sw_dn_tab(icol) = sw_flux_dn_tab(icol,ilay);
887  sfc_flux_lw_dn_tab(icol) = lw_flux_dn_tab(icol,ilay);
888  }
889  });
890  for (int ivar(0); ivar<lsm_output_ptrs.size(); ivar++) {
891  if (lsm_output_ptrs[ivar]) {
892  auto rrtmgp_for_fill = rrtmgp_out_vars[ivar];
893  const Array4<Real>& lsm_out_arr = lsm_output_ptrs[ivar]->array(mfi);
894  ParallelFor(sbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
895  {
896  // map [i,j,k] 0-based to [icol, ilay] 0-based
897  const int icol = (j-jmin)*nx + (i-imin) + offset;
898 
899  // export the desired variable at surface
900  lsm_out_arr(i,j,k) = rrtmgp_for_fill(icol);
901  });
902  } // valid ptr
903  } // ivar
904  }// mfi
905 }
rdOcp
const Real rdOcp
Definition: ERF_InitCustomPert_ABL.H:72
ParallelFor
ParallelFor(fab_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:36
Radiation::m_cons_in
amrex::MultiFab * m_cons_in
Definition: ERF_Radiation.H:328
Radiation::m_rad_fluxes
amrex::MultiFab * m_rad_fluxes
Definition: ERF_Radiation.H:334
Radiation::m_qheating_rates
amrex::MultiFab * m_qheating_rates
Definition: ERF_Radiation.H:331
rrtmgp::inverse_exner
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real inverse_exner(const amrex::Real pressure, const amrex::Real rdOcp)
Definition: ERF_RRTMGP_SurfaceTemperature.H:12
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,
const amrex::Vector< const amrex::MultiFab * > &  lsm_input_ptrs 
)
567 {
568  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))});
569  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))});
570  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))});
571  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))});
572  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))});
573  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))});
574  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))});
575  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))});
576 
577  Table2D<Real,Order::C> lwp_tab(lwp.data(), {0,0}, {static_cast<int>(lwp.extent(0)),static_cast<int>(lwp.extent(1))});
578  Table2D<Real,Order::C> iwp_tab(iwp.data(), {0,0}, {static_cast<int>(iwp.extent(0)),static_cast<int>(iwp.extent(1))});
579  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))});
580  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))});
581 
582  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))});
583  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))});
584 
585  Table1D<Real> lat_tab(lat.data(), {0}, {static_cast<int>(lat.extent(0))});
586  Table1D<Real> lon_tab(lon.data(), {0}, {static_cast<int>(lon.extent(0))});
587  Table1D<Real> t_sfc_tab(t_sfc.data(), {0}, {static_cast<int>(t_sfc.extent(0))});
588 
589  bool moist = m_moist;
590  bool ice = m_ice;
591  const int qi_comp = m_qi_comp;
592  const bool has_lsm = m_lsm;
593  const bool has_lat = m_lat;
594  const bool has_lon = m_lon;
595  const bool has_surflayer = (t_surf);
596  int ncol = m_ncol;
597  int nlay = m_nlay;
598  Real dz = m_geom.CellSize(2);
599  Real cons_lat = m_lat_cons;
600  Real cons_lon = m_lon_cons;
601  Real rad_t_sfc = m_rad_t_sfc;
602  Real rdOcp = m_rdOcp;
603 
604  for (MFIter mfi(*m_cons_in); mfi.isValid(); ++mfi) {
605  const auto& vbx = mfi.validbox();
606  const int nx = vbx.length(0);
607  const int imin = vbx.smallEnd(0);
608  const int jmin = vbx.smallEnd(1);
609  const int offset = m_col_offsets[mfi.index()];
610  const Array4<const Real>& cons_arr = m_cons_in->const_array(mfi);
611  const Array4<const Real>& z_arr = (m_z_phys) ? m_z_phys->const_array(mfi) :
612  Array4<const Real>{};
613  const Array4<const Real>& lat_arr = (m_lat) ? m_lat->const_array(mfi) :
614  Array4<const Real>{};
615  const Array4<const Real>& lon_arr = (m_lon) ? m_lon->const_array(mfi) :
616  Array4<const Real>{};
617  ParallelFor(vbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
618  {
619  // map [i,j,k] 0-based to [icol, ilay] 0-based
620  const int icol = (j-jmin)*nx + (i-imin) + offset;
621  const int ilay = k;
622 
623  // EOS input (at CC)
624  Real r = cons_arr(i,j,k,Rho_comp);
625  Real rt = cons_arr(i,j,k,RhoTheta_comp);
626  Real qv = (moist) ? std::max(cons_arr(i,j,k,RhoQ1_comp)/r,Real(0.)) : Real(0.);
627  Real qc = (moist) ? std::max(cons_arr(i,j,k,RhoQ2_comp)/r,Real(0.)) : Real(0.);
628  Real qi = (ice && qi_comp >= 0) ? std::max(cons_arr(i,j,k,qi_comp)/r,Real(0.)) : Real(0.);
629 
630  // EOS avg to z-face
631  Real r_lo = cons_arr(i,j,k-1,Rho_comp);
632  Real rt_lo = cons_arr(i,j,k-1,RhoTheta_comp);
633  Real qv_lo = (moist) ? cons_arr(i,j,k-1,RhoQ1_comp)/r_lo : Real(0.);
634  Real dz_k = (z_arr) ? Real(0.125) * ( (z_arr(i ,j ,k+1) - z_arr(i ,j ,k))
635  + (z_arr(i+1,j ,k+1) - z_arr(i+1,j ,k))
636  + (z_arr(i ,j+1,k+1) - z_arr(i ,j+1,k))
637  + (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
638  Real dz_km1 = (z_arr) ? Real(0.125) * ( (z_arr(i ,j ,k ) - z_arr(i ,j ,k-1))
639  + (z_arr(i+1,j ,k ) - z_arr(i+1,j ,k-1))
640  + (z_arr(i ,j+1,k ) - z_arr(i ,j+1,k-1))
641  + (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
642  // NOTE: Linear interpolation to the w-face weights each CC value by the
643  // distance from the face to the *opposite* CC (inverse distance)
644  Real r_avg = (dz_km1*r + dz_k*r_lo ) / (dz_k + dz_km1);
645  Real rt_avg = (dz_km1*rt + dz_k*rt_lo) / (dz_k + dz_km1);
646  Real qv_avg = (dz_km1*qv + dz_k*qv_lo) / (dz_k + dz_km1);
647 
648  // Views at CC
649  r_lay_tab(icol,ilay) = r;
650 
651  p_lay_tab(icol,ilay) = getPgivenRTh(rt, qv);
652  t_lay_tab(icol,ilay) = getTgivenRandRTh(r, rt, qv);
653  z_del_tab(icol,ilay) = (z_arr) ? Real(0.25) * ( (z_arr(i ,j ,k+1) - z_arr(i ,j ,k))
654  + (z_arr(i+1,j ,k+1) - z_arr(i+1,j ,k))
655  + (z_arr(i ,j+1,k+1) - z_arr(i ,j+1,k))
656  + (z_arr(i+1,j+1,k+1) - z_arr(i+1,j+1,k)) ) : dz;
657  qv_lay_tab(icol,ilay) = qv;
658  qc_lay_tab(icol,ilay) = qc;
659  qi_lay_tab(icol,ilay) = qi;
660  cldfrac_tot_tab(icol,ilay) = ((qc+qi)>Real(0.)) ? Real(1.) : Real(0.);
661 
662  // NOTE: These are populated in 'mixing_ratio_to_cloud_mass'
663  lwp_tab(icol,ilay) = Real(0.);
664  iwp_tab(icol,ilay) = Real(0.);
665 
666  // NOTE: These would be populated from P3 (we use the constants in p3_main_impl.hpp)
667  // NOTE: These are in units of micron!
668  eff_radius_qc_tab(icol,ilay) = (qc>Real(0.)) ? Real(10.0) : Real(0.);
669  eff_radius_qi_tab(icol,ilay) = (qi>Real(0.)) ? Real(25.0) : Real(0.);
670 
671  // Buffers on z-faces (nlay+1)
672  p_lev_tab(icol,ilay) = getPgivenRTh(rt_avg, qv_avg);
673  t_lev_tab(icol,ilay) = getTgivenRandRTh(r_avg, rt_avg, qv_avg);
674  if (ilay==(nlay-1)) {
675  Real r_hi = cons_arr(i,j,k+1,Rho_comp);
676  Real rt_hi = cons_arr(i,j,k+1,RhoTheta_comp);
677  Real qv_hi = (moist) ? std::max(cons_arr(i,j,k+1,RhoQ1_comp)/r_hi,Real(0.)) : Real(0.);
678  Real dz_kp1 = (z_arr) ? Real(0.125) * ( (z_arr(i ,j ,k+2) - z_arr(i ,j ,k+1))
679  + (z_arr(i+1,j ,k+2) - z_arr(i+1,j ,k+1))
680  + (z_arr(i ,j+1,k+2) - z_arr(i ,j+1,k+1))
681  + (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
682  r_avg = (dz_kp1*r + dz_k*r_hi ) / (dz_k + dz_kp1);
683  rt_avg = (dz_kp1*rt + dz_k*rt_hi) / (dz_k + dz_kp1);
684  qv_avg = (dz_kp1*qv + dz_k*qv_hi) / (dz_k + dz_kp1);
685  p_lev_tab(icol,ilay+1) = getPgivenRTh(rt_avg, qv_avg);
686  t_lev_tab(icol,ilay+1) = getTgivenRandRTh(r_avg, rt_avg, qv_avg);
687  }
688 
689  // 1D data structures
690  if (k==0) {
691  lat_tab(icol) = (has_lat) ? lat_arr(i,j,0) : cons_lat;
692  lon_tab(icol) = (has_lon) ? lon_arr(i,j,0) : cons_lon;
693  }
694 
695  });
696  } // mfi
697 
698  // Populate vars LSM would provide
699  if (!has_lsm && !has_surflayer) {
700  // Parsed surface temp
701  Kokkos::deep_copy(t_sfc, rad_t_sfc);
702 
703  // EAMXX dummy atmos constants
704  Kokkos::deep_copy(sfc_alb_dir_vis, Real(0.06));
705  Kokkos::deep_copy(sfc_alb_dir_nir, Real(0.06));
706  Kokkos::deep_copy(sfc_alb_dif_vis, Real(0.06));
707  Kokkos::deep_copy(sfc_alb_dif_nir, Real(0.06));
708 
709  // AML NOTE: These are not used in current EAMXX, I've left
710  // the code to plug into these if we need it.
711  //
712  // Current EAMXX constants
713  Kokkos::deep_copy(sfc_emis, Real(0.98));
714  Kokkos::deep_copy(lw_src , zero );
715  } else {
716  Vector<real1d_k> rrtmgp_in_vars = {t_sfc, sfc_emis,
717  sfc_alb_dir_vis, sfc_alb_dir_nir,
718  sfc_alb_dif_vis, sfc_alb_dif_nir};
719  Vector<Real> rrtmgp_default_vals = {rad_t_sfc, Real(0.98),
720  Real(0.06), Real(0.06),
721  Real(0.06), Real(0.06)};
722  for (int ivar(0); ivar<lsm_input_ptrs.size(); ivar++) {
723  auto rrtmgp_default_val = rrtmgp_default_vals[ivar];
724  auto rrtmgp_to_fill_k = rrtmgp_in_vars[ivar];
725  amrex::Table1D<amrex::Real> rrtmgp_to_fill(rrtmgp_to_fill_k.data(),
726  0, rrtmgp_to_fill_k.extent(0));
727  for (MFIter mfi(*m_cons_in); mfi.isValid(); ++mfi) {
728  const auto& vbx = mfi.validbox();
729  const auto& sbx = makeSlab(vbx,2,vbx.smallEnd(2));
730  const int nx = vbx.length(0);
731  const int imin = vbx.smallEnd(0);
732  const int jmin = vbx.smallEnd(1);
733  const int offset = m_col_offsets[mfi.index()];
734  const int k_surface = vbx.smallEnd(2);
735  const Array4<const Real>& cons_arr = m_cons_in->const_array(mfi);
736  const Array4<const Real>& z_arr = (m_z_phys) ? m_z_phys->const_array(mfi) :
737  Array4<const Real>{};
738  const Array4<const int>& lmask_arr = (lmask) ? lmask->const_array(mfi) :
739  Array4<const int> {};
740  const Array4<const Real>& tsurf_arr = (t_surf) ? t_surf->const_array(mfi) :
741  Array4<const Real> {};
742  const Array4<const Real>& lsm_in_arr = (lsm_input_ptrs[ivar]) ? lsm_input_ptrs[ivar]->const_array(mfi) :
743  Array4<const Real> {};
744  ParallelFor(sbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
745  {
746  // map [i,j,k] 0-based to [icol, ilay] 0-based
747  const int icol = (j-jmin)*nx + (i-imin) + offset;
748 
749  // Check if over land
750  bool is_land = (lmask_arr) ? lmask_arr(i,j,k) : 1;
751 
752  // Surface temperature has a distinct contract: LSM and
753  // RRTMGP use absolute temperature, while SurfaceLayer
754  // supplies potential temperature. The other LSM inputs
755  // retain their existing validity/default handling.
756  if (ivar == 0) {
757  const bool has_lsm_t_sfc = static_cast<bool>(lsm_in_arr);
758  const bool valid_lsm_t_sfc =
759  has_lsm_t_sfc && amrex::Math::isfinite(lsm_in_arr(i,j,k)) &&
760  (lsm_in_arr(i,j,k) > Real(0.)) &&
761  (lsm_in_arr(i,j,k) < lsm_undefined);
762  // Match TwoStream: convert SurfaceLayer theta with
763  // the physical surface pressure diagnosed from the
764  // lowest atmospheric cell.
765  rrtmgp::resolve_surface_temperature(
766  is_land,
767  has_lsm_t_sfc,
768  valid_lsm_t_sfc,
769  has_lsm_t_sfc ? lsm_in_arr(i,j,k) : Real(0.),
770  static_cast<bool>(tsurf_arr),
771  tsurf_arr ? tsurf_arr(i,j,k) : Real(0.),
772  erf_surface_temperature::pressure_at_surface(
773  cons_arr(i,j,k_surface,Rho_comp),
774  cons_arr(i,j,k_surface,RhoTheta_comp),
775  moist ? std::max(cons_arr(i,j,k_surface,RhoQ1_comp) /
776  cons_arr(i,j,k_surface,Rho_comp), Real(0.)) : Real(0.),
777  z_arr ? Compute_Zrel_AtCellCenter(i,j,k_surface,z_arr) : Real(0.5)*dz),
778  rdOcp,
779  rrtmgp_default_val,
780  rrtmgp_to_fill(icol));
781  } else {
782  // Have LSM and are over land.
783  const bool valid_lsm_data =
784  (lsm_in_arr && (lsm_in_arr(i,j,k) < lsm_undefined));
785  if (is_land && valid_lsm_data) {
786  rrtmgp_to_fill(icol) = lsm_in_arr(i,j,k);
787  } else {
788  // Use the default value.
789  rrtmgp_to_fill(icol) = rrtmgp_default_val;
790  }
791  }
792  });
793  } //mfi
794  } // ivar
795  Kokkos::deep_copy(lw_src, zero );
796  } // have lsm
797 
798  // Enforce consistency between t_sfc and t_lev at bottom surface
799  Kokkos::parallel_for(Kokkos::RangePolicy(0, ncol),
800  KOKKOS_LAMBDA (int icol)
801  {
802  t_lev_tab(icol,0) = t_sfc_tab(icol);
803  });
804 }
lsm_undefined
constexpr amrex::Real lsm_undefined
Definition: ERF_Constants.H:28
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:53
RhoTheta_comp
#define RhoTheta_comp
Definition: ERF_IndexDefines.H:54
RhoQ2_comp
#define RhoQ2_comp
Definition: ERF_IndexDefines.H:67
RhoQ1_comp
#define RhoQ1_comp
Definition: ERF_IndexDefines.H:66
zero
constexpr amrex::Real zero
Definition: ERF_NumericalConstants.H:36
Compute_Zrel_AtCellCenter
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real Compute_Zrel_AtCellCenter(const int &i, const int &j, const int &k, const amrex::Array4< const amrex::Real > &z_nd)
Definition: ERF_TerrainMetrics.H:762
Radiation::m_lon
amrex::MultiFab * m_lon
Definition: ERF_Radiation.H:341
Radiation::m_z_phys
amrex::MultiFab * m_z_phys
Definition: ERF_Radiation.H:337
Radiation::m_geom
amrex::Geometry m_geom
Definition: ERF_Radiation.H:293
Radiation::m_lat
amrex::MultiFab * m_lat
Definition: ERF_Radiation.H:340
MicVar_Kess::qv
@ qv
Definition: ERF_Kessler.H:31
MorrSed::qi
@ qi
Definition: ERF_Morrison.H:111
MorrSed::qc
@ qc
Definition: ERF_Morrison.H:110
WDM6SedCellScratch::dz
@ dz
Definition: ERF_AdvanceWDM6.cpp:273
erf_surface_temperature::pressure_at_surface
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real pressure_at_surface(const amrex::Real rho, const amrex::Real rho_theta, const amrex::Real qv, const amrex::Real delta_z)
Definition: ERF_SurfaceTemperature.H:36
rrtmgp::resolve_surface_temperature
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void resolve_surface_temperature(const bool is_land, const bool has_lsm_t_sfc, const bool valid_lsm_t_sfc, const amrex::Real lsm_t_sfc, const bool has_surface_layer, const amrex::Real surface_layer_theta, const amrex::Real surface_pressure, const amrex::Real rdOcp, const amrex::Real default_t_sfc, amrex::Real &t_sfc)
Definition: ERF_RRTMGP_SurfaceTemperature.H:39
Here is the call graph for this function:

◆ populateDatalogMF()

void Radiation::populateDatalogMF ( )
949 {
950  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))});
951  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))});
952  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))});
953  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))});
954  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))});
955 
956  Table2D<Real,Order::C> sw_clrsky_flux_up_tab(sw_clrsky_flux_up.data(), {0,0},
957  {static_cast<int>(sw_clrsky_flux_up.extent(0)),static_cast<int>(sw_clrsky_flux_up.extent(1))});
958  Table2D<Real,Order::C> sw_clrsky_flux_dn_tab(sw_clrsky_flux_dn.data(), {0,0},
959  {static_cast<int>(sw_clrsky_flux_dn.extent(0)),static_cast<int>(sw_clrsky_flux_dn.extent(1))});
960  Table2D<Real,Order::C> sw_clrsky_flux_dn_dir_tab(sw_clrsky_flux_dn_dir.data(), {0,0},
961  {static_cast<int>(sw_clrsky_flux_dn_dir.extent(0)),static_cast<int>(sw_clrsky_flux_dn_dir.extent(1))});
962  Table2D<Real,Order::C> lw_clrsky_flux_up_tab(lw_clrsky_flux_up.data(), {0,0},
963  {static_cast<int>(lw_clrsky_flux_up.extent(0)),static_cast<int>(lw_clrsky_flux_up.extent(1))});
964  Table2D<Real,Order::C> lw_clrsky_flux_dn_tab(lw_clrsky_flux_dn.data(), {0,0},
965  {static_cast<int>(lw_clrsky_flux_dn.extent(0)),static_cast<int>(lw_clrsky_flux_dn.extent(1))});
966  Table2D<Real,Order::C> sw_clrsky_heating_tab(sw_clrsky_heating.data(), {0,0},
967  {static_cast<int>(sw_clrsky_heating.extent(0)),static_cast<int>(sw_clrsky_heating.extent(1))});
968  Table2D<Real,Order::C> lw_clrsky_heating_tab(lw_clrsky_heating.data(), {0,0},
969  {static_cast<int>(lw_clrsky_heating.extent(0)),static_cast<int>(lw_clrsky_heating.extent(1))});
970  Table2D<Real,Order::C> sw_clnsky_flux_up_tab(sw_clnsky_flux_up.data(), {0,0},
971  {static_cast<int>(sw_clnsky_flux_up.extent(0)),static_cast<int>(sw_clnsky_flux_up.extent(1))});
972  Table2D<Real,Order::C> sw_clnsky_flux_dn_tab(sw_clnsky_flux_dn.data(), {0,0},
973  {static_cast<int>(sw_clnsky_flux_dn.extent(0)),static_cast<int>(sw_clnsky_flux_dn.extent(1))});
974  Table2D<Real,Order::C> sw_clnsky_flux_dn_dir_tab(sw_clnsky_flux_dn_dir.data(), {0,0},
975  {static_cast<int>(sw_clnsky_flux_dn_dir.extent(0)),static_cast<int>(sw_clnsky_flux_dn_dir.extent(1))});
976  Table2D<Real,Order::C> lw_clnsky_flux_up_tab(lw_clnsky_flux_up.data(), {0,0},
977  {static_cast<int>(lw_clnsky_flux_up.extent(0)),static_cast<int>(lw_clnsky_flux_up.extent(1))});
978  Table2D<Real,Order::C> lw_clnsky_flux_dn_tab(lw_clnsky_flux_dn.data(), {0,0},
979  {static_cast<int>(lw_clnsky_flux_dn.extent(0)),static_cast<int>(lw_clnsky_flux_dn.extent(1))});
980  Table2D<Real,Order::C> sw_clnclrsky_flux_up_tab(sw_clnclrsky_flux_up.data(), {0,0},
981  {static_cast<int>(sw_clnclrsky_flux_up.extent(0)),static_cast<int>(sw_clnclrsky_flux_up.extent(1))});
982  Table2D<Real,Order::C> sw_clnclrsky_flux_dn_tab(sw_clnclrsky_flux_dn.data(), {0,0},
983  {static_cast<int>(sw_clnclrsky_flux_dn.extent(0)),static_cast<int>(sw_clnclrsky_flux_dn.extent(1))});
984  Table2D<Real,Order::C> sw_clnclrsky_flux_dn_dir_tab(sw_clnclrsky_flux_dn_dir.data(), {0,0},
985  {static_cast<int>(sw_clnclrsky_flux_dn_dir.extent(0)),static_cast<int>(sw_clnclrsky_flux_dn_dir.extent(1))});
986  Table2D<Real,Order::C> lw_clnclrsky_flux_up_tab(lw_clnclrsky_flux_up.data(), {0,0},
987  {static_cast<int>(lw_clnclrsky_flux_up.extent(0)),static_cast<int>(lw_clnclrsky_flux_up.extent(1))});
988  Table2D<Real,Order::C> lw_clnclrsky_flux_dn_tab(lw_clnclrsky_flux_dn.data(), {0,0},
989  {static_cast<int>(lw_clnclrsky_flux_dn.extent(0)),static_cast<int>(lw_clnclrsky_flux_dn.extent(1))});
990 
991  Table1D<Real> mu0_tab(mu0.data(), {0}, {static_cast<int>(mu0.extent(0))});
992 
993  auto extra_clnsky_diag = m_extra_clnsky_diag;
994  auto extra_clnclrsky_diag = m_extra_clnclrsky_diag;
995 
996  for (MFIter mfi(datalog_mf); mfi.isValid(); ++mfi) {
997  const auto& vbx = mfi.validbox();
998  const int nx = vbx.length(0);
999  const int imin = vbx.smallEnd(0);
1000  const int jmin = vbx.smallEnd(1);
1001  const int offset = m_col_offsets[mfi.index()];
1002  const Array4<Real>& dst_arr = datalog_mf.array(mfi);
1003  const Array4<Real>& q_arr = m_qheating_rates->array(mfi);
1004  ParallelFor(vbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
1005  {
1006  // map [i,j,k] 0-based to [icol, ilay] 0-based
1007  const int icol = (j-jmin)*nx + (i-imin) + offset;
1008  const int ilay = k;
1009 
1010  dst_arr(i,j,k,0) = q_arr(i, j, k, 0);
1011  dst_arr(i,j,k,1) = q_arr(i, j, k, 1);
1012 
1013  // SW and LW fluxes
1014  dst_arr(i,j,k,2) = sw_flux_up_tab(icol,ilay);
1015  dst_arr(i,j,k,3) = sw_flux_dn_tab(icol,ilay);
1016  dst_arr(i,j,k,4) = sw_flux_dn_dir_tab(icol,ilay);
1017  dst_arr(i,j,k,5) = lw_flux_up_tab(icol,ilay);
1018  dst_arr(i,j,k,6) = lw_flux_dn_tab(icol,ilay);
1019 
1020  // Cosine zenith angle
1021  dst_arr(i,j,k,7) = mu0_tab(icol);
1022 
1023  // Clear sky heating rates and fluxes:
1024  dst_arr(i,j,k,8) = sw_clrsky_heating_tab(icol, ilay);
1025  dst_arr(i,j,k,9) = lw_clrsky_heating_tab(icol, ilay);
1026 
1027  dst_arr(i,j,k,10) = sw_clrsky_flux_up_tab(icol,ilay);
1028  dst_arr(i,j,k,11) = sw_clrsky_flux_dn_tab(icol,ilay);
1029  dst_arr(i,j,k,12) = sw_clrsky_flux_dn_dir_tab(icol,ilay);
1030  dst_arr(i,j,k,13) = lw_clrsky_flux_up_tab(icol,ilay);
1031  dst_arr(i,j,k,14) = lw_clrsky_flux_dn_tab(icol,ilay);
1032 
1033  // Clean sky fluxes:
1034  if (extra_clnsky_diag) {
1035  dst_arr(i,j,k,15) = sw_clnsky_flux_up_tab(icol,ilay);
1036  dst_arr(i,j,k,16) = sw_clnsky_flux_dn_tab(icol,ilay);
1037  dst_arr(i,j,k,17) = sw_clnsky_flux_dn_dir_tab(icol,ilay);
1038  dst_arr(i,j,k,18) = lw_clnsky_flux_up_tab(icol,ilay);
1039  dst_arr(i,j,k,19) = lw_clnsky_flux_dn_tab(icol,ilay);
1040  }
1041 
1042  // Clean-clear sky fluxes:
1043  if (extra_clnclrsky_diag) {
1044  dst_arr(i,j,k,20) = sw_clnclrsky_flux_up_tab(icol,ilay);
1045  dst_arr(i,j,k,21) = sw_clnclrsky_flux_dn_tab(icol,ilay);
1046  dst_arr(i,j,k,22) = sw_clnclrsky_flux_dn_dir_tab(icol,ilay);
1047  dst_arr(i,j,k,23) = lw_clnclrsky_flux_up_tab(icol,ilay);
1048  dst_arr(i,j,k,24) = lw_clnclrsky_flux_dn_tab(icol,ilay);
1049  }
1050  });
1051  }
1052 }
Radiation::datalog_mf
amrex::MultiFab datalog_mf
Definition: ERF_Radiation.H:348
Here is the call graph for this function:

◆ rad_run_impl()

void Radiation::rad_run_impl ( const amrex::Vector< amrex::MultiFab * > &  lsm_output_ptrs)
inline
230  {
231  if (m_update_rad) {
232  amrex::Print() << "Radiation advancing level " << m_lev << " at (YY-MM-DD SS) " << m_orbital_year << '-'
233  << m_orbital_mon << '-' << m_orbital_day << ' ' << m_orbital_sec << " ...";
234  this->initialize_impl();
235  this->run_impl();
236  this->finalize_impl(lsm_output_ptrs);
237  amrex::Print() << "DONE\n";
238  }
239  }
Radiation::initialize_impl
void initialize_impl()
Definition: ERF_Radiation.cpp:1189
Radiation::run_impl
void run_impl()
Definition: ERF_Radiation.cpp:1214
Radiation::m_orbital_mon
int m_orbital_mon
Definition: ERF_Radiation.H:409
Radiation::m_orbital_sec
int m_orbital_sec
Definition: ERF_Radiation.H:411
Radiation::m_lev
int m_lev
Definition: ERF_Radiation.H:281
Radiation::m_update_rad
bool m_update_rad
Definition: ERF_Radiation.H:299
Radiation::m_orbital_day
int m_orbital_day
Definition: ERF_Radiation.H:410
Radiation::finalize_impl
void finalize_impl(const amrex::Vector< amrex::MultiFab * > &lsm_output_ptrs)
Definition: ERF_Radiation.cpp:1511

Referenced by Run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ radiation_updated()

bool Radiation::radiation_updated ( ) const
inlineoverridevirtual

Reports whether the last radiation call updated its outputs.

Returns
True when the radiation kernel wrote output fields.

Reimplemented from IRadiation.

172 { return m_update_rad && !m_is_nested_patch; }

◆ Run()

virtual void Radiation::Run ( int &  level,
int &  step,
double &  time,
const double &  dt,
const amrex::BoxArray &  ba,
amrex::Geometry &  geom,
amrex::MultiFab *  cons_in,
amrex::iMultiFab *  lmask,
amrex::MultiFab *  t_surf,
const amrex::Vector< const amrex::MultiFab * > &  lsm_input_ptrs,
const 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,
const bool  force_update,
amrex::Real &  declin,
amrex::Real &  calday 
)
inlineoverridevirtual

Implements IRadiation.

149  {
150  // Skip radiation computation on nested patches - heating rates will be
151  // filled via interpolation from coarser level in ERF::FillPatch
152  if (m_is_nested_patch) {
153  return;
154  }
155 
156  AMREX_ALWAYS_ASSERT_WITH_MESSAGE(
157  m_nlay == geom.Domain().length(2),
158  "Radiation: m_nlay (" + std::to_string(m_nlay) +
159  ") doesn't match domain vertical extent (" +
160  std::to_string(geom.Domain().length(2)) + ")");
161 
162  set_grids(level, step, time, dt, ba, geom,
163  cons_in, lmask, t_surf,
164  lsm_input_ptrs, qheating_rates,
165  rad_fluxes, z_phys, lat_ptr, lon_ptr,
166  force_update);
167  rad_run_impl(lsm_output_ptrs);
168  declin = m_declin;
169  calday = m_calday;
170  }
Radiation::set_grids
void set_grids(int &level, int &step, double &time, const double &dt, const amrex::BoxArray &ba, amrex::Geometry &geom, amrex::MultiFab *cons_in, amrex::iMultiFab *lmask, amrex::MultiFab *t_surf, const amrex::Vector< const amrex::MultiFab * > &lsm_input_ptrs, amrex::MultiFab *qheating_rates, amrex::MultiFab *rad_fluxes, amrex::MultiFab *z_phys, amrex::MultiFab *lat, amrex::MultiFab *lon, const bool force_update)
Definition: ERF_Radiation.cpp:244
Radiation::rad_run_impl
void rad_run_impl(const amrex::Vector< amrex::MultiFab * > &lsm_output_ptrs)
Definition: ERF_Radiation.H:229
Radiation::m_declin
amrex::Real m_declin
Definition: ERF_Radiation.H:431
Radiation::m_calday
amrex::Real m_calday
Definition: ERF_Radiation.H:432
Here is the call graph for this function:

◆ run_impl()

void Radiation::run_impl ( )
1215 {
1216  // A rank that owns no boxes on this level has no columns and therefore no
1217  // radiation work to do. Bail out before the chunk loop; there are no MPI
1218  // collectives in this routine, so returning early cannot deadlock.
1219  if (m_ncol == 0) { return; }
1220 
1221  // Local copies
1222  const auto ncol = m_ncol;
1223  const auto nlay = m_nlay;
1224  const auto nswbands = m_nswbands;
1225 
1226  // Compute orbital parameters; these are used both for computing
1227  // the solar zenith angle and also for computing total solar
1228  // irradiance scaling (tsi_scaling).
1229  double obliqr, lambm0, mvelpp;
1230  // Any of eccen/obliq/mvelp that the user set (i.e. is non-negative) is used
1231  // as is by orbital_params; the rest are computed from the orbital year.
1232  int orbital_year = m_orbital_year;
1233  double eccen = m_orbital_eccen;
1234  double obliq = m_orbital_obliq;
1235  double mvelp = m_orbital_mvelp;
1236  orbital_params(orbital_year, eccen, obliq,
1237  mvelp, obliqr, lambm0, mvelpp);
1238 
1239  // Use the orbital parameters to calculate the solar declination and eccentricity factor
1240  double delta, eccf;
1241  // Day of the year plus fraction, calday 1 == Jan 1 0Z (leap-aware)
1242  double calday = orbital_calday(m_orbital_year, m_orbital_mon, m_orbital_day, m_orbital_sec);
1243  orbital_decl(calday, eccen, mvelpp, lambm0, obliqr, delta, eccf);
1244  m_calday = calday;
1245  m_declin = delta;
1246 
1247  // Overwrite eccf if using a fixed solar constant.
1248  auto fixed_total_solar_irradiance = m_fixed_total_solar_irradiance;
1249  if (fixed_total_solar_irradiance >= 0){
1250  eccf = fixed_total_solar_irradiance/Real(1360.9);
1251  }
1252 
1253  // Precompute volume mixing ratio (VMR) for all gases
1254  //
1255  // H2O is obtained from qv.
1256  // O3 may be a constant or a 1D vector
1257  // All other comps are set to constants for now
1258  Vector<real2d_k> vmr_full_vec(m_ngas);
1259  for (int igas(0); igas < m_ngas; ++igas) {
1260  auto name = m_gas_names[igas];
1261  vmr_full_vec[igas] = real2d_k("vmr_full_" + name, ncol, nlay);
1262  auto tmp2d = vmr_full_vec[igas];
1263  auto gas_mol_weight = m_mol_weight_gas[igas];
1264  if (name == "H2O") {
1265  auto qv_lay_d = qv_lay;
1266  Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<2>>({0, 0}, {ncol, nlay}),
1267  KOKKOS_LAMBDA (int icol, int ilay)
1268  {
1269  tmp2d(icol,ilay) = qv_lay_d(icol,ilay) * mwdair/gas_mol_weight;
1270  });
1271  } else if (name == "CO2") {
1272  Kokkos::deep_copy(tmp2d, m_co2vmr);
1273  } else if (name == "O3") {
1274  if (m_o3_size==1) {
1275  Kokkos::deep_copy(tmp2d, m_o3vmr[0] );
1276  } else {
1277  auto o3_lay_d = o3_lay;
1278  Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<2>>({0, 0}, {ncol, nlay}),
1279  KOKKOS_LAMBDA (int icol, int ilay)
1280  {
1281  tmp2d(icol,ilay) = o3_lay_d(ilay);
1282  });
1283  }
1284  } else if (name == "N2O") {
1285  Kokkos::deep_copy(tmp2d, m_n2ovmr);
1286  } else if (name == "CO") {
1287  Kokkos::deep_copy(tmp2d, m_covmr );
1288  } else if (name == "CH4") {
1289  Kokkos::deep_copy(tmp2d, m_ch4vmr);
1290  } else if (name == "O2") {
1291  Kokkos::deep_copy(tmp2d, m_o2vmr );
1292  } else if (name == "N2") {
1293  Kokkos::deep_copy(tmp2d, m_n2vmr );
1294  } else {
1295  Abort("Radiation: Unknown gas component.");
1296  }
1297  }
1298 
1299  // Determine the cosine zenith angle.
1300  // Populate mu0 1D array
1301  // This must be done on HOST and copied to device.
1302  auto h_mu0 = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), mu0);
1303  if (m_fixed_solar_zenith_angle > 0) {
1304  Kokkos::deep_copy(h_mu0, m_fixed_solar_zenith_angle);
1305  } else {
1306  auto h_lat = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), lat);
1307  auto h_lon = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), lon);
1308  double dt = double(m_dt);
1309  auto rad_freq_in_steps = m_rad_freq_in_steps;
1310  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::Serial>(0, ncol),
1311  [&,PI_d=PI] (int icol)
1312  {
1313  // Convert lat/lon to radians
1314  double lat_col = h_lat(icol)*PI_d/Real(180.0);
1315  double lon_col = h_lon(icol)*PI_d/Real(180.0);
1316  double lcalday = calday;
1317  double ldelta = delta;
1318  double dt_avg = static_cast<double>(rad_freq_in_steps) * dt;
1319  h_mu0(icol) = Real(orbital_cos_zenith(lcalday, lat_col, lon_col, ldelta, dt_avg));
1320  });
1321  }
1322  Kokkos::deep_copy(mu0, h_mu0);
1323 
1324  // Compute layer cloud mass per unit area (populates lwp/iwp)
1325  rrtmgp::mixing_ratio_to_cloud_mass(qc_lay, cldfrac_tot, r_lay, z_del, lwp);
1326  rrtmgp::mixing_ratio_to_cloud_mass(qi_lay, cldfrac_tot, r_lay, z_del, iwp);
1327 
1328  // Convert to g/m2 (needed by RRTMGP)
1329  Table2D<Real,Order::C> lwp_tab(lwp.data(), {0,0}, {static_cast<int>(lwp.extent(0)),static_cast<int>(lwp.extent(1))});
1330  Table2D<Real,Order::C> iwp_tab(iwp.data(), {0,0}, {static_cast<int>(iwp.extent(0)),static_cast<int>(iwp.extent(1))});
1331  Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<2>>({0, 0}, {ncol, nlay}),
1332  KOKKOS_LAMBDA (int icol, int ilay)
1333  {
1334  lwp_tab(icol,ilay) *= Real(1.e3);
1335  iwp_tab(icol,ilay) *= Real(1.e3);
1336  });
1337 
1338  // -----------------------------------------------------------------------
1339  // Process radiation in column chunks to limit peak GPU memory.
1340  // Radiation columns are independent (no horizontal coupling), so
1341  // chunking produces bit-identical results.
1342  // -----------------------------------------------------------------------
1343  const int ncol_chunk = std::min(m_ncol_chunk, ncol);
1344  const int kbot = 0;
1345 
1346  for (int col_s = 0; col_s < ncol; col_s += ncol_chunk) {
1347  const int ncol_c = std::min(ncol_chunk, ncol - col_s);
1348 
1349  // --- Chunk subviews: 1D (ncol) ---
1350  real1d_k mu0_c (mu0.data() + col_s, ncol_c);
1351  real1d_k sfc_alb_dir_vis_c (sfc_alb_dir_vis.data() + col_s, ncol_c);
1352  real1d_k sfc_alb_dir_nir_c (sfc_alb_dir_nir.data() + col_s, ncol_c);
1353  real1d_k sfc_alb_dif_vis_c (sfc_alb_dif_vis.data() + col_s, ncol_c);
1354  real1d_k sfc_alb_dif_nir_c (sfc_alb_dif_nir.data() + col_s, ncol_c);
1355  real1d_k sfc_flux_dir_vis_c (sfc_flux_dir_vis.data() + col_s, ncol_c);
1356  real1d_k sfc_flux_dir_nir_c (sfc_flux_dir_nir.data() + col_s, ncol_c);
1357  real1d_k sfc_flux_dif_vis_c (sfc_flux_dif_vis.data() + col_s, ncol_c);
1358  real1d_k sfc_flux_dif_nir_c (sfc_flux_dif_nir.data() + col_s, ncol_c);
1359  real1d_k t_sfc_c (t_sfc.data() + col_s, ncol_c);
1360  real1d_k sfc_emis_c (sfc_emis.data() + col_s, ncol_c);
1361  real1d_k lw_src_c (lw_src.data() + col_s, ncol_c);
1362 
1363  // --- Chunk subviews: 2D (ncol, nlay) via LayoutRight pointer offset ---
1364  const int stride2_nlay = nlay;
1365  const int stride2_nlayp1 = nlay + 1;
1366  real2d_k p_lay_c (p_lay.data() + col_s*stride2_nlay, ncol_c, nlay);
1367  real2d_k t_lay_c (t_lay.data() + col_s*stride2_nlay, ncol_c, nlay);
1368  real2d_k r_lay_c (r_lay.data() + col_s*stride2_nlay, ncol_c, nlay);
1369  real2d_k z_del_c (z_del.data() + col_s*stride2_nlay, ncol_c, nlay);
1370  real2d_k lwp_c (lwp.data() + col_s*stride2_nlay, ncol_c, nlay);
1371  real2d_k iwp_c (iwp.data() + col_s*stride2_nlay, ncol_c, nlay);
1372  real2d_k eff_radius_qc_c(eff_radius_qc.data() + col_s*stride2_nlay, ncol_c, nlay);
1373  real2d_k eff_radius_qi_c(eff_radius_qi.data() + col_s*stride2_nlay, ncol_c, nlay);
1374  real2d_k cldfrac_tot_c (cldfrac_tot.data() + col_s*stride2_nlay, ncol_c, nlay);
1375  real2d_k sw_heating_c (sw_heating.data() + col_s*stride2_nlay, ncol_c, nlay);
1376  real2d_k lw_heating_c (lw_heating.data() + col_s*stride2_nlay, ncol_c, nlay);
1377 
1378  // --- Chunk subviews: 2D (ncol, nlay+1) ---
1379  real2d_k p_lev_c (p_lev.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1380  real2d_k t_lev_c (t_lev.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1381  real2d_k sw_flux_up_c (sw_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1382  real2d_k sw_flux_dn_c (sw_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1383  real2d_k sw_flux_dn_dir_c (sw_flux_dn_dir.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1384  real2d_k lw_flux_up_c (lw_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1385  real2d_k lw_flux_dn_c (lw_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1386  // Clear-sky flux subviews (always active)
1387  // NOTE: once on m_ncol_chunk if not writing a datalog
1388  real2d_k sw_clrsky_flux_up_c, sw_clrsky_flux_dn_c, sw_clrsky_flux_dn_dir_c;
1389  real2d_k lw_clrsky_flux_up_c, lw_clrsky_flux_dn_c;
1390  if (datalog_int > 0) {
1391  sw_clrsky_flux_up_c = real2d_k(sw_clrsky_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1392  sw_clrsky_flux_dn_c = real2d_k(sw_clrsky_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1393  sw_clrsky_flux_dn_dir_c = real2d_k(sw_clrsky_flux_dn_dir.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1394  lw_clrsky_flux_up_c = real2d_k(lw_clrsky_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1395  lw_clrsky_flux_dn_c = real2d_k(lw_clrsky_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1396  } else {
1397  sw_clrsky_flux_up_c = real2d_k(sw_clrsky_flux_up.data() , ncol_c, nlay+1);
1398  sw_clrsky_flux_dn_c = real2d_k(sw_clrsky_flux_dn.data() , ncol_c, nlay+1);
1399  sw_clrsky_flux_dn_dir_c = real2d_k(sw_clrsky_flux_dn_dir.data() , ncol_c, nlay+1);
1400  lw_clrsky_flux_up_c = real2d_k(lw_clrsky_flux_up.data() , ncol_c, nlay+1);
1401  lw_clrsky_flux_dn_c = real2d_k(lw_clrsky_flux_dn.data() , ncol_c, nlay+1);
1402  }
1403 
1404  // Diagnostic flux subviews (placeholder when disabled)
1405  real2d_k sw_clnclrsky_flux_up_c, sw_clnclrsky_flux_dn_c, sw_clnclrsky_flux_dn_dir_c;
1406  real2d_k lw_clnclrsky_flux_up_c, lw_clnclrsky_flux_dn_c;
1407  if (m_extra_clnclrsky_diag) {
1408  sw_clnclrsky_flux_up_c = real2d_k(sw_clnclrsky_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1409  sw_clnclrsky_flux_dn_c = real2d_k(sw_clnclrsky_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1410  sw_clnclrsky_flux_dn_dir_c = real2d_k(sw_clnclrsky_flux_dn_dir.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1411  lw_clnclrsky_flux_up_c = real2d_k(lw_clnclrsky_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1412  lw_clnclrsky_flux_dn_c = real2d_k(lw_clnclrsky_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1413  } else {
1414  sw_clnclrsky_flux_up_c = real2d_k("sw_clnclrsky_flux_up_c" , 1, 1);
1415  sw_clnclrsky_flux_dn_c = real2d_k("sw_clnclrsky_flux_dn_c" , 1, 1);
1416  sw_clnclrsky_flux_dn_dir_c = real2d_k("sw_clnclrsky_flux_dn_dir_c", 1, 1);
1417  lw_clnclrsky_flux_up_c = real2d_k("lw_clnclrsky_flux_up_c" , 1, 1);
1418  lw_clnclrsky_flux_dn_c = real2d_k("lw_clnclrsky_flux_dn_c" , 1, 1);
1419  }
1420 
1421  real2d_k sw_clnsky_flux_up_c, sw_clnsky_flux_dn_c, sw_clnsky_flux_dn_dir_c;
1422  real2d_k lw_clnsky_flux_up_c, lw_clnsky_flux_dn_c;
1423  if (m_extra_clnsky_diag) {
1424  sw_clnsky_flux_up_c = real2d_k(sw_clnsky_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1425  sw_clnsky_flux_dn_c = real2d_k(sw_clnsky_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1426  sw_clnsky_flux_dn_dir_c = real2d_k(sw_clnsky_flux_dn_dir.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1427  lw_clnsky_flux_up_c = real2d_k(lw_clnsky_flux_up.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1428  lw_clnsky_flux_dn_c = real2d_k(lw_clnsky_flux_dn.data() + col_s*stride2_nlayp1, ncol_c, nlay+1);
1429  } else {
1430  sw_clnsky_flux_up_c = real2d_k("sw_clnsky_flux_up_c" , 1, 1);
1431  sw_clnsky_flux_dn_c = real2d_k("sw_clnsky_flux_dn_c" , 1, 1);
1432  sw_clnsky_flux_dn_dir_c = real2d_k("sw_clnsky_flux_dn_dir_c", 1, 1);
1433  lw_clnsky_flux_up_c = real2d_k("lw_clnsky_flux_up_c" , 1, 1);
1434  lw_clnsky_flux_dn_c = real2d_k("lw_clnsky_flux_dn_c" , 1, 1);
1435  }
1436 
1437  // --- Chunk subviews: 2D (ncol, nswbands) ---
1438  real2d_k sfc_alb_dir_c(sfc_alb_dir.data() + col_s*nswbands, ncol_c, nswbands);
1439  real2d_k sfc_alb_dif_c(sfc_alb_dif.data() + col_s*nswbands, ncol_c, nswbands);
1440 
1441  // --- Chunk subviews: 3D (ncol, nlay+1, nbands) ---
1442  // NOTE: Allocate these once on m_ncol_chunk and use what we need in the chunk loop
1443  real3d_k sw_bnd_flux_up_c (sw_bnd_flux_up.data() , ncol_c, nlay+1, nswbands);
1444  real3d_k sw_bnd_flux_dn_c (sw_bnd_flux_dn.data() , ncol_c, nlay+1, nswbands);
1445  real3d_k sw_bnd_flux_dir_c(sw_bnd_flux_dir.data(), ncol_c, nlay+1, nswbands);
1446  real3d_k sw_bnd_flux_dif_c(sw_bnd_flux_dif.data(), ncol_c, nlay+1, nswbands);
1447  real3d_k lw_bnd_flux_up_c (lw_bnd_flux_up.data() , ncol_c, nlay+1, m_nlwbands);
1448  real3d_k lw_bnd_flux_dn_c (lw_bnd_flux_dn.data() , ncol_c, nlay+1, m_nlwbands);
1449 
1450  // --- Create chunk gas concentrations by subsetting from pre-fetched VMR ---
1451  gas_concs_t gas_concs_c;
1452  gas_concs_c.init(gas_names_offset, ncol_c, nlay);
1453  for (int igas = 0; igas < m_ngas; ++igas) {
1454  real2d_k vmr_c("vmr_c", ncol_c, nlay);
1455  auto vmr_full = vmr_full_vec[igas];
1456  auto cs = col_s;
1457  Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<2>>({0, 0}, {ncol_c, nlay}),
1458  KOKKOS_LAMBDA (int i, int j) {
1459  vmr_c(i, j) = vmr_full(cs + i, j);
1460  });
1461  gas_concs_c.set_vmr(m_gas_names[igas], vmr_c);
1462  }
1463 
1464  // Expand surface albedos along nswbands for this chunk
1465  rrtmgp::compute_band_by_band_surface_albedos(ncol_c, nswbands,
1466  sfc_alb_dir_vis_c, sfc_alb_dir_nir_c,
1467  sfc_alb_dif_vis_c, sfc_alb_dif_nir_c,
1468  sfc_alb_dir_c , sfc_alb_dif_c);
1469 
1470  // Run RRTMGP driver for this column chunk
1471  rrtmgp::rrtmgp_main(ncol_c, m_nlay,
1472  p_lay_c, t_lay_c,
1473  p_lev_c, t_lev_c,
1474  gas_concs_c,
1475  sfc_alb_dir_c, sfc_alb_dif_c, mu0_c,
1476  t_sfc_c, sfc_emis_c, lw_src_c,
1477  lwp_c, iwp_c, eff_radius_qc_c, eff_radius_qi_c, cldfrac_tot_c,
1478  sw_flux_up_c, sw_flux_dn_c, sw_flux_dn_dir_c,
1479  lw_flux_up_c, lw_flux_dn_c,
1480  sw_clnclrsky_flux_up_c, sw_clnclrsky_flux_dn_c, sw_clnclrsky_flux_dn_dir_c,
1481  sw_clrsky_flux_up_c, sw_clrsky_flux_dn_c, sw_clrsky_flux_dn_dir_c,
1482  sw_clnsky_flux_up_c, sw_clnsky_flux_dn_c, sw_clnsky_flux_dn_dir_c,
1483  lw_clnclrsky_flux_up_c, lw_clnclrsky_flux_dn_c,
1484  lw_clrsky_flux_up_c, lw_clrsky_flux_dn_c,
1485  lw_clnsky_flux_up_c, lw_clnsky_flux_dn_c,
1486  sw_bnd_flux_up_c, sw_bnd_flux_dn_c, sw_bnd_flux_dir_c,
1487  lw_bnd_flux_up_c, lw_bnd_flux_dn_c,
1488  eccf, m_extra_clnclrsky_diag, m_extra_clnsky_diag);
1489 
1490  // Compute heating rates for this chunk
1491  rrtmgp::compute_heating_rate(sw_flux_up_c, sw_flux_dn_c, r_lay_c, z_del_c, sw_heating_c);
1492  rrtmgp::compute_heating_rate(lw_flux_up_c, lw_flux_dn_c, r_lay_c, z_del_c, lw_heating_c);
1493 
1494  // Compute diffuse band fluxes and broadband surface fluxes for this chunk
1495  Kokkos::parallel_for(Kokkos::MDRangePolicy<Kokkos::Rank<3>>({0, 0, 0}, {ncol_c, nlay+1, nswbands}),
1496  KOKKOS_LAMBDA (int icol, int ilay, int ibnd)
1497  {
1498  sw_bnd_flux_dif_c(icol,ilay,ibnd) = sw_bnd_flux_dn_c(icol,ilay,ibnd) - sw_bnd_flux_dir_c(icol,ilay,ibnd);
1499  });
1500  rrtmgp::compute_broadband_surface_fluxes(ncol_c, kbot, nswbands,
1501  sw_bnd_flux_dir_c , sw_bnd_flux_dif_c ,
1502  sfc_flux_dir_vis_c, sfc_flux_dir_nir_c,
1503  sfc_flux_dif_vis_c, sfc_flux_dif_nir_c);
1504 
1505  gas_concs_c.reset();
1506  } // end column chunk loop
1507 }
mwdair
constexpr amrex::Real mwdair
Definition: ERF_Constants.H:82
PI
constexpr amrex::Real PI
Definition: ERF_NumericalConstants.H:46
orbital_calday
AMREX_GPU_HOST AMREX_FORCE_INLINE double orbital_calday(int year, int mon, int day, int sec)
Definition: ERF_OrbCosZenith.H:485
orbital_cos_zenith
AMREX_GPU_HOST AMREX_FORCE_INLINE double orbital_cos_zenith(double &jday, double &lat, double &lon, double &declin, double dt_avg=-one, double uniform_angle=-one, double constant_zenith_angle_deg=-one)
Definition: ERF_OrbCosZenith.H:620
orbital_decl
AMREX_GPU_HOST AMREX_FORCE_INLINE void orbital_decl(double &calday, double &eccen, double &mvelpp, double &lambm0, double &obliqr, double &delta, double &eccf)
Definition: ERF_OrbCosZenith.H:18
orbital_params
AMREX_GPU_HOST AMREX_FORCE_INLINE void orbital_params(int &iyear_AD, double &eccen, double &obliq, double &mvelp, double &obliqr, double &lambm0, double &mvelpp)
Definition: ERF_OrbCosZenith.H:84
name
std::string name
Definition: ERF_Plotfile2DCatalog.cpp:116
Radiation::m_dt
double m_dt
Definition: ERF_Radiation.H:290
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:393
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:291
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:335
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,
double &  time,
const double &  dt,
const amrex::BoxArray &  ba,
amrex::Geometry &  geom,
amrex::MultiFab *  cons_in,
amrex::iMultiFab *  lmask,
amrex::MultiFab *  t_surf,
const amrex::Vector< const amrex::MultiFab * > &  lsm_input_ptrs,
amrex::MultiFab *  qheating_rates,
amrex::MultiFab *  rad_fluxes,
amrex::MultiFab *  z_phys,
amrex::MultiFab *  lat,
amrex::MultiFab *  lon,
const bool  force_update 
)
261 {
262  // Set data members that may change
263  m_lev = level;
264  m_step = step;
265  m_time = time;
266  m_dt = dt;
267  m_geom = geom;
268  m_cons_in = cons_in;
269  m_qheating_rates = qheating_rates;
270  m_rad_fluxes = rad_fluxes;
271  m_z_phys = z_phys;
272  m_lat = lat;
273  m_lon = lon;
274 
275  // Update the day and month
276  time_t timestamp = time_t(time);
277  struct tm *timeinfo = gmtime(&timestamp);
278  if (m_fixed_orbital_year) {
279  m_orbital_mon = timeinfo->tm_mon + 1;
280  m_orbital_day = timeinfo->tm_mday;
281  m_orbital_sec = timeinfo->tm_hour*3600 + timeinfo->tm_min*60 + timeinfo->tm_sec;
282  } else {
283  m_orbital_year = timeinfo->tm_year + 1900;
284  m_orbital_mon = timeinfo->tm_mon + 1;
285  m_orbital_day = timeinfo->tm_mday;
286  m_orbital_sec = timeinfo->tm_hour*3600 + timeinfo->tm_min*60 + timeinfo->tm_sec;
287  }
288 
289  // Only allocate and proceed if we are going to update radiation
290  m_update_rad = force_update;
291  if (m_rad_freq_in_steps > 0) {
292  m_update_rad = m_update_rad || (m_step == 0) || (m_step % m_rad_freq_in_steps == 0);
293  }
294 
295  if (m_update_rad) {
296  // Call to Init() has set the dimensions: ncol & nlay
297 
298  // Allocate the buffer arrays
299  alloc_buffers();
300 
301  // Fill the KOKKOS Views from AMReX MFs
302  mf_to_kokkos_buffers(lmask, t_surf, lsm_input_ptrs);
303 
304  // (Re)define the datalog MF whenever the grids change; this must always
305  // match the layout of cons_in since populateDatalogMF() iterates over it
306  // while indexing m_col_offsets and m_qheating_rates.
307  if (datalog_int > 0) {
308  bool needs_define = ( (datalog_mf.boxArray() != cons_in->boxArray()) ||
309  (datalog_mf.DistributionMap() != cons_in->DistributionMap()) );
310  if (needs_define) {
311  datalog_mf.define(cons_in->boxArray(), cons_in->DistributionMap(), 25, 0);
312  datalog_mf.setVal(0.0);
313  }
314  }
315  }
316 }
Radiation::mf_to_kokkos_buffers
void mf_to_kokkos_buffers(amrex::iMultiFab *lmask, amrex::MultiFab *t_surf, const amrex::Vector< const amrex::MultiFab * > &lsm_input_ptrs)
Definition: ERF_Radiation.cpp:564
Radiation::m_step
int m_step
Definition: ERF_Radiation.H:284
Radiation::alloc_buffers
void alloc_buffers()
Definition: ERF_Radiation.cpp:319
Radiation::m_time
double m_time
Definition: ERF_Radiation.H:287

Referenced by Run().

Here is the caller graph for this function:

◆ write_rrtmgp_fluxes()

void Radiation::write_rrtmgp_fluxes ( )
909 {
910  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))});
911  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))});
912  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))});
913  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))});
914  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))});
915 
916  int n_fluxes = 5;
917  MultiFab mf_flux(m_cons_in->boxArray(), m_cons_in->DistributionMap(), n_fluxes, 0);
918 
919  for (MFIter mfi(mf_flux); mfi.isValid(); ++mfi) {
920  const auto& vbx = mfi.validbox();
921  const int nx = vbx.length(0);
922  const int imin = vbx.smallEnd(0);
923  const int jmin = vbx.smallEnd(1);
924  const int offset = m_col_offsets[mfi.index()];
925  const Array4<Real>& dst_arr = mf_flux.array(mfi);
926  ParallelFor(vbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
927  {
928  // map [i,j,k] 0-based to [icol, ilay] 0-based
929  const int icol = (j-jmin)*nx + (i-imin) + offset;
930  const int ilay = k;
931 
932  // SW and LW fluxes
933  dst_arr(i,j,k,0) = sw_flux_up_tab(icol,ilay);
934  dst_arr(i,j,k,1) = sw_flux_dn_tab(icol,ilay);
935  dst_arr(i,j,k,2) = sw_flux_dn_dir_tab(icol,ilay);
936  dst_arr(i,j,k,3) = lw_flux_up_tab(icol,ilay);
937  dst_arr(i,j,k,4) = lw_flux_dn_tab(icol,ilay);
938  });
939  }
940 
941 
942  std::string plotfilename = amrex::Concatenate("plt_rad", m_step, 5);
943  Vector<std::string> flux_names = {"sw_flux_up", "sw_flux_dn", "sw_flux_dir",
944  "lw_flux_up", "lw_flux_dn"};
945  WriteSingleLevelPlotfile(plotfilename, mf_flux, flux_names, m_geom, static_cast<Real>(m_time), m_step);
946 }
Here is the call graph for this function:

◆ WriteDataLog()

void Radiation::WriteDataLog ( const double &  time)
overridevirtual

Implements IRadiation.

1055 {
1056  constexpr int datwidth = 14;
1057  constexpr int datprecision = 9;
1058  constexpr int timeprecision = 13;
1059 
1060  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;
1061  // Clear sky
1062  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;
1063  // Clean sky
1064  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;
1065  // Clean clear sky
1066  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;
1067 
1068 
1069  auto domain = m_geom.Domain();
1070  h_avg_radqrsw = sumToLine(datalog_mf, 0, 1, domain, 2);
1071  h_avg_radqrlw = sumToLine(datalog_mf, 1, 1, domain, 2);
1072  h_avg_sw_up = sumToLine(datalog_mf, 2, 1, domain, 2);
1073  h_avg_sw_dn = sumToLine(datalog_mf, 3, 1, domain, 2);
1074  h_avg_sw_dn_dir = sumToLine(datalog_mf, 4, 1, domain, 2);
1075  h_avg_lw_up = sumToLine(datalog_mf, 5, 1, domain, 2);
1076  h_avg_lw_dn = sumToLine(datalog_mf, 6, 1, domain, 2);
1077  h_avg_zenith = sumToLine(datalog_mf, 7, 1, domain, 2);
1078 
1079  h_avg_radqrcsw = sumToLine(datalog_mf, 8, 1, domain, 2);
1080  h_avg_radqrclw = sumToLine(datalog_mf, 9, 1, domain, 2);
1081  h_avg_sw_clr_up = sumToLine(datalog_mf, 10, 1, domain, 2);
1082  h_avg_sw_clr_dn = sumToLine(datalog_mf, 11, 1, domain, 2);
1083  h_avg_sw_clr_dn_dir = sumToLine(datalog_mf, 12, 1, domain, 2);
1084  h_avg_lw_clr_up = sumToLine(datalog_mf, 13, 1, domain, 2);
1085  h_avg_lw_clr_dn = sumToLine(datalog_mf, 14, 1, domain, 2);
1086 
1087  if (m_extra_clnsky_diag) {
1088  h_avg_sw_cln_up = sumToLine(datalog_mf, 15, 1, domain, 2);
1089  h_avg_sw_cln_dn = sumToLine(datalog_mf, 16, 1, domain, 2);
1090  h_avg_sw_cln_dn_dir = sumToLine(datalog_mf, 17, 1, domain, 2);
1091  h_avg_lw_cln_up = sumToLine(datalog_mf, 18, 1, domain, 2);
1092  h_avg_lw_cln_dn = sumToLine(datalog_mf, 19, 1, domain, 2);
1093  }
1094 
1095  if (m_extra_clnclrsky_diag) {
1096  h_avg_sw_clnclr_up = sumToLine(datalog_mf, 20, 1, domain, 2);
1097  h_avg_sw_clnclr_dn = sumToLine(datalog_mf, 21, 1, domain, 2);
1098  h_avg_sw_clnclr_dn_dir = sumToLine(datalog_mf, 22, 1, domain, 2);
1099  h_avg_lw_clnclr_up = sumToLine(datalog_mf, 23, 1, domain, 2);
1100  h_avg_lw_clnclr_dn = sumToLine(datalog_mf, 24, 1, domain, 2);
1101  }
1102 
1103  Real area_z = static_cast<Real>(domain.length(0)*domain.length(1));
1104  int nz = domain.length(2);
1105  for (int k = 0; k < nz; k++) {
1106  h_avg_radqrsw[k] /= area_z;
1107  h_avg_radqrlw[k] /= area_z;
1108  h_avg_sw_up[k] /= area_z;
1109  h_avg_sw_dn[k] /= area_z;
1110  h_avg_sw_dn_dir[k] /= area_z;
1111  h_avg_lw_up[k] /= area_z;
1112  h_avg_lw_dn[k] /= area_z;
1113  h_avg_zenith[k] /= area_z;
1114 
1115  h_avg_radqrcsw[k] /= area_z;
1116  h_avg_radqrclw[k] /= area_z;
1117  h_avg_sw_clr_up[k] /= area_z;
1118  h_avg_sw_clr_dn[k] /= area_z;
1119  h_avg_sw_clr_dn_dir[k] /= area_z;
1120  h_avg_lw_clr_up[k] /= area_z;
1121  h_avg_lw_clr_dn[k] /= area_z;
1122  }
1123 
1124  if (m_extra_clnsky_diag) {
1125  for (int k = 0; k < nz; k++) {
1126  h_avg_sw_cln_up[k] /= area_z;
1127  h_avg_sw_cln_dn[k] /= area_z;
1128  h_avg_sw_cln_dn_dir[k] /= area_z;
1129  h_avg_lw_cln_up[k] /= area_z;
1130  h_avg_lw_cln_dn[k] /= area_z;
1131  }
1132  }
1133 
1134  if (m_extra_clnclrsky_diag) {
1135  for (int k = 0; k < nz; k++) {
1136  h_avg_sw_clnclr_up[k] /= area_z;
1137  h_avg_sw_clnclr_dn[k] /= area_z;
1138  h_avg_sw_clnclr_dn_dir[k] /= area_z;
1139  h_avg_lw_clnclr_up[k] /= area_z;
1140  h_avg_lw_clnclr_dn[k] /= area_z;
1141  }
1142  }
1143 
1144  if (ParallelDescriptor::IOProcessor()) {
1145  std::ostream& log = *datalog;
1146  if (log.good()) {
1147 
1148  for (int k = 0; k < nz; k++)
1149  {
1150  Real z = k * m_geom.CellSize(2);
1151  log << std::setw(datwidth) << std::setprecision(timeprecision) << time << " "
1152  << std::setw(datwidth) << std::setprecision(datprecision) << z << " "
1153  << h_avg_radqrsw[k] << " " << h_avg_radqrlw[k] << " " << h_avg_sw_up[k] << " "
1154  << h_avg_sw_dn[k] << " " << h_avg_sw_dn_dir[k] << " " << h_avg_lw_up[k] << " "
1155  << h_avg_lw_dn[k] << " " << h_avg_zenith[k] << " "
1156  << h_avg_radqrcsw[k] << " " << h_avg_radqrclw[k] << " " << h_avg_sw_clr_up[k] << " "
1157  << h_avg_sw_clr_dn[k] << " " << h_avg_sw_clr_dn_dir[k] << " " << h_avg_lw_clr_up[k] << " "
1158  << h_avg_lw_clr_dn[k] << " ";
1159  if (m_extra_clnsky_diag) {
1160  log << h_avg_sw_cln_up[k] << " " << h_avg_sw_cln_dn[k] << " " << h_avg_sw_cln_dn_dir[k] << " "
1161  << h_avg_lw_cln_up[k] << " " << h_avg_lw_cln_dn[k] << " ";
1162  } else {
1163  log << zero << " " << zero << " " << zero << " " << zero << " " << zero << " ";
1164  }
1165 
1166  if (m_extra_clnclrsky_diag) {
1167  log << h_avg_sw_clnclr_up[k] << " " << h_avg_sw_clnclr_dn[k] << " " << h_avg_sw_clnclr_dn_dir[k] << " "
1168  << h_avg_lw_clnclr_up[k] << " " << h_avg_lw_clnclr_dn[k] << std::endl;
1169  } else {
1170  log << zero << " " << zero << " " << zero << " " << zero << " " << zero << std::endl;
1171  }
1172  }
1173  // Write top face values
1174  Real z = nz * m_geom.CellSize(2);
1175  log << std::setw(datwidth) << std::setprecision(timeprecision) << time << " "
1176  << std::setw(datwidth) << std::setprecision(datprecision) << z << " "
1177  << zero << " " << zero << " " << zero << " " << zero << " " << zero << " " << zero << " "
1178  << zero << " " << zero << " "
1179  << zero << " " << zero << " " << zero << " " << zero << " " << zero << " " << zero << " "
1180  << zero << " "
1181  << zero << " " << zero << " " << zero << " " << zero << " " << zero << " "
1182  << zero << " " << zero << " " << zero << " " << zero << " " << zero
1183  << std::endl;
1184  }
1185  }
1186 }
Coord::z
@ z
IRadiation::datalog
std::unique_ptr< std::fstream > datalog
Definition: ERF_RadiationInterface.H:102

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_calday

amrex::Real Radiation::m_calday = 0.0
private

Referenced by Run().

◆ 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_declin

amrex::Real Radiation::m_declin = 0.0
private

Referenced by Run().

◆ 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

double 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_fixed_orbital_year

bool Radiation::m_fixed_orbital_year = false
private

◆ m_fixed_solar_zenith_angle

amrex::Real Radiation::m_fixed_solar_zenith_angle
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_is_nested_patch

bool Radiation::m_is_nested_patch = false
private

Referenced by Init(), is_nested_patch(), radiation_updated(), and Run().

◆ m_lat

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

◆ m_lat_cons

amrex::Real Radiation::m_lat_cons
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
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_ncol_chunk_requested

int Radiation::m_ncol_chunk_requested = 1024
private

Referenced by Init().

◆ m_ngas

int Radiation::m_ngas = 8
private

◆ m_nlay

int Radiation::m_nlay
private

Referenced by Init(), and Run().

◆ 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_qi_comp

int Radiation::m_qi_comp = -1
private

◆ m_rad_fluxes

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

◆ m_rad_freq_in_steps

int Radiation::m_rad_freq_in_steps
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_rdOcp

amrex::Real Radiation::m_rdOcp = RdoCp
private

◆ m_step

int Radiation::m_step
private

◆ m_time

double Radiation::m_time
private

◆ m_update_rad

bool Radiation::m_update_rad = false
private

Referenced by rad_run_impl(), and radiation_updated().

◆ 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: