refactor: make newton_div type names less verbose

Author: Mikolaj-A-Kowalski

ext/OceananigansCUDAExt.jl

@@ -137,7 +137,7 @@ end
 @inline UT.sync_device!(::CUDABackend)   = CUDA.synchronize()
 
 # Use faster versions of `newton_div` on Nvidia GPUs
-CUDA.@device_override UT.newton_div(::Type{UT.BackendOptimizedNewtonDiv}, a, b) = a * fast_inv_cuda(b)
+CUDA.@device_override UT.newton_div(::Type{UT.BackendOptimizedDivision}, a, b) = a * fast_inv_cuda(b)
 
 function fast_inv_cuda(a::Float64)
     # Get the approximate reciprocal

src/Advection/vector_invariant_advection.jl

@@ -193,11 +193,11 @@ julia> using Oceananigans
 
 julia> WENOVectorInvariant()
 WENOVectorInvariant{5, Float64}(vorticity_order=9, vertical_order=5)
-├── vorticity_scheme: WENO{5, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=9)
+├── vorticity_scheme: WENO{5, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=9)
 ├── vorticity_stencil: Oceananigans.Advection.VelocityStencil
-├── vertical_advection_scheme: WENO{3, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=5)
-├── kinetic_energy_gradient_scheme: WENO{3, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=5)
-├── divergence_scheme: WENO{3, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=5)
+├── vertical_advection_scheme: WENO{3, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=5)
+├── kinetic_energy_gradient_scheme: WENO{3, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=5)
+├── divergence_scheme: WENO{3, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=5)
 └── upwinding: OnlySelfUpwinding
 ```
 """

src/Advection/weno_reconstruction.jl

@@ -32,7 +32,7 @@ Arguments
 Keyword arguments
 =================
 - `weight_computation`: The type of approximate division to used when computing WENO weights.
-                        Default: `Oceananigans.Utils.NewtonDivWithConversion{Float32}`
+                        Default: `Oceananigans.Utils.ConvertingDivision{Float32}`
 - `order`: The order of the WENO advection scheme. Default: 5
 - `bounds` (experimental): Whether to use bounds-preserving WENO, which produces a reconstruction
                            that attempts to restrict a quantity to lie between a `bounds` tuple.
@@ -51,8 +51,8 @@ To build the default 5th-order scheme:
 julia> using Oceananigans
 
 julia> WENO()
-WENO{3, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=5)
-├── buffer_scheme: WENO{2, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=3)
+WENO{3, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=5)
+├── buffer_scheme: WENO{2, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=3)
 │   └── buffer_scheme: Centered(order=2)
 └── advecting_velocity_scheme: Centered(order=4)
 ```
@@ -62,10 +62,10 @@ yet minimally-dissipative advection scheme):
 
 ```jldoctest weno
 julia> WENO(order=9)
-WENO{5, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=9)
-├── buffer_scheme: WENO{4, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=7)
-│   └── buffer_scheme: WENO{3, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=5)
-│       └── buffer_scheme: WENO{2, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=3)
+WENO{5, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=9)
+├── buffer_scheme: WENO{4, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=7)
+│   └── buffer_scheme: WENO{3, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=5)
+│       └── buffer_scheme: WENO{2, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=3)
 │           └── buffer_scheme: Centered(order=2)
 └── advecting_velocity_scheme: Centered(order=8)
 ```
