ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
CloudRadProps Class Reference

#include <ERF_Cloud_rad_props.H>

Collaboration diagram for CloudRadProps:

Public Member Functions

 CloudRadProps ()=default
 
 ~CloudRadProps ()=default
 
void initialize ()
 
void gammadist_liq_optics_sw (const int &ncol, const int &nlev, const real2d &iclwpth, const real2d &lamc, const real2d &pgam, real3d &tau, real3d &tau_w, real3d &tau_w_g, real3d &tau_w_f)
 
void gammadist_liq_optics_lw (const int &ncol, const int &nlev, const real2d &iclwpth, const real2d &lamc, const real2d &pgam, real3d &abs_od)
 
void mitchell_ice_optics_sw (const int &ncol, const int &nlev, const real2d &iciwpth, const real2d &dei, real3d &tau, real3d &tau_w, real3d &tau_w_g, real3d &tau_w_f)
 
void mitchell_ice_optics_lw (const int &ncol, const int &nlev, const real2d &iciwpth, const real2d &dei, real3d &abs_od)
 
void gam_liquid_lw (const real &clwptn, const real &lamc, const real &pgam, real1d abs_od)
 
void gam_liquid_sw (const real &clwptn, const real &lamc, const real &pgam, real1d tau, real1d tau_w, real1d tau_w_g, real1d tau_w_f)
 
void get_mu_lambda_weights (const real &lamc, const real &pgam, LinInterp::InterpType &mu_wgts, LinInterp::InterpType &lambda_wgts)
 

Private Attributes

std::string name {"CloudRadProps"}
 
std::string liquid_file
 
std::string ice_file
 
int nlwbands
 
int nswbands
 
int nlambda
 
int nmu
 
int n_g_d
 
real1d g_mu
 
real2d g_lambda
 
real3d ext_sw_liq
 
real3d ssa_sw_liq
 
real3d asm_sw_liq
 
real3d abs_lw_liq
 
real1d g_d_eff
 
real2d ext_sw_ice
 
real2d ssa_sw_ice
 
real2d asm_sw_ice
 
real2d abs_lw_ice
 

Constructor & Destructor Documentation

◆ CloudRadProps()

CloudRadProps::CloudRadProps ( )
default

◆ ~CloudRadProps()

CloudRadProps::~CloudRadProps ( )
default

Member Function Documentation

◆ gam_liquid_lw()

void CloudRadProps::gam_liquid_lw ( const real &  clwptn,
const real &  lamc,
const real &  pgam,
real1d  abs_od 
)
258 {
259  LinInterp::InterpType mu_wgts;
260  LinInterp::InterpType lambda_wgts;
261 
262  real2d abs_lw_liq_2d("abs_lw_liq_2d", nmu, nlambda);
263  real1d abs_od_1d("abs_od_1d", 1);
264 
265  if (clwptn < 1.e-80) {
266  yakl::memset(abs_od, 0.);
267  return;
268  }
269 
270  get_mu_lambda_weights(lamc, pgam, mu_wgts, lambda_wgts);
271 
272  parallel_for(SimpleBounds<1>(nlwbands), YAKL_LAMBDA (int lwband)
273  {
274  for (auto imu=1; imu<=nmu; ++imu) {
275  for (auto ilb=1; ilb<=nlambda; ++ilb) {
276  abs_lw_liq_2d(imu, ilb) = abs_lw_liq(imu, ilb, lwband);
277  }
278  }
279  abs_od_1d(1) = abs_od(lwband);
280  LinInterp::interp2d1d(abs_lw_liq_2d, nmu, nlambda, abs_od_1d, 1, mu_wgts, lambda_wgts);
281  abs_od(lwband) = clwptn*abs_od_1d(1);
282  });
283 
284  parallel_for(SimpleBounds<1>(nlwbands) , YAKL_LAMBDA (int iband)
285  {
286  abs_od(iband) = clwptn * abs_od(iband);
287  });
288 }
real3d abs_lw_liq
Definition: ERF_Cloud_rad_props.H:88
int nlambda
Definition: ERF_Cloud_rad_props.H:81
void get_mu_lambda_weights(const real &lamc, const real &pgam, LinInterp::InterpType &mu_wgts, LinInterp::InterpType &lambda_wgts)
Definition: ERF_Cloud_rad_props.cpp:344
int nlwbands
Definition: ERF_Cloud_rad_props.H:81
int nmu
Definition: ERF_Cloud_rad_props.H:81
static YAKL_INLINE void interp2d1d(const real2d &arrin, const int &n1, const int &n2, const real1d &arrout, const int &m1, const InterpType &wgt1, const InterpType &wgt2)
Definition: ERF_Linear_interpolate.H:309
Definition: ERF_Linear_interpolate.H:20

