dyngen (version 1.0.5)

bblego: Design your own custom backbone easily

Description

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.

Usage

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)
)

Value

A dyngen backbone.

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.

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)
)