adds some equilibrium based rate laws

docs/Reactions.rst

@@ -153,6 +153,30 @@ BiBi Pingpong Rev
 .. autoclass:: kinetics.BiBi_Pingpong_rev
 
 
+Equilibrium based reversible Michaelis-Menten kinetics
+------------------------------------------------------
+
+BiBi Ordered rev eq
+~~~~~~~~~~~~~~~~~
+
+.. autoclass:: kinetics.BiBi_Ordered_rev_eq
+
+UniUni Ordered rev eq
+~~~~~~~~~~~~~~~~~
+
+.. autoclass:: kinetics.UniUni_rev_eq
+
+
+Equilibrium based mass action
+------------------------------------------------------
+
+UniUni Ordered rev eq
+~~~~~~~~~~~~~~~~~
+
+.. autoclass:: kinetics.UniUni_rev_eq
+
+
+
 Modifiers of Michaelis-Menten kinetics eg for Inhibition
 --------------------------------------------------------
 Modifications to rate equations for things like competitive inhibition can applied as follows:

kinetics/__init__.py

@@ -5,6 +5,8 @@
 from kinetics.reaction_classes.mass_transfer import *
 from kinetics.reaction_classes.michaelis_menton_modifiers import *
 from kinetics.reaction_classes.reversible_michaelis_menton import *
+from kinetics.reaction_classes.equilibrium_mass_action import *
+from kinetics.reaction_classes.equilibrium_reversible_mechaelis_menton import *
 from kinetics.reaction_classes.reaction_base_class import Reaction
 
 from kinetics.optimisation.metrics import Metrics, uM_to_mgml

kinetics/reaction_classes/equilibrium_mass_action.py

@@ -0,0 +1,33 @@
+from kinetics.reaction_classes.reaction_base_class import Reaction
+
+
+class Uni_mass_action_eq(kinetics.Reaction):
+
+    def __init__(self,
+                 keq=None, kf=None,
+                 a='', p='',
+                 substrates=[], products=[]):
+
+        super().__init__()
+
+        self.parameter_names=[keq, kf]
+        self.reaction_substrate_names = [a, p]
+        self.substrates = substrates
+        self.products = products
+
+    def calculate_rate(self, substrates, parameters):
+
+        # Substrates
+        a = substrates[0]
+        p = substrates[1]
+
+        # Parameters
+        keq = parameters[0]
+        kf = parameters[1]
+
+        fwd = kf*a
+        rev = (kf/keq)*p
+
+        rate = fwd-rev
+
+        return rate

kinetics/reaction_classes/equilibrium_reversible_mechaelis_menton.py

@@ -0,0 +1,85 @@
+from kinetics.reaction_classes.reaction_base_class import Reaction
+
+class BiBi_Ordered_rev_eq(kinetics.Reaction):
+
+    def __init__(self,
+                 keq=None,
+                 kcatf=None, kcatr=None,
+                 kma=None, kmb=None, kmp=None, kmq=None,
+                 kib=None, kip=None, kia=None,
+                 a='', b='', p='', q='', enz='',
+                 substrates=[], products=[]):
+
+        super().__init__()
+
+        self.parameter_names = [keq, kcatf, kcatr, kma, kmb, kmp, kmq, kia, kib, kip]
+        self.reaction_substrate_names = [a, b, p, q, enz]
+        self.substrates = substrates
+        self.products = products
+
+    def calculate_rate(self, substrates, parameters):
+
+        # Substrates
+        a = substrates[0]
+        b = substrates[1]
+        p = substrates[2]
+        q = substrates[3]
+        enz = substrates[4]
+
+        # Parameters
+        keq = parameters[0]
+        kcatf = parameters[1]
+        kcatr = parameters[2]
+        kma = parameters[3]
+        kmb = parameters[4]
+        kmp = parameters[5]
+        kmq = parameters[6]
+        kia = parameters[7]
+        kib = parameters[8]
+        kip = parameters[9]
+
+
+        Vf = kcatf*enz
+        Vr = kcatr*enz
+
+        num = Vf*(a*b-((p*q)/keq))
+
+        den1 = a*b*(1+p/kip)
+        den2 = (kma*b) + (kmb*(a*kia))
+        den3 = (Vf/(Vr*keq)) * ( (kmq*p*(1+(a/kia))) + (q* (kmp*( 1+((kma*b)/(kia*kmb)) + p*(1+(b/kib)))) ))
+
+        rate = num / (den1 + den2 + den3)
+        return rate
+
+class UniUni_rev_eq(kinetics.Reaction):
+
+    def __init__(self,
+                 keq=None, kcatf=None, kma=None, kmp=None,
+                 a='', p='', enz='',
+                 substrates=[], products=[]):
+
+        super().__init__()
+
+        self.parameter_names=[keq, kcatf, kma, kmp]
+        self.reaction_substrate_names = [a, p, enz]
+        self.substrates = substrates
+        self.products = products
+
+    def calculate_rate(self, substrates, parameters):
+
+        # Substrates
+        a = substrates[0]
+        p = substrates[1]
+        enz = substrates[2]
+
+        # Parameters
+        keq = parameters[0]
+        kcatf = parameters[1]
+        kma = parameters[2]
+        kmp = parameters[3]
+
+        numerator = enz*kcatf*(a-(p/keq))
+        denominator = a+(kma*(1+(p/kmp)))
+        rate = numerator / denominator
+
+        return rate

setup.py

@@ -7,7 +7,7 @@
               'kinetics.other_analysis',
               'kinetics.reaction_classes',
               'kinetics.ua_and_sa'],
-  version = '1.4.1',
+  version = '1.4.2',
   license='MIT',
   description = 'Python code to run kinetic models of enzyme reactions',
   author = 'William Finnigan',