Parameters from script

๐ŸŽฏ Objectives

Discrete-event simulations (DES) require many parameters - like arrival rates, resource times, and probabilities - which often need to be changed for different scenarios and analyses. Managing these parameters well makes your simulations easier to update, track, and reuse.

This page explains best practices for managing model parameters directly within scripts.

  • ๐Ÿšซ What not to do: hardcoding parameters.
  • ๐Ÿ“„ A slight improvement: global parameters.
  • โœ… Recommendation for managing parameters in DES: grouping parameters into a dedicated object and passing that object explicitly to your model.
  • ๐Ÿงฎ Handling a large number of parameters.
  • ๐Ÿงพ Examples: Full code examples from our example simulation models.

If you want to see how to store parameters in a separate file, see the parameters from file page.

๐Ÿ”— Reproducibility guidelines

This page helps you meet reproducibility criteria from:

  • Heather et al. 2025: Avoid hard-coded parameters.
# Load required packages
library(R6) # nolint: undesirable_function_linter

๐Ÿšซ What not to do: hardcoding parameters

Hardcoding means writing parameter values directly into your code. For example:

def model():
    # Hardcoded parameter values
    interarrival_time = 5
    consultation_time = 20
    transfer_prob = 0.3
    # ...rest of the model...
model <- function() {
    # Hardcoded parameter values
    interarrival_time <- 5
    consultation_time <- 20
    transfer_prob <- 0.3
    # ...rest of the model...
}

This makes it very difficult to change the values. Modellers might choose toโ€ฆ

1. Edit parameters directly in the script.

This involves manually changing parameter values in the script each time you want to run a new scenario. Problems with this approach include:

  • โŒ Not a reproducible analytical pipeline. Alot of manual intervention is required to re-run the model with different parameters.
  • โŒ Error-prone. It would be easy to make mistakes or forget to update all relevant values.
  • โŒ Parameters can get lost. If you lost your notes or forget to record what you used, you wonโ€™t know what values were used for past runs.

2. Duplicate scripts for each scenario.

This involves copying the entire script, changing parameters in each copy, and running them separately. Problems with this approach include:

  • โŒ Code duplication. This means any changes - like bug fixes or improvements to the model - must be made to every copy. This is tedious and there is a risk that some copies are missed or updated incorrectly.
  • โŒ Hard to keep track. With multiple script copies, it can become difficult to know which scripts correspond to which scenarios, and which parameters were used (as have to delve into the model code to identify them).

๐Ÿ“„ A slight improvement: global parameters

A better (but still limited) approach is to define all parameters at the top of your script.

This way, parameters are no longer hidden within the code. It becomes much easier to see which parameters are being used, and to change the values used.

# Parameters for base case
INTERARRIVAL_TIME = 5
CONSULTATION_TIME = 20
TRANSFER_PROB = 0.3

def model():
    # Use the global parameters
    # ...
# Parameters for base case
interarrival_time <- 5
consultation_time <- 20
transfer_prob <- 0.3

model <- function() {
  # Use the global parameters
  # ...
}

For scenarios, you would define the same global variables with alternative values:

# Scenario 1
INTERARRIVAL_TIME = 6
CONSULTATION_TIME = 20
TRANSFER_PROB = 0.3
# Scenario 2
INTERARRIVAL_TIME = 5
CONSULTATION_TIME = 20
TRANSFER_PROB = 0.4
# Scenario 1
interarrival_time <- 6
consultation_time <- 20
transfer_prob <- 0.3
# Scenario 2
interarrival_time <- 5
consultation_time <- 20
transfer_prob <- 0.4

The improvements are that parameters are:

  • โœ… No longer hardcoded. Within the model, it refers to the variable name rather than a specific value,which means we are able to now list the values in one outside the model logic.
  • โœ… Centralised. All parameters are in one place, making them easier to find and change.

However, there are still several disadvantages:

  • โŒ Still inflexible. In order to re-run the model with different scenarios, you would still need to do the approaches above - editing code directly or duplicating scripts for each scenario.
  • โŒ Not scalable. As the number of scenarios or parameters grows, managing all these global variables becomes messy.

โœ… Recommendation for managing parameters in DES

Two critical practices

To manage parameters effectively, you need to:

  1. Group parameters into a dedicated object.
  2. Pass these objects explicitly to your model.

Why?

  • โœ… Clear parameter sets. Every scenario has its own object with all the parameters needed. This can be easily viewed, and comes in handy in logs to easily print a copy of all parameters used for a scenario.
  • โœ… No global variables. By explicitly passing our parameters, we avoid accidental parameter reuse between scenarios (which is a possibility with global variables!).
  • โœ… Fewer inputs. If all parameters are in one object, then we can just pass that as a single input to our model function/class, reducing the number of arguments we need to pass.


Itโ€™s important to use both of these practices.

If you only do option 1 (group parameters, but use as globals), parameters might accidentally be modified elsewhere, or one scenarioโ€™s parameters might affect anotherโ€™s.

# BAD: Parameters are grouped but still global
global_params = Parameters()

def simulate():
    # Uses global_params.interarrival_time... ๐Ÿ˜ฌ
    ...
# BAD: Parameters are grouped but still global
global_params <- list()

simulate <- function() {
  # Uses global_params$interarrival_time ... ๐Ÿ˜ฌ
  ...
}

If you only do option 2 (pass parameters, but donโ€™t group them), you end up with messy, error-prone code thatโ€™s hard to maintain:

# BAD: Parameters are passed but disorganised
def simulate(interarrival_time, consultation_time, transfer_prob, ...):
    # 10+ parameters? Hard to track!
    ...
# BAD: Parameters are passed but disorganised
simulate <- function(interarrival_time, consultation_time, transfer_prob, ...) {
  # 10+ parameters? Hard to track!
  ...
}

Three implementation options

There are three implementation options: dictionary, function or class.

Using a dictionary

# Base case
base_params = {
    "interarrival_time": 5,
    "consultation_time": 20,
    "transfer_prob": 0.3,
}
print(base_params)
{'interarrival_time': 5, 'consultation_time': 20, 'transfer_prob': 0.3}
# Create a scenario by copying and tweaking only what's needed
scenario1 = base_params.copy()
scenario1["interarrival_time"] = 6
print(scenario1)
{'interarrival_time': 6, 'consultation_time': 20, 'transfer_prob': 0.3}

Using a function

def create_params(
  interarrival_time=5, consultation_time=20, transfer_prob=0.3
):
    """
    Generate parameter dictionary.

    Parameters
    ----------
    interarrival_time : float
        Time between arrivals (minutes).
    consultation_time : float
        Length of consultation (minutes).
    transfer_prob : float
        Transfer probability (0-1).

    Returns
    -------
    Dictionary containing parameters.
    """
    return {
        "interarrival_time": interarrival_time,
        "consultation_time": consultation_time,
        "transfer_prob": transfer_prob
    }


# Base case
base_params = create_params()
print(base_params)
{'interarrival_time': 5, 'consultation_time': 20, 'transfer_prob': 0.3}
# Create a scenario with altered inter-arrival time
scenario1 = create_params(interarrival_time=6)
print(scenario1)
{'interarrival_time': 6, 'consultation_time': 20, 'transfer_prob': 0.3}

Using a class

class Parameters: # pylint: disable=too-few-public-methods
    """
    Parameter class.
    """
    def __init__(
        self, interarrival_time=5, consultation_time=20, transfer_prob=0.3
    ):
        """
        Initialise Parameters instance.

        Parameters
        ----------
        interarrival_time : float
            Time between arrivals (minutes).
        consultation_time : float
            Length of consultation (minutes).
        transfer_prob : float
            Transfer probability (0-1).
        """
        self.interarrival_time = interarrival_time
        self.consultation_time = consultation_time
        self.transfer_prob = transfer_prob

# Base case
base_params = Parameters()
print(base_params.__dict__)
{'interarrival_time': 5, 'consultation_time': 20, 'transfer_prob': 0.3}
# Create a scenario with altered inter-arrival time
scenario1 = Parameters(interarrival_time=6)
print(scenario1.__dict__)
{'interarrival_time': 6, 'consultation_time': 20, 'transfer_prob': 0.3}

There are three implementation options: list, function or R6 class.

Using a list

# Base case
base_params <- list(
  interarrival_time = 5L,
  consultation_time = 20L,
  transfer_prob = 0.3
)
base_params
$interarrival_time
[1] 5

$consultation_time
[1] 20

