REMORA
Regional Modeling of Oceans Refined Adaptively
Loading...
Searching...
No Matches
REMORA.H
Go to the documentation of this file.
1#ifndef REMORA_H_
2#define REMORA_H_
3
4#include <string>
5#include <limits>
6#include <array>
7#include <memory>
8
9#ifdef _OPENMP
10#include <omp.h>
11#endif
12
13#include <AMReX_AmrCore.H>
14#include <AMReX_BCRec.H>
15#include <AMReX_InterpFaceRegister.H>
16
17#include <AMReX_ParallelDescriptor.H>
18#include <AMReX_ParmParse.H>
19#include <AMReX_MultiFabUtil.H>
20#include <AMReX_FillPatchUtil.H>
21#include <AMReX_VisMF.H>
22#include <AMReX_PhysBCFunct.H>
23#include <AMReX_YAFluxRegister.H>
24#include <AMReX_ErrorList.H>
25
26#ifdef AMREX_MEM_PROFILING
27#include <AMReX_MemProfiler.H>
28#endif
29
30#include <REMORA_PhysBCFunct.H>
31#include <REMORA_FillPatcher.H>
32
33#include <REMORA_IndexDefines.H>
34#include <REMORA_TimeInterpolatedData.H>
35#include <REMORA_DataStruct.H>
36#include <REMORA_Derive.H>
37#include <REMORA_Biology.H>
38#include "REMORA_prob_common.H"
39
40#ifdef REMORA_USE_PARTICLES
41#include "REMORA_ParticleData.H"
42#endif
43
44#ifdef REMORA_USE_NETCDF
45#include "REMORA_NCInterface.H"
46#include "REMORA_NCTimeSeries.H"
47#include "REMORA_NCTimeSeriesRiver.H"
48#include "REMORA_NCTimeSeriesBoundary.H"
49#endif
50
51#ifdef REMORA_USE_MOAB
52#include "REMORA_MOAB.H"
53#endif
54
55#include <iostream>
56
57#ifdef AMREX_LAZY
58#include <AMReX_Lazy.H>
59#endif
60
61#ifndef AMREX_USE_MPI
62using amrex::MPI_COMM_WORLD;
63using amrex::MPI_Comm;
64#endif
65
77
78// Forward declarations to resolve circular dependency
79class ProblemBase;
80#ifdef REMORA_USE_NETCDF
81class NCTimeSeries;
82class NCTimeSeriesRiver;
83class NCTimeSeriesBoundary;
84#endif
85
86/*!
87 * \brief Class that stores all relevant simulation state data with methods for time stepping
88 */
89class REMORA
90 : public amrex::AmrCore
91{
92public:
93 enum class DriverAtmosForcingMode : int {
94 State = 0,
95 Flux
96 };
97
98 static constexpr bool DriverUsesStateForcing (DriverAtmosForcingMode mode) noexcept
99 {
100 return mode == DriverAtmosForcingMode::State;
101 }
102
103 REMORA ();
104 REMORA (const amrex::RealBox& rb, int max_level_in, const amrex::Vector<int>& n_cell_in, int coord, const amrex::Vector<amrex::IntVect>& ref_ratio, const amrex::Array<int,AMREX_SPACEDIM>& is_per, std::string prefix);
105 virtual ~REMORA ();
106
107 /** \brief Advance solution to final time */
108 void Evolve ();
109
110 /** \brief Write checkpoint and plotfiles at end of simulation */
111 void WriteAtFinalTime ();
112
113 /** \brief Write checkpoint and plotfiles at intermediate point of simulation, if needed */
114 void WriteAtIntermediateTime (int step, amrex::Real cur_time);
115
116 /** \brief Tag cells for refinement */
117 virtual void ErrorEst (int lev, amrex::TagBoxArray& tags, amrex::Real time, int ngrow) override;
118
119 /** \brief Initialize multilevel data */
120 void InitData ();
121 amrex::Real EvolveOneStep (amrex::Real time, amrex::Real dt_request);
122 void SetStartTime (amrex::Real time) noexcept { start_time = time; }
123
124 void ConfigureDriverAtmosToOceanCoupling (bool use_coupling_driver,
125 bool use_two_way_coupling,
126 DriverAtmosForcingMode active_mode);
127 void SetDriverAtmosToOceanForcingMode (DriverAtmosForcingMode mode);
128
129 // Consume the driver-supplied DOWNWARD longwave on vec_longwave_down instead
130 // of computing longwave internally. Set programmatically rather than through
131 // ParmParse so a coupled run's job_info still reflects the deck rather than
132 // driver-injected keys. Safe any time before the first step: the lane is
133 // allocated whenever bulk fluxes are on, independent of lwrad_type.
134 void SetLongwaveFromDriver ();
135
136 // Per state lane, whether the deck named its forcing - either the selector
137 // (remora.<x>_type, its legacy aliases, remora.wind_type) or the constant
138 // (remora.air_humidity and friends). A coupling driver uses it to leave such
139 // a lane with the deck instead of overriding it with atmospheric data.
140 //
141 // Not answerable from ParmParse afterwards: queryAdd materializes the
142 // defaults. See SolverChoice::bulk_flux_type_specified.
143 void GetDeckConfiguredAtmosStateLanes (
144 std::array<bool, AtmosState::NumTypes>& deck_configured) const;
145
146 // Driver currently consumes BoxArray/DistributionMapping only. If we later
147 // need exact copy semantics, promote these to expose IndexType/ngrow
148 // explicitly or return the underlying MultiFab pointer/reference instead.
149 void GetAtmosToOceanRhoLayout (amrex::BoxArray& ba,
150 amrex::DistributionMapping& dm) const;
151 void GetAtmosToOceanUFaceLayout (amrex::BoxArray& ba,
152 amrex::DistributionMapping& dm) const;
153 void GetAtmosToOceanVFaceLayout (amrex::BoxArray& ba,
154 amrex::DistributionMapping& dm) const;
155 // Returns pointers to level-0 psi-point coordinate MultiFabs (vec_xp/vec_yp)
156 // used to build atmos->ocean remap weights. Sets both to nullptr if
157 // unavailable in the current configuration rather than aborting.
158 void GetAtmosToOceanPsiCoordinates (const amrex::MultiFab*& x_psi,
159 const amrex::MultiFab*& y_psi) const;
160
161 // Returns pointers to level-0 psi-point spherical coordinate MultiFabs
162 // (vec_lonp/vec_latp, degrees east/north). These are the corner arrays a
163 // coupled driver needs when the two solvers do not share a projected
164 // Cartesian frame: SCRIP/COAWST likewise remaps in lon/lat and reads
165 // lon_psi/lat_psi for spherical ROMS grids (see COAWST
166 // Lib/SCRIP_COAWST/read_roms.f). Sets both to nullptr when the grid file
167 // carried no spherical coordinates rather than aborting.
168 void GetAtmosToOceanPsiLonLat (const amrex::MultiFab*& lon_psi,
169 const amrex::MultiFab*& lat_psi) const;
170
171 // Returns the level-0 wet/dry masks (1 = wet, 0 = land) at rho, u-face,
172 // and v-face points, used by the driver to exclude land cells from
173 // remap destination stencils. Sets pointers to nullptr if unavailable.
174 void GetLandSeaMasks (const amrex::MultiFab*& mskr,
175 const amrex::MultiFab*& msku,
176 const amrex::MultiFab*& mskv) const;
177
178 /** \brief Init (NOT restart or regrid) */
179 void init_only (int lev, amrex::Real time);
180
181 /** \briefRestart */
182 void restart ();
183
184 /** \brief Called after every level 0 timestep */
185 void post_timestep (int nstep, amrex::Real time, amrex::Real dt_lev);
186
187 /**
188 * \brief Extracts SST from the 3D conservative state for the atmospheric driver.
189 *
190 * Reads Temp_comp at the top water-column cell (k_sfc), converts from
191 * Celsius to Kelvin, and copies the result into state[SSTIndex].
192 *
193 * @param[in,out] state OCN2ATM slab buffer sized by the driver (one MultiFab
194 * per ocean-to-atmosphere export layer). state[SSTIndex]
195 * (index 0) is overwritten with sea-surface temperature
196 * (SST) sampled from the Temp_comp tracer at the uppermost
197 * sigma level (k = Nz) and converted from degrees Celsius
198 * to Kelvin for the atmospheric driver. An empty vector or
199 * null state[0] is treated as a no-op.
200 * @param[in ] time Current ocean model time (unused; retained for driver
201 * interface conformance).
202 */
203 // dst_land_mask is the ERF land mask (1 = land, 0 = water) on the
204 // destination (ERF) layout; destination cells over land are zeroed.
205 // Pass nullptr to skip masking.
206 void PackSurfaceState (amrex::Vector<amrex::MultiFab*>& state, amrex::Real time,
207 const amrex::MultiFab* weight_o2a_mf,
208 const amrex::iMultiFab* index_o2a_mf,
209 int max_stencil_size,
210 const amrex::iMultiFab* dst_land_mask = nullptr);
211
212 /**
213 * \brief Receives atmospheric states from the driver and applies unit conversions.
214 *
215 * Fills REMORA's internal forcing MultiFabs from states and records which
216 * lanes were successfully updated in driver_atmos_state_from_driver.
217 * Unit conversions applied: Pair Pa to mb; Tair K to Celsius.
218 *
219 * @param[in] states ATM2OCN forcing slab buffer from the driver (Warner et al.
220 * 2010, Block B state-passing contract), indexed by AtmosState.
221 * Expected units per lane:
222 * Uwind/Vwind: 10-m winds [m/s];
223 * Pair: mean sea-level pressure [Pa, converted to mb];
224 * Qair: near-surface specific humidity [kg/kg];
225 * Tair: 2-m air temperature [K, converted to degC];
226 * Cloud: cloud fraction [0-1];
227 * Rain: precipitation rate [kg/m^2/s];
228 * SWrad/LWrad: downwelling shortwave/longwave radiation [W/m^2].
229 * Missing lanes (null pointer or index out of range) are skipped;
230 * driver_atmos_state_from_driver tracks populated lanes for the
231 * bulk-flux parameterization fallback logic.
232 * @param[in] time Current ocean model time (unused; retained for driver
233 * interface conformance).
234 */
235 void ApplyAtmosphericStates (const amrex::Vector<amrex::MultiFab*>& states, amrex::Real time);
236
237 /**
238 * \brief Receives atmospheric flux lanes from the driver and assembles REMORA flux inputs.
239 *
240 * Expected active-lane order matches the driver FluxPassing contract:
241 * tau_x, tau_y, SHflux, LHflux, SWrad, LWrad, rain, evap.
242 *
243 * This routine copies imported forcing lanes into REMORA's existing flux arrays
244 * and assembles vec_stflux directly from those imported values. It intentionally
245 * leaves the downstream salt_old multiplication to setup_step().
246 */
247 void ApplyAtmosphericFluxes (const amrex::Vector<amrex::MultiFab*>& states, amrex::Real time);
248
249 // Diagnostics
250
251 /** \brief Integrate conserved quantities for diagnostics */
252 void sum_integrated_quantities (amrex::Real time);
253
254 /** \brief Perform the volume-weighted sum */
255 amrex::Real
256 volWgtSumMF (int lev,
257 const amrex::MultiFab& mf, int comp, bool local, bool finemask);
258
259 /** \brief Decide if it is time to take an action */
260 bool is_it_time_for_action (int nstep, amrex::Real time, amrex::Real dt,
261 int action_interval, amrex::Real action_per);
262
263 /** \brief Make a new level using provided BoxArray and DistributionMapping and
264 * fill with interpolated coarse level data.
265 * Overrides the pure virtual function in AmrCore
266 */
267 virtual void MakeNewLevelFromCoarse (int lev, amrex::Real time, const amrex::BoxArray& ba,
268 const amrex::DistributionMapping& dm) override;
269
270 /** \brief Remake an existing level using provided BoxArray and DistributionMapping and
271 * fill with existing fine and coarse data.
272 * Overrides the pure virtual function in AmrCore
273 */
274 virtual void RemakeLevel (int lev, amrex::Real time, const amrex::BoxArray& ba,
275 const amrex::DistributionMapping& dm) override;
276
277 /** \brief Delete level data
278 * Overrides the pure virtual function in AmrCore
279 */
280 virtual void ClearLevel (int lev) override;
281
282 /** \brief Make a new level from scratch using provided BoxArray and DistributionMapping.
283 * Only used during initialization.
284 * Overrides the pure virtual function in AmrCore
285 */
286 virtual void MakeNewLevelFromScratch (int lev, amrex::Real time, const amrex::BoxArray& ba,
287 const amrex::DistributionMapping& dm) override;
288
289 /** \brief Set pm and pn arrays and x/y coords on level lev */
290 void set_grid_scale (int lev);
291
292 /** \brief Set x/y coords on level lev based on pm and pn */
293 void set_grid_coords_from_grid_scale (int lev);
294
295 /** \brief Set curvilinear derivative terms on level lev based on pm and pn */
296 void set_curvilinear_terms_from_grid_scale (int lev);
297
298 /** \brief Set pm/pn by averaging down from higher-resolution grid */
299 void set_grid_vars_averaged_down (int lev);
300
301 /** \brief Set zeta components to be equal to time-averaged Zt_avg1 */
302 void set_zeta_to_Ztavg (int lev, bool apply_eminusp=true);
303
304 /** \brief Calculate u-, v-, and psi-point masks based on rho-point masks after analytic initialization */
305 void calculate_nodal_masks (int lev);
306
307 /** \brief Copy maskr to all z levels */
308 void fill_3d_masks (int lev);
309
310 /** \brief Set psi-point mask to be consistent with rho-point mask */
311 void update_mskp (int lev);
312
313 /** \brief compute dt from CFL considerations */
314 amrex::Real estTimeStep (int lev) const;
315
316 /** \brief Interface for advancing the data at one level by one "slow" timestep */
317 void remora_advance(int level,
318 amrex::MultiFab& cons_old, amrex::MultiFab& cons_new,
319 amrex::MultiFab& xvel_old, amrex::MultiFab& yvel_old, amrex::MultiFab& zvel_old,
320 amrex::MultiFab& xvel_new, amrex::MultiFab& yvel_new, amrex::MultiFab& zvel_new,
321 amrex::MultiFab& source,
322 const amrex::Geometry fine_geom,
323 const amrex::Real dt, const amrex::Real time);
324
325 /** \brief Make mask to zero out covered cells (for mesh refinement) */
326 amrex::MultiFab& build_fine_mask(int lev);
327
328 /** \brief main driver for writing AMReX plotfiles */
329 void WritePlotFile (int istep);
330
331 /** \brief write out particular data to an AMReX plotfile */
332 void WriteMultiLevelPlotfileWithBathymetry (const std::string &plotfilename,
333 int nlevels,
334 const amrex::Vector<const amrex::MultiFab*> &mf,
335 const amrex::Vector<const amrex::MultiFab*> &mf_nd,
336 const amrex::Vector<const amrex::MultiFab*> &mf_u,
337 const amrex::Vector<const amrex::MultiFab*> &mf_v,
338 const amrex::Vector<const amrex::MultiFab*> &mf_w,
339 const amrex::Vector<const amrex::MultiFab*> &mf_2d_rho,
340 const amrex::Vector<const amrex::MultiFab*> &mf_2d_u,
341 const amrex::Vector<const amrex::MultiFab*> &mf_2d_v,
342 const amrex::Vector<std::string> &varnames_3d,
343 const amrex::Vector<std::string> &varnames_2d_rho,
344 const amrex::Vector<std::string> &varnames_2d_u,
345 const amrex::Vector<std::string> &varnames_2d_v,
346 const amrex::Vector<amrex::Geometry>& my_geom,
347 amrex::Real time,
348 const amrex::Vector<int> &level_steps,
349 const amrex::Vector<amrex::IntVect>& rr,
350 const std::string &versionName = "HyperCLaw-V1.1",
351 const std::string &levelPrefix = "Level_",
352 const std::string &mfPrefix = "Cell",
353 const amrex::Vector<std::string>& extra_dirs = amrex::Vector<std::string>()) const;
354
355
356
357 /** \brief write out header data for an AMReX plotfile */
358 void WriteGenericPlotfileHeaderWithBathymetry (std::ostream &HeaderFile,
359 int nlevels,
360 const amrex::Vector<amrex::BoxArray> &bArray,
361 const amrex::Vector<std::string> &varnames_3d,
362 const amrex::Vector<std::string> &varnames_2d_rho,
363 const amrex::Vector<std::string> &varnames_2d_u,
364 const amrex::Vector<std::string> &varnames_2d_v,
365 const amrex::Vector<amrex::Geometry>& my_geom,
366 amrex::Real time,
367 const amrex::Vector<int> &level_steps,
368 const amrex::Vector<amrex::IntVect>& rr,
369 const std::string &versionName,
370 const std::string &levelPrefix,
371 const std::string &mfPrefix) const;
372
373 /** \brief default prefix for input file parameters */
374 std::string pp_prefix {"remora"};
375
376 /** \brief multilevel data container for last step's scalar data: temperature, salinity, passive tracer */
377 amrex::Vector<amrex::MultiFab*> cons_old;
378 /** \brief multilevel data container for last step's x velocities (u in ROMS) */
379 amrex::Vector<amrex::MultiFab*> xvel_old;
380 /** \brief multilevel data container for last step's y velocities (v in ROMS) */
381 amrex::Vector<amrex::MultiFab*> yvel_old;
382 /** \brief multilevel data container for last step's z velocities (largely unused; W stored separately) */
383 amrex::Vector<amrex::MultiFab*> zvel_old;
384
385 /** \brief multilevel data container for current step's scalar data: temperature, salinity, passive tracer */
386 amrex::Vector<amrex::MultiFab*> cons_new;
387 /** \brief multilevel data container for current step's x velocities (u in ROMS) */
388 amrex::Vector<amrex::MultiFab*> xvel_new;
389 /** \brief multilevel data container for current step's y velocities (v in ROMS) */
390 amrex::Vector<amrex::MultiFab*> yvel_new;
391 /** \brief multilevel data container for current step's z velocities (largely unused; W stored separately) */
392 amrex::Vector<amrex::MultiFab*> zvel_new;
393
394 /** \brief multilevel data container for high res initial data: temperature, salinity, passive tracer */
395 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_cons_full_domain;
396 /** \brief multilevel data container for high res initial x velocities (u in ROMS) */
397 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_xvel_full_domain;
398 /** \brief multilevel data container for high res initial y velocities (v in ROMS) */
399 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_yvel_full_domain;
400 /** \brief multilevel data container for current step's z velocities (largely unused; W stored separately) */
401
402 // Program state data is represented by vectors of pointers to AMReX Multifabs.
403 // There is one pointer per level
404
405 /** \brief Bathymetry data (2D, positive valued, h in ROMS) **/
406 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_h;
407
408 /** \brief Bathymetry data on the whole domain at each potential level **/
409 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_h_full_domain;
410
411 /** \brief Width of cells in the vertical (z-) direction (3D, Hz in ROMS) */
412 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_Hz;
413 /** \brief u-volume flux (3D) */
414 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_Huon;
415 /** \brief v-volume flux (3D) */
416 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_Hvom;
417 /** \brief u velocity RHS (3D, includes horizontal and vertical advection) */
418 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_ru;
419 /** \brief v velocity RHS (3D, includes horizontal and vertical advection) */
420 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_rv;
421 /** \brief u velocity RHS (2D, includes horizontal and vertical advection) */
422 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_ru2d;
423 /** \brief v velocity RHS (2D, includes horizontal and vertical advection) */
424 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_rv2d;
425 /** \brief u velocity RHS, integrated, including advection and bottom/surface stresses (2D) */
426 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_rufrc;
427 /** \brief v velocity RHS, integrated, including advection and bottom/surface stresses (2D) */
428 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_rvfrc;
429 /** \brief Vertical viscosity coefficient (3D) */
430 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_Akv;
431 /** \brief Vertical diffusion coefficient (3D) */
432 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_Akt;
433 /** \brief Harmonic viscosity defined on the psi points (corners of horizontal grid cells) */
434 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_visc2_p;
435 /** \brief Harmonic viscosity defined on the rho points (centers) */
436 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_visc2_r;
437 /** \brief Harmonic diffusivity for temperature / salinity */
438 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_diff2;
439
440 /** \brief z coordinates at rho points (cell centers) */
441 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_z_r;
442
443 /** \brief z coordinates at w points (faces between z-cells) */
444 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_z_w;
445 /** \brief Scaled vertical coordinate (range [0,1]) that transforms to z, defined at rho points (cell centers) */
446 amrex::Gpu::DeviceVector<amrex::Real> s_r;
447 /** \brief Scaled vertical coordinate (range [0,1]) that transforms to z, defined at w-points (cell faces) */
448 amrex::Gpu::DeviceVector<amrex::Real> s_w;
449
450 //amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_s_r;
451 //amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_s_w;
452 //amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_Cs_r;
453 //amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_Cs_w;
454
455 /** \brief Stretching coefficients at rho points */
456 amrex::Gpu::DeviceVector<amrex::Real> Cs_r;
457 /** \brief Stretching coefficients at w points */
458 amrex::Gpu::DeviceVector<amrex::Real> Cs_w;
459
460 /** \brief z coordinates at psi points (cell nodes) **/
461 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_z_phys_nd;
462
463 /** \brief Average of the free surface, zeta (2D) */
464 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_Zt_avg1;
465
466 /** \brief Surface stress in the u direction */
467 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_sustr;
468 /** \brief Surface stress in the v direction */
469 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_svstr;
470
471 /** \brief Wind in the u direction, defined at rho-points */
472 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_uwind;
473 /** \brief Wind in the v direction, defined at rho-points */
474 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_vwind;
475 /** \brief Air temperature [°C], defined at rho-points */
476 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_Tair;
477 /** \brief Specific humidity [kg/kg], defined at rho-points */
478 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_qair;
479 /** \brief Air pressure [mb], defined at rho-points */
480 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_Pair;
481
482 /** \brief Shortwave radiation flux [W/m²], defined at rho-points */
483 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_srflx;
484 /** \brief longwave radiation */
485 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_lrflx;
486 /** \brief Downward longwave radiation */
487 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_longwave_down;
488 /** \brief latent heat flux */
489 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_lhflx;
490 /** \brief sensible heat flux */
491 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_shflx;
492
493 /** \brief Surface tracer flux; working arrays */
494 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_stflx;
495 /** \brief Surface tracer flux; input arrays */
496 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_stflux;
497 /** \brief Bottom tracer flux; working arrays */
498 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_btflx;
499 /** \brief Bottom tracer flux; input arrays */
500 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_btflux;
501
502 /** \brief precipitation rate [kg/m^2/s] */
503 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_rain;
504 /** \brief evaporation rate [kg/m^2/s] */
505 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_evap;
506 /** \brief cloud cover fraction [0-1], defined at rho-points */
507 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_cloud;
508 /** \brief evaporation minus precipitation [kg/m^2/s], defined at rho-points */
509 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_EminusP;
510
511 /** \brief provenance flags for driver-supplied atmospheric forcing lanes */
512 std::array<bool, AtmosState::NumTypes> driver_atmos_state_from_driver {};
513 /** \brief True once REMORA has received forcing through the coupling driver. */
514 bool running_with_coupling_driver = false;
515 /** \brief Driver-level direction flag copied in before InitData. */
516 bool driver_uses_two_way_coupling = false;
517 /** \brief Active atmosphere-to-ocean forcing contract on the most recent driver apply. */
518 DriverAtmosForcingMode driver_atmos_forcing_mode = DriverAtmosForcingMode::State;
519
520 /** \brief Linear drag coefficient [m/s], defined at rho points */
521 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_rdrag;
522 /** \brief Quadratic drag coefficient [unitless], defined at rho points */
523 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_rdrag2;
524 /** \brief Bottom roughness length [m], defined at rho points */
525 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_ZoBot;
526
527 /** \brief Bottom stress in the u direction */
528 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_bustr;
529 /** \brief Bottom stress in the v direction */
530 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_bvstr;
531
532 /** \brief time average of barotropic x velocity flux (2D) */
533 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_DU_avg1;
534 /** \brief correct time average of barotropic x velocity flux for coupling (2D) */
535 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_DU_avg2;
536 /** \brief time average of barotropic y velocity flux */
537 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_DV_avg1;
538 /** \brief correct time average of barotropic y velocity flux for coupling (2D) */
539 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_DV_avg2;
540 /** \brief barotropic x velocity for the RHS (2D) */
541 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_rubar;
542 /** \brief barotropic y velocity for the RHS (2D) */
543 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_rvbar;
544 /** \brief free surface height for the RHS (2D) */
545 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_rzeta;
546 /** \brief barotropic x velocity (2D) */
547 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_ubar;
548 /** \brief barotropic y velocity (2D) */
549 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_vbar;
550 /** \brief free surface height (2D) */
551 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_zeta;
552
553 /** \brief high resolution initial free surface height (2D) */
554 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_zeta_full_domain;
555
556 /** \brief land/sea mask at cell centers (2D) */
557 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_mskr;
558 /** \brief land/sea mask at x-faces (2D) */
559 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_msku;
560 /** \brief land/sea mask at y-faces (2D) */
561 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_mskv;
562 /** \brief land/sea mask at cell corners (2D) */
563 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_mskp;
564 /** \brief land/sea mask at cell centers, copied to all z levels (3D) */
565 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_mskr3d;
566
567 /** \brief horizontal scaling factor: 1 / dx (2D) */
568 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_pm;
569 /** \brief horizontal scaling factor: 1 / dy (2D) */
570 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_pn;
571 /** \brief horizontal scaling factor: 1 / dx (2D) on whole domain */
572 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_pm_full_domain;
573 /** \brief horizontal scaling factor: 1 / dy (2D) on whole domain */
574 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_pn_full_domain;
575
576 /** \brief coriolis factor (2D) */
577 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_fcor;
578
579 /** \brief x_grid on rho points (2D) */
580 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_xr;
581 /** \brief y_grid on rho points (2D) */
582 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_yr;
583
584 /** \brief x_grid on u-points (2D) */
585 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_xu;
586 /** \brief y_grid on u-points (2D) */
587 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_yu;
588
589 /** \brief x_grid on v-points (2D) */
590 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_xv;
591 /** \brief y_grid on v-points (2D) */
592 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_yv;
593
594 /** \brief x_grid on psi-points (2D) */
595 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_xp;
596 /** \brief y_grid on psi-points (2D) */
597 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_yp;
598
599 /** \brief longitude on psi-points (2D, degrees east); only filled when the
600 * grid NetCDF file carries lon_psi */
601 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_lonp;
602 /** \brief latitude on psi-points (2D, degrees north); only filled when the
603 * grid NetCDF file carries lat_psi */
604 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_latp;
605
606 /** \brief d(1/n)/d(xi) */
607 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_dndx;
608 /** \brief d(1/m)/d(eta) */
609 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_dmde;
610
611 /** \brief additional scratch space for calculations on temp, salt, etc */
612 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_sstore;
613
614 /** \brief density perturbation */
615 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_rhoS;
616 /** \brief vertically-averaged density */
617 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_rhoA;
618 /** \brief Brunt-Vaisala frequency (3D) */
619 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_bvf;
620 /** \brief Thermal expansion coefficient (3D) */
621 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_alpha;
622 /** \brief Saline contraction coefficient (3D) */
623 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_beta;
624
625 /** \brief Weights for calculating avg1 in 2D advance */
626 amrex::Vector<amrex::Real> vec_weight1;
627 /** \brief Weights for calculating avg2 in 2D advance */
628 amrex::Vector<amrex::Real> vec_weight2;
629
630 // GLS
631 /** \brief Turbulent kinetic energy */
632 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_tke;
633 /** \brief Turbulent generic length scale */
634 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_gls;
635 /** \brief Vertical mixing turbulent length scale */
636 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_Lscale;
637 /** \brief Turbulent kinetic energy vertical diffusion coefficient */
638 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_Akk;
639 /** \brief Turbulent length scale vertical diffusion coefficient */
640 amrex::Vector<std::unique_ptr<amrex::MultiFab>> vec_Akp;
641
642 /** \brief Climatology nudging coefficients */
643 amrex::Vector<amrex::Vector<std::unique_ptr<amrex::MultiFab>>> vec_nudg_coeff;
644
645 /** \brief advance a single level for a single time step */
646 void Advance (int lev, amrex::Real time, amrex::Real dt_lev, int iteration, int ncycle);
647
648 /** \brief Set everything up for a step on a level */
649 void setup_step(int lev, amrex::Real time, amrex::Real dt_lev);
650
651 /** \brief 3D advance on a single level */
652 void advance_3d_ml (int lev, amrex::Real dt_lev);
653
654 /** \brief 2D advance, one predictor/corrector step */
655 void advance_2d_onestep (int lev, amrex::Real dt_lev, amrex::Real dtfast_lev, int my_iif, int nfast_counter);
656
657 /** \brief Perform a 2D predictor (predictor_2d_step=True) or corrector (predictor_2d_step=False) step */
658 void advance_2d (int lev,
659 amrex::MultiFab const* mf_rhoS,
660 amrex::MultiFab const* mf_rhoA,
661 amrex::MultiFab * mf_ru2d,
662 amrex::MultiFab * mf_rv2d,
663 amrex::MultiFab * mf_rufrc,
664 amrex::MultiFab * mf_rvfrc,
665 amrex::MultiFab * mf_Zt_avg1,
666 std::unique_ptr<amrex::MultiFab>& mf_DU_avg1,
667 std::unique_ptr<amrex::MultiFab>& mf_DU_avg2,
668 std::unique_ptr<amrex::MultiFab>& mf_DV_avg1,
669 std::unique_ptr<amrex::MultiFab>& mf_DV_avg2,
670 std::unique_ptr<amrex::MultiFab>& mf_rubar,
671 std::unique_ptr<amrex::MultiFab>& mf_rvbar,
672 std::unique_ptr<amrex::MultiFab>& mf_rzeta,
673 std::unique_ptr<amrex::MultiFab>& mf_ubar,
674 std::unique_ptr<amrex::MultiFab>& mf_vbar,
675 amrex::MultiFab * mf_zeta,
676 amrex::MultiFab const* mf_h,
677 amrex::MultiFab const* mf_pm,
678 amrex::MultiFab const* mf_pn,
679 amrex::MultiFab const* mf_fcor,
680 amrex::MultiFab const* mf_visc2_p,
681 amrex::MultiFab const* mf_visc2_r,
682 amrex::MultiFab const* mf_mskr,
683 amrex::MultiFab const* mf_msku,
684 amrex::MultiFab const* mf_mskv,
685 amrex::MultiFab const* mf_mskp,
686 amrex::Real dtfast_lev,
687 bool predictor_2d_step,
688 bool first_2d_step, int my_iif,
689 int & next_indx1);
690
691 /** \brief Advance the 3D variables */
692 void advance_3d (int lev,
693 amrex::MultiFab& mf_cons,
694 amrex::MultiFab& mf_u , amrex::MultiFab& mf_v,
695 amrex::MultiFab* mf_sstore,
696 amrex::MultiFab* mf_ru , amrex::MultiFab* mf_rv,
697 std::unique_ptr<amrex::MultiFab>& mf_DU_avg1,
698 std::unique_ptr<amrex::MultiFab>& mf_DU_avg2,
699 std::unique_ptr<amrex::MultiFab>& mf_DV_avg1,
700 std::unique_ptr<amrex::MultiFab>& mf_DV_avg2,
701 std::unique_ptr<amrex::MultiFab>& mf_ubar,
702 std::unique_ptr<amrex::MultiFab>& mf_vbar,
703 std::unique_ptr<amrex::MultiFab>& mf_Akv,
704 std::unique_ptr<amrex::MultiFab>& mf_Akt,
705 std::unique_ptr<amrex::MultiFab>& mf_Hz,
706 std::unique_ptr<amrex::MultiFab>& mf_Huon,
707 std::unique_ptr<amrex::MultiFab>& mf_Hvom,
708 std::unique_ptr<amrex::MultiFab>& mf_z_w,
709 amrex::MultiFab const* mf_h,
710 amrex::MultiFab const* mf_pm,
711 amrex::MultiFab const* mf_pn,
712 amrex::MultiFab const* mf_mskr,
713 amrex::MultiFab const* mf_msku,
714 amrex::MultiFab const* mf_mskv,
715 const int N,
716 const amrex::Real dt_lev);
717
718 /** \brief Apply biological tracer source/sink terms */
719 void advance_biology (int lev, amrex::MultiFab const& mf_cons_old,
720 amrex::MultiFab& mf_cons_new,
721 int N, amrex::Real dt_lev);
722
723#ifdef REMORA_USE_FENNEL_FORT
724 /** \brief Path A oracle: apply biological source/sink terms through the
725 * ROMS Fennel Fortran kernel. Selected at run time by
726 * remora.use_biology_cpp_answer = 0. */
727 void advance_biology_fortran (int lev, amrex::MultiFab const& mf_cons_old,
728 amrex::MultiFab& mf_cons_new,
729 int N, amrex::Real dt_lev);
730#endif
731
732 /** \brief Calculate bulk temperature, salinity, wind fluxes */
733 void bulk_fluxes (int lev,
734 amrex::MultiFab* mf_cons,
735 amrex::MultiFab* mf_uwind,
736 amrex::MultiFab* mf_vwind,
737 amrex::MultiFab* mf_Tair,
738 amrex::MultiFab* mf_qair,
739 amrex::MultiFab* mf_Pair,
740 amrex::MultiFab* mf_srflx,
741 amrex::MultiFab* mf_longwave_down,
742 amrex::MultiFab* mf_evap,
743 amrex::MultiFab* mf_sustr,
744 amrex::MultiFab* mf_svstr,
745 amrex::MultiFab* mf_stflux,
746 amrex::MultiFab* mf_lrflx,
747 amrex::MultiFab* mf_lhflx,
748 amrex::MultiFab* mf_shflx,
749 const int N);
750
751 /** \brief Wrapper function for prestep */
752 void prestep (int lev,
753 amrex::MultiFab& mf_uold, amrex::MultiFab& mf_vold,
754 amrex::MultiFab& mf_u, amrex::MultiFab& mf_v,
755 amrex::MultiFab* mf_ru,
756 amrex::MultiFab* mf_rv,
757 amrex::MultiFab& S_old,
758 amrex::MultiFab& S_new,
759 amrex::MultiFab& mf_W, amrex::MultiFab& mf_DC,
760 /* MF mf_FC? */
761 const amrex::MultiFab* mf_z_r,
762 const amrex::MultiFab* mf_z_w,
763 const amrex::MultiFab* mf_h,
764 const amrex::MultiFab* mf_pm,
765 const amrex::MultiFab* mf_pn,
766 const amrex::MultiFab* mf_sustr,
767 const amrex::MultiFab* mf_svstr,
768 const amrex::MultiFab* mf_bustr,
769 const amrex::MultiFab* mf_bvstr,
770 const amrex::MultiFab* mf_msku,
771 const amrex::MultiFab* mf_mskv,
772 const int iic, const int nfirst,
773 const int nnew, int nstp, int nrhs,
774 int N, const amrex::Real dt_lev);
775
776 /** \brief Prestep advection calculations for the tracers */
777 void prestep_t_advection (int lev, const amrex::Box& tbx,
778 const amrex::Box& gbx,
779 const amrex::Array4<amrex::Real >& tempold,
780 const amrex::Array4<amrex::Real >& tempcache,
781 const amrex::Array4<amrex::Real >& Hz,
782 const amrex::Array4<amrex::Real >& Huon,
783 const amrex::Array4<amrex::Real >& Hvom,
784 const amrex::Array4<amrex::Real >& W,
785 const amrex::Array4<amrex::Real >& DC,
786 const amrex::Array4<amrex::Real >& FC,
787 const amrex::Array4<amrex::Real >& sstore,
788 const amrex::Array4<amrex::Real const>& z_w,
789 const amrex::Array4<amrex::Real const>& h,
790 const amrex::Array4<amrex::Real const>& pm,
791 const amrex::Array4<amrex::Real const>& pn,
792 const amrex::Array4<amrex::Real const>& msku,
793 const amrex::Array4<amrex::Real const>& mskv,
794 const amrex::Array4<int const>& river_pos,
795 const amrex::Array4<amrex::Real const>& river_source,
796 int iic, int ntfirst, int nrhs, int N,
797 const amrex::Real dt_lev);
798
799 /** \brief RHS terms for tracer */
800 void rhs_t_3d (int lev,
801 const amrex::Box& bx,
802 const amrex::Array4<amrex::Real >& t,
803 const amrex::Array4<amrex::Real const>& tempstore,
804 const amrex::Array4<amrex::Real const>& Huon,
805 const amrex::Array4<amrex::Real const>& Hvom,
806 const amrex::Array4<amrex::Real const>& Hz,
807 const amrex::Array4<amrex::Real const>& pn,
808 const amrex::Array4<amrex::Real const>& pm,
809 const amrex::Array4<amrex::Real const>& W,
810 const amrex::Array4<amrex::Real >& FC,
811 const amrex::Array4<amrex::Real const>& mskr,
812 const amrex::Array4<amrex::Real const>& msku,
813 const amrex::Array4<amrex::Real const>& mskv,
814 const amrex::Array4<int const>& river_pos,
815 const amrex::Array4<amrex::Real const>& river_source,
816 int nrhs, int nnew, int N, const amrex::Real dt_lev);
817
818 /** \brief RHS terms for 3D momentum */
819 void rhs_uv_3d (int lev,
820 const amrex::Box& xbx,
821 const amrex::Box& ybx,
822 const amrex::Array4<amrex::Real const>& uold,
823 const amrex::Array4<amrex::Real const>& vold,
824 const amrex::Array4<amrex::Real >& ru,
825 const amrex::Array4<amrex::Real >& rv,
826 const amrex::Array4<amrex::Real >& rufrc,
827 const amrex::Array4<amrex::Real >& rvfrc,
828 const amrex::Array4<amrex::Real const>& sustr,
829 const amrex::Array4<amrex::Real const>& svstr,
830 const amrex::Array4<amrex::Real const>& bustr,
831 const amrex::Array4<amrex::Real const>& bvstr,
832 const amrex::Array4<amrex::Real const>& Huon,
833 const amrex::Array4<amrex::Real const>& Hvom,
834 const amrex::Array4<amrex::Real const>& pm,
835 const amrex::Array4<amrex::Real const>& pn,
836 const amrex::Array4<amrex::Real const>& W,
837 const amrex::Array4<amrex::Real >& FC,
838 int nrhs, int N);
839
840 /** \brief RHS terms for 2D momentum */
841 void rhs_uv_2d (int lev,
842 const amrex::Box& xbx,
843 const amrex::Box& ybx,
844 const amrex::Array4<amrex::Real const>& uold,
845 const amrex::Array4<amrex::Real const>& vold,
846 const amrex::Array4<amrex::Real >& ru,
847 const amrex::Array4<amrex::Real >& rv,
848 const amrex::Array4<amrex::Real const>& Duon,
849 const amrex::Array4<amrex::Real const>& Dvom,
850 const int nrhs);
851
852 /** \brief Wrapper around equation of state calculation */
853 void rho_eos (const amrex::Box& bx,
854 const amrex::Array4<amrex::Real const>& state,
855 const amrex::Array4<amrex::Real >& rho,
856 const amrex::Array4<amrex::Real >& rhoA,
857 const amrex::Array4<amrex::Real >& rhoS,
858 const amrex::Array4<amrex::Real >& bvf,
859 const amrex::Array4<amrex::Real >& alpha,
860 const amrex::Array4<amrex::Real >& beta,
861 const amrex::Array4<amrex::Real const>& Hz,
862 const amrex::Array4<amrex::Real const>& z_w,
863 const amrex::Array4<amrex::Real const>& z_r,
864 const amrex::Array4<amrex::Real const>& h,
865 const amrex::Array4<amrex::Real const>& mskr,
866 const int N);
867
868 /** \brief Calculate density and related quantities from linear equation of state */
869 void lin_eos (const amrex::Box& bx,
870 const amrex::Array4<amrex::Real const>& state,
871 const amrex::Array4<amrex::Real >& rho,
872 const amrex::Array4<amrex::Real >& rhoA,
873 const amrex::Array4<amrex::Real >& rhoS,
874 const amrex::Array4<amrex::Real >& bvf,
875 const amrex::Array4<amrex::Real const>& Hz,
876 const amrex::Array4<amrex::Real const>& z_w,
877 const amrex::Array4<amrex::Real const>& z_r,
878 const amrex::Array4<amrex::Real const>& h,
879 const amrex::Array4<amrex::Real const>& mskr,
880 const int N);
881
882 /** \brief Calculate density and related quantities from nonlinear equation of state */
883 void nonlin_eos (const amrex::Box& bx,
884 const amrex::Array4<amrex::Real const>& state,
885 const amrex::Array4<amrex::Real >& rho,
886 const amrex::Array4<amrex::Real >& rhoA,
887 const amrex::Array4<amrex::Real >& rhoS,
888 const amrex::Array4<amrex::Real >& bvf,
889 const amrex::Array4<amrex::Real >& alpha,
890 const amrex::Array4<amrex::Real >& beta,
891 const amrex::Array4<amrex::Real const>& Hz,
892 const amrex::Array4<amrex::Real const>& z_w,
893 const amrex::Array4<amrex::Real const>& z_r,
894 const amrex::Array4<amrex::Real const>& h,
895 const amrex::Array4<amrex::Real const>& mskr,
896 const int N);
897
898 /** \brief Calculate pressure gradient */
899 void prsgrd (const amrex::Box& bx,
900 const amrex::Box& gbx,
901 const amrex::Box& utbx,
902 const amrex::Box& vtbx,
903 const amrex::Array4<amrex::Real >& ru,
904 const amrex::Array4<amrex::Real >& rv,
905 const amrex::Array4<amrex::Real const>& pn,
906 const amrex::Array4<amrex::Real const>& pm,
907 const amrex::Array4<amrex::Real const>& rho,
908 const amrex::Array4<amrex::Real >& FC,
909 const amrex::Array4<amrex::Real const>& Hz,
910 const amrex::Array4<amrex::Real const>& z_r,
911 const amrex::Array4<amrex::Real const>& z_w,
912 const amrex::Array4<amrex::Real const>& msku,
913 const amrex::Array4<amrex::Real const>& mskv,
914 const int nrhs, const int N);
915
916 /** \brief Update velocities or tracers with diffusion/viscosity
917 * as the last part of the prestep */
918 void prestep_diffusion (const amrex::Box& bx,
919 const amrex::Box& gbx,
920 const int ioff, const int joff,
921 const amrex::Array4<amrex::Real >& vel,
922 const amrex::Array4<amrex::Real const>& vel_old,
923 const amrex::Array4<amrex::Real >& rvel,
924 const amrex::Array4<amrex::Real const>& Hz,
925 const amrex::Array4<amrex::Real const>& Akv,
926 const amrex::Array4<amrex::Real >& FC,
927 const amrex::Array4<amrex::Real const>& sstr,
928 const amrex::Array4<amrex::Real const>& bstr,
929 const amrex::Array4<amrex::Real const>& z_r,
930 const amrex::Array4<amrex::Real const>& pm,
931 const amrex::Array4<amrex::Real const>& pn,
932 const int iic, const int ntfirst, const int nnew, int nstp, int nrhs, int N,
933 const amrex::Real lambda, const amrex::Real dt_lev);
934
935 /** \brief Calculate effects of vertical viscosity or diffusivity */
936 void vert_visc_3d (const amrex::Box& bx,
937 const int ioff, const int joff,
938 const amrex::Array4<amrex::Real >& phi,
939 const amrex::Array4<amrex::Real const>& Hz,
940 const amrex::Array4<amrex::Real >& Hzk,
941 const amrex::Array4<amrex::Real >& AK,
942 const amrex::Array4<amrex::Real const>& Akv,
943 const amrex::Array4<amrex::Real >& BC,
944 const amrex::Array4<amrex::Real >& DC,
945 const amrex::Array4<amrex::Real >& FC,
946 const amrex::Array4<amrex::Real >& CF,
947 const int nnew, const int N,
948 const amrex::Real dt_lev);
949
950 /** \brief Correct mass flux */
951 void update_massflux_3d (int lev, const amrex::Box& bx,
952 const int ioff, const int joff,
953 const amrex::Array4<amrex::Real >& phi,
954 const amrex::Array4<amrex::Real >& phibar,
955 const amrex::Array4<amrex::Real >& Hphi,
956 const amrex::Array4<amrex::Real const>& Hz,
957 const amrex::Array4<amrex::Real const>& pm_or_pn,
958 const amrex::Array4<amrex::Real const>& Dphi1,
959 const amrex::Array4<amrex::Real const>& Dphi2,
960 const amrex::Array4<amrex::Real >& DC,
961 const amrex::Array4<amrex::Real >& FC,
962 const amrex::Array4<amrex::Real const>& msk,
963 const int nnew);
964
965 /** \brief Adjust 3D momentum variables based on vertical mean momentum */
966 void vert_mean_3d (const amrex::Box& bx,
967 const int ioff, const int joff,
968 const amrex::Array4<amrex::Real >& phi,
969 const amrex::Array4<amrex::Real const>& Hz,
970 const amrex::Array4<amrex::Real const>& Dphi_avg1,
971 const amrex::Array4<amrex::Real >& DC,
972 const amrex::Array4<amrex::Real >& CF,
973 const amrex::Array4<amrex::Real const>& pm_or_pn,
974 const amrex::Array4<amrex::Real const>& msk,
975 const int nnew, const int N);
976
977 /** \brief Harmonic viscosity */
978 void uv3dmix (const amrex::Box& xbx,
979 const amrex::Box& ybx,
980 const amrex::Array4<amrex::Real >& u,
981 const amrex::Array4<amrex::Real >& v,
982 const amrex::Array4<amrex::Real const>& uold,
983 const amrex::Array4<amrex::Real const>& vold,
984 const amrex::Array4<amrex::Real >& rufrc,
985 const amrex::Array4<amrex::Real >& rvfrc,
986 const amrex::Array4<amrex::Real const>& visc2_p,
987 const amrex::Array4<amrex::Real const>& visc2_r,
988 const amrex::Array4<amrex::Real const>& Hz,
989 const amrex::Array4<amrex::Real const>& pm,
990 const amrex::Array4<amrex::Real const>& pn,
991 const amrex::Array4<amrex::Real const>& mskp,
992 int nrhs, int nnew,
993 const amrex::Real dt_lev);
994
995 /** \brief Wrapper for harmonic diffusivity for tracers */
996 void t3dmix2 (const amrex::Box& bx,
997 const amrex::Array4<amrex::Real >& state,
998 const amrex::Array4<amrex::Real >& state_rhs,
999 const amrex::Array4<amrex::Real const>& diff2,
1000 const amrex::Array4<amrex::Real const>& Hz,
1001 const amrex::Array4<amrex::Real const>& z_r,
1002 const amrex::Array4<amrex::Real const>& pm,
1003 const amrex::Array4<amrex::Real const>& pn,
1004 const amrex::Array4<amrex::Real const>& msku,
1005 const amrex::Array4<amrex::Real const>& mskv,
1006 const amrex::Real dt_lev,
1007 const int ncomp, const int N);
1008
1009 /** \brief Harmonic diffusivity for tracers along S-coordinate level surfaces */
1010 void t3dmix2_s(const amrex::Box& bx,
1011 const amrex::Array4<amrex::Real >& state,
1012 const amrex::Array4<amrex::Real >& state_rhs,
1013 const amrex::Array4<amrex::Real const>& diff2,
1014 const amrex::Array4<amrex::Real const>& Hz,
1015 const amrex::Array4<amrex::Real const>& pm,
1016 const amrex::Array4<amrex::Real const>& pn,
1017 const amrex::Array4<amrex::Real const>& msku,
1018 const amrex::Array4<amrex::Real const>& mskv,
1019 const amrex::Real dt_lev, const int ncomp);
1020
1021 /** \brief Harmonic diffusivity for tracers along geopotential surfaces */
1022 void t3dmix2_geo (const amrex::Box& bx,
1023 const amrex::Array4<amrex::Real >& state,
1024 const amrex::Array4<amrex::Real >& state_rhs,
1025 const amrex::Array4<amrex::Real const>& diff2,
1026 const amrex::Array4<amrex::Real const>& Hz,
1027 const amrex::Array4<amrex::Real const>& z_r,
1028 const amrex::Array4<amrex::Real const>& pm,
1029 const amrex::Array4<amrex::Real const>& pn,
1030 const amrex::Array4<amrex::Real const>& msku,
1031 const amrex::Array4<amrex::Real const>& mskv,
1032 const amrex::Real dt_lev,
1033 const int ncomp, const int N);
1034
1035 /** \brief Calculate Coriolis terms */
1036 void coriolis (const amrex::Box& xbx,
1037 const amrex::Box& ybx,
1038 const amrex::Array4<amrex::Real const>& uold,
1039 const amrex::Array4<amrex::Real const>& vold,
1040 const amrex::Array4<amrex::Real >& ru,
1041 const amrex::Array4<amrex::Real >& rv,
1042 const amrex::Array4<amrex::Real const>& Hz,
1043 const amrex::Array4<amrex::Real const>& fomn,
1044 int nrhs, int nr);
1045
1046 /** \brief Calculate curvilinear advection terms */
1047 void curvilinear (const amrex::Box& bx,
1048 const amrex::Box& xbx,
1049 const amrex::Box& ybx,
1050 const amrex::Array4<amrex::Real const>& uold,
1051 const amrex::Array4<amrex::Real const>& vold,
1052 const amrex::Array4<amrex::Real >& ru,
1053 const amrex::Array4<amrex::Real >& rv,
1054 const amrex::Array4<amrex::Real const>& Hz,
1055 const amrex::Array4<amrex::Real const>& dndx,
1056 const amrex::Array4<amrex::Real const>& dmde,
1057 int nrhs, int nr);
1058
1059 /** \brief Shrink an x- or y-nodal momentum tilebox to the faces ROMS nudges
1060 *
1061 * ROMS nudges momentum toward climatology over i=IstrU..Iend (j=JstrV..Jend), which
1062 * excludes the u-face on the western and eastern domain edges (v-face on the southern
1063 * and northern edges). This returns the part of \p nodal_bx that survives that
1064 * exclusion. Under EW_PERIODIC (NS_PERIODIC) ROMS sets IstrU=Istr (JstrV=Jstr) and
1065 * nudges every face, so a periodic direction is left alone.
1066 *
1067 * @param[in] nodal_bx box from MFIter::nodaltilebox(dir)
1068 * @param[in] dir direction the box is nodal in (0 for u, 1 for v)
1069 * @param[in] domain cell-centered problem domain at this level
1070 * @param[in] is_periodic whether \p dir is periodic
1071 */
1072 static amrex::Box clim_nudg_momentum_box (const amrex::Box& nodal_bx,
1073 int dir,
1074 const amrex::Box& domain,
1075 bool is_periodic);
1076
1077 /** \brief Apply climatology nudging */
1078 void apply_clim_nudg (const amrex::Box& bx,
1079 int ioff, int joff,
1080 const amrex::Array4<amrex::Real >& var,
1081 const amrex::Array4<amrex::Real const>& var_old,
1082 const amrex::Array4<amrex::Real const>& var_clim,
1083 const amrex::Array4<amrex::Real const>& clim_coeff,
1084 const amrex::Array4<amrex::Real const>& Hz,
1085 const amrex::Array4<amrex::Real const>& pm,
1086 const amrex::Array4<amrex::Real const>& pn,
1087 const amrex::Real dt_lev = zero);
1088
1089 /** \brief Set 2D momentum arrays from 3D momentum */
1090 void set_2darrays (int lev);
1091
1092 /** \brief Set Zt_avg1 to zeta */
1093 void set_zeta_average (int lev);
1094
1095 /** \brief Initialize zeta from file or analytic */
1096 void set_zeta (int lev);
1097
1098 /** \brief Copy over zeta data that has been averaged down from high res */
1099 void set_zeta_averaged_down (int lev);
1100
1101 /** \brief Initialize bathymetry from file or analytic */
1102 void set_bathymetry (int lev);
1103
1104 /** \brief Copy over bathymetry data that has been averaged down from high resolution
1105 * input netcdf file */
1106 void set_bathymetry_averaged_down (int lev);
1107
1108 /** \brief Initialize Coriolis factor from file or analytic */
1109 void set_coriolis (int lev);
1110
1111 /** \brief Initialize land-sea masks from file or analytic */
1112 void set_masks (int lev);
1113
1114 /** \brief Calculate vertical stretched coordinates */
1115 void stretch_transform (int lev);
1116
1117 /** \brief Initialize vertical mixing coefficients from file or analytic */
1118 void init_set_vmix (int lev);
1119 /** \brief Set vertical mixing coefficients from analytic */
1120 void set_analytic_vmix (int lev);
1121 /** \brief Initialize GLS variables */
1122 void init_gls_vmix (int lev, SolverChoice solver_choice);
1123 /** \brief Prestep for GLS calculation */
1124 void gls_prestep (int lev, amrex::MultiFab* mf_gls, amrex::MultiFab* mf_tke,
1125 amrex::MultiFab& mf_W,
1126 amrex::MultiFab* mf_msku, amrex::MultiFab* mf_mskv,
1127 const int nstp, const int nnew, const int iic, const int ntfirst,
1128 const int N, const amrex::Real dt_lev);
1129 /** \brief Corrector step for GLS calculation */
1130 void gls_corrector (int lev, amrex::MultiFab* mf_gls, amrex::MultiFab* mf_tke,
1131 amrex::MultiFab& mf_W, amrex::MultiFab* mf_Akv, amrex::MultiFab* mf_Akt,
1132 amrex::MultiFab* mf_Akk, amrex::MultiFab* mf_Akp,
1133 amrex::MultiFab* mf_mskr,
1134 amrex::MultiFab* mf_msku, amrex::MultiFab* mf_mskv,
1135 const int nstp, const int nnew,
1136 const int N, const amrex::Real dt_lev);
1137
1138 /** \brief Scale RHS momentum variables by 1/cell area, needed before FillPatch to different levels*/
1139 void scale_rhs_vars ();
1140 /** \brief Scale RHS momentum variables by cell area, needed after FillPatch to different levels*/
1141 void scale_rhs_vars_inv ();
1142
1143 /** \brief Initialize or calculate surface momentum flux from file or analytic */
1144 void set_smflux (int lev);
1145
1146 /** \brief Initialize or calculate wind speed and other surface state vars from file or analytic */
1147 void set_surface_state (int lev);
1148
1149 /** \brief Initialize horizontal mixing coefficients */
1150 void set_hmixcoef (int lev);
1151
1152 /** \brief Initialize or calculate bottom drag */
1153 void set_drag (int lev);
1154
1155 /** \brief Set weights for averaging 3D variables to 2D */
1156 void set_weights (int lev);
1157
1158 /** \brief Fill the physical boundary conditions for cell-centered velocity (diagnostic only) */
1159 void FillBdyCCVels (int lev, amrex::MultiFab& mf_cc_vel);
1160
1161 /** \brief Fill a new MultiFab by copying in phi from valid region and filling ghost cells */
1162 void FillPatch (int lev, amrex::Real time,
1163 amrex::MultiFab& mf_to_be_filled,
1164 amrex::Vector<amrex::MultiFab*> const& mfs,
1165 const int bccomp,
1166 const int bdy_var_type = BdyVars::null,
1167 const int icomp=0,
1168 const bool fill_all=true,
1169 const bool fill_set=false,
1170 const int n_not_fill=0,
1171 const int icomp_calc=0,
1172 const amrex::Real dt = zero,
1173 const amrex::MultiFab& mf_calc = amrex::MultiFab());
1174
1175 /** \brief Fill a new MultiFab by copying in phi from valid region and filling ghost cells without applying boundary conditions */
1176 void FillPatchNoBC (int lev, amrex::Real time,
1177 amrex::MultiFab& mf_to_be_filled,
1178 amrex::Vector<amrex::MultiFab*> const& mfs,
1179 const int bdy_var_type = BdyVars::null,
1180 const int icomp=0,
1181 const bool fill_all=true,
1182 const bool fill_set=false);
1183 /** \brief Fill boundary data from netcdf file */
1184 void fill_from_bdyfiles (int lev,
1185 amrex::MultiFab& mf_to_fill,
1186 const amrex::MultiFab& mf_mask,
1187 const amrex::Real time,
1188 const int bccomp,
1189 const int bdy_var_type,
1190 const int icomp_to_fill,
1191 const int icomp_calc = 0,
1192 const amrex::MultiFab& mf_calc = amrex::MultiFab(),
1193 const amrex::Real = zero);
1194
1195 /** \brief fill an entire multifab by interpolating from the coarser level
1196 * using the piecewise constant interpolater */
1197 void FillCoarsePatchPC (int lev, amrex::Real time, amrex::MultiFab* mf_fine,
1198 amrex::MultiFab* mf_crse,
1199 const int bccomp,
1200 const int bdy_var_type = BdyVars::null,
1201 const int icomp = 0,
1202 const bool fill_all = true,
1203 const int n_not_fill=0,
1204 const int icomp_calc=0,
1205 const amrex::Real dt = zero,
1206 const amrex::MultiFab& mf_calc = amrex::MultiFab());
1207
1208 /** \brief fill an entire multifab by interpolating from the coarser level */
1209 void FillCoarsePatch (int lev, amrex::Real time, amrex::MultiFab* mf_fine,
1210 amrex::MultiFab* mf_crse,
1211 const int bccomp,
1212 const int bdy_var_type = BdyVars::null,
1213 const int icomp = 0,
1214 const bool fill_all = true,
1215 const int n_not_fill=0,
1216 const int icomp_calc=0,
1217 const amrex::Real dt = zero,
1218 const amrex::MultiFab& mf_calc = amrex::MultiFab());
1219
1220 /** \brief fill an entire multifab by interpolating from the coarser level,
1221 * explicitly specifying interpolator to use */
1222 void FillCoarsePatchMap (int lev, amrex::Real time, amrex::MultiFab* mf_fine,
1223 amrex::MultiFab* mf_crse,
1224 const int bccomp,
1225 const int bdy_var_type = BdyVars::null,
1226 const int icomp = 0,
1227 const bool fill_all = true,
1228 const int n_not_fill=0,
1229 const int icomp_calc=0,
1230 const amrex::Real dt = zero,
1231 const amrex::MultiFab& mf_calc = amrex::MultiFab(),
1232 amrex::Interpolater* mapper = nullptr);
1233
1234 /** \brief initialize and calculate stretch coefficients */
1235 void init_stretch_coeffs ();
1236 /** \brief calculate vertical stretch coefficients */
1237 void calc_stretch_coeffs ();
1238
1239 /** \brief Calculate Coriolis parameters from beta plane parametrization */
1240 void init_beta_plane_coriolis (int lev);
1241
1242 /** \brief Full domain bathymetry data initialization from analytic */
1243 void init_bathymetry_full_domain_from_analytic ();
1244
1245 /** \brief Problem initialization from averaged-down high resolution data */
1246 void set_init_data_averaged_down (int lev);
1247 /** \brief Problem initialization from NetCDF file */
1248 void init_data_from_netcdf (int lev);
1249 /** \brief Biology initialization from NetCDF file */
1250 void init_biology_from_netcdf (int lev);
1251 /** \brief Passive (dye) scalar initialization from NetCDF file. Called from
1252 * init_data_from_netcdf: dye follows remora.ic_type rather than having
1253 * a source flag of its own. */
1254 void init_scalars_from_netcdf (int lev);
1255
1256 /** \brief Initialize biology tracers from whichever source
1257 * remora.biology_ic_type selects. Call after the physical fields
1258 * exist: the analytic profiles are functions of temperature. */
1259 void init_biology_ic (int lev);
1260
1261 /** \brief Full-domain counterpart of init_biology_ic, for the
1262 * hires_init_level average-down path. */
1263 void init_biology_ic_full_domain ();
1264 /** \brief High resolution roblem initialization from NetCDF file */
1265 void init_data_full_domain_from_netcdf ();
1266 /** \brief Full-domain high-res biology initialization from NetCDF file */
1267 void init_biology_full_domain_from_netcdf ();
1268 /** \brief Full-domain high-res passive (dye) scalar initialization from NetCDF file */
1269 void init_scalars_full_domain_from_netcdf ();
1270 /** \brief Boundary data initialization from NetCDF file */
1271 void init_bdry_from_netcdf (int lev);
1272 /** \brief Mask data initialization from NetCDF file */
1273 void init_masks_from_netcdf (int lev);
1274 /** \brief Bathymetry data initialization from NetCDF file */
1275 void init_bathymetry_from_netcdf (int lev);
1276 /** \brief Full domain high-res bathymetry data initialization from NetCDF file */
1277 void init_bathymetry_full_domain_from_netcdf ();
1278
1279 /** \brief Grid variable initialization from NetCDF file */
1280 void init_grid_vars_from_netcdf (int lev);
1281 /** \brief Full domain high-res grid variable initialization from NetCDF file */
1282 void init_grid_vars_full_domain_from_netcdf ();
1283
1284 /** \brief Extrapolate grid metrics to edge of MultiFab */
1285 void extrapolate_metric_to_physical_boundaries(amrex::MultiFab& mf, const amrex::Geometry& geom);
1286
1287 /** \brief Sea-surface height data initialization from NetCDF file */
1288 void init_zeta_from_netcdf (int lev);
1289 /** \brief Full-domain high res sea-surface height data initialization from NetCDF file */
1290 void init_zeta_full_domain_from_netcdf ();
1291 /** \brief Coriolis parameter data initialization from NetCDF file */
1292 void init_coriolis_from_netcdf (int lev);
1293 /** \brief Climatology nudging coefficient initialization from NetCDF file */
1294 void init_clim_nudg_coeff_from_netcdf (int lev);
1295 /** \brief Wrapper to initialize climatology nudging coefficient */
1296 void init_clim_nudg_coeff (int lev);
1297 void init_riv_pos_from_netcdf (int lev);
1298
1299 /** \brief Allocate multifabs for storing full-domain bathymetry and grid vars data */
1300 void allocate_bathymetry_grid_vars_full_domain ();
1301 /** \brief Allocate multifabs for storing full-domain high resolution initial data */
1302 void allocate_init_full_domain ();
1303
1304 /** \brief Convert data in a multifab from inverse days to inverse seconds */
1305 void convert_inv_days_to_inv_s (amrex::MultiFab*);
1306
1307 /** \brief Mask data arrays before writing output */
1308 void mask_arrays_for_write (int lev, amrex::Real fill_value, amrex::Real fill_where);
1309
1310 /** \brief Average down from level lev+1 to lev in mf, including grow cells */
1311 void average_down_with_grow_cells(int lev, amrex::Vector<std::unique_ptr<amrex::MultiFab>>& mf);
1312
1313 int xvel_bc () const noexcept { return BCVars::xvel_bc(ncons); }
1314 int yvel_bc () const noexcept { return BCVars::yvel_bc(ncons); }
1315 int zvel_bc () const noexcept { return BCVars::zvel_bc(ncons); }
1316 int ubar_bc () const noexcept { return BCVars::ubar_bc(ncons); }
1317 int vbar_bc () const noexcept { return BCVars::vbar_bc(ncons); }
1318 int zeta_bc () const noexcept { return BCVars::zeta_bc(ncons); }
1319 int tke_bc () const noexcept { return BCVars::tke_bc(ncons); }
1320 int foextrap_periodic_bc () const noexcept { return BCVars::foextrap_periodic_bc(ncons); }
1321 int foextrap_bc () const noexcept { return BCVars::foextrap_bc(ncons); }
1322 int u2d_simple_bc () const noexcept { return BCVars::u2d_simple_bc(ncons); }
1323 int v2d_simple_bc () const noexcept { return BCVars::v2d_simple_bc(ncons); }
1324 int num_bc_vars () const noexcept { return BCVars::NumTypes(ncons); }
1325
1326 ///@{
1327 /** \brief Accessors for the ncons-dependent entries of BdyVars */
1328 int bdy_cons (int icomp) const noexcept { return BdyVars::cons(icomp); }
1329 int bdy_ubar () const noexcept { return BdyVars::ubar(ncons); }
1330 int bdy_vbar () const noexcept { return BdyVars::vbar(ncons); }
1331 int bdy_zeta () const noexcept { return BdyVars::zeta(ncons); }
1332 int num_bdy_vars () const noexcept { return BdyVars::NumTypes(ncons); }
1333 ///@}
1334
1335 /** \brief Number of passive (dye) scalars in the state, not counting biology tracers.
1336 *
1337 * Zero means the state has no dye component at all, so Tracer_comp is either the first
1338 * biology tracer or one past the end of cons. Problem setups that initialize a dye have
1339 * to test this rather than nComp(), which cannot tell a dye apart from a biology tracer.
1340 */
1341 int num_passive_scalars () const noexcept { return nscalar; }
1342
1343
1344#ifdef REMORA_USE_NETCDF
1345 static int total_nc_plot_file_step;
1346#endif
1347
1348private:
1349
1350 ///////////////////////////
1351 // private member functions
1352 ///////////////////////////
1353
1354 /** \brief read in some parameters from inputs file */
1355 void ReadParameters();
1356
1357 /** \brief Build runtime scalar names after nscalar is known */
1358 void init_scalar_metadata();
1359
1360 /** \brief set covered coarse cells to be the average of overlying fine cells */
1361 void AverageDown ();
1362
1363 /** \brief Read in boundary parameters from input file and set up data structures */
1364 void init_bcs();
1365
1366 /** \brief Initialize initial problem data from analytic functions */
1367 void init_analytic(int lev);
1368 /** \brief Initialize high resolution initial problem data from analytic functions */
1369 void init_full_domain_from_analytic();
1370
1371 /** \brief Initialize high resolution initial sea surface height from analytic functions */
1372 void init_full_domain_zeta_from_analytic();
1373
1374 /** \brief Allocate MultiFabs for state and evolution variables */
1375 void init_stuff (int lev, const amrex::BoxArray& ba, const amrex::DistributionMapping& dm);
1376
1377 /** \brief Allocate MultiFabs for masks */
1378 void init_masks (int lev, const amrex::BoxArray& ba, const amrex::DistributionMapping& dm);
1379
1380 /** \brief Resize variable containers to accommodate data on levels 0 to max_lev */
1381 void resize_stuff (int lev);
1382
1383 /** \brief more flexible version of AverageDown() that lets you average down across multiple levels */
1384 void AverageDownTo (int crse_lev);
1385
1386 /** \brief Construct FillPatchers */
1387 void Construct_REMORAFillPatchers (int lev);
1388
1389 /** \brief Define FillPatchers */
1390 void Define_REMORAFillPatchers (int lev);
1391
1392 /** \brief utility to copy in data from old and/or new state into another multifab */
1393 TimeInterpolatedData GetDataAtTime (int lev, amrex::Real time);
1394
1395 /** \brief advance a level by dt, includes a recursive call for finer levels */
1396 void timeStep (int lev, amrex::Real time, int iteration);
1397
1398 /** \brief advance all levels by dt, loops over finer levels */
1399 void timeStepML (amrex::Real time, int iteration);
1400
1401 /** \brief a wrapper for estTimeStep() */
1402 void ComputeDt ();
1403
1404 /** \brief get plotfile name */
1405 std::string PlotFileName (int lev) const;
1406
1407 /* set which variables and derived quantities go into plotfiles */
1408 void set2DPlotVariables (const std::string& pp_plot_var_names_2d);
1409 void set3DPlotVariables (const std::string& pp_plot_var_names_3d);
1410
1411 /* append variables to plot */
1412 void append2DPlotVariables (const std::string& pp_plot_var_names_2d);
1413 void append3DPlotVariables (const std::string& pp_plot_var_names_3d);
1414
1415#ifdef REMORA_USE_NETCDF
1416 /** \brief Write plotfile using NetCDF (wrapper) */
1417 void WriteNCPlotFile (int istep, amrex::MultiFab const* plotMF);
1418
1419 /** \brief Write a particular NetCDF plotfile */
1420 void WriteNCPlotFile_which (int lev, int which_subdomain,
1421 amrex::MultiFab const* plotMF,
1422 bool write_header, ncutils::NCFile& ncf,
1423 bool is_history);
1424
1425 /** \brief Write MultiFab in NetCDF format */
1426 void WriteNCMultiFab (const amrex::FabArray<amrex::FArrayBox> &fab,
1427 const std::string& name,
1428 bool set_ghost = false) const;
1429
1430 /** \brief Read MultiFab in NetCDF format */
1431 void ReadNCMultiFab (amrex::FabArray<amrex::FArrayBox> &fab,
1432 const std::string &name,
1433 int coordinatorProc = amrex::ParallelDescriptor::IOProcessorNumber(),
1434 int allow_empty_mf = 0);
1435
1436 /** \brief Start time in the time series of boundary data */
1437 amrex::Real start_bdy_time;
1438 /** \brief Interval between boundary data times */
1439 amrex::Real bdy_time_interval;
1440
1441 /** \brief Whether to output NetCDF files as a single history file with several time steps */
1442 static bool write_history_file;
1443
1444 /** \brief Data container for u-component surface momentum flux read from file */
1445 std::unique_ptr<NCTimeSeries> sustr_data_from_file;
1446 /** \brief Data container for v-component surface momentum flux read from file */
1447 std::unique_ptr<NCTimeSeries> svstr_data_from_file;
1448 /** \brief Data container for u-direction wind read from file */
1449 std::unique_ptr<NCTimeSeries> Uwind_data_from_file;
1450 /** \brief Data container for v-direction wind read from file */
1451 std::unique_ptr<NCTimeSeries> Vwind_data_from_file;
1452 /** \brief Data container for air temperature read from file */
1453 std::unique_ptr<NCTimeSeries> Tair_data_from_file;
1454 /** \brief Data container for specific humidity read from file */
1455 std::unique_ptr<NCTimeSeries> qair_data_from_file;
1456 /** \brief Data container for air pressure read from file */
1457 std::unique_ptr<NCTimeSeries> Pair_data_from_file;
1458 /** \brief Data container for shortwave radiation flux read from file */
1459 std::unique_ptr<NCTimeSeries> srflx_data_from_file;
1460 /** \brief Data container for downward longwave radiation flux read from file */
1461 std::unique_ptr<NCTimeSeries> longwave_down_data_from_file;
1462 /** \brief Data container for precipitation rate read from file */
1463 std::unique_ptr<NCTimeSeries> rain_data_from_file;
1464 /** \brief Data container for cloud cover fraction read from file */
1465 std::unique_ptr<NCTimeSeries> cloud_data_from_file;
1466 /** \brief Data container for evaporation minus precipitation read from file */
1467 std::unique_ptr<NCTimeSeries> EminusP_data_from_file;
1468
1469 /** \brief Data container for ubar climatology data read from file */
1470 std::unique_ptr<NCTimeSeries> ubar_clim_data_from_file;
1471 /** \brief Data container for vbar climatology data read from file */
1472 std::unique_ptr<NCTimeSeries> vbar_clim_data_from_file;
1473 /** \brief Data container for u-velocity climatology data read from file */
1474 std::unique_ptr<NCTimeSeries> u_clim_data_from_file;
1475 /** \brief Data container for v-velocity climatology data read from file */
1476 std::unique_ptr<NCTimeSeries> v_clim_data_from_file;
1477 /** \brief Vector over cons components of climatology data read from file.
1478 *
1479 * Entry icomp is null unless solverChoice.do_cons_clim_nudg[icomp] is set. */
1480 amrex::Vector<std::unique_ptr<NCTimeSeries>> cons_clim_data_from_file;
1481
1482 /** \brief Vector of data containers for scalar data in rivers */
1483 amrex::Vector<std::unique_ptr<NCTimeSeriesRiver>> river_source_cons;
1484 /** \brief Data container for momentum transport in rivers */
1485 std::unique_ptr<NCTimeSeriesRiver> river_source_transport;
1486 /** \brief Data container for vertically integrated momentum transport in rivers */
1487 std::unique_ptr<NCTimeSeriesRiver> river_source_transportbar;
1488
1489 /** \brief Vector over BdyVars of boundary series data containers */
1490 amrex::Vector<amrex::Vector<std::unique_ptr<NCTimeSeriesBoundary>>> boundary_series;
1491
1492#endif // REMORA_USE_NETCDF
1493 /** \brief iMultiFab for river positions; contents are indices of rivers */
1494 amrex::Vector<std::unique_ptr<amrex::iMultiFab>> vec_river_position;
1495 /** \brief Vector over rivers of river direction: 0: u-face; 1: v-face; 2: w-face */
1496 amrex::Gpu::DeviceVector<int> river_direction;
1497
1498
1499#ifdef REMORA_USE_MOAB
1500 /** \brief Initialize connection to MOAB */
1501 void InitMOABMesh();
1502#endif
1503 /** \brief Nudging width at coarse-fine interface */
1504 int cf_width{0};
1505 /** \brief Width for fixing values at coarse-fine interface */
1506 int cf_set_width{0};
1507 // Fillpatcher classes for coarse-fine boundaries
1508 /** \brief Vector over levels of FillPatchers for scalars */
1509 amrex::Vector<REMORAFillPatcher> FPr_c;
1510 /** \brief Vector over levels of FillPatchers for u (3D) */
1511 amrex::Vector<REMORAFillPatcher> FPr_u;
1512 /** \brief Vector over levels of FillPatchers for v (3D) */
1513 amrex::Vector<REMORAFillPatcher> FPr_v;
1514 /** \brief Vector over levels of FillPatchers for w */
1515 amrex::Vector<REMORAFillPatcher> FPr_w;
1516
1517 // Fillpatcher classes for 2d velocity variables
1518 /** \brief Vector over levels of FillPatchers for ubar (2D) */
1519 amrex::Vector<REMORAFillPatcher> FPr_ubar;
1520 /** \brief Vector over levels of FillPatchers for vbar (2D) */
1521 amrex::Vector<REMORAFillPatcher> FPr_vbar;
1522
1523 /** \brief write checkpoint file to disk */
1524 void WriteCheckpointFile ();
1525
1526 /** \brief read checkpoint file from disk */
1527 void ReadCheckpointFile ();
1528
1529 /** \brief Read the file passed to remora.restart and use it as an initial condition for the current simulation */
1530 void InitializeFromFile ();
1531
1532 /** \brief Initialize the new-time data at a level from the initial_data MultiFab */
1533 void InitializeLevelFromData (int lev, const amrex::MultiFab& initial_data);
1534
1535 /** \brief utility to skip to next line in Header */
1536 static void GotoNextLine (std::istream& is);
1537
1538 ////////////////
1539 // private data members
1540
1541 /** \brief Pointer to container of analytical functions for problem definition */
1542 std::unique_ptr<ProblemBase> prob = nullptr;
1543
1544 /** \brief how many boxes specified at each level by tagging criteria */
1545 amrex::Vector<int> num_boxes_at_level;
1546 /** \brief how many netcdf input files specified at each level */
1547 amrex::Vector<int> num_files_at_level;
1548 /** \brief the boxes specified at each level by tagging criteria */
1549 amrex::Vector<amrex::Vector<amrex::Box>> boxes_at_level;
1550
1551 /** \brief which step? */
1552 amrex::Vector<int> istep;
1553 /** \brief How many substeps on each level? */
1554 amrex::Vector<int> nsubsteps;
1555 /** \brief new time at each level */
1556 amrex::Vector<amrex::Real> t_new;
1557 /** \brief old time at each level */
1558 amrex::Vector<amrex::Real> t_old;
1559 /** \brief time step at each level */
1560 amrex::Vector<amrex::Real> dt;
1561
1562 /** \brief whether to set boundary conditions by variable rather than just by side */
1563 bool set_bcs_by_var;
1564
1565 /** \brief Vector (over level) of functors to apply physical boundary conditions */
1566 amrex::Vector<std::unique_ptr<REMORAPhysBCFunct>> physbcs;
1567
1568 /** \brief array of flux registers for refluxing in multilevel */
1569 amrex::Vector<std::unique_ptr<amrex::YAFluxRegister>> advflux_reg;
1570
1571 ////////////////
1572 // boundary data members
1573
1574 // A BCRec is essentially a 2*DIM integer array storing the boundary
1575 // condition type at each lo/hi walls in each direction. We have one BCRec
1576 // for each component of the cell-centered variables and each velocity component.
1577 /** \brief vector (over BCVars) of BCRecs */
1578 amrex::Vector <amrex::BCRec> domain_bcs_type;
1579 /** \brief GPU vector (over BCVars) of BCRecs */
1580 amrex::Gpu::DeviceVector<amrex::BCRec> domain_bcs_type_d;
1581
1582 /** \brief Array of strings describing domain boundary conditions */
1583 amrex::Array<std::string,2*AMREX_SPACEDIM> domain_bc_type;
1584
1585 /** \brief Array holding the Dirichlet values at walls which need them */
1586 amrex::Vector<amrex::GpuArray<amrex::Real, AMREX_SPACEDIM*2>> m_bc_extdir_vals;
1587
1588 /** \brief Array holding the "physical" boundary condition types (e.g. "inflow") */
1589 amrex::Vector<amrex::GpuArray<REMORA_BC, AMREX_SPACEDIM*2>> phys_bc_type;
1590
1591 /** \brief These are flags that indicate whether we need to read in boundary data from file.
1592 *
1593 * Sized num_bdy_vars()+1; the extra trailing slot is a scratch entry that variables with
1594 * no NetCDF boundary lane (see bdy_index) write into and nothing reads.
1595 */
1596 amrex::Vector<amrex::GpuArray<bool, AMREX_SPACEDIM*2>> phys_bc_need_data;
1597
1598 /** \brief Container to connect boundary data being read in boundary condition containers.
1599 *
1600 * Needed for phys_bc_need_data to work correctly
1601 */
1602 amrex::Vector<int> bdy_index;
1603
1604 /** \brief Step when we last output a plotfile */
1605 int last_plot_file_step;
1606 /** \brief Simulation time when we last output a plotfile */
1607 amrex::Real last_plot_file_time;
1608
1609 /** \brief Step when we last output a checkpoint file */
1610 int last_check_file_step;
1611 /** \brief Simulation time when we last output a checkpoint file */
1612 amrex::Real last_check_file_time;
1613 /** \brief Whether to output a plotfile on restart from checkpoint */
1614 int plot_file_on_restart = 1;
1615
1616 ////////////////
1617 // runtime parameters
1618
1619 /** \brief maximum number of steps */
1620 int max_step = std::numeric_limits<int>::max();
1621 /** \brief Whether max_step was set in the inputs; the default above is not a
1622 * distinguishable sentinel */
1623 /** \brief Time to stop */
1624 amrex::Real stop_time = std::numeric_limits<amrex::Real>::max();
1625
1626 /** \brief Time of the start of the simulation, in seconds */
1627 amrex::Real start_time = zero;
1628
1629 /** \brief If set, restart from this checkpoint file */
1630 std::string restart_chkfile = "";
1631
1632 /** \brief Number of passive (dye) scalars carried in the state, beyond temperature
1633 * and salinity. Does not count biology tracers. Dye is opt-in: a run
1634 * carries one only when remora.nscalar asks for it. */
1635 int nscalar = 0;
1636 /** \brief Number of biology tracers, set by the active biology model. Zero when no
1637 * biology model is active. */
1638 int nbio = 0;
1639 /** \brief First cons component of the biology block, i.e. Tracer_comp + nscalar.
1640 * The state is laid out as temp, salt, the passive scalars, then biology. */
1641 int Bio_comp = Tracer_comp;
1642 /** \brief Number of conserved scalars in the state
1643 * (temperature + salt + passive scalars + biology tracers) */
1644 int ncons = Tracer_comp + 1;
1645 /** \brief Active biology package */
1646 REMORABiology::BiologyModel biology_model = REMORABiology::BiologyModel::none;
1647 /** \brief Runtime parameters for the Fennel biology package */
1648 REMORABiology::FennelParameters fennel_params;
1649 /** \brief Source of the biology tracer initial condition, independent of
1650 * remora.ic_type. Default follows ic_type. */
1651 REMORABiology::BiologyICType biology_ic_type = REMORABiology::BiologyICType::follow_ic_type;
1652 /** \brief Select the native C++ biology kernel (1) or the ROMS Fortran
1653 * bridge oracle (0). Only meaningful when built with
1654 * USE_FENNEL_FORT=TRUE; ignored otherwise. Runtime-controlled so
1655 * the two paths can be compared without a rebuild. */
1656 int use_biology_cpp_answer = 1;
1657 /** \brief Biology diagnostic verbosity: 0 off, 1 target column, 2 all
1658 * columns. See Source/Biology/Fortran/tag_map.md. */
1659 int biology_debug = 0;
1660 /** \brief Target column i index for biology_debug = 1 */
1661 int biology_debug_i = 2;
1662 /** \brief Target column j index for biology_debug = 1 */
1663 int biology_debug_j = 2;
1664
1665 // Time step controls
1666 /** \brief CFL condition */
1667 static amrex::Real cfl;
1668 /** \brief Fraction maximum change in subsequent time steps */
1669 static amrex::Real change_max;
1670 /** \brief User specified fixed baroclinic time step */
1671 static amrex::Real fixed_dt;
1672 /** \brief User specified, number of barotropic steps per baroclinic step */
1673 static int ndtfast;
1674 /** \brief Number of fast steps to take */
1675 int nfast;
1676
1677 /** \brief Whether to substep fine levels in time */
1678 int do_substep = 0;
1679
1680 /** \brief how often each level regrids the higher levels of refinement (after a level advances that many time steps) */
1681 int regrid_int = 2;
1682
1683 // I/O controls
1684 /** \brief Plotfile prefix */
1685 std::string plot_file_name {"plt_"};
1686 /** \brief Plotfile output interval in iterations */
1687 int plot_int = -1;
1688 /** \brief Plotfile output interval in seconds */
1689 amrex::Real plot_int_time = amrex::Real(-one);
1690 /** \brief Checkpoint file prefix */
1691 std::string check_file {"chk"};
1692 /** \brief Checkpoint output interval in iterations */
1693 int check_int = -1;
1694 /** \brief Checkpoint output interval in seconds */
1695 amrex::Real check_int_time = amrex::Real(-one);
1696
1697 /** \brief Whether to split the netcdf history file into fixed-length chunks */
1698 bool chunk_history_file = false;
1699 /** \brief Time steps per netcdf history file. Must be > 0 if chunk_history_file. */
1700 int steps_per_history_file = -1;
1701 /** \brief Counter for which time index we are writing to in the netcdf history file */
1702 int history_count = 0;
1703
1704 /** \brief Names of 3D variables to output to AMReX plotfile */
1705 amrex::Vector<std::string> plot_var_names_3d;
1706 /** \brief Names of 2D variables to output to AMReX plotfile */
1707 amrex::Vector<std::string> plot_var_names_2d;
1708 /** \brief Names of scalars for plotfile output */
1709 amrex::Vector<std::string> cons_names {"temp", "salt", "tracer"};
1710 // Note that the order of variable names here must match the order in PlotFile.cpp
1711 /** \brief Names of derived fields for 3d plotfile fields */
1712 const amrex::Vector<std::string> derived_names_3d {"vorticity"};
1713 /** \brief Names of derived fields for 2d plotfile fields */
1714 const amrex::Vector<std::string> derived_names_2d {};
1715
1716 /** \brief Container for algorithmic choices */
1717 static SolverChoice solverChoice;
1718
1719 /** \brief whether plotfile variables should be expanded to a uniform refinement ratio */
1720 bool expand_plotvars_to_unif_rr = false;
1721
1722 /** \brief fill value for masked arrays in amrex plotfiles */
1723 amrex::Real plotfile_fill_value = zero;
1724 /** \brief fill value for masked arrays in netcdf output */
1725 amrex::Real netcdf_fill_value = amrex::Real(1.0e37);
1726
1727
1728#ifdef REMORA_USE_PARTICLES
1729 /** \brief Particle container with all particle species */
1730 ParticleData particleData;
1731
1732 // variables and functions for tracers particles
1733 /** \brief tracer particles that advect with flow */
1734 bool m_use_tracer_particles;
1735 /** \brief tracer particles that fall with gravity */
1736 bool m_use_hydro_particles;
1737
1738 /** \brief Read tracer and hydro particles parameters */
1739 void readTracersParams();
1740
1741 /** \brief Initialize tracer and hydro particles */
1742 void initializeTracers ( amrex::ParGDBBase*,
1743 const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& );
1744
1745 /** \brief Evolve tracers and hydro particles */
1746 void evolveTracers( int lev,
1747 amrex::Real dt,
1748 amrex::Vector<amrex::MultiFab const*>& flow_vel,
1749 const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& );
1750
1751#endif
1752 /** \brief Verbosity level of output */
1753 static int verbose;
1754
1755 /** \brief Diagnostic sum output interval in number of steps */
1756 static int sum_interval;
1757 /** \brief Diagnostic sum output interval in time */
1758 static amrex::Real sum_per;
1759
1760 /** \brief Minimum number of digits in plotfile name or chunked history file */
1761 static int file_min_digits;
1762
1763 /** \brief Whether to write the staggered velocities (not averaged to cell centers) */
1764 static bool plot_staggered_vels;
1765
1766 /** \brief Whether to write nodal data (Nu_nd) to plotfiles */
1767 static bool plot_nodal_data;
1768
1769 /** \brief Native or NetCDF plotfile output */
1770 static PlotfileType plotfile_type;
1771
1772 /** \brief NetCDF initialization file */
1773 static amrex::Vector<amrex::Vector<std::string>> nc_init_file;
1774 /** \brief NetCDF grid file */
1775 static amrex::Vector<amrex::Vector<std::string>> nc_grid_file;
1776 /** \brief NetCDF boundary data */
1777 static amrex::Vector<std::string> nc_bdry_file;
1778
1779 /** \brief Which level the high resolution bathymetry is at */
1780 int hires_grid_level = -1;
1781 /** \brief Grid file for high resolution bathymetry */
1782 std::string nc_grid_file_hires;
1783 /** \brief Box for the full domain at nc_hires_grid_level */
1784 amrex::Box nc_hires_grid_box;
1785
1786 /** \brief Which level the high resolution initialization data is at */
1787 int hires_init_level = -1;
1788 /** \brief Init file for high resolution */
1789 std::string nc_init_file_hires;
1790 /** \brief Box for the full domain at nc_hires_init_level */
1791 amrex::Box nc_hires_init_box;
1792
1793 /** \brief Cumulative refinement ratio between level 0 and level i */
1794 amrex::Vector<amrex::IntVect> cum_ref_ratios;
1795
1796 /** \brief NetCDF forcing file(s) */
1797 amrex::Vector<std::string> nc_frc_file;
1798 /** \brief NetCDF river file(s) */
1799 amrex::Vector<std::string> nc_riv_file;
1800
1801 /** \brief NetCDF climatology history file(s) */
1802 amrex::Vector<std::string> nc_clim_his_file;
1803 /** \brief NetCDF climatology coefficient file */
1804 std::string nc_clim_coeff_file;
1805
1806 /** \brief Default name of time field for boundary data */
1807 std::string bdry_time_varname = "ocean_time";
1808 /** \brief Name of time fields for boundary data */
1809 amrex::Vector<std::string> bdry_time_name_byvar;
1810
1811 /** \brief Name of time field for ubar climatology data */
1812 std::string clim_ubar_time_varname = "ocean_time";
1813 /** \brief Name of time field for vbar climatology data */
1814 std::string clim_vbar_time_varname = "ocean_time";
1815 /** \brief Name of time field for u climatology data */
1816 std::string clim_u_time_varname = "ocean_time";
1817 /** \brief Name of time field for v climatology data */
1818 std::string clim_v_time_varname = "ocean_time";
1819 /** \brief Vector over cons components of the name of the time field for that
1820 * tracer's climatology data */
1821 amrex::Vector<std::string> clim_cons_time_varname;
1822 /** \brief Name of time field for river time */
1823 std::string riv_time_varname = "river_time";
1824 /** \brief Name of time field for forcing data */
1825 std::string frc_time_varname = "";
1826
1827 /** \brief Set refinement criteria */
1828 void refinement_criteria_setup();
1829
1830 /** \brief Holds info for dynamically generated tagging criteria */
1831 static amrex::Vector<amrex::AMRErrorTag> ref_tags;
1832
1833 /** \brief Mask that zeroes out values on a coarse level underlying grids on the next finest level */
1834 amrex::MultiFab fine_mask;
1835
1836 /** \brief Helper function to determine number of ghost cells */
1837 AMREX_FORCE_INLINE
1838 int
1839 ComputeGhostCells(const int& spatial_order) {
1840 int nGhostCells = 0;
1841 switch (spatial_order) {
1842 case 2:
1843 nGhostCells = 2; // We need this many to compute the eddy viscosity in the ghost cells
1844 break;
1845 case 3:
1846 nGhostCells = 2;
1847 break;
1848 case 4:
1849 nGhostCells = 2;
1850 break;
1851 case 5:
1852 nGhostCells = 3;
1853 break;
1854 case 6:
1855 nGhostCells = 3;
1856 break;
1857 default:
1858 amrex::Error("Must specify spatial order to be 2,3,4,5 or 6");
1859 }
1860
1861 return nGhostCells;
1862 }
1863
1864 /** \brief Helper function for IO stream */
1865 AMREX_FORCE_INLINE
1866 std::ostream&
1867 DataLog (int i)
1868 {
1869 return *datalog[i];
1870 }
1871
1872 AMREX_FORCE_INLINE
1873 int
1874 NumDataLogs () noexcept
1875 {
1876 return datalog.size();
1877 }
1878
1879 /** \brief Variable for CPU timing */
1880 static amrex::Real startCPUTime;
1881 /** \brief Accumulator variable for CPU time used thusfar */
1882 static amrex::Real previousCPUTimeUsed;
1883
1884 /** \brief Get CPU time used */
1885 amrex::Real
1886 getCPUTime() const
1887 {
1888 int numCores = amrex::ParallelDescriptor::NProcs();
1889#ifdef _OPENMP
1890 numCores = numCores * omp_get_max_threads();
1891#endif
1892
1893 amrex::Real T =
1894 numCores * (amrex::Real(amrex::ParallelDescriptor::second()) - startCPUTime) +
1895 previousCPUTimeUsed;
1896
1897 return T;
1898 }
1899
1900 void setRecordDataInfo (int i, const std::string& filename)
1901 {
1902 if (amrex::ParallelDescriptor::IOProcessor())
1903 {
1904 datalog[i] = std::make_unique<std::fstream>();
1905 datalog[i]->open(filename.c_str(),std::ios::out|std::ios::app);
1906 if (!datalog[i]->good()) {
1907 amrex::FileOpenFailed(filename);
1908 }
1909 }
1910 amrex::ParallelDescriptor::Barrier("REMORA::setRecordDataInfo");
1911 }
1912
1913 amrex::Vector<std::unique_ptr<std::fstream> > datalog;
1914 amrex::Vector<std::string> datalogname;
1915
1916 /** \brief The filename of the ith datalog file. */
1917 const std::string DataLogName (int i) const noexcept { return datalogname[i]; }
1918
1919public:
1920 /** \brief Write job info to stdout */
1921 void writeJobInfo (const std::string& dir) const;
1922 /** \brief Write build info to os */
1923 static void writeBuildInfo (std::ostream& os);
1924
1925 static void print_banner(MPI_Comm /*comm*/, std::ostream& /*out*/);
1926 static void print_usage(MPI_Comm /*comm*/, std::ostream& /*out*/);
1927 static void print_error(MPI_Comm /*comm*/, const std::string& msg);
1928 static void print_summary(std::ostream&);
1929 static void print_tpls(std::ostream& /*out*/);
1930
1931 /** \brief Accessor method for t_old to expose to outside classes */
1932 amrex::Real get_t_old(int lev) const;
1933
1934 /** \brief First cons component of the biology block. Problem setups need this to
1935 * write biology initial conditions, since the passive scalars sit between
1936 * salinity and the biology tracers. */
1937 int bio_comp_start () const noexcept { return Bio_comp; }
1938 /** \brief Number of biology tracers carried in the state */
1939 int num_bio () const noexcept { return nbio; }
1940 /** \brief Number of passive (dye) scalars carried in the state */
1941 int num_scalar () const noexcept { return nscalar; }
1942
1943 /** \brief Evaluate stability function psi for wind speed */
1944 AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
1945 static amrex::Real bulk_psiu(amrex::Real ZoL) {
1946 // Compute stability function, psi
1947 using namespace amrex;
1948
1949 Real psiu;
1950 if (ZoL < zero) {
1951 // Unstable conditions.
1952 Real x = std::pow(one-Real(15.0)*ZoL,fourth);
1953 Real psik = two*std::log(Real(0.5)*(one+x))+
1954 std::log(Real(0.5)*(one+x*x))-
1955 two*std::atan(x)+Real(0.5)*PI;
1956 // For very unstable conditions, use free-convection (Fairall).
1957 Real sqrt3 = std::sqrt(three);
1958 Real y = std::pow(one-Real(10.15)*ZoL,third);
1959 Real psic = Real(1.5)*std::log(one/Real(three)*(one+y+y*y))-
1960 sqrt3*std::atan((one+two*y)/sqrt3)+PI/sqrt3;
1961 // Match Kansas and free-convection forms with weighting Fw.
1962 Real Zol2 = ZoL*ZoL;
1963 Real Fw = Zol2/(one+Zol2);
1964
1965 psiu = (one-Fw)*psik+Fw*psic;
1966 } else {
1967 // Stable conditions
1968 Real cff=std::min(Real(50.0),Real(0.35)*ZoL);
1969 psiu = -((one+ZoL)+Real(0.6667)*(ZoL-Real(14.28))/
1970 std::exp(cff)+Real(8.525));
1971 }
1972 return psiu;
1973 }
1974
1975 /** \brief Evaluate stability function psi for moisture and heat */
1976 AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
1977 static amrex::Real bulk_psit(amrex::Real ZoL) {
1978 // Compute stability function, psi
1979 using namespace amrex;
1980
1981 Real psit;
1982 if (ZoL < zero) {
1983 // Unstable conditions.
1984 Real x = std::pow(one-Real(15.0)*ZoL,Real(0.5));
1985 Real psik = two*std::log(Real(0.5)*(one+x));
1986 // For very unstable conditions, use free-convection (Fairall).
1987 Real sqrt3=std::sqrt(three);
1988 Real y=std::pow(one-Real(34.15)*ZoL,one/three);
1989 Real psic=Real(1.5)*std::log(one/three*(one+y+y*y))-
1990 sqrt3*std::atan((one+two*y)/sqrt3)+PI/sqrt3;
1991
1992 // Match Kansas and free-convection forms with weighting Fw.
1993 Real ZoL2=ZoL*ZoL;
1994 Real Fw=ZoL2/(one+ZoL2);
1995 psit = (one-Fw)*psik+Fw*psic;
1996 } else {
1997 // Stable conditions.
1998 Real cff=std::min(Real(50.0),Real(0.35)*ZoL);
1999 psit=-(std::pow(one+two*ZoL,Real(1.5))+
2000 Real(0.6667)*(ZoL-Real(14.28))/std::exp(cff)+Real(8.525));
2001 }
2002 return psit;
2003 }
2004};
2005
2006#endif
REMORA_Biology.H
three
constexpr amrex::Real three
Definition REMORA_Constants.H:9
two
constexpr amrex::Real two
Definition REMORA_Constants.H:8
one
constexpr amrex::Real one
Definition REMORA_Constants.H:7
fourth
constexpr amrex::Real fourth
Definition REMORA_Constants.H:12
zero
constexpr amrex::Real zero
Definition REMORA_Constants.H:6
PI
constexpr amrex::Real PI
Definition REMORA_Constants.H:19
third
constexpr amrex::Real third
Definition REMORA_Constants.H:13
REMORA_DataStruct.H
PlotfileType
PlotfileType
plotfile format
Definition REMORA_DataStruct.H:42
Coord::y
@ y
Coord::x
@ x
REMORA_Derive.H
REMORA_FillPatcher.H
REMORA_IndexDefines.H
Tracer_comp
#define Tracer_comp
Definition REMORA_IndexDefines.H:12
setVal
mf_h setVal(geomdata.ProbHi(2))
time
Real time
Definition REMORA_InitAnalyticSMFlux_ChannelTest.H:1
mf_fcor
Real mf_fcor
Definition REMORA_InitAnalyticSMFlux_ChannelTest.H:7
REMORA_MOAB.H
REMORA_NCInterface.H
REMORA_NCTimeSeriesBoundary.H
REMORA_NCTimeSeriesRiver.H
REMORA_NCTimeSeries.H
REMORA_ParticleData.H
REMORA_PhysBCFunct.H
REMORA_TimeInterpolatedData.H
REMORA_prob_common.H
NCTimeSeriesBoundary
A class to hold and interpolate time series data read from a NetCDF file.
Definition REMORA_NCTimeSeriesBoundary.H:18
NCTimeSeries
A class to hold and interpolate time series data read from a NetCDF file.
Definition REMORA_NCTimeSeries.H:17
REMORA
Class that stores all relevant simulation state data with methods for time stepping.
Definition REMORA.H:91
REMORA::plotfile_type
static PlotfileType plotfile_type
Native or NetCDF plotfile output.
Definition REMORA.H:1770
REMORA::nc_grid_file_hires
std::string nc_grid_file_hires
Grid file for high resolution bathymetry.
Definition REMORA.H:1782
REMORA::vec_EminusP
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_EminusP
evaporation minus precipitation [kg/m^2/s], defined at rho-points
Definition REMORA.H:509
REMORA::nc_riv_file
amrex::Vector< std::string > nc_riv_file
NetCDF river file(s)
Definition REMORA.H:1799
REMORA::set_grid_vars_averaged_down
void set_grid_vars_averaged_down(int lev)
Set pm/pn by averaging down from higher-resolution grid.
Definition REMORA.cpp:750
REMORA::riv_time_varname
std::string riv_time_varname
Name of time field for river time.
Definition REMORA.H:1823
REMORA::foextrap_periodic_bc
int foextrap_periodic_bc() const noexcept
Definition REMORA.H:1320
REMORA::GotoNextLine
static void GotoNextLine(std::istream &is)
utility to skip to next line in Header
Definition REMORA_Checkpoint.cpp:8
REMORA::ConfigureDriverAtmosToOceanCoupling
void ConfigureDriverAtmosToOceanCoupling(bool use_coupling_driver, bool use_two_way_coupling, DriverAtmosForcingMode active_mode)
Definition REMORA_Coupling.cpp:248
REMORA::nfast
int nfast
Number of fast steps to take.
Definition REMORA.H:1675
REMORA::nc_clim_his_file
amrex::Vector< std::string > nc_clim_his_file
NetCDF climatology history file(s)
Definition REMORA.H:1802
REMORA::ncons
int ncons
Number of conserved scalars in the state (temperature + salt + passive scalars + biology tracers)
Definition REMORA.H:1644
REMORA::WriteNCMultiFab
void WriteNCMultiFab(const amrex::FabArray< amrex::FArrayBox > &fab, const std::string &name, bool set_ghost=false) const
Write MultiFab in NetCDF format.
REMORA::vec_zeta_full_domain
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_zeta_full_domain
high resolution initial free surface height (2D)
Definition REMORA.H:554
REMORA::vec_rv2d
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_rv2d
v velocity RHS (2D, includes horizontal and vertical advection)
Definition REMORA.H:424
REMORA::nc_init_file_hires
std::string nc_init_file_hires
Init file for high resolution.
Definition REMORA.H:1789
REMORA::SetStartTime
void SetStartTime(amrex::Real time) noexcept
Definition REMORA.H:122
REMORA::prsgrd
void prsgrd(const amrex::Box &bx, const amrex::Box &gbx, const amrex::Box &utbx, const amrex::Box &vtbx, const amrex::Array4< amrex::Real > &ru, const amrex::Array4< amrex::Real > &rv, const amrex::Array4< amrex::Real const > &pn, const amrex::Array4< amrex::Real const > &pm, const amrex::Array4< amrex::Real const > &rho, const amrex::Array4< amrex::Real > &FC, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &z_r, const amrex::Array4< amrex::Real const > &z_w, const amrex::Array4< amrex::Real const > &msku, const amrex::Array4< amrex::Real const > &mskv, const int nrhs, const int N)
Calculate pressure gradient.
Definition REMORA_prsgrd.cpp:25
REMORA::biology_debug_i
int biology_debug_i
Target column i index for biology_debug = 1.
Definition REMORA.H:1661
REMORA::fixed_dt
static amrex::Real fixed_dt
User specified fixed baroclinic time step.
Definition REMORA.H:1671
REMORA::vec_evap
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_evap
evaporation rate [kg/m^2/s]
Definition REMORA.H:505
REMORA::last_plot_file_time
amrex::Real last_plot_file_time
Simulation time when we last output a plotfile.
Definition REMORA.H:1607
REMORA::update_massflux_3d
void update_massflux_3d(int lev, const amrex::Box &bx, const int ioff, const int joff, const amrex::Array4< amrex::Real > &phi, const amrex::Array4< amrex::Real > &phibar, const amrex::Array4< amrex::Real > &Hphi, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &pm_or_pn, const amrex::Array4< amrex::Real const > &Dphi1, const amrex::Array4< amrex::Real const > &Dphi2, const amrex::Array4< amrex::Real > &DC, const amrex::Array4< amrex::Real > &FC, const amrex::Array4< amrex::Real const > &msk, const int nnew)
Correct mass flux.
Definition REMORA_update_massflux_3d.cpp:23
REMORA::scale_rhs_vars
void scale_rhs_vars()
Scale RHS momentum variables by 1/cell area, needed before FillPatch to different levels.
Definition REMORA_scale_rhs_vars.cpp:6
REMORA::zvel_bc
int zvel_bc() const noexcept
Definition REMORA.H:1315
REMORA::init_full_domain_zeta_from_analytic
void init_full_domain_zeta_from_analytic()
Initialize high resolution initial sea surface height from analytic functions.
Definition REMORA_init.cpp:427
REMORA::plot_staggered_vels
static bool plot_staggered_vels
Whether to write the staggered velocities (not averaged to cell centers)
Definition REMORA.H:1764
REMORA::init_bathymetry_from_netcdf
void init_bathymetry_from_netcdf(int lev)
Bathymetry data initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:665
REMORA::init_bcs
void init_bcs()
Read in boundary parameters from input file and set up data structures.
Definition REMORA_init_bcs.cpp:9
REMORA::xvel_bc
int xvel_bc() const noexcept
Definition REMORA.H:1313
REMORA::domain_bcs_type
amrex::Vector< amrex::BCRec > domain_bcs_type
vector (over BCVars) of BCRecs
Definition REMORA.H:1578
REMORA::set_bcs_by_var
bool set_bcs_by_var
whether to set boundary conditions by variable rather than just by side
Definition REMORA.H:1563
REMORA::set_zeta_averaged_down
void set_zeta_averaged_down(int lev)
Copy over zeta data that has been averaged down from high res.
Definition REMORA.cpp:768
REMORA::calculate_nodal_masks
void calculate_nodal_masks(int lev)
Calculate u-, v-, and psi-point masks based on rho-point masks after analytic initialization.
Definition REMORA_make_new_level.cpp:1027
REMORA::qair_data_from_file
std::unique_ptr< NCTimeSeries > qair_data_from_file
Data container for specific humidity read from file.
Definition REMORA.H:1455
REMORA::previousCPUTimeUsed
static amrex::Real previousCPUTimeUsed
Accumulator variable for CPU time used thusfar.
Definition REMORA.H:1882
REMORA::cons_names
amrex::Vector< std::string > cons_names
Names of scalars for plotfile output.
Definition REMORA.H:1709
REMORA::running_with_coupling_driver
bool running_with_coupling_driver
True once REMORA has received forcing through the coupling driver.
Definition REMORA.H:514
REMORA::advflux_reg
amrex::Vector< std::unique_ptr< amrex::YAFluxRegister > > advflux_reg
array of flux registers for refluxing in multilevel
Definition REMORA.H:1569
REMORA::sustr_data_from_file
std::unique_ptr< NCTimeSeries > sustr_data_from_file
Data container for u-component surface momentum flux read from file.
Definition REMORA.H:1445
REMORA::vec_fcor
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_fcor
coriolis factor (2D)
Definition REMORA.H:577
REMORA::allocate_init_full_domain
void allocate_init_full_domain()
Allocate multifabs for storing full-domain high resolution initial data.
Definition REMORA_init.cpp:367
REMORA::vec_btflux
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_btflux
Bottom tracer flux; input arrays.
Definition REMORA.H:500
REMORA::init_gls_vmix
void init_gls_vmix(int lev, SolverChoice solver_choice)
Initialize GLS variables.
Definition REMORA_init.cpp:235
REMORA::vec_rubar
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_rubar
barotropic x velocity for the RHS (2D)
Definition REMORA.H:541
REMORA::init_biology_from_netcdf
void init_biology_from_netcdf(int lev)
Biology initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:257
REMORA::vec_xvel_full_domain
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_xvel_full_domain
multilevel data container for high res initial x velocities (u in ROMS)
Definition REMORA.H:397
REMORA::vec_h
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_h
multilevel data container for current step's z velocities (largely unused; W stored separately)
Definition REMORA.H:406
REMORA::vec_pm
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_pm
horizontal scaling factor: 1 / dx (2D)
Definition REMORA.H:568
REMORA::fine_mask
amrex::MultiFab fine_mask
Mask that zeroes out values on a coarse level underlying grids on the next finest level.
Definition REMORA.H:1834
REMORA::set2DPlotVariables
void set2DPlotVariables(const std::string &pp_plot_var_names_2d)
Definition REMORA_SetPlotVars.cpp:118
REMORA::FillCoarsePatchMap
void FillCoarsePatchMap(int lev, amrex::Real time, amrex::MultiFab *mf_fine, amrex::MultiFab *mf_crse, const int bccomp, const int bdy_var_type=BdyVars::null, const int icomp=0, const bool fill_all=true, const int n_not_fill=0, const int icomp_calc=0, const amrex::Real dt=zero, const amrex::MultiFab &mf_calc=amrex::MultiFab(), amrex::Interpolater *mapper=nullptr)
fill an entire multifab by interpolating from the coarser level, explicitly specifying interpolator t...
Definition REMORA_FillPatch.cpp:445
REMORA::GetLandSeaMasks
void GetLandSeaMasks(const amrex::MultiFab *&mskr, const amrex::MultiFab *&msku, const amrex::MultiFab *&mskv) const
Definition REMORA_Coupling.cpp:364
REMORA::FPr_v
amrex::Vector< REMORAFillPatcher > FPr_v
Vector over levels of FillPatchers for v (3D)
Definition REMORA.H:1513
REMORA::vec_ZoBot
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_ZoBot
Bottom roughness length [m], defined at rho points.
Definition REMORA.H:525
REMORA::init_biology_ic
void init_biology_ic(int lev)
Initialize biology tracers from whichever source remora.biology_ic_type selects. Call after the physi...
Definition REMORA_init.cpp:39
REMORA::vec_DU_avg2
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_DU_avg2
correct time average of barotropic x velocity flux for coupling (2D)
Definition REMORA.H:535
REMORA::vec_lrflx
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_lrflx
longwave radiation
Definition REMORA.H:485
REMORA::init_zeta_full_domain_from_netcdf
void init_zeta_full_domain_from_netcdf()
Full-domain high res sea-surface height data initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:482
REMORA::vec_yv
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_yv
y_grid on v-points (2D)
Definition REMORA.H:592
REMORA::print_error
static void print_error(MPI_Comm, const std::string &msg)
Definition REMORA_console_io.cpp:43
REMORA::cons_new
amrex::Vector< amrex::MultiFab * > cons_new
multilevel data container for current step's scalar data: temperature, salinity, passive tracer
Definition REMORA.H:386
REMORA::write_history_file
static bool write_history_file
Whether to output NetCDF files as a single history file with several time steps.
Definition REMORA.H:1442
REMORA::init_biology_ic_full_domain
void init_biology_ic_full_domain()
Full-domain counterpart of init_biology_ic, for the hires_init_level average-down path.
Definition REMORA_init.cpp:76
REMORA::MakeNewLevelFromCoarse
virtual void MakeNewLevelFromCoarse(int lev, amrex::Real time, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm) override
Make a new level using provided BoxArray and DistributionMapping and fill with interpolated coarse le...
Definition REMORA_make_new_level.cpp:24
REMORA::tke_bc
int tke_bc() const noexcept
Definition REMORA.H:1319
REMORA::stretch_transform
void stretch_transform(int lev)
Calculate vertical stretched coordinates.
Definition REMORA_DepthStretchTransform.H:78
REMORA::rain_data_from_file
std::unique_ptr< NCTimeSeries > rain_data_from_file
Data container for precipitation rate read from file.
Definition REMORA.H:1463
REMORA::set_curvilinear_terms_from_grid_scale
void set_curvilinear_terms_from_grid_scale(int lev)
Set curvilinear derivative terms on level lev based on pm and pn.
Definition REMORA_make_new_level.cpp:909
REMORA::s_w
amrex::Gpu::DeviceVector< amrex::Real > s_w
Scaled vertical coordinate (range [0,1]) that transforms to z, defined at w-points (cell faces)
Definition REMORA.H:448
REMORA::biology_model
REMORABiology::BiologyModel biology_model
Active biology package.
Definition REMORA.H:1646
REMORA::vec_vwind
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_vwind
Wind in the v direction, defined at rho-points.
Definition REMORA.H:474
REMORA::prob
std::unique_ptr< ProblemBase > prob
Pointer to container of analytical functions for problem definition.
Definition REMORA.H:1542
REMORA::vec_mskr
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_mskr
land/sea mask at cell centers (2D)
Definition REMORA.H:557
REMORA::Construct_REMORAFillPatchers
void Construct_REMORAFillPatchers(int lev)
Construct FillPatchers.
Definition REMORA.cpp:522
REMORA::advance_3d
void advance_3d(int lev, amrex::MultiFab &mf_cons, amrex::MultiFab &mf_u, amrex::MultiFab &mf_v, amrex::MultiFab *mf_sstore, amrex::MultiFab *mf_ru, amrex::MultiFab *mf_rv, std::unique_ptr< amrex::MultiFab > &mf_DU_avg1, std::unique_ptr< amrex::MultiFab > &mf_DU_avg2, std::unique_ptr< amrex::MultiFab > &mf_DV_avg1, std::unique_ptr< amrex::MultiFab > &mf_DV_avg2, std::unique_ptr< amrex::MultiFab > &mf_ubar, std::unique_ptr< amrex::MultiFab > &mf_vbar, std::unique_ptr< amrex::MultiFab > &mf_Akv, std::unique_ptr< amrex::MultiFab > &mf_Akt, std::unique_ptr< amrex::MultiFab > &mf_Hz, std::unique_ptr< amrex::MultiFab > &mf_Huon, std::unique_ptr< amrex::MultiFab > &mf_Hvom, std::unique_ptr< amrex::MultiFab > &mf_z_w, amrex::MultiFab const *mf_h, amrex::MultiFab const *mf_pm, amrex::MultiFab const *mf_pn, amrex::MultiFab const *mf_mskr, amrex::MultiFab const *mf_msku, amrex::MultiFab const *mf_mskv, const int N, const amrex::Real dt_lev)
Advance the 3D variables.
Definition REMORA_advance_3d.cpp:35
REMORA::init_grid_vars_from_netcdf
void init_grid_vars_from_netcdf(int lev)
Grid variable initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:526
REMORA::sum_interval
static int sum_interval
Diagnostic sum output interval in number of steps.
Definition REMORA.H:1756
REMORA::history_count
int history_count
Counter for which time index we are writing to in the netcdf history file.
Definition REMORA.H:1702
REMORA::stop_time
amrex::Real stop_time
Whether max_step was set in the inputs; the default above is not a distinguishable sentinel.
Definition REMORA.H:1624
REMORA::vec_rain
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_rain
precipitation rate [kg/m^2/s]
Definition REMORA.H:503
REMORA::vec_tke
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_tke
Turbulent kinetic energy.
Definition REMORA.H:632
REMORA::rho_eos
void rho_eos(const amrex::Box &bx, const amrex::Array4< amrex::Real const > &state, const amrex::Array4< amrex::Real > &rho, const amrex::Array4< amrex::Real > &rhoA, const amrex::Array4< amrex::Real > &rhoS, const amrex::Array4< amrex::Real > &bvf, const amrex::Array4< amrex::Real > &alpha, const amrex::Array4< amrex::Real > &beta, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &z_w, const amrex::Array4< amrex::Real const > &z_r, const amrex::Array4< amrex::Real const > &h, const amrex::Array4< amrex::Real const > &mskr, const int N)
Wrapper around equation of state calculation.
Definition REMORA_rho_eos.cpp:22
REMORA::print_summary
static void print_summary(std::ostream &)
REMORA::do_substep
int do_substep
Whether to substep fine levels in time.
Definition REMORA.H:1678
REMORA::vec_stflx
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_stflx
Surface tracer flux; working arrays.
Definition REMORA.H:494
REMORA::Evolve
void Evolve()
Advance solution to final time.
Definition REMORA.cpp:276
REMORA::t3dmix2
void t3dmix2(const amrex::Box &bx, const amrex::Array4< amrex::Real > &state, const amrex::Array4< amrex::Real > &state_rhs, const amrex::Array4< amrex::Real const > &diff2, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &z_r, const amrex::Array4< amrex::Real const > &pm, const amrex::Array4< amrex::Real const > &pn, const amrex::Array4< amrex::Real const > &msku, const amrex::Array4< amrex::Real const > &mskv, const amrex::Real dt_lev, const int ncomp, const int N)
Wrapper for harmonic diffusivity for tracers.
Definition REMORA_t3dmix.cpp:21
REMORA::bdry_time_varname
std::string bdry_time_varname
Default name of time field for boundary data.
Definition REMORA.H:1807
REMORA::plotfile_fill_value
amrex::Real plotfile_fill_value
fill value for masked arrays in amrex plotfiles
Definition REMORA.H:1723
REMORA::num_passive_scalars
int num_passive_scalars() const noexcept
Number of passive (dye) scalars in the state, not counting biology tracers.
Definition REMORA.H:1341
REMORA::ReadCheckpointFile
void ReadCheckpointFile()
read checkpoint file from disk
Definition REMORA_Checkpoint.cpp:220
REMORA::vec_gls
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_gls
Turbulent generic length scale.
Definition REMORA.H:634
REMORA::GetAtmosToOceanPsiLonLat
void GetAtmosToOceanPsiLonLat(const amrex::MultiFab *&lon_psi, const amrex::MultiFab *&lat_psi) const
Definition REMORA_Coupling.cpp:350
REMORA::biology_debug
int biology_debug
Biology diagnostic verbosity: 0 off, 1 target column, 2 all columns. See Source/Biology/Fortran/tag_m...
Definition REMORA.H:1659
REMORA::chunk_history_file
bool chunk_history_file
Whether to split the netcdf history file into fixed-length chunks.
Definition REMORA.H:1698
REMORA::writeJobInfo
void writeJobInfo(const std::string &dir) const
Write job info to stdout.
Definition REMORA_writeJobInfo.cpp:7
REMORA::num_bc_vars
int num_bc_vars() const noexcept
Definition REMORA.H:1324
REMORA::ApplyAtmosphericFluxes
void ApplyAtmosphericFluxes(const amrex::Vector< amrex::MultiFab * > &states, amrex::Real time)
Receives atmospheric flux lanes from the driver and assembles REMORA flux inputs.
Definition REMORA_Coupling.cpp:511
REMORA::vec_sustr
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_sustr
Surface stress in the u direction.
Definition REMORA.H:467
REMORA::get_t_old
amrex::Real get_t_old(int lev) const
Accessor method for t_old to expose to outside classes.
Definition REMORA.cpp:2113
REMORA::vec_yp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_yp
y_grid on psi-points (2D)
Definition REMORA.H:597
REMORA::vec_xr
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_xr
x_grid on rho points (2D)
Definition REMORA.H:580
REMORA::yvel_bc
int yvel_bc() const noexcept
Definition REMORA.H:1314
REMORA::longwave_down_data_from_file
std::unique_ptr< NCTimeSeries > longwave_down_data_from_file
Data container for downward longwave radiation flux read from file.
Definition REMORA.H:1461
REMORA::vec_ru2d
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_ru2d
u velocity RHS (2D, includes horizontal and vertical advection)
Definition REMORA.H:422
REMORA::ClearLevel
virtual void ClearLevel(int lev) override
Delete level data Overrides the pure virtual function in AmrCore.
Definition REMORA_make_new_level.cpp:799
REMORA::init_biology_full_domain_from_netcdf
void init_biology_full_domain_from_netcdf()
Full-domain high-res biology initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:395
REMORA::datalogname
amrex::Vector< std::string > datalogname
Definition REMORA.H:1914
REMORA::GetAtmosToOceanVFaceLayout
void GetAtmosToOceanVFaceLayout(amrex::BoxArray &ba, amrex::DistributionMapping &dm) const
Definition REMORA_Coupling.cpp:325
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:392
REMORA::set_surface_state
void set_surface_state(int lev)
Initialize or calculate wind speed and other surface state vars from file or analytic.
Definition REMORA.cpp:1190
REMORA::GetAtmosToOceanRhoLayout
void GetAtmosToOceanRhoLayout(amrex::BoxArray &ba, amrex::DistributionMapping &dm) const
Definition REMORA_Coupling.cpp:303
REMORA::num_scalar
int num_scalar() const noexcept
Number of passive (dye) scalars carried in the state.
Definition REMORA.H:1941
REMORA::ComputeGhostCells
AMREX_FORCE_INLINE int ComputeGhostCells(const int &spatial_order)
Helper function to determine number of ghost cells.
Definition REMORA.H:1839
REMORA::vec_sstore
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_sstore
additional scratch space for calculations on temp, salt, etc
Definition REMORA.H:612
REMORA::vec_xv
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_xv
x_grid on v-points (2D)
Definition REMORA.H:590
REMORA::WriteAtIntermediateTime
void WriteAtIntermediateTime(int step, amrex::Real cur_time)
Write checkpoint and plotfiles at intermediate point of simulation, if needed.
Definition REMORA.cpp:348
REMORA::init_only
void init_only(int lev, amrex::Real time)
Init (NOT restart or regrid)
Definition REMORA.cpp:1320
REMORA::init_set_vmix
void init_set_vmix(int lev)
Initialize vertical mixing coefficients from file or analytic.
Definition REMORA.cpp:825
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=zero)
Fill boundary data from netcdf file.
Definition REMORA_BoundaryConditions_netcdf.cpp:20
REMORA::EvolveOneStep
amrex::Real EvolveOneStep(amrex::Real time, amrex::Real dt_request)
Definition REMORA_Coupling.cpp:219
REMORA::v_clim_data_from_file
std::unique_ptr< NCTimeSeries > v_clim_data_from_file
Data container for v-velocity climatology data read from file.
Definition REMORA.H:1476
REMORA::clim_u_time_varname
std::string clim_u_time_varname
Name of time field for u climatology data.
Definition REMORA.H:1816
REMORA::rhs_uv_3d
void rhs_uv_3d(int lev, const amrex::Box &xbx, const amrex::Box &ybx, const amrex::Array4< amrex::Real const > &uold, const amrex::Array4< amrex::Real const > &vold, const amrex::Array4< amrex::Real > &ru, const amrex::Array4< amrex::Real > &rv, const amrex::Array4< amrex::Real > &rufrc, const amrex::Array4< amrex::Real > &rvfrc, const amrex::Array4< amrex::Real const > &sustr, const amrex::Array4< amrex::Real const > &svstr, const amrex::Array4< amrex::Real const > &bustr, const amrex::Array4< amrex::Real const > &bvstr, const amrex::Array4< amrex::Real const > &Huon, const amrex::Array4< amrex::Real const > &Hvom, const amrex::Array4< amrex::Real const > &pm, const amrex::Array4< amrex::Real const > &pn, const amrex::Array4< amrex::Real const > &W, const amrex::Array4< amrex::Real > &FC, int nrhs, int N)
RHS terms for 3D momentum.
Definition REMORA_rhs_uv_3d.cpp:29
REMORA::set_grid_scale
void set_grid_scale(int lev)
Set pm and pn arrays and x/y coords on level lev.
Definition REMORA_make_new_level.cpp:809
REMORA::set_coriolis
void set_coriolis(int lev)
Initialize Coriolis factor from file or analytic.
Definition REMORA.cpp:796
REMORA::foextrap_bc
int foextrap_bc() const noexcept
Definition REMORA.H:1321
REMORA::vec_Lscale
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_Lscale
Vertical mixing turbulent length scale.
Definition REMORA.H:636
REMORA::DriverAtmosForcingMode
DriverAtmosForcingMode
Definition REMORA.H:93
REMORA::FPr_u
amrex::Vector< REMORAFillPatcher > FPr_u
Vector over levels of FillPatchers for u (3D)
Definition REMORA.H:1511
REMORA::clim_nudg_momentum_box
static amrex::Box clim_nudg_momentum_box(const amrex::Box &nodal_bx, int dir, const amrex::Box &domain, bool is_periodic)
Shrink an x- or y-nodal momentum tilebox to the faces ROMS nudges.
Definition REMORA_apply_clim_nudg.cpp:52
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:1549
REMORA::prestep_diffusion
void prestep_diffusion(const amrex::Box &bx, const amrex::Box &gbx, const int ioff, const int joff, const amrex::Array4< amrex::Real > &vel, const amrex::Array4< amrex::Real const > &vel_old, const amrex::Array4< amrex::Real > &rvel, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &Akv, const amrex::Array4< amrex::Real > &FC, const amrex::Array4< amrex::Real const > &sstr, const amrex::Array4< amrex::Real const > &bstr, const amrex::Array4< amrex::Real const > &z_r, const amrex::Array4< amrex::Real const > &pm, const amrex::Array4< amrex::Real const > &pn, const int iic, const int ntfirst, const int nnew, int nstp, int nrhs, int N, const amrex::Real lambda, const amrex::Real dt_lev)
Update velocities or tracers with diffusion/viscosity as the last part of the prestep.
Definition REMORA_prestep_diffusion.cpp:38
REMORA::vert_mean_3d
void vert_mean_3d(const amrex::Box &bx, const int ioff, const int joff, const amrex::Array4< amrex::Real > &phi, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &Dphi_avg1, const amrex::Array4< amrex::Real > &DC, const amrex::Array4< amrex::Real > &CF, const amrex::Array4< amrex::Real const > &pm_or_pn, const amrex::Array4< amrex::Real const > &msk, const int nnew, const int N)
Adjust 3D momentum variables based on vertical mean momentum.
Definition REMORA_vert_mean_3d.cpp:19
REMORA::ref_tags
static amrex::Vector< amrex::AMRErrorTag > ref_tags
Holds info for dynamically generated tagging criteria.
Definition REMORA.H:1831
REMORA::vec_Hz
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_Hz
Width of cells in the vertical (z-) direction (3D, Hz in ROMS)
Definition REMORA.H:412
REMORA::vec_Akt
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_Akt
Vertical diffusion coefficient (3D)
Definition REMORA.H:432
REMORA::vec_msku
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_msku
land/sea mask at x-faces (2D)
Definition REMORA.H:559
REMORA::river_source_transportbar
std::unique_ptr< NCTimeSeriesRiver > river_source_transportbar
Data container for vertically integrated momentum transport in rivers.
Definition REMORA.H:1487
REMORA::driver_atmos_state_from_driver
std::array< bool, AtmosState::NumTypes > driver_atmos_state_from_driver
provenance flags for driver-supplied atmospheric forcing lanes
Definition REMORA.H:512
REMORA::vec_rvfrc
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_rvfrc
v velocity RHS, integrated, including advection and bottom/surface stresses (2D)
Definition REMORA.H:428
REMORA::v2d_simple_bc
int v2d_simple_bc() const noexcept
Definition REMORA.H:1323
REMORA::extrapolate_metric_to_physical_boundaries
void extrapolate_metric_to_physical_boundaries(amrex::MultiFab &mf, const amrex::Geometry &geom)
Extrapolate grid metrics to edge of MultiFab.
Definition REMORA_init_from_netcdf.cpp:1205
REMORA::GetAtmosToOceanPsiCoordinates
void GetAtmosToOceanPsiCoordinates(const amrex::MultiFab *&x_psi, const amrex::MultiFab *&y_psi) const
Definition REMORA_Coupling.cpp:336
REMORA::clim_ubar_time_varname
std::string clim_ubar_time_varname
Name of time field for ubar climatology data.
Definition REMORA.H:1812
REMORA::u_clim_data_from_file
std::unique_ptr< NCTimeSeries > u_clim_data_from_file
Data container for u-velocity climatology data read from file.
Definition REMORA.H:1474
REMORA::check_file
std::string check_file
Checkpoint file prefix.
Definition REMORA.H:1691
REMORA::startCPUTime
static amrex::Real startCPUTime
Variable for CPU timing.
Definition REMORA.H:1880
REMORA::vec_pm_full_domain
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_pm_full_domain
horizontal scaling factor: 1 / dx (2D) on whole domain
Definition REMORA.H:572
REMORA::xvel_old
amrex::Vector< amrex::MultiFab * > xvel_old
multilevel data container for last step's x velocities (u in ROMS)
Definition REMORA.H:379
REMORA::start_time
amrex::Real start_time
Time of the start of the simulation, in seconds.
Definition REMORA.H:1627
REMORA::init_scalars_full_domain_from_netcdf
void init_scalars_full_domain_from_netcdf()
Full-domain high-res passive (dye) scalar initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:358
REMORA::init_data_from_netcdf
void init_data_from_netcdf(int lev)
Problem initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:148
REMORA::init_masks_from_netcdf
void init_masks_from_netcdf(int lev)
Mask data initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:747
REMORA::yvel_new
amrex::Vector< amrex::MultiFab * > yvel_new
multilevel data container for current step's y velocities (v in ROMS)
Definition REMORA.H:390
REMORA::vec_uwind
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_uwind
Wind in the u direction, defined at rho-points.
Definition REMORA.H:472
REMORA::vec_rufrc
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_rufrc
u velocity RHS, integrated, including advection and bottom/surface stresses (2D)
Definition REMORA.H:426
REMORA::plot_nodal_data
static bool plot_nodal_data
Whether to write nodal data (Nu_nd) to plotfiles.
Definition REMORA.H:1767
REMORA::regrid_int
int regrid_int
how often each level regrids the higher levels of refinement (after a level advances that many time s...
Definition REMORA.H:1681
REMORA::check_int_time
amrex::Real check_int_time
Checkpoint output interval in seconds.
Definition REMORA.H:1695
REMORA::nc_hires_init_box
amrex::Box nc_hires_init_box
Box for the full domain at nc_hires_init_level.
Definition REMORA.H:1791
REMORA::driver_atmos_forcing_mode
DriverAtmosForcingMode driver_atmos_forcing_mode
Active atmosphere-to-ocean forcing contract on the most recent driver apply.
Definition REMORA.H:518
REMORA::bdy_time_interval
amrex::Real bdy_time_interval
Interval between boundary data times.
Definition REMORA.H:1439
REMORA::gls_prestep
void gls_prestep(int lev, amrex::MultiFab *mf_gls, amrex::MultiFab *mf_tke, amrex::MultiFab &mf_W, amrex::MultiFab *mf_msku, amrex::MultiFab *mf_mskv, const int nstp, const int nnew, const int iic, const int ntfirst, const int N, const amrex::Real dt_lev)
Prestep for GLS calculation.
Definition REMORA_gls.cpp:20
REMORA::init_scalar_metadata
void init_scalar_metadata()
Build runtime scalar names after nscalar is known.
Definition REMORA.cpp:249
REMORA::start_bdy_time
amrex::Real start_bdy_time
Start time in the time series of boundary data.
Definition REMORA.H:1437
REMORA::zeta_bc
int zeta_bc() const noexcept
Definition REMORA.H:1318
REMORA::phys_bc_type
amrex::Vector< amrex::GpuArray< REMORA_BC, AMREX_SPACEDIM *2 > > phys_bc_type
Array holding the "physical" boundary condition types (e.g. "inflow")
Definition REMORA.H:1589
REMORA::vec_weight2
amrex::Vector< amrex::Real > vec_weight2
Weights for calculating avg2 in 2D advance.
Definition REMORA.H:628
REMORA::bdy_index
amrex::Vector< int > bdy_index
Container to connect boundary data being read in boundary condition containers.
Definition REMORA.H:1602
REMORA::s_r
amrex::Gpu::DeviceVector< amrex::Real > s_r
Scaled vertical coordinate (range [0,1]) that transforms to z, defined at rho points (cell centers)
Definition REMORA.H:446
REMORA::Define_REMORAFillPatchers
void Define_REMORAFillPatchers(int lev)
Define FillPatchers.
Definition REMORA.cpp:571
REMORA::num_bdy_vars
int num_bdy_vars() const noexcept
Definition REMORA.H:1332
REMORA::cum_ref_ratios
amrex::Vector< amrex::IntVect > cum_ref_ratios
Cumulative refinement ratio between level 0 and level i.
Definition REMORA.H:1794
REMORA::derived_names_3d
const amrex::Vector< std::string > derived_names_3d
Names of derived fields for 3d plotfile fields.
Definition REMORA.H:1712
REMORA::vec_shflx
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_shflx
sensible heat flux
Definition REMORA.H:491
REMORA::vec_visc2_p
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_visc2_p
Harmonic viscosity defined on the psi points (corners of horizontal grid cells)
Definition REMORA.H:434
REMORA::set_drag
void set_drag(int lev)
Initialize or calculate bottom drag.
REMORA::build_fine_mask
amrex::MultiFab & build_fine_mask(int lev)
Make mask to zero out covered cells (for mesh refinement)
Definition REMORA_SumIQ.cpp:245
REMORA::plot_int_time
amrex::Real plot_int_time
Plotfile output interval in seconds.
Definition REMORA.H:1689
REMORA::vec_dmde
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_dmde
d(1/m)/d(eta)
Definition REMORA.H:609
REMORA::vec_rvbar
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_rvbar
barotropic y velocity for the RHS (2D)
Definition REMORA.H:543
REMORA::num_files_at_level
amrex::Vector< int > num_files_at_level
how many netcdf input files specified at each level
Definition REMORA.H:1547
REMORA::advance_2d_onestep
void advance_2d_onestep(int lev, amrex::Real dt_lev, amrex::Real dtfast_lev, int my_iif, int nfast_counter)
2D advance, one predictor/corrector step
Definition REMORA_advance_2d_onestep.cpp:12
REMORA::FPr_vbar
amrex::Vector< REMORAFillPatcher > FPr_vbar
Vector over levels of FillPatchers for vbar (2D)
Definition REMORA.H:1521
REMORA::AverageDownTo
void AverageDownTo(int crse_lev)
more flexible version of AverageDown() that lets you average down across multiple levels
Definition REMORA.cpp:2051
REMORA::steps_per_history_file
int steps_per_history_file
Time steps per netcdf history file. Must be > 0 if chunk_history_file.
Definition REMORA.H:1700
REMORA::post_timestep
void post_timestep(int nstep, amrex::Real time, amrex::Real dt_lev)
Called after every level 0 timestep.
Definition REMORA.cpp:373
REMORA::max_step
int max_step
maximum number of steps
Definition REMORA.H:1620
REMORA::zvel_old
amrex::Vector< amrex::MultiFab * > zvel_old
multilevel data container for last step's z velocities (largely unused; W stored separately)
Definition REMORA.H:383
REMORA::svstr_data_from_file
std::unique_ptr< NCTimeSeries > svstr_data_from_file
Data container for v-component surface momentum flux read from file.
Definition REMORA.H:1447
REMORA::vec_z_r
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_z_r
z coordinates at rho points (cell centers)
Definition REMORA.H:441
REMORA::nc_frc_file
amrex::Vector< std::string > nc_frc_file
NetCDF forcing file(s)
Definition REMORA.H:1797
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:1545
REMORA::xvel_new
amrex::Vector< amrex::MultiFab * > xvel_new
multilevel data container for current step's x velocities (u in ROMS)
Definition REMORA.H:388
REMORA::vec_lhflx
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_lhflx
latent heat flux
Definition REMORA.H:489
REMORA::refinement_criteria_setup
void refinement_criteria_setup()
Set refinement criteria.
Definition REMORA_Tagging.cpp:277
REMORA::u2d_simple_bc
int u2d_simple_bc() const noexcept
Definition REMORA.H:1322
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=false)
Fill a new MultiFab by copying in phi from valid region and filling ghost cells without applying boun...
Definition REMORA_FillPatch.cpp:199
REMORA::init_scalars_from_netcdf
void init_scalars_from_netcdf(int lev)
Passive (dye) scalar initialization from NetCDF file. Called from init_data_from_netcdf: dye follows ...
Definition REMORA_init_from_netcdf.cpp:211
REMORA::vec_mskp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_mskp
land/sea mask at cell corners (2D)
Definition REMORA.H:563
REMORA::remora_advance
void remora_advance(int level, amrex::MultiFab &cons_old, amrex::MultiFab &cons_new, amrex::MultiFab &xvel_old, amrex::MultiFab &yvel_old, amrex::MultiFab &zvel_old, amrex::MultiFab &xvel_new, amrex::MultiFab &yvel_new, amrex::MultiFab &zvel_new, amrex::MultiFab &source, const amrex::Geometry fine_geom, const amrex::Real dt, const amrex::Real time)
Interface for advancing the data at one level by one "slow" timestep.
REMORA::Bio_comp
int Bio_comp
First cons component of the biology block, i.e. Tracer_comp + nscalar. The state is laid out as temp,...
Definition REMORA.H:1641
REMORA::last_check_file_step
int last_check_file_step
Step when we last output a checkpoint file.
Definition REMORA.H:1610
REMORA::bdy_zeta
int bdy_zeta() const noexcept
Definition REMORA.H:1331
REMORA::prestep
void prestep(int lev, amrex::MultiFab &mf_uold, amrex::MultiFab &mf_vold, amrex::MultiFab &mf_u, amrex::MultiFab &mf_v, amrex::MultiFab *mf_ru, amrex::MultiFab *mf_rv, amrex::MultiFab &S_old, amrex::MultiFab &S_new, amrex::MultiFab &mf_W, amrex::MultiFab &mf_DC, const amrex::MultiFab *mf_z_r, const amrex::MultiFab *mf_z_w, const amrex::MultiFab *mf_h, const amrex::MultiFab *mf_pm, const amrex::MultiFab *mf_pn, const amrex::MultiFab *mf_sustr, const amrex::MultiFab *mf_svstr, const amrex::MultiFab *mf_bustr, const amrex::MultiFab *mf_bvstr, const amrex::MultiFab *mf_msku, const amrex::MultiFab *mf_mskv, const int iic, const int nfirst, const int nnew, int nstp, int nrhs, int N, const amrex::Real dt_lev)
Wrapper function for prestep.
Definition REMORA_prestep.cpp:38
REMORA::init_beta_plane_coriolis
void init_beta_plane_coriolis(int lev)
Calculate Coriolis parameters from beta plane parametrization.
Definition REMORA_init.cpp:112
REMORA::clim_vbar_time_varname
std::string clim_vbar_time_varname
Name of time field for vbar climatology data.
Definition REMORA.H:1814
REMORA::vec_bvf
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_bvf
Brunt-Vaisala frequency (3D)
Definition REMORA.H:619
REMORA::RemakeLevel
virtual void RemakeLevel(int lev, amrex::Real time, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm) override
Remake an existing level using provided BoxArray and DistributionMapping and fill with existing fine ...
Definition REMORA_make_new_level.cpp:166
REMORA::vec_lonp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_lonp
longitude on psi-points (2D, degrees east); only filled when the grid NetCDF file carries lon_psi
Definition REMORA.H:601
REMORA::vec_mskv
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_mskv
land/sea mask at y-faces (2D)
Definition REMORA.H:561
REMORA::init_masks
void init_masks(int lev, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm)
Allocate MultiFabs for masks.
Definition REMORA_make_new_level.cpp:542
REMORA::nsubsteps
amrex::Vector< int > nsubsteps
How many substeps on each level?
Definition REMORA.H:1554
REMORA::physbcs
amrex::Vector< std::unique_ptr< REMORAPhysBCFunct > > physbcs
Vector (over level) of functors to apply physical boundary conditions.
Definition REMORA.H:1566
REMORA::ComputeDt
void ComputeDt()
a wrapper for estTimeStep()
Definition REMORA_ComputeTimestep.cpp:8
REMORA::fill_3d_masks
void fill_3d_masks(int lev)
Copy maskr to all z levels.
Definition REMORA_make_new_level.cpp:1051
REMORA::writeBuildInfo
static void writeBuildInfo(std::ostream &os)
Write build info to os.
Definition REMORA_writeJobInfo.cpp:135
REMORA::EminusP_data_from_file
std::unique_ptr< NCTimeSeries > EminusP_data_from_file
Data container for evaporation minus precipitation read from file.
Definition REMORA.H:1467
REMORA::FillCoarsePatch
void FillCoarsePatch(int lev, amrex::Real time, amrex::MultiFab *mf_fine, amrex::MultiFab *mf_crse, const int bccomp, const int bdy_var_type=BdyVars::null, const int icomp=0, const bool fill_all=true, const int n_not_fill=0, const int icomp_calc=0, const amrex::Real dt=zero, const amrex::MultiFab &mf_calc=amrex::MultiFab())
fill an entire multifab by interpolating from the coarser level
Definition REMORA_FillPatch.cpp:411
REMORA::ErrorEst
virtual void ErrorEst(int lev, amrex::TagBoxArray &tags, amrex::Real time, int ngrow) override
Tag cells for refinement.
Definition REMORA_Tagging.cpp:97
REMORA::plot_int
int plot_int
Plotfile output interval in iterations.
Definition REMORA.H:1687
REMORA::cloud_data_from_file
std::unique_ptr< NCTimeSeries > cloud_data_from_file
Data container for cloud cover fraction read from file.
Definition REMORA.H:1465
REMORA::getCPUTime
amrex::Real getCPUTime() const
Get CPU time used.
Definition REMORA.H:1886
REMORA::nbio
int nbio
Number of biology tracers, set by the active biology model. Zero when no biology model is active.
Definition REMORA.H:1638
REMORA::WriteAtFinalTime
void WriteAtFinalTime()
Write checkpoint and plotfiles at end of simulation.
Definition REMORA.cpp:333
REMORA::InitData
void InitData()
Initialize multilevel data.
Definition REMORA.cpp:405
REMORA::set3DPlotVariables
void set3DPlotVariables(const std::string &pp_plot_var_names_3d)
Definition REMORA_SetPlotVars.cpp:16
REMORA::istep
amrex::Vector< int > istep
which step?
Definition REMORA.H:1552
REMORA::uv3dmix
void uv3dmix(const amrex::Box &xbx, const amrex::Box &ybx, const amrex::Array4< amrex::Real > &u, const amrex::Array4< amrex::Real > &v, const amrex::Array4< amrex::Real const > &uold, const amrex::Array4< amrex::Real const > &vold, const amrex::Array4< amrex::Real > &rufrc, const amrex::Array4< amrex::Real > &rvfrc, const amrex::Array4< amrex::Real const > &visc2_p, const amrex::Array4< amrex::Real const > &visc2_r, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &pm, const amrex::Array4< amrex::Real const > &pn, const amrex::Array4< amrex::Real const > &mskp, int nrhs, int nnew, const amrex::Real dt_lev)
Harmonic viscosity.
Definition REMORA_uv3dmix.cpp:25
REMORA::WriteCheckpointFile
void WriteCheckpointFile()
write checkpoint file to disk
Definition REMORA_Checkpoint.cpp:15
REMORA::nc_clim_coeff_file
std::string nc_clim_coeff_file
NetCDF climatology coefficient file.
Definition REMORA.H:1804
REMORA::lin_eos
void lin_eos(const amrex::Box &bx, const amrex::Array4< amrex::Real const > &state, const amrex::Array4< amrex::Real > &rho, const amrex::Array4< amrex::Real > &rhoA, const amrex::Array4< amrex::Real > &rhoS, const amrex::Array4< amrex::Real > &bvf, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &z_w, const amrex::Array4< amrex::Real const > &z_r, const amrex::Array4< amrex::Real const > &h, const amrex::Array4< amrex::Real const > &mskr, const int N)
Calculate density and related quantities from linear equation of state.
Definition REMORA_rho_eos.cpp:61
REMORA::setRecordDataInfo
void setRecordDataInfo(int i, const std::string &filename)
Definition REMORA.H:1900
REMORA::advance_3d_ml
void advance_3d_ml(int lev, amrex::Real dt_lev)
3D advance on a single level
Definition REMORA_advance_3d_ml.cpp:9
REMORA::DataLogName
const std::string DataLogName(int i) const noexcept
The filename of the ith datalog file.
Definition REMORA.H:1917
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:670
REMORA::set_analytic_vmix
void set_analytic_vmix(int lev)
Set vertical mixing coefficients from analytic.
Definition REMORA.cpp:842
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:992
REMORA::vec_rhoS
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_rhoS
density perturbation
Definition REMORA.H:615
REMORA::bdry_time_name_byvar
amrex::Vector< std::string > bdry_time_name_byvar
Name of time fields for boundary data.
Definition REMORA.H:1809
REMORA::rhs_uv_2d
void rhs_uv_2d(int lev, const amrex::Box &xbx, const amrex::Box &ybx, const amrex::Array4< amrex::Real const > &uold, const amrex::Array4< amrex::Real const > &vold, const amrex::Array4< amrex::Real > &ru, const amrex::Array4< amrex::Real > &rv, const amrex::Array4< amrex::Real const > &Duon, const amrex::Array4< amrex::Real const > &Dvom, const int nrhs)
RHS terms for 2D momentum.
Definition REMORA_rhs_uv_2d.cpp:18
REMORA::file_min_digits
static int file_min_digits
Minimum number of digits in plotfile name or chunked history file.
Definition REMORA.H:1761
REMORA::init_riv_pos_from_netcdf
void init_riv_pos_from_netcdf(int lev)
Definition REMORA_init_from_netcdf.cpp:1011
REMORA::nc_bdry_file
static amrex::Vector< std::string > nc_bdry_file
NetCDF boundary data.
Definition REMORA.H:57
REMORA::vec_visc2_r
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_visc2_r
Harmonic viscosity defined on the rho points (centers)
Definition REMORA.H:436
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:983
REMORA::vec_yvel_full_domain
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_yvel_full_domain
multilevel data container for high res initial y velocities (v in ROMS)
Definition REMORA.H:399
REMORA::vec_svstr
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_svstr
Surface stress in the v direction.
Definition REMORA.H:469
REMORA::srflx_data_from_file
std::unique_ptr< NCTimeSeries > srflx_data_from_file
Data container for shortwave radiation flux read from file.
Definition REMORA.H:1459
REMORA::vec_Huon
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_Huon
u-volume flux (3D)
Definition REMORA.H:414
REMORA::REMORA
REMORA()
Definition REMORA.cpp:68
REMORA::FillBdyCCVels
void FillBdyCCVels(int lev, amrex::MultiFab &mf_cc_vel)
Fill the physical boundary conditions for cell-centered velocity (diagnostic only)
Definition REMORA_FillPatch.cpp:626
REMORA::set_zeta
void set_zeta(int lev)
Initialize zeta from file or analytic.
Definition REMORA.cpp:635
REMORA::change_max
static amrex::Real change_max
Fraction maximum change in subsequent time steps.
Definition REMORA.H:1669
REMORA::calc_stretch_coeffs
void calc_stretch_coeffs()
calculate vertical stretch coefficients
Definition REMORA_DepthStretchTransform.H:12
REMORA::num_bio
int num_bio() const noexcept
Number of biology tracers carried in the state.
Definition REMORA.H:1939
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:436
REMORA::set_zeta_average
void set_zeta_average(int lev)
Set Zt_avg1 to zeta.
Definition REMORA_init.cpp:148
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:712
REMORA::print_usage
static void print_usage(MPI_Comm, std::ostream &)
Definition REMORA_console_io.cpp:26
REMORA::pp_prefix
std::string pp_prefix
default prefix for input file parameters
Definition REMORA.H:374
REMORA::GetDeckConfiguredAtmosStateLanes
void GetDeckConfiguredAtmosStateLanes(std::array< bool, AtmosState::NumTypes > &deck_configured) const
Definition REMORA_Coupling.cpp:269
REMORA::vec_h_full_domain
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_h_full_domain
Bathymetry data on the whole domain at each potential level.
Definition REMORA.H:409
REMORA::set_bathymetry
void set_bathymetry(int lev)
Initialize bathymetry from file or analytic.
Definition REMORA.cpp:674
REMORA::yvel_old
amrex::Vector< amrex::MultiFab * > yvel_old
multilevel data container for last step's y velocities (v in ROMS)
Definition REMORA.H:381
REMORA::ubar_clim_data_from_file
std::unique_ptr< NCTimeSeries > ubar_clim_data_from_file
Data container for ubar climatology data read from file.
Definition REMORA.H:1470
REMORA::init_stuff
void init_stuff(int lev, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm)
Allocate MultiFabs for state and evolution variables.
Definition REMORA_make_new_level.cpp:570
REMORA::init_full_domain_from_analytic
void init_full_domain_from_analytic()
Initialize high resolution initial problem data from analytic functions.
Definition REMORA_init.cpp:410
REMORA::GetDataAtTime
TimeInterpolatedData GetDataAtTime(int lev, amrex::Real time)
utility to copy in data from old and/or new state into another multifab
Definition REMORA_FillPatch.cpp:303
REMORA::Advance
void Advance(int lev, amrex::Real time, amrex::Real dt_lev, int iteration, int ncycle)
advance a single level for a single time step
Definition REMORA_Advance.cpp:17
REMORA::init_data_full_domain_from_netcdf
void init_data_full_domain_from_netcdf()
High resolution roblem initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:294
REMORA::vec_rhoA
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_rhoA
vertically-averaged density
Definition REMORA.H:617
REMORA::vec_DV_avg1
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_DV_avg1
time average of barotropic y velocity flux
Definition REMORA.H:537
REMORA::FPr_c
amrex::Vector< REMORAFillPatcher > FPr_c
Vector over levels of FillPatchers for scalars.
Definition REMORA.H:1509
REMORA::hires_init_level
int hires_init_level
Which level the high resolution initialization data is at.
Definition REMORA.H:1787
REMORA::WriteNCPlotFile
void WriteNCPlotFile(int istep, amrex::MultiFab const *plotMF)
Write plotfile using NetCDF (wrapper)
Definition REMORA_NCPlotFile.cpp:170
REMORA::clim_cons_time_varname
amrex::Vector< std::string > clim_cons_time_varname
Vector over cons components of the name of the time field for that tracer's climatology data.
Definition REMORA.H:1821
REMORA::Tair_data_from_file
std::unique_ptr< NCTimeSeries > Tair_data_from_file
Data container for air temperature read from file.
Definition REMORA.H:1453
REMORA::bdy_vbar
int bdy_vbar() const noexcept
Definition REMORA.H:1330
REMORA::rhs_t_3d
void rhs_t_3d(int lev, const amrex::Box &bx, const amrex::Array4< amrex::Real > &t, const amrex::Array4< amrex::Real const > &tempstore, const amrex::Array4< amrex::Real const > &Huon, const amrex::Array4< amrex::Real const > &Hvom, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &pn, const amrex::Array4< amrex::Real const > &pm, const amrex::Array4< amrex::Real const > &W, const amrex::Array4< amrex::Real > &FC, const amrex::Array4< amrex::Real const > &mskr, const amrex::Array4< amrex::Real const > &msku, const amrex::Array4< amrex::Real const > &mskv, const amrex::Array4< int const > &river_pos, const amrex::Array4< amrex::Real const > &river_source, int nrhs, int nnew, int N, const amrex::Real dt_lev)
RHS terms for tracer.
Definition REMORA_rhs_t_3d.cpp:28
REMORA::bulk_psiu
AMREX_GPU_HOST_DEVICE static AMREX_FORCE_INLINE amrex::Real bulk_psiu(amrex::Real ZoL)
Evaluate stability function psi for wind speed.
Definition REMORA.H:1945
REMORA::apply_clim_nudg
void apply_clim_nudg(const amrex::Box &bx, int ioff, int joff, const amrex::Array4< amrex::Real > &var, const amrex::Array4< amrex::Real const > &var_old, const amrex::Array4< amrex::Real const > &var_clim, const amrex::Array4< amrex::Real const > &clim_coeff, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &pm, const amrex::Array4< amrex::Real const > &pn, const amrex::Real dt_lev=zero)
Apply climatology nudging.
Definition REMORA_apply_clim_nudg.cpp:19
REMORA::print_banner
static void print_banner(MPI_Comm, std::ostream &)
Definition REMORA_console_io.cpp:60
REMORA::nscalar
int nscalar
Number of passive (dye) scalars carried in the state, beyond temperature and salinity....
Definition REMORA.H:1635
REMORA::clim_v_time_varname
std::string clim_v_time_varname
Name of time field for v climatology data.
Definition REMORA.H:1818
REMORA::scale_rhs_vars_inv
void scale_rhs_vars_inv()
Scale RHS momentum variables by cell area, needed after FillPatch to different levels.
Definition REMORA_scale_rhs_vars.cpp:55
REMORA::FPr_w
amrex::Vector< REMORAFillPatcher > FPr_w
Vector over levels of FillPatchers for w.
Definition REMORA.H:1515
REMORA::average_down_with_grow_cells
void average_down_with_grow_cells(int lev, amrex::Vector< std::unique_ptr< amrex::MultiFab > > &mf)
Average down from level lev+1 to lev in mf, including grow cells.
Definition REMORA.cpp:2079
REMORA::Cs_r
amrex::Gpu::DeviceVector< amrex::Real > Cs_r
Stretching coefficients at rho points.
Definition REMORA.H:456
REMORA::Uwind_data_from_file
std::unique_ptr< NCTimeSeries > Uwind_data_from_file
Data container for u-direction wind read from file.
Definition REMORA.H:1449
REMORA::Pair_data_from_file
std::unique_ptr< NCTimeSeries > Pair_data_from_file
Data container for air pressure read from file.
Definition REMORA.H:1457
REMORA::t_new
amrex::Vector< amrex::Real > t_new
new time at each level
Definition REMORA.H:1556
REMORA::init_stretch_coeffs
void init_stretch_coeffs()
initialize and calculate stretch coefficients
Definition REMORA_init.cpp:310
REMORA::init_bdry_from_netcdf
void init_bdry_from_netcdf(int lev)
Boundary data initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:794
REMORA::solverChoice
static SolverChoice solverChoice
Container for algorithmic choices.
Definition REMORA.H:1717
REMORA::ApplyAtmosphericStates
void ApplyAtmosphericStates(const amrex::Vector< amrex::MultiFab * > &states, amrex::Real time)
Receives atmospheric states from the driver and applies unit conversions.
Definition REMORA_Coupling.cpp:426
REMORA::set_grid_coords_from_grid_scale
void set_grid_coords_from_grid_scale(int lev)
Set x/y coords on level lev based on pm and pn.
Definition REMORA_make_new_level.cpp:864
REMORA::resize_stuff
void resize_stuff(int lev)
Resize variable containers to accommodate data on levels 0 to max_lev.
Definition REMORA_make_new_level.cpp:419
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:1494
REMORA::vec_Akk
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_Akk
Turbulent kinetic energy vertical diffusion coefficient.
Definition REMORA.H:638
REMORA::set_masks
void set_masks(int lev)
Initialize land-sea masks from file or analytic.
Definition REMORA.cpp:860
REMORA::vec_rdrag2
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_rdrag2
Quadratic drag coefficient [unitless], defined at rho points.
Definition REMORA.H:523
REMORA::set_zeta_to_Ztavg
void set_zeta_to_Ztavg(int lev, bool apply_eminusp=true)
Set zeta components to be equal to time-averaged Zt_avg1.
Definition REMORA_make_new_level.cpp:931
REMORA::SetLongwaveFromDriver
void SetLongwaveFromDriver()
Definition REMORA_Coupling.cpp:258
REMORA::driver_uses_two_way_coupling
bool driver_uses_two_way_coupling
Driver-level direction flag copied in before InitData.
Definition REMORA.H:516
REMORA::boundary_series
amrex::Vector< amrex::Vector< std::unique_ptr< NCTimeSeriesBoundary > > > boundary_series
Vector over BdyVars of boundary series data containers.
Definition REMORA.H:1490
REMORA::cf_set_width
int cf_set_width
Width for fixing values at coarse-fine interface.
Definition REMORA.H:1506
REMORA::biology_debug_j
int biology_debug_j
Target column j index for biology_debug = 1.
Definition REMORA.H:1663
REMORA::ReadParameters
void ReadParameters()
read in some parameters from inputs file
Definition REMORA.cpp:1654
REMORA::print_tpls
static void print_tpls(std::ostream &)
Definition REMORA_console_io.cpp:137
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:835
REMORA::vert_visc_3d
void vert_visc_3d(const amrex::Box &bx, const int ioff, const int joff, const amrex::Array4< amrex::Real > &phi, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real > &Hzk, const amrex::Array4< amrex::Real > &AK, const amrex::Array4< amrex::Real const > &Akv, const amrex::Array4< amrex::Real > &BC, const amrex::Array4< amrex::Real > &DC, const amrex::Array4< amrex::Real > &FC, const amrex::Array4< amrex::Real > &CF, const int nnew, const int N, const amrex::Real dt_lev)
Calculate effects of vertical viscosity or diffusivity.
Definition REMORA_vert_visc_3d.cpp:23
REMORA::vec_ru
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_ru
u velocity RHS (3D, includes horizontal and vertical advection)
Definition REMORA.H:418
REMORA::sum_integrated_quantities
void sum_integrated_quantities(amrex::Real time)
Integrate conserved quantities for diagnostics.
Definition REMORA_SumIQ.cpp:11
REMORA::total_nc_plot_file_step
static int total_nc_plot_file_step
Definition REMORA.H:1345
REMORA::vec_weight1
amrex::Vector< amrex::Real > vec_weight1
Weights for calculating avg1 in 2D advance.
Definition REMORA.H:626
REMORA::bdy_ubar
int bdy_ubar() const noexcept
Definition REMORA.H:1329
REMORA::vec_xp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_xp
x_grid on psi-points (2D)
Definition REMORA.H:595
REMORA::advance_biology
void advance_biology(int lev, amrex::MultiFab const &mf_cons_old, amrex::MultiFab &mf_cons_new, int N, amrex::Real dt_lev)
Apply biological tracer source/sink terms.
Definition REMORA_Biology.cpp:494
REMORA::nc_grid_file
static amrex::Vector< amrex::Vector< std::string > > nc_grid_file
NetCDF grid file.
Definition REMORA.H:59
REMORA::vec_longwave_down
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_longwave_down
Downward longwave radiation.
Definition REMORA.H:487
REMORA::vec_zeta
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_zeta
free surface height (2D)
Definition REMORA.H:551
REMORA::ubar_bc
int ubar_bc() const noexcept
Definition REMORA.H:1316
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:1496
REMORA::vec_vbar
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_vbar
barotropic y velocity (2D)
Definition REMORA.H:549
REMORA::GetAtmosToOceanUFaceLayout
void GetAtmosToOceanUFaceLayout(amrex::BoxArray &ba, amrex::DistributionMapping &dm) const
Definition REMORA_Coupling.cpp:314
REMORA::ReadNCMultiFab
void ReadNCMultiFab(amrex::FabArray< amrex::FArrayBox > &fab, const std::string &name, int coordinatorProc=amrex::ParallelDescriptor::IOProcessorNumber(), int allow_empty_mf=0)
Read MultiFab in NetCDF format.
REMORA::nc_hires_grid_box
amrex::Box nc_hires_grid_box
Box for the full domain at nc_hires_grid_level.
Definition REMORA.H:1784
REMORA::FillCoarsePatchPC
void FillCoarsePatchPC(int lev, amrex::Real time, amrex::MultiFab *mf_fine, amrex::MultiFab *mf_crse, const int bccomp, const int bdy_var_type=BdyVars::null, const int icomp=0, const bool fill_all=true, const int n_not_fill=0, const int icomp_calc=0, const amrex::Real dt=zero, const amrex::MultiFab &mf_calc=amrex::MultiFab())
fill an entire multifab by interpolating from the coarser level using the piecewise constant interpol...
Definition REMORA_FillPatch.cpp:377
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:533
REMORA::Cs_w
amrex::Gpu::DeviceVector< amrex::Real > Cs_w
Stretching coefficients at w points.
Definition REMORA.H:458
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:1720
REMORA::advance_2d
void advance_2d(int lev, amrex::MultiFab const *mf_rhoS, amrex::MultiFab const *mf_rhoA, amrex::MultiFab *mf_ru2d, amrex::MultiFab *mf_rv2d, amrex::MultiFab *mf_rufrc, amrex::MultiFab *mf_rvfrc, amrex::MultiFab *mf_Zt_avg1, std::unique_ptr< amrex::MultiFab > &mf_DU_avg1, std::unique_ptr< amrex::MultiFab > &mf_DU_avg2, std::unique_ptr< amrex::MultiFab > &mf_DV_avg1, std::unique_ptr< amrex::MultiFab > &mf_DV_avg2, std::unique_ptr< amrex::MultiFab > &mf_rubar, std::unique_ptr< amrex::MultiFab > &mf_rvbar, std::unique_ptr< amrex::MultiFab > &mf_rzeta, std::unique_ptr< amrex::MultiFab > &mf_ubar, std::unique_ptr< amrex::MultiFab > &mf_vbar, amrex::MultiFab *mf_zeta, amrex::MultiFab const *mf_h, amrex::MultiFab const *mf_pm, amrex::MultiFab const *mf_pn, amrex::MultiFab const *mf_fcor, amrex::MultiFab const *mf_visc2_p, amrex::MultiFab const *mf_visc2_r, amrex::MultiFab const *mf_mskr, amrex::MultiFab const *mf_msku, amrex::MultiFab const *mf_mskv, amrex::MultiFab const *mf_mskp, amrex::Real dtfast_lev, bool predictor_2d_step, bool first_2d_step, int my_iif, int &next_indx1)
Perform a 2D predictor (predictor_2d_step=True) or corrector (predictor_2d_step=False) step.
Definition REMORA_advance_2d.cpp:44
REMORA::plot_file_on_restart
int plot_file_on_restart
Whether to output a plotfile on restart from checkpoint.
Definition REMORA.H:1614
REMORA::vec_alpha
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_alpha
Thermal expansion coefficient (3D)
Definition REMORA.H:621
REMORA::set_2darrays
void set_2darrays(int lev)
Set 2D momentum arrays from 3D momentum.
Definition REMORA_init.cpp:172
REMORA::SetDriverAtmosToOceanForcingMode
void SetDriverAtmosToOceanForcingMode(DriverAtmosForcingMode mode)
Definition REMORA_Coupling.cpp:297
REMORA::init_analytic
void init_analytic(int lev)
Initialize initial problem data from analytic functions.
Definition REMORA_init.cpp:15
REMORA::vec_ubar
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_ubar
barotropic x velocity (2D)
Definition REMORA.H:547
REMORA::InitializeLevelFromData
void InitializeLevelFromData(int lev, const amrex::MultiFab &initial_data)
Initialize the new-time data at a level from the initial_data MultiFab.
REMORA::cons_old
amrex::Vector< amrex::MultiFab * > cons_old
multilevel data container for last step's scalar data: temperature, salinity, passive tracer
Definition REMORA.H:377
REMORA::vec_bustr
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_bustr
Bottom stress in the u direction.
Definition REMORA.H:528
REMORA::NumDataLogs
AMREX_FORCE_INLINE int NumDataLogs() noexcept
Definition REMORA.H:1874
REMORA::volWgtSumMF
amrex::Real volWgtSumMF(int lev, const amrex::MultiFab &mf, int comp, bool local, bool finemask)
Perform the volume-weighted sum.
Definition REMORA_SumIQ.cpp:204
REMORA::frc_time_varname
std::string frc_time_varname
Name of time field for forcing data.
Definition REMORA.H:1825
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:927
REMORA::FPr_ubar
amrex::Vector< REMORAFillPatcher > FPr_ubar
Vector over levels of FillPatchers for ubar (2D)
Definition REMORA.H:1519
REMORA::is_it_time_for_action
bool is_it_time_for_action(int nstep, amrex::Real time, amrex::Real dt, int action_interval, amrex::Real action_per)
Decide if it is time to take an action.
Definition REMORA_SumIQ.cpp:280
REMORA::vec_cons_full_domain
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_cons_full_domain
multilevel data container for high res initial data: temperature, salinity, passive tracer
Definition REMORA.H:395
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=false, const int n_not_fill=0, const int icomp_calc=0, const amrex::Real dt=zero, 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::vbar_bc
int vbar_bc() const noexcept
Definition REMORA.H:1317
REMORA::Vwind_data_from_file
std::unique_ptr< NCTimeSeries > Vwind_data_from_file
Data container for v-direction wind read from file.
Definition REMORA.H:1451
REMORA::DriverUsesStateForcing
static constexpr bool DriverUsesStateForcing(DriverAtmosForcingMode mode) noexcept
Definition REMORA.H:98
REMORA::ndtfast
static int ndtfast
User specified, number of barotropic steps per baroclinic step.
Definition REMORA.H:1673
REMORA::PlotFileName
std::string PlotFileName(int lev) const
get plotfile name
REMORA::init_bathymetry_full_domain_from_netcdf
void init_bathymetry_full_domain_from_netcdf()
Full domain high-res bathymetry data initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:1120
REMORA::vec_DV_avg2
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_DV_avg2
correct time average of barotropic y velocity flux for coupling (2D)
Definition REMORA.H:539
REMORA::cons_clim_data_from_file
amrex::Vector< std::unique_ptr< NCTimeSeries > > cons_clim_data_from_file
Vector over cons components of climatology data read from file.
Definition REMORA.H:1480
REMORA::set_hmixcoef
void set_hmixcoef(int lev)
Initialize horizontal mixing coefficients.
Definition REMORA.cpp:886
REMORA::domain_bc_type
amrex::Array< std::string, 2 *AMREX_SPACEDIM > domain_bc_type
Array of strings describing domain boundary conditions.
Definition REMORA.H:1583
REMORA::river_source_cons
amrex::Vector< std::unique_ptr< NCTimeSeriesRiver > > river_source_cons
Vector of data containers for scalar data in rivers.
Definition REMORA.H:1483
REMORA::estTimeStep
amrex::Real estTimeStep(int lev) const
compute dt from CFL considerations
Definition REMORA_ComputeTimestep.cpp:69
REMORA::vec_yu
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_yu
y_grid on u-points (2D)
Definition REMORA.H:587
REMORA::WriteNCPlotFile_which
void WriteNCPlotFile_which(int lev, int which_subdomain, amrex::MultiFab const *plotMF, bool write_header, ncutils::NCFile &ncf, bool is_history)
Write a particular NetCDF plotfile.
Definition REMORA_NCPlotFile.cpp:255
REMORA::vec_dndx
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_dndx
d(1/n)/d(xi)
Definition REMORA.H:607
REMORA::vec_bvstr
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_bvstr
Bottom stress in the v direction.
Definition REMORA.H:530
REMORA::timeStep
void timeStep(int lev, amrex::Real time, int iteration)
advance a level by dt, includes a recursive call for finer levels
Definition REMORA_TimeStep.cpp:11
REMORA::vec_rzeta
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_rzeta
free surface height for the RHS (2D)
Definition REMORA.H:545
REMORA::river_source_transport
std::unique_ptr< NCTimeSeriesRiver > river_source_transport
Data container for momentum transport in rivers.
Definition REMORA.H:1485
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:461
REMORA::init_grid_vars_full_domain_from_netcdf
void init_grid_vars_full_domain_from_netcdf()
Full domain high-res grid variable initialization from NetCDF file.
Definition REMORA_init_from_netcdf.cpp:1146
REMORA::AverageDown
void AverageDown()
set covered coarse cells to be the average of overlying fine cells
Definition REMORA.cpp:2038
REMORA::netcdf_fill_value
amrex::Real netcdf_fill_value
fill value for masked arrays in netcdf output
Definition REMORA.H:1725
REMORA::bdy_cons
int bdy_cons(int icomp) const noexcept
Accessors for the ncons-dependent entries of BdyVars.
Definition REMORA.H:1328
REMORA::vec_xu
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_xu
x_grid on u-points (2D)
Definition REMORA.H:585
REMORA::vec_pn_full_domain
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_pn_full_domain
horizontal scaling factor: 1 / dy (2D) on whole domain
Definition REMORA.H:574
REMORA::timeStepML
void timeStepML(amrex::Real time, int iteration)
advance all levels by dt, loops over finer levels
Definition REMORA_TimeStepML.cpp:10
REMORA::vec_nudg_coeff
amrex::Vector< amrex::Vector< std::unique_ptr< amrex::MultiFab > > > vec_nudg_coeff
Climatology nudging coefficients.
Definition REMORA.H:643
REMORA::set_weights
void set_weights(int lev)
Set weights for averaging 3D variables to 2D.
Definition REMORA_set_weights.cpp:11
REMORA::prestep_t_advection
void prestep_t_advection(int lev, const amrex::Box &tbx, const amrex::Box &gbx, const amrex::Array4< amrex::Real > &tempold, const amrex::Array4< amrex::Real > &tempcache, const amrex::Array4< amrex::Real > &Hz, const amrex::Array4< amrex::Real > &Huon, const amrex::Array4< amrex::Real > &Hvom, const amrex::Array4< amrex::Real > &W, const amrex::Array4< amrex::Real > &DC, const amrex::Array4< amrex::Real > &FC, const amrex::Array4< amrex::Real > &sstore, const amrex::Array4< amrex::Real const > &z_w, const amrex::Array4< amrex::Real const > &h, const amrex::Array4< amrex::Real const > &pm, const amrex::Array4< amrex::Real const > &pn, const amrex::Array4< amrex::Real const > &msku, const amrex::Array4< amrex::Real const > &mskv, const amrex::Array4< int const > &river_pos, const amrex::Array4< amrex::Real const > &river_source, int iic, int ntfirst, int nrhs, int N, const amrex::Real dt_lev)
Prestep advection calculations for the tracers.
Definition REMORA_prestep_t_advection.cpp:35
REMORA::DataLog
AMREX_FORCE_INLINE std::ostream & DataLog(int i)
Helper function for IO stream.
Definition REMORA.H:1867
REMORA::vec_pn
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_pn
horizontal scaling factor: 1 / dy (2D)
Definition REMORA.H:570
REMORA::curvilinear
void curvilinear(const amrex::Box &bx, const amrex::Box &xbx, const amrex::Box &ybx, const amrex::Array4< amrex::Real const > &uold, const amrex::Array4< amrex::Real const > &vold, const amrex::Array4< amrex::Real > &ru, const amrex::Array4< amrex::Real > &rv, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &dndx, const amrex::Array4< amrex::Real const > &dmde, int nrhs, int nr)
Calculate curvilinear advection terms.
Definition REMORA_curvilinear.cpp:21
REMORA::datalog
amrex::Vector< std::unique_ptr< std::fstream > > datalog
Definition REMORA.H:1913
REMORA::vec_Akv
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_Akv
Vertical viscosity coefficient (3D)
Definition REMORA.H:430
REMORA::cfl
static amrex::Real cfl
CFL condition.
Definition REMORA.H:1667
REMORA::phys_bc_need_data
amrex::Vector< amrex::GpuArray< bool, AMREX_SPACEDIM *2 > > phys_bc_need_data
These are flags that indicate whether we need to read in boundary data from file.
Definition REMORA.H:1596
REMORA::append3DPlotVariables
void append3DPlotVariables(const std::string &pp_plot_var_names_3d)
Definition REMORA_SetPlotVars.cpp:216
REMORA::fennel_params
REMORABiology::FennelParameters fennel_params
Runtime parameters for the Fennel biology package.
Definition REMORA.H:1648
REMORA::allocate_bathymetry_grid_vars_full_domain
void allocate_bathymetry_grid_vars_full_domain()
Allocate multifabs for storing full-domain bathymetry and grid vars data.
Definition REMORA_init.cpp:320
REMORA::MakeNewLevelFromScratch
virtual void MakeNewLevelFromScratch(int lev, amrex::Real time, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm) override
Make a new level from scratch using provided BoxArray and DistributionMapping. Only used during initi...
Definition REMORA_make_new_level.cpp:349
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:1705
REMORA::vec_stflux
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_stflux
Surface tracer flux; input arrays.
Definition REMORA.H:496
REMORA::set_init_data_averaged_down
void set_init_data_averaged_down(int lev)
Problem initialization from averaged-down high resolution data.
Definition REMORA.cpp:779
REMORA::verbose
static int verbose
Verbosity level of output.
Definition REMORA.H:1753
REMORA::setup_step
void setup_step(int lev, amrex::Real time, amrex::Real dt_lev)
Set everything up for a step on a level.
Definition REMORA_setup_step.cpp:11
REMORA::vec_rdrag
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_rdrag
Linear drag coefficient [m/s], defined at rho points.
Definition REMORA.H:521
REMORA::vec_cloud
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_cloud
cloud cover fraction [0-1], defined at rho-points
Definition REMORA.H:507
REMORA::nonlin_eos
void nonlin_eos(const amrex::Box &bx, const amrex::Array4< amrex::Real const > &state, const amrex::Array4< amrex::Real > &rho, const amrex::Array4< amrex::Real > &rhoA, const amrex::Array4< amrex::Real > &rhoS, const amrex::Array4< amrex::Real > &bvf, const amrex::Array4< amrex::Real > &alpha, const amrex::Array4< amrex::Real > &beta, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &z_w, const amrex::Array4< amrex::Real const > &z_r, const amrex::Array4< amrex::Real const > &h, const amrex::Array4< amrex::Real const > &mskr, const int N)
Calculate density and related quantities from nonlinear equation of state.
Definition REMORA_rho_eos.cpp:158
REMORA::t3dmix2_geo
void t3dmix2_geo(const amrex::Box &bx, const amrex::Array4< amrex::Real > &state, const amrex::Array4< amrex::Real > &state_rhs, const amrex::Array4< amrex::Real const > &diff2, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &z_r, const amrex::Array4< amrex::Real const > &pm, const amrex::Array4< amrex::Real const > &pn, const amrex::Array4< amrex::Real const > &msku, const amrex::Array4< amrex::Real const > &mskv, const amrex::Real dt_lev, const int ncomp, const int N)
Harmonic diffusivity for tracers along geopotential surfaces.
Definition REMORA_t3dmix.cpp:126
REMORA::plot_file_name
std::string plot_file_name
Plotfile prefix.
Definition REMORA.H:1685
REMORA::vec_Zt_avg1
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_Zt_avg1
Average of the free surface, zeta (2D)
Definition REMORA.H:464
REMORA::check_int
int check_int
Checkpoint output interval in iterations.
Definition REMORA.H:1693
REMORA::set_smflux
void set_smflux(int lev)
Initialize or calculate surface momentum flux from file or analytic.
Definition REMORA.cpp:1171
REMORA::WritePlotFile
void WritePlotFile(int istep)
main driver for writing AMReX plotfiles
Definition REMORA_Plotfile.cpp:16
REMORA::restart_chkfile
std::string restart_chkfile
If set, restart from this checkpoint file.
Definition REMORA.H:1630
REMORA::init_clim_nudg_coeff
void init_clim_nudg_coeff(int lev)
Wrapper to initialize climatology nudging coefficient.
Definition REMORA_init.cpp:280
REMORA::init_bathymetry_full_domain_from_analytic
void init_bathymetry_full_domain_from_analytic()
Full domain bathymetry data initialization from analytic.
Definition REMORA_init.cpp:356
REMORA::vec_rv
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_rv
v velocity RHS (3D, includes horizontal and vertical advection)
Definition REMORA.H:420
REMORA::vec_btflx
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_btflx
Bottom tracer flux; working arrays.
Definition REMORA.H:498
REMORA::cf_width
int cf_width
Nudging width at coarse-fine interface.
Definition REMORA.H:1504
REMORA::bulk_psit
AMREX_GPU_HOST_DEVICE static AMREX_FORCE_INLINE amrex::Real bulk_psit(amrex::Real ZoL)
Evaluate stability function psi for moisture and heat.
Definition REMORA.H:1977
REMORA::nc_init_file
static amrex::Vector< amrex::Vector< std::string > > nc_init_file
NetCDF initialization file.
Definition REMORA.H:58
REMORA::vec_beta
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_beta
Saline contraction coefficient (3D)
Definition REMORA.H:623
REMORA::last_plot_file_step
int last_plot_file_step
Step when we last output a plotfile.
Definition REMORA.H:1605
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:1707
REMORA::use_biology_cpp_answer
int use_biology_cpp_answer
Select the native C++ biology kernel (1) or the ROMS Fortran bridge oracle (0). Only meaningful when ...
Definition REMORA.H:1656
REMORA::bulk_fluxes
void bulk_fluxes(int lev, amrex::MultiFab *mf_cons, amrex::MultiFab *mf_uwind, amrex::MultiFab *mf_vwind, amrex::MultiFab *mf_Tair, amrex::MultiFab *mf_qair, amrex::MultiFab *mf_Pair, amrex::MultiFab *mf_srflx, amrex::MultiFab *mf_longwave_down, amrex::MultiFab *mf_evap, amrex::MultiFab *mf_sustr, amrex::MultiFab *mf_svstr, amrex::MultiFab *mf_stflux, amrex::MultiFab *mf_lrflx, amrex::MultiFab *mf_lhflx, amrex::MultiFab *mf_shflx, const int N)
Calculate bulk temperature, salinity, wind fluxes.
Definition REMORA_bulk_flux.cpp:25
REMORA::t3dmix2_s
void t3dmix2_s(const amrex::Box &bx, const amrex::Array4< amrex::Real > &state, const amrex::Array4< amrex::Real > &state_rhs, const amrex::Array4< amrex::Real const > &diff2, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &pm, const amrex::Array4< amrex::Real const > &pn, const amrex::Array4< amrex::Real const > &msku, const amrex::Array4< amrex::Real const > &mskv, const amrex::Real dt_lev, const int ncomp)
Harmonic diffusivity for tracers along S-coordinate level surfaces.
Definition REMORA_t3dmix.cpp:55
REMORA::t_old
amrex::Vector< amrex::Real > t_old
old time at each level
Definition REMORA.H:1558
REMORA::bio_comp_start
int bio_comp_start() const noexcept
First cons component of the biology block. Problem setups need this to write biology initial conditio...
Definition REMORA.H:1937
REMORA::vec_mskr3d
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_mskr3d
land/sea mask at cell centers, copied to all z levels (3D)
Definition REMORA.H:565
REMORA::m_bc_extdir_vals
amrex::Vector< amrex::GpuArray< amrex::Real, AMREX_SPACEDIM *2 > > m_bc_extdir_vals
Array holding the Dirichlet values at walls which need them.
Definition REMORA.H:1586
REMORA::vec_srflx
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_srflx
Shortwave radiation flux [W/m²], defined at rho-points.
Definition REMORA.H:483
REMORA::last_check_file_time
amrex::Real last_check_file_time
Simulation time when we last output a checkpoint file.
Definition REMORA.H:1612
REMORA::append2DPlotVariables
void append2DPlotVariables(const std::string &pp_plot_var_names_2d)
Definition REMORA_SetPlotVars.cpp:254
REMORA::set_bathymetry_averaged_down
void set_bathymetry_averaged_down(int lev)
Copy over bathymetry data that has been averaged down from high resolution input netcdf file.
Definition REMORA.cpp:733
REMORA::dt
amrex::Vector< amrex::Real > dt
time step at each level
Definition REMORA.H:1560
REMORA::PackSurfaceState
void PackSurfaceState(amrex::Vector< amrex::MultiFab * > &state, amrex::Real time, const amrex::MultiFab *weight_o2a_mf, const amrex::iMultiFab *index_o2a_mf, int max_stencil_size, const amrex::iMultiFab *dst_land_mask=nullptr)
Extracts SST from the 3D conservative state for the atmospheric driver.
Definition REMORA_Coupling.cpp:380
REMORA::sum_per
static amrex::Real sum_per
Diagnostic sum output interval in time.
Definition REMORA.H:1758
REMORA::vec_Pair
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_Pair
Air pressure [mb], defined at rho-points.
Definition REMORA.H:480
REMORA::InitializeFromFile
void InitializeFromFile()
Read the file passed to remora.restart and use it as an initial condition for the current simulation.
REMORA::coriolis
void coriolis(const amrex::Box &xbx, const amrex::Box &ybx, const amrex::Array4< amrex::Real const > &uold, const amrex::Array4< amrex::Real const > &vold, const amrex::Array4< amrex::Real > &ru, const amrex::Array4< amrex::Real > &rv, const amrex::Array4< amrex::Real const > &Hz, const amrex::Array4< amrex::Real const > &fomn, int nrhs, int nr)
Calculate Coriolis terms.
Definition REMORA_coriolis.cpp:19
REMORA::domain_bcs_type_d
amrex::Gpu::DeviceVector< amrex::BCRec > domain_bcs_type_d
GPU vector (over BCVars) of BCRecs.
Definition REMORA.H:1580
REMORA::~REMORA
virtual ~REMORA()
Definition REMORA.cpp:244
REMORA::vec_qair
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_qair
Specific humidity [kg/kg], defined at rho-points.
Definition REMORA.H:478
REMORA::hires_grid_level
int hires_grid_level
Which level the high resolution bathymetry is at.
Definition REMORA.H:1780
REMORA::vec_z_w
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_z_w
z coordinates at w points (faces between z-cells)
Definition REMORA.H:444
REMORA::restart
void restart()
Definition REMORA.cpp:618
REMORA::vbar_clim_data_from_file
std::unique_ptr< NCTimeSeries > vbar_clim_data_from_file
Data container for vbar climatology data read from file.
Definition REMORA.H:1472
REMORA::vec_Tair
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_Tair
Air temperature [°C], defined at rho-points.
Definition REMORA.H:476
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:1105
REMORA::derived_names_2d
const amrex::Vector< std::string > derived_names_2d
Names of derived fields for 2d plotfile fields.
Definition REMORA.H:1714
REMORA::vec_yr
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_yr
y_grid on rho points (2D)
Definition REMORA.H:582
REMORA::vec_Hvom
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_Hvom
v-volume flux (3D)
Definition REMORA.H:416
REMORA::vec_Akp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_Akp
Turbulent length scale vertical diffusion coefficient.
Definition REMORA.H:640
REMORA::gls_corrector
void gls_corrector(int lev, amrex::MultiFab *mf_gls, amrex::MultiFab *mf_tke, amrex::MultiFab &mf_W, amrex::MultiFab *mf_Akv, amrex::MultiFab *mf_Akt, amrex::MultiFab *mf_Akk, amrex::MultiFab *mf_Akp, amrex::MultiFab *mf_mskr, amrex::MultiFab *mf_msku, amrex::MultiFab *mf_mskv, const int nstp, const int nnew, const int N, const amrex::Real dt_lev)
Corrector step for GLS calculation.
Definition REMORA_gls.cpp:247
REMORA::vec_diff2
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_diff2
Harmonic diffusivity for temperature / salinity.
Definition REMORA.H:438
REMORA::vec_latp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > vec_latp
latitude on psi-points (2D, degrees north); only filled when the grid NetCDF file carries lat_psi
Definition REMORA.H:604
REMORA::biology_ic_type
REMORABiology::BiologyICType biology_ic_type
Source of the biology tracer initial condition, independent of remora.ic_type. Default follows ic_typ...
Definition REMORA.H:1651
BCVars::NumTypes
int NumTypes(int ncons) noexcept
Definition REMORA_IndexDefines.H:52
BCVars::xvel_bc
int xvel_bc(int ncons) noexcept
Definition REMORA_IndexDefines.H:41
BCVars::zvel_bc
int zvel_bc(int ncons) noexcept
Definition REMORA_IndexDefines.H:43
BCVars::yvel_bc
int yvel_bc(int ncons) noexcept
Definition REMORA_IndexDefines.H:42
BCVars::vbar_bc
int vbar_bc(int ncons) noexcept
Definition REMORA_IndexDefines.H:45
BCVars::foextrap_bc
int foextrap_bc(int ncons) noexcept
Definition REMORA_IndexDefines.H:49
BCVars::v2d_simple_bc
int v2d_simple_bc(int ncons) noexcept
Definition REMORA_IndexDefines.H:51
BCVars::u2d_simple_bc
int u2d_simple_bc(int ncons) noexcept
Definition REMORA_IndexDefines.H:50
BCVars::zeta_bc
int zeta_bc(int ncons) noexcept
Definition REMORA_IndexDefines.H:46
BCVars::ubar_bc
int ubar_bc(int ncons) noexcept
Definition REMORA_IndexDefines.H:44
BCVars::tke_bc
int tke_bc(int ncons) noexcept
Definition REMORA_IndexDefines.H:47
BCVars::foextrap_periodic_bc
int foextrap_periodic_bc(int ncons) noexcept
Definition REMORA_IndexDefines.H:48
BdyVars::NumTypes
int NumTypes(int ncons) noexcept
Definition REMORA_IndexDefines.H:80
BdyVars::vbar
int vbar(int ncons) noexcept
Definition REMORA_IndexDefines.H:78
BdyVars::cons
int cons(int icomp) noexcept
Definition REMORA_IndexDefines.H:76
BdyVars::null
static constexpr int null
Definition REMORA_IndexDefines.H:70
BdyVars::zeta
int zeta(int ncons) noexcept
Definition REMORA_IndexDefines.H:79
BdyVars::ubar
int ubar(int ncons) noexcept
Definition REMORA_IndexDefines.H:77
InterpType::CellConservativeQuartic
@ CellConservativeQuartic
Definition REMORA.H:74
InterpType::CellBilinear
@ CellBilinear
Definition REMORA.H:71
InterpType::PCInterp
@ PCInterp
Definition REMORA.H:68
InterpType::NodeBilinear
@ NodeBilinear
Definition REMORA.H:69
InterpType::CellConservativeLinear
@ CellConservativeLinear
Definition REMORA.H:70
InterpType::CellQuadratic
@ CellQuadratic
Definition REMORA.H:72
InterpType::CellConservativeProtected
@ CellConservativeProtected
Definition REMORA.H:73
REMORABiology::BiologyICType::follow_ic_type
@ follow_ic_type
default: NetCDF when ic_type is netcdf, else analytic