You can use the bblego functions in order to create custom backbones using various components. Please note that the bblego functions currently only allow you to create tree-like backbones.

bblego(..., .list = NULL)

bblego_linear(
  from,
  to,
  type = sample(c("simple", "doublerep1", "doublerep2"), 1),
  num_modules = sample(4:6, 1),
  burn = FALSE
)

bblego_branching(
  from,
  to,
  type = "simple",
  num_steps = 3,
  num_modules = 2 + length(to) * (3 + num_steps),
  burn = FALSE
)

bblego_start(
  to,
  type = sample(c("simple", "doublerep1", "doublerep2"), 1),
  num_modules = sample(4:6, 1)
)

bblego_end(
  from,
  type = sample(c("simple", "doublerep1", "doublerep2"), 1),
  num_modules = sample(4:6, 1)
)

Arguments

..., .list

bblego components, either as separate args or as a list.

from

The begin state of this component.

to

The end state of this component.

type

Some components have alternative module regulatory networks.

bblego_start(), bblego_linear(), bblego_end():

  • "simple": a sequence of modules in which every module upregulates the next module.

  • "doublerep1": a sequence of modules in which every module downregulates the next module, and each module has positive basal expression.

  • "doublerep2": a sequence of modules in which every module upregulates the next module, but downregulates the one after that.

  • "flipflop": a sequence of modules in which every module upregulates the next module. In addition, the last module upregulates itself and strongly downregulates the first module.

bblego_branching():

  • "simple": a set of n modules (with n = length(to)) which all downregulate one another and upregulate themselves. This causes a branching to occur in the trajectory.

num_modules

The number of modules this component is allowed to use. Various components might require a minimum number of components in order to work properly.

burn

Whether or not these components are part of the warm-up simulation.

num_steps

The number of branching steps to reduce the odds of double positive cells occurring.

Value

A dyngen backbone.

Details

A backbone always needs to start with a single bblego_start() state and needs to end with one or more bblego_end() states. The order of the mentioned states needs to be such that a state is never specified in the first argument (except for bblego_start()) before having been specified as the second argument.

Examples

backbone <- bblego( bblego_start("A", type = "simple", num_modules = 2), bblego_linear("A", "B", type = "simple", num_modules = 3), bblego_branching("B", c("C", "D"), type = "simple", num_steps = 3), bblego_end("C", type = "flipflop", num_modules = 4), bblego_end("D", type = "doublerep1", num_modules = 7) )