Merge pull request #275 from brian-oneill/omega/add-vert-coord

Add vertical coordinate module

Author: sbrus89

components/omega/configs/Default.yml

@@ -6,8 +6,6 @@ Omega:
     StartTime: 0001-01-01_00:00:00
     StopTime: 0001-01-01_02:00:00
     RunDuration: none
-  Dimension:
-    NVertLevels: 60
   Decomp:
     HaloWidth: 3
     DecompMethod: MetisKWay
@@ -24,6 +22,8 @@ Omega:
     FluxTracerType: Center
   WindStress:
     InterpType: Isotropic
+  VertCoord:
+    MovementWeightType: Uniform
   Tendencies:
     ThicknessFluxTendencyEnable: true
     PVTendencyEnable: true
@@ -55,6 +55,16 @@ Omega:
       DRhoDS: 0.8
       RhoT0S0: 1000.0
   IOStreams:
+    InitialVertCoord:
+      UsePointerFile: false
+      Filename: OmegaMesh.nc
+      Mode: read
+      Precision: double
+      Freq: 1
+      FreqUnits: OnStartup
+      UseStartEnd: false
+      Contents:
+        - InitVertCoord
     # InitialState should only be used when starting from scratch.
     # For restart runs, the frequency units should be changed from
     # "OnStartup" to "never" so that the initial state file is not read.

components/omega/doc/design/AuxiliaryState.md

@@ -70,14 +70,14 @@ The constructor will be responsible for:
   * registering fields and metadata with the I/O infrastructure
 
 ```c++
-AuxiliaryState(const std::string &Name, const HorzMesh *Mesh, int NVertLevels);
+AuxiliaryState(const std::string &Name, const HorzMesh *Mesh, int NVertLayers);
 ```
 
 The create method will take the same arguments as the constructor, use it to
 create a new auxiliary state, and put it in the static map of all auxiliary
 states. It will return a pointer to the newly created state.
 ```c++
-AuxiliaryState* AuxiliaryState::create(const std::string &Name, const HorzMesh *Mesh, int NVertLevels);
+AuxiliaryState* AuxiliaryState::create(const std::string &Name, const HorzMesh *Mesh, int NVertLayers);
 ```
 
 #### 4.2.2 Initialization

components/omega/doc/design/AuxiliaryVariables.md

@@ -10,7 +10,7 @@ can often be bundled together into groups of variables that are logically
 related, or can be efficiently computed together. Each auxiliary variable group
 is implemented as a class containing array(s) storing the variable(s) and member
 functions that compute them. The member functions compute the variable (or
-variable group) over a chunk of vertical levels for a particular mesh location.
+variable group) over a chunk of vertical layers for a particular mesh location.
 There may be more than one compute function, since some groups may contain
 variables defined on different mesh elements. This approach allows flexible
 groupings of computational work within larger cell/edge/vertex loops. This type
@@ -31,7 +31,7 @@ implement a given variable (group) computation on a specific mesh location
 
 ### 2.3 Requirement: Vectorization on CPU architectures
 Auxiliary variables computations have inner loops over a chunk of vertical
-levels. The chunk size will be set to the vector length on CPU machines and 1
+layers. The chunk size will be set to the vector length on CPU machines and 1
 for GPUs. This will allow for the possibility of vectorization on CPUs.
 
 ### 2.4 Requirement: Configuration options
@@ -101,11 +101,11 @@ The constructor will be responsible for:
   * registering fields and metadata with the I/O infrastructure.
 
 ```c++
-   LayerThicknessAuxVars(const HorzMesh *mesh, int NVertLevels, const Config *Options)
+   LayerThicknessAuxVars(const HorzMesh *mesh, int NVertLayers, const Config *Options)
        : FluxLayerThickEdge("FluxLayerThickEdge", mesh->NEdgesSize,
-                            NVertLevels),
+                            NVertLayers),
          MeanLayerThickEdge("MeanLayerThickEdge", mesh->NEdgesSize,
-                            NVertLevels),
+                            NVertLayers),
          CellsOnEdge(mesh->CellsOnEdge) {
 
              std::string FluxThickTypeStr;
@@ -128,11 +128,11 @@ The constructor will be responsible for:
 
 #### 4.2.2 Compute methods
 Compute methods implement the auxiliary variables computations for a chunk of
-vertical levels at a given horizontal mesh location. The mesh location is
+vertical layers at a given horizontal mesh location. The mesh location is
 indicated in the method name. There may be more than one compute method to
 compute different groups of variables over different mesh locations. Any
 configurable computation options are handled inside the compute method. The
-inner loop over a chunk of vertical levels enables CPU vectorization.
+inner loop over a chunk of vertical layers enables CPU vectorization.
 
 ```c++
    KOKKOS_FUNCTION void

components/omega/doc/design/EOS.md

