From b78eedf6069b496471788780581adbec4d49b1e2 Mon Sep 17 00:00:00 2001
From: Charles Kawczynski <kawczynski.charles@gmail.com>
Date: Fri, 16 Aug 2024 13:13:29 -0400
Subject: [PATCH] Make Nh a dynamic parameter

---
 ext/cuda/data_layouts_copyto.jl          |   8 +-
 lib/ClimaCorePlots/src/ClimaCorePlots.jl |   2 +-
 src/DataLayouts/DataLayouts.jl           | 239 ++++++++++++-----------
 src/DataLayouts/broadcast.jl             | 177 +++++++++--------
 src/DataLayouts/copyto.jl                |  24 ++-
 src/DataLayouts/fused_copyto.jl          |  15 +-
 src/DataLayouts/mapreduce.jl             |  20 +-
 src/Grids/spectralelement.jl             |   8 +-
 src/InputOutput/readers.jl               |  30 +--
 src/Limiters/quasimonotone.jl            |   4 +-
 src/Topologies/dss.jl                    |   3 +-
 src/Topologies/dss_transform.jl          |  18 +-
 src/deprecated.jl                        |  26 ---
 test/DataLayouts/benchmark_copyto.jl     |  26 ++-
 test/DataLayouts/benchmark_fill.jl       |  34 +++-
 test/DataLayouts/cuda.jl                 |  17 +-
 test/DataLayouts/data0d.jl               |  14 +-
 test/DataLayouts/data1dx.jl              |  12 +-
 test/DataLayouts/data2d.jl               |  23 +--
 test/DataLayouts/data2dx.jl              |  10 +-
 test/DataLayouts/opt_similar.jl          |  28 +--
 test/DataLayouts/opt_universal_size.jl   |  57 +++---
 test/DataLayouts/unit_copyto.jl          |  75 ++++---
 test/DataLayouts/unit_data2array.jl      |   8 +-
 test/DataLayouts/unit_fill.jl            |  97 +++++----
 test/DataLayouts/unit_mapreduce.jl       |  60 +++---
 test/DataLayouts/unit_ndims.jl           |  44 +++--
 test/Fields/unit_field.jl                |   8 +-
 test/Spaces/opt_spaces.jl                |   2 +-
 test/deprecations.jl                     |  13 +-
 30 files changed, 606 insertions(+), 496 deletions(-)

diff --git a/ext/cuda/data_layouts_copyto.jl b/ext/cuda/data_layouts_copyto.jl
index 013892e602..83f22ea355 100644
--- a/ext/cuda/data_layouts_copyto.jl
+++ b/ext/cuda/data_layouts_copyto.jl
@@ -27,12 +27,12 @@ function cuda_copyto!(dest::AbstractData, bc)
 end
 
 #! format: off
-Base.copyto!(dest::IJFH{S, Nij},          bc::DataLayouts.BroadcastedUnionIJFH{S, Nij, Nh}, ::ToCUDA) where {S, Nij, Nh} = cuda_copyto!(dest, bc)
-Base.copyto!(dest::IFH{S, Ni, Nh},        bc::DataLayouts.BroadcastedUnionIFH{S, Ni, Nh}, ::ToCUDA) where {S, Ni, Nh} = cuda_copyto!(dest, bc)
+Base.copyto!(dest::IJFH{S, Nij},          bc::DataLayouts.BroadcastedUnionIJFH{S, Nij}, ::ToCUDA) where {S, Nij} = cuda_copyto!(dest, bc)
+Base.copyto!(dest::IFH{S, Ni},            bc::DataLayouts.BroadcastedUnionIFH{S, Ni}, ::ToCUDA) where {S, Ni} = cuda_copyto!(dest, bc)
 Base.copyto!(dest::IJF{S, Nij},           bc::DataLayouts.BroadcastedUnionIJF{S, Nij}, ::ToCUDA) where {S, Nij} = cuda_copyto!(dest, bc)
 Base.copyto!(dest::IF{S, Ni},             bc::DataLayouts.BroadcastedUnionIF{S, Ni}, ::ToCUDA) where {S, Ni} = cuda_copyto!(dest, bc)
-Base.copyto!(dest::VIFH{S, Nv, Ni, Nh},   bc::DataLayouts.BroadcastedUnionVIFH{S, Nv, Ni, Nh}, ::ToCUDA) where {S, Nv, Ni, Nh} = cuda_copyto!(dest, bc)
-Base.copyto!(dest::VIJFH{S, Nv, Nij, Nh}, bc::DataLayouts.BroadcastedUnionVIJFH{S, Nv, Nij, Nh}, ::ToCUDA) where {S, Nv, Nij, Nh} = cuda_copyto!(dest, bc)
+Base.copyto!(dest::VIFH{S, Nv, Ni},       bc::DataLayouts.BroadcastedUnionVIFH{S, Nv, Ni}, ::ToCUDA) where {S, Nv, Ni} = cuda_copyto!(dest, bc)
+Base.copyto!(dest::VIJFH{S, Nv, Nij},     bc::DataLayouts.BroadcastedUnionVIJFH{S, Nv, Nij}, ::ToCUDA) where {S, Nv, Nij} = cuda_copyto!(dest, bc)
 Base.copyto!(dest::VF{S, Nv},             bc::DataLayouts.BroadcastedUnionVF{S, Nv}, ::ToCUDA) where {S, Nv} = cuda_copyto!(dest, bc)
 Base.copyto!(dest::DataF{S},              bc::DataLayouts.BroadcastedUnionDataF{S}, ::ToCUDA) where {S} = cuda_copyto!(dest, bc)
 #! format: on
diff --git a/lib/ClimaCorePlots/src/ClimaCorePlots.jl b/lib/ClimaCorePlots/src/ClimaCorePlots.jl
index 5c786b44a2..a7070e2232 100644
--- a/lib/ClimaCorePlots/src/ClimaCorePlots.jl
+++ b/lib/ClimaCorePlots/src/ClimaCorePlots.jl
@@ -431,7 +431,7 @@ function _unfolded_pannel_matrix(field, interpolate)
     # TODO: inefficient memory wise, but good enough for now
     panels = [fill(NaN, (panel_size * dof, panel_size * dof)) for _ in 1:6]
 
-    interpolated_data = DataLayouts.IJFH{FT, interpolate, nelem}(Array{FT})
+    interpolated_data = DataLayouts.IJFH{FT, interpolate}(Array{FT}, nelem)
     field_data = Fields.field_values(field)
 
     Operators.tensor_product!(interpolated_data, field_data, Imat)
diff --git a/src/DataLayouts/DataLayouts.jl b/src/DataLayouts/DataLayouts.jl
index 5d45024e5c..62164f6253 100644
--- a/src/DataLayouts/DataLayouts.jl
+++ b/src/DataLayouts/DataLayouts.jl
@@ -53,20 +53,26 @@ abstract type AbstractData{S} end
 @inline Base.size(data::AbstractData) = universal_size(data)
 
 """
-    struct UniversalSize{Ni, Nj, Nv, Nh} end
+    struct UniversalSize{Ni, Nj, Nv} end
     UniversalSize(data::AbstractData)
 
-A struct containing static dimensions, universal to all datalayouts:
+A struct containing static dimensions (except `Nh`),
+universal to all datalayouts:
+
  - `Ni` number of spectral element nodal degrees of freedom in first horizontal direction
  - `Nj` number of spectral element nodal degrees of freedom in second horizontal direction
  - `Nv` number of vertical degrees of freedom
  - `Nh` number of horizontal elements
+
+Note that this dynamically allocates a new type.
 """
-struct UniversalSize{Ni, Nj, Nv, Nh} end
+struct UniversalSize{Ni, Nj, Nv, T}
+    Nh::T
+end
 
 @inline function UniversalSize(data::AbstractData)
     us = universal_size(data)
-    UniversalSize{us[1], us[2], us[4], us[5]}()
+    UniversalSize{us[1], us[2], us[4], typeof(us[5])}(us[5])
 end
 
 @inline array_length(data::AbstractData) = prod(size(parent(data)))
@@ -78,39 +84,43 @@ A tuple of compile-time known type parameters,
 corresponding to `UniversalSize`. The field dimension
 is excluded and is returned as 1.
 """
-@inline universal_size(::UniversalSize{Ni, Nj, Nv, Nh}) where {Ni, Nj, Nv, Nh} =
-    (Ni, Nj, 1, Nv, Nh)
+@inline universal_size(us::UniversalSize{Ni, Nj, Nv}) where {Ni, Nj, Nv} =
+    (Ni, Nj, 1, Nv, us.Nh)
 
 """
-    get_N(::AbstractData)
-    get_N(::UniversalSize)
+    get_N(::UniversalSize) # static
+    get_N(::AbstractData) # dynamic
 
 Statically returns `prod((Ni, Nj, Nv, Nh))`
 """
-@inline get_N(::UniversalSize{Ni, Nj, Nv, Nh}) where {Ni, Nj, Nv, Nh} =
-    prod((Ni, Nj, Nv, Nh))
+@inline get_N(us::UniversalSize{Ni, Nj, Nv}) where {Ni, Nj, Nv} =
+    prod((Ni, Nj, Nv, us.Nh))
 
 """
-    get_Nv(::UniversalSize)
+    get_Nv(::UniversalSize) # static
+    get_Nv(::AbstractData) # dynamic
 
 Statically returns `Nv`.
 """
 @inline get_Nv(::UniversalSize{Ni, Nj, Nv}) where {Ni, Nj, Nv} = Nv
 
 """
-    get_Nij(::UniversalSize)
+    get_Nij(::UniversalSize) # static
+    get_Nij(::AbstractData) # dynamic
 
 Statically returns `Nij`.
 """
 @inline get_Nij(::UniversalSize{Nij}) where {Nij} = Nij
 
 """
-    get_Nh(::UniversalSize)
+    get_Nh(::UniversalSize) # dynamic
+    get_Nh(::AbstractData) # dynamic
 
-Statically returns `Nh`.
+Returns `Nh`.
 """
-@inline get_Nh(::UniversalSize{Ni, Nj, Nv, Nh}) where {Ni, Nj, Nv, Nh} = Nh
+@inline get_Nh(us::UniversalSize{Ni, Nj, Nv}) where {Ni, Nj, Nv} = us.Nh
 
+@inline get_Nh_dynamic(data::AbstractData) = size(parent(data), h_dim(data))
 @inline get_Nh(data::AbstractData) = get_Nh(UniversalSize(data))
 @inline get_Nij(data::AbstractData) = get_Nij(UniversalSize(data))
 @inline get_Nv(data::AbstractData) = get_Nv(UniversalSize(data))
@@ -301,26 +311,24 @@ end
 
 A 3D DataLayout. TODO: Add more docs
 """
-struct IJKFVH{S, Nij, Nk, Nv, Nh, A} <: Data3D{S, Nij, Nk}
+struct IJKFVH{S, Nij, Nk, Nv, A} <: Data3D{S, Nij, Nk}
     array::A
 end
 
-function IJKFVH{S, Nij, Nk, Nv, Nh}(
+function IJKFVH{S, Nij, Nk, Nv}(
     array::AbstractArray{T, 6},
-) where {S, Nij, Nk, Nv, Nh, T}
+) where {S, Nij, Nk, Nv, T}
     check_basetype(T, S)
     @assert size(array, 1) == Nij
     @assert size(array, 2) == Nij
     @assert size(array, 3) == Nk
     @assert size(array, 4) == typesize(T, S)
     @assert size(array, 5) == Nv
-    @assert size(array, 6) == Nh
-    IJKFVH{S, Nij, Nk, Nv, Nh, typeof(array)}(array)
+    IJKFVH{S, Nij, Nk, Nv, typeof(array)}(array)
 end
 
-@inline universal_size(
-    ::IJKFVH{S, Nij, Nk, Nv, Nh},
-) where {S, Nij, Nk, Nv, Nh} = (Nij, Nij, Nk, Nv, Nh)
+@inline universal_size(data::IJKFVH{S, Nij, Nk, Nv}) where {S, Nij, Nk, Nv} =
+    (Nij, Nij, Nk, Nv, get_Nh_dynamic(data))
 
 # ==================
 # Data2D DataLayout
@@ -340,41 +348,41 @@ The `ArrayType`-constructor constructs a IJFH 2D Spectral
 DataLayout given the backing `ArrayType`, quadrature degrees
 of freedom `Nij × Nij`, and the number of mesh elements `nelements`.
 """
-struct IJFH{S, Nij, Nh, A} <: Data2D{S, Nij}
+struct IJFH{S, Nij, A} <: Data2D{S, Nij}
     array::A
 end
 
-function IJFH{S, Nij, Nh}(array::AbstractArray{T, 4}) where {S, Nij, Nh, T}
+function IJFH{S, Nij}(array::AbstractArray{T, 4}) where {S, Nij, T}
     check_basetype(T, S)
     @assert size(array, 1) == Nij
     @assert size(array, 2) == Nij
     @assert size(array, 3) == typesize(T, S)
-    @assert size(array, 4) == Nh
-    IJFH{S, Nij, Nh, typeof(array)}(array)
+    IJFH{S, Nij, typeof(array)}(array)
 end
 
-@inline universal_size(::IJFH{S, Nij, Nh}) where {S, Nij, Nh} =
-    (Nij, Nij, 1, 1, Nh)
+@inline universal_size(data::IJFH{S, Nij}) where {S, Nij} =
+    (Nij, Nij, 1, 1, get_Nh_dynamic(data))
 
-function IJFH{S, Nij, Nh}(::Type{ArrayType}) where {S, Nij, Nh, ArrayType}
+function IJFH{S, Nij}(::Type{ArrayType}, Nh::Integer) where {S, Nij, ArrayType}
     T = eltype(ArrayType)
-    IJFH{S, Nij, Nh}(ArrayType(undef, Nij, Nij, typesize(T, S), Nh))
+    IJFH{S, Nij}(ArrayType(undef, Nij, Nij, typesize(T, S), Nh))
 end
 
-Base.length(data::IJFH) = get_Nh(data)
+Base.length(data::IJFH) = get_Nh_dynamic(data)
 
 Base.@propagate_inbounds slab(data::IJFH, h::Integer) = slab(data, 1, h)
 
 @inline function slab(data::IJFH{S, Nij}, v::Integer, h::Integer) where {S, Nij}
-    @boundscheck (v >= 1 && 1 <= h <= get_Nh(data)) ||
+    @boundscheck (v >= 1 && 1 <= h <= get_Nh_dynamic(data)) ||
                  throw(BoundsError(data, (v, h)))
     dataview = @inbounds view(parent(data), :, :, :, h)
     IJF{S, Nij}(dataview)
 end
 
 @inline function column(data::IJFH{S, Nij}, i, j, h) where {S, Nij}
-    @boundscheck (1 <= j <= Nij && 1 <= i <= Nij && 1 <= h <= get_Nh(data)) ||
-                 throw(BoundsError(data, (i, j, h)))
+    @boundscheck (
+        1 <= j <= Nij && 1 <= i <= Nij && 1 <= h <= get_Nh_dynamic(data)
+    ) || throw(BoundsError(data, (i, j, h)))
     dataview = @inbounds view(parent(data), i, j, :, h)
     DataF{S}(dataview)
 end
@@ -385,8 +393,7 @@ function gather(
 ) where {S, Nij}
     gatherdata = ClimaComms.gather(ctx, parent(data))
     if ClimaComms.iamroot(ctx)
-        Nh = size(gatherdata, 4)
-        IJFH{S, Nij, Nh}(gatherdata)
+        IJFH{S, Nij}(gatherdata)
     else
         nothing
     end
@@ -396,7 +403,7 @@ end
 # Data1D DataLayout
 # ==================
 
-Base.length(data::Data1D) = get_Nh(data)
+Base.length(data::Data1D) = get_Nh_dynamic(data)
 
 """
     IFH{S,Ni,Nh,A} <: Data1D{S, Ni}
