Advanced Trajectory Usage

Iñaki Ucar, Bart Smeets

2016-12-27

library(simmer)
library(ggplot2)

Available set of activities

When a generator creates an arrival, it couples the arrival to a given trajectory. A trajectory is defined as an interlinkage of activities which together form the arrivals’ lifetime in the system. Once an arrival is coupled to the trajectory, it will (in general) start processing the activities in the trajectory in the specified order and, eventually, leave the system. Consider the following:

patient_traj <- trajectory(name = "patient_trajectory") %>%
  seize(resource = "doctor", amount = 1) %>%
  timeout(task = 3) %>%
  release(resource = "doctor", amount = 1)

Here we create a trajectory where a patient seizes a doctor for 3 minutes and then releases him again.

This is a very straightforward example, however, most of the trajectory-related functions allow for more advanced usage. The different functions are introduced below.

log_()

The log_(., message) method just prints a given message preceded by the simulation time and the name of the arrival, for debugging purposes:

set.seed(1234)

t <- trajectory() %>%
  log_("hello world!")

simmer() %>%
  add_generator("dummy", t, function() rexp(1, 1)) %>%
  run(5) %>% invisible
#> 2.50176: dummy0: hello world!
#> 2.74852: dummy1: hello world!
#> 2.7551: dummy2: hello world!
#> 4.49785: dummy3: hello world!
#> 4.88503: dummy4: hello world!
#> 4.97498: dummy5: hello world!

set_attribute()

The set_attribute(., key, value, global) method sets the value of an arrival’s attribute key. Be aware that value can only be numeric.

patient_traj <- trajectory(name = "patient_trajectory") %>%
  set_attribute(key = "my_key", value = 123) %>%
  timeout(5) %>%
  set_attribute(key = "my_key", value = 456)

env <- simmer() %>%
  add_generator("patient", patient_traj, at(0), mon = 2) %>%
  run()

get_mon_attributes(env)
#>   time     name    key value replication
#> 1    0 patient0 my_key   123           1
#> 2    5 patient0 my_key   456           1

Above, a trajectory which only sets attribute my_key to value 123 is launched once by an arrival generated at time 0 (check ?at). The mon=2 of add_generator() makes the simulation environment monitor the attributes’ evolution (disabled by default). Using get_mon_attributes(), we can look at the evolution of the value of my_key.

If you want to set an attribute that depends on another attribute, or on the current value of the attribute to be set, this is also possible. In fact, if, instead of a numeric value, you supply a function with one parameter, the current set of attributes is passed as a list to that function. Whatever (numeric value) your function returns is set as the value of the specified attribute key. If the supplied function has no parameters, it is evaluated in the same way, but the attribute list is not accesible in the function body. This means that, if you supply a function to the value parameter, it has to be in the form of either function(attrs){} (first case) or function(){} (second case). Below, you can see an example of this in practice.

patient_traj <- trajectory(name = "patient_trajectory") %>%
  set_attribute("my_key", 123) %>%
  timeout(5) %>%
  set_attribute("my_key", function(attrs) attrs[["my_key"]] + 1) %>%
  timeout(5) %>%
  set_attribute("dependent_key", function(attrs) ifelse(attrs[["my_key"]]<=123, 1, 0)) %>%
  timeout(5) %>%
  set_attribute("independent_key", function() runif(1))

env<- simmer() %>%
  add_generator("patient", patient_traj, at(0), mon = 2) %>%
  run()

get_mon_attributes(env)
#>   time     name             key       value replication
#> 1    0 patient0          my_key 123.0000000           1
#> 2    5 patient0          my_key 124.0000000           1
#> 3   10 patient0   dependent_key   0.0000000           1
#> 4   15 patient0 independent_key   0.9234335           1

In general, whenever an activity accepts a function as a parameter, the rule above applies, and you can obtain the current set of attributes as the first argument of that function.

Attributes are per arrival by default (global=FALSE), meaning that each arrival has its own set of attributes, not visible by anyone else:

writer <- trajectory() %>%
  set_attribute(key = "my_key", value = 123)

reader <- trajectory() %>%
  log_(function(attr) paste0(attr["my_key"]))

env <- simmer() %>%
  add_generator("writer", writer, at(0), mon = 2) %>%
  add_generator("reader", reader, at(1), mon = 2) %>%
  run()
#> 1: reader0: NA

get_mon_attributes(env)
#>   time    name    key value replication
#> 1    0 writer0 my_key   123           1

Thus, the reader in the example above returns NA, missing. However, attributes can also be global with global=TRUE. To retrieve the global set of attributes in any activity that accepts a function as a parameter, you need to specify a second argument:

writer <- trajectory() %>%
  set_attribute(key = "my_key", value = 123, global = TRUE)

reader <- trajectory() %>%
  log_(function(attr, glb) paste0(attr["my_key"], ", ", glb["my_key"]))

env <- simmer() %>%
  add_generator("writer", writer, at(0), mon = 2) %>%
  add_generator("reader", reader, at(1), mon = 2) %>%
  run()
#> 1: reader0: NA, 123

get_mon_attributes(env)
#>   time name    key value replication
#> 1    0      my_key   123           1

As shown above, global attributes are reported in get_mon_attributes() as unnamed key/value pairs.

timeout()

At its simplest, the timeout(., task) method delays the arrival’s advance through the trajectory for a specified amount of time. Consider the following minimal example where we simply supply a static value to the timeout’s task parameter.

patient_traj <- trajectory(name = "patient_trajectory") %>%
  timeout(task = 3)

env <- simmer() %>%
  add_generator("patient", patient_traj, at(0)) %>%
  run()

get_mon_arrivals(env)
#>       name start_time end_time activity_time finished replication
#> 1 patient0          0        3             3     TRUE           1

Often, however, you want a timeout to be dependent on a distribution or, for example, an earlier set attribute. This is achieved by passing a function in to form of either function(){} or function(attrs){} to the task parameter, as we explained before. In the following example, this functionality is demonstrated:

patient_traj <- trajectory(name = "patient_trajectory") %>%
  set_attribute("health", function() sample(20:80, 1)) %>%
  # distribution-based timeout
  timeout(function() rexp(1, 10)) %>%
  # attribute-dependent timeout
  timeout(function(attrs) (100 - attrs[["health"]]) * 2)

env <- simmer() %>%
  add_generator("patient", patient_traj, at(0), mon = 2) %>%
  run()

get_mon_arrivals(env)
#>       name start_time end_time activity_time finished replication
#> 1 patient0          0 126.0675      126.0675     TRUE           1
get_mon_attributes(env)
#>   time     name    key value replication
#> 1    0 patient0 health    37           1

Be aware that if you want the timeout()’s task parameter to be evaluated dynamically, you should supply a callable function. For example in timeout(function() rexp(1, 10)), rexp(1, 10) will be evaluated every time the timeout activity is executed. However, if you supply it in the form of timeout(rexp(1, 10)), it will only be evaluated at the initalization and will remain static after that.

Of course, this task, supplied as a function, may be as complex as you need and, for instance, it may check a resource’s status, interact with other entities in your simulation model… The same applies to all the activities when they accept a function as a parameter.

seize(), release()

The seize(., resource, amount) method seizes a specified amount of the resource named resource. Conversely, the release(., resource, amount) method releases a specified amount of the resource named resource. Be aware that, in order to use these functions in relation to a specific resource, you have to create it in your definition of the simulation environment (check ?add_resource).

Consider the following example:

