REMORA
Regional Modeling of Oceans Refined Adaptively
Loading...
Searching...
No Matches
REMORA_Plotfile.cpp
Go to the documentation of this file.
1#include <REMORA.H>
2#include "AMReX_Interp_3D_C.H"
3#include "AMReX_PlotFileUtil.H"
4
5using namespace amrex;
6
7PhysBCFunctNoOp null_bc_for_fill;
8
9template<typename V, typename T>
10bool containerHasElement(const V& iterable, const T& query) {
11 return std::find(iterable.begin(), iterable.end(), query) != iterable.end();
12}
13
14// Write plotfile to disk
15void
16REMORA::WritePlotFile ()
17{
18 Vector<std::string> varnames_3d;
19 varnames_3d.insert(varnames_3d.end(), plot_var_names_3d.begin(), plot_var_names_3d.end());
20
21 Vector<std::string> varnames_2d;
22 varnames_2d.insert(varnames_2d.end(), plot_var_names_2d.begin(), plot_var_names_2d.end());
23
24 Vector<std::string> varnames_2d_rho;
25 Vector<std::string> varnames_2d_u;
26 Vector<std::string> varnames_2d_v;
27
28 const int ncomp_mf_3d = varnames_3d.size();
29 const auto ngrow_vars = IntVect(NGROW-1,NGROW-1,0);
30
31 // These are the ncomp for the 2D cell-centered, x-face-based, y-face-based MultiFabs respectively
32 int ncomp_mf_2d_rho = 0;
33 int ncomp_mf_2d_u = 0;
34 int ncomp_mf_2d_v = 0;
35
36 // Check to see if we found all the requested variables
37 for (auto plot_name : varnames_2d) {
38 {
39 if (plot_name == "zeta" ) {varnames_2d_rho.push_back(plot_name); ncomp_mf_2d_rho++;}
40 if (plot_name == "h" ) {varnames_2d_rho.push_back(plot_name); ncomp_mf_2d_rho++;}
41 if (plot_name == "ubar" ) {varnames_2d_u.push_back(plot_name); ncomp_mf_2d_u++;}
42 if (plot_name == "sustr") {varnames_2d_u.push_back(plot_name); ncomp_mf_2d_u++;}
43 if (plot_name == "bustr") {varnames_2d_u.push_back(plot_name); ncomp_mf_2d_u++;}
44 if (plot_name == "vbar" ) {varnames_2d_v.push_back(plot_name); ncomp_mf_2d_v++;}
45 if (plot_name == "svstr") {varnames_2d_v.push_back(plot_name); ncomp_mf_2d_v++;}
46 if (plot_name == "bvstr") {varnames_2d_v.push_back(plot_name); ncomp_mf_2d_v++;}
47 }
48 }
49
50 // We fillpatch here because some of the derived quantities require derivatives
51 // which require ghost cells to be filled. Don't fill the boundary, though.
52 for (int lev = 0; lev <= finest_level; ++lev) {
53 FillPatchNoBC(lev, t_new[lev], *cons_new[lev], cons_new, BdyVars::t,0,true,false);
54 FillPatchNoBC(lev, t_new[lev], *xvel_new[lev], xvel_new, BdyVars::u,0,true,false);
55 FillPatchNoBC(lev, t_new[lev], *yvel_new[lev], yvel_new, BdyVars::v,0,true,false);
56 FillPatchNoBC(lev, t_new[lev], *zvel_new[lev], zvel_new, BdyVars::null,0,true,false);
57 }
58
59 Real fill_value = 0.0_rt;
60 for (int lev = 0; lev <= finest_level; ++lev) {
61 mask_arrays_for_write(lev, (Real) fill_value, 0.0_rt);
62 }
63
64 // Array of 3D MultiFabs to hold the plotfile data
65 Vector<MultiFab> mf(finest_level+1);
66 for (int lev = 0; lev <= finest_level; ++lev) {
67 mf[lev].define(grids[lev], dmap[lev], ncomp_mf_3d, ngrow_vars);
68 }
69
70 // Array of 2D MultiFabs to hold the plotfile data
71 Vector<MultiFab> mf_2d_rho(finest_level+1);
72 Vector<MultiFab> mf_2d_u(finest_level+1);
73 Vector<MultiFab> mf_2d_v(finest_level+1);
74 for (int lev = 0; lev <= finest_level; ++lev) {
75 BoxArray ba(grids[lev]);
76 BoxList bl2d = ba.boxList();
77 for (auto& b : bl2d) {
78 b.setRange(2,0);
79 }
80 BoxArray ba2d(std::move(bl2d));
81 mf_2d_rho[lev].define(ba2d, dmap[lev], ncomp_mf_2d_rho, IntVect(0,0,0));
82 mf_2d_u[lev].define(ba2d, dmap[lev], ncomp_mf_2d_u , IntVect(0,0,0));
83 mf_2d_v[lev].define(ba2d, dmap[lev], ncomp_mf_2d_v , IntVect(0,0,0));
84 }
85
86 // Array of MultiFabs for nodal data
87 Vector<MultiFab> mf_nd(finest_level+1);
88 for (int lev = 0; lev <= finest_level; ++lev) {
89 BoxArray nodal_grids(grids[lev]); nodal_grids.surroundingNodes();
90 mf_nd[lev].define(nodal_grids, dmap[lev], AMREX_SPACEDIM, 0);
91 mf_nd[lev].setVal(0.);
92 }
93
94 // Vector of MultiFabs for face-centered velocity
95 Vector<MultiFab> mf_u(finest_level+1);
96 Vector<MultiFab> mf_v(finest_level+1);
97 Vector<MultiFab> mf_w(finest_level+1);
98 if (plot_staggered_vels) {
99 for (int lev = 0; lev <= finest_level; ++lev) {
100 BoxArray grid_stag_u(grids[lev]); grid_stag_u.surroundingNodes(0);
101 BoxArray grid_stag_v(grids[lev]); grid_stag_v.surroundingNodes(1);
102 BoxArray grid_stag_w(grids[lev]); grid_stag_w.surroundingNodes(2);
103 mf_u[lev].define(grid_stag_u, dmap[lev], 1, 0);
104 mf_v[lev].define(grid_stag_v, dmap[lev], 1, 0);
105 mf_w[lev].define(grid_stag_w, dmap[lev], 1, 0);
106 MultiFab::Copy(mf_u[lev],*xvel_new[lev],0,0,1,0);
107 MultiFab::Copy(mf_v[lev],*yvel_new[lev],0,0,1,0);
108 MultiFab::Copy(mf_w[lev],*zvel_new[lev],0,0,1,0);
109 }
110 }
111
112 // Array of MultiFabs for cell-centered velocity
113 Vector<MultiFab> mf_cc_vel(finest_level+1);
114
115 if (containerHasElement(plot_var_names_3d, "x_velocity") ||
116 containerHasElement(plot_var_names_3d, "y_velocity") ||
117 containerHasElement(plot_var_names_3d, "z_velocity") ||
118 containerHasElement(plot_var_names_3d, "vorticity") ) {
119
120 for (int lev = 0; lev <= finest_level; ++lev) {
121 mf_cc_vel[lev].define(grids[lev], dmap[lev], AMREX_SPACEDIM, IntVect(1,1,0));
122 mf_cc_vel[lev].setVal(0.0_rt); // zero out velocity in case we have any wall boundaries
123 average_face_to_cellcenter(mf_cc_vel[lev],0,
124 Array<const MultiFab*,3>{xvel_new[lev],yvel_new[lev],zvel_new[lev]},IntVect(1,1,0));
125 mf_cc_vel[lev].FillBoundary(geom[lev].periodicity());
126 } // lev
127
128 // We need ghost cells if computing vorticity
129 amrex::Interpolater* mapper = &cell_cons_interp;
130 if ( containerHasElement(plot_var_names_3d, "vorticity") ) {
131 for (int lev = 1; lev <= finest_level; ++lev) {
132 Vector<MultiFab*> fmf = {&(mf_cc_vel[lev]), &(mf_cc_vel[lev])};
133 Vector<Real> ftime = {t_new[lev], t_new[lev]};
134 Vector<MultiFab*> cmf = {&mf_cc_vel[lev-1], &mf_cc_vel[lev-1]};
135 Vector<Real> ctime = {t_new[lev], t_new[lev]};
136
137 MultiFab mf_to_fill;
138 amrex::FillPatchTwoLevels(mf_cc_vel[lev], mf_cc_vel[lev].nGrowVect(), IntVect(0,0,0),
139 t_new[lev], cmf, ctime, fmf, ftime,
140 0, 0, mf_cc_vel[lev].nComp(), geom[lev-1], geom[lev],
141 refRatio(lev-1), mapper, domain_bcs_type, BCVars::foextrap_bc);
142 } // lev
143 } // if
144 } // if
145
146 int icomp_rho = 0;
147 for (auto plot_name : varnames_2d_rho)
148 {
149 if (plot_name == "zeta" ) {
150 for (int lev = 0; lev <= finest_level; ++lev) { MultiFab::Copy(mf_2d_rho[lev],*vec_Zt_avg1[lev],0,icomp_rho,1,0); }
151 icomp_rho++;
152 }
153 if (plot_name == "h" ) {
154 for (int lev = 0; lev <= finest_level; ++lev) { MultiFab::Copy(mf_2d_rho[lev],*vec_h[lev],0,icomp_rho,1,0); }
155 icomp_rho++;
156 }
157 }
158
159 int icomp_u = 0;
160 for (auto plot_name : varnames_2d_u)
161 {
162 if (plot_name == "ubar" ) {
163 for (int lev = 0; lev <= finest_level; ++lev) {
164 MultiFab::Copy(mf_2d_u[lev],*vec_DU_avg1[lev],0,icomp_u,1,0);
165 }
166 icomp_u++;
167 }
168 if (plot_name == "sustr" ) {
169 for (int lev = 0; lev <= finest_level; ++lev) { MultiFab::Copy(mf_2d_u[lev],*vec_sustr[lev],0,icomp_u,1,0); }
170 icomp_u++;
171 }
172 if (plot_name == "bustr" ) {
173 for (int lev = 0; lev <= finest_level; ++lev) { MultiFab::Copy(mf_2d_u[lev],*vec_bustr[lev],0,icomp_u,1,0); }
174 icomp_u++;
175 }
176 }
177
178 int icomp_v = 0;
179 for (auto plot_name : varnames_2d_v)
180 {
181 if (plot_name == "vbar" ) {
182 for (int lev = 0; lev <= finest_level; ++lev) { MultiFab::Copy(mf_2d_v[lev],*vec_DV_avg1[lev],0,icomp_v,1,0); }
183 icomp_v++;
184 }
185 if (plot_name == "svstr" ) {
186 for (int lev = 0; lev <= finest_level; ++lev) { MultiFab::Copy(mf_2d_v[lev],*vec_svstr[lev],0,icomp_v,1,0); }
187 icomp_v++;
188 }
189 if (plot_name == "bvstr" ) {
190 for (int lev = 0; lev <= finest_level; ++lev) { MultiFab::Copy(mf_2d_v[lev],*vec_bvstr[lev],0,icomp_v,1,0); }
191 icomp_v++;
192 }
193 }
194
195 for (int lev = 0; lev <= finest_level; ++lev)
196 {
197 int mf_comp = 0;
198
199 // First, copy any of the conserved state variables into the output plotfile
200 AMREX_ALWAYS_ASSERT(cons_names.size() == NCONS);
201 for (int i = 0; i < NCONS; ++i) {
202 if (containerHasElement(plot_var_names_3d, cons_names[i])) {
203 if (cons_new[lev]->contains_nan() || cons_new[lev]->contains_inf()) {
204 amrex::Abort("Found while writing output: Cons (salt, temp, or scalar, etc) contains nan or inf");
205 }
206 MultiFab::Copy(mf[lev],*cons_new[lev],i,mf_comp,1,ngrow_vars);
207 mf_comp++;
208 }
209 } // NCONS
210
211 // Next, check for velocities
212 if (containerHasElement(plot_var_names_3d, "x_velocity")) {
213 if (mf_cc_vel[lev].contains_nan(0,1) || mf_cc_vel[lev].contains_inf(0,1)) {
214 amrex::Abort("Found while writing output: u velocity contains nan or inf");
215 }
216 MultiFab::Copy(mf[lev], mf_cc_vel[lev], 0, mf_comp, 1, 0);
217 mf_comp += 1;
218 }
219 if (containerHasElement(plot_var_names_3d, "y_velocity")) {
220 if (mf_cc_vel[lev].contains_nan(1,1) || mf_cc_vel[lev].contains_inf(1,1)) {
221 amrex::Abort("Found while writing output: v velocity contains nan or inf");
222 }
223 MultiFab::Copy(mf[lev], mf_cc_vel[lev], 1, mf_comp, 1, 0);
224 mf_comp += 1;
225 }
226 if (containerHasElement(plot_var_names_3d, "z_velocity")) {
227 if (mf_cc_vel[lev].contains_nan(2,1) || mf_cc_vel[lev].contains_inf(2,1)) {
228 amrex::Abort("Found while writing output: z velocity contains nan or inf");
229 }
230 MultiFab::Copy(mf[lev], mf_cc_vel[lev], 2, mf_comp, 1, 0);
231 mf_comp += 1;
232 }
233
234 // Define standard process for calling the functions in Derive.cpp
235 auto calculate_derived = [&](const std::string& der_name,
236 decltype(derived::remora_dernull)& der_function)
237 {
238 if (containerHasElement(plot_var_names_3d, der_name)) {
239 MultiFab dmf(mf[lev], make_alias, mf_comp, 1);
240#ifdef _OPENMP
241#pragma omp parallel if (amrex::Gpu::notInLaunchRegion())
242#endif
243 for (MFIter mfi(dmf, TilingIfNotGPU()); mfi.isValid(); ++mfi)
244 {
245 const Box& bx = mfi.tilebox();
246 auto& dfab = dmf[mfi];
247
248 if (der_name == "vorticity") {
249 auto const& sfab = mf_cc_vel[lev][mfi];
250 der_function(bx, dfab, 0, 1, sfab, vec_pm[lev]->const_array(mfi), vec_pn[lev]->const_array(mfi), vec_mskr[lev]->const_array(mfi), Geom(lev), t_new[0], nullptr, lev);
251 } else {
252 auto const& sfab = (*cons_new[lev])[mfi];
253 der_function(bx, dfab, 0, 1, sfab, vec_pm[lev]->const_array(mfi), vec_pn[lev]->const_array(mfi), vec_mskr[lev]->const_array(mfi), Geom(lev), t_new[0], nullptr, lev);
254 }
255 }
256
257 mf_comp++;
258 }
259 };
260
261 // Note: All derived variables must be computed in order of "derived_names" defined in REMORA.H
262 calculate_derived("vorticity", derived::remora_dervort);
263
264 // Fill cell-centered location
265 Real dx = Geom()[lev].CellSizeArray()[0];
266 Real dy = Geom()[lev].CellSizeArray()[1];
267
268 // Next, check for location names -- if we write one we write all
269 if (containerHasElement(plot_var_names_3d, "x_cc") ||
270 containerHasElement(plot_var_names_3d, "y_cc") ||
271 containerHasElement(plot_var_names_3d, "z_cc"))
272 {
273 MultiFab dmf(mf[lev], make_alias, mf_comp, AMREX_SPACEDIM);
274#ifdef _OPENMP
275#pragma omp parallel if (Gpu::notInLaunchRegion())
276#endif
277 for (MFIter mfi(dmf, TilingIfNotGPU()); mfi.isValid(); ++mfi) {
278 const Box& bx = mfi.tilebox();
279 const Array4<Real> loc_arr = dmf.array(mfi);
280 const Array4<Real const> zp_arr = vec_z_phys_nd[lev]->const_array(mfi);
281
282 ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) {
283 loc_arr(i,j,k,0) = (i+0.5_rt) * dx;
284 loc_arr(i,j,k,1) = (j+0.5_rt) * dy;
285 loc_arr(i,j,k,2) = 0.125_rt * (zp_arr(i,j ,k ) + zp_arr(i+1,j ,k ) +
286 zp_arr(i,j+1,k ) + zp_arr(i+1,j+1,k ) +
287 zp_arr(i,j ,k+1) + zp_arr(i+1,j ,k+1) +
288 zp_arr(i,j+1,k+1) + zp_arr(i+1,j+1,k+1) );
289 });
290 } // mfi
291 mf_comp += AMREX_SPACEDIM;
292 } // if containerHasElement
293
294#ifdef REMORA_USE_PARTICLES
295 const auto& particles_namelist( particleData.getNames() );
296 for (ParticlesNamesVector::size_type i = 0; i < particles_namelist.size(); i++) {
297 if (containerHasElement(plot_var_names_3d, std::string(particles_namelist[i]+"_count"))) {
298 MultiFab temp_dat(mf[lev].boxArray(), mf[lev].DistributionMap(), 1, 0);
299 temp_dat.setVal(0);
300 particleData[particles_namelist[i]]->Increment(temp_dat, lev);
301 MultiFab::Copy(mf[lev], temp_dat, 0, mf_comp, 1, 0);
302 mf_comp += 1;
303 }
304 }
305
306 Vector<std::string> particle_mesh_plot_names(0);
307 particleData.GetMeshPlotVarNames( particle_mesh_plot_names );
308 for (int i = 0; i < particle_mesh_plot_names.size(); i++) {
309 std::string plot_var_name(particle_mesh_plot_names[i]);
310 if (containerHasElement(plot_var_names_3d, plot_var_name) ) {
311 MultiFab temp_dat(mf[lev].boxArray(), mf[lev].DistributionMap(), 1, 1);
312 temp_dat.setVal(0);
313 particleData.GetMeshPlotVar(plot_var_name, temp_dat, lev);
314 MultiFab::Copy(mf[lev], temp_dat, 0, mf_comp, 1, 0);
315 mf_comp += 1;
316 }
317 }
318#endif
319
320 MultiFab::Copy(mf_nd[lev],*vec_z_phys_nd[lev],0,2,1,0);
321 Real dz = Geom()[lev].CellSizeArray()[2];
322 int N = Geom()[lev].Domain().size()[2];
323
324#ifdef _OPENMP
325#pragma omp parallel if (Gpu::notInLaunchRegion())
326#endif
327 for (MFIter mfi(mf_nd[lev], TilingIfNotGPU()); mfi.isValid(); ++mfi)
328 {
329 const Box& bx = mfi.tilebox();
330 Array4<Real> mf_arr = mf_nd[lev].array(mfi);
331 ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) {
332 mf_arr(i,j,k,2) = mf_arr(i,j,k,2) + (N-k) * dz;
333 });
334 } // mfi
335
336 } // lev
337
338 std::string plotfilename = Concatenate(plot_file_name, istep[0], file_min_digits);
339
340 if (finest_level == 0)
341 {
342 if (plotfile_type == PlotfileType::amrex) {
343 amrex::Print() << "Writing plotfile " << plotfilename << "\n";
344 WriteMultiLevelPlotfileWithBathymetry(plotfilename, finest_level+1,
345 GetVecOfConstPtrs(mf),
346 GetVecOfConstPtrs(mf_nd),
347 GetVecOfConstPtrs(mf_u),
348 GetVecOfConstPtrs(mf_v),
349 GetVecOfConstPtrs(mf_w),
350 GetVecOfConstPtrs(mf_2d_rho),
351 GetVecOfConstPtrs(mf_2d_u),
352 GetVecOfConstPtrs(mf_2d_v),
353 varnames_3d, varnames_2d_rho,
354 varnames_2d_u, varnames_2d_v,
355 Geom(),
356 t_new[0], istep, refRatio());
357 writeJobInfo(plotfilename);
358
359#ifdef REMORA_USE_PARTICLES
360 particleData.Checkpoint(plotfilename);
361#endif
362
363#ifdef REMORA_USE_HDF5
364 } else if (plotfile_type == PlotfileType::hdf5) {
365 amrex::Print() << "Writing plotfile " << plotfilename+"d01.h5" << "\n";
366 WriteMultiLevelPlotfileHDF5(plotfilename, finest_level+1,
367 GetVecOfConstPtrs(mf),
368 varnames_3d,
369 Geom(), t_new[0], istep, refRatio());
370#endif
371 } else if (!(plotfile_type == PlotfileType::netcdf)) {
372 amrex::Abort("User specified unknown plot_filetype");
373 }
374
375 } else { // multilevel
376 if (plotfile_type == PlotfileType::amrex) {
377 amrex::Print() << "Writing plotfile " << plotfilename << "\n";
378 int lev0 = 0;
379 [[maybe_unused]] int desired_ratio = std::max(std::max(ref_ratio[lev0][0],ref_ratio[lev0][1]),ref_ratio[lev0][2]);
380 bool any_ratio_one = ( ( (ref_ratio[lev0][0] == 1) || (ref_ratio[lev0][1] == 1) ) ||
381 (ref_ratio[lev0][2] == 1) );
382 for (int lev = 1; lev < finest_level; lev++) {
383 any_ratio_one = any_ratio_one ||
384 ( ( (ref_ratio[lev][0] == 1) || (ref_ratio[lev][1] == 1) ) ||
385 (ref_ratio[lev][2] == 1) );
386 }
387 if (any_ratio_one && expand_plotvars_to_unif_rr) {
388 Vector<IntVect> r2(finest_level);
389 Vector<Geometry> g2(finest_level+1);
390 Vector<MultiFab> mf2(finest_level+1);
391
392 mf2[0].define(grids[0], dmap[0], ncomp_mf_3d, 0);
393
394 // Copy level 0 as is
395 MultiFab::Copy(mf2[0],mf[0],0,0,mf[0].nComp(),0);
396
397 // Define a new multi-level array of Geometry's so that we pass the new "domain" at lev > 0
398 Array<int,AMREX_SPACEDIM> periodicity =
399 {Geom()[0].isPeriodic(0),Geom()[0].isPeriodic(1),Geom()[0].isPeriodic(2)};
400 g2[0].define(Geom()[0].Domain(),&(Geom()[0].ProbDomain()),0,periodicity.data());
401
402 r2[0] = IntVect(1,1,ref_ratio[0][0]);
403 for (int lev = 1; lev <= finest_level; ++lev) {
404 if (lev > 1) {
405 r2[lev-1][0] = 1;
406 r2[lev-1][1] = 1;
407 r2[lev-1][2] = r2[lev-2][2] * ref_ratio[lev-1][0];
408 }
409
410 mf2[lev].define(refine(grids[lev],r2[lev-1]), dmap[lev], ncomp_mf_3d, 0);
411
412 // Set the new problem domain
413 Box d2(Geom()[lev].Domain());
414 d2.refine(r2[lev-1]);
415
416 g2[lev].define(d2,&(Geom()[lev].ProbDomain()),0,periodicity.data());
417 }
418
419 // Make a vector of BCRec with default values so we can use it here -- note the values
420 // aren't actually used because we do PCInterp
421 amrex::Vector<amrex::BCRec> null_dom_bcs;
422 null_dom_bcs.resize(mf2[0].nComp());
423 for (int n = 0; n < mf2[0].nComp(); n++) {
424 for (int dir = 0; dir < AMREX_SPACEDIM; dir++) {
425 null_dom_bcs[n].setLo(dir, REMORABCType::int_dir);
426 null_dom_bcs[n].setHi(dir, REMORABCType::int_dir);
427 }
428 }
429
430 // Do piecewise interpolation of mf into mf2
431 for (int lev = 1; lev <= finest_level; ++lev) {
432 Interpolater* mapper_c = &pc_interp;
433 InterpFromCoarseLevel(mf2[lev], t_new[lev], mf[lev],
434 0, 0, mf2[lev].nComp(),
435 geom[lev], g2[lev],
436 null_bc_for_fill, 0, null_bc_for_fill, 0,
437 r2[lev-1], mapper_c, null_dom_bcs, 0);
438 }
439
440 // Define an effective ref_ratio which is isotropic to be passed into WriteMultiLevelPlotfile
441 Vector<IntVect> rr(finest_level);
442 for (int lev = 0; lev < finest_level; ++lev) {
443 rr[lev] = IntVect(ref_ratio[lev][0],ref_ratio[lev][1],ref_ratio[lev][0]);
444 }
445
446 WriteMultiLevelPlotfileWithBathymetry(plotfilename, finest_level+1,
447 GetVecOfConstPtrs(mf2),
448 GetVecOfConstPtrs(mf_nd),
449 GetVecOfConstPtrs(mf_u),
450 GetVecOfConstPtrs(mf_v),
451 GetVecOfConstPtrs(mf_w),
452 GetVecOfConstPtrs(mf_2d_rho),
453 GetVecOfConstPtrs(mf_2d_u),
454 GetVecOfConstPtrs(mf_2d_v),
455 varnames_3d, varnames_2d_rho,
456 varnames_2d_u, varnames_2d_v,
457 g2,
458 t_new[0], istep, rr);
459 writeJobInfo(plotfilename);
460
461#ifdef REMORA_USE_PARTICLES
462 particleData.Checkpoint(plotfilename);
463#endif
464 } else {
465 WriteMultiLevelPlotfileWithBathymetry(plotfilename, finest_level+1,
466 GetVecOfConstPtrs(mf),
467 GetVecOfConstPtrs(mf_nd),
468 GetVecOfConstPtrs(mf_u),
469 GetVecOfConstPtrs(mf_v),
470 GetVecOfConstPtrs(mf_w),
471 GetVecOfConstPtrs(mf_2d_rho),
472 GetVecOfConstPtrs(mf_2d_u),
473 GetVecOfConstPtrs(mf_2d_v),
474 varnames_3d, varnames_2d_rho,
475 varnames_2d_u, varnames_2d_v,
476 Geom(),
477 t_new[0], istep, ref_ratio);
478 writeJobInfo(plotfilename);
479#ifdef REMORA_USE_PARTICLES
480 particleData.Checkpoint(plotfilename);
481#endif
482 }
483 }
484 } // end multi-level
485 for (int lev = 0; lev <= finest_level; ++lev) {
486 mask_arrays_for_write(lev, 0.0_rt, (Real) fill_value);
487 }
488}
489
490/**
491 * @param plotfilename name of plotfile to write to
492 * @param nlevels number of levels to write out
493 * @param mf MultiFab of data to write out
494 * @param mf_nd Multifab of nodal data to write out
495 * @param varnames_3d 3D variable names to write out
496 * @param varnames_2d_rho 2D cell-centered variable names to write out
497 * @param varnames_2d_u 2D x-face-based variable names to write out
498 * @param varnames_2d_v 2D y-face-based variable names to write out
499 * @param my_geom geometry to use for writing plotfile
500 * @param time time at which to output
501 * @param level_steps vector over level of iterations
502 * @param rr refinement ratio to use for writing plotfile
503 * @param versionName version string for VisIt
504 * @param levelPrefix string to prepend to level number
505 * @param mfPrefix subdirectory for multifab data
506 * @param extra_dirs additional subdirectories within plotfile
507 */
508 void
509 REMORA::WriteMultiLevelPlotfileWithBathymetry (const std::string& plotfilename, int nlevels,
510 const Vector<const MultiFab*>& mf,
511 const Vector<const MultiFab*>& mf_nd,
512 const Vector<const MultiFab*>& mf_u,
513 const Vector<const MultiFab*>& mf_v,
514 const Vector<const MultiFab*>& mf_w,
515 const Vector<const MultiFab*>& mf_2d_rho,
516 const Vector<const MultiFab*>& mf_2d_u,
517 const Vector<const MultiFab*>& mf_2d_v,
518 const Vector<std::string>& varnames_3d,
519 const Vector<std::string>& varnames_2d_rho,
520 const Vector<std::string>& varnames_2d_u,
521 const Vector<std::string>& varnames_2d_v,
522 const Vector<Geometry>& my_geom,
523 Real time,
524 const Vector<int>& level_steps,
525 const Vector<IntVect>& rr,
526 const std::string &versionName,
527 const std::string &levelPrefix,
528 const std::string &mfPrefix,
529 const Vector<std::string>& extra_dirs) const
530{
531 BL_PROFILE("WriteMultiLevelPlotfileWithBathymetry()");
532
533 BL_ASSERT(nlevels <= mf.size());
534 BL_ASSERT(nlevels <= ref_ratio.size()+1);
535 BL_ASSERT(nlevels <= level_steps.size());
536
537 BL_ASSERT(mf[0]->nComp() == varnames_3d.size());
538
539 bool callBarrier(false);
540 PreBuildDirectorHierarchy(plotfilename, levelPrefix, nlevels, callBarrier);
541 if (!extra_dirs.empty()) {
542 for (const auto& d : extra_dirs) {
543 const std::string ed = plotfilename+"/"+d;
544 PreBuildDirectorHierarchy(ed, levelPrefix, nlevels, callBarrier);
545 }
546 }
547 ParallelDescriptor::Barrier();
548
549 if (ParallelDescriptor::MyProc() == ParallelDescriptor::NProcs()-1) {
550 Vector<BoxArray> boxArrays(nlevels);
551 for(int level(0); level < boxArrays.size(); ++level) {
552 boxArrays[level] = mf[level]->boxArray();
553 }
554
555 auto f = [=]() {
556 VisMF::IO_Buffer io_buffer(VisMF::IO_Buffer_Size);
557 std::string HeaderFileName(plotfilename + "/Header");
558 std::ofstream HeaderFile;
559 HeaderFile.rdbuf()->pubsetbuf(io_buffer.dataPtr(), io_buffer.size());
560 HeaderFile.open(HeaderFileName.c_str(), std::ofstream::out |
561 std::ofstream::trunc |
562 std::ofstream::binary);
563 if( ! HeaderFile.good()) FileOpenFailed(HeaderFileName);
564 WriteGenericPlotfileHeaderWithBathymetry(HeaderFile, nlevels, boxArrays, varnames_3d,
565 varnames_2d_rho, varnames_2d_u, varnames_2d_v,
566 my_geom, time, level_steps, rr, versionName,
567 levelPrefix, mfPrefix);
568 };
569
570 if (AsyncOut::UseAsyncOut()) {
571 AsyncOut::Submit(std::move(f));
572 } else {
573 f();
574 }
575 }
576
577 std::string mf_nodal_prefix = "Nu_nd";
578 std::string mf_uface_prefix = "UFace";
579 std::string mf_vface_prefix = "VFace";
580 std::string mf_wface_prefix = "WFace";
581 std::string mf_2d_rho_prefix = "rho2d";
582 std::string mf_2d_u_prefix = "u2d";
583 std::string mf_2d_v_prefix = "v2d";
584
585 for (int level = 0; level <= finest_level; ++level)
586 {
587 if (AsyncOut::UseAsyncOut()) {
588 VisMF::AsyncWrite(*mf[level],
589 MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mfPrefix),
590 true);
591 VisMF::AsyncWrite(*mf_nd[level],
592 MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mf_nodal_prefix),
593 true);
594 if (plot_staggered_vels) {
595 VisMF::AsyncWrite(*mf_u[level],
596 MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mf_uface_prefix),
597 true);
598 VisMF::AsyncWrite(*mf_v[level],
599 MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mf_vface_prefix),
600 true);
601 VisMF::AsyncWrite(*mf_w[level],
602 MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mf_wface_prefix),
603 true);
604 }
605 if (mf_2d_rho[level]->nComp() > 0) {
606 VisMF::AsyncWrite(*mf_2d_rho[level],
607 MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mf_2d_rho_prefix),
608 true);
609 }
610 if (mf_2d_u[level]->nComp() > 0) {
611 VisMF::AsyncWrite(*mf_2d_u[level],
612 MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mf_2d_u_prefix),
613 true);
614 }
615 if (mf_2d_v[level]->nComp() > 0) {
616 VisMF::AsyncWrite(*mf_2d_v[level],
617 MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mf_2d_v_prefix),
618 true);
619 }
620 } else {
621 const MultiFab* data;
622 std::unique_ptr<MultiFab> mf_tmp;
623 if (mf[level]->nGrowVect() != 0) {
624 mf_tmp = std::make_unique<MultiFab>(mf[level]->boxArray(),
625 mf[level]->DistributionMap(),
626 mf[level]->nComp(), 0, MFInfo(),
627 mf[level]->Factory());
628 MultiFab::Copy(*mf_tmp, *mf[level], 0, 0, mf[level]->nComp(), 0);
629 data = mf_tmp.get();
630 } else {
631 data = mf[level];
632 }
633 VisMF::Write(*data , MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mfPrefix));
634 VisMF::Write(*mf_nd[level], MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mf_nodal_prefix));
635 if (plot_staggered_vels) {
636 VisMF::Write(*mf_u[level], MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mf_uface_prefix));
637 VisMF::Write(*mf_v[level], MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mf_vface_prefix));
638 VisMF::Write(*mf_w[level], MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mf_wface_prefix));
639 }
640 if (mf_2d_rho[level]->nComp() > 0) {
641 VisMF::Write(*mf_2d_rho[level], MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mf_2d_rho_prefix));
642 }
643 if (mf_2d_u[level]->nComp() > 0) {
644 VisMF::Write(*mf_2d_u[level], MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mf_2d_u_prefix));
645 }
646 if (mf_2d_v[level]->nComp() > 0) {
647 VisMF::Write(*mf_2d_v[level], MultiFabFileFullPrefix(level, plotfilename, levelPrefix, mf_2d_v_prefix));
648 }
649 }
650 } // level
651}
652
653/**
654 * @param HeaderFile output stream for header
655 * @param nlevels number of levels to write out
656 * @param bArray vector over levels of BoxArrays
657 * @param varnames_3d 3D variable names to write out
658 * @param varnames_2d 2D variable names to write out
659 * @param my_geom geometry to use for writing plotfile
660 * @param time time at which to output
661 * @param level_steps vector over level of iterations
662 * @param my_ref_ratio refinement ratio to use for writing plotfile
663 * @param versionName version string for VisIt
664 * @param levelPrefix string to prepend to level number
665 * @param mfPrefix subdirectory for multifab data
666 */
667void
668REMORA::WriteGenericPlotfileHeaderWithBathymetry (std::ostream &HeaderFile,
669 [[maybe_unused]] int nlevels,
670 const Vector<BoxArray> &bArray,
671 const Vector<std::string> &varnames_3d,
672 const Vector<std::string> &varnames_2d_rho,
673 const Vector<std::string> &varnames_2d_u,
674 const Vector<std::string> &varnames_2d_v,
675 const Vector<Geometry>& my_geom,
676 Real time,
677 const Vector<int> &level_steps,
678 const Vector<IntVect>& my_ref_ratio,
679 const std::string &versionName,
680 const std::string &levelPrefix,
681 const std::string &mfPrefix) const
682{
683 BL_ASSERT(nlevels <= bArray.size());
684 BL_ASSERT(nlevels <= ref_ratio.size()+1);
685 BL_ASSERT(nlevels <= level_steps.size());
686
687 int num_extra_mfs = 1; // for nodal, which is always on
688 if (plot_staggered_vels) {
689 num_extra_mfs += 3; // for nodal, which is always on
690 }
691
692 HeaderFile.precision(17);
693
694 // ---- this is the generic plot file type name
695 HeaderFile << versionName << '\n';
696
697 HeaderFile << varnames_3d.size() << '\n';
698
699 for (int ivar = 0; ivar < varnames_3d.size(); ++ivar) {
700 HeaderFile << varnames_3d[ivar] << "\n";
701 }
702 HeaderFile << AMREX_SPACEDIM << '\n';
703 HeaderFile << time << '\n';
704 HeaderFile << finest_level << '\n';
705 for (int i = 0; i < AMREX_SPACEDIM; ++i) {
706 HeaderFile << my_geom[0].ProbLo(i) << ' ';
707 }
708 HeaderFile << '\n';
709 for (int i = 0; i < AMREX_SPACEDIM; ++i) {
710 HeaderFile << my_geom[0].ProbHi(i) << ' ';
711 }
712 HeaderFile << '\n';
713 for (int i = 0; i < finest_level; ++i) {
714 HeaderFile << my_ref_ratio[i][0] << ' ';
715 }
716 HeaderFile << '\n';
717 for (int i = 0; i <= finest_level; ++i) {
718 HeaderFile << my_geom[i].Domain() << ' ';
719 }
720 HeaderFile << '\n';
721 for (int i = 0; i <= finest_level; ++i) {
722 HeaderFile << level_steps[i] << ' ';
723 }
724 HeaderFile << '\n';
725 for (int i = 0; i <= finest_level; ++i) {
726 for (int k = 0; k < AMREX_SPACEDIM; ++k) {
727 HeaderFile << my_geom[i].CellSize()[k] << ' ';
728 }
729 HeaderFile << '\n';
730 }
731 HeaderFile << (int) my_geom[0].Coord() << '\n';
732 HeaderFile << "0\n";
733
734 for (int level = 0; level <= finest_level; ++level) {
735 HeaderFile << level << ' ' << bArray[level].size() << ' ' << time << '\n';
736 HeaderFile << level_steps[level] << '\n';
737
738 const IntVect& domain_lo = my_geom[level].Domain().smallEnd();
739 for (int i = 0; i < bArray[level].size(); ++i)
740 {
741 // Need to shift because the RealBox ctor we call takes the
742 // physical location of index (0,0,0). This does not affect
743 // the usual cases where the domain index starts with 0.
744 const Box& b = shift(bArray[level][i], -domain_lo);
745 RealBox loc = RealBox(b, my_geom[level].CellSize(), my_geom[level].ProbLo());
746 for (int n = 0; n < AMREX_SPACEDIM; ++n) {
747 HeaderFile << loc.lo(n) << ' ' << loc.hi(n) << '\n';
748 }
749 }
750
751 HeaderFile << MultiFabHeaderPath(level, levelPrefix, mfPrefix) << '\n';
752 }
753 HeaderFile << num_extra_mfs << "\n";
754 HeaderFile << "3" << "\n";
755 HeaderFile << "amrexvec_nu_x" << "\n";
756 HeaderFile << "amrexvec_nu_y" << "\n";
757 HeaderFile << "amrexvec_nu_z" << "\n";
758 std::string mf_nodal_prefix = "Nu_nd";
759 for (int level = 0; level <= finest_level; ++level) {
760 HeaderFile << MultiFabHeaderPath(level, levelPrefix, mf_nodal_prefix) << '\n';
761 }
762 if (plot_staggered_vels) {
763 HeaderFile << "1" << "\n"; // number of components in the multifab
764 HeaderFile << "u_vel" << "\n";
765 std::string mf_uface_prefix = "UFace";
766 for (int level = 0; level <= finest_level; ++level) {
767 HeaderFile << MultiFabHeaderPath(level, levelPrefix, mf_uface_prefix) << '\n';
768 }
769 HeaderFile << "1" << "\n";
770 HeaderFile << "v_vel" << "\n";
771 std::string mf_vface_prefix = "VFace";
772 for (int level = 0; level <= finest_level; ++level) {
773 HeaderFile << MultiFabHeaderPath(level, levelPrefix, mf_vface_prefix) << '\n';
774 }
775 HeaderFile << "1" << "\n";
776 HeaderFile << "w_vel" << "\n";
777 std::string mf_wface_prefix = "WFace";
778 for (int level = 0; level <= finest_level; ++level) {
779 HeaderFile << MultiFabHeaderPath(level, levelPrefix, mf_wface_prefix) << '\n';
780 }
781 }
782
783 if (varnames_2d_rho.size() > 0) {
784 HeaderFile << varnames_2d_rho.size() << "\n"; // number of components in the 2D rho multifab
785 for (int ivar = 0; ivar < varnames_2d_rho.size(); ++ivar) {
786 HeaderFile << varnames_2d_rho[ivar] << "\n";
787 }
788 std::string mf_2d_rho_prefix = "rho2d";
789 for (int level = 0; level <= finest_level; ++level) {
790 HeaderFile << MultiFabHeaderPath(level, levelPrefix, mf_2d_rho_prefix) << "\n";
791 }
792 }
793
794 if (varnames_2d_u.size() > 0) {
795 HeaderFile << varnames_2d_u.size() << "\n"; // number of components in the 2D rho multifab
796 for (int ivar = 0; ivar < varnames_2d_u.size(); ++ivar) {
797 HeaderFile << varnames_2d_u[ivar] << "\n";
798 }
799 std::string mf_2d_u_prefix = "u2d";
800 for (int level = 0; level <= finest_level; ++level) {
801 HeaderFile << MultiFabHeaderPath(level, levelPrefix, mf_2d_u_prefix) << "\n";
802 }
803 }
804
805 if (varnames_2d_v.size() > 0) {
806 HeaderFile << varnames_2d_v.size() << "\n"; // number of components in the 2D v multifab
807 for (int ivar = 0; ivar < varnames_2d_v.size(); ++ivar) {
808 HeaderFile << varnames_2d_v[ivar] << "\n";
809 }
810 std::string mf_2d_v_prefix = "v2d";
811 for (int level = 0; level <= finest_level; ++level) {
812 HeaderFile << MultiFabHeaderPath(level, levelPrefix, mf_2d_v_prefix) << "\n";
813 }
814 }
815}
816
817/**
818 * @param lev level to mask
819 * @param fill_value fill value to mask with
820 * @param fill_where value at cells where we will apply the mask. This is necessary because rivers
821 */
822void
823REMORA::mask_arrays_for_write(int lev, Real fill_value, Real fill_where) {
824 for (MFIter mfi(*cons_new[lev],false); mfi.isValid(); ++mfi) {
825 Box gbx1 = mfi.growntilebox(IntVect(NGROW+1,NGROW+1,0));
826 Box ubx = mfi.grownnodaltilebox(0,IntVect(NGROW,NGROW,0));
827 Box vbx = mfi.grownnodaltilebox(1,IntVect(NGROW,NGROW,0));
828
829 Array4<Real> const& Zt_avg1 = vec_Zt_avg1[lev]->array(mfi);
830 Array4<Real> const& ubar = vec_ubar[lev]->array(mfi);
831 Array4<Real> const& vbar = vec_vbar[lev]->array(mfi);
832 Array4<Real> const& xvel = xvel_new[lev]->array(mfi);
833 Array4<Real> const& yvel = yvel_new[lev]->array(mfi);
834 Array4<Real> const& temp = cons_new[lev]->array(mfi,Temp_comp);
835 Array4<Real> const& salt = cons_new[lev]->array(mfi,Salt_comp);
836
837 Array4<Real const> const& mskr = vec_mskr[lev]->array(mfi);
838 Array4<Real const> const& msku = vec_msku[lev]->array(mfi);
839 Array4<Real const> const& mskv = vec_mskv[lev]->array(mfi);
840
841 ParallelFor(makeSlab(gbx1,2,0), [=] AMREX_GPU_DEVICE (int i, int j, int )
842 {
843 if (mskr(i,j,0) == 0.0) { // Explicitly compare to 0.0
844 Zt_avg1(i,j,0) = fill_value;
845 }
846 });
847 ParallelFor(gbx1, [=] AMREX_GPU_DEVICE (int i, int j, int k)
848 {
849 if (mskr(i,j,0) == 0.0) { // Explicitly compare to 0.0
850 temp(i,j,k) = fill_value;
851 salt(i,j,k) = fill_value;
852 }
853 });
854 ParallelFor(makeSlab(ubx,2,0), 3, [=] AMREX_GPU_DEVICE (int i, int j, int , int n)
855 {
856 if (msku(i,j,0) == 0.0 && ubar(i,j,0)==fill_where) { // Explicitly compare to 0.0
857 ubar(i,j,0,n) = fill_value;
858 }
859 });
860 ParallelFor(makeSlab(vbx,2,0), 3, [=] AMREX_GPU_DEVICE (int i, int j, int , int n)
861 {
862 if (mskv(i,j,0) == 0.0 && vbar(i,j,0)==fill_where) { // Explicitly compare to 0.0
863 vbar(i,j,0,n) = fill_value;
864 }
865 });
866 ParallelFor(ubx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
867 {
868 if (msku(i,j,0) == 0.0 && xvel(i,j,k)==fill_where) { // Explicitly compare to 0.0
869 xvel(i,j,k) = fill_value;
870 }
871 });
872 ParallelFor(vbx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
873 {
874 if (mskv(i,j,0) == 0.0 && yvel(i,j,k)==fill_where) { // Explicitly compare to 0.0
875 yvel(i,j,k) = fill_value;
876 }
877 });
878 }
879 Gpu::streamSynchronize();
880}
PlotfileType::amrex
@ amrex
PlotfileType::netcdf
@ netcdf
PlotfileType::hdf5
@ hdf5
Coord
Coord
Coordinates.
Definition REMORA_DataStruct.H:20
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
NCONS
#define NCONS
Definition REMORA_IndexDefines.H:11
containerHasElement
bool containerHasElement(const V &iterable, const T &query)
Definition REMORA_Plotfile.cpp:10
null_bc_for_fill
PhysBCFunctNoOp null_bc_for_fill
Definition REMORA_Plotfile.cpp:7
REMORA::plotfile_type
static PlotfileType plotfile_type
Native or NetCDF plotfile output.
Definition REMORA.H:1373
REMORA::cons_names
const amrex::Vector< std::string > cons_names
Names of scalars for plotfile output.
Definition REMORA.H:1323
REMORA::domain_bcs_type
amrex::Vector< amrex::BCRec > domain_bcs_type
vector (over BCVars) of BCRecs
Definition REMORA.H:1226
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:398
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:387
REMORA::writeJobInfo
void writeJobInfo(const std::string &dir) const
Write job info to stdout.
Definition REMORA_writeJobInfo.cpp:7
REMORA::vec_sustr
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_sustr
Surface stress in the u direction.
Definition REMORA.H:311
REMORA::zvel_new
amrex::Vector< amrex::MultiFab * > zvel_new
multilevel data container for current step's z velocities (largely unused; W stored separately)
Definition REMORA.H:247
REMORA::vec_msku
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_msku
land/sea mask at x-faces (2D)
Definition REMORA.H:389
REMORA::FillPatchNoBC
void FillPatchNoBC(int lev, amrex::Real time, amrex::MultiFab &mf_to_be_filled, amrex::Vector< amrex::MultiFab * > const &mfs, const int bdy_var_type=BdyVars::null, const int icomp=0, const bool fill_all=true, const bool fill_set=true)
Fill a new MultiFab by copying in phi from valid region and filling ghost cells without applying boun...
Definition REMORA_FillPatch.cpp:199
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::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_mskv
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_mskv
land/sea mask at y-faces (2D)
Definition REMORA.H:391
REMORA::istep
amrex::Vector< int > istep
which step?
Definition REMORA.H:1200
REMORA::WriteMultiLevelPlotfileWithBathymetry
void WriteMultiLevelPlotfileWithBathymetry(const std::string &plotfilename, int nlevels, const amrex::Vector< const amrex::MultiFab * > &mf, const amrex::Vector< const amrex::MultiFab * > &mf_nd, const amrex::Vector< const amrex::MultiFab * > &mf_u, const amrex::Vector< const amrex::MultiFab * > &mf_v, const amrex::Vector< const amrex::MultiFab * > &mf_w, const amrex::Vector< const amrex::MultiFab * > &mf_2d_rho, const amrex::Vector< const amrex::MultiFab * > &mf_2d_u, const amrex::Vector< const amrex::MultiFab * > &mf_2d_v, const amrex::Vector< std::string > &varnames_3d, const amrex::Vector< std::string > &varnames_2d_rho, const amrex::Vector< std::string > &varnames_2d_u, const amrex::Vector< std::string > &varnames_2d_v, const amrex::Vector< amrex::Geometry > &my_geom, amrex::Real time, const amrex::Vector< int > &level_steps, const amrex::Vector< amrex::IntVect > &rr, const std::string &versionName="HyperCLaw-V1.1", const std::string &levelPrefix="Level_", const std::string &mfPrefix="Cell", const amrex::Vector< std::string > &extra_dirs=amrex::Vector< std::string >()) const
write out particular data to an AMReX plotfile
Definition REMORA_Plotfile.cpp:509
REMORA::mask_arrays_for_write
void mask_arrays_for_write(int lev, amrex::Real fill_value, amrex::Real fill_where)
Mask data arrays before writing output.
Definition REMORA_Plotfile.cpp:823
REMORA::file_min_digits
static int file_min_digits
Minimum number of digits in plotfile name or chunked history file.
Definition REMORA.H:1367
REMORA::vec_svstr
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_svstr
Surface stress in the v direction.
Definition REMORA.H:313
REMORA::vec_DV_avg1
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_DV_avg1
time average of barotropic y velocity flux
Definition REMORA.H:370
REMORA::t_new
amrex::Vector< amrex::Real > t_new
new time at each level
Definition REMORA.H:1204
REMORA::WriteGenericPlotfileHeaderWithBathymetry
void WriteGenericPlotfileHeaderWithBathymetry(std::ostream &HeaderFile, int nlevels, const amrex::Vector< amrex::BoxArray > &bArray, const amrex::Vector< std::string > &varnames_3d, const amrex::Vector< std::string > &varnames_2d_rho, const amrex::Vector< std::string > &varnames_2d_u, const amrex::Vector< std::string > &varnames_2d_v, const amrex::Vector< amrex::Geometry > &my_geom, amrex::Real time, const amrex::Vector< int > &level_steps, const amrex::Vector< amrex::IntVect > &rr, const std::string &versionName, const std::string &levelPrefix, const std::string &mfPrefix) const
write out header data for an AMReX plotfile
Definition REMORA_Plotfile.cpp:668
REMORA::plot_staggered_vels
static int plot_staggered_vels
Whether to write the staggered velocities (not averaged to cell centers)
Definition REMORA.H:1370
REMORA::vec_vbar
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_vbar
barotropic y velocity (2D)
Definition REMORA.H:382
REMORA::vec_DU_avg1
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_DU_avg1
time average of barotropic x velocity flux (2D)
Definition REMORA.H:366
REMORA::expand_plotvars_to_unif_rr
bool expand_plotvars_to_unif_rr
whether plotfile variables should be expanded to a uniform refinement ratio
Definition REMORA.H:1332
REMORA::vec_ubar
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_ubar
barotropic x velocity (2D)
Definition REMORA.H:380
REMORA::vec_bustr
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_bustr
Bottom stress in the u direction.
Definition REMORA.H:361
REMORA::vec_bvstr
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_bvstr
Bottom stress in the v direction.
Definition REMORA.H:363
REMORA::vec_z_phys_nd
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_z_phys_nd
z coordinates at psi points (cell nodes)
Definition REMORA.H:305
REMORA::vec_pn
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_pn
horizontal scaling factor: 1 / dy (2D)
Definition REMORA.H:400
REMORA::plot_var_names_3d
amrex::Vector< std::string > plot_var_names_3d
Names of 3D variables to output to AMReX plotfile.
Definition REMORA.H:1319
REMORA::plot_file_name
std::string plot_file_name
Plotfile prefix.
Definition REMORA.H:1296
REMORA::vec_Zt_avg1
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_Zt_avg1
Average of the free surface, zeta (2D)
Definition REMORA.H:308
REMORA::WritePlotFile
void WritePlotFile()
main driver for writing AMReX plotfiles
Definition REMORA_Plotfile.cpp:16
REMORA::plot_var_names_2d
amrex::Vector< std::string > plot_var_names_2d
Names of 2D variables to output to AMReX plotfile.
Definition REMORA.H:1321
derived::remora_dervort
void remora_dervort(const amrex::Box &bx, amrex::FArrayBox &derfab, int dcomp, int ncomp, const amrex::FArrayBox &datfab, const amrex::Array4< const amrex::Real > &pm, const amrex::Array4< const amrex::Real > &pn, const amrex::Array4< const amrex::Real > &, const amrex::Geometry &, amrex::Real, const int *, const int)
Definition REMORA_Derive.cpp:42
derived::remora_dernull
void remora_dernull(const amrex::Box &, amrex::FArrayBox &, int, int, const amrex::FArrayBox &, const amrex::Array4< const amrex::Real > &, const amrex::Array4< const amrex::Real > &, const amrex::Array4< const amrex::Real > &, const amrex::Geometry &, amrex::Real, const int *, const int)
Definition REMORA_Derive.cpp:9