@@ -413,34 +420,35 @@ DataLayout given the backing `ArrayType`, quadrature
 degrees of freedom `Ni`, and the number of mesh elements
 `Nh`.
 """
-struct IFH{S, Ni, Nh, A} <: Data1D{S, Ni}
+struct IFH{S, Ni, A} <: Data1D{S, Ni}
     array::A
 end
 
-function IFH{S, Ni, Nh}(array::AbstractArray{T, 3}) where {S, Ni, Nh, T}
+function IFH{S, Ni}(array::AbstractArray{T, 3}) where {S, Ni, T}
     check_basetype(T, S)
     @assert size(array, 1) == Ni
     @assert size(array, 2) == typesize(T, S)
-    @assert size(array, 3) == Nh
-    IFH{S, Ni, Nh, typeof(array)}(array)
+    IFH{S, Ni, typeof(array)}(array)
 end
 
-function IFH{S, Ni, Nh}(::Type{ArrayType}) where {S, Ni, Nh, ArrayType}
+function IFH{S, Ni}(::Type{ArrayType}, Nh::Integer) where {S, Ni, ArrayType}
     T = eltype(ArrayType)
-    IFH{S, Ni, Nh}(ArrayType(undef, Ni, typesize(T, S), Nh))
+    IFH{S, Ni}(ArrayType(undef, Ni, typesize(T, S), Nh))
 end
 
-@inline universal_size(::IFH{S, Ni, Nh}) where {S, Ni, Nh} = (Ni, 1, 1, 1, Nh)
+@inline universal_size(data::IFH{S, Ni}) where {S, Ni} =
+    (Ni, 1, 1, 1, get_Nh_dynamic(data))
 
 @inline function slab(data::IFH{S, Ni}, h::Integer) where {S, Ni}
-    @boundscheck (1 <= h <= get_Nh(data)) || throw(BoundsError(data, (h,)))
+    @boundscheck (1 <= h <= get_Nh_dynamic(data)) ||
+                 throw(BoundsError(data, (h,)))
     dataview = @inbounds view(parent(data), :, :, h)
     IF{S, Ni}(dataview)
 end
 Base.@propagate_inbounds slab(data::IFH, v::Integer, h::Integer) = slab(data, h)
 
 @inline function column(data::IFH{S, Ni}, i, h) where {S, Ni}
-    @boundscheck (1 <= h <= get_Nh(data) && 1 <= i <= Ni) ||
+    @boundscheck (1 <= h <= get_Nh_dynamic(data) && 1 <= i <= Ni) ||
                  throw(BoundsError(data, (i, h)))
     dataview = @inbounds view(parent(data), i, :, h)
     DataF{S}(dataview)
@@ -695,32 +703,29 @@ Backing `DataLayout` for 2D spectral element slab + extruded 1D FV column data.
 Column levels (V) are contiguous for every element nodal point (I, J)
 for each `S` datatype struct field (F), for each 2D mesh element slab (H).
 """
-struct VIJFH{S, Nv, Nij, Nh, A} <: Data2DX{S, Nv, Nij}
+struct VIJFH{S, Nv, Nij, A} <: Data2DX{S, Nv, Nij}
     array::A
 end
 
-function VIJFH{S, Nv, Nij, Nh}(
-    array::AbstractArray{T, 5},
-) where {S, Nv, Nij, Nh, T}
+function VIJFH{S, Nv, Nij}(array::AbstractArray{T, 5}) where {S, Nv, Nij, T}
     check_basetype(T, S)
     @assert size(array, 1) == Nv
     @assert size(array, 2) == size(array, 3) == Nij
     @assert size(array, 4) == typesize(T, S)
-    @assert size(array, 5) == Nh
-    VIJFH{S, Nv, Nij, Nh, typeof(array)}(array)
+    VIJFH{S, Nv, Nij, typeof(array)}(array)
 end
 
 nlevels(::VIJFH{S, Nv}) where {S, Nv} = Nv
 
-@inline universal_size(::VIJFH{<:Any, Nv, Nij, Nh}) where {Nv, Nij, Nh} =
-    (Nij, Nij, 1, Nv, Nh)
+@inline universal_size(data::VIJFH{<:Any, Nv, Nij}) where {Nv, Nij} =
+    (Nij, Nij, 1, Nv, get_Nh_dynamic(data))
 
-Base.length(data::VIJFH) = get_Nv(data) * get_Nh(data)
+Base.length(data::VIJFH) = get_Nv(data) * get_Nh_dynamic(data)
 
 # Note: construct the subarray view directly as optimizer fails in Base.to_indices (v1.7)
-@inline function slab(data::VIJFH{S, Nv, Nij, Nh}, v, h) where {S, Nv, Nij, Nh}
+@inline function slab(data::VIJFH{S, Nv, Nij}, v, h) where {S, Nv, Nij}
     array = parent(data)
