Improve names

Author: charleskawczynski

docs/src/APIs/domains_api.md

@@ -17,4 +17,5 @@ Domains.SphereDomain
 
 ```@docs
 Domains.boundary_names
+Domains.unique_boundary_names
 ```

src/Domains/Domains.jl

@@ -22,10 +22,17 @@ float_type(domain::AbstractDomain) = float_type(coordinate_type(domain))
 """
     boundary_names(obj::Union{AbstractDomain, AbstractMesh, AbstractTopology})
 
-A tuple or vector of unique boundary names of a spatial domain.
+The boundary names passed to the IntervalDomain (a tuple, or `nothing`).
 """
 function boundary_names end
 
+"""
+    unique_boundary_names(obj::Union{AbstractDomain, AbstractMesh, AbstractTopology})
+
+A tuple or vector of unique boundary names of a spatial domain.
+"""
+function unique_boundary_names end
+
 struct IntervalDomain{CT, B} <: AbstractDomain where {
     CT <: Geometry.Abstract1DPoint{FT},
     B <: BCTagType,
@@ -35,9 +42,9 @@ struct IntervalDomain{CT, B} <: AbstractDomain where {
 end
 
 isperiodic(::IntervalDomain{CT, B}) where {CT, B} = B == nothing
-boundary_names(domain::IntervalDomain{CT, B}) where {CT, B} =
+unique_boundary_names(domain::IntervalDomain{CT, B}) where {CT, B} =
     isperiodic(domain) ? () : unique(B)
-boundary_names_type(::IntervalDomain{CT, B}) where {CT, B} = B
+boundary_names(::IntervalDomain{CT, B}) where {CT, B} = B
 
 """
     IntervalDomain(coord⁻, coord⁺; periodic=true)
@@ -101,7 +108,7 @@ function print_interval(io::IO, domain::IntervalDomain{CT}) where {CT}
     if isperiodic(domain)
         print(io, "(periodic)")
     else
-        print(io, boundary_names_type(domain))
+        print(io, boundary_names(domain))
     end
 end
 function Base.show(io::IO, domain::IntervalDomain)
@@ -117,10 +124,10 @@ end
 Base.:*(interval1::IntervalDomain, interval2::IntervalDomain) =
     RectangleDomain(interval1, interval2)
 
-boundary_names(domain::RectangleDomain) = unique(
+unique_boundary_names(domain::RectangleDomain) = unique(
     Symbol[
-        boundary_names(domain.interval1)...,
-        boundary_names(domain.interval2)...,
+        unique_boundary_names(domain.interval1)...,
+        unique_boundary_names(domain.interval2)...,
     ],
 )::Vector{Symbol}
 
@@ -177,6 +184,7 @@ Base.show(io::IO, domain::SphereDomain) =
     print(io, nameof(typeof(domain)), ": radius = ", domain.radius)
 
 boundary_names(::SphereDomain) = ()
+unique_boundary_names(::SphereDomain) = ()
 coordinate_type(::SphereDomain{FT}) where {FT} = Geometry.Cartesian123Point{FT}
 
 end # module

src/InputOutput/writers.jl

@@ -166,10 +166,10 @@ function write_new!(
     )
     write_attribute(group, "coord_min", Geometry.component(domain.coord_min, 1))
     write_attribute(group, "coord_max", Geometry.component(domain.coord_max, 1))
-    !isnothing(Domains.boundary_names_type(domain)) && write_attribute(
+    !isnothing(Domains.boundary_names(domain)) && write_attribute(
         group,
         "boundary_names",
-        [String(bname) for bname in Domains.boundary_names_type(domain)],
+        [String(bname) for bname in Domains.boundary_names(domain)],
     )
     return name
 end

src/Meshes/Meshes.jl

@@ -14,6 +14,7 @@ import ..Domains:
     RectangleDomain,
     SphereDomain,
     boundary_names,
+    unique_boundary_names,
     coordinate_type
 import ..Geometry
 import SparseArrays, CubedSphere, LinearAlgebra, StaticArrays

src/Meshes/common.jl

@@ -1,4 +1,5 @@
 boundary_names(mesh::AbstractMesh) = boundary_names(domain(mesh))
+unique_boundary_names(mesh::AbstractMesh) = unique_boundary_names(domain(mesh))
 coordinate_type(mesh::AbstractMesh) = coordinate_type(domain(mesh))
 
 """

src/Meshes/interval.jl

@@ -88,9 +88,9 @@ end
 function boundary_face_name(mesh::IntervalMesh, elem::Integer, face)
     if !Domains.isperiodic(mesh.domain)
         if elem == 1 && face == 1
-            return Domains.boundary_names(mesh.domain)[1]
+            return Domains.unique_boundary_names(mesh.domain)[1]
         elseif elem == nelements(mesh) && face == 2
-            return Domains.boundary_names(mesh.domain)[2]
+            return Domains.unique_boundary_names(mesh.domain)[2]
         end
     end
     return nothing
@@ -471,7 +471,7 @@ function truncate_mesh(
     new_domain = IntervalDomain(
         z_bottom,
         Geometry.ZPoint{FT}(z_top),
-        boundary_names = Domains.boundary_names_type(trunc_domain),
+        boundary_names = Domains.boundary_names(trunc_domain),
     )
     return IntervalMesh(new_domain, new_stretch; nelems = new_nelems)
 end

src/Topologies/Topologies.jl

@@ -5,7 +5,7 @@ import ClimaComms, Adapt
 import ..ClimaCore
 import ..Utilities: Cache, cart_ind, linear_ind
 import ..Geometry
-import ..Domains: Domains, coordinate_type
+import ..Domains: Domains, coordinate_type, unique_boundary_names
 import ..Meshes: Meshes, domain, coordinates
 import ..DataLayouts
 import ..DataLayouts: slab_index

src/Topologies/interval.jl

@@ -45,7 +45,7 @@ function _IntervalTopology(
     if Domains.isperiodic(domain)
         boundaries = NamedTuple()
     else
-        bn = Domains.boundary_names_type(domain)
+        bn = Domains.boundary_names(domain)
         boundaries = if bn[1] == bn[2]
             NamedTuple{(bn[1],)}(1)
         else

src/Topologies/topology2d.jl

@@ -462,7 +462,7 @@ function _Topology2D(
     # 5) faces
     boundaries = NamedTuple(
         boundary_name => Tuple{Int, Int}[] for
-        boundary_name in Meshes.boundary_names(mesh)
+        boundary_name in Meshes.unique_boundary_names(mesh)
     )
     interior_faces = Tuple{Int, Int, Int, Int, Bool}[]
     ghost_faces = Tuple{Int, Int, Int, Int, Bool}[]
@@ -772,12 +772,12 @@ end
 
 
 neighbors(topology::Topology2D) = topology.neighbor_pids
-boundary_names(topology::Topology2D) = keys(topology.boundaries)
-boundary_tags(topology::Topology2D) = NamedTuple{boundary_names(topology)}(
+unique_boundary_names(topology::Topology2D) = keys(topology.boundaries)
+boundary_tags(topology::Topology2D) = NamedTuple{unique_boundary_names(topology)}(
     ntuple(i -> i, length(topology.boundaries)),
 )
 boundary_tag(topology::Topology2D, boundary_name::Symbol) =
-    findfirst(==(boundary_name), boundary_names(topology))
+    findfirst(==(boundary_name), unique_boundary_names(topology))
 
 boundary_faces(topology::Topology2D, boundary) = topology.boundaries[boundary]