@@ -75,34 +75,34 @@ which uses `Centered(order=2)` as the innermost buffer scheme:
 
 ```jldoctest weno
 julia> WENO(order=9, minimum_buffer_upwind_order=5)
-WENO{5, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=9)
-├── buffer_scheme: WENO{4, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=7)
-│   └── buffer_scheme: WENO{3, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=5)
+WENO{5, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=9)
+├── buffer_scheme: WENO{4, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=7)
+│   └── buffer_scheme: WENO{3, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=5)
 │       └── buffer_scheme: Centered(order=2)
 └── advecting_velocity_scheme: Centered(order=8)
 ```
 
 ```jldoctest weno
 julia> WENO(order=9, bounds=(0, 1))
-WENO{5, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=9, bounds=(0.0, 1.0))
-├── buffer_scheme: WENO{4, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=7, bounds=(0.0, 1.0))
-│   └── buffer_scheme: WENO{3, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=5, bounds=(0.0, 1.0))
-│       └── buffer_scheme: WENO{2, Float64, Oceananigans.Utils.NewtonDivWithConversion{Float32}}(order=3, bounds=(0.0, 1.0))
+WENO{5, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=9, bounds=(0.0, 1.0))
+├── buffer_scheme: WENO{4, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=7, bounds=(0.0, 1.0))
+│   └── buffer_scheme: WENO{3, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=5, bounds=(0.0, 1.0))
+│       └── buffer_scheme: WENO{2, Float64, Oceananigans.Utils.ConvertingDivision{Float32}}(order=3, bounds=(0.0, 1.0))
 │           └── buffer_scheme: Centered(order=2)
 └── advecting_velocity_scheme: Centered(order=8)
 ```
 
 To build a WENO scheme that uses approximate division on a GPU to execute faster:
 ```jldoctest weno
-julia> WENO(;weight_computation=Oceananigans.Utils.BackendOptimizedNewtonDiv)
-WENO{3, Float64, Oceananigans.Utils.BackendOptimizedNewtonDiv}(order=5)
-├── buffer_scheme: WENO{2, Float64, Oceananigans.Utils.BackendOptimizedNewtonDiv}(order=3)
+julia> WENO(;weight_computation=Oceananigans.Utils.BackendOptimizedDivision)
+WENO{3, Float64, Oceananigans.Utils.BackendOptimizedDivision}(order=5)
+├── buffer_scheme: WENO{2, Float64, Oceananigans.Utils.BackendOptimizedDivision}(order=3)
 │   └── buffer_scheme: Centered(order=2)
 └── advecting_velocity_scheme: Centered(order=4)
 ```
 """
 function WENO(FT::DataType=Oceananigans.defaults.FloatType;
-              weight_computation::DataType=Oceananigans.Utils.NewtonDivWithConversion{Float32},
+              weight_computation::DataType=Oceananigans.Utils.ConvertingDivision{Float32},
               order = 5,
               buffer_scheme = DecreasingOrderAdvectionScheme(),
               bounds = nothing,

src/Utils/Utils.jl

@@ -11,7 +11,7 @@ export seconds_to_nanosecond, period_to_seconds, time_difference_seconds, add_ti
 export TimeInterval, IterationInterval, WallTimeInterval, SpecifiedTimes, AndSchedule, OrSchedule, ConsecutiveIterations
 export apply_regionally!, construct_regionally, @apply_regionally, MultiRegionObject
 export isregional, getregion, _getregion, regions, sync_device!
-export newton_div, NoNewtonDiv, NewtonDivWithConversion, BackendOptimizedNewtonDiv
+export newton_div, NormalDivision, ConvertingDivision, BackendOptimizedDivision
 export TabulatedFunction
 export interpolator, _interpolate
 export ϕ₁, ϕ₂, ϕ₃, ϕ₄, ϕ₅, ϕ₆, ϕ₇, ϕ₈

src/Utils/newton_div.jl

@@ -8,21 +8,21 @@ abstract type NewtonDivConfig end
 """
 Configuration selecting regular, full-precision division.
 """
-struct NoNewtonDiv <: NewtonDivConfig end
+struct NormalDivision <: NewtonDivConfig end
 
 """
 Configuration selecting approximate division via one Newton iteration.
 The reciprocal `1/b` is first evaluated in a lower-precision type `FT`
 to obtain a fast initial guess, then refined with a single Newton step
 in the original precision.
 """
-struct NewtonDivWithConversion{FT} <: NewtonDivConfig end
+struct ConvertingDivision{FT} <: NewtonDivConfig end
 
 """
 Configuration selecting a backend-optimized implementation of approximate division.
 The actual algorithm may differ across CPU and different GPU backends.
 """
-struct BackendOptimizedNewtonDiv <: NewtonDivConfig end
+struct BackendOptimizedDivision <: NewtonDivConfig end
 
 """
     newton_div(::Type{T}, a, b)
@@ -31,7 +31,7 @@ Compute an approximate division `a/b` using a method specified by selector type
 """
 function newton_div end
 
-@inline function newton_div(::Type{NewtonDivWithConversion{inv_FT}}, a, b::FT) where {inv_FT, FT}
+@inline function newton_div(::Type{ConvertingDivision{inv_FT}}, a, b::FT) where {inv_FT, FT}
     # Low precision division:
     b_low = convert(inv_FT, b)
     inv_b = Base.FastMath.inv_fast(b_low)
@@ -46,7 +46,7 @@ function newton_div end
 end
 
 # Case of matching precisions
-@inline newton_div(::Type{NewtonDivWithConversion{FT}}, a, b::FT) where FT = a * Base.FastMath.inv_fast(b)
+@inline newton_div(::Type{ConvertingDivision{FT}}, a, b::FT) where FT = a * Base.FastMath.inv_fast(b)
 
 # Exact division if requested
-@inline newton_div(::Type{NoNewtonDiv}, a, b) = a / b
+@inline newton_div(::Type{NormalDivision}, a, b) = a / b