-    @boundscheck (1 <= v <= Nv && 1 <= h <= Nh) ||
+    @boundscheck (1 <= v <= Nv && 1 <= h <= get_Nh_dynamic(data)) ||
                  throw(BoundsError(data, (v, h)))
     Nf = ncomponents(data)
     dataview = @inbounds view(
@@ -735,15 +740,11 @@ Base.length(data::VIJFH) = get_Nv(data) * get_Nh(data)
 end
 
 # Note: construct the subarray view directly as optimizer fails in Base.to_indices (v1.7)
-@inline function column(
-    data::VIJFH{S, Nv, Nij, Nh},
-    i,
-    j,
-    h,
-) where {S, Nv, Nij, Nh}
+@inline function column(data::VIJFH{S, Nv, Nij}, i, j, h) where {S, Nv, Nij}
     array = parent(data)
-    @boundscheck (1 <= i <= Nij && 1 <= j <= Nij && 1 <= h <= Nh) ||
-                 throw(BoundsError(data, (i, j, h)))
+    @boundscheck (
+        1 <= i <= Nij && 1 <= j <= Nij && 1 <= h <= get_Nh_dynamic(data)
+    ) || throw(BoundsError(data, (i, j, h)))
     Nf = ncomponents(data)
     dataview = @inbounds SubArray(
         array,
@@ -752,11 +753,11 @@ end
     VF{S, Nv}(dataview)
 end
 
-@inline function level(data::VIJFH{S, Nv, Nij, Nh}, v) where {S, Nv, Nij, Nh}
+@inline function level(data::VIJFH{S, Nv, Nij}, v) where {S, Nv, Nij}
     array = parent(data)
     @boundscheck (1 <= v <= Nv) || throw(BoundsError(data, (v,)))
     dataview = @inbounds view(array, v, :, :, :, :)
-    IJFH{S, Nij, Nh}(dataview)
+    IJFH{S, Nij}(dataview)
 end
 
 function gather(
@@ -765,8 +766,7 @@ function gather(
 ) where {S, Nv, Nij}
     gatherdata = ClimaComms.gather(ctx, parent(data))
     if ClimaComms.iamroot(ctx)
-        Nh = size(gatherdata, 5)
-        VIJFH{S, Nv, Nij, Nh}(gatherdata)
+        VIJFH{S, Nv, Nij}(gatherdata)
     else
         nothing
     end
@@ -784,32 +784,29 @@ Backing `DataLayout` for 1D spectral element slab + extruded 1D FV column data.
 Column levels (V) are contiguous for every element nodal point (I)
 for each datatype `S` struct field (F), for each 1D mesh element slab (H).
 """
-struct VIFH{S, Nv, Ni, Nh, A} <: Data1DX{S, Nv, Ni}
+struct VIFH{S, Nv, Ni, A} <: Data1DX{S, Nv, Ni}
     array::A
 end
 
-function VIFH{S, Nv, Ni, Nh}(
-    array::AbstractArray{T, 4},
-) where {S, Nv, Ni, Nh, T}
+function VIFH{S, Nv, Ni}(array::AbstractArray{T, 4}) where {S, Nv, Ni, T}
     check_basetype(T, S)
     @assert size(array, 1) == Nv
     @assert size(array, 2) == Ni
     @assert size(array, 3) == typesize(T, S)
-    @assert size(array, 4) == Nh
-    VIFH{S, Nv, Ni, Nh, typeof(array)}(array)
+    VIFH{S, Nv, Ni, typeof(array)}(array)
 end
 
 nlevels(::VIFH{S, Nv}) where {S, Nv} = Nv
 
-@inline universal_size(::VIFH{<:Any, Nv, Ni, Nh}) where {Nv, Ni, Nh} =
-    (Ni, 1, 1, Nv, Nh)
+@inline universal_size(data::VIFH{<:Any, Nv, Ni}) where {Nv, Ni} =
+    (Ni, 1, 1, Nv, get_Nh_dynamic(data))
 
-Base.length(data::VIFH) = nlevels(data) * get_Nh(data)
+Base.length(data::VIFH) = nlevels(data) * get_Nh_dynamic(data)
 
 # Note: construct the subarray view directly as optimizer fails in Base.to_indices (v1.7)
-@inline function slab(data::VIFH{S, Nv, Ni, Nh}, v, h) where {S, Nv, Ni, Nh}
+@inline function slab(data::VIFH{S, Nv, Ni}, v, h) where {S, Nv, Ni}
     array = parent(data)
-    @boundscheck (1 <= v <= Nv && 1 <= h <= Nh) ||
+    @boundscheck (1 <= v <= Nv && 1 <= h <= get_Nh_dynamic(data)) ||
                  throw(BoundsError(data, (v, h)))
     Nf = ncomponents(data)
     dataview = @inbounds SubArray(
@@ -822,14 +819,9 @@ end
 Base.@propagate_inbounds column(data::VIFH, i, h) = column(data, i, 1, h)
 
 # Note: construct the subarray view directly as optimizer fails in Base.to_indices (v1.7)
-@inline function column(
-    data::VIFH{S, Nv, Ni, Nh},
-    i,
-    j,
-    h,
-) where {S, Nv, Ni, Nh}
+@inline function column(data::VIFH{S, Nv, Ni}, i, j, h) where {S, Nv, Ni}
     array = parent(data)
-    @boundscheck (1 <= i <= Ni && j == 1 && 1 <= h <= Nh) ||
+    @boundscheck (1 <= i <= Ni && j == 1 && 1 <= h <= get_Nh_dynamic(data)) ||
                  throw(BoundsError(data, (i, j, h)))
     Nf = ncomponents(data)
     dataview = @inbounds SubArray(
@@ -839,11 +831,11 @@ Base.@propagate_inbounds column(data::VIFH, i, h) = column(data, i, 1, h)
     VF{S, Nv}(dataview)
 end
 
-@inline function level(data::VIFH{S, Nv, Nij, Nh}, v) where {S, Nv, Nij, Nh}
+@inline function level(data::VIFH{S, Nv, Nij}, v) where {S, Nv, Nij}
     array = parent(data)
     @boundscheck (1 <= v <= Nv) || throw(BoundsError(data, (v,)))
     dataview = @inbounds view(array, v, :, :, :)
-    IFH{S, Nij, Nh}(dataview)
+    IFH{S, Nij}(dataview)
 end
 
 # =========================================
@@ -988,6 +980,25 @@ type parameters.
 @inline field_dim(::Type{<:VIJFH}) = 4
 @inline field_dim(::Type{<:VIFH}) = 3
 
+"""
+    h_dim(data::AbstractData)
+    h_dim(::Type{<:AbstractData})
+
+This is an internal function, please do not use outside of ClimaCore.
+
+Returns the horizontal element dimension in the backing array.
+
+This function is helpful for writing generic
+code, when reconstructing new datalayouts with new
+type parameters.
+"""
+@inline h_dim(data::AbstractData) = h_dim(typeof(data))
+@inline h_dim(::Type{<:IJKFVH}) = 5
+@inline h_dim(::Type{<:IJFH}) = 4
+@inline h_dim(::Type{<:IFH}) = 3
+@inline h_dim(::Type{<:VIJFH}) = 5
+@inline h_dim(::Type{<:VIFH}) = 4
+
 @inline to_data_specific(data::AbstractData, I::CartesianIndex) =
     CartesianIndex(_to_data_specific(data, I.I))
 @inline _to_data_specific(::VF, I::Tuple) = (I[4], 1)
@@ -1023,15 +1034,15 @@ code, when reconstructing new datalayouts with new
 type parameters.
 """
 @inline type_params(data::AbstractData) = type_params(typeof(data))
-@inline type_params(::Type{IJKFVH{S, Nij, Nk, Nv, Nh, A}}) where {S, Nij, Nk, Nv, Nh, A} = (S, Nij, Nk, Nv, Nh)
-@inline type_params(::Type{IJFH{S, Nij, Nh, A}}) where {S, Nij, Nh, A} = (S, Nij, Nh)
-@inline type_params(::Type{IFH{S, Ni, Nh, A}}) where {S, Ni, Nh, A} = (S, Ni, Nh)
+@inline type_params(::Type{IJKFVH{S, Nij, Nk, Nv, A}}) where {S, Nij, Nk, Nv, A} = (S, Nij, Nk, Nv)
+@inline type_params(::Type{IJFH{S, Nij, A}}) where {S, Nij, A} = (S, Nij)
+@inline type_params(::Type{IFH{S, Ni, A}}) where {S, Ni, A} = (S, Ni)
 @inline type_params(::Type{DataF{S, A}}) where {S, A} = (S,)
 @inline type_params(::Type{IJF{S, Nij, A}}) where {S, Nij, A} = (S, Nij)
 @inline type_params(::Type{IF{S, Ni, A}}) where {S, Ni, A} = (S, Ni)
 @inline type_params(::Type{VF{S, Nv, A}}) where {S, Nv, A} = (S, Nv)
-@inline type_params(::Type{VIJFH{S, Nv, Nij, Nh, A}}) where {S, Nv, Nij, Nh, A} = (S, Nv, Nij, Nh)
-@inline type_params(::Type{VIFH{S, Nv, Ni, Nh, A}}) where {S, Nv, Ni, Nh, A} = (S, Nv, Ni, Nh)
+@inline type_params(::Type{VIJFH{S, Nv, Nij, A}}) where {S, Nv, Nij, A} = (S, Nv, Nij)
+@inline type_params(::Type{VIFH{S, Nv, Ni, A}}) where {S, Nv, Ni, A} = (S, Nv, Ni)
 @inline type_params(::Type{IH1JH2{S, Nij, A}}) where {S, Nij, A} = (S, Nij)
 @inline type_params(::Type{IV1JH2{S, n1, Ni, A}}) where {S, n1, Ni, A} = (S, n1, Ni)
 
@@ -1074,15 +1085,15 @@ code, when reconstructing new datalayouts with new
 type parameters.
 """
 @inline array_size(data::AbstractData, i::Integer) = array_size(data)[i]
-@inline array_size(::IJKFVH{S, Nij, Nk, Nv, Nh}) where {S, Nij, Nk, Nv, Nh} = (Nij, Nij, Nk, 1, Nv, Nh)
-@inline array_size(::IJFH{S, Nij, Nh}) where {S, Nij, Nh} = (Nij, Nij, 1, Nh)
-@inline array_size(::IFH{S, Ni, Nh}) where {S, Ni, Nh} = (Ni, 1, Nh)
-@inline array_size(::DataF{S}) where {S} = (1,)
-@inline array_size(::IJF{S, Nij}) where {S, Nij} = (Nij, Nij, 1)
-@inline array_size(::IF{S, Ni}) where {S, Ni} = (Ni, 1)
-@inline array_size(::VF{S, Nv}) where {S, Nv} = (Nv, 1)
-@inline array_size(::VIJFH{S, Nv, Nij, Nh}) where {S, Nv, Nij, Nh} = (Nv, Nij, Nij, 1, Nh)
-@inline array_size(::VIFH{S, Nv, Ni, Nh}) where {S, Nv, Ni, Nh} = (Nv, Ni, 1, Nh)
+@inline array_size(data::IJKFVH{S, Nij, Nk, Nv}) where {S, Nij, Nk, Nv} = (Nij, Nij, Nk, 1, Nv, get_Nh_dynamic(data))
+@inline array_size(data::IJFH{S, Nij}) where {S, Nij} = (Nij, Nij, 1, get_Nh_dynamic(data))
+@inline array_size(data::IFH{S, Ni}) where {S, Ni} = (Ni, 1, get_Nh_dynamic(data))
+@inline array_size(data::DataF{S}) where {S} = (1,)
+@inline array_size(data::IJF{S, Nij}) where {S, Nij} = (Nij, Nij, 1)
+@inline array_size(data::IF{S, Ni}) where {S, Ni} = (Ni, 1)
+@inline array_size(data::VF{S, Nv}) where {S, Nv} = (Nv, 1)
+@inline array_size(data::VIJFH{S, Nv, Nij}) where {S, Nv, Nij} = (Nv, Nij, Nij, 1, get_Nh_dynamic(data))
+@inline array_size(data::VIFH{S, Nv, Ni}) where {S, Nv, Ni} = (Nv, Ni, 1, get_Nh_dynamic(data))
 
 """
     farray_size(data::AbstractData)
@@ -1096,15 +1107,15 @@ code, when reconstructing new datalayouts with new
 type parameters.
 """
 @inline farray_size(data::AbstractData, i::Integer) = farray_size(data)[i]
-@inline farray_size(data::IJKFVH{S, Nij, Nk, Nv, Nh}) where {S, Nij, Nk, Nv, Nh} = (Nij, Nij, Nk, ncomponents(data), Nv, Nh)
-@inline farray_size(data::IJFH{S, Nij, Nh}) where {S, Nij, Nh} = (Nij, Nij, ncomponents(data), Nh)
-@inline farray_size(data::IFH{S, Ni, Nh}) where {S, Ni, Nh} = (Ni, ncomponents(data), Nh)
+@inline farray_size(data::IJKFVH{S, Nij, Nk, Nv}) where {S, Nij, Nk, Nv} = (Nij, Nij, Nk, ncomponents(data), Nv, get_Nh_dynamic(data))
+@inline farray_size(data::IJFH{S, Nij}) where {S, Nij} = (Nij, Nij, ncomponents(data), get_Nh_dynamic(data))
+@inline farray_size(data::IFH{S, Ni}) where {S, Ni} = (Ni, ncomponents(data), get_Nh_dynamic(data))
 @inline farray_size(data::DataF{S}) where {S} = (ncomponents(data),)
 @inline farray_size(data::IJF{S, Nij}) where {S, Nij} = (Nij, Nij, ncomponents(data))
 @inline farray_size(data::IF{S, Ni}) where {S, Ni} = (Ni, ncomponents(data))
 @inline farray_size(data::VF{S, Nv}) where {S, Nv} = (Nv, ncomponents(data))
-@inline farray_size(data::VIJFH{S, Nv, Nij, Nh}) where {S, Nv, Nij, Nh} = (Nv, Nij, Nij, ncomponents(data), Nh)
-@inline farray_size(data::VIFH{S, Nv, Ni, Nh}) where {S, Nv, Ni, Nh} = (Nv, Ni, ncomponents(data), Nh)
+@inline farray_size(data::VIJFH{S, Nv, Nij}) where {S, Nv, Nij} = (Nv, Nij, Nij, ncomponents(data), get_Nh_dynamic(data))
+@inline farray_size(data::VIFH{S, Nv, Ni}) where {S, Nv, Ni} = (Nv, Ni, ncomponents(data), get_Nh_dynamic(data))
 
 # Keep in sync with definition(s) in libs.
 @inline slab_index(i::T, j::T) where {T} = CartesianIndex(i, j, T(1), T(1), T(1))
@@ -1125,17 +1136,17 @@ type parameters.
 @inline parent_array_type(data::AbstractData) = parent_array_type(typeof(data))
 # Equivalent to:
 # @generated parent_array_type(::Type{A}) where {A <: AbstractData} = Tuple(A.parameters)[end]
-@inline parent_array_type(::Type{IFH{S, Ni, Nh, A}}) where {S, Ni, Nh, A} = A
+@inline parent_array_type(::Type{IFH{S, Ni, A}}) where {S, Ni, A} = A
 @inline parent_array_type(::Type{DataF{S, A}}) where {S, A} = A
 @inline parent_array_type(::Type{IJF{S, Nij, A}}) where {S, Nij, A} = A
 @inline parent_array_type(::Type{IF{S, Ni, A}}) where {S, Ni, A} = A
 @inline parent_array_type(::Type{VF{S, Nv, A}}) where {S, Nv, A} = A
-@inline parent_array_type(::Type{VIJFH{S, Nv, Nij, Nh, A}}) where {S, Nv, Nij, Nh, A} = A
-@inline parent_array_type(::Type{VIFH{S, Nv, Ni, Nh, A}}) where {S, Nv, Ni, Nh, A} = A
-@inline parent_array_type(::Type{IJFH{S, Nij, Nh, A}}) where {S, Nij, Nh, A} = A
+@inline parent_array_type(::Type{VIJFH{S, Nv, Nij, A}}) where {S, Nv, Nij, A} = A
+@inline parent_array_type(::Type{VIFH{S, Nv, Ni, A}}) where {S, Nv, Ni, A} = A
+@inline parent_array_type(::Type{IJFH{S, Nij, A}}) where {S, Nij, A} = A
 @inline parent_array_type(::Type{IH1JH2{S, Nij, A}}) where {S, Nij, A} = A
 @inline parent_array_type(::Type{IV1JH2{S, n1, Ni, A}}) where {S, n1, Ni, A} = A
-@inline parent_array_type(::Type{IJKFVH{S, Nij, Nk, Nv, Nh, A}}) where {S, Nij, Nk, Nv, Nh, A} = A
+@inline parent_array_type(::Type{IJKFVH{S, Nij, Nk, Nv, A}}) where {S, Nij, Nk, Nv, A} = A
 
 #! format: on
 
diff --git a/src/DataLayouts/broadcast.jl b/src/DataLayouts/broadcast.jl
index 8be07a9662..ca7d921e83 100644
--- a/src/DataLayouts/broadcast.jl
+++ b/src/DataLayouts/broadcast.jl
@@ -23,12 +23,12 @@ DataStyle(::Type{VF{S, Nv, A}}) where {S, Nv, A} =
 DataColumnStyle(::Type{VFStyle{Nv, A}}) where {Nv, A} = VFStyle{Nv, A}
 
 abstract type Data1DStyle{Ni} <: DataStyle end
-struct IFHStyle{Ni, Nh, A} <: Data1DStyle{Ni} end
-DataStyle(::Type{IFH{S, Ni, Nh, A}}) where {S, Ni, Nh, A} =
-    IFHStyle{Ni, Nh, parent_array_type(A)}()
+struct IFHStyle{Ni, A} <: Data1DStyle{Ni} end
+DataStyle(::Type{IFH{S, Ni, A}}) where {S, Ni, A} =
+    IFHStyle{Ni, parent_array_type(A)}()
 
 abstract type DataSlab1DStyle{Ni} <: DataStyle end
-DataSlab1DStyle(::Type{IFHStyle{Ni, Nh, A}}) where {Ni, Nh, A} = IFStyle{Ni, A}
+DataSlab1DStyle(::Type{IFHStyle{Ni, A}}) where {Ni, A} = IFStyle{Ni, A}
 
 struct IFStyle{Ni, A} <: DataSlab1DStyle{Ni} end
 DataStyle(::Type{IF{S, Ni, A}}) where {S, Ni, A} =
@@ -40,32 +40,29 @@ DataStyle(::Type{IJF{S, Nij, A}}) where {S, Nij, A} =
     IJFStyle{Nij, parent_array_type(A)}()
 
 abstract type Data2DStyle{Nij} <: DataStyle end
-struct IJFHStyle{Nij, Nh, A} <: Data2DStyle{Nij} end
-DataStyle(::Type{IJFH{S, Nij, Nh, A}}) where {S, Nij, Nh, A} =
-    IJFHStyle{Nij, Nh, parent_array_type(A)}()
-DataSlab2DStyle(::Type{IJFHStyle{Nij, Nh, A}}) where {Nij, Nh, A} =
-    IJFStyle{Nij, A}
+struct IJFHStyle{Nij, A} <: Data2DStyle{Nij} end
+DataStyle(::Type{IJFH{S, Nij, A}}) where {S, Nij, A} =
+    IJFHStyle{Nij, parent_array_type(A)}()
+DataSlab2DStyle(::Type{IJFHStyle{Nij, A}}) where {Nij, A} = IJFStyle{Nij, A}
 
 abstract type Data1DXStyle{Nv, Ni} <: DataStyle end
-struct VIFHStyle{Nv, Ni, Nh, A} <: Data1DXStyle{Nv, Ni} end
-DataStyle(::Type{VIFH{S, Nv, Ni, Nh, A}}) where {S, Nv, Ni, Nh, A} =
-    VIFHStyle{Nv, Ni, Nh, parent_array_type(A)}()
-Data1DXStyle(::Type{VIFHStyle{Nv, Ni, Nh, A}}) where {Ni, Nv, Nh, A} =
-    VIFHStyle{Nv, Ni, Nh, A}
-DataColumnStyle(::Type{VIFHStyle{Nv, Ni, Nh, A}}) where {Ni, Nv, Nh, A} =
-    VFStyle{Nv, A}
-DataSlab1DStyle(::Type{VIFHStyle{Nv, Ni, Nh, A}}) where {Ni, Nv, Nh, A} =
-    IFStyle{Ni, A}
+struct VIFHStyle{Nv, Ni, A} <: Data1DXStyle{Nv, Ni} end
+DataStyle(::Type{VIFH{S, Nv, Ni, A}}) where {S, Nv, Ni, A} =
+    VIFHStyle{Nv, Ni, parent_array_type(A)}()
+Data1DXStyle(::Type{VIFHStyle{Nv, Ni, A}}) where {Ni, Nv, A} =
+    VIFHStyle{Nv, Ni, A}
+DataColumnStyle(::Type{VIFHStyle{Nv, Ni, A}}) where {Ni, Nv, A} = VFStyle{Nv, A}
+DataSlab1DStyle(::Type{VIFHStyle{Nv, Ni, A}}) where {Ni, Nv, A} = IFStyle{Ni, A}
 
 abstract type Data2DXStyle{Nv, Nij} <: DataStyle end
-struct VIJFHStyle{Nv, Nij, Nh, A} <: Data2DXStyle{Nv, Nij} end
-DataStyle(::Type{VIJFH{S, Nv, Nij, Nh, A}}) where {S, Nv, Nij, Nh, A} =
-    VIJFHStyle{Nv, Nij, Nh, parent_array_type(A)}()
-Data2DXStyle(::Type{VIJFHStyle{Nv, Nij, Nh, A}}) where {Nv, Nij, Nh, A} =
-    VIJFHStyle{Nv, Nij, Nh, A}
-DataColumnStyle(::Type{VIJFHStyle{Nv, Nij, Nh, A}}) where {Nv, Nij, Nh, A} =
+struct VIJFHStyle{Nv, Nij, A} <: Data2DXStyle{Nv, Nij} end
+DataStyle(::Type{VIJFH{S, Nv, Nij, A}}) where {S, Nv, Nij, A} =
+    VIJFHStyle{Nv, Nij, parent_array_type(A)}()
+Data2DXStyle(::Type{VIJFHStyle{Nv, Nij, A}}) where {Nv, Nij, A} =
+    VIJFHStyle{Nv, Nij, A}
+DataColumnStyle(::Type{VIJFHStyle{Nv, Nij, A}}) where {Nv, Nij, A} =
     VFStyle{Nv, A}
-DataSlab2DStyle(::Type{VIJFHStyle{Nv, Nij, Nh, A}}) where {Nv, Nij, Nh, A} =
+DataSlab2DStyle(::Type{VIJFHStyle{Nv, Nij, A}}) where {Nv, Nij, A} =
     IJFStyle{Nij, A}
 
 #####
@@ -73,12 +70,12 @@ DataSlab2DStyle(::Type{VIJFHStyle{Nv, Nij, Nh, A}}) where {Nv, Nij, Nh, A} =
 #####
 
 #! format: off
-const BroadcastedUnionIJFH{S, Nij, Nh, A}      = Union{Base.Broadcast.Broadcasted{IJFHStyle{Nij, Nh, A}}, IJFH{S, Nij, Nh, A}}
-const BroadcastedUnionIFH{S, Ni, Nh, A}        = Union{Base.Broadcast.Broadcasted{IFHStyle{Ni, Nh, A}}, IFH{S, Ni, Nh, A}}
+const BroadcastedUnionIJFH{S, Nij, A}      = Union{Base.Broadcast.Broadcasted{IJFHStyle{Nij, A}}, IJFH{S, Nij, A}}
+const BroadcastedUnionIFH{S, Ni, A}        = Union{Base.Broadcast.Broadcasted{IFHStyle{Ni, A}}, IFH{S, Ni, A}}
 const BroadcastedUnionIJF{S, Nij, A}           = Union{Base.Broadcast.Broadcasted{IJFStyle{Nij, A}}, IJF{S, Nij, A}}
 const BroadcastedUnionIF{S, Ni, A}             = Union{Base.Broadcast.Broadcasted{IFStyle{Ni, A}}, IF{S, Ni, A}}
-const BroadcastedUnionVIFH{S, Nv, Ni, Nh, A}   = Union{Base.Broadcast.Broadcasted{VIFHStyle{Nv, Ni, Nh, A}}, VIFH{S, Nv, Ni, Nh, A}}
-const BroadcastedUnionVIJFH{S, Nv, Nij, Nh, A} = Union{Base.Broadcast.Broadcasted{VIJFHStyle{Nv, Nij, Nh, A}}, VIJFH{S, Nv, Nij, Nh, A}}
+const BroadcastedUnionVIFH{S, Nv, Ni, A}   = Union{Base.Broadcast.Broadcasted{VIFHStyle{Nv, Ni, A}}, VIFH{S, Nv, Ni, A}}
+const BroadcastedUnionVIJFH{S, Nv, Nij, A} = Union{Base.Broadcast.Broadcasted{VIJFHStyle{Nv, Nij, A}}, VIJFH{S, Nv, Nij, A}}
 const BroadcastedUnionVF{S, Nv, A}             = Union{Base.Broadcast.Broadcasted{VFStyle{Nv, A}}, VF{S, Nv, A}}
 const BroadcastedUnionDataF{S, A}              = Union{Base.Broadcast.Broadcasted{DataFStyle{A}}, DataF{S, A}}
 #! format: on
@@ -111,28 +108,27 @@ Base.Broadcast.BroadcastStyle(
     ::IFStyle{Ni, A2},
 ) where {Ni, A1, A2} = IFStyle{Ni, promote_parent_array_type(A1, A2)}()
 Base.Broadcast.BroadcastStyle(
-    ::IFHStyle{Ni, Nh, A1},
-    ::IFHStyle{Ni, Nh, A2},
-) where {Ni, Nh, A1, A2} = IFHStyle{Ni, Nh, promote_parent_array_type(A1, A2)}()
+    ::IFHStyle{Ni, A1},
+    ::IFHStyle{Ni, A2},
+) where {Ni, A1, A2} = IFHStyle{Ni, promote_parent_array_type(A1, A2)}()
 Base.Broadcast.BroadcastStyle(
-    ::VIFHStyle{Nv, Ni, Nh, A1},
-    ::VIFHStyle{Nv, Ni, Nh, A2},
-) where {Nv, Ni, Nh, A1, A2} =
-    VIFHStyle{Nv, Ni, Nh, promote_parent_array_type(A1, A2)}()
+    ::VIFHStyle{Nv, Ni, A1},
+    ::VIFHStyle{Nv, Ni, A2},
+) where {Nv, Ni, A1, A2} =
+    VIFHStyle{Nv, Ni, promote_parent_array_type(A1, A2)}()
 Base.Broadcast.BroadcastStyle(
     ::IJFStyle{Nij, A1},
     ::IJFStyle{Nij, A2},
 ) where {Nij, A1, A2} = IJFStyle{Nij, promote_parent_array_type(A1, A2)}()
 Base.Broadcast.BroadcastStyle(
-    ::IJFHStyle{Nij, Nh, A1},
-    ::IJFHStyle{Nij, Nh, A2},
-) where {Nij, Nh, A1, A2} =
-    IJFHStyle{Nij, Nh, promote_parent_array_type(A1, A2)}()
+    ::IJFHStyle{Nij, A1},
+    ::IJFHStyle{Nij, A2},
+) where {Nij, A1, A2} = IJFHStyle{Nij, promote_parent_array_type(A1, A2)}()
 Base.Broadcast.BroadcastStyle(
-    ::VIJFHStyle{Nv, Nij, Nh, A1},
-    ::VIJFHStyle{Nv, Nij, Nh, A2},
-) where {Nv, Nij, Nh, A1, A2} =
-    VIJFHStyle{Nv, Nij, Nh, promote_parent_array_type(A1, A2)}()
+    ::VIJFHStyle{Nv, Nij, A1},
+    ::VIJFHStyle{Nv, Nij, A2},
+) where {Nv, Nij, A1, A2} =
+    VIJFHStyle{Nv, Nij, promote_parent_array_type(A1, A2)}()
 
 Base.Broadcast.BroadcastStyle(
     ::DataFStyle{A1},
@@ -151,62 +147,61 @@ Base.Broadcast.BroadcastStyle(
 
 Base.Broadcast.BroadcastStyle(
     ::DataFStyle{A1},
-    ::IFHStyle{Ni, Nh, A2},
-) where {Ni, Nh, A1, A2} = IFHStyle{Ni, Nh, promote_parent_array_type(A1, A2)}()
+    ::IFHStyle{Ni, A2},
+) where {Ni, A1, A2} = IFHStyle{Ni, promote_parent_array_type(A1, A2)}()
 
 Base.Broadcast.BroadcastStyle(
     ::DataFStyle{A1},
-    ::IJFHStyle{Nij, Nh, A2},
-) where {Nij, Nh, A1, A2} =
-    IJFHStyle{Nij, Nh, promote_parent_array_type(A1, A2)}()
+    ::IJFHStyle{Nij, A2},
+) where {Nij, A1, A2} = IJFHStyle{Nij, promote_parent_array_type(A1, A2)}()
 
 Base.Broadcast.BroadcastStyle(
     ::DataFStyle{A1},
-    ::VIFHStyle{Nv, Ni, Nh, A2},
-) where {Nv, Ni, Nh, A1, A2} =
-    VIFHStyle{Nv, Ni, Nh, promote_parent_array_type(A1, A2)}()
+    ::VIFHStyle{Nv, Ni, A2},
+) where {Nv, Ni, A1, A2} =
+    VIFHStyle{Nv, Ni, promote_parent_array_type(A1, A2)}()
 
 Base.Broadcast.BroadcastStyle(
     ::DataFStyle{A1},
-    ::VIJFHStyle{Nv, Nij, Nh, A2},
-) where {Nv, Nij, Nh, A1, A2} =
-    VIJFHStyle{Nv, Nij, Nh, promote_parent_array_type(A1, A2)}()
+    ::VIJFHStyle{Nv, Nij, A2},
+) where {Nv, Nij, A1, A2} =
+    VIJFHStyle{Nv, Nij, promote_parent_array_type(A1, A2)}()
 
 Base.Broadcast.BroadcastStyle(
     ::VFStyle{Nv, A1},
-    ::IFHStyle{Ni, Nh, A2},
-) where {Nv, Ni, Nh, A1, A2} =
-    VIFHStyle{Nv, Ni, Nh, promote_parent_array_type(A1, A2)}()
+    ::IFHStyle{Ni, A2},
+) where {Nv, Ni, A1, A2} =
+    VIFHStyle{Nv, Ni, promote_parent_array_type(A1, A2)}()
 
 Base.Broadcast.BroadcastStyle(
     ::VFStyle{Nv, A1},
-    ::IJFHStyle{Nij, Nh, A2},
-) where {Nv, Nij, Nh, A1, A2} =
-    VIJFHStyle{Nv, Nij, Nh, promote_parent_array_type(A1, A2)}()
+    ::IJFHStyle{Nij, A2},
+) where {Nv, Nij, A1, A2} =
+    VIJFHStyle{Nv, Nij, promote_parent_array_type(A1, A2)}()
 
 Base.Broadcast.BroadcastStyle(
     ::VFStyle{Nv, A1},
-    ::VIFHStyle{Nv, Ni, Nh, A2},
-) where {Nv, Ni, Nh, A1, A2} =
-    VIFHStyle{Nv, Ni, Nh, promote_parent_array_type(A1, A2)}()
+    ::VIFHStyle{Nv, Ni, A2},
+) where {Nv, Ni, A1, A2} =
+    VIFHStyle{Nv, Ni, promote_parent_array_type(A1, A2)}()
 
 Base.Broadcast.BroadcastStyle(
     ::VFStyle{Nv, A1},
-    ::VIJFHStyle{Nv, Nij, Nh, A2},
-) where {Nv, Nij, Nh, A1, A2} =
-    VIJFHStyle{Nv, Nij, Nh, promote_parent_array_type(A1, A2)}()
+    ::VIJFHStyle{Nv, Nij, A2},
+) where {Nv, Nij, A1, A2} =
+    VIJFHStyle{Nv, Nij, promote_parent_array_type(A1, A2)}()
 
 Base.Broadcast.BroadcastStyle(
-    ::IFHStyle{Ni, Nh, A1},
-    ::VIFHStyle{Nv, Ni, Nh, A2},
-) where {Nv, Ni, Nh, A1, A2} =
-    VIFHStyle{Nv, Ni, Nh, promote_parent_array_type(A1, A2)}()
+    ::IFHStyle{Ni, A1},
+    ::VIFHStyle{Nv, Ni, A2},
+) where {Nv, Ni, A1, A2} =
+    VIFHStyle{Nv, Ni, promote_parent_array_type(A1, A2)}()
 
 Base.Broadcast.BroadcastStyle(
-    ::IJFHStyle{Nij, Nh, A1},
-    ::VIJFHStyle{Nv, Nij, Nh, A2},
-) where {Nv, Nij, Nh, A1, A2} =
-    VIJFHStyle{Nv, Nij, Nh, promote_parent_array_type(A1, A2)}()
+    ::IJFHStyle{Nij, A1},
+    ::VIJFHStyle{Nv, Nij, A2},
+) where {Nv, Nij, A1, A2} =
+    VIJFHStyle{Nv, Nij, promote_parent_array_type(A1, A2)}()
 
 Base.Broadcast.broadcastable(data::AbstractData) = data
 
@@ -298,21 +293,23 @@ function Base.similar(
 end
 
 function Base.similar(
-    bc::BroadcastedUnionIJFH{<:Any, Nij, Nh, A},
+    bc::BroadcastedUnionIJFH{<:Any, Nij, A},
     ::Type{Eltype},
-) where {Nij, Nh, A, Eltype}
+    (_, _, _, _, Nh) = size(bc),
+) where {Nij, A, Eltype}
     PA = parent_array_type(A)
     array = similar(PA, (Nij, Nij, typesize(eltype(A), Eltype), Nh))
-    return IJFH{Eltype, Nij, Nh}(array)
+    return IJFH{Eltype, Nij}(array)
 end
 
 function Base.similar(
-    bc::BroadcastedUnionIFH{<:Any, Ni, Nh, A},
+    bc::BroadcastedUnionIFH{<:Any, Ni, A},
     ::Type{Eltype},
-) where {Ni, Nh, A, Eltype}
+    (_, _, _, _, Nh) = size(bc),
+) where {Ni, A, Eltype}
     PA = parent_array_type(A)
     array = similar(PA, (Ni, typesize(eltype(A), Eltype), Nh))
-    return IFH{Eltype, Ni, Nh}(array)
+    return IFH{Eltype, Ni}(array)
 end
 
 function Base.similar(
@@ -354,28 +351,30 @@ Base.similar(
 ) where {Nv, Eltype} = Base.similar(bc, Eltype, Val(Nv))
 
 function Base.similar(
-    bc::BroadcastedUnionVIFH{<:Any, Nv, Ni, Nh, A},
+    bc::BroadcastedUnionVIFH{<:Any, Nv, Ni, A},
     ::Type{Eltype},
     ::Val{newNv},
-) where {Nv, Ni, Nh, A, Eltype, newNv}
+) where {Nv, Ni, A, Eltype, newNv}
+    (_, _, _, _, Nh) = size(bc)
     PA = parent_array_type(A)
     array = similar(PA, (newNv, Ni, typesize(eltype(A), Eltype), Nh))
-    return VIFH{Eltype, newNv, Ni, Nh}(array)
+    return VIFH{Eltype, newNv, Ni}(array)
 end
 
 Base.similar(
-    bc::BroadcastedUnionVIJFH{<:Any, Nv, Nij, Nh, A},
+    bc::BroadcastedUnionVIJFH{<:Any, Nv, Nij, A},
     ::Type{Eltype},
-) where {Nv, Nij, Nh, A, Eltype} = similar(bc, Eltype, Val(Nv))
+) where {Nv, Nij, A, Eltype} = similar(bc, Eltype, Val(Nv))
 
 function Base.similar(
-    bc::BroadcastedUnionVIJFH{<:Any, Nv, Nij, Nh, A},
+    bc::BroadcastedUnionVIJFH{<:Any, Nv, Nij, A},
     ::Type{Eltype},
     ::Val{newNv},
-) where {Nv, Nij, Nh, A, Eltype, newNv}
+) where {Nv, Nij, A, Eltype, newNv}
+    (_, _, _, _, Nh) = size(bc)
     PA = parent_array_type(A)
     array = similar(PA, (newNv, Nij, Nij, typesize(eltype(A), Eltype), Nh))
-    return VIJFH{Eltype, newNv, Nij, Nh}(array)
+    return VIJFH{Eltype, newNv, Nij}(array)
 end
 
 # ============= FusedMultiBroadcast
diff --git a/src/DataLayouts/copyto.jl b/src/DataLayouts/copyto.jl
index 4a94638edb..a8b209c66d 100644
--- a/src/DataLayouts/copyto.jl
+++ b/src/DataLayouts/copyto.jl
@@ -47,9 +47,10 @@ end
 
 function Base.copyto!(
     dest::IJFH{S, Nij},
-    bc::BroadcastedUnionIJFH{S, Nij, Nh},
+    bc::BroadcastedUnionIJFH{S, Nij},
     ::ToCPU,
-) where {S, Nij, Nh}
+) where {S, Nij}
+    (_, _, _, _, Nh) = size(dest)
     @inbounds for h in 1:Nh
         slab_dest = slab(dest, h)
         slab_bc = slab(bc, h)
@@ -60,9 +61,10 @@ end
 
 function Base.copyto!(
     dest::IFH{S, Ni},
-    bc::BroadcastedUnionIFH{S, Ni, Nh},
+    bc::BroadcastedUnionIFH{S, Ni},
     ::ToCPU,
-) where {S, Ni, Nh}
+) where {S, Ni}
+    (_, _, _, _, Nh) = size(dest)
     @inbounds for h in 1:Nh
         slab_dest = slab(dest, h)
         slab_bc = slab(bc, h)
@@ -123,11 +125,12 @@ function Base.copyto!(
 end
 
 function Base.copyto!(
-    dest::VIFH{S, Nv, Ni, Nh},
-    bc::BroadcastedUnionVIFH{S, Nv, Ni, Nh},
+    dest::VIFH{S, Nv, Ni},
+    bc::BroadcastedUnionVIFH{S, Nv, Ni},
     ::ToCPU,
-) where {S, Nv, Ni, Nh}
+) where {S, Nv, Ni}
     # copy contiguous columns
+    (_, _, _, _, Nh) = size(dest)
     @inbounds for h in 1:Nh, i in 1:Ni
         col_dest = column(dest, i, h)
         col_bc = column(bc, i, h)
@@ -137,11 +140,12 @@ function Base.copyto!(
 end
 
 function Base.copyto!(
-    dest::VIJFH{S, Nv, Nij, Nh},
-    bc::BroadcastedUnionVIJFH{S, Nv, Nij, Nh},
+    dest::VIJFH{S, Nv, Nij},
+    bc::BroadcastedUnionVIJFH{S, Nv, Nij},
     ::ToCPU,
-) where {S, Nv, Nij, Nh}
+) where {S, Nv, Nij}
     # copy contiguous columns
+    (_, _, _, _, Nh) = size(dest)
     @inbounds for h in 1:Nh, j in 1:Nij, i in 1:Nij
         col_dest = column(dest, i, j, h)
         col_bc = column(bc, i, j, h)
diff --git a/src/DataLayouts/fused_copyto.jl b/src/DataLayouts/fused_copyto.jl
index 5ea26e908e..548c9fabf6 100644
--- a/src/DataLayouts/fused_copyto.jl
+++ b/src/DataLayouts/fused_copyto.jl
@@ -23,10 +23,11 @@ end
 
 function fused_copyto!(
     fmbc::FusedMultiBroadcast,
-    dest1::VIJFH{S1, Nv1, Nij, Nh},
+    dest1::VIJFH{S1, Nv1, Nij},
     ::ToCPU,
-) where {S1, Nv1, Nij, Nh}
+) where {S1, Nv1, Nij}
     for (dest, bc) in fmbc.pairs
+        (_, _, _, _, Nh) = size(dest1)
         # Base.copyto!(dest, bc) # we can just fall back like this
         @inbounds for h in 1:Nh, j in 1:Nij, i in 1:Nij, v in 1:Nv1
             I = CartesianIndex(i, j, 1, v, h)
@@ -39,12 +40,13 @@ end
 
 function fused_copyto!(
     fmbc::FusedMultiBroadcast,
-    dest1::IJFH{S, Nij, Nh},
+    dest1::IJFH{S, Nij},
     ::ToCPU,
-) where {S, Nij, Nh}
+) where {S, Nij}
     # copy contiguous columns
     _, _, _, Nv, _ = size(dest1)
     for (dest, bc) in fmbc.pairs
+        (_, _, _, _, Nh) = size(dest1)
         @inbounds for h in 1:Nh, j in 1:Nij, i in 1:Nij
             I = CartesianIndex(i, j, 1, 1, h)
             bcI = isascalar(bc) ? bc[] : bc[I]
@@ -56,11 +58,12 @@ end
 
 function fused_copyto!(
     fmbc::FusedMultiBroadcast,
-    dest1::VIFH{S, Nv1, Ni, Nh},
+    dest1::VIFH{S, Nv1, Ni},
     ::ToCPU,
-) where {S, Nv1, Ni, Nh}
+) where {S, Nv1, Ni}
     # copy contiguous columns
     for (dest, bc) in fmbc.pairs
+        (_, _, _, _, Nh) = size(dest1)
         @inbounds for h in 1:Nh, i in 1:Ni, v in 1:Nv1
             I = CartesianIndex(i, 1, 1, v, h)
             bcI = isascalar(bc) ? bc[] : bc[I]
diff --git a/src/DataLayouts/mapreduce.jl b/src/DataLayouts/mapreduce.jl
index 0f9f02eb0c..a67f86941f 100644
--- a/src/DataLayouts/mapreduce.jl
+++ b/src/DataLayouts/mapreduce.jl
@@ -15,9 +15,10 @@ end
 function Base.mapreduce(
     fn::F,
     op::Op,
-    bc::BroadcastedUnionIJFH{<:Any, Nij, Nh, A},
-) where {F, Op, Nij, Nh, A}
+    bc::BroadcastedUnionIJFH{<:Any, Nij, A},
+) where {F, Op, Nij, A}
     # mapreduce across DataSlab2D
+    (_, _, _, _, Nh) = size(bc)
     mapreduce(op, 1:Nh) do h
         Base.@_inline_meta
         slabview = @inbounds slab(bc, h)
@@ -28,9 +29,10 @@ end
 function Base.mapreduce(
     fn::F,
     op::Op,
-    bc::BroadcastedUnionIFH{<:Any, Ni, Nh, A},
-) where {F, Op, Ni, Nh, A}
+    bc::BroadcastedUnionIFH{<:Any, Ni, A},
+) where {F, Op, Ni, A}
     # mapreduce across DataSlab1D
+    (_, _, _, _, Nh) = size(bc)
     mapreduce(op, 1:Nh) do h
         Base.@_inline_meta
         slabview = @inbounds slab(bc, h)
@@ -75,9 +77,10 @@ end
 function Base.mapreduce(
     fn::F,
     op::Op,
-    bc::BroadcastedUnionVIFH{<:Any, Nv, Ni, Nh, A},
-) where {F, Op, Nv, Ni, Nh, A}
+    bc::BroadcastedUnionVIFH{<:Any, Nv, Ni, A},
+) where {F, Op, Nv, Ni, A}
     # mapreduce across columns
+    (_, _, _, _, Nh) = size(bc)
     mapreduce(op, Iterators.product(1:Ni, 1:Nh)) do (i, h)
         Base.@_inline_meta
         columnview = @inbounds column(bc, i, h)
@@ -88,9 +91,10 @@ end
 function Base.mapreduce(
     fn::F,
     op::Op,
-    bc::BroadcastedUnionVIJFH{<:Any, Nv, Nij, Nh, A},
-) where {F, Op, Nv, Nij, Nh, A}
+    bc::BroadcastedUnionVIJFH{<:Any, Nv, Nij, A},
+) where {F, Op, Nv, Nij, A}
     # mapreduce across columns
+    (_, _, _, _, Nh) = size(bc)
     mapreduce(op, Iterators.product(1:Nij, 1:Nij, 1:Nh)) do (i, j, h)
         Base.@_inline_meta
         columnview = @inbounds column(bc, i, j, h)
diff --git a/src/Grids/spectralelement.jl b/src/Grids/spectralelement.jl
index c021421a54..c304b2e86f 100644
--- a/src/Grids/spectralelement.jl
+++ b/src/Grids/spectralelement.jl
@@ -60,7 +60,7 @@ function _SpectralElementGrid1D(
     Nq = Quadratures.degrees_of_freedom(quadrature_style)
 
     LG = Geometry.LocalGeometry{AIdx, CoordType, FT, SMatrix{1, 1, FT, 1}}
-    local_geometry = DataLayouts.IFH{LG, Nq, Nh}(Array{FT})
+    local_geometry = DataLayouts.IFH{LG, Nq}(Array{FT}, Nh)
     quad_points, quad_weights =
         Quadratures.quadrature_points(FT, quadrature_style)
 
@@ -241,7 +241,7 @@ function _SpectralElementGrid2D(
 
     LG = Geometry.LocalGeometry{AIdx, CoordType2D, FT, SMatrix{2, 2, FT, 4}}
 
-    local_geometry = DataLayouts.IJFH{LG, Nq, Nh}(Array{FT})
+    local_geometry = DataLayouts.IJFH{LG, Nq}(Array{FT}, Nh)
 
     quad_points, quad_weights =
         Quadratures.quadrature_points(FT, quadrature_style)
@@ -399,7 +399,7 @@ function _SpectralElementGrid2D(
 
     if quadrature_style isa Quadratures.GLL
         internal_surface_geometry =
-            DataLayouts.IFH{SG, Nq, length(interior_faces)}(Array{FT})
+            DataLayouts.IFH{SG, Nq}(Array{FT}, length(interior_faces))
         for (iface, (lidx⁻, face⁻, lidx⁺, face⁺, reversed)) in
             enumerate(interior_faces)
             internal_surface_geometry_slab =
@@ -438,7 +438,7 @@ function _SpectralElementGrid2D(
                 boundary_faces =
                     Topologies.boundary_faces(topology, boundarytag)
                 boundary_surface_geometry =
-                    DataLayouts.IFH{SG, Nq, length(boundary_faces)}(Array{FT})
+                    DataLayouts.IFH{SG, Nq}(Array{FT}, length(boundary_faces))
                 for (iface, (elem, face)) in enumerate(boundary_faces)
                     boundary_surface_geometry_slab =
                         slab(boundary_surface_geometry, iface)
diff --git a/src/InputOutput/readers.jl b/src/InputOutput/readers.jl
index 744699ecf4..6affc65d43 100644
--- a/src/InputOutput/readers.jl
+++ b/src/InputOutput/readers.jl
@@ -154,15 +154,16 @@ function _scan_data_layout(layoutstring::AbstractString)
     return DataLayouts.VIFH
 end
 
-function Nh_dim(layoutstring::AbstractString)
-    @assert layoutstring ∈ ("IJFH", "IJF", "IFH", "IF", "VIJFH", "VIFH")
-    layoutstring == "IJFH" && return 4
-    layoutstring == "IJF" && return -1
-    layoutstring == "IFH" && return 3
-    layoutstring == "IF" && return -1
-    layoutstring == "VIJFH" && return 5
-    return 4
-end
+# for when Nh is in type-domain
+# function Nh_dim(layoutstring::AbstractString)
+#     @assert layoutstring ∈ ("IJFH", "IJF", "IFH", "IF", "VIJFH", "VIFH")
+#     layoutstring == "IJFH" && return 4
+#     layoutstring == "IJF" && return -1
+#     layoutstring == "IFH" && return 3
+#     layoutstring == "IF" && return -1
+#     layoutstring == "VIJFH" && return 5
+#     return 4
+# end
 
 """
     matrix_to_cartesianindices(elemorder_matrix)
@@ -474,14 +475,17 @@ function read_field(reader::HDF5Reader, name::AbstractString)
         data_layout = attrs(obj)["data_layout"]
         Nij = size(data, findfirst("I", data_layout)[1])
         DataLayout = _scan_data_layout(data_layout)
-        Nhd = Nh_dim(data_layout)
-        Nht = Nhd == -1 ? () : (size(data, Nhd),)
+        # For when `Nh` is added back to the type space
+        #     Nhd = Nh_dim(data_layout)
+        #     Nht = Nhd == -1 ? () : (size(data, Nhd),)
         ElType = eval(Meta.parse(attrs(obj)["value_type"]))
         if data_layout in ("VIJFH", "VIFH")
             Nv = size(data, 1)
-            values = DataLayout{ElType, Nv, Nij, Nht...}(data)
+            # values = DataLayout{ElType, Nv, Nij, Nht...}(data) # when Nh is in type-domain
+            values = DataLayout{ElType, Nv, Nij}(data)
         else
-            values = DataLayout{ElType, Nij, Nht...}(data)
+            # values = DataLayout{ElType, Nij, Nht...}(data) # when Nh is in type-domain
+            values = DataLayout{ElType, Nij}(data)
         end
         return Fields.Field(values, space)
     elseif type == "FieldVector"
diff --git a/src/Limiters/quasimonotone.jl b/src/Limiters/quasimonotone.jl
index 0fa200b171..9f41645948 100644
--- a/src/Limiters/quasimonotone.jl
+++ b/src/Limiters/quasimonotone.jl
@@ -72,14 +72,14 @@ function make_q_bounds(
 ) where {S}
     Nf = DataLayouts.ncomponents(ρq)
     _, _, _, _, Nh = size(ρq)
-    return DataLayouts.IFH{S, 2, Nh}(similar(parent(ρq), (2, Nf, Nh)))
+    return DataLayouts.IFH{S, 2}(similar(parent(ρq), (2, Nf, Nh)))
 end
 function make_q_bounds(
     ρq::Union{DataLayouts.VIFH{S}, DataLayouts.VIJFH{S}},
 ) where {S}
     Nf = DataLayouts.ncomponents(ρq)
     _, _, _, Nv, Nh = size(ρq)
-    return DataLayouts.VIFH{S, Nv, 2, Nh}(similar(parent(ρq), (Nv, 2, Nf, Nh)))
+    return DataLayouts.VIFH{S, Nv, 2}(similar(parent(ρq), (Nv, 2, Nf, Nh)))
 end
 
 
diff --git a/src/Topologies/dss.jl b/src/Topologies/dss.jl
index 4253b10c87..6c17fc6be2 100644
--- a/src/Topologies/dss.jl
+++ b/src/Topologies/dss.jl
@@ -69,8 +69,7 @@ function create_dss_buffer(
     else
         _transformed_type(data, local_geometry, local_weights, DA) # extract transformed type
     end
-    perimeter_data =
-        DataLayouts.VIFH{TS, Nv, Np, Nh}(DA{T}(undef, Nv, Np, Nf, Nh))
+    perimeter_data = DataLayouts.VIFH{TS, Nv, Np}(DA{T}(undef, Nv, Np, Nf, Nh))
     if context isa ClimaComms.SingletonCommsContext
         graph_context = ClimaComms.SingletonGraphContext(context)
         send_data, recv_data = T[], T[]
diff --git a/src/Topologies/dss_transform.jl b/src/Topologies/dss_transform.jl
index 6682b9fd2f..5cd23a3470 100644
--- a/src/Topologies/dss_transform.jl
+++ b/src/Topologies/dss_transform.jl
@@ -255,27 +255,27 @@ create_ghost_buffer(
 ) where {S, Nij} = create_ghost_buffer(
     data,
     topology,
-    Val(Topologies.nsendelems(topology)),
-    Val(Topologies.nrecvelems(topology)),
+    Topologies.nsendelems(topology),
+    Topologies.nrecvelems(topology),
 )
 
 
 function create_ghost_buffer(
     data::Union{DataLayouts.IJFH{S, Nij}, DataLayouts.VIJFH{S, <:Any, Nij}},
     topology::Topologies.Topology2D,
-    ::Val{Nhsend},
-    ::Val{Nhrec},
-) where {S, Nij, Nhsend, Nhrec}
+    Nhsend,
+    Nhrec,
+) where {S, Nij}
     if data isa DataLayouts.IJFH
-        send_data = DataLayouts.IJFH{S, Nij, Nhsend}(typeof(parent(data)))
-        recv_data = DataLayouts.IJFH{S, Nij, Nhrec}(typeof(parent(data)))
+        send_data = DataLayouts.IJFH{S, Nij}(typeof(parent(data)), Nhsend)
+        recv_data = DataLayouts.IJFH{S, Nij}(typeof(parent(data)), Nhrec)
         k = stride(parent(send_data), 4)
     else
         Nv, _, _, Nf, _ = DataLayouts.farray_size(data)
-        send_data = DataLayouts.VIJFH{S, Nv, Nij, Nhsend}(
+        send_data = DataLayouts.VIJFH{S, Nv, Nij}(
             similar(parent(data), (Nv, Nij, Nij, Nf, Nhsend)),
         )
-        recv_data = DataLayouts.VIJFH{S, Nv, Nij, Nhrec}(
+        recv_data = DataLayouts.VIJFH{S, Nv, Nij}(
             similar(parent(data), (Nv, Nij, Nij, Nf, Nhrec)),
         )
         k = stride(parent(send_data), 5)
diff --git a/src/deprecated.jl b/src/deprecated.jl
index e45f26c174..7643535fae 100644
--- a/src/deprecated.jl
+++ b/src/deprecated.jl
@@ -27,29 +27,3 @@ import .DataLayouts
 @deprecate FiniteDifferenceGrid(mesh::IntervalMesh) FiniteDifferenceGrid(
     IntervalTopology(ClimaComms.device(), mesh),
 )
-
-@deprecate DataLayouts.IJFH{S, Nij}(
-    ::Type{ArrayType},
-    nelements,
-) where {S, Nij, ArrayType} DataLayouts.IJFH{S, Nij, nelements}(ArrayType) false
-
-@deprecate DataLayouts.IJFH{S, Nij}(
-    array::AbstractArray{T, 4},
-) where {S, Nij, T} DataLayouts.IJFH{S, Nij, size(array, 4)}(array) false
-@deprecate DataLayouts.IFH{S, Ni}(array::AbstractArray{T, 3}) where {S, Ni, T} DataLayouts.IFH{
-    S,
-    Ni,
-    size(array, 3),
-}(
-    array,
-) false
-@deprecate DataLayouts.IFH{S, Ni}(
-    ::Type{ArrayType},
-    nelements,
-) where {S, Ni, ArrayType} DataLayouts.IFH{S, Ni, nelements}(ArrayType) false
-@deprecate DataLayouts.VIJFH{S, Nv, Nij}(
-    array::AbstractArray{T, 5},
-) where {S, Nv, Nij, T} DataLayouts.VIJFH{S, Nv, Nij, size(array, 5)}(array) false
-@deprecate DataLayouts.VIFH{S, Nv, Ni}(
-    array::AbstractArray{T, 4},
-) where {S, Nv, Ni, T} DataLayouts.VIFH{S, Nv, Ni, size(array, 4)}(array) false
diff --git a/test/DataLayouts/benchmark_copyto.jl b/test/DataLayouts/benchmark_copyto.jl
index 2ad9a1c467..737d1bf523 100644
--- a/test/DataLayouts/benchmark_copyto.jl
+++ b/test/DataLayouts/benchmark_copyto.jl
@@ -49,17 +49,27 @@ end
     Nh = 30 * 30 * 6
     Nk = 6
     bm = Benchmark(; float_type = FT, device_name)
-#! format: off
-    data = DataF{S}(device_zeros(FT,Nf));                        benchmarkcopyto!(bm, device, data, 3); @test all(parent(data) .== 3)
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));     benchmarkcopyto!(bm, device, data, 3); @test all(parent(data) .== 3)
-    data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));          benchmarkcopyto!(bm, device, data, 3); @test all(parent(data) .== 3)
+    data = DataF{S}(device_zeros(FT, Nf))
+    benchmarkcopyto!(bm, device, data, 3)
+    @test all(parent(data) .== 3)
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    benchmarkcopyto!(bm, device, data, 3)
+    @test all(parent(data) .== 3)
+    data = IFH{S, Nij}(device_zeros(FT, Nij, Nf, Nh))
+    benchmarkcopyto!(bm, device, data, 3)
+    @test all(parent(data) .== 3)
     # The parent array of IJF and IF datalayouts are MArrays, and can therefore not bm, be passed into CUDA kernels on the RHS.
     # data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));             benchmarkcopyto!(bm, device, data, 3); @test all(parent(data) .== 3)
     # data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                  benchmarkcopyto!(bm, device, data, 3); @test all(parent(data) .== 3)
-    data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                    benchmarkcopyto!(bm, device, data, 3); @test all(parent(data) .== 3)
-    data = VIJFH{S,Nv,Nij,Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));benchmarkcopyto!(bm, device, data, 3); @test all(parent(data) .== 3)
-    data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));  benchmarkcopyto!(bm, device, data, 3); @test all(parent(data) .== 3)
-#! format: on
+    data = VF{S, Nv}(device_zeros(FT, Nv, Nf))
+    benchmarkcopyto!(bm, device, data, 3)
+    @test all(parent(data) .== 3)
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    benchmarkcopyto!(bm, device, data, 3)
+    @test all(parent(data) .== 3)
+    data = VIFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nf, Nh))
+    benchmarkcopyto!(bm, device, data, 3)
+    @test all(parent(data) .== 3)
 
     # data = IJKFVH{S}(device_zeros(FT,Nij,Nij,Nk,Nf,Nh)); benchmarkcopyto!(bm, device, data, 3); @test all(parent(data) .== 3) # TODO: test
     # data = IH1JH2{S}(device_zeros(FT,Nij,Nij,Nk,Nf,Nh)); benchmarkcopyto!(bm, device, data, 3); @test all(parent(data) .== 3) # TODO: test