Referenced by gammadist_liq_optics_lw().

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

◆ gam_liquid_sw()

void CloudRadProps::gam_liquid_sw ( const real &  clwptn,
const real &  lamc,
const real &  pgam,
real1d  tau,
real1d  tau_w,
real1d  tau_w_g,
real1d  tau_w_f 
)
297 {
298  real1d extb("ext", nswbands),
299  ssab("ssa", nswbands),
300  asmb("asm", nswbands);
301 
302  real2d ext_sw_liq_2d("ext_sw_liq_2d", nmu, nlambda),
303  ssa_sw_liq_2d("ssa_sw_liq_2d", nmu, nlambda),
304  asm_sw_liq_2d("asm_sw_liq_2d", nmu, nlambda);
305 
306  LinInterp::InterpType mu_wgts;
307  LinInterp::InterpType lambda_wgts;
308 
309  if (clwptn < 1.e-80) {
310  yakl::memset(tau, 0.);
311  yakl::memset(tau_w, 0.);
312  yakl::memset(tau_w_g, 0.);
313  yakl::memset(tau_w_f, 0.);
314  return;
315  }
316 
317  get_mu_lambda_weights(lamc, pgam, mu_wgts, lambda_wgts);
318 
319  parallel_for(SimpleBounds<1>(nswbands), YAKL_LAMBDA (int swband)
320  {
321  for (auto imu=1; imu<=nmu; ++imu) {
322  for (auto lb=1; lb<=nlambda; ++lb) {
323  ext_sw_liq_2d(imu,lb) = ext_sw_liq(imu,lb,swband);
324  ssa_sw_liq_2d(imu,lb) = ssa_sw_liq(imu,lb,swband);
325  asm_sw_liq_2d(imu,lb) = asm_sw_liq(imu,lb,swband);
326  }
327  }
328  LinInterp::interp2d1d(ext_sw_liq_2d, nmu, nlambda, extb, 1, mu_wgts, lambda_wgts);
329  LinInterp::interp2d1d(ssa_sw_liq_2d, nmu, nlambda, ssab, 1, mu_wgts, lambda_wgts);
330  LinInterp::interp2d1d(asm_sw_liq_2d, nmu, nlambda, asmb, 1, mu_wgts, lambda_wgts);
331  });
332 
333  // compute radiative properties
334  parallel_for(SimpleBounds<1>(nswbands), YAKL_LAMBDA (int iband)
335  {
336  tau(iband) = clwptn * extb(iband);
337  tau_w(iband) = tau(iband) * ssab(iband);
338  tau_w_g(iband) = tau_w(iband) * asmb(iband);
339  tau_w_f(iband) = tau_w_g(iband) * asmb(iband);
340  });
341 }
real3d ssa_sw_liq
Definition: ERF_Cloud_rad_props.H:86
real3d ext_sw_liq
Definition: ERF_Cloud_rad_props.H:85
real3d asm_sw_liq
Definition: ERF_Cloud_rad_props.H:87
int nswbands
Definition: ERF_Cloud_rad_props.H:81

Referenced by gammadist_liq_optics_sw().

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

◆ gammadist_liq_optics_lw()

void CloudRadProps::gammadist_liq_optics_lw ( const int &  ncol,
const int &  nlev,
const real2d &  iclwpth,
const real2d &  lamc,
const real2d &  pgam,
real3d &  abs_od 
)
138 {
139  auto abs_od_1d = real1d("abs_od_1d", nlwbands);
140  parallel_for(SimpleBounds<2>(ncol, nlev), YAKL_LAMBDA (int i, int k)
141  {
142  if(lamc(i,k) > 0.) { // This seems to be the clue for no cloud from microphysics formulation
143  for (auto ib=1; ib<=nlwbands; ++ib) abs_od_1d(ib) = abs_od(ib,i,k);
144  gam_liquid_lw(iclwpth(i,k), lamc(i,k), pgam(i,k), abs_od_1d);
145  }
146  else {
147  for(auto j=1; j<=nlwbands; ++j) abs_od(j,i,k) = 0.;
148  }
149  });
150 }
void gam_liquid_lw(const real &clwptn, const real &lamc, const real &pgam, real1d abs_od)
Definition: ERF_Cloud_rad_props.cpp:254

