rename model files

build/create_binaries/precompile.jl

@@ -3,5 +3,5 @@
 
 using Ribasim, Dates, TOML
 
-toml_path = normpath(@__DIR__, "../../generated_testmodels/basic/basic.toml")
+toml_path = normpath(@__DIR__, "../../generated_testmodels/basic/ribasim.toml")
 Ribasim.run(toml_path)

build/libribasim/README.md

@@ -22,7 +22,7 @@ In [3]: argument = create_string_buffer(0)
    ...: c_dll.init_julia(c_int(0), byref(argument))
 Out[3]: 1
 
-In [4]: config_path = "run.toml"
+In [4]: config_path = "ribasim.toml"
 
 In [5]: c_dll.initialize(c_char_p(config_path.encode()))
 Out[5]: 0

build/ribasim_cli/README.md

@@ -13,11 +13,11 @@ If you have installed Julia and Ribasim, a simulation can also be started from t
 line as follows:
 
 ```
-julia --eval 'using Ribasim; Ribasim.run("path/to/config.toml")'
+julia --eval 'using Ribasim; Ribasim.run("path/to/model/ribasim.toml")'
 ```
 
 With a Ribasim CLI build this becomes:
 
 ```
-ribasim path/to/config.toml
+ribasim path/to/model/ribasim.toml
 ```

build/ribasim_cli/src/ribasim_cli.jl

@@ -7,7 +7,7 @@ using Ribasim
 
 function help(x)::Cint
     println(x)
-    println("Usage: ribasim path/to/config.toml")
+    println("Usage: ribasim path/to/model/ribasim.toml")
     return 1
 end
 

build/ribasim_cli/tests/test_models.py

@@ -7,13 +7,13 @@
 
 
 @pytest.mark.parametrize(
-    "model_constructor",
-    map(ribasim_testmodels.__dict__.get, ribasim_testmodels.__all__),
+    "model_name,model_constructor",
+    ribasim_testmodels.constructors.items(),
 )
-def test_ribasim_cli(model_constructor, tmp_path):
+def test_ribasim_cli(model_name, model_constructor, tmp_path):
     model = model_constructor()
     assert isinstance(model, ribasim.Model)
-    model.write(tmp_path)
+    model.write(tmp_path / model_name)
 
     executable = (
         Path(__file__).parents[2]
@@ -22,10 +22,10 @@ def test_ribasim_cli(model_constructor, tmp_path):
         / "bin"
         / "ribasim.exe"
     )
-    config_file = str(tmp_path / f"{model.modelname}.toml")
+    config_file = str(tmp_path / "ribasim.toml")
     result = subprocess.run([executable, config_file])
 
-    if model.modelname.startswith("invalid"):
+    if model_name.startswith("invalid_"):
         assert result.returncode != 0
     else:
         assert result.returncode == 0

core/src/bmi.jl

@@ -15,19 +15,19 @@
 """
 function BMI.initialize(T::Type{Model}, config::Config)::Model
     alg = algorithm(config.solver)
-    gpkg_path = input_path(config, config.geopackage)
-    if !isfile(gpkg_path)
-        throw(SystemError("GeoPackage file not found: $gpkg_path"))
+    db_path = input_path(config, config.database)
+    if !isfile(db_path)
+        throw(SystemError("Database file not found: $db_path"))
     end
 
     # Setup timing logging
     if config.logging.timing
         TimerOutputs.enable_debug_timings(Ribasim)  # causes recompilation (!)
     end
 
-    # All data from the GeoPackage that we need during runtime is copied into memory,
+    # All data from the database that we need during runtime is copied into memory,
     # so we can directly close it again.
-    db = SQLite.DB(gpkg_path)
+    db = SQLite.DB(db_path)
     local parameters, state, n, tstops
     try
         parameters = Parameters(db, config)
@@ -83,7 +83,7 @@
         state = load_structvector(db, config, BasinStateV1)
         n = length(get_ids(db, "Basin"))
     finally
-        # always close the GeoPackage, also in case of an error
+        # always close the database, also in case of an error
         close(db)
     end
     @debug "Read database into memory."
@@ -156,29 +156,29 @@
 """
     BMI.finalize(model::Model)::Model
 
-Write all output to the configured output files.
+Write all results to the configured files.
 """
 function BMI.finalize(model::Model)::Model
     (; config) = model
-    (; output) = model.config
-    compress = get_compressor(output)
+    (; results) = model.config
+    compress = get_compressor(results)
 
     # basin
     table = basin_table(model)
-    path = output_path(config, output.basin)
+    path = results_path(config, results.basin)
     write_arrow(path, table, compress)
 
     # flow
     table = flow_table(model)
-    path = output_path(config, output.flow)
+    path = results_path(config, results.flow)
     write_arrow(path, table, compress)
 
     # discrete control
     table = discrete_control_table(model)
-    path = output_path(config, output.control)
+    path = results_path(config, results.control)
     write_arrow(path, table, compress)
 
-    @debug "Wrote output."
+    @debug "Wrote results."
     return model
 end
 
@@ -203,7 +203,7 @@
 end
 
 """