diff --git a/test/DataLayouts/benchmark_fill.jl b/test/DataLayouts/benchmark_fill.jl
index f05b2be785..e067d414c7 100644
--- a/test/DataLayouts/benchmark_fill.jl
+++ b/test/DataLayouts/benchmark_fill.jl
@@ -46,16 +46,30 @@ end
     Nh = 30 * 30 * 6
     Nk = 6
     bm = Benchmark(; float_type = FT, device_name)
-#! format: off
-    data = DataF{S}(device_zeros(FT,Nf));                        benchmarkfill!(bm, device, data, 3, "DataF" ); @test all(parent(data) .== 3)
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));     benchmarkfill!(bm, device, data, 3, "IJFH"  ); @test all(parent(data) .== 3)
-    data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));          benchmarkfill!(bm, device, data, 3, "IFH"   ); @test all(parent(data) .== 3)
-    data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));             benchmarkfill!(bm, device, data, 3, "IJF"   ); @test all(parent(data) .== 3)
-    data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                  benchmarkfill!(bm, device, data, 3, "IF"    ); @test all(parent(data) .== 3)
-    data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                    benchmarkfill!(bm, device, data, 3, "VF"    ); @test all(parent(data) .== 3)
-    data = VIJFH{S,Nv,Nij,Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));benchmarkfill!(bm, device, data, 3, "VIJFH" ); @test all(parent(data) .== 3)
-    data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));  benchmarkfill!(bm, device, data, 3, "VIFH"  ); @test all(parent(data) .== 3)
-#! format: on
+    data = DataF{S}(device_zeros(FT, Nf))
+    benchmarkfill!(bm, device, data, 3, "DataF")
+    @test all(parent(data) .== 3)
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    benchmarkfill!(bm, device, data, 3, "IJFH")
+    @test all(parent(data) .== 3)
+    data = IFH{S, Nij}(device_zeros(FT, Nij, Nf, Nh))
+    benchmarkfill!(bm, device, data, 3, "IFH")
+    @test all(parent(data) .== 3)
+    data = IJF{S, Nij}(device_zeros(FT, Nij, Nij, Nf))
+    benchmarkfill!(bm, device, data, 3, "IJF")
+    @test all(parent(data) .== 3)
+    data = IF{S, Nij}(device_zeros(FT, Nij, Nf))
+    benchmarkfill!(bm, device, data, 3, "IF")
+    @test all(parent(data) .== 3)
+    data = VF{S, Nv}(device_zeros(FT, Nv, Nf))
+    benchmarkfill!(bm, device, data, 3, "VF")
+    @test all(parent(data) .== 3)
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    benchmarkfill!(bm, device, data, 3, "VIJFH")
+    @test all(parent(data) .== 3)
+    data = VIFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nf, Nh))
+    benchmarkfill!(bm, device, data, 3, "VIFH")
+    @test all(parent(data) .== 3)
 
     # data = IJKFVH{S}(device_zeros(FT,Nij,Nij,Nk,Nf,Nh)); benchmarkfill!(bm, device, data, 3); @test all(parent(data) .== 3) # TODO: test
     # data = IH1JH2{S}(device_zeros(FT,Nij,Nij,Nk,Nf,Nh)); benchmarkfill!(bm, device, data, 3); @test all(parent(data) .== 3) # TODO: test
