vivarium.processes.ode_expression module

Ordinary Differential Equation Expression Model

class vivarium.processes.ode_expression.ODE_expression(parameters=None)

Bases: vivarium.core.process.Process

Models gene expression using ordinary differential equations

This process class models the rates of transcription, translation, and degradation using ordinary differential equations (ODEs). These ODEs are as follows:

• Transcription: \(\frac{dM}{dt} = k_M - d_M M\)

  • \(M\): Concentration of mRNA

  • \(k_M\): Trancription rate

  • \(d_M\): Degradation rate

• Translation: \(\frac{dP}{dt} = k_P m_P - d_P P\)

  • \(P\): Concentration of protein

  • \(m_P\): Concentration of transcript

  • \(k_P\): Translation rate

  • \(d_P\): Degradation rate

The transcription rate abstracts over factors that include gene copy number, RNA polymerase abundance, promoter strengths, and nucleotide availability. The translation rate similarly abstracts over factors that include ribosome availability, the binding strength of the mRNA to the ribosome, the availability of tRNAs, and the availability of free amino acids.

This process class also models genetic regulation with boolean logic statements. This restricts us to modeling binary regulation: reactions can be completely suppressed, but they cannot be only slowed. For example, we can model a statement like:

If \([glucose] > 0.1\), completely inhibit LacY expression.

But we cannot model a statement like this:

If \([glucose] > 0.1\), reduce LacY expression by 50%.

Note

This model does not include:

• Kinetic regulation

• Cooperativity

• Autoinhibition

• Autoactivation

Ports:

• internal: Expects a store with all of the transcripts and proteins being modeled. This store should also include any internal regulators.

• external: Expects a store with all external regulators. These variables are not updated; they are only read.

Parameters

initial_parameters –

A dictionary of configuration options. The following configuration options may be provided:

• transcription_rates (dict): Maps transcript names (the keys of the dict) to transcription rates (values of the dict).

• translation_rates (dict): Maps protein names (the keys of the dict) to translation rates (the values of the dict).

• degradation_rates (dict): Maps from names of substrates (transcripts or proteins) to degrade to their degradation rates.

• protein_map (dict): Maps from protein name to transcript name for each transcript-protein pair.

• initial_state (dict): Maps from port names to the initial state of that port. Each initial state is specified as a dictionary with variable names as keys and variable values as values.

• regulators (list): List of the molecules that regulate any of the modeled transcription or translation reactions. Each molecule is a tuple of the port and the molecule’s variable name.

• regulation (dict): Maps from reaction product (transcript or protein) name to a boolean regulation statement. For example, to only transcribe lacy_RNA if external glc__D_e concentration is at most 0.1, we would pass:

  {'lacy_RNA': 'if not (external, glc__D_e) > 0.1'}
  

Example instantiation of a process modeling LacY expression:

>>> initial_state = {
...     'internal': {
...         'lacy_RNA': 0.0,
...         'LacY': 0.0,
...     },
...     'external': {
...         'glc__D_e': 2.0,
...     }
... }
>>> config = {
...     'transcription_rates': {
...         'lacy_RNA': 3.0,
...     },
...     'translation_rates': {
...         'LacY': 4.0,
...     },
...     'degradation_rates': {
...         'lacy_RNA': 1.0,
...         'LacY': 0.0,
...     },
...     'protein_map': {
...         'LacY': 'lacy_RNA',
...     },
...     'initial_state': initial_state,
...     'regulators': [('external', 'glc__D_e')],
...     'regulation': {
...         'lacy_RNA': 'if (external, glc__D_e) > 1.0',
...     },
... }
>>> expression_process = ODE_expression(config)
>>> state = expression_process.default_state()
>>> state == initial_state
True
>>> # When external glc__D_e present, no transcription
>>> expression_process.next_update(1, state)
{'internal': {'lacy_RNA': 0.0, 'LacY': 0.0}}
>>> # But translation and degradation still occur
>>> state['internal']['lacy_RNA'] = 1.0
>>> expression_process.next_update(1, state)
{'internal': {'lacy_RNA': -1.0, 'LacY': 4.0}}
>>> # When external glc__D_e low, LacY transcribed
>>> state['external']['glc__D_e'] = 0.5
>>> expression_process.next_update(1, state)
{'internal': {'lacy_RNA': 2.0, 'LacY': 4.0}}

defaults = {'counts_deriver_key': 'expression_counts', 'degradation_rates': {}, 'initial_state': {}, 'protein_map': {}, 'regulation': {}, 'regulators': [], 'time_step': 1.0, 'transcription_leak': {'magnitude': 0.0, 'rate': 0.0}, 'transcription_rates': {}, 'translation_rates': {}}

derivers()

name = 'ode_expression'

next_update(timestep, states)

ports_schema()

vivarium.processes.ode_expression.get_flagella_expression()

Flagella ODE expresion configuration

This configuration can be passed to ODE_expression like this:

>>> config = get_flagella_expression()
>>> expression_process = ODE_expression(config)

vivarium.processes.ode_expression.get_lacy_config()

LacY ODE expresion configuration

This configuration can be passed to ODE_expression like this:

>>> config = get_lacy_config()
>>> expression_process = ODE_expression(config)

vivarium.processes.ode_expression.test_expression(config={'degradation_rates': {'LacY': 3e-05, 'lacy_RNA': 0.003}, 'initial_state': {'external': {'glc__D_e': 8.0, 'lcts_e': 8.0}, 'internal': {'LacY': 0.0, 'lacy_RNA': 0.0}}, 'protein_map': {'LacY': 'lacy_RNA'}, 'regulation': {'lacy_RNA': 'if (external, glc__D_e) > 0.1 and (internal, lcts_p) < 0.01'}, 'regulators': [('external', 'glc__D_e'), ('internal', 'lcts_p')], 'transcription_leak': {'magnitude': 1e-06, 'rate': 0.0001}, 'transcription_rates': {'lacy_RNA': 1e-07}, 'translation_rates': {'LacY': 0.005}}, timeline=[(100, {})])