$transfer_prob
[1] 0.3
# Create a scenario by copying and tweaking only what's needed
scenario1 <- base_params
scenario1$interarrival_time <- 6L
scenario1
$interarrival_time
[1] 6

$consultation_time
[1] 20

$transfer_prob
[1] 0.3

Using a function

#' Generate parameter list.
#'
#' @param interarrival_time Numeric. Time between arrivals (minutes).
#' @param consultation_time Numeric. Length of consultation (minutes).
#' @param transfer_prob Numeric. Transfer probability (0-1).
#'
#' @return A named list of parameters.

create_params <- function(interarrival_time = 5L,
                          consultation_time = 20L,
                          transfer_prob = 0.3) {
  list(
    interarrival_time = interarrival_time,
    consultation_time = consultation_time,
    transfer_prob     = transfer_prob
  )
}

# Base case
base_params <- create_params()
base_params
$interarrival_time
[1] 5

$consultation_time
[1] 20

$transfer_prob
[1] 0.3
# Create a scenario with altered inter-arrival time
scenario1 <- create_params(interarrival_time = 6L)
scenario1
$interarrival_time
[1] 6

$consultation_time
[1] 20

$transfer_prob
[1] 0.3

Using a R6 class

Include a get_params method to easily return a list of parameters.

#' @title Parameter class.
#'
#' @field interarrival_time Numeric. Time between arrivals (minutes).
#' @field consultation_time Numeric. Length of consultation (minutes).
#' @field transfer_prob Numeric. Transfer probability (0-1).

Parameters <- R6Class( # nolint: object_name_linter
  classname = "Parameters",
  public = list(
    interarrival_time = NULL,
    consultation_time = NULL,
    transfer_prob = NULL,
    initialize = function(
      interarrival_time = 5L,
      consultation_time = 20L,
      transfer_prob = 0.3
    ) {
      self$interarrival_time <- interarrival_time
      self$consultation_time <- consultation_time
      self$transfer_prob <- transfer_prob
    },

    #' @description
    #' Returns parameters as a named list.

    get_params = function() {
      # Get all non-function fields
      all_names <- ls(self)
      is_not_function <- vapply(
        all_names,
        function(x) !is.function(self[[x]]),
        FUN.VALUE = logical(1L)
      )
      param_names <- all_names[is_not_function]
      mget(param_names, envir = self)
    }
  )
)

# Base case
base_params <- Parameters$new()
base_params$get_params()
$consultation_time
[1] 20

$interarrival_time
[1] 5

$transfer_prob
[1] 0.3
# Create a scenario with altered inter-arrival time
scenario1 <- Parameters$new(interarrival_time = 6L)
scenario1$get_params()
$consultation_time
[1] 20

$interarrival_time
[1] 6

$transfer_prob
[1] 0.3

Which option is best?

The most robust approach is to use a function or class to manage your parameters.

  • โœ… Functions and classes make it easy to create variations for different scenarios, since you simply change the inputs when you define a new scenario. For example, you can create a new scenario by only specifying the parameter you want to change, while all other parameters remain at their default values.
  • โŒ With a dictionary, you have to make a copy of the base dictionary and then manually change individual values for each scenario. This can become cumbersome as the number of parameters or scenarios grows - and is just a bit more clunky!
  • โŒ With a list, you have to make a copy of the base list and then manually change individual values for each scenario. This can become cumbersome as the number of parameters or scenarios grows - and is just a bit more clunky!

Your choice may be further informed by options for parameter validation, where classes can be superior as you can incorporate validation within the class, as discussed on the parameter validation page.

Itโ€™s worth noting though that, while R does support object-oriented programming (i.e. using classes), these are less commonly used in typical R code.

๐Ÿงฎ Handling a large number of parameters

You may need to manage many parameters - for example, if you have several patient types and/or units each with their own arrival times, resource times, and so on.

We have suggested a few strategies you could useโ€ฆ

Using a single function or class for all parameters

This can be convenient for smaller models, though can get unwieldly as the number of parameters grow, including potentially quite long parameter names! Although you could return a nested object to address this.

Function example (with nested dictionaries)

def create_params( # pylint: disable=function-redefined, too-many-arguments, too-many-positional-arguments
    adult_interarrival=5, adult_consultation=20, adult_transfer=0.3,
    child_interarrival=7, child_consultation=15, child_transfer=0.2,
    elderly_interarrival=10, elderly_consultation=30, elderly_transfer=0.5
):
    """
    Generate parameter dictionary.

    Parameters
    ----------
    adult_interarrival : float
        Time between adult patient arrivals (minutes).
    adult_consultation : float
        Length of adult patient consultation (minutes).
    adult_transfer : float
        Adult patient transfer probability (0-1).
    child_interarrival : float
        Time between child patient arrivals (minutes).
    child_consultation : float
        Length of child patient consultation (minutes).
    child_transfer : float
        Child patient transfer probability (0-1).
    elderly_interarrival : float
        Time between elderly patient arrivals (minutes).
    elderly_consultation : float
        Length of elderly patient consultation (minutes).
    elderly_transfer : float
        Elderly patient transfer probability (0-1).

    Returns
    -------
    Dictionary with three keys ("adult", "child", "elderly"), each containing a
    dictionary of parameters.
    """
    return {
        "adult": {
            "interarrival_time": adult_interarrival,
            "consultation_time": adult_consultation,
            "transfer_prob": adult_transfer
        },
        "child": {
            "interarrival_time": child_interarrival,
            "consultation_time": child_consultation,
            "transfer_prob": child_transfer
        },
        "elderly": {
            "interarrival_time": elderly_interarrival,
            "consultation_time": elderly_consultation,
            "transfer_prob": elderly_transfer
        }
    }


# Example usage
base_params = create_params()
print(base_params)
{'adult': {'interarrival_time': 5, 'consultation_time': 20, 'transfer_prob': 0.3}, 'child': {'interarrival_time': 7, 'consultation_time': 15, 'transfer_prob': 0.2}, 'elderly': {'interarrival_time': 10, 'consultation_time': 30, 'transfer_prob': 0.5}}

Class example

class Parameters:  # pylint: disable=function-redefined, too-many-instance-attributes, too-many-arguments, too-many-positional-arguments, too-few-public-methods
    """
    Parameter class.
    """
    def __init__(
        self,
        adult_interarrival=5, adult_consultation=20, adult_transfer=0.3,
        child_interarrival=7, child_consultation=15, child_transfer=0.2,
        elderly_interarrival=10, elderly_consultation=30, elderly_transfer=0.5
    ):
        """
        Initialise Parameters instance.

        Parameters
        ----------
        adult_interarrival : float
            Time between adult patient arrivals (minutes).
        adult_consultation : float
            Length of adult patient consultation (minutes).
        adult_transfer : float
            Adult patient transfer probability (0-1).
        child_interarrival : float
            Time between child patient arrivals (minutes).
        child_consultation : float
            Length of child patient consultation (minutes).
        child_transfer : float
            Child patient transfer probability (0-1).
        elderly_interarrival : float
            Time between elderly patient arrivals (minutes).
        elderly_consultation : float
            Length of elderly patient consultation (minutes).
        elderly_transfer : float
            Elderly patient transfer probability (0-1).
        """
        # Adult parameters
        self.adult_interarrival = adult_interarrival
        self.adult_consultation = adult_consultation
        self.adult_transfer = adult_transfer
        # Child parameters
        self.child_interarrival = child_interarrival
        self.child_consultation = child_consultation
        self.child_transfer = child_transfer
        # Elderly parameters
        self.elderly_interarrival = elderly_interarrival
        self.elderly_consultation = elderly_consultation
        self.elderly_transfer = elderly_transfer


# Example usage
base_params = Parameters()
print(base_params.__dict__)
{'adult_interarrival': 5, 'adult_consultation': 20, 'adult_transfer': 0.3, 'child_interarrival': 7, 'child_consultation': 15, 'child_transfer': 0.2, 'elderly_interarrival': 10, 'elderly_consultation': 30, 'elderly_transfer': 0.5}

Function example (with nested lists)

#' Generate parameter list.
#'
#' @param adult_interarrival Numeric. Time between adult patient arrivals
#' (minutes).
#' @param adult_consultation Numeric. Length of adult patient consultation
#' (minutes).
#' @param adult_transfer Numeric. Adult patient transfer probability (0-1).
#' @param child_interarrival Numeric. Time between child patient arrivals
#' (minutes).
#' @param child_consultation Numeric. Length of child patient consultation
#' (minutes).
#' @param child_transfer Numeric. Child patient transfer probability (0-1).
#' @param elderly_interarrival Numeric. Time between elderly patient arrivals
#' (minutes).
#' @param elderly_consultation Numeric. Length of elderly patient consultation
#' (minutes).
#' @param elderly_transfer Numeric. Elderly patient transfer probability (0-1).
#'
#' @return A named list with three keys ("adult", "child", "elderly"), each
#' containing a list of parameters.