patient_traj <- trajectory(name = "patient_trajectory") %>%
  seize(resource = "doctor", amount = 1) %>%
  timeout(3) %>%
  release(resource = "doctor", amount = 1)

env <- simmer() %>%
  add_resource("doctor", capacity=1, mon = 1) %>%
  add_generator("patient", patient_traj, at(0)) %>%
  run()

get_mon_resources(env)
#>   resource time server queue capacity queue_size system limit replication
#> 1   doctor    0      1     0        1        Inf      1   Inf           1
#> 2   doctor    3      0     0        1        Inf      0   Inf           1

Here the mon=1 argument (=default) of add_resource() makes the simulation environment monitor the resource usage. Using the get_mon_resources(env) method you can get access to the log of the usage evolution of resources.

There are situations where you want to let the amount of resources seized/released be dependent on a specific function or on a previously set attribute. To achieve this, you can pass a function in the form of either function(){} or function(attrs){} to the amount parameter instead of a numeric value. If going for the latter, the current state of the arrival’s attributes will be passed to attrs as a list which you can inspect. This allows for the following:

patient_traj <- trajectory(name = "patient_trajectory") %>%
  set_attribute("health", function() sample(20:80, 1)) %>%
  set_attribute("docs_to_seize", function(attrs) ifelse(attrs[["health"]]<50, 1, 2)) %>%
  seize("doctor", function(attrs) attrs[["docs_to_seize"]]) %>%
  timeout(3) %>%
  release("doctor", function(attrs) attrs[["docs_to_seize"]])

env <- simmer() %>%
  add_resource("doctor", capacity = 2, mon = 1) %>%
  add_generator("patient", patient_traj, at(0), mon = 2) %>%
  run()

get_mon_resources(env)
#>   resource time server queue capacity queue_size system limit replication
#> 1   doctor    0      1     0        2        Inf      1   Inf           1
#> 2   doctor    3      0     0        2        Inf      0   Inf           1
get_mon_attributes(env)
#>   time     name           key value replication
#> 1    0 patient0        health    37           1
#> 2    0 patient0 docs_to_seize     1           1

By default, an unsuccessful seize() results in the rejection of the arrival. In the following example, the second patient tries to seize the only doctor while the first patient is being attended. There is no waiting room available, therefore it is rejected:

patient_traj <- trajectory(name = "patient_trajectory") %>%
  log_("arriving...") %>%
  seize("doctor", 1) %>%
  # the second patient won't reach this point
  log_("doctor seized") %>%
  timeout(5) %>%
  release("doctor", 1)

env <- simmer() %>%
  add_resource("doctor", capacity = 1, queue_size = 0) %>%
  add_generator("patient", patient_traj, at(0, 1)) %>%
  run()
#> 0: patient0: arriving...
#> 0: patient0: doctor seized
#> 1: patient1: arriving...

get_mon_arrivals(env)
#>       name start_time end_time activity_time finished replication
#> 1 patient1          1        1             0    FALSE           1
#> 2 patient0          0        5             5     TRUE           1
get_mon_resources(env)
#>   resource time server queue capacity queue_size system limit replication
#> 1   doctor    0      1     0        1          0      1     1           1
#> 2   doctor    5      0     0        1          0      0     1           1

Sometimes, you don’t want to reject an unsuccessful seize(), but to follow another path. Let’s modify the example above to enable the second patient to visit a nurse instead:

patient_traj <- trajectory(name = "patient_trajectory") %>%
  log_("arriving...") %>%
  seize("doctor", 1, continue = FALSE,
        reject = trajectory("rejected patient") %>%
          log_("rejected!") %>%
          seize("nurse", 1) %>%
          log_("nurse seized") %>%
          timeout(2) %>%
          release("nurse", 1)) %>%
  # the second patient won't reach this point
  log_("doctor seized") %>%
  timeout(5) %>%
  release("doctor", 1)

env <- simmer() %>%
  add_resource("doctor", capacity = 1, queue_size = 0) %>%
  add_resource("nurse", capacity = 10, queue_size = 0) %>%
  add_generator("patient", patient_traj, at(0, 1)) %>%
  run()
#> 0: patient0: arriving...
#> 0: patient0: doctor seized
#> 1: patient1: arriving...
#> 1: patient1: rejected!
#> 1: patient1: nurse seized

get_mon_arrivals(env)
#>       name start_time end_time activity_time finished replication
#> 1 patient1          1        3             2     TRUE           1
#> 2 patient0          0        5             5     TRUE           1
get_mon_resources(env)
#>   resource time server queue capacity queue_size system limit replication
#> 1   doctor    0      1     0        1          0      1     1           1
#> 2    nurse    1      1     0       10          0      1    10           1
#> 3    nurse    3      0     0       10          0      0    10           1
#> 4   doctor    5      0     0        1          0      0     1           1

The flag continue indicates whether the reject sub-trajectory should be connected to the main trajectory or not. In this case, with continue=FALSE, the rejected arrival seizes the nurse and its lifetime ends after releasing him/her. Otherwise, it would keep executing activities in the main trajectory.

Note that the second patient may also keep trying if he/she must see the doctor:

patient_traj <- trajectory(name = "patient_trajectory") %>%
  log_("arriving...") %>%
  seize("doctor", 1, continue = FALSE,
        reject = trajectory("rejected patient") %>%
          log_("rejected!") %>%
          # go for a walk and try again
          timeout(2) %>%
          log_("retrying...") %>%
          rollback(amount = 4, times = Inf)) %>%
  # the second patient will reach this point after a couple of walks
  log_("doctor seized") %>%
  timeout(5) %>%
  release("doctor", 1) %>%
  log_("leaving")

env <- simmer() %>%
  add_resource("doctor", capacity = 1, queue_size = 0) %>%
  add_generator("patient", patient_traj, at(0, 1)) %>%
  run()
#> 0: patient0: arriving...
#> 0: patient0: doctor seized
#> 1: patient1: arriving...
#> 1: patient1: rejected!
#> 3: patient1: retrying...
#> 3: patient1: rejected!
#> 5: patient1: retrying...
#> 5: patient0: leaving
#> 5: patient1: doctor seized
#> 10: patient1: leaving

get_mon_arrivals(env)
#>       name start_time end_time activity_time finished replication
#> 1 patient0          0        5             5     TRUE           1
#> 2 patient1          1       10             9     TRUE           1
get_mon_resources(env)
#>   resource time server queue capacity queue_size system limit replication
#> 1   doctor    0      1     0        1          0      1     1           1
#> 2   doctor    5      0     0        1          0      0     1           1
#> 3   doctor    5      1     0        1          0      1     1           1
#> 4   doctor   10      0     0        1          0      0     1           1

There is another optional sub-trajectory called post.seize and, as its name suggests, it is executed after a successful seize(). Thus, you can do the following:

patient_traj <- trajectory(name = "patient_trajectory") %>%
  log_("arriving...") %>%
  seize("doctor", 1, continue = c(TRUE, TRUE),
        post.seize = trajectory("admitted patient") %>%
          log_("admitted") %>%
          timeout(5) %>%
          release("doctor", 1),
        reject = trajectory("rejected patient") %>%
          log_("rejected!") %>%
          seize("nurse", 1) %>%
          timeout(2) %>%
          release("nurse", 1)) %>%
  # both patients will reach this point, as continue = c(TRUE, TRUE)
  timeout(10) %>%
  log_("leaving...")

env <- simmer() %>%
  add_resource("doctor", capacity = 1, queue_size = 0) %>%
  add_resource("nurse", capacity = 10, queue_size = 0) %>%
  add_generator("patient", patient_traj, at(0, 1)) %>%
  run()