Referenced by Optics::get_cloud_optics_lw().

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

◆ gammadist_liq_optics_sw()

void CloudRadProps::gammadist_liq_optics_sw ( const int &  ncol,
const int &  nlev,
const real2d &  iclwpth,
const real2d &  lamc,
const real2d &  pgam,
real3d &  tau,
real3d &  tau_w,
real3d &  tau_w_g,
real3d &  tau_w_f 
)
105 {
106  real1d tau1d("tau1d", nswbands);
107  real1d tauw1d("tauw1d", nswbands);
108  real1d tauwg1d("tauwg1d", nswbands);
109  real1d tauwf1d("tauwf1d", nswbands);
110  parallel_for(SimpleBounds<2>(ncol, nlev), YAKL_LAMBDA (int i, int k)
111  {
112  if(lamc(i,k) > 0.) { // This seems to be clue from microphysics of no cloud
113  for (auto iband=1; iband<=nswbands; ++iband) {
114  tau1d(iband) = tau(iband,i,k);
115  tauw1d(iband) = tau_w(iband,i,k);
116  tauwg1d(iband) = tau_w_g(iband,i,k);
117  tauwf1d(iband) = tau_w_f(iband,i,k);
118  }
119  gam_liquid_sw(iclwpth(i,k), lamc(i,k), pgam(i,k), tau1d, tauw1d, tauwg1d, tauwf1d);
120  }
121  else {
122  for (auto iband=1; iband<=nswbands; ++iband) {
123  tau(iband,i,k) = 0.;
124  tau_w(iband,i,k) = 0.;
125  tau_w_g(iband,i,k) = 0.;
126  tau_w_f(iband,i,k) = 0.;
127  }
128  }
129  });
130 }
void gam_liquid_sw(const real &clwptn, const real &lamc, const real &pgam, real1d tau, real1d tau_w, real1d tau_w_g, real1d tau_w_f)
Definition: ERF_Cloud_rad_props.cpp:290

Referenced by Optics::get_cloud_optics_sw().

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

◆ get_mu_lambda_weights()

void CloudRadProps::get_mu_lambda_weights ( const real &  lamc,
const real &  pgam,
LinInterp::InterpType mu_wgts,
LinInterp::InterpType lambda_wgts 
)
348 {
349  real1d g_lambda_interp("g_lambda_interp", nlambda);
350  real1d pgam1d("pgam1d", nmu);
351  real1d lamc1d("lam1d", nmu);
352  real1d g_lambda1d("g_lambda1d", nmu);
353 
354  yakl::memset(pgam1d, pgam);
355  yakl::memset(lamc1d, lamc);
356 
357  real1d g_mu0 = real1d("g_mu0",nmu);
358 
359  // Make interpolation weights for mu.
360  // (Put pgam in a temporary array for this purpose.)
361  LinInterp::init(g_mu0, nmu, pgam1d, 1, LinInterp::extrap_method_bndry, mu_wgts);
362 
363  // Use mu weights to interpolate to a row in the lambda table.
364  parallel_for(SimpleBounds<1>(nlambda), YAKL_LAMBDA (int i)
365  {
366  for (auto im=1; im<=nmu; ++im) g_lambda1d(im) = g_lambda(im, i);
367  LinInterp::interp1d(g_lambda1d, nmu, g_lambda_interp, 1, mu_wgts);
368  });
369 
370  // Make interpolation weights for lambda.
371  LinInterp::init(g_lambda_interp, nlambda, lamc1d, 1, LinInterp::extrap_method_bndry, lambda_wgts);
372 }
real2d g_lambda
Definition: ERF_Cloud_rad_props.H:84
static YAKL_INLINE void init(const real1d &yin, const int &n_in, const real1d &yout, const int &nout, const InterpMethod &extrap_method, InterpType &interp_wgts, real cyclicmin=0., real cyclicmax=0.)
Definition: ERF_Linear_interpolate.H:40
@ extrap_method_bndry
Definition: ERF_Linear_interpolate.H:16
static YAKL_INLINE void interp1d(const real1d &arrin, const int &n1, const real1d &arrout, const int &m1, const InterpType &interp_wgts)
Definition: ERF_Linear_interpolate.H:268