diff --git a/test/DataLayouts/cuda.jl b/test/DataLayouts/cuda.jl
index b954117903..d684b82988 100644
--- a/test/DataLayouts/cuda.jl
+++ b/test/DataLayouts/cuda.jl
@@ -32,8 +32,8 @@ end
     device = ClimaComms.device()
     ArrayType = ClimaComms.array_type(device)
     Nh = 10
-    src = IJFH{S, 4, Nh}(ArrayType(rand(4, 4, 3, Nh)))
-    dst = IJFH{S, 4, Nh}(ArrayType(zeros(4, 4, 3, Nh)))
+    src = IJFH{S, 4}(ArrayType(rand(4, 4, 3, Nh)))
+    dst = IJFH{S, 4}(ArrayType(zeros(4, 4, 3, Nh)))
 
     test_copy!(dst, src)
 
@@ -49,8 +49,8 @@ end
     ArrayType = ClimaComms.array_type(device)
     data_arr1 = ArrayType(ones(FT, 2, 2, 3, Nh))
     data_arr2 = ArrayType(ones(FT, 2, 2, 1, Nh))
-    data1 = IJFH{S1, 2, Nh}(data_arr1)
-    data2 = IJFH{S2, 2, Nh}(data_arr2)
+    data1 = IJFH{S1, 2}(data_arr1)
+    data2 = IJFH{S2, 2}(data_arr2)
 
     f1(a1, a2) = a1.a.re * a2 + a1.b
     res = f1.(data1, data2)