create_params <- function(
  adult_interarrival = 5L, adult_consultation = 20L, adult_transfer = 0.3,
  child_interarrival = 7L, child_consultation = 15L, child_transfer = 0.2,
  elderly_interarrival = 10L, elderly_consultation = 30L,
  elderly_transfer = 0.5
) {
  list(
    adult = list(
      interarrival_time = adult_interarrival,
      consultation_time = adult_consultation,
      transfer_prob = adult_transfer
    ),
    child = list(
      interarrival_time = child_interarrival,
      consultation_time = child_consultation,
      transfer_prob = child_transfer
    ),
    elderly = list(
      interarrival_time = elderly_interarrival,
      consultation_time = elderly_consultation,
      transfer_prob = elderly_transfer
    )
  )
}


# Example usage
base_params <- create_params()
base_params
$adult
$adult$interarrival_time
[1] 5

$adult$consultation_time
[1] 20

$adult$transfer_prob
[1] 0.3


$child
$child$interarrival_time
[1] 7

$child$consultation_time
[1] 15

$child$transfer_prob
[1] 0.2


$elderly
$elderly$interarrival_time
[1] 10

$elderly$consultation_time
[1] 30

$elderly$transfer_prob
[1] 0.5

R6 class example

#' @title Parameter class.
#'
#' @field adult_interarrival Numeric. Time between adult patient arrivals
#' (minutes).
#' @field adult_consultation Numeric. Length of adult patient consultation
#' (minutes).
#' @field adult_transfer Numeric. Adult patient transfer probability (0-1).
#' @field child_interarrival Numeric. Time between child patient arrivals
#' (minutes).
#' @field child_consultation Numeric. Length of child patient consultation
#' (minutes).
#' @field child_transfer Numeric. Child patient transfer probability (0-1).
#' @field elderly_interarrival Numeric. Time between elderly patient arrivals
#' (minutes).
#' @field elderly_consultation Numeric. Length of elderly patient consultation
#' (minutes).
#' @field elderly_transfer Numeric. Elderly patient transfer probability (0-1).

Parameters <- R6Class( # nolint: object_name_linter
  classname = "Parameters",
  public = list(
    # Adult parameters
    adult_interarrival = NULL,
    adult_consultation = NULL,
    adult_transfer = NULL,

    # Child parameters
    child_interarrival = NULL,
    child_consultation = NULL,
    child_transfer = NULL,

    # Elderly parameters
    elderly_interarrival = NULL,
    elderly_consultation = NULL,
    elderly_transfer = NULL,

    #' @description
    #' Initialise Parameters instance.

    initialize = function(
      adult_interarrival = 5L, adult_consultation = 20L,
      adult_transfer = 0.3, child_interarrival = 7L,
      child_consultation = 15L, child_transfer = 0.2,
      elderly_interarrival = 10L, elderly_consultation = 30L,
      elderly_transfer = 0.5
    ) {
      # Adult parameters
      self$adult_interarrival <- adult_interarrival
      self$adult_consultation <- adult_consultation
      self$adult_transfer <- adult_transfer

      # Child parameters
      self$child_interarrival <- child_interarrival
      self$child_consultation <- child_consultation
      self$child_transfer <- child_transfer

      # Elderly parameters
      self$elderly_interarrival <- elderly_interarrival
      self$elderly_consultation <- elderly_consultation
      self$elderly_transfer <- elderly_transfer
    },

    #' @description
    #' Returns parameters as a named list.
    #'
    #' @return A named list containing all parameter values.

    get_params = function() {
      # Get all non-function fields
      all_names <- ls(self)
      is_not_function <- vapply(
        all_names,
        function(x) !is.function(self[[x]]),
        FUN.VALUE = logical(1L)
      )
      param_names <- all_names[is_not_function]
      mget(param_names, envir = self)
    }
  )
)


# Example usage
base_params <- Parameters$new()
base_params$get_params()
$adult_consultation
[1] 20

$adult_interarrival
[1] 5

$adult_transfer
[1] 0.3

$child_consultation
[1] 15

$child_interarrival
[1] 7

$child_transfer
[1] 0.2

$elderly_consultation
[1] 30

$elderly_interarrival
[1] 10

$elderly_transfer
[1] 0.5

Using multiple functions or classes

Alternatively, parameters can be split into logical groups (e.g., patient type, parameter type), with each group having its own function or class. These groups are then combined into a single parameter set.

For simulations with a large number of parameters, this approach simplifies input management. It also enables validation to be performed for each individual function/class.

Function example

def create_arrivals(adult=5, child=7, elderly=10):
    """
    Generate dictionary of inter-arrival times (minutes).

    Parameters
    ----------
    adult : float
        Time between arrivals for adults.
    child : float
        Time between arrivals for children.
    elderly : float
        Time between arrivals for elderly people.

    Returns
    -------
    Dictionary of inter-arrival times for each patient type.
    """
    return {
        "adult": adult,
        "child": child,
        "elderly": elderly
    }

def create_consultations(adult=20, child=15, elderly=30):
    """
    Generate dictionary of consultation times (minutes).

    Parameters
    ----------
    adult : float
        Consultation duration for adults.
    child : float
        Consultation duration for children.
    elderly : float
        Consultation duration for elderly people.

    Returns
    -------
    Dictionary of consultation times for each patient type.
    """
    return {
        "adult": adult,
        "child": child,
        "elderly": elderly
    }

def create_transfers(adult=0.3, child=0.2, elderly=0.5):
    """
    Generate dictionary of transfer probabilities.

    Parameters
    ----------
    adult : float
        Transfer probability for adults.
    child : float
        Transfer probability for children.
    elderly : float
        Transfer probability for elderly people.

    Returns
    -------
    Dictionary of transfer probabilities for each patient type.
    """
    return {
        "adult": adult,
        "child": child,
        "elderly": elderly
    }

def create_parameters(
    arrivals=None,
    consultations=None,
    transfers=None
):
    """
    Generate complete parameter dictionary for simulation.

    Uses None as default argument, as setting e.g. arrivals=create_arrivals()
    is dangerous, since it creates a single dictionary shared by subsequent
    calls.

    Parameters
    ----------
    arrivals : dict
        Dictionary of inter-arrival times (minutes) for each patient type.
    consultations : dict
        Dictionary of consultation durations (minutes) for each patient type.
    transfers : dict
        Dictionary of transfer probabilities (0-1) for each patient type.

    Returns
    -------
    Nested dictionary with three keys ("arrivals", "consultations",
    "transfers"), each containing a dictionary of parameters.
    """
    # Create the individual dictionaries if none provided
    arrivals = create_arrivals() if arrivals is None else arrivals
    consultations = (
      create_consultations() if consultations is None else consultations)
    transfers = create_transfers() if transfers is None else transfers
    # Create dictionary
    return {
        "arrivals": arrivals,
        "consultations": consultations,
        "transfers": transfers
    }


# Example usage
base_params = create_parameters()
print(base_params)
{'arrivals': {'adult': 5, 'child': 7, 'elderly': 10}, 'consultations': {'adult': 20, 'child': 15, 'elderly': 30}, 'transfers': {'adult': 0.3, 'child': 0.2, 'elderly': 0.5}}

Class example

class Arrivals:  # pylint: disable=too-few-public-methods
    """
    Inter-arrival times (minutes).
    """
    def __init__(self, adult=5, child=7, elderly=10):
        """
        Initialise Arrivals instance.

        Parameters
        ----------
        adult : float
            Time between arrivals for adults.
        child : float
            Time between arrivals for children.
        elderly : float
            Time between arrivals for elderly people.
        """
        self.adult = adult
        self.child = child
        self.elderly = elderly


class Consultations:  # pylint: disable=too-few-public-methods
    """
    Consultation times (minutes).
    """
    def __init__(self, adult=20, child=15, elderly=30):
        """
        Initialise Consultations instance.

        Parameters
        ----------
        adult : float
            Consultation duration for adults.
        child : float
            Consultation duration for children.
        elderly : float
            Consultation duration for elderly people.
        """
        self.adult = adult
        self.child = child
        self.elderly = elderly