Referenced by gam_liquid_lw(), and gam_liquid_sw().

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

◆ initialize()

void CloudRadProps::initialize ( )
12 {
13  realHost1d g_mu_h; // mu samples on grid
14  realHost2d g_lambda_h; // lambda scale samples on grid
15  realHost3d ext_sw_liq_h;
16  realHost3d ssa_sw_liq_h;
17  realHost3d asm_sw_liq_h;
18  realHost3d abs_lw_liq_h;
19 
20  realHost1d g_d_eff_h; // radiative effective diameter samples on grid
21  realHost2d ext_sw_ice_h;
22  realHost2d ssa_sw_ice_h;
23  realHost2d asm_sw_ice_h;
24  realHost2d abs_lw_ice_h;
25 
26  auto erf_rad_data_dir = getRadiationDataDir() + "/";
27  liquid_file = erf_rad_data_dir + "F_nwvl200_mu20_lam50_res64_t298_c080428.nc";
28  ice_file = erf_rad_data_dir + "iceoptics_c080917.nc";
29 
30  yakl::SimpleNetCDF liquid, ice;
31  liquid.open(liquid_file, yakl::NETCDF_MODE_READ);
32  ice.open(ice_file, yakl::NETCDF_MODE_READ);
33 
34  // read the dimensions
35  nlwbands = liquid.getDimSize( "lw_band" );
36  nswbands = liquid.getDimSize( "sw_band" );
37  nmu = liquid.getDimSize( "mu" );
38  nlambda = liquid.getDimSize( "lambda_scale" );
39 
40  liquid.read( g_mu_h, "mu");
41  liquid.read( g_lambda_h, "lambda");
42  liquid.read( ext_sw_liq_h, "k_ext_sw");
43  liquid.read( ssa_sw_liq_h, "ssa_sw");
44  liquid.read( asm_sw_liq_h, "asm_sw");
45  liquid.read( abs_lw_liq_h, "k_abs_lw");
46 
47  g_mu = real1d("gmu", nmu);
48  g_lambda = real2d("g_lambda", nmu, nlambda);
49  ext_sw_liq = real3d("ext_sw_liq", nmu, nlambda, nswbands);
50  ssa_sw_liq = real3d("ssa_sw_liq", nmu, nlambda, nswbands);
51  asm_sw_liq = real3d("asm_sw_liq", nmu, nlambda, nswbands);
52  abs_lw_liq = real3d("abs_lw_liq", nmu, nlambda, nlwbands);
53 
54  g_mu_h.deep_copy_to(g_mu);
55  g_lambda_h.deep_copy_to(g_lambda);
56  ext_sw_liq_h.deep_copy_to(ext_sw_liq);
57  ssa_sw_liq_h.deep_copy_to(ssa_sw_liq);
58  asm_sw_liq_h.deep_copy_to(asm_sw_liq);
59  abs_lw_liq_h.deep_copy_to(abs_lw_liq);
60 
61  // I forgot to convert kext from m^2/Volume to m^2/Kg
62  parallel_for(SimpleBounds<3>(nmu,nlambda,nswbands) , YAKL_LAMBDA (int i, int j, int k)
63  {
64  ext_sw_liq(i,j,k) = ext_sw_liq(i,j,k) / 0.9970449e3;
65  });
66 
67  parallel_for(SimpleBounds<3>(nmu,nlambda,nlwbands) , YAKL_LAMBDA (int i, int j, int k)
68  {
69  abs_lw_liq(i,j,k) = abs_lw_liq(i,j,k) / 0.9970449e3;
70  });
71 
72  // read ice cloud optics
73  nlwbands = ice.getDimSize( "lw_band" );
74  nswbands = ice.getDimSize( "sw_band" );
75  n_g_d = ice.getDimSize( "d_eff" );
76 
77  ice.read( g_d_eff_h, "d_eff");
78  ice.read( ext_sw_ice_h, "sw_ext");
79  ice.read( ssa_sw_ice_h, "sw_ssa");
80  ice.read( asm_sw_ice_h, "sw_asm");
81  ice.read( abs_lw_ice_h, "lw_abs");
82 
83  g_d_eff = real1d("g_d_eff",n_g_d);
84  ext_sw_ice = real2d("ext_sw_ice", n_g_d, nswbands);
85  ssa_sw_ice = real2d("ssa_sw_ice", n_g_d, nswbands);
86  asm_sw_ice = real2d("asm_sw_ice", n_g_d, nswbands);
87  abs_lw_ice = real2d("abs_lw_ice", n_g_d, nlwbands);
88 
89  g_d_eff_h.deep_copy_to(g_d_eff);
90  ext_sw_ice_h.deep_copy_to(ext_sw_ice);
91  ssa_sw_ice_h.deep_copy_to(ssa_sw_ice);
92  asm_sw_ice_h.deep_copy_to(asm_sw_ice);
93  abs_lw_ice_h.deep_copy_to(abs_lw_ice);
94 }
std::string liquid_file
Definition: ERF_Cloud_rad_props.H:78
real2d abs_lw_ice
Definition: ERF_Cloud_rad_props.H:94
real1d g_mu
Definition: ERF_Cloud_rad_props.H:83
int n_g_d
Definition: ERF_Cloud_rad_props.H:81
real2d ext_sw_ice
Definition: ERF_Cloud_rad_props.H:91
std::string ice_file
Definition: ERF_Cloud_rad_props.H:79
real2d ssa_sw_ice
Definition: ERF_Cloud_rad_props.H:92
real1d g_d_eff
Definition: ERF_Cloud_rad_props.H:90
real2d asm_sw_ice
Definition: ERF_Cloud_rad_props.H:93

