Team:Evry/Model/Dynamic/Circuit
Dynamic Regulation
Dynamic circuit
Living systems are problem-solving systems. Multidisciplinary field of Synthetic Biology is trying to develop scalable platforms to engineer biological systems enabling sophisticated sense-and-respond behaviors vastly more efficient, safe, understandable, and predictable. Due to the deep similarities between living cellular modules and electronic parts, biological electronic-like circuits have been developed during the past ten years as main tool in order to design novel biological parts and process information in living cells [1]. Practical applications of biological electronic-like circuits include biosensors for pollutant detection and degradation, biosensors for medical diagnostic, smart therapeutics enabling sensing and regulation of drug delivery, and dynamic regulation in metabolic engineering.
Information processing in living cells involves integrating multiple input signals, performing computations on these signals, storing information in memory, and actuating outputs, as how electrical circuits accomplish. Most circuits take as input small molecules, which are used to activate or inhibit genes expression via riboswitches or transcription factors. Just considering progress made in the last two years, signal processing in biological systems can now rely on elements such as logic gates, load drivers, memory systems, amplifiers, coupling systems or bow-tie architectures, to name a few.
At the cellular level, biochemical pathways can be modeled as electrical circuits where signals are produced, propagated and consumed with the following equivalents [2]: (i) mass flux as electric current, (ii) concentration as voltage, (iii) stoichiometric conservation as Kirchhoff’s voltage law, and (iv) mass conservation as Kirchhoff’s current law. Additionally, the deep similarity between the Boltzmann thermodynamic equations that describe noisy electronic current flow in sub-threshold transistors and noisy molecular flux in biochemical reactions has been used to map analog circuit motifs in electronics to analog circuit motifs in cells and vice versa [3]. For instance, the increase in gate voltage in a transistor (which lowers energy barriers and increases current flow) is analogous to the increases of enzyme/catalyst concentration in a metabolic reaction (which increases reaction rates).
In our project, the aim of electrical circuits-like modeling was to integrate metabolic and gene expression levels in order to obtain a profound sight on our production pathway, considering the pathway tightly connected into the cell metabolism and more importantly cell gene expression and regulation network. In the electronic, possessing the differential equation of many kind of the systems (an electrical chip, a string or a biochemical reaction or regulation), enables one to model the system in a circuit schema. Then, the circuit is solved to study or optimize the system.
Here we presented the first electrical circuit modelling of the dynamic regulation in the metabolic engineering in the iGEM. Our approach can be applied in order to design regulating system applying biosensors (Using the tool from [5]) and making synthetic feedback loops sophisticating and optimizing the processes in the metabolic engineering.
Figure 1. Electrical circuit interpretation of the designed dynamic regulation system.
The first effort was to interpret the dynamic regulation circuit in an electrical circuit language (Figure 1. Derived from dynamic regulation map, the annotations are based on the equations which have been represented in the table). Because we did not have any electrical engineer in our team, we confine ourselves in extracting the differential equation (see the equations) of the evolution of each component from dynamic regulation map and solving them using Python (see the code). Figure 2. illustrates the dynamic behaviour of each component proportional to the time. The mathematical method used for extracting the dynamic equations is from Brian Ingalls lab, University of Waterloo [4].
Figure 2. Output of the Python code solving the equations. (A) The red curve associated with evolution of PLA indicates that the network maximizes the PLA. (B) Increasing the time range of the solution confirms the stability of the all components of the system after a period of time, while PLA is still increasing.
Figure 2. demonstrates that evolution of the PLA (red curve) increases while all the other components reach a balance after a period of time. Even though we used approximation for the value of all the constants (Ki , di …), we achieved an expected curve equilibrating the enzymes and metabolites as well as maximizing the PLA production. This astonishing results obviously suggest that, natural behaviour of each part is dramatically more important than the value of each enzymatic, interaction or regulation (thermodynamic and kinetic constants). However, in order to model the circuits more precisely, and include more details, the necessity of associating the exact values is unavoidable. Nowadays, there are many computational and practical methods for measuring these constants. It must be emphasized that, using electrical circuit modelling, one will consider more details such as gain, delay, amplification and even memory, along with applying different electronic equivalents as mentioned before.
Equations
Part 1
Part 2
| Abbreviations and Constants | Description |
|---|---|
| Pyr ↔ Pyruvate | |
| Lac ↔ Lactate | |
| LacCoA ↔ Lactyl-CoA | |
| mRNA_Ei ↔ mRNA of the enzyme Ei | |
| apoLldR | free LldR |
| aloLldR | LldR bound to the Ligand (Lactate) |
| di | degradation constants of mRNAs and proteins |
| β / (1 + [McbR]^n1) | Kinetics of repressed gene transcription by McbR (and n1 are constants) |
| α / (1 + [aloLldR]^n2) | Kinetics of activated gene transcription by LldR ( and n2 are constants) |
| Ki | Thermodynamic constant of the reactions, first-order (translation of mRNA) or second-order reaction |
| Kcat /Km | Kinetic constants of the enzymes |
Python code
@author: Clément
Nonlinear problem solving using Euler method
for biological engineering purpose
"""
# in the current program, dX will be the derivate
# of the concentration of X over time
#defining of the global constants
Kcat1=1
Km1=1
K=1
K1=1
K2=1
K3=1
K4=1
K5=1
K_1=1
Kcat2=1
Km2=1
Km3=1
Kcat3=1
d1=1
d2=1
d3=1
d4=1
d5=1
d6=1
d7=1
d8=1
n_1=1
n_2=1
beta=1
alpha=1
#defining the basic functions on which the Euler method will be applied
#dX must be understood as "the derivate of the concentration of X over time"
# pyruvate
def dpyr (t,E1,pyr,Glu):
dpyr = -Kcat1*E1*pyr/(Km1+pyr)+K*Glu
return (dpyr)
# lactate
def dlactate (t,E1,E2,pyr,lactate,apoLldR,aloLldr):
dlactate = Kcat1*E1*pyr/(Km1+pyr)-K1*lactate*apoLldR+K_1*aloLldr -Kcat2*E2*lactate/(Km2+lactate)
return (dlactate)
def dlactylCoa (t,E2,E3,lactate,lactylCoa):
dlactylCoa = Kcat2*E2*lactate/(Km2+lactate)-Kcat3*E3*lactylCoa/(Km3+lactylCoa)
return (dlactylCoa)
# PolyLacticAcid
def dPLA (t,E3,lactylCoa):
dPLA = Kcat3*E3*lactylCoa/(Km3+lactylCoa)
return (dPLA)
# Messenger RNA of the E1 enzyme
def dmRNA_E1 (t,repressor,mRNA_E1):
dmRNA_E1 = beta/(1+repressor**n_1)-d1*mRNA_E1
return (dmRNA_E1)
# Messenger RNA of the E2 enzyme
def dmRNA_E2 (t,aloLldR,mRNA_E2):
dmRNA_E2 = alpha/(1+aloLldR**n_2)-d2*mRNA_E2
return (dmRNA_E2)
# Messenger RNA of the E3 enzyme
def dmRNA_E3 (t,aloLldR,mRNA_E3):
dmRNA_E3 = alpha/(1+aloLldR**n_2)-d3*mRNA_E3
return (dmRNA_E3)
# Messenger RNA of the Repressor
def dmRNA_Repressor (t,aloLldR,mRNA_Repressor):
dmRNA_Repressor = alpha/(1+aloLldR**n_2)-d4*mRNA_Repressor
return (dmRNA_Repressor)
# Repressor
def drepressor (t,mRNA_Repressor,repressor):
drepressor = K2*mRNA_Repressor-d5*repressor
return (drepressor)
#
def dapoLldR (t,apoLldR,lactate):
dapoLldR = -K1*apoLldR*lactate+K_1*al
oLldR
return (dapoLldR)
#
def daloLldR (t,apoLldR,lactate):
daloLldR = K1*apoLldR*lactate-K_1*aloLldR
return (daloLldR)
#
def dE1 (t,E1,mRNA_E1):
dE1 = K3*mRNA_E1-d6*E1
return (dE1)
#
def dE2 (t,E2,mRNA_E2):
dE2 = K4*mRNA_E2-d7*E2
return (dE2)
#
def dE3 (t,E3,mRNA_E3):
dE3 = K5*mRNA_E3-d8*E3
return (dE3)
#importing a library allowing of the application of plotting function
import matplotlib.pyplot as plt
#defining the Euler method function and its variables
# t0 = start time of the simulation
# tf = end time of the simulation
# Glu0 = concentration of Glucose (considered as constant in this simulation)
# n = resolution of the simulation
# N.B: curves will not match with a realistic experiment if "n" is taken
#too small but the program will be too memory consuming if taken too big
def Euler(dE1,dE2,dE3,dmRNA_E1,dmRNA_E2,dmRNA_E3,dmRNA_Repressor,dpyr,
dlactate,dlactylCoa,drepressor,daloLldR,dapoLldR,dPLA,t0,tf,Glu0,n) :
#initialising variables
t=t0
Glu=Glu0
E1,E2,E3=1,1,1
mRNA_E1,mRNA_E2,mRNA_E3,pyr,lactate,lactylCoa,PLA,mRNA_Repressor,repressor,apoLldR,aloLldR=0,0,0,0,0,0,0,0,0,0,0
#slicing time in n parts. For each part, the evolution of derivate will be
# considered as null
h=(tf-t0)/float(n)
#creating a list of the time stamps (used as absciss for plotting the curves)
temps=[t0]
#introducing lists that will store the consecutive values of the concentrations
# for each of the products
LE1=[1]
LE2=[1]
LE3=[1]
LmRNA_E1=[0]
LmRNA_E2=[0]
LmRNA_E3=[0]
Lpyr=[0]
Llactate=[0]
LlactylCoa=[0]
LPLA=[0]
LmRNA_Repressor=[0]
Lrepressor=[0]
LapoLldR=[0]
LaloLldR=[0]
#Starting of the real simulation:
#runs n times the computation
for i in range(n) :
# "+=" means increment, X will take the value of X+h*dX
# where "h" is the little "time slice" on which dX is
# considered as the constant
pyr += h*dpyr (t,E1,pyr,Glu)
lactate += h*dlactate (t,E1,E2,pyr,lactate,apoLldR,aloLldR)
lactylCoa += h*dlactylCoa (t,E2,E3,lactate,lactylCoa)
PLA += h*dPLA (t,E3,lactylCoa)
mRNA_E1 += h*dmRNA_E1 (t,repressor,mRNA_E1)
mRNA_E2 += h*dmRNA_E2 (t,aloLldR,mRNA_E2)
mRNA_E3 += h*dmRNA_E3 (t,aloLldR,mRNA_E3)
mRNA_Repressor += h*drepressor (t,mRNA_Repressor,repressor)
repressor += h*drepressor (t,mRNA_Repressor,repressor)
apoLldR += h*dapoLldR (t,apoLldR,lactate)
aloLldR += h*daloLldR (t,apoLldR,lactate)
E1 += h*dE1 (t,E1,mRNA_E1)
E2 += h*dE2 (t,E2,mRNA_E2)
E3 += h*dE3 (t,E3,mRNA_E3)
#storing current time value in the "time-list"
temps.append(t)
# storing concentration values in each dedicated list
LE1.append(E1)
LE2.append(E2)
LE3.append(E3)
LmRNA_E1.append(mRNA_E1)
LmRNA_E2.append(mRNA_E2)
LmRNA_E3.append(mRNA_E3)
Lpyr.append(pyr)
Llactate.append(lactate)
LlactylCoa.append(lactylCoa)
LPLA.append(PLA)
LmRNA_Repressor.append(mRNA_Repressor)
Lrepressor.append(repressor)
LapoLldR.append(apoLldR)
LaloLldR.append(aloLldR)
#increasing time by adding "h" for the next run
t+=h
#plotting all the curves
# if you want to see selected curves (not all of them),
# you just have to put a "#" before the curves you don't want to see
plt.plot(temps,LE1)
plt.plot(temps,LE2)
plt.plot(temps,LE3)
plt.plot(temps,LmRNA_E1)
plt.plot(temps,LmRNA_E2)
plt.plot(temps,LmRNA_E3)
plt.plot(temps,Lpyr)
plt.plot(temps,Llactate)
plt.plot(temps,LlactylCoa)
plt.plot(temps,LPLA)
plt.plot(temps,LmRNA_Repressor)
plt.plot(temps,Lrepressor)
plt.plot(temps,LapoLldR)
plt.plot(temps,LaloLldR)
""" USER GUIDE:
to run the simulation, just copy and paste the following line
Euler(dE1,dE2,dE3,dmRNA_E1,dmRNA_E2,dmRNA_E3,dmRNA_Repressor,dpyr,dlactate,
dlactylCoa,drepressor,daloLldR,dapoLldR,dPLA,t0,tf,Glu0,n)
in the console, making sure you choose values for "t0", "tf", "Glu" and "n"
"""
References
- Brophy, J.A. and C.A. Voigt, Principles of genetic circuit design. Nat Methods, 2014. 11(5): 508-20.
- May, E.E. and R.L. Schiek, BioXyce: an engineering platform for the study of cellular systems. IET Syst Biol, 2009. 3(2): 77-89.
- Sarpeshkar, R., Analog synthetic biology. Philos Trans A Math Phys Eng Sci, 2014. 372(2012): p. 20130110.
- Brian Ingalls, from University of Waterloo. Website: https://uwaterloo.ca/applied-mathematics/people-profiles/brian-ingalls (10/10/2016)
- Delépine, Baudoin, et al. "SensiPath: computer-aided design of sensing-enabling metabolic pathways." Nucleic acids research (2016): gkw305.
Feel free to contact us!