New model with agent_step! and model_step!

src/simulations/collect.jl

@@ -28,8 +28,8 @@ should_we_collect(s, model, when::Bool) = when
 should_we_collect(s, model, when) = when(model, s)
 
 """
-    run!(model, agent_step! [, model_step!], n::Integer; kwargs...) → agent_df, model_df
-    run!(model, agent_step!, model_step!, n::Function; kwargs...) → agent_df, model_df
+    run!(model, n::Integer; kwargs...) → agent_df, model_df
+    run!(model, f::Function; kwargs...) → agent_df, model_df
 
 Run the model (step it with the input arguments propagated into [`step!`](@ref)) and collect
 data specified by the keywords, explained one by one below. Return the data as
@@ -160,8 +160,8 @@ function run!(model, n;
 end
 
 """
-    offline_run!(model, agent_step! [, model_step!], n::Integer; kwargs...)
-    offline_run!(model, agent_step!, model_step!, n::Function; kwargs...)
+    offline_run!(model, n::Integer; kwargs...)
+    offline_run!(model, f::Function; kwargs...)
 
 Do the same as [`run`](@ref), but instead of collecting the whole run into an in-memory 
 dataframe, write the output to a file after collecting data `writing_interval` times and 

src/simulations/ensemblerun.jl

@@ -2,11 +2,12 @@ export ensemblerun!
 Vector_or_Tuple = Union{AbstractArray,Tuple}
 
 """
-    ensemblerun!(models::Vector, agent_step!, model_step!, n; kwargs...)
+    ensemblerun!(models::Vector, n; kwargs...)
 Perform an ensemble simulation of [`run!`](@ref) for all `model ∈ models`.
 Each `model` should be a (different) instance of an [`AgentBasedModel`](@ref) but probably
 initialized with a different random seed or different initial agent distribution.
-All models obey the same rules `agent_step!, model_step!` and are evolved for `n`.
+All models obey the same rules `agent_step!, model_step!` contained in the model
+and are evolved for `n`.
 
 Similarly to [`run!`](@ref) this function will collect data. It will furthermore
 add one additional column to the dataframe called `:ensemble`, which has an integer
@@ -44,7 +45,7 @@ function ensemblerun!(
 end
 
 """
-    ensemblerun!(generator, agent_step!, model_step!, n; kwargs...)
+    ensemblerun!(generator, n; kwargs...)
 Generate many `ABM`s and propagate them into `ensemblerun!(models, ...)` using
 the provided `generator` which is a one-argument function whose input is a seed.
 

src/simulations/paramscan.jl

@@ -41,10 +41,8 @@ The following keywords modify the `paramscan` function:
 - `showprogress::Bool = false` whether a progressbar will be displayed to indicate % runs finished.
 
 All other keywords are propagated into [`run!`](@ref).
-Furthermore, `agent_step!, model_step!, n` are also keywords here, that are given
-to [`run!`](@ref) as arguments. Naturally, stepping functions and the
-number of time steps (`agent_step!`, `model_step!`, and `n`) and at least one
-of `adata, mdata` are mandatory.
+Furthermore, `n` is also a keyword here, that is given to [`run!`](@ref) as argument. 
+Naturally, the number of time steps `n` and at least one of `adata, mdata` are mandatory.
 The `adata, mdata` lists shouldn't contain the parameters that are already in
 the `parameters` dictionary to avoid duplication.
 
@@ -74,7 +72,7 @@ parameters = Dict(
     :griddims => (20, 20),            # not Vector = not expanded
 )
 