-Create the different callbacks that are used to store output
+Create the different callbacks that are used to store results
 and feed the simulation with new data. The different callbacks
 are combined to a CallbackSet that goes to the integrator.
 Returns the CallbackSet and the SavedValues for flow.
@@ -566,7 +566,7 @@
     run(config::Config)::Model
 
 Run a [`Model`](@ref), given a path to a TOML configuration file, or a Config object.
-Running a model includes initialization, solving to the end with `[`solve!`](@ref)` and writing output with [`BMI.finalize`](@ref).
+Running a model includes initialization, solving to the end with `[`solve!`](@ref)` and writing results with [`BMI.finalize`](@ref).
 """
 run(config_file::AbstractString)::Model = run(Config(config_file))
 

core/src/config.jl

@@ -15,7 +15,7 @@ using Logging: LogLevel, Debug, Info, Warn, Error
 using ..Ribasim: Ribasim, isnode, nodetype
 using OrdinaryDiffEq
 
-export Config, Solver, Output, Logging
+export Config, Solver, Results, Logging
 export algorithm, snake_case, zstd, lz4
 
 const schemas =
@@ -108,10 +108,10 @@ function Base.convert(::Type{Compression}, str::AbstractString)
 end
 
 # Separate struct, as basin clashes with nodetype
-@option struct Output <: TableOption
-    basin::String = "output/basin.arrow"
-    flow::String = "output/flow.arrow"
-    control::String = "output/control.arrow"
+@option struct Results <: TableOption
+    basin::String = "results/basin.arrow"
+    flow::String = "results/flow.arrow"
+    control::String = "results/control.arrow"
     outstate::Union{String, Nothing} = nothing
     compression::Compression = "zstd"
     compression_level::Int = 6
@@ -132,13 +132,13 @@ end
     # optional, when Config is created from a TOML file, this is its directory
     relative_dir::String = "."  # ignored(!)
     input_dir::String = "."
-    output_dir::String = "."
+    results_dir::String = "."
 
     # input, required
-    geopackage::String
+    database::String
 
-    # output, required
-    output::Output = Output()
+    # results, required
+    results::Results = Results()
 
     solver::Solver = Solver()
 

core/src/io.jl

@@ -47,7 +47,7 @@ datetime_since(t::Real, t0::DateTime)::DateTime = t0 + Millisecond(round(1000 *
 """
     load_data(db::DB, config::Config, nodetype::Symbol, kind::Symbol)::Union{Table, Query, Nothing}
 
-Load data from Arrow files if available, otherwise the GeoPackage.
+Load data from Arrow files if available, otherwise the database.
 Returns either an `Arrow.Table`, `SQLite.Query` or `nothing` if the data is not present.
 """
 function load_data(
@@ -78,7 +78,7 @@ end
 """
     load_structvector(db::DB, config::Config, ::Type{T})::StructVector{T}
 
-Load data from Arrow files if available, otherwise the GeoPackage.
+Load data from Arrow files if available, otherwise the database.
 Always returns a StructVector of the given struct type T, which is empty if the table is
 not found. This function validates the schema, and enforces the required sort order.
 """
@@ -95,7 +95,7 @@ function load_structvector(
 
     nt = Tables.columntable(table)
     if table isa Query && haskey(nt, :time)
-        # time has type timestamp and is stored as a String in the GeoPackage
+        # time has type timestamp and is stored as a String in the database
         # currently SQLite.jl does not automatically convert it to DateTime
         nt = merge(
             nt,
@@ -127,9 +127,9 @@ function input_path(config::Config, path::String)
     return normpath(config.relative_dir, config.input_dir, path)
 end
 
-"Construct a path relative to both the TOML directory and the optional `output_dir`"
-function output_path(config::Config, path::String)
-    return normpath(config.relative_dir, config.output_dir, path)
+"Construct a path relative to both the TOML directory and the optional `results_dir`"
+function results_path(config::Config, path::String)
+    return normpath(config.relative_dir, config.results_dir, path)
 end
 
 """

core/src/lib.jl

@@ -4,7 +4,7 @@
 
 Initialize a Model.
 