@@ -60,8 +60,8 @@ end
     Nv = 33
     data_arr1 = ArrayType(ones(FT, Nv, 4, 4, 3, 2))
     data_arr2 = ArrayType(ones(FT, Nv, 4, 4, 1, 2))
-    data1 = VIJFH{S1, Nv, 4, Nh}(data_arr1)
-    data2 = VIJFH{S2, Nv, 4, Nh}(data_arr2)
+    data1 = VIJFH{S1, Nv, 4}(data_arr1)
+    data2 = VIJFH{S2, Nv, 4}(data_arr2)
 
     f2(a1, a2) = a1.a.re * a2 + a1.b
     res = f2.(data1, data2)
@@ -77,13 +77,14 @@ end
     Nh = 3
     device = ClimaComms.device()
     ArrayType = ClimaComms.array_type(device)
-    data = IJFH{S, 2, Nh}(ArrayType{FT})
+    array = similar(ArrayType{FT}, 2, 2, 2, Nh)
+    data = IJFH{S, 2}(array)
     data .= Complex(1.0, 2.0)
     @test Array(parent(data)) ==
           FT[f == 1 ? 1 : 2 for i in 1:2, j in 1:2, f in 1:2, h in 1:3]
 
     Nv = 33
-    data = VIJFH{S, Nv, 4, Nh}(ArrayType{FT}(undef, Nv, 4, 4, 2, Nh))
+    data = VIJFH{S, Nv, 4}(ArrayType{FT}(undef, Nv, 4, 4, 2, Nh))
     data .= Complex(1.0, 2.0)
     @test Array(parent(data)) == FT[
         f == 1 ? 1 : 2 for v in 1:Nv, i in 1:4, j in 1:4, f in 1:2, h in 1:3
diff --git a/test/DataLayouts/data0d.jl b/test/DataLayouts/data0d.jl
index 5a2425f8b9..6e71ef7331 100644
--- a/test/DataLayouts/data0d.jl
+++ b/test/DataLayouts/data0d.jl
@@ -130,7 +130,7 @@ end
     S = Complex{FT}
     Nh = 3
     data_f = DataF{S}(ones(FT, 2))
-    data_ifh = IFH{S, 2, Nh}(ones(FT, 2, 2, Nh))
+    data_ifh = IFH{S, 2}(ones(FT, 2, 2, Nh))
     data_ifh2 = data_f .+ data_ifh
     @test data_ifh2 isa IFH{S}
     @test size(data_ifh2) == (2, 1, 1, 1, 3)
@@ -151,7 +151,7 @@ end
     S = Complex{FT}
     Nh = 3
     data_f = DataF{S}(ones(FT, 2))
-    data_ijfh = IJFH{S, 2, Nh}(ones(2, 2, 2, Nh))
+    data_ijfh = IJFH{S, 2}(ones(2, 2, 2, Nh))
     data_ijfh2 = data_f .+ data_ijfh
     @test data_ijfh2 isa IJFH{S}
     @test size(data_ijfh2) == (2, 2, 1, 1, Nh)
@@ -163,7 +163,7 @@ end
     Nh = 10
     data_f = DataF{S}(ones(FT, 2))
     Nv = 10
-    data_vifh = VIFH{S, Nv, 4, Nh}(ones(FT, Nv, 4, 2, Nh))
+    data_vifh = VIFH{S, Nv, 4}(ones(FT, Nv, 4, 2, Nh))
     data_vifh2 = data_f .+ data_vifh
     @test data_vifh2 isa VIFH{S, Nv}
     @test size(data_vifh2) == (4, 1, 1, Nv, Nh)
@@ -175,9 +175,9 @@ end
     Nv = 2
     Nh = 2
     data_f = DataF{S}(ones(FT, 2))
-    data_vijfh = VIJFH{S, Nv, 2, Nh}(ones(FT, Nv, 2, 2, 2, Nh))
+    data_vijfh = VIJFH{S, Nv, 2}(ones(FT, Nv, 2, 2, 2, Nh))
     data_vijfh2 = data_f .+ data_vijfh
-    @test data_vijfh2 isa VIJFH{S, Nv, Nh}
+    @test data_vijfh2 isa VIJFH{S, Nv}
     @test size(data_vijfh2) == (2, 2, 1, Nv, Nh)
 end
 
@@ -198,7 +198,7 @@ end
     Nh = 3
     array = ones(FT, 2, 2, Nh)
     array[1, :, 1] .= FT[3, 4]
-    data_ifh = IFH{S, 2, Nh}(array)
+    data_ifh = IFH{S, 2}(array)
     ifh_column = column(data_ifh, 1, 1)
     @test ifh_column isa DataF
     @test ifh_column[] == 3.0 + 4.0im
@@ -225,7 +225,7 @@ end
     Nh = 3
     array = ones(2, 2, 2, 3)
     array[1, 1, :, 2] .= FT[3, 4]
-    data_ijfh = IJFH{S, 2, Nh}(array)
+    data_ijfh = IJFH{S, 2}(array)
     ijfh_column = column(data_ijfh, 1, 1, 2)
     @test ijfh_column isa DataF
     @test ijfh_column[] == 3.0 + 4.0im
diff --git a/test/DataLayouts/data1dx.jl b/test/DataLayouts/data1dx.jl
index ece0c50d3a..8322ca03aa 100644
--- a/test/DataLayouts/data1dx.jl
+++ b/test/DataLayouts/data1dx.jl
@@ -18,7 +18,7 @@ import ClimaCore.DataLayouts: VIFH, slab, column, VF, IFH, vindex, slab_index
         # 10 elements in horizontal with 4 nodal points per element in horizontal
         array = rand(FT, Nv, Ni, 3, Nh)
 
-        data = VIFH{S, Nv, Ni, Nh}(array)
+        data = VIFH{S, Nv, Ni}(array)
         sum(x -> x[2], data)
 
         @test getfield(data.:1, :array) == @view(array[:, :, 1:2, :])
@@ -51,7 +51,7 @@ end
 
     S = Tuple{Complex{Float64}, Float64}
     array = zeros(Float64, Nv, Ni, 3, Nh)
-    data = VIFH{S, Nv, Ni, Nh}(array)
+    data = VIFH{S, Nv, Ni}(array)
 
     @test_throws BoundsError slab(data, -1, -1)
     @test_throws BoundsError slab(data, 1, 3)
@@ -77,7 +77,7 @@ end
     SB = (c = 1.0, d = 2.0)
 
     array = zeros(Float64, Nv, Ni, 2, Nh)
-    data = VIFH{typeof(SA), Nv, Ni, Nh}(array)
+    data = VIFH{typeof(SA), Nv, Ni}(array)
 
     cdata = column(data, 1, 1)
     cdata[slab_index(1)] = SA
@@ -95,7 +95,7 @@ end
     Nh = 2
     data1 = ones(FT, Nv, 2, 2, 2)
     S = Complex{Float64}
-    data1 = VIFH{S, Nv, 2, Nh}(data1)
+    data1 = VIFH{S, Nv, 2}(data1)
     res = data1 .+ 1
     @test res isa VIFH{S, Nv}
     @test parent(res) ==
@@ -110,7 +110,7 @@ end
     Nv = 3
     Nh = 2
     data_vf = VF{S, Nv}(ones(FT, Nv, 2))
-    data_ifh = IFH{FT, 2, Nh}(ones(FT, 2, 1, 2))
+    data_ifh = IFH{FT, 2}(ones(FT, 2, 1, 2))
     data_vifh = data_vf .+ data_ifh
     @test data_vifh isa VIFH{S, Nv}
     @test size(data_vifh) == (2, 1, 1, 3, 2)
@@ -127,7 +127,7 @@ end
 @testset "fill" begin
 
     Nh = 3
-    data = IFH{Float64, 3, Nh}(ones(3, 1, Nh))
+    data = IFH{Float64, 3}(ones(3, 1, Nh))
     data .= 2.0
     @test all(==(2.0), parent(data))
 end
diff --git a/test/DataLayouts/data2d.jl b/test/DataLayouts/data2d.jl
index 4bdfdd0800..8d1fd03894 100644
--- a/test/DataLayouts/data2d.jl
+++ b/test/DataLayouts/data2d.jl
@@ -46,7 +46,7 @@ end
     Nh = 2 # number of elements
     S = Tuple{Complex{Float64}, Float64}
     array = rand(Nij, Nij, 3, Nh)
-    data = IJFH{S, 2, Nh}(array)
+    data = IJFH{S, 2}(array)
     @test getfield(data.:1, :array) == @view(array[:, :, 1:2, :])
     data_slab = slab(data, 1)
     @test data_slab[slab_index(2, 1)] ==
@@ -71,7 +71,7 @@ end
     Nh = 2 # number of elements
     S = Tuple{Complex{Float64}, Float64}
     array = zeros(Float64, Nij, Nij, 3, Nh)
-    data = IJFH{S, Nij, Nh}(array)
+    data = IJFH{S, Nij}(array)
 
     @test_throws BoundsError slab(data, -1)
     @test_throws BoundsError slab(data, 3)
@@ -95,7 +95,7 @@ end
     SB = (c = 1.0, d = 2.0)
 
     array = zeros(Float64, Nij, Nij, 2, Nh)
-    data = IJFH{typeof(SA), Nij, Nh}(array)
+    data = IJFH{typeof(SA), Nij}(array)
     data_slab = slab(data, 1)
     ret = begin
         data_slab[slab_index(1, 1)] = SA
@@ -111,10 +111,10 @@ end
     S1 = Float64
     S2 = Float32
     array1 = ones(S1, Nij, Nij, 1, Nh)
-    data1 = IJFH{S1, Nij, Nh}(array1)
+    data1 = IJFH{S1, Nij}(array1)
 
     array2 = ones(S2, Nij, Nij, 1, Nh)
-    data2 = IJFH{S2, Nij, Nh}(array2)
+    data2 = IJFH{S2, Nij}(array2)
 
     for h in 1:Nh
         slab1 = slab(data1, h)
@@ -131,7 +131,7 @@ end
     Nh = 2
     data1 = ones(FT, 2, 2, 2, Nh)
     S = Complex{Float64}
-    data1 = IJFH{S, 2, Nh}(data1)
+    data1 = IJFH{S, 2}(data1)
     res = data1 .+ 1
     @test res isa IJFH{S}
     @test parent(res) ==
@@ -145,7 +145,8 @@ end
     FT = Float64
     S = Complex{FT}
     Nh = 3
-    data = IJFH{S, 2, Nh}(Array{FT})
+    array = similar(Array{FT}, 2, 2, 2, Nh)
+    data = IJFH{S, 2}(array)
     data .= Complex(1.0, 2.0)
     @test parent(data) ==
           FT[f == 1 ? 1 : 2 for i in 1:2, j in 1:2, f in 1:2, h in 1:3]
@@ -163,8 +164,8 @@ end
     data2 = ones(FT, 2, 2, 1, Nh)
     S1 = Complex{Float64}
     S2 = Float64
-    data1 = IJFH{S1, 2, Nh}(data1)
-    data2 = IJFH{S2, 2, Nh}(data2)
+    data1 = IJFH{S1, 2}(data1)
+    data2 = IJFH{S2, 2}(data2)
     res = data1 .+ data2
     @test res isa IJFH{S1}
     @test parent(res) ==
@@ -181,8 +182,8 @@ end
     data1 = ones(FT, 2, 2, 3, Nh)
     S2 = Float64
     data2 = ones(FT, 2, 2, 1, Nh)
-    data1 = IJFH{S1, 2, Nh}(data1)
-    data2 = IJFH{S2, 2, Nh}(data2)
+    data1 = IJFH{S1, 2}(data1)
+    data2 = IJFH{S2, 2}(data2)
 
     f(a1, a2) = a1.a.re * a2 + a1.b
     res = f.(data1, data2)
diff --git a/test/DataLayouts/data2dx.jl b/test/DataLayouts/data2dx.jl
index 02dfbb3d21..62b45ff53a 100644
--- a/test/DataLayouts/data2dx.jl
+++ b/test/DataLayouts/data2dx.jl
@@ -19,7 +19,7 @@ import ClimaCore.DataLayouts: VF, IJFH, VIJFH, slab, column, slab_index, vindex
         # 10 elements in horizontal with 4 × 4 nodal points per element in horizontal
         array = rand(FT, Nv, Nij, Nij, 3, Nh)
 
-        data = VIJFH{S, Nv, Nij, Nh}(array)
+        data = VIJFH{S, Nv, Nij}(array)
 
         @test getfield(data.:1, :array) == @view(array[:, :, :, 1:2, :])
         @test getfield(data.:2, :array) == @view(array[:, :, :, 3:3, :])
@@ -52,7 +52,7 @@ end
 
     S = Tuple{Complex{Float64}, Float64}
     array = zeros(Float64, Nv, Nij, Nij, 3, Nh)
-    data = VIJFH{S, Nv, Nij, Nh}(array)
+    data = VIJFH{S, Nv, Nij}(array)
 
     @test_throws BoundsError slab(data, -1, 1)
     @test_throws BoundsError slab(data, 1, -1)
@@ -77,7 +77,7 @@ end
     SB = (c = 1.0, d = 2.0)
 
     array = zeros(Float64, Nv, Nij, Nij, 2, Nh)
-    data = VIJFH{typeof(SA), Nv, Nij, Nh}(array)
+    data = VIJFH{typeof(SA), Nv, Nij}(array)
 
     cdata = column(data, 1, 2, 1)
     cdata[vindex(1)] = SA
@@ -95,7 +95,7 @@ end
     Nv = size(array, 1)
     Nh = size(array, 5)
     S = Complex{Float64}
-    data1 = VIJFH{S, Nv, 2, Nh}(array)
+    data1 = VIJFH{S, Nv, 2}(array)
     res = data1 .+ 1
     @test res isa VIJFH{S, Nv}
     @test parent(res) == FT[
@@ -112,7 +112,7 @@ end
     Nv = 3
     Nh = 2
     data_vf = VF{S, Nv}(ones(FT, Nv, 2))
-    data_ijfh = IJFH{FT, 2, Nh}(ones(FT, 2, 2, 1, Nh))
+    data_ijfh = IJFH{FT, 2}(ones(FT, 2, 2, 1, Nh))
     data_vijfh = data_vf .+ data_ijfh
     @test data_vijfh isa VIJFH{S, Nv}
     @test size(data_vijfh) == (2, 2, 1, 3, 2)
diff --git a/test/DataLayouts/opt_similar.jl b/test/DataLayouts/opt_similar.jl
index 807b496773..a14cffb084 100644
--- a/test/DataLayouts/opt_similar.jl
+++ b/test/DataLayouts/opt_similar.jl
@@ -36,16 +36,22 @@ end
     Nij = 3
     Nh = 5
     Nk = 6
-#! format: off
-    data = DataF{S}(device_zeros(FT,Nf));                        test_similar!(data)
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));     test_similar!(data)
-    data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));          test_similar!(data)
-    data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));             test_similar!(data)
-    data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                  test_similar!(data)
-    data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                    test_similar!(data)
-    data = VIJFH{S,Nv,Nij,Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));test_similar!(data)
-    data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));  test_similar!(data)
-#! format: on
-    # data = DataLayouts.IJKFVH{S, Nij, Nk, Nv, Nh}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_similar!(data) # TODO: test
+    data = DataF{S}(device_zeros(FT, Nf))
+    test_similar!(data)
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    test_similar!(data)
+    data = IFH{S, Nij}(device_zeros(FT, Nij, Nf, Nh))
+    test_similar!(data)
+    data = IJF{S, Nij}(device_zeros(FT, Nij, Nij, Nf))
+    test_similar!(data)
+    data = IF{S, Nij}(device_zeros(FT, Nij, Nf))
+    test_similar!(data)
+    data = VF{S, Nv}(device_zeros(FT, Nv, Nf))
+    test_similar!(data)
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    test_similar!(data)
+    data = VIFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nf, Nh))
+    test_similar!(data)
+    # data = DataLayouts.IJKFVH{S, Nij, Nk, Nv}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_similar!(data) # TODO: test
     # data = DataLayouts.IH1JH2{S, Nij}(device_zeros(FT,2*Nij,3*Nij));                     test_similar!(data) # TODO: test
 end