#> 0: patient0: arriving...
#> 0: patient0: admitted
#> 1: patient1: arriving...
#> 1: patient1: rejected!
#> 13: patient1: leaving...
#> 15: patient0: leaving...

get_mon_arrivals(env)
#>       name start_time end_time activity_time finished replication
#> 1 patient1          1       13            12     TRUE           1
#> 2 patient0          0       15            15     TRUE           1
get_mon_resources(env)
#>   resource time server queue capacity queue_size system limit replication
#> 1   doctor    0      1     0        1          0      1     1           1
#> 2    nurse    1      1     0       10          0      1    10           1
#> 3    nurse    3      0     0       10          0      0    10           1
#> 4   doctor    5      0     0        1          0      0     1           1

set_capacity(), set_queue_size()

The set_capacity(., resource, value) method modifies the capacity of the specified resource by name, and the set_queue_size(., resource, value) method modifies its queue size. Be aware that, in order to use these functions in relation to a specific resource, you have to create it in your definition of the simulation environment (check ?add_resource). You can supply the value parameter either as a numeric value or as a function, in the form of either function(){} or function(attrs){}, which must return a numeric value.

These activities are interesting to introduce dynamical changes in the resources. For instance, consider the following example in which two trajectories fight for the capacity of their resource:

set.seed(12345)
env <- simmer()

increment <- function(res) {
  function() get_capacity(env, res) + 1
}
decrement <- function(res) {
  function() {
    n <- get_capacity(env, res) - 1
    if (n < 0) 0
    else n
  }
}

t1 <- trajectory() %>%
  seize("res1", 1) %>%
  set_capacity(resource = "res1", value = increment("res1")) %>%
  set_capacity(resource = "res2", value = decrement("res2")) %>%
  timeout(function() rexp(1, 1)) %>%
  release("res1", 1)

t2 <- trajectory() %>%
  seize("res2", 1) %>%
  set_capacity(resource = "res2", value = increment("res2")) %>%
  set_capacity(resource = "res1", value = decrement("res1")) %>%
  timeout(function() rexp(1, 1)) %>%
  release("res2", 1)

env <- env %>%
  add_resource("res1", capacity = 20, queue_size = Inf) %>%
  add_resource("res2", capacity = 20, queue_size = Inf) %>%
  add_generator("t1_", t1, function() rexp(1, 1)) %>%
  add_generator("t2_", t2, function() rexp(1, 1)) %>%
  run(100)

plot_resource_usage(env, "res1", steps = TRUE)
#> Warning: 'plot_resource_usage' is deprecated.
#> Use 'simmer.plot::plot' instead.
#> See help("Deprecated")

plot_resource_usage(env, "res2", steps = TRUE)
#> Warning: 'plot_resource_usage' is deprecated.
#> Use 'simmer.plot::plot' instead.
#> See help("Deprecated")

select()

seize(), release(), set_capacity() and set_queue_size() work well when you know the resources implied beforehand. But sometimes the resource to choose may depend on a certain policy. For these situations, the select(., resources, policy, id) method offers the possibility of selecting a resource at any point, and this choice will be observed by seize_selected(), release_selected(), set_capacity_selected() and set_queue_size_selected():

patient_traj <- trajectory(name = "patient_trajectory") %>%
  select(resources = c("doctor1", "doctor2", "doctor3"), policy = "round-robin") %>%
  set_capacity_selected(1) %>%
  seize_selected(amount = 1) %>%
  timeout(5) %>%
  release_selected(amount = 1)

env <- simmer() %>%
  add_resource("doctor1", capacity = 0) %>%
  add_resource("doctor2", capacity = 0) %>%
  add_resource("doctor3", capacity = 0) %>%
  add_generator("patient", patient_traj, at(0, 1, 2)) %>%
  run()

get_mon_arrivals(env)
#>       name start_time end_time activity_time finished replication
#> 1 patient0          0        5             5     TRUE           1
#> 2 patient1          1        6             5     TRUE           1
#> 3 patient2          2        7             5     TRUE           1
get_mon_resources(env)
#>   resource time server queue capacity queue_size system limit replication
#> 1  doctor1    0      0     0        1        Inf      0   Inf           1
#> 2  doctor1    0      1     0        1        Inf      1   Inf           1
#> 3  doctor2    1      0     0        1        Inf      0   Inf           1
#> 4  doctor2    1      1     0        1        Inf      1   Inf           1
#> 5  doctor3    2      0     0        1        Inf      0   Inf           1
#> 6  doctor3    2      1     0        1        Inf      1   Inf           1
#> 7  doctor1    5      0     0        1        Inf      0   Inf           1
#> 8  doctor2    6      0     0        1        Inf      0   Inf           1
#> 9  doctor3    7      0     0        1        Inf      0   Inf           1

If you provide select() with resources as a vector of names, you can use one of the predefined policies (see ?select). If you need some custom policy, you can define it and supply it as a function. For instance, let’s pick a resource based on a previously set attribute:

patient_traj <- trajectory(name = "patient_trajectory") %>%
  set_attribute("resource", function() sample(1:3, 1)) %>%
  select(resources = function(attrs) paste0("doctor", attrs["resource"])) %>%
  seize_selected(amount = 1) %>%
  timeout(5) %>%
  release_selected(amount = 1)

env <- simmer() %>%
  add_resource("doctor1", capacity = 1) %>%
  add_resource("doctor2", capacity = 1) %>%
  add_resource("doctor3", capacity = 1) %>%
  add_generator("patient", patient_traj, at(0, 1, 2), mon = 2) %>%
  run()

get_mon_attributes(env)
#>   time     name      key value replication
#> 1    0 patient0 resource     2           1
#> 2    1 patient1 resource     3           1
#> 3    2 patient2 resource     3           1
get_mon_arrivals(env)
#>       name start_time end_time activity_time finished replication
#> 1 patient0          0        5             5     TRUE           1
#> 2 patient1          1        6             5     TRUE           1
#> 3 patient2          2       11             5     TRUE           1
get_mon_resources(env)
#>   resource time server queue capacity queue_size system limit replication
#> 1  doctor2    0      1     0        1        Inf      1   Inf           1
#> 2  doctor3    1      1     0        1        Inf      1   Inf           1
#> 3  doctor3    2      1     1        1        Inf      2   Inf           1
#> 4  doctor2    5      0     0        1        Inf      0   Inf           1
#> 5  doctor3    6      1     0        1        Inf      1   Inf           1
#> 6  doctor3   11      0     0        1        Inf      0   Inf           1

And, of course, everything learned for seize(), release(), set_capacity() and set_queue_size() applies to all their _selected versions.

activate(), deactivate()

The activate(., generator) and deactivate(., generator) methods are able to start or stop, respectively, a generator by name. This name can be supplied as either a string or a function returning a string. In the following simple example, the use of these methods spreads the interarrival times which otherwise would be of 1 unit of time, as defined in the generator:

t <- trajectory() %>%
  deactivate(generator = "dummy") %>%
  timeout(1) %>%
  activate(generator = "dummy")

simmer() %>%
  add_generator("dummy", t, function() 1) %>%
  run(10) %>%
  get_mon_arrivals()
#>     name start_time end_time activity_time finished replication
#> 1 dummy0          1        2             1     TRUE           1
#> 2 dummy1          3        4             1     TRUE           1
#> 3 dummy2          5        6             1     TRUE           1
#> 4 dummy3          7        8             1     TRUE           1

