Change FH -> HF

Swap F and H inds

NEWS.md

@@ -21,12 +21,12 @@ PR [#2033](https://github.com/CliMA/ClimaCore.jl/pull/2033) introduces new
 constructors for `DataLayout`s. Instead of writing
 ```julia
 array = rand(FT, Nv, Nij, Nij, 3, Nh)
-data = VIJFH{S, Nv, Nij}(array)
+data = VIJHF{S, Nv, Nij}(array)
 ```
 
 You can now write
 ```julia
-data = VIJFH{S}(ArrayType{FT}, rand; Nv, Nij, Nh)
+data = VIJHF{S}(ArrayType{FT}, rand; Nv, Nij, Nh)
 ```
 and grab the `array` with `parent(data)` (if you need).
 

docs/src/api.md

@@ -28,10 +28,10 @@ DataLayouts.DataF
 DataLayouts.IF
 DataLayouts.IJF
 DataLayouts.VF
-DataLayouts.IFH
-DataLayouts.IJFH
-DataLayouts.VIFH
-DataLayouts.VIJFH
+DataLayouts.IHF
+DataLayouts.IJHF
+DataLayouts.VIHF
+DataLayouts.VIJHF
 ```
 
 ## Geometry

examples/hybrid/sphere/solid_body_rotation_3d.jl

@@ -247,7 +247,7 @@ discrete_hydrostatic_balance!(ρ, p, z_top / n_vert, grav)
 # set up initial condition: not discretely balanced; only create a Field as a place holder
 Yc = map(coord -> init_sbr_thermo(coord.z), c_coords)
 # put the dicretely balanced ρ and ρe into Yc
-parent(Yc.ρ) .= ρ  # Yc.ρ is a VIJFH layout
+parent(Yc.ρ) .= ρ  # Yc.ρ is a VIJHF layout
 parent(Yc.ρe) .= ρe
 
 # initialize velocity: at rest

ext/cuda/data_layouts.jl

@@ -1,8 +1,8 @@
 
 import ClimaCore.DataLayouts: AbstractData
 import ClimaCore.DataLayouts: FusedMultiBroadcast
-import ClimaCore.DataLayouts: IJKFVH, IJFH, VIJFH, VIFH, IFH, IJF, IF, VF, DataF
-import ClimaCore.DataLayouts: IJFHStyle, VIJFHStyle, VFStyle, DataFStyle
+import ClimaCore.DataLayouts: IJKFVH, IJHF, VIJHF, VIHF, IHF, IJF, IF, VF, DataF
+import ClimaCore.DataLayouts: IJHFStyle, VIJHFStyle, VFStyle, DataFStyle
 import ClimaCore.DataLayouts: promote_parent_array_type
 import ClimaCore.DataLayouts: parent_array_type
 import ClimaCore.DataLayouts: isascalar

ext/cuda/data_layouts_mapreduce.jl

@@ -20,7 +20,7 @@ end
 function mapreduce_cuda(
     f,
     op,
-    data::Union{DataLayouts.VF, DataLayouts.IJFH, DataLayouts.VIJFH};
+    data::Union{DataLayouts.VF, DataLayouts.IJHF, DataLayouts.VIJHF};
     weighted_jacobian = OnesArray(parent(data)),
     opargs...,
 )
@@ -83,7 +83,7 @@ function mapreduce_cuda_kernel!(
     gidx = _get_gidx(tidx, bidx, effective_blksize)
     reduction = CUDA.CuStaticSharedArray(T, shmemsize)
     reduction[tidx] = 0
-    (Nv, Nij, Nf, Nh) = _get_dims(dataview)
+    (Nv, Nij, Nh, Nf) = _get_dims(dataview)
     nitems = Nv * Nij * Nij * Nf * Nh
 
     # load shmem
@@ -115,21 +115,21 @@ end
 @inline _dataview(pdata::AbstractArray{FT, 2}, fidx) where {FT} =
     view(pdata, :, fidx:fidx)
 
-# for IJFH DataLayout
+# for IJHF DataLayout
 @inline function _get_dims(pdata::AbstractArray{FT, 4}) where {FT}
-    (Nij, _, Nf, Nh) = size(pdata)
-    return (1, Nij, Nf, Nh)
+    (Nij, _, Nh, Nf) = size(pdata)
+    return (1, Nij, Nh, Nf)
 end
 @inline _dataview(pdata::AbstractArray{FT, 4}, fidx) where {FT} =
-    view(pdata, :, :, fidx:fidx, :)
+    view(pdata, :, :, :, fidx:fidx)
 
-# for VIJFH DataLayout
+# for VIJHF DataLayout
 @inline function _get_dims(pdata::AbstractArray{FT, 5}) where {FT}
-    (Nv, Nij, _, Nf, Nh) = size(pdata)
-    return (Nv, Nij, Nf, Nh)
+    (Nv, Nij, _, Nh, Nf) = size(pdata)
+    return (Nv, Nij, Nh, Nf)
 end
 @inline _dataview(pdata::AbstractArray{FT, 5}, fidx) where {FT} =
-    view(pdata, :, :, :, fidx:fidx, :)
+    view(pdata, :, :, :, :, fidx:fidx)
 
 @inline function _cuda_reduce!(op, reduction, tidx, reduction_size, N)
     if reduction_size > N

ext/cuda/data_layouts_threadblock.jl

@@ -24,7 +24,7 @@ criteria:
    in the thread partition
  - The order of the thread partition should
    follow the fastest changing index in the
-   datalayout (e.g., VIJ in VIJFH)
+   datalayout (e.g., VIJ in VIJHF)
 """
 function partition end
 
@@ -46,25 +46,25 @@ bounds to ensure that the result of
 """
 function is_valid_index end
 
-##### VIJFH
-@inline function partition(data::DataLayouts.VIJFH, n_max_threads::Integer)
+##### VIJHF
+@inline function partition(data::DataLayouts.VIJHF, n_max_threads::Integer)
     (Nij, _, _, Nv, Nh) = DataLayouts.universal_size(data)
     Nv_thread = min(Int(fld(n_max_threads, Nij * Nij)), Nv)
     Nv_blocks = cld(Nv, Nv_thread)
     @assert prod((Nv_thread, Nij, Nij)) ≤ n_max_threads "threads,n_max_threads=($(prod((Nv_thread, Nij, Nij))),$n_max_threads)"
     return (; threads = (Nv_thread, Nij, Nij), blocks = (Nv_blocks, Nh))
 end
-@inline function universal_index(::DataLayouts.VIJFH)
+@inline function universal_index(::DataLayouts.VIJHF)
     (tv, i, j) = CUDA.threadIdx()
     (bv, h) = CUDA.blockIdx()
     v = tv + (bv - 1) * CUDA.blockDim().x
     return CartesianIndex((i, j, 1, v, h))
 end
-@inline is_valid_index(::DataLayouts.VIJFH, I::CI5, us::UniversalSize) =
+@inline is_valid_index(::DataLayouts.VIJHF, I::CI5, us::UniversalSize) =
     1 ≤ I[4] ≤ DataLayouts.get_Nv(us)
 
-##### IJFH
-@inline function partition(data::DataLayouts.IJFH, n_max_threads::Integer)
+##### IJHF
+@inline function partition(data::DataLayouts.IJHF, n_max_threads::Integer)
     (Nij, _, _, _, Nh) = DataLayouts.universal_size(data)
     Nh_thread = min(
         Int(fld(n_max_threads, Nij * Nij)),
@@ -75,30 +75,30 @@ end
     @assert prod((Nij, Nij)) ≤ n_max_threads "threads,n_max_threads=($(prod((Nij, Nij))),$n_max_threads)"
     return (; threads = (Nij, Nij, Nh_thread), blocks = (Nh_blocks,))
 end
-@inline function universal_index(::DataLayouts.IJFH)
+@inline function universal_index(::DataLayouts.IJHF)
     (i, j, th) = CUDA.threadIdx()
     (bh,) = CUDA.blockIdx()
     h = th + (bh - 1) * CUDA.blockDim().z
     return CartesianIndex((i, j, 1, 1, h))
 end
-@inline is_valid_index(::DataLayouts.IJFH, I::CI5, us::UniversalSize) =
+@inline is_valid_index(::DataLayouts.IJHF, I::CI5, us::UniversalSize) =
     1 ≤ I[5] ≤ DataLayouts.get_Nh(us)
 
-##### IFH
-@inline function partition(data::DataLayouts.IFH, n_max_threads::Integer)
+##### IHF
+@inline function partition(data::DataLayouts.IHF, n_max_threads::Integer)
     (Ni, _, _, _, Nh) = DataLayouts.universal_size(data)
     Nh_thread = min(Int(fld(n_max_threads, Ni)), Nh)
     Nh_blocks = cld(Nh, Nh_thread)
     @assert prod((Ni, Nh_thread)) ≤ n_max_threads "threads,n_max_threads=($(prod((Ni, Nh_thread))),$n_max_threads)"
     return (; threads = (Ni, Nh_thread), blocks = (Nh_blocks,))
 end
-@inline function universal_index(::DataLayouts.IFH)
+@inline function universal_index(::DataLayouts.IHF)
     (i, th) = CUDA.threadIdx()
     (bh,) = CUDA.blockIdx()
     h = th + (bh - 1) * CUDA.blockDim().y
     return CartesianIndex((i, 1, 1, 1, h))
 end
-@inline is_valid_index(::DataLayouts.IFH, I::CI5, us::UniversalSize) =
+@inline is_valid_index(::DataLayouts.IHF, I::CI5, us::UniversalSize) =
     1 ≤ I[5] ≤ DataLayouts.get_Nh(us)
 
 ##### IJF
@@ -125,21 +125,21 @@ end
 end
 @inline is_valid_index(::DataLayouts.IF, I::CI5, us::UniversalSize) = true
 
-##### VIFH
-@inline function partition(data::DataLayouts.VIFH, n_max_threads::Integer)
+##### VIHF
+@inline function partition(data::DataLayouts.VIHF, n_max_threads::Integer)
     (Ni, _, _, Nv, Nh) = DataLayouts.universal_size(data)
     Nv_thread = min(Int(fld(n_max_threads, Ni)), Nv)
     Nv_blocks = cld(Nv, Nv_thread)
     @assert prod((Nv_thread, Ni)) ≤ n_max_threads "threads,n_max_threads=($(prod((Nv_thread, Ni))),$n_max_threads)"
     return (; threads = (Nv_thread, Ni), blocks = (Nv_blocks, Nh))
 end
-@inline function universal_index(::DataLayouts.VIFH)
+@inline function universal_index(::DataLayouts.VIHF)
     (tv, i) = CUDA.threadIdx()
     (bv, h) = CUDA.blockIdx()
     v = tv + (bv - 1) * CUDA.blockDim().x
     return CartesianIndex((i, 1, 1, v, h))
 end
-@inline is_valid_index(::DataLayouts.VIFH, I::CI5, us::UniversalSize) =
+@inline is_valid_index(::DataLayouts.VIHF, I::CI5, us::UniversalSize) =
     1 ≤ I[4] ≤ DataLayouts.get_Nv(us)
 
 ##### VF

ext/cuda/topologies_dss.jl

@@ -18,7 +18,7 @@ _configure_threadblock(nitems) =
 function Topologies.dss_load_perimeter_data!(
     ::ClimaComms.CUDADevice,
     dss_buffer::Topologies.DSSBuffer,
-    data::Union{DataLayouts.IJFH, DataLayouts.VIJFH},
+    data::Union{DataLayouts.IJHF, DataLayouts.VIJHF},
     perimeter::Topologies.Perimeter2D,
 )
     (; perimeter_data) = dss_buffer
@@ -37,13 +37,13 @@ end
 
 function dss_load_perimeter_data_kernel!(
     perimeter_data::DataLayouts.AbstractData,
-    data::Union{DataLayouts.IJFH, DataLayouts.VIJFH},
+    data::Union{DataLayouts.IJHF, DataLayouts.VIJHF},
     perimeter::Topologies.Perimeter2D{Nq},
 ) where {Nq}
     gidx = threadIdx().x + (blockIdx().x - Int32(1)) * blockDim().x
     (nperimeter, _, _, nlevels, nelems) = size(perimeter_data)
     nfidx = DataLayouts.ncomponents(perimeter_data)
-    sizep = (nlevels, nperimeter, nfidx, nelems) # assume VIFH order
+    sizep = (nlevels, nperimeter, nfidx, nelems) # assume VIHF order
     CI = CartesianFieldIndex
 
     if gidx ≤ prod(sizep)
@@ -57,7 +57,7 @@ end
 
 function Topologies.dss_unload_perimeter_data!(
     ::ClimaComms.CUDADevice,
-    data::Union{DataLayouts.IJFH, DataLayouts.VIJFH},
+    data::Union{DataLayouts.IJHF, DataLayouts.VIJHF},
     dss_buffer::Topologies.DSSBuffer,
     perimeter,
 )
@@ -76,14 +76,14 @@ function Topologies.dss_unload_perimeter_data!(
 end
 
 function dss_unload_perimeter_data_kernel!(
-    data::Union{DataLayouts.IJFH, DataLayouts.VIJFH},
+    data::Union{DataLayouts.IJHF, DataLayouts.VIJHF},
     perimeter_data::AbstractData,
     perimeter::Topologies.Perimeter2D{Nq},
 ) where {Nq}
     gidx = threadIdx().x + (blockIdx().x - Int32(1)) * blockDim().x
     (nperimeter, _, _, nlevels, nelems) = size(perimeter_data)
     nfidx = DataLayouts.ncomponents(perimeter_data)
-    sizep = (nlevels, nperimeter, nfidx, nelems) # assume VIFH order
+    sizep = (nlevels, nperimeter, nfidx, nelems) # assume VIHF order
     CI = CartesianFieldIndex
 
     if gidx ≤ prod(sizep)
@@ -97,7 +97,7 @@ end
 
 function Topologies.dss_local!(
     ::ClimaComms.CUDADevice,
-    perimeter_data::DataLayouts.VIFH,
+    perimeter_data::DataLayouts.VIHF,
     perimeter::Topologies.Perimeter2D,
     topology::Topologies.Topology2D,
 )
@@ -127,7 +127,7 @@ function Topologies.dss_local!(
 end
 
 function dss_local_kernel!(
-    perimeter_data::DataLayouts.VIFH,
+    perimeter_data::DataLayouts.VIHF,
     local_vertices::AbstractVector{Tuple{Int, Int}},
     local_vertex_offset::AbstractVector{Int},
     interior_faces::AbstractVector{Tuple{Int, Int, Int, Int, Bool}},
@@ -182,11 +182,11 @@ end
 
 function Topologies.dss_transform!(
     device::ClimaComms.CUDADevice,
-    perimeter_data::DataLayouts.VIFH,
-    data::Union{DataLayouts.VIJFH, DataLayouts.IJFH},
+    perimeter_data::DataLayouts.VIHF,
+    data::Union{DataLayouts.VIJHF, DataLayouts.IJHF},
     perimeter::Topologies.Perimeter2D,
-    local_geometry::Union{DataLayouts.IJFH, DataLayouts.VIJFH},
-    weight::DataLayouts.IJFH,
+    local_geometry::Union{DataLayouts.IJHF, DataLayouts.VIJHF},
+    weight::DataLayouts.IJHF,
     localelems::AbstractVector{Int},
 )
     nlocalelems = length(localelems)
@@ -217,11 +217,11 @@ function Topologies.dss_transform!(
 end
 
 function dss_transform_kernel!(
-    perimeter_data::DataLayouts.VIFH,
-    data::Union{DataLayouts.VIJFH, DataLayouts.IJFH},
+    perimeter_data::DataLayouts.VIHF,
+    data::Union{DataLayouts.VIJHF, DataLayouts.IJHF},
     perimeter::Topologies.Perimeter2D,
-    local_geometry::Union{DataLayouts.IJFH, DataLayouts.VIJFH},
-    weight::DataLayouts.IJFH,
+    local_geometry::Union{DataLayouts.IJHF, DataLayouts.VIJHF},
+    weight::DataLayouts.IJHF,
     localelems::AbstractVector{Int},
     ::Val{nlocalelems},
 ) where {nlocalelems}
@@ -248,9 +248,9 @@ end
 
 function Topologies.dss_untransform!(
     device::ClimaComms.CUDADevice,
-    perimeter_data::DataLayouts.VIFH,
-    data::Union{DataLayouts.VIJFH, DataLayouts.IJFH},
-    local_geometry::Union{DataLayouts.IJFH, DataLayouts.VIJFH},
+    perimeter_data::DataLayouts.VIHF,
+    data::Union{DataLayouts.VIJHF, DataLayouts.IJHF},
+    local_geometry::Union{DataLayouts.IJHF, DataLayouts.VIJHF},
     perimeter::Topologies.Perimeter2D,
     localelems::AbstractVector{Int},
 )
@@ -280,9 +280,9 @@ function Topologies.dss_untransform!(
 end
 
 function dss_untransform_kernel!(
-    perimeter_data::DataLayouts.VIFH,
-    data::Union{DataLayouts.VIJFH, DataLayouts.IJFH},
-    local_geometry::Union{DataLayouts.IJFH, DataLayouts.VIJFH},
+    perimeter_data::DataLayouts.VIHF,
+    data::Union{DataLayouts.VIJHF, DataLayouts.IJHF},
+    local_geometry::Union{DataLayouts.IJHF, DataLayouts.VIJHF},
     perimeter::Topologies.Perimeter2D,
     localelems::AbstractVector{Int},
     ::Val{nlocalelems},
@@ -309,7 +309,7 @@ end
 # TODO: Function stubs, code to be implemented, needed only for distributed GPU runs
 function Topologies.dss_local_ghost!(
     ::ClimaComms.CUDADevice,
-    perimeter_data::DataLayouts.VIFH,
+    perimeter_data::DataLayouts.VIHF,
     perimeter::Topologies.Perimeter2D,
     topology::Topologies.AbstractTopology,
 )
@@ -337,7 +337,7 @@ function Topologies.dss_local_ghost!(
 end
 
 function dss_local_ghost_kernel!(
-    perimeter_data::DataLayouts.VIFH,
+    perimeter_data::DataLayouts.VIHF,
     ghost_vertices,
     ghost_vertex_offset,
     perimeter::Topologies.Perimeter2D,
@@ -474,7 +474,7 @@ end
 
 function Topologies.dss_ghost!(
     ::ClimaComms.CUDADevice,
-    perimeter_data::DataLayouts.VIFH,
+    perimeter_data::DataLayouts.VIHF,
     perimeter::Topologies.Perimeter2D,
     topology::Topologies.Topology2D,
 )

lib/ClimaCorePlots/src/ClimaCorePlots.jl

@@ -104,7 +104,7 @@ RecipesBase.@recipe function f(space::Spaces.ExtrudedFiniteDifferenceSpace)
     data = Fields.field_values(coord_field)
     Ni, Nj, _, Nv, Nh = size(data)
 
-    #TODO: assumes VIFH layout
+    #TODO: assumes VIHF layout
     @assert Nj == 1 "plotting only defined for 1D extruded fields"
 
     hspace = Spaces.horizontal_space(space)
@@ -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}(Array{FT}, nelem)
+    interpolated_data = DataLayouts.IJHF{FT, interpolate}(Array{FT}, nelem)
     field_data = Fields.field_values(field)
 
     Operators.tensor_product!(interpolated_data, field_data, Imat)
@@ -445,7 +445,7 @@ function _unfolded_pannel_matrix(field, interpolate)
         x2_nodal_range = (dof * (ex2 - 1) + 1):(dof * ex2)
         # transpose the data as our plotting axis order is
         # reverse nodal element order (x1 axis varies fastest)
-        data_element = permutedims(parent(interpolated_data)[:, :, 1, lidx])
+        data_element = permutedims(parent(interpolated_data)[:, :, lidx, 1])
         panel_data[x2_nodal_range, x1_nodal_range] = data_element
     end