class Transfers:  # pylint: disable=too-few-public-methods
    """
    Transfer probabilities (0-1).
    """
    def __init__(self, adult=0.3, child=0.2, elderly=0.5):
        """
        Initialise Transfers instance.

        Parameters
        ----------
        adult : float
            Transfer probability for adults (0-1).
        child : float
            Transfer probability for children (0-1).
        elderly : float
            Transfer probability for elderly people  (0-1).
        """
        self.adult = adult
        self.child = child
        self.elderly = elderly


class Parameters():  # pylint: disable=function-redefined, too-few-public-methods
    """
    Complete parameter class.
    """
    def __init__(
        self,
        arrivals=Arrivals(),
        consultations=Consultations(),
        transfers=Transfers()
    ):
        """
        Initialise Parameters instance.

        Parameters
        ----------
        arrivals : dict
            Class with inter-arrival times (minutes) for each patient type.
        consultations : dict
            Class with consultation durations (minutes) for each patient type.
        transfers : dict
            Class with transfer probabilities (0-1) for each patient type.
        """
        self.arrivals = arrivals
        self.consultations = consultations
        self.transfers = transfers


# Example usage
base_params = Parameters()
print(base_params.arrivals.__dict__)
{'adult': 5, 'child': 7, 'elderly': 10}
print(base_params.consultations.__dict__)
{'adult': 20, 'child': 15, 'elderly': 30}
print(base_params.transfers.__dict__)
{'adult': 0.3, 'child': 0.2, 'elderly': 0.5}

Function example

#' Generate list of inter-arrival times (minutes).
#'
#' @param adult Numeric. Time between adult patient arrivals.
#' @param child Numeric. Time between child patient arrivals.
#' @param elderly Numeric. Time between elderly patient arrivals.
#'
#' @return A named list of inter-arrival times for each patient type.
create_arrivals <- function(adult = 5L, child = 7L, elderly = 10L) {
  list(
    adult = adult,
    child = child,
    elderly = elderly
  )
}

#' Generate list of consultation times (minutes).
#'
#' @param adult Numeric. Consultation duration for adults.
#' @param child Numeric. Consultation duration for children.
#' @param elderly Numeric. Consultation duration for elderly people.
#'
#' @return A named list of consultation times for each patient type.
create_consultations <- function(adult = 20L, child = 15L, elderly = 30L) {
  list(
    adult = adult,
    child = child,
    elderly = elderly
  )
}

#' Generate list of transfer probabilities (0-1).
#'
#' @param adult Numeric. Transfer probability for adults.
#' @param child Numeric. Transfer probability for children.
#' @param elderly Numeric. Transfer probability for elderly people.
#'
#' @return A named list of transfer probabilities for each patient type.
create_transfers <- function(adult = 0.3, child = 0.2, elderly = 0.5) {
  list(
    adult = adult,
    child = child,
    elderly = elderly
  )
}

#' Generate complete parameter list for simulation.
#'
#' @param arrivals List. Named list of inter-arrival times (minutes) for each
#' patient type.
#' @param consultations List. Named list of consultation durations (minutes)
#' for each patient type.
#' @param transfers List. Named list of transfer probabilities (0-1) for each
#' patient type.
#'
#' @return A named list with three keys ("arrivals", "consultations",
#' "transfers"), each containing a list of parameters for each patient type.
create_parameters <- function(
  arrivals = create_arrivals(),
  consultations = create_consultations(),
  transfers = create_transfers()
) {
  list(
    arrivals = arrivals,
    consultations = consultations,
    transfers = transfers
  )
}


# Example usage
base_params <- create_parameters()
base_params
$arrivals
$arrivals$adult
[1] 5

$arrivals$child
[1] 7

$arrivals$elderly
[1] 10


$consultations
$consultations$adult
[1] 20

$consultations$child
[1] 15

$consultations$elderly
[1] 30


$transfers
$transfers$adult
[1] 0.3

$transfers$child
[1] 0.2

$transfers$elderly
[1] 0.5

R6 class example

With modified get_params() method to extract fields from each component class.

#' @title Arrivals class.
#' @description Inter-arrival times (minutes).
#'
#' @field adult Numeric. Time between adult patient arrivals (minutes).
#' @field child Numeric. Time between child patient arrivals (minutes).
#' @field elderly Numeric. Time between elderly patient arrivals (minutes).

Arrivals <- R6Class( # nolint: object_name_linter
  classname = "Arrivals",
  public = list(
    adult = NULL,
    child = NULL,
    elderly = NULL,

    #' @description
    #' Initialise Arrivals instance.

    initialize = function(adult = 5L, child = 7L, elderly = 10L) {
      self$adult <- adult
      self$child <- child
      self$elderly <- elderly
    }
  )
)

#' @title Consultations class.
#' @description Consultation times (minutes).
#'
#' @field adult Numeric. Length of adult patient consultation (minutes).
#' @field child Numeric. Length of child patient consultation (minutes).
#' @field elderly Numeric. Length of elderly patient consultation (minutes).

Consultations <- R6Class( # nolint: object_name_linter
  classname = "Consultations",
  public = list(
    adult = NULL,
    child = NULL,
    elderly = NULL,

    #' @description
    #' Initialise Consultations instance.

    initialize = function(adult = 20L, child = 15L, elderly = 30L) {
      self$adult <- adult
      self$child <- child
      self$elderly <- elderly
    }
  )
)

#' @title Transfers class.
#' @description Transfer probabilities (0-1).
#'
#' @field adult Numeric. Adult patient transfer probability (0-1).
#' @field child Numeric. Child patient transfer probability (0-1).
#' @field elderly Numeric. Elderly patient transfer probability (0-1).

Transfers <- R6Class( # nolint: object_name_linter
  classname = "Transfers",
  public = list(
    adult = NULL,
    child = NULL,
    elderly = NULL,

    #' @description
    #' Initialise Transfers instance.

    initialize = function(adult = 0.3, child = 0.2, elderly = 0.5) {
      self$adult <- adult
      self$child <- child
      self$elderly <- elderly
    }
  )
)

#' @title Parameters class.
#' @description Complete parameter class for simulation.
#'
#' @field arrivals Arrivals. Instance with inter-arrival times for each patient
#' type.
#' @field consultations Consultations. Instance with consultation durations for
#' each patient type.
#' @field transfers Transfers. Instance with transfer probabilities for each
#' patient type.

Parameters <- R6Class( # nolint: object_name_linter
  classname = "Parameters",
  public = list(
    arrivals = NULL,
    consultations = NULL,
    transfers = NULL,

    #' @description
    #' Initialise Parameters instance.

    initialize = function(
      arrivals = Arrivals$new(),
      consultations = Consultations$new(),
      transfers = Transfers$new()
    ) {
      self$arrivals <- arrivals
      self$consultations <- consultations
      self$transfers <- transfers
    },

    #' @description
    #' Returns parameters as a named list.
    #'
    #' @return A named list containing all parameter values organised by type.

    get_params = function() {
      # Get all non-function fields from self
      all_names <- ls(self)
      is_not_function <- vapply(
        all_names,
        function(x) !is.function(self[[x]]),
        FUN.VALUE = logical(1L)
      )
      instance_names <- all_names[is_not_function]

      # Get the instances
      instances <- mget(instance_names, envir = self)

      # Apply parameter extraction to each instance using lapply
      lapply(instances, function(instance) {
        if (inherits(instance, "R6")) {
          # Extract non-function fields from R6 instance
          all_fields <- ls(instance)
          is_not_function <- vapply(
            all_fields,
            function(x) !is.function(instance[[x]]),
            FUN.VALUE = logical(1L)
          )
          field_names <- all_fields[is_not_function]
          mget(field_names, envir = instance)
        } else {
          # Return non-R6 objects as-is
          instance
        }
      })
    }
  )
)


# Example usage
base_params <- Parameters$new()
base_params$get_params()
$arrivals
$arrivals$adult
[1] 5

$arrivals$child
[1] 7

$arrivals$elderly
[1] 10


$consultations
$consultations$adult
[1] 20

$consultations$child
[1] 15

$consultations$elderly
[1] 30


$transfers
$transfers$adult
[1] 0.3

$transfers$child
[1] 0.2

$transfers$elderly
[1] 0.5

๐Ÿงพ Examples

This section contains full code examples for our example conceptual models.

Show/Hide example 1: ๐Ÿฉบ Nurse visit simulation


This example is from simulation/param.py in pydesrap_mms.

"""
Param.
"""

from .simlogger import SimLogger