set_trajectory(), set_distribution()

The set_trajectory(., generator, trajectory) and set_distribution(., generator, distribution) methods are able to install a new trajectory or distribution, respectively, in a generator by name. This name can be supplied as either a string or a function returning a string.

In the following distribution, t2 changes the distribution and then switches to t1, so that only the first arrival takes t2:

t1 <- trajectory() %>%
  timeout(1)

t2 <- trajectory() %>%
  set_distribution("dummy", function() 1) %>%
  set_trajectory("dummy", t1) %>%
  timeout(2)

simmer() %>%
  add_generator("dummy", trajectory = t2, distribution = function() 2) %>%
  run(10) %>%
  get_mon_arrivals()
#>     name start_time end_time activity_time finished replication
#> 1 dummy0          2        4             2     TRUE           1
#> 2 dummy1          3        4             1     TRUE           1
#> 3 dummy2          4        5             1     TRUE           1
#> 4 dummy3          5        6             1     TRUE           1
#> 5 dummy4          6        7             1     TRUE           1
#> 6 dummy5          7        8             1     TRUE           1
#> 7 dummy6          8        9             1     TRUE           1

set_prioritization()

The add_generator() method assigns a set of prioritization values to each generated arrival: by default, priority=0, preemptible=priority, restart=FALSE (see ?add_generator for more details). The set_prioritization(., values) method can change those values with more granularity at any point in the trajectory:

patient_traj <- trajectory(name = "patient_trajectory") %>%
  set_attribute("priority", 3) %>%
  # static values
  set_prioritization(values = c(3, 7, TRUE)) %>%
  # dynamically with a function
  set_prioritization(values = function(attrs) c(attrs["priority"], 7, TRUE))

More details on prioritization in the Advanced Resource Usage vignette (pending).

branch()

The branch(., option, continue, ...) method offers the possibility of adding alternative paths in the trajectory. The following example shows how a trajectory can be built with a 50-50 chance for an arrival to pass through each path of a two-path branch.

t1 <- trajectory("trajectory with a branch") %>%
  seize("server", 1) %>%
  branch(option = function() sample(1:2, 1), continue = c(T, F), 
         trajectory("branch1") %>%
           timeout(function() 1),
         trajectory("branch2") %>%
           timeout(function() rexp(1, 3)) %>%
           release("server", 1)
  ) %>%
  release("server", 1)

When an arrival gets to the branch, the first argument is evaluated to select a specific path to follow, so it must be callable and must return a numeric value between 1 and n, where n is the number of paths defined. The second argument, continue, indicates whether the arrival must continue executing the activities after the selected path or not. In the example above, only the first path continues to the last release().

Sometimes you may need to count how many times a certain trajectory in a certain branch is entered, or how much time arrivals spend inside that trajectory. For these situations, it is handy to use resources with infinite capacity just for accounting purposes, like in the example below.

t0 <- trajectory() %>%
  branch(function() sample(c(1, 2), 1), continue = c(T, T),
         trajectory() %>%
           seize("branch1", 1) %>%
           # do stuff here
           timeout(function() rexp(1, 1)) %>%
           release("branch1", 1),
         trajectory() %>%
           seize("branch2", 1) %>%
           # do stuff here
           timeout(function() rexp(1, 1/2)) %>%
           release("branch2", 1))

env <- simmer() %>%
  add_generator("dummy", t0, at(rep(0, 1000))) %>%
  # Resources with infinite capacity, just for accounting purposes
  add_resource("branch1", Inf) %>%
  add_resource("branch2", Inf) %>%
  run()

arrivals <- get_mon_arrivals(env, per_resource = T)

# Times that each branch was entered
table(arrivals$resource)
#> 
#> branch1 branch2 
#>     490     510

# The `activity_time` is the total time inside each branch for each arrival
# Let's see the distributions
ggplot(arrivals) + geom_histogram(aes(x=activity_time)) + facet_wrap(~resource)

rollback()

The rollback(., amount, times, check) method allows an arrival to rollback the trajectory an amount number of steps.

Consider the following where a string is printed in the timeout function. After the first run, the trajectory is rolled back 3 times (so that it prints “Hello!” four times).

t0 <- trajectory() %>%
  log_("Hello!") %>%
  timeout(1) %>%
  rollback(amount = 2, times = 3)

simmer() %>%
  add_generator("hello_sayer", t0, at(0)) %>% 
  run() %>% invisible
#> 0: hello_sayer0: Hello!
#> 1: hello_sayer0: Hello!
#> 2: hello_sayer0: Hello!
#> 3: hello_sayer0: Hello!

The rollback() method also accepts an optional check parameter which overrides the default amount-based behaviour. This parameter must be a function that returns a logical value. Each time an arrival reaches the activity, this check is evaluated to determine whether the rollback() with amount steps must be performed or not. Consider the following example:

t0 <- trajectory() %>%
  set_attribute("happiness", 0) %>%
  log_(function(attrs) {
    paste0(">> Happiness level is at: ", attrs[["happiness"]], " -- ", 
           ifelse(attrs[["happiness"]]<25,"PETE: I'm feeling crappy...",
                  ifelse(attrs[["happiness"]]<50,"PETE: Feelin' a bit moody",
                         ifelse(attrs[["happiness"]]<75,"PETE: Just had a good espresso",
                                "PETE: Let's do this! (and stop this loop...)"))))
  }) %>%
  set_attribute("happiness", function(attrs) attrs[["happiness"]] + 25) %>%
  rollback(amount = 2, check = function(attrs) attrs[["happiness"]] < 100)

simmer() %>%
  add_generator("mood_swinger", t0, at(0)) %>% 
  run() %>% invisible
#> 0: mood_swinger0: >> Happiness level is at: 0 -- PETE: I'm feeling crappy...
#> 0: mood_swinger0: >> Happiness level is at: 25 -- PETE: Feelin' a bit moody
#> 0: mood_swinger0: >> Happiness level is at: 50 -- PETE: Just had a good espresso
#> 0: mood_swinger0: >> Happiness level is at: 75 -- PETE: Let's do this! (and stop this loop...)

leave()

The leave(., prob) method allows an arrival to leave the trajectory with some probability:

patient_traj <- trajectory(name = "patient_trajectory") %>%
  seize("nurse", 1) %>%
  timeout(3) %>%
  release("nurse", 1) %>%
  log_("before leave") %>%
  leave(prob = 1) %>%
  log_("after leave") %>%
  # patients will never seize the doctor
  seize("doctor", 1) %>%
  timeout(3) %>%
  release("doctor", 1)

env <- simmer() %>%
  add_resource("nurse", capacity=1) %>%
  add_resource("doctor", capacity=1) %>%
  add_generator("patient", patient_traj, at(0)) %>%
  run()
#> 3: patient0: before leave

get_mon_resources(env)
#>   resource time server queue capacity queue_size system limit replication
#> 1    nurse    0      1     0        1        Inf      1   Inf           1
#> 2    nurse    3      0     0        1        Inf      0   Inf           1

And of course, this probability may be evaluated dynamically also:

set.seed(1234)

patient_traj <- trajectory(name = "patient_trajectory") %>%
  seize("nurse", 1) %>%
  timeout(3) %>%
  release("nurse", 1) %>%
  log_("before leave") %>%
  leave(prob = function() runif(1) < 0.5) %>%
  log_("after leave") %>%
  # some patients will seize the doctor
  seize("doctor", 1) %>%
  timeout(3) %>%
  release("doctor", 1)