Referenced by Optics::initialize().

Here is the caller graph for this function:

◆ mitchell_ice_optics_lw()

void CloudRadProps::mitchell_ice_optics_lw ( const int &  ncol,
const int &  nlev,
const real2d &  iciwpth,
const real2d &  dei,
real3d &  abs_od 
)
220 {
221  real1d absor("absor", nlwbands);
222  real1d dei_1d("dei_1d",1);
223  real1d abs_lw_ice_1d("abs_lw_ice_1d",n_g_d);
224 
225  real1d absor_1d("absor_1d",1);
226 
227  parallel_for(SimpleBounds<2>(ncol, nlev), YAKL_LAMBDA (int i, int k)
228  {
229  // if ice water path is too small, OD := 0
230  if(iciwpth(i,k) < 1.e-80 || dei(i,k) == 0.) {
231  for (auto lb=1; lb<=nlwbands; ++lb) {
232  abs_od (lb,i,k) = 0.;
233  }
234  }
235  else {
236  // for each cell interpolate to find weights in g_d_eff grid.
237  dei_1d(1) = dei(i,k);
238  LinInterp::InterpType dei_wgts;
240  // interpolate into grid and extract radiative properties
241  for(auto lwband = 1; lwband <= nlwbands; ++lwband) {
242  absor_1d(1) = absor(lwband);
243  LinInterp::interp1d(abs_lw_ice_1d, n_g_d, absor_1d, 1, dei_wgts);
244  absor(lwband) = absor_1d(1);
245  }
246  for (auto lwband = 1; lwband <= nlwbands; ++lwband) {
247  abs_od(lwband,i,k) = iciwpth(i,k) * absor(lwband);
248  }
249  }
250  });
251 }

Referenced by Optics::get_cloud_optics_lw().

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

◆ mitchell_ice_optics_sw()

