Forgot the notebook in the last commit.

Automaton G is implemented and runs OK. Not tested with Cosmos call.

The next step of development is the restruction of data collection for
trajectories.

From now on: Trajectory.values::Matrix{Float64}, it will be
Trajectory.values::Vector{Vector{Float64}}.

According to small performance tests I've made, it will increase the
performance of the package.

automata/automaton_F.jl

 
 function create_automaton_F(m::ContinuousTimeModel, x1::Float64, x2::Float64, t1::Float64, t2::Float64, str_obs::String)
+    @assert str_obs in m.g
     # Locations
     l_loc = ["l0", "l1", "l2", "l3"]
 
@@ -14,7 +15,7 @@ function create_automaton_F(m::ContinuousTimeModel, x1::Float64, x2::Float64, t1
 
     #S.n <=> S.l_var[A.map_var_automaton_idx["n"]] 
     #P <=> xn[map_var_model_idx[l_ctes[str_O]] with str_O = "P". On stock str_O dans l_ctes
-    
+    # P = get_value(A, x, str_obs) 
     ## Map of automaton variables
     map_var_automaton_idx = Dict{VariableAutomaton,Int}("n" => 1, "d" => 2)
 

automata/automaton_G.jl

+
+function create_automaton_G(m::ContinuousTimeModel, x1::Float64, x2::Float64, t1::Float64, t2::Float64, str_obs::String)
+    @assert str_obs in m.g
+    # Locations
+    l_loc = ["l0", "l1", "l2", "l3", "l4"]
+
+    # Invariant predicates
+    true_inv_predicate = (A::LHA, S:: StateLHA) -> return true 
+    Λ_F = Dict("l0" => true_inv_predicate, "l1" => true_inv_predicate,
+               "l2" => true_inv_predicate, "l3" => true_inv_predicate, 
+               "l4" => true_inv_predicate)
+    
+    ## Init and final loc
+    l_loc_init = ["l0"]
+    l_loc_final = ["l2"]
+
+    ## Map of automaton variables
+    map_var_automaton_idx = Dict{VariableAutomaton,Int}("t'" => 1, "in" => 2,
+                                                         "n" => 3,  "d" => 4)
+
+    ## Flow of variables
+    l_flow = Dict{VariableAutomaton,Vector{Float64}}("l0" => [0.0,0.0,0.0,0.0], 
+                                                     "l1" => [0.0,0.0,0.0,0.0], 
+                                                     "l2" => [0.0,0.0,0.0,0.0], 
+                                                     "l3" => [0.0,0.0,0.0,0.0], 
+                                                     "l4" => [1.0,0.0,0.0,0.0])
+
+    ## Edges
+    map_edges = Dict{Tuple{Location,Location}, Vector{Edge}}()
+
+    isin(val::Float64) = convert(Bool, val)
+
+    # l0 loc
+    tuple = ("l0", "l1")
+    cc_aut_G_l0l1_1(A::LHA, S::StateLHA) = true
+    us_aut_G_l0l1_1!(A::LHA, S::StateLHA, x::SubArray{Int,1}) = (S.loc = "l1"; S["d"] = 0; S["n"] = get_value(A, x, str_obs); S["in"] = true)
+    edge1 = Edge([nothing], cc_aut_G_l0l1_1, us_aut_G_l0l1_1!)
+    map_edges[tuple] = [edge1]
+
+    # l1 loc
+    tuple = ("l1", "l3")
+    cc_aut_G_l1l3_1(A::LHA, S::StateLHA) = 
+        (S.time < A.l_ctes["t1"] && (S["n"] < A.l_ctes["x1"] || S["n"] > A.l_ctes["x2"]))
+    us_aut_G_l1l3_1!(A::LHA, S::StateLHA, x::SubArray{Int,1}) = 
+        (S.loc = "l3"; S["d"] = min(abs(A.l_ctes["x1"] - S["n"]), abs(A.l_ctes["x2"] - S["n"])); S["in"] = false)
+    edge1 = Edge([nothing], cc_aut_G_l1l3_1, us_aut_G_l1l3_1!)
+    cc_aut_G_l1l3_2(A::LHA, S::StateLHA) = 
+        (S.time < A.l_ctes["t1"] && (A.l_ctes["x1"] <= S["n"] <= A.l_ctes["x2"]))
+    us_aut_G_l1l3_2!(A::LHA, S::StateLHA, x::SubArray{Int,1}) = 
+        (S.loc = "l3"; S["d"] = 0; S["in"] = false)
+    edge2 = Edge([nothing], cc_aut_G_l1l3_2, us_aut_G_l1l3_2!)
+    cc_aut_G_l1l3_3(A::LHA, S::StateLHA) = 
+        (!isin(S["in"]) && (A.l_ctes["t1"] <= S.time <= A.l_ctes["t2"]) && (A.l_ctes["x1"] <= S["n"] <= A.l_ctes["x2"]))
+    us_aut_G_l1l3_3!(A::LHA, S::StateLHA, x::SubArray{Int,1}) = (S.loc = "l3"; S["d"] = S["d"] * (S.time - A.l_ctes["t1"]); S["t'"] = 0.0)
+    edge3 = Edge([nothing], cc_aut_G_l1l3_3, us_aut_G_l1l3_3!)
+    cc_aut_G_l1l3_4(A::LHA, S::StateLHA) = 
+        (isin(S["in"]) && (A.l_ctes["t1"] <= S.time <= A.l_ctes["t2"]) && (A.l_ctes["x1"] <= S["n"] <= A.l_ctes["x2"]))
+    us_aut_G_l1l3_4!(A::LHA, S::StateLHA, x::SubArray{Int,1}) = (S.loc = "l3"; S["t'"] = 0.0)
+    edge4 = Edge([nothing], cc_aut_G_l1l3_4, us_aut_G_l1l3_4!)
+    map_edges[tuple] = [edge1, edge2, edge3, edge4]
+
+    tuple = ("l1", "l4")
+    cc_aut_G_l1l4_1(A::LHA, S::StateLHA) = 
+        (!isin(S["in"]) && (A.l_ctes["t1"] <= S.time <= A.l_ctes["t2"]) && (S["n"] < A.l_ctes["x1"] || S["n"] > A.l_ctes["x2"]))
+    us_aut_G_l1l4_1!(A::LHA, S::StateLHA, x::SubArray{Int,1}) = (S.loc = "l4"; S["d"] += S["d"] * (S.time - A.l_ctes["t1"]))
+    edge1 = Edge([nothing], cc_aut_G_l1l4_1, us_aut_G_l1l4_1!)
+    cc_aut_G_l1l4_2(A::LHA, S::StateLHA) = 
+        (isin(S["in"]) && (A.l_ctes["t1"] <= S.time <= A.l_ctes["t2"]) && (S["n"] < A.l_ctes["x1"] || S["n"] > A.l_ctes["x2"]))
+    us_aut_G_l1l4_2!(A::LHA, S::StateLHA, x::SubArray{Int,1}) = (S.loc = "l4")
+    edge2 = Edge([nothing], cc_aut_G_l1l4_2, us_aut_G_l1l4_2!)
+    map_edges[tuple] = [edge1, edge2]
+
+    tuple = ("l1", "l2")
+    cc_aut_G_l1l2_1(A::LHA, S::StateLHA) = (isin(S["in"]) && S.time >= A.l_ctes["t2"])
+    us_aut_G_l1l2_1!(A::LHA, S::StateLHA, x::SubArray{Int,1}) = (S.loc = "l2")
+    edge1 = Edge([nothing], cc_aut_G_l1l2_1, us_aut_G_l1l2_1!)
+    cc_aut_G_l1l2_2(A::LHA, S::StateLHA) = (!isin(S["in"]) && S.time >= A.l_ctes["t2"])
+    us_aut_G_l1l2_2!(A::LHA, S::StateLHA, x::SubArray{Int,1}) = (S.loc = "l2"; S["d"] = S["d"] * (A.l_ctes["t2"] - A.l_ctes["t1"]))
+    edge2 = Edge([nothing], cc_aut_G_l1l2_2, us_aut_G_l1l2_2!)
+    map_edges[tuple] = [edge1, edge2]
+
+    # l3 loc
+    tuple = ("l3", "l1")
+    cc_aut_G_l3l1_1(A::LHA, S::StateLHA) = true
+    us_aut_G_l3l1_1!(A::LHA, S::StateLHA, x::SubArray{Int,1}) = (S.loc = "l1"; S["n"] = get_value(A, x, str_obs))
+    edge1 = Edge(["ALL"], cc_aut_G_l3l1_1, us_aut_G_l3l1_1!)
+    map_edges[tuple] = [edge1]
+
+    tuple = ("l3", "l2")
+    cc_aut_G_l3l2_1(A::LHA, S::StateLHA) = (isin(S["in"]) && S.time >= A.l_ctes["t2"])
+    us_aut_G_l3l2_1!(A::LHA, S::StateLHA, x::SubArray{Int,1}) = (S.loc = "l2")
+    edge1 = Edge([nothing], cc_aut_G_l3l2_1, us_aut_G_l3l2_1!)
+    cc_aut_G_l3l2_2(A::LHA, S::StateLHA) = (!isin(S["in"]) && S.time >= A.l_ctes["t2"])
+    us_aut_G_l3l2_2!(A::LHA, S::StateLHA, x::SubArray{Int,1}) = (S.loc = "l2"; S["d"] = S["d"] * (A.l_ctes["t2"] - A.l_ctes["t1"]))
+    edge2 = Edge([nothing], cc_aut_G_l3l2_2, us_aut_G_l3l2_2!)
+    map_edges[tuple] = [edge1, edge2]
+
+    # l4 loc
+    tuple = ("l4", "l1")
+    cc_aut_G_l4l1_1(A::LHA, S::StateLHA) = true
+    us_aut_G_l4l1_1!(A::LHA, S::StateLHA, x::SubArray{Int,1}) = 
+        (S.loc = "l1"; S["d"] += S["t'"] * min(abs(A.l_ctes["x1"] - S["n"]), abs(A.l_ctes["x2"] - S["n"])); 
+         S["t'"] = 0.0; S["n"] = get_value(A, x, str_obs); S["in"] = true)
+    edge1 = Edge(["ALL"], cc_aut_G_l4l1_1, us_aut_G_l4l1_1!)
+    map_edges[tuple] = [edge1]
+
+    tuple = ("l4", "l2")
+    cc_aut_G_l4l2_1(A::LHA, S::StateLHA) = (S.time >= A.l_ctes["t2"])
+    us_aut_G_l4l2_1!(A::LHA, S::StateLHA, x::SubArray{Int,1}) = 
+        (S.loc = "l2"; S["d"] +=  S["t'"] * min(abs(A.l_ctes["x1"] - S["n"]), abs(A.l_ctes["x2"] - S["n"])); S["t'"] = 0.0)
+    edge1 = Edge([nothing], cc_aut_G_l4l2_1, us_aut_G_l4l2_1!)
+    map_edges[tuple] = [edge1]
+
+    ## Constants
+    l_ctes = Dict{String,Float64}("x1" => x1, "x2" => x2, "t1" => t1, "t2" => t2)
+
+    A = LHA(m.l_transitions, l_loc, Λ_F, l_loc_init, l_loc_final, 
+            map_var_automaton_idx, l_flow, map_edges, l_ctes, m.map_var_idx)
+    return A
+end
+
+export create_automaton_G
+

core/lha.jl

@@ -9,6 +9,8 @@ copy(S::StateLHA) = StateLHA(S.A, S.loc, S.l_var, S.time)
 getindex(S::StateLHA, var::VariableAutomaton) = (S.l_var)[(S.A).map_var_automaton_idx[var]]
 setindex!(S::StateLHA, val::Float64, var::VariableAutomaton) = (S.l_var)[(S.A).map_var_automaton_idx[var]] = val
 setindex!(S::StateLHA, val::Int, var::VariableAutomaton) = (S.l_var)[(S.A).map_var_automaton_idx[var]] = convert(Float64, val)
+setindex!(S::StateLHA, val::Bool, var::VariableAutomaton) = (S.l_var)[(S.A).map_var_automaton_idx[var]] = convert(Float64, val)
+
 function Base.show(io::IO, S::StateLHA)
     print(io, "State of LHA\n")
     print(io, "- location: $(S.loc)\n")

examples/notebooks/1_Simulation.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 1. About simulation of models and trajectories\n",
+    "\n",
+    "The goal of this notebook is to present the basics of the simulation in our package.\n",
+    "\n",
+    "Let's get familiar with the package. First, we shoud load it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "using MarkovProcesses"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Models\n",
+    "\n",
+    "In this package, we are focused on Continuous-Time Markov Chains models that can be described by Chemical Reaction Networks.\n",
+    "\n",
+    "Let's simulate our first model. We consider the famous SIR epidemiology model described by two reactions:\n",
+    "\n",
+    "$$\n",
+    "Infection: S + I \\xrightarrow{k_i} 2I \\\\\n",
+    "Recovery: I \\xrightarrow{k_r} R\n",
+    "$$\n",
+    "\n",
+    "In the MarkovProcesses package, models are objects that can be instantiatied and their types all derived from the abstract type `Model`. Let's load the SIR model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "load_model(\"SIR\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This function searchs a model file called SIR.jl in the models/ directory (at the root of the package). This files creates the necessary resources to create a `ContinuousTimeModel` and store it in a variable called SIR."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "ContinuousTimeModel(3, 2, Dict(\"S\" => 1,\"I\" => 2,\"R\" => 3), Dict(\"I\" => 1), Dict(\"kr\" => 2,\"ki\" => 1), Union{Nothing, String}[\"R1\", \"R2\"], [0.0012, 0.05], [95, 5, 0], 0.0, MarkovProcesses.SIR_f!, [\"I\"], [2], MarkovProcesses.isabsorbing_SIR, Inf, 10)"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "SIR"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This variable contains a parameter vector and an initial point. It is ready to use."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SIR.p = [0.0012, 0.05]\n",
+      "SIR.x0 = [95, 5, 0]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "3-element Array{Int64,1}:\n",
+       " 95\n",
+       "  5\n",
+       "  0"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "@show SIR.p\n",
+    "@show SIR.x0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can change the parameters with the function `set_param!`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SIR.p = [0.015, 0.05]\n",
+      "SIR.p = [0.02, 0.07]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "2-element Array{Float64,1}:\n",
+       " 0.02\n",
+       " 0.07"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "set_param!(SIR, \"ki\", 0.015)\n",
+    "@show SIR.p\n",
+    "set_param!(SIR, [0.02, 0.07])\n",
+    "@show SIR.p"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Trajectories\n",
+    "\n",
+    "The simulation of the model is done by the function `simulate`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Trajectory(ContinuousTimeModel(3, 2, Dict(\"S\" => 1,\"I\" => 2,\"R\" => 3), Dict(\"I\" => 1), Dict(\"kr\" => 2,\"ki\" => 1), Union{Nothing, String}[\"R1\", \"R2\"], [0.02, 0.07], [95, 5, 0], 0.0, MarkovProcesses.SIR_f!, [\"I\"], [2], MarkovProcesses.isabsorbing_SIR, Inf, 10), [5; 6; … ; 1; 0], [0.0, 0.0002090421844976379, 0.026738149867351305, 0.1546747797181483, 0.1670337962687422, 0.1864041143902683, 0.22499455696452758, 0.2609816573473689, 0.26211457357364876, 0.34981665245812765  …  28.156954777152635, 29.8789510639123, 31.349526365163364, 31.418132567003155, 43.3115664747499, 49.84826982651157, 50.582546017297425, 51.33856085518521, 55.25637949865968, 63.081159577787396], Union{Nothing, String}[nothing, \"R1\", \"R1\", \"R1\", \"R1\", \"R1\", \"R1\", \"R1\", \"R1\", \"R1\"  …  \"R2\", \"R2\", \"R2\", \"R2\", \"R2\", \"R2\", \"R2\", \"R2\", \"R2\", \"R2\"])"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "σ = simulate(SIR)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`simulate` returns a path which type is derived from `AbstractTrajectory`. It can be either an object of type `Trajectory` for models `::ContinuousTimeModel` or `SynchronizedTrajectory` for models that includes an automaton (but this is the subject of another notebook). It is easy to access the values of a trajectory:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "σ[3] = [7]\n",
+      "length_states(σ) = 196\n",
+      "σ[\"I\", 4] = 8\n",
+      "get_state_from_time(σ, 2.3) = [76]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "1-element view(::Array{Int64,2}, 84, :) with eltype Int64:\n",
+       " 76"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "@show σ[3] # the third state of the trajectory\n",
+    "@show length_states(σ) # number of states\n",
+    "@show σ[\"I\", 4] # Fourth value of the variable I\n",
+    "@show get_state_from_time(σ, 2.3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The SIR object includes an observation model symbolized by the vector `SIR.g`. Even if the variables of the model are [\"S\", \"I\", \"R\"], only \"I\" will be observed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SIR.map_var_idx = Dict(\"S\" => 1,\"I\" => 2,\"R\" => 3)\n",
+      "SIR.g = [\"I\"]\n",
+      "(size(σ.values), length(σ[\"I\"])) = ((196, 1), 196)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "((196, 1), 196)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "@show SIR.map_var_idx\n",
+    "@show SIR.g\n",
+    "@show size(σ.values), length(σ[\"I\"]) # Only one column which corresponds to the I variable"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The SIR model is by default unbounded, i.e. each trajectory is simulated until it reaches an absorbing state."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "isbounded(SIR) = false\n",
+      "isbounded(σ) = false\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "false"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "@show isbounded(SIR)\n",
+    "@show isbounded(σ)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For example, computations of Lp integral distances needs bounded trajectories."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "┌ Warning: Lp distance computed on unbounded trajectories. Result should be wrong\n",
+      "└ @ MarkovProcesses /home/moud/MarkovProcesses/markovprocesses.jl/core/trajectory.jl:61\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "20.942860320770663"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dist_lp(simulate(SIR),simulate(SIR); p=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "But this feature can be changed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "120.0"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "set_time_bound!(SIR, 120.0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dist_lp(simulate(SIR), simulate(SIR)) = 270.22871331339087\n",
+      "isbounded(SIR) = true\n",
+      "isbounded(simulate(SIR)) = true\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "true"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "@show dist_lp(simulate(SIR),simulate(SIR))\n",
+    "@show isbounded(SIR)\n",
+    "@show isbounded(simulate(SIR))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Buffer size\n",
+    "\n",
+    "A useful feature is that we can change the preallocation of the memory size during the simulation in order to gain computational performance."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ER.buffer_size = 10\n",
+      "  0.070949 seconds (130.66 k allocations: 7.141 MiB)\n",
+      "elapsed time (ns): 70948721\n",
+      "bytes allocated:   7488324\n",
+      "pool allocs:       130585\n",
+      "non-pool GC allocs:73\n",
+      "length_states(σ) = 407\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "407"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "load_model(\"ER\")\n",
+    "@show ER.buffer_size\n",
+    "@timev σ = simulate(ER)\n",
+    "@show length_states(σ)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "By default, the buffer size is 10. It means that a matrix of size 10 is allocated anf filled. When it is full, another matrix of size 10 is allocated. But if you know that your simulations will have a certain number of states, you can change the buffer size. It can make a big difference in terms of performance."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  0.000232 seconds (3.02 k allocations: 212.000 KiB)\n",
+      "elapsed time (ns): 231641\n",
+      "bytes allocated:   217088\n",
+      "pool allocs:       3004\n",
+      "non-pool GC allocs:11\n",
+      "length_states(σ2) = 425\n"
+     ]
+    },
+    {
+     "data": {