# pylint: disable=too-many-instance-attributes,too-few-public-methods

class Param:
    """
    Default parameters for simulation.

    Attributes
    ----------
    _initialising : bool
        Whether the object is currently initialising.
    patient_inter : float
        Mean inter-arrival time between patients in minutes.
    mean_n_consult_time : float
        Mean nurse consultation time in minutes.
    number_of_nurses : float
        Number of available nurses.
    warm_up_period : int
        Duration of the warm-up period in minutes.
    data_collection_period : int
        Duration of data collection period in minutes.
    number_of_runs : int
        The number of runs (i.e. replications).
    audit_interval : int
        How frequently to audit resource utilisation, in minutes.
    scenario_name : int|float|str
        Label for the scenario.
    cores : int
        Number of CPU cores to use for parallel execution. For all
        available cores, set to -1. For sequential execution, set to 1.
    logger : logging.Logger
        The logging instance used for logging messages.
    """
    # pylint: disable=too-many-arguments,too-many-positional-arguments
    def __init__(
        self,
        patient_inter=4,
        mean_n_consult_time=10,
        number_of_nurses=5,
        warm_up_period=1440*27,  # 27 days
        data_collection_period=1440*30,  # 30 days
        number_of_runs=31,
        audit_interval=120,  # Every 2 hours
        scenario_name=0,
        cores=-1,
        logger=SimLogger(log_to_console=False, log_to_file=False)
    ):
        """
        Initialise instance of parameters class.

        Parameters
        ----------
        patient_inter : float, optional
            Mean inter-arrival time between patients in minutes.
        mean_n_consult_time : float, optional
            Mean nurse consultation time in minutes.
        number_of_nurses : float, optional
            Number of available nurses.
        warm_up_period : int, optional
            Duration of the warm-up period in minutes.
        data_collection_period : int, optional
            Duration of data collection period in minutes.
        number_of_runs : int, optional
            The number of runs (i.e. replications).
        audit_interval : int, optional
            How frequently to audit resource utilisation, in minutes.
        scenario_name : int|float|str, optional
            Label for the scenario.
        cores : int, optional
            Number of CPU cores to use for parallel execution.
        logger : logging.Logger, optional
            The logging instance used for logging messages.
        """
        # Disable restriction on attribute modification during initialisation
        object.__setattr__(self, "_initialising", True)
        self.patient_inter = patient_inter
        self.mean_n_consult_time = mean_n_consult_time
        self.number_of_nurses = number_of_nurses
        self.warm_up_period = warm_up_period
        self.data_collection_period = data_collection_period
        self.number_of_runs = number_of_runs
        self.audit_interval = audit_interval
        self.scenario_name = scenario_name
        self.cores = cores
        self.logger = logger

        # Re-enable attribute checks after initialisation
        object.__setattr__(self, "_initialising", False)

    def __setattr__(self, name, value):
        """
        Prevent addition of new attributes.

        Parameters
        ----------
        name : str
            The name of the attribute to set.
        value : Any
            The value to assign to the attribute.

        Raises
        ------
        AttributeError
            If `name` is not an existing attribute and an attempt is made
            to add it to the instance.
        """
        # Skip the check if the object is still initialising
        # pylint: disable=maybe-no-member
        if hasattr(self, "_initialising") and self._initialising:
            super().__setattr__(name, value)
        else:
            # Check if attribute of that name is already present
            if name in self.__dict__:
                super().__setattr__(name, value)
            else:
                raise AttributeError(
                    f"Cannot add new attribute '{name}' - only possible to "
                    f"modify existing attributes: {self.__dict__.keys()}"
                )

This example is from R/parameters.R in rdesrap_mms.

If youโ€™re building the nurse M/M/s model: Create a file called parameters.R within your R folder, and copy this code into that file.

#' Create a named list of default model parameters (which can be altered).
#'
#' When input to model(), valid_inputs() will fetch the inputs to this
#' function and compare them against the provided list, to ensure no
#' new keys have been add to the list.
#'
#' @param patient_inter Mean inter-arrival time between patients in minutes.
#' @param mean_n_consult_time Mean nurse consultation time in minutes.
#' @param number_of_nurses Number of available nurses (int).
#' @param warm_up_period Duration of warm-up period in minutes.
#' @param data_collection_period Duration of data collection period in
#' minutes.
#' @param number_of_runs Number of simulation runs (int).
#' @param scenario_name Label for the scenario (int|float|string).
#' @param cores Number of cores to use for parallel execution (int).
#' @param log_to_console Whether to print activity log to console.
#' @param log_to_file Whether to save activity log to file.
#' @param file_path Path to save log to file.
#'
#' @return A named list containing the parameters for the model.
#' @export

parameters <- function(
  patient_inter = 4L,
  mean_n_consult_time = 10L,
  number_of_nurses = 5L,
  warm_up_period = 0L,
  data_collection_period = 80L,
  number_of_runs = 100L,
  scenario_name = NULL,
  cores = 1L,
  log_to_console = FALSE,
  log_to_file = FALSE,
  file_path = NULL
) {
  return(as.list(environment()))
}

Show/Hide example 2: ๐Ÿง  Stroke pathway simulation


This example is from simulation/parameters.py in pydesrap_stroke.

"""
Stroke pathway simulation parameters.

It includes arrival rates, length of stay distributions, and routing
probabilities between different care settings.
"""

import time

from simulation.logging import SimLogger


class RestrictAttributesMeta(type):
    """
    Metaclass for attribute restriction.

    A metaclass modifies class construction. It intercepts instance creation
    via __call__, adding the _initialised flag after __init__ completes. This
    is later used by RestrictAttributes to enforce attribute restrictions.
    """
    def __call__(cls, *args, **kwargs):
        # Create instance using the standard method
        instance = super().__call__(*args, **kwargs)
        # Set the "_initialised" flag to True, marking end of initialisation
        instance.__dict__["_initialised"] = True
        return instance


class RestrictAttributes(metaclass=RestrictAttributesMeta):
    """
    Base class that prevents the addition of new attributes after
    initialisation.

    This class uses RestrictAttributesMeta as its metaclass to implement
    attribute restriction. It allows for safe initialisation of attributes
    during the __init__ method, but prevents the addition of new attributes
    afterwards.

    The restriction is enforced through the custom __setattr__ method, which
    checks if the attribute already exists before allowing assignment.
    """
    def __setattr__(self, name, value):
        """
        Prevent addition of new attributes.

        Parameters
        ----------
        name: str
            The name of the attribute to set.
        value: any
            The value to assign to the attribute.

        Raises
        ------
        AttributeError
            If `name` is not an existing attribute and an attempt is made
            to add it to the class instance.
        """
        # Check if the instance is initialised and the attribute doesn"t exist
        if hasattr(self, "_initialised") and not hasattr(self, name):
            # Get a list of existing attributes for the error message
            existing = ", ".join(self.__dict__.keys())
            raise AttributeError(
                f"Cannot add new attribute '{name}' - only possible to " +
                f"modify existing attributes: {existing}."
            )
        # If checks pass, set the attribute using the standard method
        object.__setattr__(self, name, value)


class ASUArrivals(RestrictAttributes):
    """
    Arrival rates for the acute stroke unit (ASU) by patient type.

    These are the average time intervals (in days) between new admissions.
    For example, a value of 1.2 means a new admission every 1.2 days.
    """
    def __init__(self, stroke=1.2, tia=9.3, neuro=3.6, other=3.2):
        """
        Parameters
        ----------
        stroke: float
            Stroke patient.
        tia: float
            Transient ischaemic attack (TIA) patient.
        neuro: float
            Complex neurological patient.
        other: float
            Other patient types (including medical outliers).
        """
        self.stroke = stroke
        self.tia = tia
        self.neuro = neuro
        self.other = other


class RehabArrivals(RestrictAttributes):
    """
    Arrival rates for the rehabiliation unit by patient type.

    These are the average time intervals (in days) between new admissions.
    For example, a value of 21.8 means a new admission every 21.8 days.
    """
    def __init__(self, stroke=21.8, neuro=31.7, other=28.6):
        """
        Parameters
        ----------
        stroke: float
            Stroke patient.
        neuro: float
            Complex neurological patient.
        other: float
            Other patient types.
        """
        self.stroke = stroke
        self.neuro = neuro
        self.other = other