diff --git a/test/DataLayouts/opt_universal_size.jl b/test/DataLayouts/opt_universal_size.jl
index f54d5a6330..ef53322c9b 100644
--- a/test/DataLayouts/opt_universal_size.jl
+++ b/test/DataLayouts/opt_universal_size.jl
@@ -14,9 +14,14 @@ using InteractiveUtils: @code_typed
 function test_universal_size(data)
     us = DataLayouts.UniversalSize(data)
     # Make sure results is statically returned / constant propagated
-    ct = @code_typed DataLayouts.get_N(us)
-    @test ct.first.code[1] isa Core.ReturnNode
-    @test ct.first.code[end].val == DataLayouts.get_N(us)
+
+    # We cannot statically know Nh or N until we put Nh back
+    # into the type space. So some of these tests have been
+    # commented out until we add it back in.
+
+    # ct = @code_typed DataLayouts.get_N(us)
+    # @test ct.first.code[1] isa Core.ReturnNode
+    # @test ct.first.code[end].val == DataLayouts.get_N(us)
 
     ct = @code_typed DataLayouts.get_Nv(us)
     @test ct.first.code[1] isa Core.ReturnNode
@@ -26,17 +31,17 @@ function test_universal_size(data)
     @test ct.first.code[1] isa Core.ReturnNode
     @test ct.first.code[end].val == DataLayouts.get_Nij(us)
 
-    ct = @code_typed DataLayouts.get_Nh(us)
-    @test ct.first.code[1] isa Core.ReturnNode
-    @test ct.first.code[end].val == DataLayouts.get_Nh(us)
+    # ct = @code_typed DataLayouts.get_Nh(us)
+    # @test ct.first.code[1] isa Core.ReturnNode
+    # @test ct.first.code[end].val == DataLayouts.get_Nh(us)
 
-    ct = @code_typed size(data)
-    @test ct.first.code[1] isa Core.ReturnNode
-    @test ct.first.code[end].val == size(data)
+    # ct = @code_typed size(data)
+    # @test ct.first.code[1] isa Core.ReturnNode
+    # @test ct.first.code[end].val == size(data)
 
-    ct = @code_typed DataLayouts.get_N(data)
-    @test ct.first.code[1] isa Core.ReturnNode
-    @test ct.first.code[end].val == DataLayouts.get_N(data)
+    # ct = @code_typed DataLayouts.get_N(data)
+    # @test ct.first.code[1] isa Core.ReturnNode
+    # @test ct.first.code[end].val == DataLayouts.get_N(data)
 
     # Demo of failed constant prop:
     ct = @code_typed prod(size(data))
@@ -53,16 +58,22 @@ end
     Nij = 3
     Nh = 5
     Nk = 6
-#! format: off
-    data = DataF{S}(device_zeros(FT,Nf));                        test_universal_size(data)
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));     test_universal_size(data)
-    data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));          test_universal_size(data)
-    data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));             test_universal_size(data)
-    data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                  test_universal_size(data)
-    data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                    test_universal_size(data)
-    data = VIJFH{S,Nv,Nij,Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));test_universal_size(data)
-    data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));  test_universal_size(data)
-#! format: on
-    # data = DataLayouts.IJKFVH{S, Nij, Nk, Nv, Nh}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_universal_size(data) # TODO: test
+    data = DataF{S}(device_zeros(FT, Nf))
+    test_universal_size(data)
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    test_universal_size(data)
+    data = IFH{S, Nij}(device_zeros(FT, Nij, Nf, Nh))
+    test_universal_size(data)
+    data = IJF{S, Nij}(device_zeros(FT, Nij, Nij, Nf))
+    test_universal_size(data)
+    data = IF{S, Nij}(device_zeros(FT, Nij, Nf))
+    test_universal_size(data)
+    data = VF{S, Nv}(device_zeros(FT, Nv, Nf))
+    test_universal_size(data)
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    test_universal_size(data)
+    data = VIFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nf, Nh))
+    test_universal_size(data)
+    # data = DataLayouts.IJKFVH{S, Nij, Nk, Nv}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_universal_size(data) # TODO: test
     # data = DataLayouts.IH1JH2{S, Nij}(device_zeros(FT,2*Nij,3*Nij));                     test_universal_size(data) # TODO: test
 end
diff --git a/test/DataLayouts/unit_copyto.jl b/test/DataLayouts/unit_copyto.jl
index 1cf917fd1b..1dfe3ecee9 100644
--- a/test/DataLayouts/unit_copyto.jl
+++ b/test/DataLayouts/unit_copyto.jl
@@ -51,16 +51,22 @@ end
     Nij = 3
     Nh = 5
     Nk = 6
-#! format: off
-    data = DataF{S}(device_zeros(FT,Nf));                        test_copyto_float!(data)
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));     test_copyto_float!(data)
-    data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));          test_copyto_float!(data)
-    data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));             test_copyto_float!(data)
-    data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                  test_copyto_float!(data)
-    data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                    test_copyto_float!(data)
-    data = VIJFH{S,Nv,Nij,Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));test_copyto_float!(data)
-    data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));  test_copyto_float!(data)
-#! format: on
+    data = DataF{S}(device_zeros(FT, Nf))
+    test_copyto_float!(data)
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    test_copyto_float!(data)
+    data = IFH{S, Nij}(device_zeros(FT, Nij, Nf, Nh))
+    test_copyto_float!(data)
+    data = IJF{S, Nij}(device_zeros(FT, Nij, Nij, Nf))
+    test_copyto_float!(data)
+    data = IF{S, Nij}(device_zeros(FT, Nij, Nf))
+    test_copyto_float!(data)
+    data = VF{S, Nv}(device_zeros(FT, Nv, Nf))
+    test_copyto_float!(data)
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    test_copyto_float!(data)
+    data = VIFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nf, Nh))
+    test_copyto_float!(data)
     # data = DataLayouts.IJKFVH{S, Nij, Nk}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_copyto_float!(data) # TODO: test
     # data = DataLayouts.IH1JH2{S, Nij}(device_zeros(FT,2*Nij,3*Nij));             test_copyto_float!(data) # TODO: test
 end
@@ -75,16 +81,22 @@ end
     Nij = 3
     Nh = 5
     Nk = 6
-#! format: off
-    data = DataF{S}(device_zeros(FT,Nf));                        test_copyto!(data)
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));     test_copyto!(data)
-    data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));          test_copyto!(data)
-    data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));             test_copyto!(data)
-    data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                  test_copyto!(data)
-    data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                    test_copyto!(data)
-    data = VIJFH{S,Nv,Nij,Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));test_copyto!(data)
-    data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));  test_copyto!(data)
-#! format: on
+    data = DataF{S}(device_zeros(FT, Nf))
+    test_copyto!(data)
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    test_copyto!(data)
+    data = IFH{S, Nij}(device_zeros(FT, Nij, Nf, Nh))
+    test_copyto!(data)
+    data = IJF{S, Nij}(device_zeros(FT, Nij, Nij, Nf))
+    test_copyto!(data)
+    data = IF{S, Nij}(device_zeros(FT, Nij, Nf))
+    test_copyto!(data)
+    data = VF{S, Nv}(device_zeros(FT, Nv, Nf))
+    test_copyto!(data)
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    test_copyto!(data)
+    data = VIFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nf, Nh))
+    test_copyto!(data)
     # TODO: test this
     # data = DataLayouts.IJKFVH{S, Nij, Nk}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_copyto!(data) # TODO: test
     # data = DataLayouts.IH1JH2{S, Nij}(device_zeros(FT,2*Nij,3*Nij));             test_copyto!(data) # TODO: test
@@ -112,15 +124,20 @@ end
     Nk = 6
     # Rather than using level/slab/column, let's just make views/SubArrays
     # directly so that we can easily test all cases:
-#! format: off
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));     test_copyto!(data_view(data))
-    data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));          test_copyto!(data_view(data))
-    data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));             test_copyto!(data_view(data))
-    data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                  test_copyto!(data_view(data))
-    data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                    test_copyto!(data_view(data))
-    data = VIJFH{S,Nv,Nij,Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));test_copyto!(data_view(data))
-    data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));  test_copyto!(data_view(data))
-#! format: on
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    test_copyto!(data_view(data))
+    data = IFH{S, Nij}(device_zeros(FT, Nij, Nf, Nh))
+    test_copyto!(data_view(data))
+    data = IJF{S, Nij}(device_zeros(FT, Nij, Nij, Nf))
+    test_copyto!(data_view(data))
+    data = IF{S, Nij}(device_zeros(FT, Nij, Nf))
+    test_copyto!(data_view(data))
+    data = VF{S, Nv}(device_zeros(FT, Nv, Nf))
+    test_copyto!(data_view(data))
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    test_copyto!(data_view(data))
+    data = VIFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nf, Nh))
+    test_copyto!(data_view(data))
     # TODO: test this
     # data = DataLayouts.IJKFVH{S, Nij, Nk}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_copyto!(data) # TODO: test
     # data = DataLayouts.IH1JH2{S, Nij}(device_zeros(FT,2*Nij,3*Nij));             test_copyto!(data) # TODO: test
diff --git a/test/DataLayouts/unit_data2array.jl b/test/DataLayouts/unit_data2array.jl
index 0201fa6e52..b404f10c05 100644
--- a/test/DataLayouts/unit_data2array.jl
+++ b/test/DataLayouts/unit_data2array.jl
@@ -24,7 +24,7 @@ end
     @test is_data2array2data_identity(data)
 
     array = rand(FT, 2, 1, Nh)
-    data = IFH{FT, 2, Nh}(array)
+    data = IFH{FT, 2}(array)
     @test DataLayouts.data2array(data) == reshape(parent(data), :)
     @test is_data2array2data_identity(data)
 
@@ -34,17 +34,17 @@ end
     @test is_data2array2data_identity(data)
 
     array = rand(FT, Nij, Nij, 1, Nh)
-    data = IJFH{FT, Nij, Nh}(array)
+    data = IJFH{FT, Nij}(array)
     @test DataLayouts.data2array(data) == reshape(parent(data), :)
     @test is_data2array2data_identity(data)
 
     array = rand(FT, Nv, Nij, 1, Nh)
-    data = VIFH{FT, Nv, Nij, Nh}(array)
+    data = VIFH{FT, Nv, Nij}(array)
     @test DataLayouts.data2array(data) == reshape(parent(data), Nv, :)
     @test is_data2array2data_identity(data)
 
     array = rand(FT, Nv, Nij, Nij, 1, Nh)
-    data = VIJFH{FT, Nv, Nij, Nh}(array)
+    data = VIJFH{FT, Nv, Nij}(array)
     @test DataLayouts.data2array(data) == reshape(parent(data), Nv, :)
     @test is_data2array2data_identity(data)
 end
diff --git a/test/DataLayouts/unit_fill.jl b/test/DataLayouts/unit_fill.jl
index f8af1f022c..4c00d342a2 100644
--- a/test/DataLayouts/unit_fill.jl
+++ b/test/DataLayouts/unit_fill.jl
@@ -27,16 +27,24 @@ end
     Nij = 3
     Nh = 5
     Nk = 6
-#! format: off
-    data = DataF{S}(device_zeros(FT,Nf));                        test_fill!(data, 3)
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));     test_fill!(data, 3)
-    data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));          test_fill!(data, 3)
-    data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));             test_fill!(data, 3)
-    data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                  test_fill!(data, 3)
-    data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                    test_fill!(data, 3)
-    data = VIJFH{S,Nv,Nij,Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));test_fill!(data, 3)
-    data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));  test_fill!(data, 3)
-#! format: on
+
+    data = DataF{S}(device_zeros(FT, Nf))
+    test_fill!(data, 3)
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    test_fill!(data, 3)
+    data = IFH{S, Nij}(device_zeros(FT, Nij, Nf, Nh))
+    test_fill!(data, 3)
+    data = IJF{S, Nij}(device_zeros(FT, Nij, Nij, Nf))
+    test_fill!(data, 3)
+    data = IF{S, Nij}(device_zeros(FT, Nij, Nf))
+    test_fill!(data, 3)
+    data = VF{S, Nv}(device_zeros(FT, Nv, Nf))
+    test_fill!(data, 3)
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    test_fill!(data, 3)
+    data = VIFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nf, Nh))
+    test_fill!(data, 3)
+
     # data = DataLayouts.IJKFVH{S, Nij, Nk}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_fill!(data, 3) # TODO: test
     # data = DataLayouts.IH1JH2{S, Nij}(device_zeros(FT,2*Nij,3*Nij));             test_fill!(data, 3) # TODO: test
 end
@@ -51,16 +59,24 @@ end
     Nij = 3
     Nh = 5
     Nk = 6
-#! format: off
-    data = DataF{S}(device_zeros(FT,Nf));                        test_fill!(data, (2,3))
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));     test_fill!(data, (2,3))
-    data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));          test_fill!(data, (2,3))
-    data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));             test_fill!(data, (2,3))
-    data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                  test_fill!(data, (2,3))
-    data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                    test_fill!(data, (2,3))
-    data = VIJFH{S,Nv,Nij,Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));test_fill!(data, (2,3))
-    data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));  test_fill!(data, (2,3))
-#! format: on
+
+    data = DataF{S}(device_zeros(FT, Nf))
+    test_fill!(data, (2, 3))
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    test_fill!(data, (2, 3))
+    data = IFH{S, Nij}(device_zeros(FT, Nij, Nf, Nh))
+    test_fill!(data, (2, 3))
+    data = IJF{S, Nij}(device_zeros(FT, Nij, Nij, Nf))
+    test_fill!(data, (2, 3))
+    data = IF{S, Nij}(device_zeros(FT, Nij, Nf))
+    test_fill!(data, (2, 3))
+    data = VF{S, Nv}(device_zeros(FT, Nv, Nf))
+    test_fill!(data, (2, 3))
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    test_fill!(data, (2, 3))
+    data = VIFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nf, Nh))
+    test_fill!(data, (2, 3))
+
     # TODO: test this
     # data = DataLayouts.IJKFVH{S, Nij, Nk}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_fill!(data, (2,3)) # TODO: test
     # data = DataLayouts.IH1JH2{S, Nij}(device_zeros(FT,2*Nij,3*Nij));             test_fill!(data, (2,3)) # TODO: test