-adf, _ = paramscan(parameters, initialize; adata, agent_step!, n = 3)
+adf, _ = paramscan(parameters, initialize; adata, n = 3)
 ```
 """
 function paramscan(
@@ -92,7 +90,8 @@ function paramscan(
         agent_step! = agent_step_field(model)
         model_step! = model_step_field(model)
     else
-        @warn "some warning"
+    @warn "Passing agent_step! and model_step! to paramscan is deprecated. 
+          These functions should be already presented inside the model instance."
     end
     if include_constants
         output_params = collect(keys(parameters))

src/simulations/step.jl

@@ -3,25 +3,21 @@ using CommonSolve: step!
 export step!, dummystep
 
 """
-    step!(model::ABM, agent_step!, n::Int = 1)
-    step!(model::ABM, agent_step!, model_step!, n::Int = 1, agents_first::Bool = true)
+    step!(model::ABM, n::Int = 1, agents_first::Bool = true)
 
 Update agents `n` steps according to the stepping function `agent_step!`.
 Agents will be activated as specified by the `abmscheduler(model)`.
-`model_step!` is triggered _after_ every scheduled agent has acted, unless
-the argument `agents_first` is `false` (which then first calls `model_step!` and then
-activates the agents).
+The `model_step!` function passed to the model is triggered _after_ every 
+scheduled agent has acted, unless the argument `agents_first` is `false` 
+(which then first calls `model_step!` and then activates the agents).
 
 `step!` ignores scheduled IDs that do not exist within the model, allowing
 you to safely remove agents dynamically.
 
-    step!(model, agent_step!, model_step!, n::Function, agents_first::Bool = true)
+    step!(model, f::Function, agents_first::Bool = true)
 
-In this version `n` is a function.
-Then `step!` runs the model until `n(model, s)` returns `true`, where `s` is the
+In this version, `step!` runs the model until `f(model, s)` returns `true`, where `s` is the
 current amount of steps taken, starting from 0.
-For this method of `step!`, `model_step!` must be provided always (use [`dummystep`](@ref)
-if you have no model stepping dynamics).
 
 See also [Advanced stepping](@ref) for stepping complex models where `agent_step!` might
 not be convenient.
@@ -41,17 +37,7 @@ function CommonSolve.step!(model::ABM, n::Int = 1, agents_first::Bool = true)
     end
 end
 
-"""
-    dummystep(model)
-
-Use instead of `model_step!` in [`step!`](@ref) if no function is useful to be defined.
-"""
 dummystep(model) = nothing
-"""
-    dummystep(agent, model)
-
-Use instead of `agent_step!` in [`step!`](@ref) if no function is useful to be defined.
-"""
 dummystep(agent, model) = nothing
 
 until(s, n::Int, model) = s < n

src/visualizations.jl

@@ -71,11 +71,9 @@ The stand-alone function `abmplot` also takes two optional `NamedTuple`s named `
 # Interactivity
 
 ## Evolution related
-* `agent_step!, model_step! = Agents.dummystep`: Stepping functions to pass to
-  [`ABMObservable`](@ref) which itself passes to `Agents.step!`.
 * `add_controls::Bool`: If `true`, `abmplot` switches to "interactive application" mode.
-  This is by default `true` if either `agent_step!` or `model_step!` keywords are provided.
-  These stepping functions are used to evolve the model interactively using `Agents.step!`.
+  This is by default `true` if the model contains either `agent_step!` or `model_step!`.
+  The model evolves interactively using `Agents.step!`.
   The application has the following interactive elements:
   1. "step": advances the simulation once for `spu` steps.
   1. "run": starts/stops the continuous evolution of the model.
@@ -111,13 +109,13 @@ export abmplot, abmplot!
 
 
 """
-    ABMObservable(model; agent_step!, model_step!, adata, mdata, when) → abmobs
+    ABMObservable(model; adata, mdata, when) → abmobs
 
 `abmobs` contains all information necessary to step an agent based model interactively.
 It is also returned by [`abmplot`](@ref).
 
 Calling `Agents.step!(abmobs, n)` will step the model for `n` using the provided
-`agent_step!, model_step!, n` as in [`Agents.step!`](@ref).
+`agent_step!, model_step!` cotained in the model as in [`Agents.step!`](@ref).
 
 The fields `abmobs.model, abmobs.adf, abmobs.mdf` are _observables_ that contain
 the [`AgentBasedModel`](@ref), and the agent and model dataframes with collected data.
@@ -174,7 +172,7 @@ function abmexploration end
 export abmexploration
 
 """
-    abmvideo(file, model, agent_step! [, model_step!]; kwargs...)
+    abmvideo(file, model; kwargs...)
 
 This function exports the animated time evolution of an agent based model into a video
 saved at given path `file`, by recording the behavior of the interactive version of