class ASULOS(RestrictAttributes):
    """
    Mean and standard deviation (SD) of length of stay (LOS) in days in the
    acute stroke unit (ASU) by patient type.

    Attributes
    ----------
    stroke_noesd: dict
        Mean and SD of LOS for stroke patients without early support discharge.
    stroke_esd: dict
        Mean and SD of LOS for stroke patients with early support discharge.
    tia: dict
        Mean and SD of LOS for transient ischemic attack (TIA) patients.
    neuro: dict
        Mean and SD of LOS for complex neurological patients.
    other: dict
        Mean and SD of LOS for other patients.
    """
    def __init__(
        self,
        stroke_no_esd_mean=7.4, stroke_no_esd_sd=8.61,
        stroke_esd_mean=4.6, stroke_esd_sd=4.8,
        stroke_mortality_mean=7.0, stroke_mortality_sd=8.7,
        tia_mean=1.8, tia_sd=2.3,
        neuro_mean=4.0, neuro_sd=5.0,
        other_mean=3.8, other_sd=5.2
    ):
        """
        Parameters
        ----------
        stroke_no_esd_mean: float
            Mean LOS for stroke patients without early support discharge (ESD)
            services.
        stroke_no_esd_sd: float
            SD of LOS for stroke patients without ESD.
        stroke_esd_mean: float
            Mean LOS for stroke patients with ESD.
        stroke_esd_sd: float
            SD of LOS for stroke patients with ESD.
        stroke_mortality_mean: float
            Mean LOS for stroke patients who pass away.
        stroke_mortality_sd: float
            SD of LOS for stroke patients who pass away.
        tia_mean: float
            Mean LOS for TIA patients.
        tia_sd: float
            SD of LOS for TIA patients.
        neuro_mean: float
            Mean LOS for complex neurological patients.
        neuro_sd: float
            SD of LOS for complex neurological patients.
        other_mean: float
            Mean LOS for other patient types.
        other_sd: float
            SD of LOS for other patient types.
        """
        self.stroke_noesd = {
            "mean": stroke_no_esd_mean,
            "sd": stroke_no_esd_sd
        }
        self.stroke_esd = {
            "mean": stroke_esd_mean,
            "sd": stroke_esd_sd
        }
        self.stroke_mortality = {
            "mean": stroke_mortality_mean,
            "sd": stroke_mortality_sd
        }
        self.tia = {
            "mean": tia_mean,
            "sd": tia_sd
        }
        self.neuro = {
            "mean": neuro_mean,
            "sd": neuro_sd
        }
        self.other = {
            "mean": other_mean,
            "sd": other_sd
        }


class RehabLOS(RestrictAttributes):
    """
    Mean and standard deviation (SD) of length of stay (LOS) in days in the
    rehabilitation unit by patient type.

    Attributes
    ----------
    stroke_noesd: dict
        Mean and SD of LOS for stroke patients without early support discharge.
    stroke_esd: dict
        Mean and SD of LOS for stroke patients with early support discharge.
    tia: dict
        Mean and SD of LOS for transient ischemic attack (TIA) patients.
    neuro: dict
        Mean and SD of LOS for complex neurological patients.
    other: dict
        Mean and SD of LOS for other patients.
    """
    def __init__(
        self,
        stroke_no_esd_mean=28.4, stroke_no_esd_sd=27.2,
        stroke_esd_mean=30.3, stroke_esd_sd=23.1,
        tia_mean=18.7, tia_sd=23.5,
        neuro_mean=27.6, neuro_sd=28.4,
        other_mean=16.1, other_sd=14.1
    ):
        """
        Parameters
        ----------
        stroke_no_esd_mean: float
            Mean LOS for stroke patients without early support discharge (ESD)
            services.
        stroke_no_esd_sd: float
            SD of LOS for stroke patients without ESD.
        stroke_esd_mean: float
            Mean LOS for stroke patients with ESD.
        stroke_esd_sd: float
            SD of LOS for stroke patients with ESD.
        tia_mean: float
            Mean LOS for TIA patients.
        tia_sd: float
            SD of LOS for TIA patients.
        neuro_mean: float
            Mean LOS for complex neurological patients.
        neuro_sd: float
            SD of LOS for complex neurological patients.
        other_mean: float
            Mean LOS for other patient types.
        other_sd: float
            SD of LOS for other patient types.
        """
        self.stroke_noesd = {
            "mean": stroke_no_esd_mean,
            "sd": stroke_no_esd_sd
        }
        self.stroke_esd = {
            "mean": stroke_esd_mean,
            "sd": stroke_esd_sd
        }
        self.tia = {
            "mean": tia_mean,
            "sd": tia_sd
        }
        self.neuro = {
            "mean": neuro_mean,
            "sd": neuro_sd
        }
        self.other = {
            "mean": other_mean,
            "sd": other_sd
        }


class ASURouting(RestrictAttributes):
    """
    Probabilities of each patient type being transferred from the acute
    stroke unit (ASU) to other destinations.

    Attributes
    ----------
    stroke: dict
        Routing probabilities for stroke patients.
    tia: dict
        Routing probabilities for transient ischemic attack (TIA) patients.
    neuro: dict
        Routing probabilities for complex neurological patients.
    other: dict
        Routing probabilities for other patients.
    """
    def __init__(
        self,
        # Stroke patients
        stroke_rehab=0.24, stroke_esd=0.13, stroke_other=0.63,
        # TIA patients
        tia_rehab=0.01, tia_esd=0.01, tia_other=0.98,
        # Complex neurological patients
        neuro_rehab=0.11, neuro_esd=0.05, neuro_other=0.84,
        # Other patients
        other_rehab=0.05, other_esd=0.10, other_other=0.85
    ):
        """
        Parameters
        ----------
        stroke_rehab: float
            Stroke patient to rehabilitation unit.
        stroke_esd: float
            Stroke patient to early support discharge (ESD) services.
        stroke_other: float
            Stroke patient to other destinations (e.g., own home, care
            home, mortality).
        tia_rehab: float
            TIA patient to rehabilitation unit.
        tia_esd: float
            TIA patient to ESD.
        tia_other: float
            TIA patient to other destinations.
        neuro_rehab: float
            Complex neurological patient to rehabilitation unit.
        neuro_esd: float
            Complex neurological patient to ESD.
        neuro_other: float
            Complex neurological patient to other destinations.
        other_rehab: float
            Other patient type to rehabilitation unit.
        other_esd: float
            Other patient type to ESD.
        other_other: float
            Other patient type to other destinations.
        """
        self.stroke = {
            "rehab": stroke_rehab,
            "esd": stroke_esd,
            "other": stroke_other
        }
        self.tia = {
            "rehab": tia_rehab,
            "esd": tia_esd,
            "other": tia_other
        }
        self.neuro = {
            "rehab": neuro_rehab,
            "esd": neuro_esd,
            "other": neuro_other
        }
        self.other = {
            "rehab": other_rehab,
            "esd": other_esd,
            "other": other_other
        }


class RehabRouting(RestrictAttributes):
    """
    Probabilities of each patient type being transferred from the rehabiliation
    unit to other destinations.

    Attributes
    ----------
    stroke: dict
        Routing probabilities for stroke patients.
    tia: dict
        Routing probabilities for transient ischemic attack (TIA) patients.
    neuro: dict
        Routing probabilities for complex neurological patients.
    other: dict
        Routing probabilities for other patients.
    """
    def __init__(
        self,
        # Stroke patients
        stroke_esd=0.40, stroke_other=0.60,
        # TIA patients
        tia_esd=0, tia_other=1,
        # Complex neurological patients
        neuro_esd=0.09, neuro_other=0.91,
        # Other patients
        other_esd=0.13, other_other=0.88
    ):
        """
        Parameters
        ----------
        stroke_esd: float
            Stroke patient to early support discharge (ESD) services.
        stroke_other: float
            Stroke patient to other destinations (e.g., own home, care home,
            mortality).
        tia_esd: float
            TIA patient to ESD.
        tia_other: float
            TIA patient to other destinations.
        neuro_esd: float
            Complex neurological patient to ESD.
        neuro_other: float
            Complex neurological patient to other destinations.
        other_esd: float
            Other patient type to ESD.
        other_other: float
            Other patient type to other destinations.
        """
        self.stroke = {
            "esd": stroke_esd,
            "other": stroke_other
        }
        self.tia = {
            "esd": tia_esd,
            "other": tia_other
        }
        self.neuro = {
            "esd": neuro_esd,
            "other": neuro_other
        }
        self.other = {
            "esd": other_esd,
            "other": other_other
        }