env <- simmer() %>%
  add_resource("nurse", capacity=1) %>%
  add_resource("doctor", capacity=1) %>%
  add_generator("patient", patient_traj, at(0, 1)) %>%
  run()
#> 3: patient0: before leave
#> 6: patient1: before leave
#> 6: patient1: after leave

get_mon_arrivals(env)
#>       name start_time end_time activity_time finished replication
#> 1 patient0          0        3             3    FALSE           1
#> 2 patient1          1        9             6     TRUE           1
get_mon_resources(env)
#>   resource time server queue capacity queue_size system limit replication
#> 1    nurse    0      1     0        1        Inf      1   Inf           1
#> 2    nurse    1      1     1        1        Inf      2   Inf           1
#> 3    nurse    3      1     0        1        Inf      1   Inf           1
#> 4    nurse    6      0     0        1        Inf      0   Inf           1
#> 5   doctor    6      1     0        1        Inf      1   Inf           1
#> 6   doctor    9      0     0        1        Inf      0   Inf           1

clone(), synchronize()

The clone(., n, ...) method offers the possibility of replicating an arrival n-1 times to be processed through up to n sub-trajectories in parallel. Then, the synchronize(., wait, mon_all) method synchronizes and removes replicas. By default, synchronize() waits for all of the replicas to arrive and allows the last one to continue:

t <- trajectory() %>%
  clone(n = 3,
        trajectory("original") %>%
          timeout(1),
        trajectory("clone 1") %>%
          timeout(2),
        trajectory("clone 2") %>%
          timeout(3)) %>%
  synchronize(wait = TRUE) %>%
  timeout(0.5)

env <- simmer(verbose = TRUE) %>%
  add_generator("arrival", t, at(0)) %>%
  run()
#>          0 | generator: arrival        |       new: arrival0       | 0
#>          0 |   arrival: arrival0       |  activity: Clone          | 3, 3 paths
#>          0 |   arrival: arrival0       |  activity: Timeout        | 1
#>          0 |   arrival: arrival0       |  activity: Timeout        | 2
#>          0 |   arrival: arrival0       |  activity: Timeout        | 3
#>          1 |   arrival: arrival0       |  activity: Synchronize    | 1
#>          2 |   arrival: arrival0       |  activity: Synchronize    | 1
#>          3 |   arrival: arrival0       |  activity: Synchronize    | 1
#>          3 |   arrival: arrival0       |  activity: Timeout        | 0.5

get_mon_arrivals(env)
#>       name start_time end_time activity_time finished replication
#> 1 arrival0          0      3.5           3.5     TRUE           1

Note that the parameter n may also be a function. If there are more sub-trajectories than clones, the extra ones are ignored. If there are less sub-trajectories than clones, some clones will continue to the next activity directly:

t <- trajectory() %>%
  clone(n = 3,
        trajectory("original") %>%
          timeout(1),
        trajectory("clone 1") %>%
          timeout(2)) %>%
  synchronize(wait = TRUE) %>%
  timeout(0.5)

env <- simmer(verbose = TRUE) %>%
  add_generator("arrival", t, at(0)) %>%
  run()
#>          0 | generator: arrival        |       new: arrival0       | 0
#>          0 |   arrival: arrival0       |  activity: Clone          | 3, 2 paths
#>          0 |   arrival: arrival0       |  activity: Timeout        | 1
#>          0 |   arrival: arrival0       |  activity: Timeout        | 2
#>          0 |   arrival: arrival0       |  activity: Synchronize    | 1
#>          1 |   arrival: arrival0       |  activity: Synchronize    | 1
#>          2 |   arrival: arrival0       |  activity: Synchronize    | 1
#>          2 |   arrival: arrival0       |  activity: Timeout        | 0.5

get_mon_arrivals(env)
#>       name start_time end_time activity_time finished replication
#> 1 arrival0          0      2.5           2.5     TRUE           1

The behaviour of synchronize() can be modified in order to let the first clone pass and remove the others by setting wait=FALSE:

t <- trajectory() %>%
  clone(n = 3,
        trajectory("original") %>%
          timeout(1),
        trajectory("clone 1") %>%
          timeout(2),
        trajectory("clone 2") %>%
          timeout(3)) %>%
  synchronize(wait = FALSE) %>%
  timeout(0.5)

env <- simmer(verbose = TRUE) %>%
  add_generator("arrival", t, at(0)) %>%
  run()
#>          0 | generator: arrival        |       new: arrival0       | 0
#>          0 |   arrival: arrival0       |  activity: Clone          | 3, 3 paths
#>          0 |   arrival: arrival0       |  activity: Timeout        | 1
#>          0 |   arrival: arrival0       |  activity: Timeout        | 2
#>          0 |   arrival: arrival0       |  activity: Timeout        | 3
#>          1 |   arrival: arrival0       |  activity: Synchronize    | 0
#>          1 |   arrival: arrival0       |  activity: Timeout        | 0.5
#>          2 |   arrival: arrival0       |  activity: Synchronize    | 0
#>          3 |   arrival: arrival0       |  activity: Synchronize    | 0

get_mon_arrivals(env)
#>       name start_time end_time activity_time finished replication
#> 1 arrival0          0      1.5           1.5     TRUE           1

By default, synchronize() does not record information about the clones removed (mon_all=FALSE). However, if it is required, you can get it by setting mon_all=TRUE:

t <- trajectory() %>%
  clone(n = 3,
        trajectory("original") %>%
          timeout(1),
        trajectory("clone 1") %>%
          timeout(2),
        trajectory("clone 2") %>%
          timeout(3)) %>%
  synchronize(wait = FALSE, mon_all = TRUE) %>%
  timeout(0.5)

env <- simmer(verbose = TRUE) %>%
  add_generator("arrival", t, at(0)) %>%
  run()
#>          0 | generator: arrival        |       new: arrival0       | 0
#>          0 |   arrival: arrival0       |  activity: Clone          | 3, 3 paths
#>          0 |   arrival: arrival0       |  activity: Timeout        | 1
#>          0 |   arrival: arrival0       |  activity: Timeout        | 2
#>          0 |   arrival: arrival0       |  activity: Timeout        | 3
#>          1 |   arrival: arrival0       |  activity: Synchronize    | 0
#>          1 |   arrival: arrival0       |  activity: Timeout        | 0.5
#>          2 |   arrival: arrival0       |  activity: Synchronize    | 0
#>          3 |   arrival: arrival0       |  activity: Synchronize    | 0

get_mon_arrivals(env)
#>       name start_time end_time activity_time finished replication
#> 1 arrival0          0      1.5           1.5     TRUE           1
#> 2 arrival0          0      2.0           2.0     TRUE           1
#> 3 arrival0          0      3.0           3.0     TRUE           1

batch(), separate()

The batch(., n, timeout, permanent, name, rule) method offers the possibility of collecting a number of arrivals before they can continue processing as a block. Then, the separate(.) method splits a previously established non-permanent batch. This allows us to implement a rollercoaster process, for instance.

Let us consider a rollercoaster, with up to 10 places and a queue of 20 people, that lasts 5 minutes. We can model this problem as follows:

set.seed(1234)

t <- trajectory() %>%
  batch(10, timeout = 5, permanent = FALSE) %>%
  seize("rollercoaster", 1) %>%
  timeout(5) %>%
  release("rollercoaster", 1) %>%
  separate()

env <- simmer() %>%
  # capacity and queue_size are defined in batches of 10
  add_resource("rollercoaster", capacity = 1, queue_size = 2) %>%
  add_generator("person", t, function() rexp(1, 2)) %>%
  run(15)