@@ -63,7 +63,7 @@ class Eos{
     private:
        EOSType eosChoice;
        I4 NCellsAll;
-       I4 NChunks = NVertLevels / VecLength;
+       I4 NChunks = NVertLayers / VecLength;
        void computeSpecVolTEOS10Poly75t();
        void computeSpecVolLinear();
        void truncateTempSal();
@@ -106,14 +106,14 @@ The constructor will be responsible for:
   * allocating arrays
 
 ```c++
-Eos::Eos(const HorzMesh *Mesh, int NVertLevels, Config *Options);
+Eos::Eos(const HorzMesh *Mesh, int NVertLayers, Config *Options);
 ```
 
 The create method will take the same arguments as the constructor plus a name. It calls the constructor to
 create a new eos instance, and put it in the static map of all eos.
 It will return a pointer to the newly created object.
 ```c++
-Eos *Eos::create(const std::string &Name, const HorzMesh *Mesh, int NVertLevels, Config *Options);
+Eos *Eos::create(const std::string &Name, const HorzMesh *Mesh, int NVertLayers, Config *Options);
 ```
 
 #### 4.2.2 Initialization

components/omega/doc/design/OmegaV1GoverningEqns.md

@@ -1,3 +1,4 @@
+(omega-design-governing-eqns-omega1)=
 # Omega V1: Governing Equations
 
 <!--

components/omega/doc/design/Reductions.md

@@ -128,11 +128,11 @@ relevant MachEnv (eg defaultEnv.comm) and indxRange is a
 `std::vector` of length 2x the number of array dimensions.
 The entries of this vector will be the min, max index of
 each array dimension. So, for example an array dimensioned
-`(nCellsAll+1, nVertLevels+1)` might need to be summed over
-the `indxRange{0, nCellsOwned-1, 0, nVertLevels-1}`. Note
+`(nCellsAll+1, nVertLayers+1)` might need to be summed over
+the `indxRange{0, nCellsOwned-1, 0, nVertLayers-1}`. Note
 that the indxRange supports a constant scalar values only so
 does not support a variable index range like
-minLevelCell/maxLevelCell. That is best managed either
+minLayerCell/maxLayerCell. That is best managed either
 by masking with the sum-product interface below or
 ensuring the array has been set to zero in non-active
 entries.

components/omega/doc/design/Tendencies.md

@@ -66,14 +66,14 @@ The constructor will be responsible for:
   * allocating tendency arrays
 
 ```c++
-Tendencies(const std::string &Name, const HorzMesh *Mesh, int NVertLevels, Config *Options);
+Tendencies(const std::string &Name, const HorzMesh *Mesh, int NVertLayers, Config *Options);
 ```
 
 The create method will take the same arguments as the constructor, use it to
 create a new tendencies instance, and put it in the static map of all tendencies.
 It will return a pointer to the newly created object.
 ```c++
-Tendencies* Tendencies::create(const std::string &Name, const HorzMesh *Mesh, int NVertLevels, Config *Options);
+Tendencies* Tendencies::create(const std::string &Name, const HorzMesh *Mesh, int NVertLayers, Config *Options);
 ```
 
 #### 4.2.2 Initialization

components/omega/doc/design/Tendency.md

@@ -3,7 +3,7 @@
 
 ## 1 Overview
 
-The tendency terms in OMEGA are implemented as functors, which define an operation over a number of vertical levels for particular a cell, edge, or vertex.
+The tendency terms in OMEGA are implemented as functors, which define an operation over a number of vertical layers for particular a cell, edge, or vertex.
 Tendency functors take information which remains constant during the forward simulation (such as `HorzMesh` and `Config`)  as constructor arguments.
 The `operator()` method is overloaded with the relevant discrete /parameterization.
 This approach allows for a modularization of the tendency terms that enables flexible groupings of work within larger cell/edge/vertex loops.
@@ -19,7 +19,7 @@ Each functor will implement a given tendency operation on a specific mesh locati
 Tendency functors take in constant data as constructor arguments, which simplifies the arguments used to call the operator method.
 
 ### 2.3 Requirement: Tendencies must allow for vectorization on CPU architectures.
-Tendency operations have inner loops over a chunk of vertical levels.
+Tendency operations have inner loops over a chunk of vertical layers.
 The chunk size will be set to the vector length on CPU machines and 1 for GPUs.
 This will allow for the possibility of vectorization on CPUs.
 
@@ -76,8 +76,8 @@ ThicknessFluxDivergenceOnCell::ThicknessFluxDivergenceOnCell(HorzMesh const *Mes
 ```
 
 #### 4.2.2 operator
-The operator method implements the tendency computation for a chunk of vertical levels at a given horizontal mesh location.
-The inner loop over a chunk of vertical levels enables CPU vectorization.
+The operator method implements the tendency computation for a chunk of vertical layers at a given horizontal mesh location.
+The inner loop over a chunk of vertical layers enables CPU vectorization.
 
 ```c++
 KOKKOS_FUNCTION void ThicknessFluxDivergenceOnCell::operator()(Array2DReal &Tend

components/omega/doc/design/VertCoord.md

@@ -56,7 +56,7 @@ In future versions of Omega, the $p^\star$ coordinate will be extended to a more
 The vertical coordinate module should retain flexibility to support VLR in future versions of Omega.
 
 ## 3 Algorithmic Formulation
-In the layered non-Boussinesq equations solved in Omega (see [V0 governing equation document](OmegaV1GoverningEqns) for details), the prognostic variable for cell $i$ and layer $k$ is the pseudo thickness, $\tilde{h}_{i,k}$, so that the geometric thickness (in meters) is a diagnostic variable defined as:
+In the layered non-Boussinesq equations solved in Omega (see [V0 governing equation document](omega-design-governing-eqns-omega1) for details), the prognostic variable for cell $i$ and layer $k$ is the pseudo thickness, $\tilde{h}_{i,k}$, so that the geometric thickness (in meters) is a diagnostic variable defined as:
 
 $$ \Delta z_{i,k} = \rho_0 \alpha_{i,k} \tilde{h}_{i,k}. $$
 

components/omega/doc/design/VerticalMixingCoeff.md

@@ -137,7 +137,7 @@ It is assumed that viscosity and diffusivity will be stored at cell centers. Add
 
 ```c++
 parallelFor(
-    {NCellsAll, NVertLevels}, KOKKOS_LAMBDA(int ICell, int K) {
+    {NCellsAll, NVertLayers}, KOKKOS_LAMBDA(int ICell, int K) {
 
         // Add background contribution to viscosity and diffusivity
         VertViscosity(ICell, K) = BackgroundViscosity;