class Param(RestrictAttributes):
    """
    Default parameters for simulation.
    """
    def __init__(
        self,
        asu_arrivals=ASUArrivals(),
        rehab_arrivals=RehabArrivals(),
        asu_los=ASULOS(),
        rehab_los=RehabLOS(),
        asu_routing=ASURouting(),
        rehab_routing=RehabRouting(),
        warm_up_period=365*3,  # 3 years
        data_collection_period=365*5,  # 5 years
        number_of_runs=150,
        audit_interval=1,
        cores=1,
        log_to_console=False,
        log_to_file=False,
        log_file_path=("../outputs/logs/" +
                       f"{time.strftime("%Y-%m-%d_%H-%M-%S")}.log")
    ):
        """
        Initialise a parameter set for the simulation.

        Parameters
        ----------
        asu_arrivals: ASUArrivals
            Arrival rates to the acute stroke unit (ASU) in days.
        rehab_arrivals: RehabArrivals
            Arrival rates to the rehabilitation unit in days.
        asu_los: ASULOS
            Length of stay (LOS) distributions for patients in the ASU in days.
        rehab_los: RehabLOS
            LOS distributions for patients in the rehabilitation unit in days.
        asu_routing: ASURouting
            Transfer probabilities from the ASU to other destinations.
        rehab_routing: RehabRouting
            Transfer probabilities from the rehabilitation unit to other
            destinations.
        warm_up_period: int
            Length of the warm-up period.
        data_collection_period: int
            Length of the data collection period.
        number_of_runs: int
            The number of runs (i.e. replications), defining how many times to
            re-run the simulation (with different random numbers).
        audit_interval: float
            Frequency of simulation audits in days.
        cores: int
            Number of CPU cores to use for parallel execution. Set to desired
            number, or to -1 to use all available cores. For sequential
            execution, set to 1.
        log_to_console: boolean
            Whether to print log messages to the console.
        log_to_file: boolean
            Whether to save log to a file.
        log_file_path: str
            Path to save log to file. Note, if you use an existing .log
            file name, it will append to that log.
        """
        # Set parameters
        self.asu_arrivals = asu_arrivals
        self.rehab_arrivals = rehab_arrivals
        self.asu_los = asu_los
        self.rehab_los = rehab_los
        self.asu_routing = asu_routing
        self.rehab_routing = rehab_routing
        self.warm_up_period = warm_up_period
        self.data_collection_period = data_collection_period
        self.number_of_runs = number_of_runs
        self.audit_interval = audit_interval
        self.cores = cores

        # Set up logger
        self.logger = SimLogger(log_to_console=log_to_console,
                                log_to_file=log_to_file,
                                file_path=log_file_path)

    def check_param_validity(self):
        """
        Check the validity of the provided parameters.

        Validates all simulation parameters to ensure they meet requirements:
        - Warm-up period and data collection period must be >= 0
        - Number of runs and audit interval must be > 0
        - Arrival rates must be >= 0
        - Length of stay parameters must be >= 0
        - Routing probabilities must sum to 1 and be between 0 and 1

        Raises
        ------
        ValueError
            If any parameter fails validation with a descriptive error message.
        """
        # Validate parameters that must be >= 0
        for param in ["warm_up_period", "data_collection_period"]:
            self.validate_param(
                param, lambda x: x >= 0,
                "must be greater than or equal to 0")

        # Validate parameters that must be > 0
        for param in ["number_of_runs", "audit_interval"]:
            self.validate_param(
                param, lambda x: x > 0,
                "must be greater than 0")

        # Validate arrival parameters
        for param in ["asu_arrivals", "rehab_arrivals"]:
            self.validate_nested_param(
                param, lambda x: x >= 0,
                "must be greater than 0")

        # Validate length of stay parameters
        for param in ["asu_los", "rehab_los"]:
            self.validate_nested_param(
                param, lambda x: x >= 0,
                "must be greater than 0", nested=True)

        # Validate routing parameters
        for param in ["asu_routing", "rehab_routing"]:
            self.validate_routing(param)

    def validate_param(self, param_name, condition, error_msg):
        """
        Validate a single parameter against a condition.

        Parameters
        ----------
        param_name: str
            Name of the parameter being validated.
        condition: callable
            A function that returns True if the value is valid.
        error_msg: str
            Error message to display if validation fails.

        Raises
        ------
        ValueError:
            If the parameter fails the validation condition.
        """
        value = getattr(self, param_name)
        if not condition(value):
            raise ValueError(
                f"Parameter '{param_name}' {error_msg}, but is: {value}")

    def validate_nested_param(
        self, obj_name, condition, error_msg, nested=False
    ):
        """
        Validate parameters within a nested object structure.

        Parameters
        ----------
        obj_name: str
            Name of the object containing parameters.
        condition: callable
            A function that returns True if the value is valid.
        error_msg: str
            Error message to display if validation fails.
        nested: bool, optional
            If True, validates parameters in a doubly-nested structure. If
            False, validates parameters in a singly-nested structure.

        Raises
        ------
        ValueError:
            If any nested parameter fails the validation condition.
        """
        obj = getattr(self, obj_name)
        for key, value in vars(obj).items():
            if key == "_initialised":
                continue
            if nested:
                for sub_key, sub_value in value.items():
                    if not condition(sub_value):
                        raise ValueError(
                            f"Parameter '{sub_key}' for '{key}' in " +
                            f"'{obj_name}' {error_msg}, but is: {sub_value}")
            else:
                if not condition(value):
                    raise ValueError(
                        f"Parameter '{key}' from '{obj_name}' {error_msg}, " +
                        f"but is: {value}")

    def validate_routing(self, obj_name):
        """
        Validate routing probability parameters.

        Performs two validations:
        1. Checks that all probabilities for each routing option sum to 1.
        2. Checks that individual probabilities are between 0 and 1 inclusive.

        Parameters
        ----------
        obj_name: str
            Name of the routing object.

        Raises
        ------
        ValueError:
            If the probabilities don't sum to 1, or if any probability is
            outside [0,1].
        """
        obj = getattr(self, obj_name)
        for key, value in vars(obj).items():
            if key == "_initialised":
                continue

            # Check that probabilities sum to 1
            # Note: In the article, rehab other is 88% and 13%, so have
            # allowed deviation of 1%
            total_prob = sum(value.values())
            if total_prob < 0.99 or total_prob > 1.01:
                raise ValueError(
                    f"Routing probabilities for '{key}' in '{obj_name}' " +
                    f"should sum to apx. 1 but sum to: {total_prob}")

            # Check that probabilities are between 0 and 1
            for sub_key, sub_value in value.items():
                if sub_value < 0 or sub_value > 1:
                    raise ValueError(
                        f"Parameter '{sub_key}' for '{key}' in '{obj_name}'" +
                        f"must be between 0 and 1, but is: {sub_value}")

This example is from R/parameters.R in rdesrap_stroke.

#' Acute Stroke Unit (ASU) arrival intervals (days).
#'
#' For example, a value of 1.2 means a new admission every 1.2 days.
#'
#' @param stroke Numeric. Mean days between stroke patient arrivals.
#' @param tia Numeric. Mean days between transient ischaemic attack (TIA)
#' patient arrivals.
#' @param neuro Numeric. Mean days between complex neurological patient
#' arrivals.
#' @param other Numeric. Mean days between other patient arrivals.
#'
#' @return A named list of arrival intervals for ASU.
#' @export

create_asu_arrivals <- function(
  stroke = 1.2, tia = 9.3, neuro = 3.6, other = 3.2
) {
  return(as.list(environment()))
}

#' Rehabilitation unit arrival intervals (days).
#'
#' For example, a value of 21.8 means a new admission every 21.8 days.
#'
#' @param stroke Numeric. Mean days between stroke patient arrivals.
#' @param neuro Numeric. Mean days between complex neurological patient
#' arrivals.
#' @param other Numeric. Mean days between other patient arrivals.
#'
#' @return A named list of arrival intervals for rehabilitation unit.
#' @export

create_rehab_arrivals <- function(
  stroke = 21.8, neuro = 31.7, other = 28.6
) {
  return(as.list(environment()))
}