get_mon_arrivals(env, per_resource = TRUE)
#>        name start_time  end_time activity_time      resource replication
#> 1   person0   3.800074  8.800074             5 rollercoaster           1
#> 2   person1   3.800074  8.800074             5 rollercoaster           1
#> 3   person2   3.800074  8.800074             5 rollercoaster           1
#> 4   person3   3.800074  8.800074             5 rollercoaster           1
#> 5   person4   3.800074  8.800074             5 rollercoaster           1
#> 6   person5   3.800074  8.800074             5 rollercoaster           1
#> 7   person6   3.800074  8.800074             5 rollercoaster           1
#> 8   person7   3.800074  8.800074             5 rollercoaster           1
#> 9   person8   3.800074  8.800074             5 rollercoaster           1
#> 10  person9   3.800074  8.800074             5 rollercoaster           1
#> 11 person10   8.800074 13.800074             5 rollercoaster           1
#> 12 person11   8.800074 13.800074             5 rollercoaster           1
#> 13 person12   8.800074 13.800074             5 rollercoaster           1
#> 14 person13   8.800074 13.800074             5 rollercoaster           1
#> 15 person14   8.800074 13.800074             5 rollercoaster           1
#> 16 person15   8.800074 13.800074             5 rollercoaster           1

We can see above that 3 batches have been created. The first 10 people arrive within 3.8 minutes and goes into the rollercoaster. When the ride ends, at 8.8, there are only 6 people waiting, but the batch() timer (timeout=5) has run out, and another ride starts with them. These batches are non-permanent (permanent=FALSE), so that separate() can split them and people can go their separate ways.

The optional argument rule accepts a function to perform a fine-grained selection of which arrivals should be batched. For each particular arrival, it is batched if the function returns TRUE, or it simply continues otherwise. For instance, in the example above, we can prevent batching by returning always FALSE:

t_batch <- trajectory() %>%
  batch(10, timeout = 5, permanent = FALSE, rule = function() FALSE) %>%
  seize("rollercoaster", 1) %>%
  timeout(5) %>%
  release("rollercoaster", 1) %>%
  separate()

t_nobatch <- trajectory() %>%
  seize("rollercoaster", 1) %>%
  timeout(5) %>%
  release("rollercoaster", 1)

set.seed(1234)

env_batch <- simmer() %>%
  # capacity and queue_size are defined in batches of 10
  add_resource("rollercoaster", capacity = 1, queue_size = 2) %>%
  add_generator("person", t_batch, function() rexp(1, 2)) %>%
  run(15)

set.seed(1234)

env_nobatch <- simmer() %>%
  # capacity and queue_size are defined in batches of 10
  add_resource("rollercoaster", capacity = 1, queue_size = 2) %>%
  add_generator("person", t_nobatch, function() rexp(1, 2)) %>%
  run(15)

get_mon_arrivals(env_batch, per_resource = TRUE)
#>      name start_time  end_time activity_time      resource replication
#> 1 person0   1.250879  6.250879             5 rollercoaster           1
#> 2 person1   1.374259 11.250879             5 rollercoaster           1
get_mon_arrivals(env_nobatch, per_resource = TRUE)
#>      name start_time  end_time activity_time      resource replication
#> 1 person0   1.250879  6.250879             5 rollercoaster           1
#> 2 person1   1.374259 11.250879             5 rollercoaster           1

By default, batches are unnamed (name=""), which makes them independent of one another. However, it may be interesting to feed a common batch from different trajectories. For instance, we can try this:

t0 <- trajectory() %>%
  batch(2) %>%
  timeout(2) %>%
  separate()

t1 <- trajectory() %>%
  timeout(1) %>%
  join(t0)

env <- simmer(verbose = TRUE) %>%
  add_generator("t0_", t0, at(0)) %>%
  add_generator("t1_", t1, at(0)) %>%
  run()
#>          0 | generator: t0_            |       new: t0_0           | 0
#>          0 | generator: t1_            |       new: t1_0           | 0
#>          0 |   arrival: t0_0           |  activity: Batch          | 2, 0, 0, 
#>          0 |   arrival: t1_0           |  activity: Timeout        | 1
#>          1 |   arrival: t1_0           |  activity: Batch          | 2, 0, 0,

get_mon_arrivals(env)
#> [1] name          start_time    end_time      activity_time finished     
#> <0 rows> (or 0-length row.names)

But we don’t get the expected output because the arrivals are feeding two different batches. The arrival following t1 join t0 after the timeout, but effectively this is a clone of t0, which means that the above definition is equivalent to the following:

t0 <- trajectory() %>%
  batch(2) %>%
  timeout(2) %>%
  separate()

t1 <- trajectory() %>%
  timeout(1) %>%
  batch(2) %>%
  timeout(2) %>%
  separate()

Thus, arrivals following a different trajectory will end up in a different batch in general. Nonetheless, there is one way to share a common batch across batch() activities. This can be done by using a common name:

t0 <- trajectory() %>%
  batch(2, name = "mybatch") %>%
  timeout(2) %>%
  separate()

t1 <- trajectory() %>%
  timeout(1) %>%
  batch(2, name = "mybatch") %>%
  timeout(2) %>%
  separate()

env <- simmer(verbose = TRUE) %>%
  add_generator("t0_", t0, at(0)) %>%
  add_generator("t1_", t1, at(0)) %>%
  run()
#>          0 | generator: t0_            |       new: t0_0           | 0
#>          0 | generator: t1_            |       new: t1_0           | 0
#>          0 |   arrival: t0_0           |  activity: Batch          | 2, 0, 0, mybatch
#>          0 |   arrival: t1_0           |  activity: Timeout        | 1
#>          1 |   arrival: t1_0           |  activity: Batch          | 2, 0, 0, mybatch
#>          1 |   arrival: batch_mybatch  |  activity: Timeout        | 2
#>          3 |   arrival: batch_mybatch  |  activity: Separate       |

get_mon_arrivals(env)
#>   name start_time end_time activity_time finished replication
#> 1 t0_0          0        3             2     TRUE           1
#> 2 t1_0          0        3             3     TRUE           1

Or, equivalently,

t0 <- trajectory() %>%
  batch(2, name = "mybatch") %>%
  timeout(2) %>%
  separate()

t1 <- trajectory() %>%
  timeout(1) %>%
  join(t0)

env <- simmer(verbose = TRUE) %>%
  add_generator("t0_", t0, at(0)) %>%
  add_generator("t1_", t1, at(0)) %>%
  run()
#>          0 | generator: t0_            |       new: t0_0           | 0
#>          0 | generator: t1_            |       new: t1_0           | 0
#>          0 |   arrival: t0_0           |  activity: Batch          | 2, 0, 0, mybatch
#>          0 |   arrival: t1_0           |  activity: Timeout        | 1
#>          1 |   arrival: t1_0           |  activity: Batch          | 2, 0, 0, mybatch
#>          1 |   arrival: batch_mybatch  |  activity: Timeout        | 2
#>          3 |   arrival: batch_mybatch  |  activity: Separate       |

get_mon_arrivals(env)
#>   name start_time end_time activity_time finished replication
#> 1 t0_0          0        3             2     TRUE           1
#> 2 t1_0          0        3             3     TRUE           1

send(), trap(), untrap(), wait()

These activities enable asynchronous programming. The send(., signals, delay) method broadcasts a signal or a list of signals to all the arrivals subscribed to them. Signals can be triggered immediately:

t <- trajectory() %>%
  send(signals = c("signal1", "signal2"))

simmer(verbose = TRUE) %>%
  add_generator("signaler", t, at(0)) %>%
  run() %>% invisible
#>          0 | generator: signaler       |       new: signaler0      | 0
#>          0 |   arrival: signaler0      |  activity: Send           | [signal1, signal2, ], 0
#>          0 |      task: Broadcast      |                           |

or after some delay:

t <- trajectory() %>%
  send(signals = c("signal1", "signal2"), delay = 3)

simmer(verbose = TRUE) %>%
  add_generator("signaler", t, at(0)) %>%
  run() %>% invisible
#>          0 | generator: signaler       |       new: signaler0      | 0
#>          0 |   arrival: signaler0      |  activity: Send           | [signal1, signal2, ], 3
#>          3 |      task: Broadcast      |                           |

Note that both arguments, signals and delay, can be functions, and therefore they can retrieve the arrival’s attributes.

This is not very useful if nobody is listening. Arrivals can subscribe to signals and (optionally) assign a handler with the trap(., signals, handler, interruptible). In the following example, an arrival subscribes to a signal and blocks until its reception using the wait(.) method.

t_blocked <- trajectory() %>%
  trap("you shall pass") %>%
  log_("waiting...") %>%
  wait() %>%
  log_("continuing!")

t_signaler <- trajectory() %>%
  log_("you shall pass") %>%
  send("you shall pass")

simmer() %>%
  add_generator("blocked", t_blocked, at(0)) %>%
  add_generator("signaler", t_signaler, at(5)) %>%
  run() %>% invisible
#> 0: blocked0: waiting...
#> 5: signaler0: you shall pass
#> 5: blocked0: continuing!

Note that signals are ignored when an arrival is waiting in a resource’s queue. The same applies inside a batch: all the signals subscribed before entering the batch are ignored. Thus, the following batch will block indifinitely:

t_blocked <- trajectory() %>%
  trap("you shall pass") %>%
  log_("waiting inside a batch...") %>%
  batch(1) %>%
  wait() %>%
  log_("continuing!")

t_signaler <- trajectory() %>%
  log_("you shall pass") %>%
  send("you shall pass")

simmer() %>%
  add_generator("blocked", t_blocked, at(0)) %>%
  add_generator("signaler", t_signaler, at(5)) %>%
  run() %>% invisible
#> 0: blocked0: waiting inside a batch...
#> 5: signaler0: you shall pass

Upon a signal reception, the arrival stops the current activity and executes the handler if provided. Then, the execution returns to the activity following the point of the interruption:

t_worker <- trajectory() %>%
  trap("you are free to go", 
       handler = trajectory() %>%
         log_("ok, I'm packing...") %>%
         timeout(1)
  ) %>%
  log_("performing a looong task...") %>%
  timeout(100) %>%
  log_("and I'm leaving!")

t_signaler <- trajectory() %>%
  log_("you are free to go") %>%
  send("you are free to go")

simmer() %>%
  add_generator("worker", t_worker, at(0)) %>%
  add_generator("signaler", t_signaler, at(5)) %>%
  run() %>% invisible
#> 0: worker0: performing a looong task...
#> 5: signaler0: you are free to go
#> 5: worker0: ok, I'm packing...
#> 6: worker0: and I'm leaving!

Finally, the untrap(., signals) method can be used to unsubscribe from signals:

t_worker <- trajectory() %>%
  trap("you are free to go", 
       handler = trajectory() %>%
         log_("ok, I'm packing...") %>%
         timeout(1)
  ) %>%
  log_("performing a looong task...") %>%
  untrap("you are free to go") %>%
  timeout(100) %>%
  log_("and I'm leaving!")

t_signaler <- trajectory() %>%
  log_("you are free to go") %>%
  send("you are free to go")

simmer() %>%
  add_generator("worker", t_worker, at(0)) %>%
  add_generator("signaler", t_signaler, at(5)) %>%
  run() %>% invisible
#> 0: worker0: performing a looong task...
#> 5: signaler0: you are free to go
#> 100: worker0: and I'm leaving!

Signal handlers can be interrupted as well by default, meaning that a handler may keep restarting if there are frequent enough signals:

t_worker <- trajectory() %>%
  trap("you are free to go", 
       handler = trajectory() %>%
         log_("ok, I'm packing...") %>%
         timeout(1)
  ) %>%
  log_("performing a looong task...") %>%
  timeout(100) %>%
  log_("and I'm leaving!")

t_signaler <- trajectory() %>%
  log_("you are free to go") %>%
  send("you are free to go")

simmer() %>%
  add_generator("worker", t_worker, at(0)) %>%
  add_generator("signaler", t_signaler, from(5, function() 0.5)) %>%
  run(10) %>% invisible
#> 0: worker0: performing a looong task...
#> 5: signaler0: you are free to go
#> 5: worker0: ok, I'm packing...
#> 5.5: signaler1: you are free to go
#> 5.5: worker0: ok, I'm packing...
#> 6: signaler2: you are free to go
#> 6: worker0: ok, I'm packing...
#> 6.5: signaler3: you are free to go
#> 6.5: worker0: ok, I'm packing...
#> 7: signaler4: you are free to go
#> 7: worker0: ok, I'm packing...
#> 7.5: signaler5: you are free to go
#> 7.5: worker0: ok, I'm packing...
#> 8: signaler6: you are free to go
#> 8: worker0: ok, I'm packing...
#> 8.5: signaler7: you are free to go
#> 8.5: worker0: ok, I'm packing...
#> 9: signaler8: you are free to go
#> 9: worker0: ok, I'm packing...
#> 9.5: signaler9: you are free to go
#> 9.5: worker0: ok, I'm packing...

If an uninterruptible handler is needed, this can be achieved by setting the proper flag:

t_worker <- trajectory() %>%
  trap("you are free to go", 
       handler = trajectory() %>%
         log_("ok, I'm packing...") %>%
         timeout(1),
       interruptible = FALSE            # make it uninterruptible
  ) %>%
  log_("performing a looong task...") %>%
  timeout(100) %>%
  log_("and I'm leaving!")

t_signaler <- trajectory() %>%
  log_("you are free to go") %>%
  send("you are free to go")

simmer() %>%
  add_generator("worker", t_worker, at(0)) %>%
  add_generator("signaler", t_signaler, from(5, function() 0.5)) %>%
  run(10) %>% invisible
#> 0: worker0: performing a looong task...
#> 5: signaler0: you are free to go
#> 5: worker0: ok, I'm packing...
#> 5.5: signaler1: you are free to go
#> 6: worker0: and I'm leaving!
#> 6: signaler2: you are free to go
#> 6.5: signaler3: you are free to go
#> 7: signaler4: you are free to go
#> 7.5: signaler5: you are free to go
#> 8: signaler6: you are free to go
#> 8.5: signaler7: you are free to go
#> 9: signaler8: you are free to go
#> 9.5: signaler9: you are free to go

renege_in(), renege_if(), renege_abort()

The renege_in(., t, out) method offers the possibility of setting a timeout after which the arrival will abandon the trajectory. After reneging, the arrival can follow an optional sub-trajectory out. The renege_abort(.) method cancels the latter. Together, they allows us, for instance, to model arrivals with limited patience. In the example below, customer1 arrives at the bank, where there is only one busy clerk. He/she waits in the queue for 5 minutes and then leaves.