void CloudRadProps::mitchell_ice_optics_sw ( const int &  ncol,
const int &  nlev,
const real2d &  iciwpth,
const real2d &  dei,
real3d &  tau,
real3d &  tau_w,
real3d &  tau_w_g,
real3d &  tau_w_f 
)
161 {
162  real1d ext("ext", nswbands),
163  ssa("ssa", nswbands),
164  assm("assm", nswbands);
165 
166  real1d ext_sw_ice_1d("ext_sw_ice_1d", n_g_d),
167  ssa_sw_ice_1d("ssa_sw_ice_1d", n_g_d),
168  asm_sw_ice_1d("asm_sw_ice_1d", n_g_d);
169 
170  real1d dei_1d("dei_1d",1);
171  auto ext_1d = real1d("ext_1d",1);
172  auto ssa_1d = real1d("ssa_1d",1);
173  auto assm_1d = real1d("assm_1d",1);
174 
175  parallel_for(SimpleBounds<2>(ncol, nlev), YAKL_LAMBDA (int i, int k)
176  {
177  if( iciwpth(i,k) < 1.e-80 || dei(i,k) == 0.) {
178  // if ice water path is too small
179  for(auto ib=1; ib<=nswbands; ++ib) {
180  tau (ib,i,k) = 0.;
181  tau_w (ib,i,k) = 0.;
182  tau_w_g(ib,i,k) = 0.;
183  tau_w_f(ib,i,k) = 0.;
184  }
185  }
186  else {
187  // for each cell interpolate to find weights in g_d_eff grid.
188  dei_1d(1) = dei(i,k);
189  LinInterp::InterpType dei_wgts;
191  // interpolate into grid and extract radiative properties
192  for (auto is=1; is<=nswbands; ++is) {
193  for(auto ig=1; ig<=n_g_d; ++ig) {
194  ext_sw_ice_1d(ig) = ext_sw_ice(ig, is);
195  ssa_sw_ice_1d(ig) = ssa_sw_ice(ig, is);
196  asm_sw_ice_1d(ig) = asm_sw_ice(ig, is);
197  }
198  ext_1d(1) = ext(is);
199  ssa_1d(1) = ssa(is);
200  assm_1d(1) = assm(is);
201  LinInterp::interp1d(ext_sw_ice_1d, n_g_d, ext_1d, 1, dei_wgts);
202  LinInterp::interp1d(ssa_sw_ice_1d, n_g_d, ssa_1d, 1, dei_wgts);
203  LinInterp::interp1d(asm_sw_ice_1d, n_g_d, assm_1d, 1, dei_wgts);
204  }
205  for (auto is=1; is<=nswbands; ++is) {
206  tau (is,i,k) = iciwpth(i,k) * ext(is);
207  tau_w (is,i,k) = tau(is,i,k) * ssa(is);
208  tau_w_g(is,i,k) = tau_w(is,i,k) * assm(is);
209  tau_w_f(is,i,k) = tau_w_g(is,i,k) * assm(is);
210  }
211  }
212  });
213 }

Referenced by Optics::get_cloud_optics_sw().

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

Member Data Documentation

◆ abs_lw_ice

real2d CloudRadProps::abs_lw_ice
private

Referenced by initialize().

◆ abs_lw_liq

real3d CloudRadProps::abs_lw_liq
private

Referenced by gam_liquid_lw(), and initialize().

◆ asm_sw_ice

real2d CloudRadProps::asm_sw_ice
private

◆ asm_sw_liq

real3d CloudRadProps::asm_sw_liq
private

Referenced by gam_liquid_sw(), and initialize().

◆ ext_sw_ice

real2d CloudRadProps::ext_sw_ice
private

◆ ext_sw_liq

real3d CloudRadProps::ext_sw_liq
private

Referenced by gam_liquid_sw(), and initialize().

◆ g_d_eff

real1d CloudRadProps::g_d_eff
private

◆ g_lambda

real2d CloudRadProps::g_lambda
private

◆ g_mu

real1d CloudRadProps::g_mu
private

Referenced by initialize().

◆ ice_file

std::string CloudRadProps::ice_file
private

Referenced by initialize().

◆ liquid_file

std::string CloudRadProps::liquid_file
private

Referenced by initialize().

◆ n_g_d

int CloudRadProps::n_g_d
private

◆ name

std::string CloudRadProps::name {"CloudRadProps"}
private

◆ nlambda

int CloudRadProps::nlambda
private

◆ nlwbands

int CloudRadProps::nlwbands
private

◆ nmu

int CloudRadProps::nmu
private

◆ nswbands

int CloudRadProps::nswbands
private

◆ ssa_sw_ice

real2d CloudRadProps::ssa_sw_ice
private

◆ ssa_sw_liq

real3d CloudRadProps::ssa_sw_liq
private

Referenced by gam_liquid_sw(), and initialize().


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