REMORA
Regional Modeling of Oceans Refined Adaptively
Loading...
Searching...
No Matches
REMORA_init_from_netcdf.cpp
Go to the documentation of this file.
1/**
2 * \file REMORA_init_from_netcdf.cpp
3 */
4
5#include <REMORA.H>
6#include <REMORA_Constants.H>
7#include <REMORA_prob_common.H>
8#include <REMORA_DataStruct.H>
9
10using namespace amrex;
11
12#ifdef REMORA_USE_NETCDF
13
14/** \brief helper function for reading in initial state data from netcdf */
15void
16read_data_from_netcdf (int /*lev*/, const Box& domain, const std::string& fname,
17 FArrayBox& NC_temp_fab, FArrayBox& NC_salt_fab,
18 FArrayBox& NC_xvel_fab, FArrayBox& NC_yvel_fab,
19 FArrayBox& NC_ubar_fab, FArrayBox& NC_vbar_fab);
20
21/** \brief helper function for reading in land-sea masks from netcdf */
22void
23read_masks_from_netcdf (int /*lev*/, const Box& domain, const std::string& fname,
24 FArrayBox& NC_mskr_fab, FArrayBox& NC_msku_fab,
25 FArrayBox& NC_mskv_fab);
26
27/** \brief helper function for reading boundary data from netcdf */
28Real
29read_bdry_from_netcdf (const Box& domain, const std::string& fname,
30 Vector<Vector<FArrayBox>>& bdy_data_xlo,
31 Vector<Vector<FArrayBox>>& bdy_data_xhi,
32 Vector<Vector<FArrayBox>>& bdy_data_ylo,
33 Vector<Vector<FArrayBox>>& bdy_data_yhi,
34 int& width, amrex::Real& start_bdy_time,
35 std::string bdry_time_varname,
36 amrex::GpuArray<amrex::GpuArray<bool, AMREX_SPACEDIM*2>,BdyVars::NumTypes+1>&);
37
38/** \brief helper function to initialize state from netcdf */
39void
40init_state_from_netcdf (int lev,
41 FArrayBox& temp_fab, FArrayBox& salt_fab,
42 FArrayBox& x_vel_fab, FArrayBox& y_vel_fab,
43 FArrayBox& ubar_fab, FArrayBox& vbar_fab,
44 const Vector<FArrayBox>& NC_temp_fab,
45 const Vector<FArrayBox>& NC_salt_fab,
46 const Vector<FArrayBox>& NC_xvel_fab,
47 const Vector<FArrayBox>& NC_yvel_fab,
48 const Vector<FArrayBox>& NC_ubar_fab,
49 const Vector<FArrayBox>& NC_vbar_fab);
50
51/** \brief helper function to read bathymetry from netcdf */
52void
53read_bathymetry_from_netcdf (int lev, const Box& domain, const std::string& fname,
54 FArrayBox& NC_h_fab,
55 FArrayBox& NC_pm_fab, FArrayBox& NC_pn_fab,
56 FArrayBox& NC_xr_fab, FArrayBox& NC_yr_fab,
57 FArrayBox& NC_xu_fab, FArrayBox& NC_yu_fab,
58 FArrayBox& NC_xv_fab, FArrayBox& NC_yv_fab,
59 FArrayBox& NC_xp_fab, FArrayBox& NC_yp_fab);
60
61/** \brief helper function to read coriolis factor from netcdf */
62void
63read_coriolis_from_netcdf (int lev, const Box& domain, const std::string& fname, FArrayBox& NC_fcor_fab);
64
65/** \brief helper function to read sea surface height from netcdf */
66void
67read_zeta_from_netcdf (int lev, const Box& domain, const std::string& fname,
68 FArrayBox& NC_zeta_fab);
69
70/** \brief helper function to read climatology nudging from netcdf */
71void
72read_clim_nudg_coeff_from_netcdf (int lev, const Box& domain, const std::string& fname,
73 bool do_m2_clim_nudg,
74 bool do_m3_clim_nudg,
75 bool do_temp_clim_nudg,
76 bool do_salt_clim_nudg,
77 FArrayBox& NC_M2NC_fab,
78 FArrayBox& NC_M3NC_fab,
79 FArrayBox& NC_TempNC_fab,
80 FArrayBox& NC_SaltNC_fab);
81
82/** \brief helper function to read in vector of data from netcdf */
83//template <typename DType>
84void read_vec_from_netcdf (int lev, const std::string& fname, const std::string& field_name, amrex::Vector<int>& vec_dat);
85
86/**
87 * @param lev Integer specifying the current level
88 */
89void
90REMORA::init_data_from_netcdf (int lev)
91{
92 // *** FArrayBox's at this level for holding the INITIAL data
93 Vector<FArrayBox> NC_temp_fab ; NC_temp_fab.resize(num_boxes_at_level[lev]);
94 Vector<FArrayBox> NC_salt_fab ; NC_salt_fab.resize(num_boxes_at_level[lev]);
95 Vector<FArrayBox> NC_xvel_fab ; NC_xvel_fab.resize(num_boxes_at_level[lev]);
96 Vector<FArrayBox> NC_yvel_fab ; NC_yvel_fab.resize(num_boxes_at_level[lev]);
97 Vector<FArrayBox> NC_ubar_fab ; NC_ubar_fab.resize(num_boxes_at_level[lev]);
98 Vector<FArrayBox> NC_vbar_fab ; NC_vbar_fab.resize(num_boxes_at_level[lev]);
99
100 for (int idx = 0; idx < num_boxes_at_level[lev]; idx++)
101 {
102 read_data_from_netcdf(lev, boxes_at_level[lev][idx], nc_init_file[lev][idx],
103 NC_temp_fab[idx], NC_salt_fab[idx],
104 NC_xvel_fab[idx], NC_yvel_fab[idx],
105 NC_ubar_fab[idx], NC_vbar_fab[idx]);
106 }
107
108
109 MultiFab mf_temp(*cons_new[lev], make_alias, Temp_comp, 1);
110 MultiFab mf_salt(*cons_new[lev], make_alias, Salt_comp, 1);
111
112#ifdef _OPENMP
113#pragma omp parallel if (amrex::Gpu::notInLaunchRegion())
114#endif
115 {
116 // Don't tile this since we are operating on full FABs in this routine
117 for ( MFIter mfi(*cons_new[lev], false); mfi.isValid(); ++mfi )
118 {
119 // Define fabs for holding the initial data
120 FArrayBox &temp_fab = mf_temp[mfi];
121 FArrayBox &salt_fab = mf_salt[mfi];
122 FArrayBox &xvel_fab = (*xvel_new[lev])[mfi];
123 FArrayBox &yvel_fab = (*yvel_new[lev])[mfi];
124 FArrayBox &ubar_fab = (*vec_ubar[lev])[mfi];
125 FArrayBox &vbar_fab = (*vec_vbar[lev])[mfi];
126
127 init_state_from_netcdf(lev, temp_fab, salt_fab,
128 xvel_fab, yvel_fab,
129 ubar_fab, vbar_fab,
130 NC_temp_fab, NC_salt_fab,
131 NC_xvel_fab, NC_yvel_fab,
132 NC_ubar_fab, NC_vbar_fab);
133 } // mf
134 } // omp
135}
136
137/**
138 * @param lev Integer specifying the current level
139 */
140void
141REMORA::init_zeta_from_netcdf (int lev)
142{
143 // *** FArrayBox's at this level for holding the INITIAL data
144 Vector<FArrayBox> NC_zeta_fab ; NC_zeta_fab.resize(num_boxes_at_level[lev]);
145
146 for (int idx = 0; idx < num_boxes_at_level[lev]; idx++)
147 {
148 read_zeta_from_netcdf(lev,boxes_at_level[lev][idx], nc_init_file[lev][idx],
149 NC_zeta_fab[idx]);
150
151#ifdef _OPENMP
152#pragma omp parallel if (amrex::Gpu::notInLaunchRegion())
153#endif
154 {
155 // Don't tile this since we are operating on full FABs in this routine
156 for ( MFIter mfi(*cons_new[lev], false); mfi.isValid(); ++mfi )
157 {
158 FArrayBox &zeta_fab = (*vec_zeta[lev])[mfi];
159
160 //
161 // FArrayBox to FArrayBox copy does "copy on intersection"
162 // This only works here because we have broadcast the FArrayBox of data from the netcdf file to all ranks
163 //
164
165 zeta_fab.template copy<RunOn::Device>(NC_zeta_fab[idx],0,0,1);
166 } // mf
167 } // omp
168 } // idx
169
170 vec_zeta[lev]->FillBoundary(geom[lev].periodicity());
171 (*physbcs[lev])(*vec_zeta[lev],*vec_mskr[lev].get(),0,1,vec_zeta[lev]->nGrowVect(),t_new[lev],BCVars::zeta_bc,0,*vec_zeta[lev],*vec_msku[lev],*vec_mskv[lev]);
172// (*physbcs[lev])(*vec_zeta[lev],*vec_mskr[lev].get(),1,1,vec_zeta[lev]->nGrowVect(),t_new[lev],BCVars::zeta_bc);
173// (*physbcs[lev])(*vec_zeta[lev],*vec_mskr[lev].get(),2,1,vec_zeta[lev]->nGrowVect(),t_new[lev],BCVars::zeta_bc);
174
175 if (solverChoice.boundary_from_netcdf) {
176 Real told = t_new[lev];
177 fill_from_bdyfiles(lev, *vec_zeta[lev], *vec_mskr[lev], told, BCVars::zeta_bc,BdyVars::zeta,0,0,
178 *vec_zeta[lev]);
179 }
180 if (lev>0) {
181 FillPatch(lev, t_old[lev], *vec_zeta[lev], GetVecOfPtrs(vec_zeta), BCVars::zeta_bc, BdyVars::zeta,
182 0, false,false,0,0,0.0,*vec_zeta[lev]);
183 }
184// fill_from_bdyfiles(lev, *vec_zeta[lev], *vec_mskr[lev], told, BCVars::zeta_bc,BdyVars::zeta,1,1);
185// fill_from_bdyfiles(lev, *vec_zeta[lev], *vec_mskr[lev], told, BCVars::zeta_bc,BdyVars::zeta,2,2);
186}
187/**
188 * @param lev Integer specifying the current level
189 */
190void
191REMORA::init_bathymetry_from_netcdf (int lev)
192{
193 // *** FArrayBox's at this level for holding the INITIAL data
194 Vector<FArrayBox> NC_h_fab ; NC_h_fab.resize(num_boxes_at_level[lev]);
195 Vector<FArrayBox> NC_pm_fab ; NC_pm_fab.resize(num_boxes_at_level[lev]);
196 Vector<FArrayBox> NC_pn_fab ; NC_pn_fab.resize(num_boxes_at_level[lev]);
197
198 Vector<FArrayBox> NC_xr_fab ; NC_xr_fab.resize(num_boxes_at_level[lev]);
199 Vector<FArrayBox> NC_yr_fab ; NC_yr_fab.resize(num_boxes_at_level[lev]);
200 Vector<FArrayBox> NC_xu_fab ; NC_xu_fab.resize(num_boxes_at_level[lev]);
201 Vector<FArrayBox> NC_yu_fab ; NC_yu_fab.resize(num_boxes_at_level[lev]);
202 Vector<FArrayBox> NC_xv_fab ; NC_xv_fab.resize(num_boxes_at_level[lev]);
203 Vector<FArrayBox> NC_yv_fab ; NC_yv_fab.resize(num_boxes_at_level[lev]);
204 Vector<FArrayBox> NC_xp_fab ; NC_xp_fab.resize(num_boxes_at_level[lev]);
205 Vector<FArrayBox> NC_yp_fab ; NC_yp_fab.resize(num_boxes_at_level[lev]);
206
207 for (int idx = 0; idx < num_boxes_at_level[lev]; idx++)
208 {
209 read_bathymetry_from_netcdf(lev, boxes_at_level[lev][idx], nc_grid_file[lev][idx],
210 NC_h_fab[idx],
211 NC_pm_fab[idx], NC_pn_fab[idx],
212 NC_xr_fab[idx], NC_yr_fab[idx],
213 NC_xu_fab[idx], NC_yu_fab[idx],
214 NC_xv_fab[idx], NC_yv_fab[idx],
215 NC_xp_fab[idx], NC_yp_fab[idx]);
216
217#ifdef _OPENMP
218#pragma omp parallel if (amrex::Gpu::notInLaunchRegion())
219#endif
220 {
221 // Don't tile this since we are operating on full FABs in this routine
222 for ( MFIter mfi(*cons_new[lev], false); mfi.isValid(); ++mfi )
223 {
224 FArrayBox &h_fab = (*vec_h[lev])[mfi];
225 FArrayBox &pm_fab = (*vec_pm[lev])[mfi];
226 FArrayBox &pn_fab = (*vec_pn[lev])[mfi];
227 FArrayBox &xr_fab = (*vec_xr[lev])[mfi];
228 FArrayBox &yr_fab = (*vec_yr[lev])[mfi];
229 FArrayBox &xu_fab = (*vec_xu[lev])[mfi];
230 FArrayBox &yu_fab = (*vec_yu[lev])[mfi];
231 FArrayBox &xv_fab = (*vec_xv[lev])[mfi];
232 FArrayBox &yv_fab = (*vec_yv[lev])[mfi];
233 FArrayBox &xp_fab = (*vec_xp[lev])[mfi];
234 FArrayBox &yp_fab = (*vec_yp[lev])[mfi];
235
236 //
237 // FArrayBox to FArrayBox copy does "copy on intersection"
238 // This only works here because we have broadcast the FArrayBox of data from the netcdf file to all ranks
239 //
240
241 // Copy into both components of h
242 h_fab.template copy<RunOn::Device>(NC_h_fab[idx],0,0,1);
243 h_fab.template copy<RunOn::Device>(NC_h_fab[idx],0,1,1);
244
245 pm_fab.template copy<RunOn::Device>(NC_pm_fab[idx]);
246 pn_fab.template copy<RunOn::Device>(NC_pn_fab[idx]);
247
248 xr_fab.template copy<RunOn::Device>(NC_xr_fab[idx]);
249 yr_fab.template copy<RunOn::Device>(NC_yr_fab[idx]);
250 xu_fab.template copy<RunOn::Device>(NC_xu_fab[idx]);
251 yu_fab.template copy<RunOn::Device>(NC_yu_fab[idx]);
252 xv_fab.template copy<RunOn::Device>(NC_xv_fab[idx]);
253 yv_fab.template copy<RunOn::Device>(NC_yv_fab[idx]);
254 xp_fab.template copy<RunOn::Device>(NC_xp_fab[idx]);
255 yp_fab.template copy<RunOn::Device>(NC_yp_fab[idx]);
256 } // mf
257 } // omp
258 } // idx
259
260 const double dummy_time = 0.0_rt;
261 // Unconditional foextrap will overwrite periodicity, but EnforcePeriodicity will
262 // be called on h afterwards
263 FillPatch(lev,dummy_time,*vec_h[lev],GetVecOfPtrs(vec_h),
264 BCVars::foextrap_periodic_bc,
265 BdyVars::null,0,false,true,1);
266 FillPatch(lev,dummy_time,*vec_h[lev],GetVecOfPtrs(vec_h),
267 BCVars::foextrap_periodic_bc,
268 BdyVars::null,1,false,true,1);
269
270 if (lev > 0) {
271 FillPatch(lev,dummy_time,*vec_pm[lev],GetVecOfPtrs(vec_pm),
272 BCVars::foextrap_periodic_bc,
273 BdyVars::null,0,false,true);
274 FillPatch(lev,dummy_time,*vec_pn[lev],GetVecOfPtrs(vec_pn),
275 BCVars::foextrap_periodic_bc,
276 BdyVars::null,0,false,true);
277 }
278
279
280 int ng = vec_pm[lev]->nGrow();
281
282 const auto& dom_lo = amrex::lbound(geom[lev].Domain());
283 const auto& dom_hi = amrex::ubound(geom[lev].Domain());
284
285 //
286 // We need values of pm and pn outside the domain so we fill
287 // them here with foextrap
288 //
289 // We first fill interior ghost cells because we will need to extrapolate
290 // from ghost cells inside the domain to ghost cells outside the domain
291 //
292 vec_pm[lev]->FillBoundary(geom[lev].periodicity());
293 vec_pn[lev]->FillBoundary(geom[lev].periodicity());
294
295 vec_xr[lev]->FillBoundary(geom[lev].periodicity());
296 vec_yr[lev]->FillBoundary(geom[lev].periodicity());
297 vec_xu[lev]->FillBoundary(geom[lev].periodicity());
298 vec_yu[lev]->FillBoundary(geom[lev].periodicity());
299 vec_xv[lev]->FillBoundary(geom[lev].periodicity());
300 vec_yv[lev]->FillBoundary(geom[lev].periodicity());
301 vec_xp[lev]->FillBoundary(geom[lev].periodicity());
302 vec_yp[lev]->FillBoundary(geom[lev].periodicity());
303
304 for ( MFIter mfi(*vec_pm[lev]); mfi.isValid(); ++mfi )
305 {
306 Box bx = mfi.tilebox();
307
308 auto pm_fab = vec_pm[lev]->array(mfi);
309 auto pn_fab = vec_pn[lev]->array(mfi);
310
311 Box gbx_lox = adjCellLo(bx,0,ng); gbx_lox.grow(1,ng); gbx_lox.setBig (0,dom_lo.x-2);
312 Box gbx_hix = adjCellHi(bx,0,ng); gbx_hix.grow(1,ng); gbx_hix.setSmall(0,dom_hi.x+2);
313 Box gbx_loy = adjCellLo(bx,1,ng); gbx_loy.grow(0,ng); gbx_loy.setBig (1,dom_lo.y-2);
314 Box gbx_hiy = adjCellHi(bx,1,ng); gbx_hiy.grow(0,ng); gbx_hiy.setSmall(1,dom_hi.y+2);
315
316 // if (gbx_lox.ok()) amrex::AllPrint() << "GBX_XLO " << gbx_lox << std::endl;
317 // if (gbx_hix.ok()) amrex::AllPrint() << "GBX_XHI " << gbx_hix << std::endl;
318 // if (gbx_loy.ok()) amrex::AllPrint() << "GBX_YLO " << gbx_loy << std::endl;
319 // if (gbx_hiy.ok()) amrex::AllPrint() << "GBX_YHI " << gbx_hiy << std::endl;
320
321 if (gbx_lox.ok()) {
322 ParallelFor(gbx_lox, [=] AMREX_GPU_DEVICE (int i, int j, int k)
323 {
324 pm_fab(i,j,k,0) = pm_fab(dom_lo.x-1,j,k,0);
325 pn_fab(i,j,k,0) = pn_fab(dom_lo.x-1,j,k,0);
326 });
327 }
328 if (gbx_hix.ok()) {
329 ParallelFor(gbx_hix, [=] AMREX_GPU_DEVICE (int i, int j, int k)
330 {
331 pm_fab(i,j,k,0) = pm_fab(dom_hi.x+1,j,k,0);
332 pn_fab(i,j,k,0) = pn_fab(dom_hi.x+1,j,k,0);
333 });
334 }
335 if (gbx_loy.ok()) {
336 ParallelFor(gbx_loy, [=] AMREX_GPU_DEVICE (int i, int j, int k)
337 {
338 pm_fab(i,j,k,0) = pm_fab(i,dom_lo.y-1,k,0);
339 pn_fab(i,j,k,0) = pn_fab(i,dom_lo.y-1,k,0);
340 });
341 }
342 if (gbx_hiy.ok()) {
343 ParallelFor(gbx_hiy, [=] AMREX_GPU_DEVICE (int i, int j, int k)
344 {
345 pm_fab(i,j,k,0) = pm_fab(i,dom_hi.y+1,k,0);
346 pn_fab(i,j,k,0) = pn_fab(i,dom_hi.y+1,k,0);
347 });
348 }
349 } // mfi
350
351 vec_h[lev]->FillBoundary(geom[lev].periodicity());
352}
353
354/**
355 * @param lev Integer specifying the current level
356 */
357void
358REMORA::init_coriolis_from_netcdf (int lev)
359{
360 // *** FArrayBox's at this level for holding the INITIAL data
361 Vector<FArrayBox> NC_fcor_fab ; NC_fcor_fab.resize(num_boxes_at_level[lev]);
362
363 for (int idx = 0; idx < num_boxes_at_level[lev]; idx++)
364 {
365 read_coriolis_from_netcdf(lev,boxes_at_level[lev][idx], nc_grid_file[lev][idx],
366 NC_fcor_fab[idx]);
367
368#ifdef _OPENMP
369#pragma omp parallel if (amrex::Gpu::notInLaunchRegion())
370#endif
371 {
372 // Don't tile this since we are operating on full FABs in this routine
373 for ( MFIter mfi(*cons_new[lev], false); mfi.isValid(); ++mfi )
374 {
375 FArrayBox &fcor_fab = (*vec_fcor[lev])[mfi];
376
377 //
378 // FArrayBox to FArrayBox copy does "copy on intersection"
379 // This only works here because we have broadcast the FArrayBox of data from the netcdf file to all ranks
380 //
381
382 fcor_fab.template copy<RunOn::Device>(NC_fcor_fab[idx]);
383 } // mf
384 } // omp
385 } // idx
386 vec_fcor[lev]->FillBoundary(geom[lev].periodicity());
387}
388
389/**
390 * @param lev Integer specifying the current level
391 */
392void
393REMORA::init_masks_from_netcdf (int lev)
394{
395 // *** FArrayBox's at this level for holding the INITIAL data
396 Vector<FArrayBox> NC_mskr_fab ; NC_mskr_fab.resize(num_boxes_at_level[lev]);
397 Vector<FArrayBox> NC_msku_fab ; NC_msku_fab.resize(num_boxes_at_level[lev]);
398 Vector<FArrayBox> NC_mskv_fab ; NC_mskv_fab.resize(num_boxes_at_level[lev]);
399
400 for (int idx = 0; idx < num_boxes_at_level[lev]; idx++)
401 {
402 read_masks_from_netcdf(lev,boxes_at_level[lev][idx], nc_grid_file[lev][idx],
403 NC_mskr_fab[idx],NC_msku_fab[idx],
404 NC_mskv_fab[idx]);
405
406#ifdef _OPENMP
407#pragma omp parallel if (amrex::Gpu::notInLaunchRegion())
408#endif
409 {
410 // Don't tile this since we are operating on full FABs in this routine
411 for ( MFIter mfi(*cons_new[lev], false); mfi.isValid(); ++mfi )
412 {
413 FArrayBox &mskr_fab = (*vec_mskr[lev])[mfi];
414 FArrayBox &msku_fab = (*vec_msku[lev])[mfi];
415 FArrayBox &mskv_fab = (*vec_mskv[lev])[mfi];
416
417 //
418 // FArrayBox to FArrayBox copy does "copy on intersection"
419 // This only works here because we have broadcast the FArrayBox of data from the netcdf file to all ranks
420 //
421
422 mskr_fab.template copy<RunOn::Device>(NC_mskr_fab[idx]);
423 msku_fab.template copy<RunOn::Device>(NC_msku_fab[idx]);
424 mskv_fab.template copy<RunOn::Device>(NC_mskv_fab[idx]);
425 } // mf
426 } // omp
427 } // idx
428
429 update_mskp(lev);
430 vec_mskr[lev]->FillBoundary(geom[lev].periodicity());
431 vec_msku[lev]->FillBoundary(geom[lev].periodicity());
432 vec_mskv[lev]->FillBoundary(geom[lev].periodicity());
433 vec_mskp[lev]->FillBoundary(geom[lev].periodicity());
434}
435
436/**
437 * @param lev Integer specifying the current level
438 */
439void
440REMORA::init_bdry_from_netcdf (int lev)
441{
442 if (nc_bdry_file.empty()) {
443 amrex::Error("NetCDF boundary file name must be provided via input");
444 }
445
446 amrex::Vector<std::string> field_name = {"u", "v", "temp", "salt", "ubar", "vbar", "zeta"};
447 amrex::Vector<IntVect > index_types = {IntVect(1,0,0), IntVect(0,1,0),
448 IntVect(0,0,0), IntVect(0,0,0),
449 IntVect(1,0,0), IntVect(0,1,0),
450 IntVect(0,0,0)};
451 std::vector<bool > is_2d = {false, false, false, false, true, true, true};
452
453 amrex::Print() << "DOING INIT AT LEVEL " << lev << std::endl;
454 int rx = 1; int ry = 1;
455 if (lev > 0) {
456 for (int k = lev-1; k >= 0; k--) {
457 rx *= ref_ratio[k][0];
458 ry *= ref_ratio[k][1];
459 }
460 }
461 for (int ivar = 0; ivar < BdyVars::NumTypes; ivar++) {
462 boundary_series[lev].push_back(new NCTimeSeriesBoundary(lev, geom, nc_bdry_file, field_name[ivar],
463 bdry_time_name_byvar[ivar],
464 index_types[ivar],
465 &phys_bc_need_data[ivar], is_2d[ivar], rx, ry));
466 boundary_series[lev][ivar]->Initialize();
467 }
468}
469
470/**
471 * \brief Helper function to initialize state and velocity data in a Fab from a REMORAdataset.
472 *
473 * @param lev Integer specifying current level
474 * @param state_fab FArrayBox object holding the state data we initialize
475 * @param temp_fab FArrayBox object holding the temperature data we initialize
476 * @param salt_fab FArrayBox object holding the salt data we initialize
477 * @param x_vel_fab FArrayBox object holding the x-velocity data we initialize
478 * @param y_vel_fab FArrayBox object holding the y-velocity data we initialize
479 * @param ubar_fab FArrayBox object holding the ubar data we initialize
480 * @param vbar_fab FArrayBox object holding the vbar data we initialize
481 * @param zeta_fab FArrayBox object holding the zeta data we initialize
482 * @param NC_temp_fab Vector of FArrayBox objects with the REMORA dataset specifying temperature
483 * @param NC_salt_fab Vector of FArrayBox objects with the REMORA dataset specifying salinity
484 * @param NC_xvel_fab Vector of FArrayBox objects with the REMORA dataset specifying x-velocity
485 * @param NC_yvel_fab Vector of FArrayBox objects with the REMORA dataset specifying y-velocity
486 * @param NC_ubar_fab Vector of FArrayBox objects with the REMORA dataset specifying ubar
487 * @param NC_vbar_fab Vector of FArrayBox objects with the REMORA dataset specifying vbar
488 * @param NC_zeta_fab Vector of FArrayBox objects with the REMORA dataset specifying zeta
489 */
490void
491init_state_from_netcdf (int /*lev*/,
492 FArrayBox& temp_fab, FArrayBox& salt_fab,
493 FArrayBox& x_vel_fab, FArrayBox& y_vel_fab,
494 FArrayBox& ubar_fab, FArrayBox& vbar_fab,
495 const Vector<FArrayBox>& NC_temp_fab,
496 const Vector<FArrayBox>& NC_salt_fab,
497 const Vector<FArrayBox>& NC_xvel_fab,
498 const Vector<FArrayBox>& NC_yvel_fab,
499 const Vector<FArrayBox>& NC_ubar_fab,
500 const Vector<FArrayBox>& NC_vbar_fab)
501{
502 int nboxes = NC_xvel_fab.size();
503 for (int idx = 0; idx < nboxes; idx++)
504 {
505 //
506 // FArrayBox to FArrayBox copy does "copy on intersection"
507 // This only works here because we have broadcast the FArrayBox of data from the netcdf file to all ranks
508 //
509 temp_fab.template copy<RunOn::Device>(NC_temp_fab[idx]);
510 salt_fab.template copy<RunOn::Device>(NC_salt_fab[idx]);
511 x_vel_fab.template copy<RunOn::Device>(NC_xvel_fab[idx]);
512 y_vel_fab.template copy<RunOn::Device>(NC_yvel_fab[idx]);
513 ubar_fab.template copy<RunOn::Device>(NC_ubar_fab[idx],0,0,1);
514 vbar_fab.template copy<RunOn::Device>(NC_vbar_fab[idx],0,0,1);
515 } // idx
516}
517
518/**
519 * @param lev Integer specifying the current level
520 */
521void
522REMORA::init_clim_nudg_coeff_from_netcdf (int lev)
523{
524 // *** FArrayBox's at this level for holding the INITIAL data
525 Vector<FArrayBox> NC_M2NC_fab ; NC_M2NC_fab.resize(num_boxes_at_level[lev]);
526 Vector<FArrayBox> NC_M3NC_fab ; NC_M3NC_fab.resize(num_boxes_at_level[lev]);
527 Vector<FArrayBox> NC_TempNC_fab ; NC_TempNC_fab.resize(num_boxes_at_level[lev]);
528 Vector<FArrayBox> NC_SaltNC_fab ; NC_SaltNC_fab.resize(num_boxes_at_level[lev]);
529
530 for (int idx = 0; idx < num_boxes_at_level[lev]; idx++)
531 {
532 read_clim_nudg_coeff_from_netcdf(lev,boxes_at_level[lev][idx], nc_clim_coeff_file,
533 solverChoice.do_m2_clim_nudg,
534 solverChoice.do_m3_clim_nudg,
535 solverChoice.do_temp_clim_nudg,
536 solverChoice.do_salt_clim_nudg,
537 NC_M2NC_fab[idx],NC_M3NC_fab[idx],
538 NC_TempNC_fab[idx],NC_SaltNC_fab[idx]);
539
540#ifdef _OPENMP
541#pragma omp parallel if (amrex::Gpu::notInLaunchRegion())
542#endif
543 {
544 // Don't tile this since we are operating on full FABs in this routine
545 for ( MFIter mfi(*cons_new[lev], false); mfi.isValid(); ++mfi )
546 {
547 if (solverChoice.do_m2_clim_nudg) {
548 FArrayBox &ubarNC_fab = (*vec_nudg_coeff[BdyVars::ubar][lev])[mfi];
549 ubarNC_fab.template copy<RunOn::Device>(NC_M2NC_fab[idx]);
550 FArrayBox &vbarNC_fab = (*vec_nudg_coeff[BdyVars::vbar][lev])[mfi];
551 vbarNC_fab.template copy<RunOn::Device>(NC_M2NC_fab[idx]);
552 }
553 if (solverChoice.do_m3_clim_nudg) {
554 FArrayBox &uNC_fab = (*vec_nudg_coeff[BdyVars::u][lev])[mfi];
555 uNC_fab.template copy<RunOn::Device>(NC_M3NC_fab[idx]);
556 FArrayBox &vNC_fab = (*vec_nudg_coeff[BdyVars::v][lev])[mfi];
557 vNC_fab.template copy<RunOn::Device>(NC_M3NC_fab[idx]);
558 }
559 if (solverChoice.do_temp_clim_nudg) {
560 FArrayBox &TempNC_fab = (*vec_nudg_coeff[BdyVars::t][lev])[mfi];
561 TempNC_fab.template copy<RunOn::Device>(NC_TempNC_fab[idx]);
562 }
563 if (solverChoice.do_salt_clim_nudg) {
564 FArrayBox &SaltNC_fab = (*vec_nudg_coeff[BdyVars::s][lev])[mfi];
565 SaltNC_fab.template copy<RunOn::Device>(NC_SaltNC_fab[idx]);
566 }
567
568 } // mf
569 } // omp
570 } // idx
571
572 if (solverChoice.do_m2_clim_nudg) {
573 vec_nudg_coeff[BdyVars::ubar][lev]->FillBoundary(geom[lev].periodicity());
574 vec_nudg_coeff[BdyVars::vbar][lev]->FillBoundary(geom[lev].periodicity());
575 convert_inv_days_to_inv_s(vec_nudg_coeff[BdyVars::ubar][lev].get());
576 convert_inv_days_to_inv_s(vec_nudg_coeff[BdyVars::vbar][lev].get());
577 }
578 if (solverChoice.do_m3_clim_nudg) {
579 vec_nudg_coeff[BdyVars::u][lev]->FillBoundary(geom[lev].periodicity());
580 vec_nudg_coeff[BdyVars::v][lev]->FillBoundary(geom[lev].periodicity());
581 convert_inv_days_to_inv_s(vec_nudg_coeff[BdyVars::u][lev].get());
582 convert_inv_days_to_inv_s(vec_nudg_coeff[BdyVars::v][lev].get());
583 }
584 if (solverChoice.do_temp_clim_nudg) {
585 vec_nudg_coeff[BdyVars::t][lev]->FillBoundary(geom[lev].periodicity());
586 convert_inv_days_to_inv_s(vec_nudg_coeff[BdyVars::t][lev].get());
587 }
588 if (solverChoice.do_salt_clim_nudg) {
589 vec_nudg_coeff[BdyVars::s][lev]->FillBoundary(geom[lev].periodicity());
590 convert_inv_days_to_inv_s(vec_nudg_coeff[BdyVars::s][lev].get());
591 }
592}
593
594/**
595 * @param[in ] lev level to read in river data
596 */
597void
598REMORA::init_riv_pos_from_netcdf (int lev)
599{
600 amrex::Vector<int> river_pos_x;
601 amrex::Vector<int> river_pos_y;
602 amrex::Vector<int> river_direction_tmp;
603
604 std::string river_x_name = "river_Xposition";
605 std::string river_y_name = "river_Eposition";
606 std::string river_dir_name = "river_direction";
607
608 read_vec_from_netcdf(lev, nc_riv_file, river_x_name, river_pos_x);
609 read_vec_from_netcdf(lev, nc_riv_file, river_y_name, river_pos_y);
610 read_vec_from_netcdf(lev, nc_riv_file, river_dir_name, river_direction_tmp);
611
612 int nriv = river_pos_x.size();
613 amrex::Gpu::DeviceVector<int> xpos_d(nriv);
614 amrex::Gpu::DeviceVector<int> ypos_d(nriv);
615 river_direction.resize(nriv);
616#ifdef AMREX_USE_GPU
617 Gpu::htod_memcpy(xpos_d.data(), river_pos_x.data(), sizeof(int)*nriv);
618 Gpu::htod_memcpy(ypos_d.data(), river_pos_y.data(), sizeof(int)*nriv);
619 Gpu::htod_memcpy(river_direction.data(), river_direction_tmp.data(), sizeof(int)*nriv);
620#else
621 std::memcpy(xpos_d.data(), river_pos_x.data(), sizeof(int)*nriv);
622 std::memcpy(ypos_d.data(), river_pos_y.data(), sizeof(int)*nriv);
623 std::memcpy(river_direction.data(), river_direction_tmp.data(), sizeof(int)*nriv);
624#endif
625 const int* xpos_ptr = xpos_d.data();
626 const int* ypos_ptr = ypos_d.data();
627
628 for (amrex::MFIter mfi(*(vec_river_position[lev]).get(),true); mfi.isValid(); ++mfi) {
629 amrex::Box bx = mfi.growntilebox(amrex::IntVect(NGROW,NGROW,0));
630 auto river_pos = vec_river_position[lev]->array(mfi);
631 ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int ) {
632 for (int iriv=0; iriv < nriv; iriv++) {
633 int xriv = xpos_ptr[iriv]-1;
634 int yriv = ypos_ptr[iriv]-1;
635 if (i==xriv && j==yriv) {
636 river_pos(i,j,0) = iriv;
637 }
638 }
639 });
640 }
641}
642
643/**
644 * @param[inout] mf multifab of data to convert
645 */
646void
647REMORA::convert_inv_days_to_inv_s (MultiFab* mf) {
648 Real inv_days_to_inv_s = 1.0_rt / (3600._rt * 24._rt);
649
650 for ( MFIter mfi(*mf, TilingIfNotGPU()); mfi.isValid(); ++mfi )
651 {
652 Array4<Real> const& arr = mf->array(mfi);
653 Box bx = mfi.growntilebox(IntVect(NGROW,NGROW,0));
654 ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) {
655 arr(i,j,k) *= inv_days_to_inv_s;
656 });
657 }
658
659}
660
661#endif // REMORA_USE_NETCDF
REMORA_Constants.H
REMORA_DataStruct.H
NGROW
#define NGROW
Definition REMORA_IndexDefines.H:13
Temp_comp
#define Temp_comp
Definition REMORA_IndexDefines.H:8
Salt_comp
#define Salt_comp
Definition REMORA_IndexDefines.H:9
init_state_from_netcdf
void init_state_from_netcdf(int lev, FArrayBox &temp_fab, FArrayBox &salt_fab, FArrayBox &x_vel_fab, FArrayBox &y_vel_fab, FArrayBox &ubar_fab, FArrayBox &vbar_fab, const Vector< FArrayBox > &NC_temp_fab, const Vector< FArrayBox > &NC_salt_fab, const Vector< FArrayBox > &NC_xvel_fab, const Vector< FArrayBox > &NC_yvel_fab, const Vector< FArrayBox > &NC_ubar_fab, const Vector< FArrayBox > &NC_vbar_fab)
helper function to initialize state from netcdf
Definition REMORA_init_from_netcdf.cpp:491
read_coriolis_from_netcdf
void read_coriolis_from_netcdf(int lev, const Box &domain, const std::string &fname, FArrayBox &NC_fcor_fab)
helper function to read coriolis factor from netcdf
Definition REMORA_ReadFromInitNetcdf.cpp:124
read_vec_from_netcdf
void read_vec_from_netcdf(int lev, const std::string &fname, const std::string &field_name, amrex::Vector< int > &vec_dat)
helper function to read in vector of data from netcdf
Definition REMORA_ReadFromInitNetcdf.cpp:226
read_data_from_netcdf
void read_data_from_netcdf(int, const Box &domain, const std::string &fname, FArrayBox &NC_temp_fab, FArrayBox &NC_salt_fab, FArrayBox &NC_xvel_fab, FArrayBox &NC_yvel_fab, FArrayBox &NC_ubar_fab, FArrayBox &NC_vbar_fab)
helper function for reading in initial state data from netcdf
Definition REMORA_ReadFromInitNetcdf.cpp:20
read_zeta_from_netcdf
void read_zeta_from_netcdf(int lev, const Box &domain, const std::string &fname, FArrayBox &NC_zeta_fab)
helper function to read sea surface height from netcdf
Definition REMORA_ReadFromInitNetcdf.cpp:51
read_bdry_from_netcdf
Real read_bdry_from_netcdf(const Box &domain, const std::string &fname, Vector< Vector< FArrayBox > > &bdy_data_xlo, Vector< Vector< FArrayBox > > &bdy_data_xhi, Vector< Vector< FArrayBox > > &bdy_data_ylo, Vector< Vector< FArrayBox > > &bdy_data_yhi, int &width, amrex::Real &start_bdy_time, std::string bdry_time_varname, amrex::GpuArray< amrex::GpuArray< bool, AMREX_SPACEDIM *2 >, BdyVars::NumTypes+1 > &)
helper function for reading boundary data from netcdf
read_masks_from_netcdf
void read_masks_from_netcdf(int, const Box &domain, const std::string &fname, FArrayBox &NC_mskr_fab, FArrayBox &NC_msku_fab, FArrayBox &NC_mskv_fab)
helper function for reading in land-sea masks from netcdf
Definition REMORA_ReadFromInitNetcdf.cpp:150
read_bathymetry_from_netcdf
void read_bathymetry_from_netcdf(int lev, const Box &domain, const std::string &fname, FArrayBox &NC_h_fab, FArrayBox &NC_pm_fab, FArrayBox &NC_pn_fab, FArrayBox &NC_xr_fab, FArrayBox &NC_yr_fab, FArrayBox &NC_xu_fab, FArrayBox &NC_yu_fab, FArrayBox &NC_xv_fab, FArrayBox &NC_yv_fab, FArrayBox &NC_xp_fab, FArrayBox &NC_yp_fab)
helper function to read bathymetry from netcdf
Definition REMORA_ReadFromInitNetcdf.cpp:85
read_clim_nudg_coeff_from_netcdf
void read_clim_nudg_coeff_from_netcdf(int lev, const Box &domain, const std::string &fname, bool do_m2_clim_nudg, bool do_m3_clim_nudg, bool do_temp_clim_nudg, bool do_salt_clim_nudg, FArrayBox &NC_M2NC_fab, FArrayBox &NC_M3NC_fab, FArrayBox &NC_TempNC_fab, FArrayBox &NC_SaltNC_fab)
helper function to read climatology nudging from netcdf
Definition REMORA_ReadFromInitNetcdf.cpp:185
REMORA_prob_common.H
NCTimeSeriesBoundary
A class to hold and interpolate time series data read from a NetCDF file.
Definition REMORA_NCTimeSeriesBoundary.H:18
REMORA::init_bathymetry_from_netcdf
void init_bathymetry_from_netcdf(int lev)
Bathymetry data initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:191
REMORA::vec_fcor
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_fcor
coriolis factor (2D)
Definition REMORA.H:391
REMORA::vec_h
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_h
Bathymetry data (2D, positive valued, h in ROMS)
Definition REMORA.H:253
REMORA::vec_pm
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_pm
horizontal scaling factor: 1 / dx (2D)
Definition REMORA.H:386
REMORA::vec_yv
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_yv
y_grid on v-points (2D)
Definition REMORA.H:406
REMORA::cons_new
amrex::Vector< amrex::MultiFab * > cons_new
multilevel data container for current step's scalar data: temperature, salinity, passive scalar
Definition REMORA.H:241
REMORA::vec_mskr
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_mskr
land/sea mask at cell centers (2D)
Definition REMORA.H:375
REMORA::vec_yp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_yp
y_grid on psi-points (2D)
Definition REMORA.H:411
REMORA::vec_xr
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_xr
x_grid on rho points (2D)
Definition REMORA.H:394
REMORA::vec_xv
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_xv
x_grid on v-points (2D)
Definition REMORA.H:404
REMORA::boxes_at_level
amrex::Vector< amrex::Vector< amrex::Box > > boxes_at_level
the boxes specified at each level by tagging criteria
Definition REMORA.H:1167
REMORA::vec_msku
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_msku
land/sea mask at x-faces (2D)
Definition REMORA.H:377
REMORA::init_data_from_netcdf
void init_data_from_netcdf(int lev)
Problem initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:90
REMORA::init_masks_from_netcdf
void init_masks_from_netcdf(int lev)
Mask data initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:393
REMORA::yvel_new
amrex::Vector< amrex::MultiFab * > yvel_new
multilevel data container for current step's y velocities (v in ROMS)
Definition REMORA.H:245
REMORA::num_boxes_at_level
amrex::Vector< int > num_boxes_at_level
how many boxes specified at each level by tagging criteria
Definition REMORA.H:1163
REMORA::xvel_new
amrex::Vector< amrex::MultiFab * > xvel_new
multilevel data container for current step's x velocities (u in ROMS)
Definition REMORA.H:243
REMORA::vec_mskp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_mskp
land/sea mask at cell corners (2D)
Definition REMORA.H:381
REMORA::vec_mskv
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_mskv
land/sea mask at y-faces (2D)
Definition REMORA.H:379
REMORA::physbcs
amrex::Vector< std::unique_ptr< REMORAPhysBCFunct > > physbcs
Vector (over level) of functors to apply physical boundary conditions.
Definition REMORA.H:1184
REMORA::FillPatch
void FillPatch(int lev, amrex::Real time, amrex::MultiFab &mf_to_be_filled, amrex::Vector< amrex::MultiFab * > const &mfs, const int bccomp, const int bdy_var_type=BdyVars::null, const int icomp=0, const bool fill_all=true, const bool fill_set=true, const int n_not_fill=0, const int icomp_calc=0, const amrex::Real dt=amrex::Real(0.0), const amrex::MultiFab &mf_calc=amrex::MultiFab())
Fill a new MultiFab by copying in phi from valid region and filling ghost cells.
Definition REMORA_FillPatch.cpp:30
REMORA::nc_clim_coeff_file
std::string nc_clim_coeff_file
NetCDF climatology coefficient file.
Definition REMORA.H:1359
REMORA::bdry_time_name_byvar
amrex::Vector< std::string > bdry_time_name_byvar
Name of time fields for boundary data.
Definition REMORA.H:1364
REMORA::init_riv_pos_from_netcdf
void init_riv_pos_from_netcdf(int lev)
Definition REMORA_init_from_netcdf.cpp:598
REMORA::nc_bdry_file
static amrex::Vector< std::string > nc_bdry_file
NetCDF boundary data.
Definition REMORA.H:51
REMORA::nc_riv_file
std::string nc_riv_file
Definition REMORA.H:1354
REMORA::update_mskp
void update_mskp(int lev)
Set psi-point mask to be consistent with rho-point mask.
Definition REMORA_make_new_level.cpp:844
REMORA::init_zeta_from_netcdf
void init_zeta_from_netcdf(int lev)
Sea-surface height data initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:141
REMORA::init_coriolis_from_netcdf
void init_coriolis_from_netcdf(int lev)
Coriolis parameter data initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:358
REMORA::fill_from_bdyfiles
void fill_from_bdyfiles(int lev, amrex::MultiFab &mf_to_fill, const amrex::MultiFab &mf_mask, const amrex::Real time, const int bccomp, const int bdy_var_type, const int icomp_to_fill, const int icomp_calc=0, const amrex::MultiFab &mf_calc=amrex::MultiFab(), const amrex::Real=amrex::Real(0.0))
Fill boundary data from netcdf file.
Definition REMORA_BoundaryConditions_netcdf.cpp:20
REMORA::t_new
amrex::Vector< amrex::Real > t_new
new time at each level
Definition REMORA.H:1174
REMORA::init_bdry_from_netcdf
void init_bdry_from_netcdf(int lev)
Boundary data initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:440
REMORA::solverChoice
static SolverChoice solverChoice
Container for algorithmic choices.
Definition REMORA.H:1299
REMORA::vec_river_position
amrex::Vector< std::unique_ptr< amrex::iMultiFab > > vec_river_position
iMultiFab for river positions; contents are indices of rivers
Definition REMORA.H:1112
REMORA::vec_xp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_xp
x_grid on psi-points (2D)
Definition REMORA.H:409
REMORA::nc_grid_file
static amrex::Vector< amrex::Vector< std::string > > nc_grid_file
NetCDF grid file.
Definition REMORA.H:53
REMORA::boundary_series
amrex::Vector< amrex::Vector< NCTimeSeriesBoundary * > > boundary_series
Vector over BdyVars of boundary series data containers.
Definition REMORA.H:1108
REMORA::vec_zeta
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_zeta
free surface height (2D)
Definition REMORA.H:372
REMORA::river_direction
amrex::Gpu::DeviceVector< int > river_direction
Vector over rivers of river direction: 0: u-face; 1: v-face; 2: w-face.
Definition REMORA.H:1114
REMORA::vec_vbar
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_vbar
barotropic y velocity (2D)
Definition REMORA.H:370
REMORA::vec_ubar
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_ubar
barotropic x velocity (2D)
Definition REMORA.H:368
REMORA::init_clim_nudg_coeff_from_netcdf
void init_clim_nudg_coeff_from_netcdf(int lev)
Climatology nudging coefficient initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:522
REMORA::vec_yu
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_yu
y_grid on u-points (2D)
Definition REMORA.H:401
REMORA::vec_xu
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_xu
x_grid on u-points (2D)
Definition REMORA.H:399
REMORA::phys_bc_need_data
amrex::GpuArray< amrex::GpuArray< bool, AMREX_SPACEDIM *2 >, BdyVars::NumTypes+1 > phys_bc_need_data
These are flags that indicate whether we need to read in boundary data from file.
Definition REMORA.H:1210
REMORA::vec_nudg_coeff
amrex::Vector< amrex::Vector< std::unique_ptr< amrex::MultiFab > > > vec_nudg_coeff
Climatology nudging coefficients.
Definition REMORA.H:445
REMORA::vec_pn
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_pn
horizontal scaling factor: 1 / dy (2D)
Definition REMORA.H:388
REMORA::nc_init_file
static amrex::Vector< amrex::Vector< std::string > > nc_init_file
NetCDF initialization file.
Definition REMORA.H:52
REMORA::t_old
amrex::Vector< amrex::Real > t_old
old time at each level
Definition REMORA.H:1176
REMORA::convert_inv_days_to_inv_s
void convert_inv_days_to_inv_s(amrex::MultiFab *)
Convert data in a multifab from inverse days to inverse seconds.
Definition REMORA_init_from_netcdf.cpp:647
REMORA::vec_yr
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_yr
y_grid on rho points (2D)
Definition REMORA.H:396