#' Acute Stroke Unit (ASU) length of stay (LOS) distributions (days).
#'
#' Mean and standard deviation (SD) of LOS in days in the ASU.
#'
#' @param stroke_no_esd_mean Numeric. Mean LOS for stroke patients without early
#' supported discharged (ESD).
#' @param stroke_no_esd_sd Numeric. SD LOS for stroke patients without ESD.
#' @param stroke_esd_mean Numeric. Mean LOS for stroke patients with ESD.
#' @param stroke_esd_sd Numeric. SD LOS for stroke patients with ESD.
#' @param stroke_mortality_mean Numeric. Mean LOS for stroke patients who pass
#' away.
#' @param stroke_mortality_sd Numeric. SD LOS for stroke patients who pass
#' away.
#' @param tia_mean Numeric. Mean LOS for transient ischemic attack (TIA)
#' patients.
#' @param tia_sd Numeric. SD LOS for TIA patients.
#' @param neuro_mean Numeric. Mean LOS for complex neurological patients
#' @param neuro_sd Numeric. SD LOS for complex neurological patients
#' @param other_mean Numeric. Mean LOS for other patients.
#' @param other_sd Numeric. SD LOS for other patients.
#'
#' @return A named list of LOS distributions for ASU.
#' @export

create_asu_los <- function(
  stroke_no_esd_mean = 7.4, stroke_no_esd_sd = 8.61,
  stroke_esd_mean = 4.6, stroke_esd_sd = 4.8,
  stroke_mortality_mean = 7.0, stroke_mortality_sd = 8.7,
  tia_mean = 1.8, tia_sd = 2.3,
  neuro_mean = 4.0, neuro_sd = 5.0,
  other_mean = 3.8, other_sd = 5.2
) {
  list(
    stroke_no_esd = list(mean = stroke_no_esd_mean, sd = stroke_no_esd_sd),
    stroke_esd = list(mean = stroke_esd_mean, sd = stroke_esd_sd),
    stroke_mortality = list(mean = stroke_mortality_mean,
                            sd = stroke_mortality_sd),
    tia = list(mean = tia_mean, sd = tia_sd),
    neuro = list(mean = neuro_mean, sd = neuro_sd),
    other = list(mean = other_mean, sd = other_sd)
  )
}

#' Rehabilitation unit length of stay (LOS) distributions (days).
#'
#' @param stroke_no_esd_mean Numeric. Mean LOS for stroke patients without early
#' supported discharged (ESD).
#' @param stroke_no_esd_sd Numeric. SD LOS for stroke patients without ESD.
#' @param stroke_esd_mean Numeric. Mean LOS for stroke patients with ESD.
#' @param stroke_esd_sd Numeric. SD LOS for stroke patients with ESD.
#' @param tia_mean Numeric. Mean LOS for transient ischemic attack (TIA)
#' patients.
#' @param tia_sd Numeric. SD LOS for TIA patients.
#' @param neuro_mean Numeric. Mean LOS for complex neurological patients
#' @param neuro_sd Numeric. SD LOS for complex neurological patients
#' @param other_mean Numeric. Mean LOS for other patients.
#' @param other_sd Numeric. SD LOS for other patients.
#'
#' @return A named list of LOS distributions for rehabilitation unit.
#' @export

create_rehab_los <- function(
  stroke_no_esd_mean = 28.4, stroke_no_esd_sd = 27.2,
  stroke_esd_mean = 30.3, stroke_esd_sd = 23.1,
  tia_mean = 18.7, tia_sd = 23.5,
  neuro_mean = 27.6, neuro_sd = 28.4,
  other_mean = 16.1, other_sd = 14.1
) {
  list(
    stroke_no_esd = list(mean = stroke_no_esd_mean, sd = stroke_no_esd_sd),
    stroke_esd = list(mean = stroke_esd_mean, sd = stroke_esd_sd),
    tia = list(mean = tia_mean, sd = tia_sd),
    neuro = list(mean = neuro_mean, sd = neuro_sd),
    other = list(mean = other_mean, sd = other_sd)
  )
}

#' ASU routing probabilities.
#'
#' Probabilities of each patient type being transferred from the acute
#' stroke unit (ASU) to other destinations.
#'
#' @param stroke_rehab Numeric. Probability stroke patient to rehab.
#' @param stroke_esd Numeric. Probability stroke patient to early supported
#' discharge (ESD) services.
#' @param stroke_other Numeric. Probability stroke patient to other
#' destinations (e.g., own home, care home, mortality).
#' @param tia_rehab Numeric. Probability transient ischemic attack (TIA)
#' patient to rehab.
#' @param tia_esd Numeric. Probability TIA patient to ESD.
#' @param tia_other Numeric. Probability TIA patient to other.
#' @param neuro_rehab Numeric. Probability complex neurological patient to
#' rehab.
#' @param neuro_esd Numeric. Probability complex neurological patient to ESD.
#' @param neuro_other Numeric. Probability complex neurological patient to
#' other.
#' @param other_rehab Numeric. Probability other patient to rehab.
#' @param other_esd Numeric. Probability other patient to ESD.
#' @param other_other Numeric. Probability other patient to other.
#'
#' @return A named list of routing probabilities for ASU.
#' @export

create_asu_routing <- function(
  stroke_rehab = 0.24, stroke_esd = 0.13, stroke_other = 0.63,
  tia_rehab = 0.01, tia_esd = 0.01, tia_other = 0.98,
  neuro_rehab = 0.11, neuro_esd = 0.05, neuro_other = 0.84,
  other_rehab = 0.05, other_esd = 0.10, other_other = 0.85
) {
  list(
    stroke = list(rehab = stroke_rehab, esd = stroke_esd, other = stroke_other),
    tia = list(rehab = tia_rehab, esd = tia_esd, other = tia_other),
    neuro = list(rehab = neuro_rehab, esd = neuro_esd, other = neuro_other),
    other = list(rehab = other_rehab, esd = other_esd, other = other_other)
  )
}

#' Rehabilitation unit routing probabilities.
#'
#' Probabilities of each patient type being transferred from the rehabilitation
#' unit to other destinations.
#'
#' @param stroke_esd Numeric. Probability stroke patient to early supported
#' discharge (ESD) services.
#' @param stroke_other Numeric. Probability stroke patient to other
#' destinations (e.g., own home, care home, mortality).
#' @param tia_esd Numeric. Probability transient ischemic attack (TIA) patient
#' to ESD.
#' @param tia_other Numeric. Probability TIA patient to other.
#' @param neuro_esd Numeric. Probability complex neurological patient to ESD.
#' @param neuro_other Numeric. Probability complex neurological patient to
#' other.
#' @param other_esd Numeric. Probability other patient to ESD.
#' @param other_other Numeric. Probability other patient to other.
#'
#' @return A named list of routing probabilities for rehabilitation unit.
#' @export

create_rehab_routing <- function(
  stroke_esd = 0.40, stroke_other = 0.60,
  tia_esd = 0L, tia_other = 1L,
  neuro_esd = 0.09, neuro_other = 0.91,
  other_esd = 0.13, other_other = 0.88
) {
  list(
    stroke = list(esd = stroke_esd, other = stroke_other),
    tia = list(esd = tia_esd, other = tia_other),
    neuro = list(esd = neuro_esd, other = neuro_other),
    other = list(esd = other_esd, other = other_other)
  )
}

#' Generate complete parameter list for simulation.
#'
#' @param asu_arrivals List. Acute stroke unit (ASU) arrival intervals.
#' @param rehab_arrivals List. Rehabilitation unit arrival intervals.
#' @param asu_los List. ASU length of stay (LOS) distributions.
#' @param rehab_los List. Rehabilitation unit LOS distributions.
#' @param asu_routing List. ASU routing probabilities.
#' @param rehab_routing List. Rehabilitation unit routing probabilities.
#' @param warm_up_period Integer. Length of warm-up period (days).
#' @param data_collection_period Integer. Length of data collection period
#' (days).
#' @param number_of_runs Integer. Number of simulation runs.
#' @param scenario_name Label for scenario (int|float|string).
#' @param cores Integer. Number of CPU cores to use.
#' @param log_to_console Whether to print activity log to console.
#' @param log_to_file Whether to save activity log to file.
#' @param file_path Path to save log to file.
#'
#' @return A named list of all simulation parameters.
#' @export

create_parameters <- function(
  asu_arrivals = create_asu_arrivals(),
  rehab_arrivals = create_rehab_arrivals(),
  asu_los = create_asu_los(),
  rehab_los = create_rehab_los(),
  asu_routing = create_asu_routing(),
  rehab_routing = create_rehab_routing(),
  warm_up_period = 365L * 3L,  # 3 years
  data_collection_period = 365L * 5L,  # 5 years
  number_of_runs = 150L,
  scenario_name = NULL,
  cores = 1L,
  log_to_console = FALSE,
  log_to_file = FALSE,
  file_path = NULL
) {
  return(as.list(environment()))
}