Merge pull request #120 from milankl/rename

Rename to ShallowWaters

Author: Milan K

Project.toml

@@ -1,7 +1,7 @@
-name = "Juls"
+name = "ShallowWaters"
 uuid = "56019723-2d87-4a65-81ff-59d5d8913e3c"
 authors = ["Milan Kloewer"]
-version = "0.5.0"
+version = "0.1.0"
 
 [compat]
 julia = "1"

README.md

@@ -4,30 +4,30 @@
 [![Cirrus CI](https://img.shields.io/cirrus/github/milankl/Juls.jl?label=FreeBSD&logo=cirrus-ci&logoColor=white&style=flat-square)](https://cirrus-ci.com/github/milankl/Juls.jl)
 
 
-# Juls.jl - A type-flexible 16bit shallow water model
+# ShallowWaters.jl - A type-flexible 16bit shallow water model
 ![sst](figs/sst_posit16.png?raw=true "SST")
 
-A shallow water model with a focus on type-flexibility and 16bit number formats. Juls allows for Float64/32/16, BigFloat/[ArbFloat](https://github.com/JeffreySarnoff/ArbNumerics.jl), [Posit32/16](https://github.com/milankl/SoftPosit.jl), [BFloat16](https://github.com/JuliaComputing/BFloat16s.jl), [Sonum16](https://github.com/milankl/Sonums.jl) and in general every number format with arithmetics and conversions implemented.
+A shallow water model with a focus on type-flexibility and 16bit number formats. ShallowWaters allows for Float64/32/16, BigFloat/[ArbFloat](https://github.com/JeffreySarnoff/ArbNumerics.jl), [Posit32/16](https://github.com/milankl/SoftPosit.jl), [BFloat16](https://github.com/JuliaComputing/BFloat16s.jl), [Sonum16](https://github.com/milankl/Sonums.jl) and in general every number format with arithmetics and conversions implemented.
 
-Juls is fully-explicit with an energy and enstrophy conserving advection scheme and a Smagorinsky-like biharmonic diffusion operator. Tracer advection is implemented with a semi-Lagrangian advection scheme. Runge-Kutta 4th-order is used for pressure, advective and Coriolis terms and the continuity equation. Semi-implicit time stepping for diffusion and bottom friction. Boundary conditions are either periodic (only in x direction) or non-periodic super-slip, free-slip, partial-slip, or no-slip. Output via NetCDF.
+ShallowWaters is fully-explicit with an energy and enstrophy conserving advection scheme and a Smagorinsky-like biharmonic diffusion operator. Tracer advection is implemented with a semi-Lagrangian advection scheme. Runge-Kutta 4th-order is used for pressure, advective and Coriolis terms and the continuity equation. Semi-implicit time stepping for diffusion and bottom friction. Boundary conditions are either periodic (only in x direction) or non-periodic super-slip, free-slip, partial-slip, or no-slip. Output via NetCDF.
 
 ## How to use
 
-You find the default parameters in `src/DefaultParameters.jl`. They can be changed with keyword arguments. Optionally, the number format `T` is defined as the first argument of `RunJuls(T,...)`
+You find the default parameters in `src/DefaultParameters.jl`. They can be changed with keyword arguments. Optionally, the number format `T` is defined as the first argument of `RunModel(T,...)`
 ```julia
-julia> Prog = RunJuls(Float32,Ndays=10,g=10,H=500,Fx0=0.12);
-Starting Juls on Sun, 20 Oct 2019 19:58:25 without output.
+julia> Prog = RunModel(Float32,Ndays=10,g=10,H=500,Fx0=0.12);
+Starting ShallowWaters on Sun, 20 Oct 2019 19:58:25 without output.
 100% Integration done in 4.65s.
 ```
 or by creating a Parameter struct
 ```julia
 julia> P = Parameter(bc="nonperiodic",wind_forcing_x="double_gyre",L_ratio=1,nx=128);
-julia> Prog = RunJuls(P);
+julia> Prog = RunModel(P);
 ```
 
 ## Installation
 ```julia
-julia> ] add https://github.com/milankl/Juls.jl
+julia> ] add https://github.com/milankl/ShallowWaters.jl
 ```
 
 ## The equations
@@ -48,6 +48,6 @@ The linear shallow water model equivalent is
           ∂η/∂t = -H*∇⋅u⃗ + γ*(η_ref - η) + Fηt(t)*Fη(x,y)         (3)
           ∂ϕ/∂t = -u⃗⋅∇ϕ                                           (4)
 
-Juls discretises the equation on an equi-distant Arakawa C-grid, with 2nd order finite-difference operators. Boundary conditions are implemented via a ghost-point copy and each variable has a halo of variable size to account for different stencil sizes of various operators.
+ShallowWaters.jl discretises the equation on an equi-distant Arakawa C-grid, with 2nd order finite-difference operators. Boundary conditions are implemented via a ghost-point copy and each variable has a halo of variable size to account for different stencil sizes of various operators.
 
-Juls splits the time steps for various terms: Runge Kutta 4th order scheme for the fast varying terms. The diffusive terms (bottom friction and diffusion) are solved semi-implicitly every n-th time step. The tracer equation is solved with a semi-Lagrangian scheme that uses usually much larger time steps.
+ShallowWaters.jl splits the time steps for various terms: Runge Kutta 4th order scheme for the fast varying terms. The diffusive terms (bottom friction and diffusion) are solved semi-implicitly every n-th time step. The tracer equation is solved with a semi-Lagrangian scheme that uses much larger time steps.

src/Feedback.jl

@@ -84,10 +84,10 @@ function feedback_init(S::ModelSetup)
         run_id,runpath = get_run_id_path(S)
 
         txt = open(joinpath(runpath,"progress.txt"),"w")
-        s = "Starting Juls run $run_id on "*Dates.format(now(),Dates.RFC1123Format)
+        s = "Starting ShallowWaters run $run_id on "*Dates.format(now(),Dates.RFC1123Format)
         println(s)
         write(txt,s*"\n")
-        write(txt,"Juls will integrate $(Ndays)days at a resolution of $(nx)x$(ny) with Δ=$(Δ/1e3)km\n")
+        write(txt,"Model will integrate $(Ndays)days at a resolution of $(nx)x$(ny) with Δ=$(Δ/1e3)km\n")
         write(txt,"Initial conditions are ")
         if initial_cond == "rest"
             write(txt,"rest.\n")
@@ -107,7 +107,7 @@ function feedback_init(S::ModelSetup)
         print(ptxt,S.parameters)
         close(ptxt)
     else
-        println("Starting Juls on "*Dates.format(now(),Dates.RFC1123Format)*" without output.")
+        println("Starting ShallowWaters on "*Dates.format(now(),Dates.RFC1123Format)*" without output.")
         txt = nothing
         run_id = -1
         runpath = ""

src/RunJuls.jl renamed to src/RunModel.jl

@@ -1,28 +1,28 @@
 """
 
-    u,v,η,sst = RunJuls()
+    u,v,η,sst = RunModel()
 
-runs Juls with default parameters as defined in src/DefaultParameters.jl
+runs ShallowWaters with default parameters as defined in src/DefaultParameters.jl
 
 # Examples
 ```jldoc
-julia> u,v,η,sst = RunJuls(Float64,nx=200,output=true)
+julia> u,v,η,sst = RunModel(Float64,nx=200,output=true)
 ```
 """
-function RunJuls(::Type{T}=Float32;     # number format
+function RunModel(::Type{T}=Float32;     # number format
     kwargs...                           # all additional parameters
     ) where {T<:AbstractFloat}
 
     P = Parameter(T=T;kwargs...)
-    return RunJuls(T,P)
+    return RunModel(T,P)
 end
 
-function RunJuls(P::Parameter)
+function RunModel(P::Parameter)
     @unpack T = P
-    return RunJuls(T,P)
+    return RunModel(T,P)
 end
 
-function RunJuls(::Type{T},P::Parameter) where {T<:AbstractFloat}
+function RunModel(::Type{T},P::Parameter) where {T<:AbstractFloat}
 
     @unpack Tprog = P
 

src/Juls.jl renamed to src/ShallowWaters.jl

@@ -1,6 +1,6 @@
-module Juls
+module ShallowWaters
 
-export RunJuls, Parameter
+export RunModel, Parameter
 
 using NetCDF, Parameters, Printf, Dates
 
@@ -25,6 +25,6 @@ include("TracerAdvection.jl")
 
 include("Feedback.jl")
 include("Output.jl")
-include("RunJuls.jl")
+include("RunModel.jl")
 
 end

src/TimeIntegration.jl

@@ -1,4 +1,4 @@
-"""Integrates Juls forward in time."""
+"""Integrates ShallowWaters forward in time."""
 function time_integration(  Prog::PrognosticVars{Tprog},
                             Diag::DiagnosticVars{T,Tprog},
                             S::ModelSetup{T,Tprog}) where {T<:AbstractFloat,Tprog<:AbstractFloat}

test/runtests.jl

@@ -1,40 +1,40 @@
-using Juls
+using ShallowWaters
 using Test
 
 @testset "No Forcing" begin
-    Prog = RunJuls(Ndays=1,Fx0=0)
+    Prog = RunModel(Ndays=1,Fx0=0)
     @test all(Prog.u .== 0.0f0)
     @test all(Prog.v .== 0.0f0)
     @test all(Prog.η .== 0.0f0)
 end
 
 @testset "Boundary Conditions" begin
-    Prog = RunJuls(Ndays=1,bc="periodic")
+    Prog = RunModel(Ndays=1,bc="periodic")
     @test all(abs.(Prog.η) .< 10)    # sea surface height shouldn't exceed +-10m
 
-    Prog = RunJuls(Ndays=1,bc="nonperiodic")
+    Prog = RunModel(Ndays=1,bc="nonperiodic")
     @test all(abs.(Prog.η) .< 10)
 
-    Prog = RunJuls(Ndays=1,α=0)     # free-slip
+    Prog = RunModel(Ndays=1,α=0)     # free-slip
     @test all(abs.(Prog.η) .< 10)
 end
 
 @testset "Continuity Forcing" begin
-    Prog = RunJuls(Ndays=1,surface_relax=true)
+    Prog = RunModel(Ndays=1,surface_relax=true)
     @test all(abs.(Prog.η) .< 10)    # sea surface height shouldn't exceed +-10m
     @test all(Prog.u .!= 0.0f0)
 
-    Prog = RunJuls(Ndays=1,surface_forcing=true)
+    Prog = RunModel(Ndays=1,surface_forcing=true)
     @test all(abs.(Prog.η) .< 10)
     @test all(Prog.u .!= 0.0f0)
 end
 
 @testset "Mixed Precision" begin
-    Prog = RunJuls(Float32,Tprog=Float64,Ndays=1)
+    Prog = RunModel(Float32,Tprog=Float64,Ndays=1)
     @test all(abs.(Prog.η) .< 10)    # sea surface height shouldn't exceed +-10m
     @test all(Prog.u .!= 0.0f0)
 
-    Prog = RunJuls(Float16,Tprog=Float32,Ndays=1)
+    Prog = RunModel(Float16,Tprog=Float32,Ndays=1)
     @test all(abs.(Prog.η) .< 10)    # sea surface height shouldn't exceed +-10m
     @test all(Prog.u .!= 0.0f0)
 end