@@ -88,15 +104,22 @@ end
     Nk = 6
     # Rather than using level/slab/column, let's just make views/SubArrays
     # directly so that we can easily test all cases:
-#! format: off
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));     test_fill!(data_view(data), (2,3))
-    data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));          test_fill!(data_view(data), (2,3))
-    data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));             test_fill!(data_view(data), (2,3))
-    data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                  test_fill!(data_view(data), (2,3))
-    data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                    test_fill!(data_view(data), (2,3))
-    data = VIJFH{S,Nv,Nij,Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));test_fill!(data_view(data), (2,3))
-    data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));  test_fill!(data_view(data), (2,3))
-#! format: on
+
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    test_fill!(data_view(data), (2, 3))
+    data = IFH{S, Nij}(device_zeros(FT, Nij, Nf, Nh))
+    test_fill!(data_view(data), (2, 3))
+    data = IJF{S, Nij}(device_zeros(FT, Nij, Nij, Nf))
+    test_fill!(data_view(data), (2, 3))
+    data = IF{S, Nij}(device_zeros(FT, Nij, Nf))
+    test_fill!(data_view(data), (2, 3))
+    data = VF{S, Nv}(device_zeros(FT, Nv, Nf))
+    test_fill!(data_view(data), (2, 3))
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    test_fill!(data_view(data), (2, 3))
+    data = VIFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nf, Nh))
+    test_fill!(data_view(data), (2, 3))
+
     # TODO: test this
     # data = DataLayouts.IJKFVH{S, Nij, Nk}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_fill!(data, (2,3)) # TODO: test
     # data = DataLayouts.IH1JH2{S, Nij}(device_zeros(FT,2*Nij,3*Nij));             test_fill!(data, (2,3)) # TODO: test
@@ -143,15 +166,19 @@ end
     Nh = 5
     Nk = 6
     # directly so that we can easily test all cases:
-#! format: off
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));     test_fill!(reshaped_array(data), 2)
-    data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));          test_fill!(reshaped_array(data), 2)
+
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    test_fill!(reshaped_array(data), 2)
+    data = IFH{S, Nij}(device_zeros(FT, Nij, Nf, Nh))
+    test_fill!(reshaped_array(data), 2)
     # data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));             test_fill!(reshaped_array(data), 2)
     # data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                  test_fill!(reshaped_array(data), 2)
     # data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                    test_fill!(reshaped_array(data), 2)
-    data = VIJFH{S,Nv,Nij,Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));test_fill!(reshaped_array(data), 2)
-    data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));  test_fill!(reshaped_array(data), 2)
-#! format: on
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    test_fill!(reshaped_array(data), 2)
+    data = VIFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nf, Nh))
+    test_fill!(reshaped_array(data), 2)
+
     # TODO: test this
     # data = DataLayouts.IJKFVH{S, Nij, Nk}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_fill!(reshaped_array(data), 2) # TODO: test
     # data = DataLayouts.IH1JH2{S, Nij}(device_zeros(FT,2*Nij,3*Nij));             test_fill!(reshaped_array(data), 2) # TODO: test
diff --git a/test/DataLayouts/unit_mapreduce.jl b/test/DataLayouts/unit_mapreduce.jl
index dcbf0a99a0..9ebe0c7fdd 100644
--- a/test/DataLayouts/unit_mapreduce.jl
+++ b/test/DataLayouts/unit_mapreduce.jl
@@ -74,17 +74,19 @@ end
     Nij = 3
     Nh = 5
     Nk = 6
-#! format: off
-    data = DataF{S}(device_zeros(FT,Nf));                              test_mapreduce_1!(context, data)
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));           test_mapreduce_1!(context, data)
-    # data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));              test_mapreduce_1!(context, data)
+    data = DataF{S}(device_zeros(FT, Nf))
+    test_mapreduce_1!(context, data)
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    test_mapreduce_1!(context, data)
+    # data = IFH{S, Nij}(device_zeros(FT,Nij,Nf,Nh));              test_mapreduce_1!(context, data)
     # data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));                 test_mapreduce_1!(context, data)
     # data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                      test_mapreduce_1!(context, data)
-    data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                          test_mapreduce_1!(context, data)
-    data = VIJFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));   test_mapreduce_1!(context, data)
-    # data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));      test_mapreduce_1!(context, data)
-#! format: on
-    # data = DataLayouts.IJKFVH{S, Nij, Nk, Nh}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_mapreduce_1!(context, data) # TODO: test
+    data = VF{S, Nv}(device_zeros(FT, Nv, Nf))
+    test_mapreduce_1!(context, data)
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    test_mapreduce_1!(context, data)
+    # data = VIFH{S, Nv, Nij}(device_zeros(FT,Nv,Nij,Nf,Nh));      test_mapreduce_1!(context, data)
+    # data = DataLayouts.IJKFVH{S, Nij, Nk}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_mapreduce_1!(context, data) # TODO: test
     # data = DataLayouts.IH1JH2{S, Nij}(device_zeros(FT,2*Nij,3*Nij));                 test_mapreduce_1!(context, data) # TODO: test
 end
 
@@ -97,18 +99,20 @@ end
     Nij = 3
     Nh = 5
     Nk = 6
-#! format: off
-    data = DataF{S}(device_zeros(FT,Nf));                              test_mapreduce_2!(context, data)
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));           test_mapreduce_2!(context, data)
-    # data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));              test_mapreduce_2!(context, data)
+    data = DataF{S}(device_zeros(FT, Nf))
+    test_mapreduce_2!(context, data)
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    test_mapreduce_2!(context, data)
+    # data = IFH{S, Nij}(device_zeros(FT,Nij,Nf,Nh));              test_mapreduce_2!(context, data)
     # data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));                 test_mapreduce_2!(context, data)
     # data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                      test_mapreduce_2!(context, data)
-    data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                          test_mapreduce_2!(context, data)
-    data = VIJFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));   test_mapreduce_2!(context, data)
-    # data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));      test_mapreduce_2!(context, data)
-#! format: on
+    data = VF{S, Nv}(device_zeros(FT, Nv, Nf))
+    test_mapreduce_2!(context, data)
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    test_mapreduce_2!(context, data)
+    # data = VIFH{S, Nv, Nij}(device_zeros(FT,Nv,Nij,Nf,Nh));      test_mapreduce_2!(context, data)
     # TODO: test this
-    # data = DataLayouts.IJKFVH{S, Nij, Nk, Nh}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_mapreduce_2!(context, data) # TODO: test
+    # data = DataLayouts.IJKFVH{S, Nij, Nk}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_mapreduce_2!(context, data) # TODO: test
     # data = DataLayouts.IH1JH2{S, Nij}(device_zeros(FT,2*Nij,3*Nij));                 test_mapreduce_2!(context, data) # TODO: test
 end
 
@@ -133,17 +137,19 @@ end
     Nk = 6
     # Rather than using level/slab/column, let's just make views/SubArrays
     # directly so that we can easily test all cases:
-#! format: off
-    data = DataF{S}(device_zeros(FT,Nf));                              test_mapreduce_2!(context, data_view(data))
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));           test_mapreduce_2!(context, data_view(data))
-    # data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));              test_mapreduce_2!(context, data_view(data))
+    data = DataF{S}(device_zeros(FT, Nf))
+    test_mapreduce_2!(context, data_view(data))
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    test_mapreduce_2!(context, data_view(data))
+    # data = IFH{S, Nij}(device_zeros(FT,Nij,Nf,Nh));              test_mapreduce_2!(context, data_view(data))
     # data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));                 test_mapreduce_2!(context, data_view(data))
     # data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                      test_mapreduce_2!(context, data_view(data))
-    data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                          test_mapreduce_2!(context, data_view(data))
-    data = VIJFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));   test_mapreduce_2!(context, data_view(data))
-    # data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));      test_mapreduce_2!(context, data_view(data))
-#! format: on
+    data = VF{S, Nv}(device_zeros(FT, Nv, Nf))
+    test_mapreduce_2!(context, data_view(data))
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    test_mapreduce_2!(context, data_view(data))
+    # data = VIFH{S, Nv, Nij}(device_zeros(FT,Nv,Nij,Nf,Nh));      test_mapreduce_2!(context, data_view(data))
     # TODO: test this
-    # data = DataLayouts.IJKFVH{S, Nij, Nk, Nh}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_mapreduce_2!(context, data_view(data)) # TODO: test
+    # data = DataLayouts.IJKFVH{S, Nij, Nk}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); test_mapreduce_2!(context, data_view(data)) # TODO: test
     # data = DataLayouts.IH1JH2{S, Nij}(device_zeros(FT,2*Nij,3*Nij));                 test_mapreduce_2!(context, data_view(data)) # TODO: test
 end
diff --git a/test/DataLayouts/unit_ndims.jl b/test/DataLayouts/unit_ndims.jl
index 75c62e7755..0b68f05945 100644
--- a/test/DataLayouts/unit_ndims.jl
+++ b/test/DataLayouts/unit_ndims.jl
@@ -17,16 +17,36 @@ ClimaComms.@import_required_backends
     Nij = 3
     Nh = 5
     Nk = 6
-#! format: off
-    data = DataF{S}(device_zeros(FT,Nf));                                            @test ndims(data) == 1; @test ndims(typeof(data)) == 1
-    data = IF{S, Nij}(device_zeros(FT,Nij,Nf));                                      @test ndims(data) == 2; @test ndims(typeof(data)) == 2
-    data = VF{S, Nv}(device_zeros(FT,Nv,Nf));                                        @test ndims(data) == 2; @test ndims(typeof(data)) == 2
-    data = IFH{S, Nij, Nh}(device_zeros(FT,Nij,Nf,Nh));                              @test ndims(data) == 3; @test ndims(typeof(data)) == 3
-    data = IJF{S, Nij}(device_zeros(FT,Nij,Nij,Nf));                                 @test ndims(data) == 3; @test ndims(typeof(data)) == 3
-    data = IJFH{S, Nij, Nh}(device_zeros(FT,Nij,Nij,Nf,Nh));                         @test ndims(data) == 4; @test ndims(typeof(data)) == 4
-    data = VIFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nf,Nh));                      @test ndims(data) == 4; @test ndims(typeof(data)) == 4
-    data = VIJFH{S, Nv, Nij, Nh}(device_zeros(FT,Nv,Nij,Nij,Nf,Nh));                 @test ndims(data) == 5; @test ndims(typeof(data)) == 5
-    data = DataLayouts.IJKFVH{S,Nij,Nk,Nv,Nh}(device_zeros(FT,Nij,Nij,Nk,Nf,Nv,Nh)); @test ndims(data) == 6; @test ndims(typeof(data)) == 6
-    data = DataLayouts.IH1JH2{S, Nij}(device_zeros(FT,2*Nij,3*Nij));                 @test ndims(data) == 2; @test ndims(typeof(data)) == 2
-#! format: on
+    data = DataF{S}(device_zeros(FT, Nf))
+    @test ndims(data) == 1
+    @test ndims(typeof(data)) == 1
+    data = IF{S, Nij}(device_zeros(FT, Nij, Nf))
+    @test ndims(data) == 2
+    @test ndims(typeof(data)) == 2
+    data = VF{S, Nv}(device_zeros(FT, Nv, Nf))
+    @test ndims(data) == 2
+    @test ndims(typeof(data)) == 2
+    data = IFH{S, Nij}(device_zeros(FT, Nij, Nf, Nh))
+    @test ndims(data) == 3
+    @test ndims(typeof(data)) == 3
+    data = IJF{S, Nij}(device_zeros(FT, Nij, Nij, Nf))
+    @test ndims(data) == 3
+    @test ndims(typeof(data)) == 3
+    data = IJFH{S, Nij}(device_zeros(FT, Nij, Nij, Nf, Nh))
+    @test ndims(data) == 4
+    @test ndims(typeof(data)) == 4
+    data = VIFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nf, Nh))
+    @test ndims(data) == 4
+    @test ndims(typeof(data)) == 4
+    data = VIJFH{S, Nv, Nij}(device_zeros(FT, Nv, Nij, Nij, Nf, Nh))
+    @test ndims(data) == 5
+    @test ndims(typeof(data)) == 5
+    data = DataLayouts.IJKFVH{S, Nij, Nk, Nv}(
+        device_zeros(FT, Nij, Nij, Nk, Nf, Nv, Nh),
+    )
+    @test ndims(data) == 6
+    @test ndims(typeof(data)) == 6
+    data = DataLayouts.IH1JH2{S, Nij}(device_zeros(FT, 2 * Nij, 3 * Nij))
+    @test ndims(data) == 2
+    @test ndims(typeof(data)) == 2
 end
diff --git a/test/Fields/unit_field.jl b/test/Fields/unit_field.jl
index 123384f328..63a1f8f701 100644
--- a/test/Fields/unit_field.jl
+++ b/test/Fields/unit_field.jl
@@ -58,10 +58,8 @@ end
     Nh = n1 * n2
     space = spectral_space_2D(n1 = n1, n2 = n2, Nij = Nij)
 
-    field = Fields.Field(
-        IJFH{ComplexF64, Nij, Nh}(ones(Nij, Nij, 2, n1 * n2)),
-        space,
-    )
+    field =
+        Fields.Field(IJFH{ComplexF64, Nij}(ones(Nij, Nij, 2, n1 * n2)), space)
 
     @test sum(field) ≈ Complex(1.0, 1.0) * 8.0 * 10.0 rtol = 10eps()
     @test sum(x -> 3.0, field) ≈ 3 * 8.0 * 10.0 rtol = 10eps()
@@ -252,7 +250,7 @@ end
     space = spectral_space_2D(n1 = n1, n2 = n2, Nij = Nij)
 
     nt_field = Fields.Field(
-        IJFH{NamedTuple{(:a, :b), Tuple{Float64, Float64}}, Nij, Nh}(
+        IJFH{NamedTuple{(:a, :b), Tuple{Float64, Float64}}, Nij}(
             ones(Nij, Nij, 2, Nh),
         ),
         space,
diff --git a/test/Spaces/opt_spaces.jl b/test/Spaces/opt_spaces.jl
index 5e52b9004d..c1c8b289b1 100644
--- a/test/Spaces/opt_spaces.jl
+++ b/test/Spaces/opt_spaces.jl
@@ -60,7 +60,7 @@ end
         Nh = Val(Topologies.nlocalelems(Spaces.topology(space)))
         result = JET.@report_opt Grids._SpectralElementGrid2D(Spaces.topology(space), Spaces.quadrature_style(space), Val(Nh); enable_bubble=false)
         n_found = length(JET.get_reports(result.analyzer, result.result))
-        n_allowed = 0
+        n_allowed = 1
         @test n_found ≤ n_allowed
         if n_found < n_allowed
             @info "Inference may have improved for _SpectralElementGrid2D: (n_found, n_allowed) = ($n_found, $n_allowed)"
diff --git a/test/deprecations.jl b/test/deprecations.jl
index 021f5d90f2..5f0fb4455a 100644
--- a/test/deprecations.jl
+++ b/test/deprecations.jl
@@ -46,12 +46,13 @@ ClimaComms.@import_required_backends
     @test_deprecated CenterFiniteDifferenceSpace(z_mesh)
     @test_deprecated FiniteDifferenceGrid(z_mesh)
 
-    S = Float64
-    @test_deprecated DataLayouts.IJFH{S, 3}(zeros(3, 3, 1, 10))
-    @test_deprecated DataLayouts.IJFH{S, 3}(typeof(zeros(3, 3, 1, 10)), 10)
-    @test_deprecated DataLayouts.IFH{S, 3}(zeros(3, 1, 10))
-    @test_deprecated DataLayouts.VIJFH{S, 10, 4}(zeros(10, 4, 4, 1, 20))
-    @test_deprecated DataLayouts.VIFH{S, 10, 4}(zeros(10, 4, 1, 20))
+    # For when Nh is in the type-domain
+    # S = Float64
+    # @test_deprecated DataLayouts.IJFH{S, 3}(zeros(3, 3, 1, 10))
+    # @test_deprecated DataLayouts.IJFH{S, 3}(typeof(zeros(3, 3, 1, 10)), 10)
+    # @test_deprecated DataLayouts.IFH{S, 3}(zeros(3, 1, 10))
+    # @test_deprecated DataLayouts.VIJFH{S, 10, 4}(zeros(10, 4, 4, 1, 20))
+    # @test_deprecated DataLayouts.VIFH{S, 10, 4}(zeros(10, 4, 1, 20))
 end
 
 nothing