t <- trajectory(name = "bank") %>%
  log_("Here I am") %>%
  # renege in 5 minutes
  renege_in(5, 
            out = trajectory() %>%
              log_("Lost my patience. Reneging...")
  ) %>%
  seize("clerk", 1) %>%
  # stay if I'm being attended within 5 minutes
  renege_abort() %>%
  log_("I'm being attended") %>%
  timeout(10) %>%
  release("clerk", 1) %>%
  log_("Finished")

simmer() %>%
  add_resource("clerk", 1) %>%
  add_generator("customer", t, at(0, 1)) %>%
  run() %>% invisible
#> 0: customer0: Here I am
#> 0: customer0: I'm being attended
#> 1: customer1: Here I am
#> 6: customer1: Lost my patience. Reneging...
#> 10: customer0: Finished

The same can be achieved with renege_if(., signal, out) if customer0 sends a signal to customer1 at t=5:

t <- trajectory(name = "bank") %>%
  log_("Here I am") %>%
  # renege when "renege now" is received
  renege_if("renege now", 
            out = trajectory() %>%
              log_("Ok. Reneging...")
  ) %>%
  seize("clerk", 1) %>%
  # stay if I'm being attended within 5 minutes
  renege_abort() %>%
  log_("I'm being attended") %>%
  timeout(5) %>%
  log_("I say: renege now") %>%
  send("renege now") %>%
  timeout(5) %>%
  release("clerk", 1) %>%
  log_("Finished")

simmer() %>%
  add_resource("clerk", 1) %>%
  add_generator("customer", t, at(0, 1)) %>%
  run() %>% invisible
#> 0: customer0: Here I am
#> 0: customer0: I'm being attended
#> 1: customer1: Here I am
#> 5: customer0: I say: renege now
#> 5: customer1: Ok. Reneging...
#> 10: customer0: Finished

Note that, in contrast to trap(), reneging is triggered even if the arrival is in a queue or is part of a non-permanent batch.

Manipulating trajectories: joining and subsetting

join()

The join(...) method is very useful to concatenate together any number of trajectories. It may be used as a standalone function as follows:

t1 <- trajectory() %>% seize("dummy", 1)
t2 <- trajectory() %>% timeout(1)
t3 <- trajectory() %>% release("dummy", 1)

t0 <- join(t1, t2, t3)
t0
#> trajectory: anonymous, 3 activities
#> { Activity: Seize        | resource: dummy | amount: 1 }
#> { Activity: Timeout      | delay: 1 }
#> { Activity: Release      | resource: dummy | amount: 1 }

Or it may operate inline, like another activity:

t0 <- trajectory() %>%
  join(t1) %>%
  timeout(1) %>%
  join(t3)
t0
#> trajectory: anonymous, 3 activities
#> { Activity: Seize        | resource: dummy | amount: 1 }
#> { Activity: Timeout      | delay: 1 }
#> { Activity: Release      | resource: dummy | amount: 1 }

[, [[

You can think about a trajectory object as a list of activities that has a length

length(t0)
#> [1] 3

and can be subset using the standard operator [. For instance, you can select the activities you want with a logical vector:

t0[c(TRUE, FALSE, TRUE)]
#> trajectory: anonymous, 2 activities
#> { Activity: Seize        | resource: dummy | amount: 1 }
#> { Activity: Release      | resource: dummy | amount: 1 }

Or a set of indices that respect the order given:

t0[c(1, 3)]
#> trajectory: anonymous, 2 activities
#> { Activity: Seize        | resource: dummy | amount: 1 }
#> { Activity: Release      | resource: dummy | amount: 1 }
t0[c(3, 1)]
#> trajectory: anonymous, 2 activities
#> { Activity: Release      | resource: dummy | amount: 1 }
#> { Activity: Seize        | resource: dummy | amount: 1 }

Or a set of indices to remove from the selection:

t0[-2]
#> trajectory: anonymous, 2 activities
#> { Activity: Seize        | resource: dummy | amount: 1 }
#> { Activity: Release      | resource: dummy | amount: 1 }

Or by name, but note that this does not respect the order given though, because it performs a match:

t0[c("seize", "release")]
#> trajectory: anonymous, 2 activities
#> { Activity: Seize        | resource: dummy | amount: 1 }
#> { Activity: Release      | resource: dummy | amount: 1 }
t0[c("release", "seize")]
#> trajectory: anonymous, 2 activities
#> { Activity: Seize        | resource: dummy | amount: 1 }
#> { Activity: Release      | resource: dummy | amount: 1 }

If you provide no indices, the whole trajectory is returned:

t0[]
#> trajectory: anonymous, 3 activities
#> { Activity: Seize        | resource: dummy | amount: 1 }
#> { Activity: Timeout      | delay: 1 }
#> { Activity: Release      | resource: dummy | amount: 1 }

In fact, you are cloning the trajectory with the latter command. It is equivalent to t0[1:length(t0)] or join(t0).

The generics head() and tail() use the [ operator under the hood, thus you can use them as well:

head(t0, 2)
#> trajectory: anonymous, 2 activities
#> { Activity: Seize        | resource: dummy | amount: 1 }
#> { Activity: Timeout      | delay: 1 }
tail(t0, -1)
#> trajectory: anonymous, 2 activities
#> { Activity: Timeout      | delay: 1 }
#> { Activity: Release      | resource: dummy | amount: 1 }

The [[ operator can also be used to extract only one element:

t0[[2]]
#> trajectory: anonymous, 1 activities
#> { Activity: Timeout      | delay: 1 }

which is equivalent to t0[2]. If a string is provided, it ensures that only the first match is returned:

join(t0, t0)["timeout"]
#> trajectory: anonymous, 2 activities
#> { Activity: Timeout      | delay: 1 }
#> { Activity: Timeout      | delay: 1 }
join(t0, t0)[["timeout"]]
#> trajectory: anonymous, 1 activities
#> { Activity: Timeout      | delay: 1 }

Interacting with the environment from within a trajectory

It is possible to interact with the simulation environment in order to extract parameters of interest such as the current simulation time (now()), status of resources (get_capacity(), get_queue_size(), get_server_count(), get_queue_count()), status of generators (get_n_generated()) or directly to gather the history of monitored values (get_mon_*()). You may also want (or in other words, your model may need) to check and use all this information to take decisions inside a given trajectory.

For instance, let’s suppose we just want to print the simulation time at a given point in a trajectory. The only requirement is that you must define the simulation environment before running the simulation. This won’t work:

remove(env)

t <- trajectory() %>%
  timeout(function() print(env %>% now()))

env <- simmer() %>%
  add_generator("dummy", t, function() 1) %>%
  run(4)
#> Error in run_(private$sim_obj, until): objeto 'env' no encontrado

Because the global env is not available at runtime: the simulation runs and then the resulting object is assigned to env. We need to assign first, then run. So this will work:

t <- trajectory() %>%
  timeout(function() print(env %>% now()))

env <- simmer() %>%
  add_generator("dummy", t, function() 1)

env %>% run(4) %>% invisible
#> [1] 1
#> [1] 2
#> [1] 3

And we get the expected output. However, as a general rule of good practice, it is recommended to instantiate the environment always in the first place, to avoid possible mistakes and because the code becomes more readable:

# First, instantiate the environment
env <- simmer()

# Here I'm using it
t <- trajectory() %>%
  timeout(function() print(env %>% now()))

# And finally, run it
env %>%
  add_generator("dummy", t, function() 1) %>%
  run(4) %>% invisible
#> [1] 1
#> [1] 2
#> [1] 3