A module is a group of genes which, to some extent, shows the same expression behaviour. Several modules are connected together such that one or more genes from one module will regulate the expression of another module. By creating chains of modules, a dynamic behaviour in gene regulation can be created.

backbone(module_info, module_network, expression_patterns)



A tibble containing meta information on the modules themselves.

  • module_id (character): the name of the module

  • basal (numeric): basal expression level of genes in this module, must be between [0, 1]

  • burn (logical): whether or not outgoing edges of this module will be active during the burn in phase

  • independence (numeric): the independence factor between regulators of this module, must be between [0, 1]


A tibble describing which modules regulate which other modules.

  • from (character): the regulating module

  • to (character): the target module

  • effect (integer): 1L if the regulating module upregulates the target module, -1L if it downregulates

  • strength (numeric): the strength of the interaction

  • hill (numeric): hill coefficient, larger than 1 for positive cooperativity, between 0 and 1 for negative cooperativity


A tibble describing the expected expression pattern changes when a cell is simulated by dyngen. Each row represents one transition between two cell states.

  • from (character): name of a cell state

  • to (character): name of a cell state

  • module_progression (character): differences in module expression between the two states. Example: "+4,-1|+9|-4" means the expression of module 4 will go up at the same time as module 1 goes down; afterwards module 9 expression will go up, and afterwards module 4 expression will go down again.

  • start (logical): Whether or not this from cell state is the start of the trajectory

  • burn (logical): Whether these cell states are part of the burn in phase. Cells will not get sampled from these cell states.

  • time (numeric): The duration of an transition.


A dyngen backbone.

See also

dyngen on how to run a dyngen simulation


backbone <- backbone(
  module_info = tribble(
    ~module_id, ~basal, ~burn, ~independence,
    "M1",       1,      TRUE,  1,
    "M2",       0,      FALSE, 1,
    "M3",       0,      FALSE, 1
  module_network = tribble(
    ~from, ~to,  ~effect, ~strength, ~hill,
    "M1",  "M2", 1L,      1,         2,
    "M2",  "M3", 1L,      1,         2
  expression_patterns = tribble(
    ~from, ~to,  ~module_progression, ~start, ~burn, ~time,
    "s0",  "s1", "+M1",               TRUE,   TRUE,  30,
    "s1",  "s2", "+M2,+M3",           FALSE,  FALSE, 80