-The Model struct is an initialized model, combined with the [`Config`](@ref) used to create it and saved outputs.
+The Model struct is an initialized model, combined with the [`Config`](@ref) used to create it and saved results.
 The Basic Model Interface ([BMI](https://github.com/Deltares/BasicModelInterface.jl)) is implemented on the Model.
 A Model can be created from the path to a TOML configuration file, or a Config object.
 """

core/src/solve.jl

@@ -392,7 +392,7 @@ greater_than: The threshold value in the condition
 condition_value: The current value of each condition
 control_state: Dictionary: node ID => (control state, control state start)
 logic_mapping: Dictionary: (control node ID, truth state) => control state
-record: Namedtuple with discrete control information for output
+record: Namedtuple with discrete control information for results
 """
 struct DiscreteControl <: AbstractParameterNode
     node_id::Vector{Int}

core/src/utils.jl

@@ -466,10 +466,10 @@ function basin_bottoms(
     return bottom_a, bottom_b
 end
 
-"Get the compressor based on the Output"
-function get_compressor(output::Output)::TranscodingStreams.Codec
-    compressor = output.compression
-    level = output.compression_level
+"Get the compressor based on the Results section"
+function get_compressor(results::Results)::TranscodingStreams.Codec
+    compressor = results.compression
+    level = results.compression_level
     c = if compressor == lz4
         LZ4FrameCompressor(; compressionlevel = level)
     elseif compressor == zstd

core/src/validation.jl

@@ -372,7 +372,7 @@ end
 """
 Depending on if a table can be sorted, either sort it or assert that it is sorted.
 
-Tables loaded from GeoPackage into memory can be sorted.
+Tables loaded from the database into memory can be sorted.
 Tables loaded from Arrow files are memory mapped and can therefore not be sorted.
 """
 function sorted_table!(

core/test/allocation.jl

@@ -3,11 +3,11 @@ using SQLite
 using JuMP: value
 
 @testset "Allocation solve" begin
-    toml_path = normpath(@__DIR__, "../../generated_testmodels/subnetwork/subnetwork.toml")
+    toml_path = normpath(@__DIR__, "../../generated_testmodels/subnetwork/ribasim.toml")
     @test ispath(toml_path)
     cfg = Ribasim.Config(toml_path)
-    gpkg_path = Ribasim.input_path(cfg, cfg.geopackage)
-    db = SQLite.DB(gpkg_path)
+    db_path = Ribasim.input_path(cfg, cfg.database)
+    db = SQLite.DB(db_path)
 
     p = Ribasim.Parameters(db, cfg)
     close(db)

core/test/bmi.jl

@@ -2,7 +2,7 @@ using Test
 using Ribasim
 import BasicModelInterface as BMI
 
-toml_path = normpath(@__DIR__, "../../generated_testmodels/basic/basic.toml")
+toml_path = normpath(@__DIR__, "../../generated_testmodels/basic/ribasim.toml")
 
 @testset "adaptive timestepping" begin
     model = BMI.initialize(Ribasim.Model, toml_path)

core/test/cli.jl

@@ -15,7 +15,7 @@ end
 
 @testset "toml_path" begin
     model_path = normpath(@__DIR__, "../../generated_testmodels/basic/")
-    toml_path = normpath(model_path, "basic.toml")
+    toml_path = normpath(model_path, "ribasim.toml")
     @test ispath(toml_path)
     empty!(ARGS)
     push!(ARGS, toml_path)

core/test/config.jl

@@ -11,7 +11,7 @@ using CodecZstd: ZstdCompressor
     @test_throws UndefKeywordError Ribasim.Config(
         startime = now(),
         endtime = now(),
-        geopackage = "",
+        database = "",
         foo = "bar",
     )
 
@@ -21,22 +21,22 @@ using CodecZstd: ZstdCompressor
         @test config.update_timestep == 86400.0
         @test config.endtime > config.starttime
         @test config.solver == Ribasim.Solver(; saveat = 86400.0)
-        @test config.output.compression == Ribasim.zstd
-        @test config.output.compression_level == 6
+        @test config.results.compression == Ribasim.zstd
+        @test config.results.compression_level == 6
     end
 
-    @testset "output" begin
-        o = Ribasim.Output()
-        @test o isa Ribasim.Output
+    @testset "results" begin
+        o = Ribasim.Results()
+        @test o isa Ribasim.Results
         @test o.compression === Ribasim.zstd
         @test o.compression_level === 6
-        @test_throws ArgumentError Ribasim.Output(compression = "lz5")
+        @test_throws ArgumentError Ribasim.Results(compression = "lz5")
 
         @test Ribasim.get_compressor(
-            Ribasim.Output(; compression = "lz4", compression_level = 2),
+            Ribasim.Results(; compression = "lz4", compression_level = 2),
         ) isa LZ4FrameCompressor
         @test Ribasim.get_compressor(
-            Ribasim.Output(; compression = "zstd", compression_level = 3),
+            Ribasim.Results(; compression = "zstd", compression_level = 3),
         ) isa ZstdCompressor
     end