ode2tn 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

ode2tn/transform.py

@@ -10,7 +10,7 @@ from scipy.integrate._ivp.ivp import OdeResult  # noqa
 
 def plot_tn(
         odes: dict[sp.Symbol | str, sp.Expr | str | float],
-        initial_values: dict[sp.Symbol | str, float],
+        initial_values: dict[sp.Symbol | str | gp.Specie, float],
         t_eval: Iterable[float] | None = None,
         *,
         gamma: float,
@@ -77,44 +77,19 @@ def plot_tn(
         Typically None, but if return_ode_result is True, returns the result of the ODE integration.
         See documentation of `gpac.plot` for details.
     """
-    tn_odes, tn_inits, tn_ratios = ode2tn(odes, initial_values, gamma=gamma, beta=beta, scale=scale)
+    tn_odes, tn_inits, tn_syms = ode2tn(odes, initial_values, gamma=gamma, beta=beta, scale=scale)
     dependent_symbols_tn = dict(dependent_symbols) if dependent_symbols is not None else {}
+    tn_ratios = {sym: sym_t/sym_b for sym, (sym_t, sym_b) in tn_syms.items()}
     dependent_symbols_tn.update(tn_ratios)
     symbols_to_plot = dependent_symbols_tn if symbols_to_plot is None else symbols_to_plot
 
+    legend = {}
+    for sym, (sym_t, sym_b) in tn_syms.items():
+        legend[sym_t] = f'${sym}^\\top$'
+        legend[sym_b] = f'${sym}^\\bot$'
+
     if resets is not None:
-        # make copy since we are going to change it
-        new_resets = {}
-        for time, reset in resets.items():
-            new_resets[time] = {}
-            for x, val in reset.items():
-                new_resets[time][x] = val
-        resets = new_resets
-        # normalize resets keys and check that variables are valid
-        for reset in resets.values():
-            for x, val in reset.items():
-                if isinstance(x, str):
-                    del reset[x]
-                    x = sp.symbols(x)
-                    reset[x] = val
-                if x not in odes.keys() and x not in tn_odes.keys():
-                    raise ValueError(f"Symbol {x} not found in original variables: {', '.join(odes.keys())},\n"
-                                     f"nor found in transcription network variables: {', '.join(tn_odes.keys())}")
-            # ensure if original variable x is in resets, then neither x_top nor x_bot are in the resets
-            # and substitute x_top and x_bot for x in resets
-            for x, ratio in tn_ratios.items():
-                # x is an original; so make sure neither x_top nor x_bot are in the reset dict
-                if x in reset:
-                    xt,xb = sp.fraction(ratio)
-                    if xt in reset:
-                        raise ValueError(f'Cannot use "top" variable {xt} in resets '
-                                         f'if original variable {x} is also used')
-                    if xb in reset:
-                        raise ValueError(f'Cannot use "bottom" variable {xb} in resets '
-                                         f'if original variable {x} is also used')
-                    reset[xt] = reset[x] * scale
-                    reset[xb] = scale
-                    del reset[x]
+        resets = update_resets_with_ratios(odes, resets, tn_odes, tn_syms, scale)
 
     return gp.plot(
         odes=tn_odes,
@@ -125,6 +100,7 @@ def plot_tn(
         resets=resets,
         figure_size=figure_size,
         symbols_to_plot=symbols_to_plot,
+        legend=legend,
         show=show,
         method=method,
         dense_output=dense_output,
@@ -137,14 +113,51 @@ def plot_tn(
     )
 
 
+def update_resets_with_ratios(odes, resets, tn_odes, tn_syms, scale: float = 1.0) -> dict[float, dict[sp.Symbol, float]]:
+    tn_ratios = {sym: sym_t / sym_b for sym, (sym_t, sym_b) in tn_syms.items()}
+    # make copy since we are going to change it
+    new_resets = {}
+    for time, reset in resets.items():
+        new_resets[time] = {}
+        for x, val in reset.items():
+            new_resets[time][x] = val
+    resets = new_resets
+    # normalize resets keys and check that variables are valid
+    for reset in resets.values():
+        for x, val in reset.items():
+            if isinstance(x, str):
+                del reset[x]
+                x = sp.symbols(x)
+                reset[x] = val
+            if x not in odes.keys() and x not in tn_odes.keys():
+                raise ValueError(f"Symbol {x} not found in original variables: {', '.join(odes.keys())},\n"
+                                 f"nor found in transcription network variables: {', '.join(tn_odes.keys())}")
+        # ensure if original variable x is in resets, then neither x_top nor x_bot are in the resets
+        # and substitute x_top and x_bot for x in resets
+        for x, ratio in tn_ratios.items():
+            # x is an original; so make sure neither x_top nor x_bot are in the reset dict
+            if x in reset:
+                xt, xb = sp.fraction(ratio)
+                if xt in reset:
+                    raise ValueError(f'Cannot use "top" variable {xt} in resets '
+                                     f'if original variable {x} is also used')
+                if xb in reset:
+                    raise ValueError(f'Cannot use "bottom" variable {xb} in resets '
+                                     f'if original variable {x} is also used')
+                reset[xt] = reset[x] * scale
+                reset[xb] = scale
+                del reset[x]
+    return resets
+
+
 def ode2tn(
         odes: dict[sp.Symbol | str, sp.Expr | str | float],
-        initial_values: dict[sp.Symbol | str, float],
+        initial_values: dict[sp.Symbol | str | gp.Specie, float],
         *,
         gamma: float,
         beta: float,
         scale: float = 1.0,
-) -> tuple[dict[sp.Symbol, sp.Expr], dict[sp.Symbol, float], dict[sp.Symbol, sp.Expr]]:
+) -> tuple[dict[sp.Symbol, sp.Expr], dict[sp.Symbol, float], dict[sp.Symbol, tuple[sp.Symbol, sp.Symbol]]]:
     """
     Maps polynomial ODEs and and initial values to transcription network (represented by ODEs with positive
     Laurent polynomials and negative linear term) simulating it, as well as initial values.
@@ -155,7 +168,8 @@ def ode2tn(
             (representing RHS of ODEs)
             Raises ValueError if any of the ODEs RHS is not a polynomial
         initial_values: initial values,
-            dict of sympy symbols or strings (representing symbols) to floats
+            dict of sympy symbols or strings (representing symbols) or gpac.Specie (representing chemical
+            species, if the ODEs were derived from `gpac.crn_to_odes`) to floats
         gamma: coefficient of the negative linear term in the transcription network
         beta: additive constant in x_top ODE
         scale: "scaling factor" for the transcription network ODEs. Each variable `x` is replaced by a pair
@@ -163,15 +177,21 @@ def ode2tn(
             `x*scale`.
 
     Return:
-        triple (`tn_odes`, `tn_inits`, `tn_ratios`), where `tn_ratios` is a dict mapping each original symbol ``x``
-        in the original ODEs to the sympy.Expr ``x_top / x_bot``.
+        triple (`tn_odes`, `tn_inits`, `tn_syms`), where `tn_syms` is a dict mapping each original symbol ``x``
+        in the original ODEs to the pair ``(x_top, x_bot)``.
     """
     # normalize initial values dict to use symbols as keys
-    initial_values = {sp.Symbol(symbol) if isinstance(symbol, str) else symbol: value
-                      for symbol, value in initial_values.items()}
+    initial_values_norm = {}
+    for symbol, value in initial_values.items():
+        if isinstance(symbol, str):
+            symbol = sp.symbols(symbol)
+        if isinstance(symbol, gp.Specie):
+            symbol = sp.symbols(symbol.name)
+        initial_values_norm[symbol] = value
+    initial_values = initial_values_norm
 
     # normalize odes dict to use symbols as keys
-    odes_symbols = {}
+    odes_normalized = {}
     symbols_found_in_expressions = set()
     for symbol, expr in odes.items():
         if isinstance(symbol, str):
@@ -179,11 +199,12 @@ def ode2tn(
         if isinstance(expr, (str, int, float)):
             expr = sp.sympify(expr)
         symbols_found_in_expressions.update(expr.free_symbols)
-        odes_symbols[symbol] = expr
+        odes_normalized[symbol] = expr
+    odes = odes_normalized
 
     # ensure that all symbols that are keys in `initial_values` are also keys in `odes`
     initial_values_keys = set(initial_values.keys())
-    odes_keys = set(odes_symbols.keys())
+    odes_keys = set(odes.keys())
     diff = initial_values_keys - odes_keys
     if len(diff) > 0:
         raise ValueError(f"\nInitial_values contains symbols that are not in odes: "
@@ -199,7 +220,7 @@ def ode2tn(
                          f"The keys in the odes dict are: {odes_keys}")
 
     # ensure all odes are polynomials
-    for symbol, expr in odes_symbols.items():
+    for symbol, expr in odes_normalized.items():
         if not expr.is_polynomial():
             raise ValueError(f"ODE for {symbol}' is not a polynomial: {expr}")
 
@@ -213,16 +234,14 @@ def normalized_ode2tn(
         gamma: float,
         beta: float,
         scale: float,
-) -> tuple[dict[sp.Symbol, sp.Expr], dict[sp.Symbol, float], dict[sp.Symbol, sp.Expr]]:
+) -> tuple[dict[sp.Symbol, sp.Expr], dict[sp.Symbol, float], dict[sp.Symbol, tuple[sp.Symbol, sp.Symbol]]]:
     # Assumes ode2tn has normalized and done error-checking
 
-    sym2pair: dict[sp.Symbol, tuple[sp.Symbol, sp.Symbol]] = {}
-    tn_ratios: dict[sp.Symbol, sp.Expr] = {}
+    tn_syms: dict[sp.Symbol, tuple[sp.Symbol, sp.Symbol]] = {}
     for x in odes.keys():
         # create x_t, x_b for each symbol x
-        x_top, x_bot = sp.symbols(f'{x}_t {x}_b')
-        sym2pair[x] = (x_top, x_bot)
-        tn_ratios[x] = x_top / x_bot
+        x_t, x_b = sp.symbols(f'{x}_t {x}_b')
+        tn_syms[x] = (x_t, x_b)
 
     tn_odes: dict[sp.Symbol, sp.Expr] = {}
     tn_inits: dict[sp.Symbol, float] = {}
@@ -231,19 +250,20 @@ def normalized_ode2tn(
 
         # replace sym with sym_top / sym_bot for each original symbol sym
         for sym in odes.keys():
-            sym_top, sym_bot = sym2pair[sym]
-            p_pos = p_pos.subs(sym, sym_top / sym_bot)
-            p_neg = p_neg.subs(sym, sym_top / sym_bot)
+            sym_top, sym_bot = tn_syms[sym]
+            ratio = sym_top / sym_bot
+            p_pos = p_pos.subs(sym, ratio)
+            p_neg = p_neg.subs(sym, ratio)
 
-        x_top, x_bot = sym2pair[x]
+        x_t, x_b = tn_syms[x]
         # tn_odes[x_top] = beta + p_pos * x_bot - gamma * x_top
         # tn_odes[x_bot] = p_neg * x_bot ** 2 / x_top + beta * x_bot / x_top - gamma * x_bot
-        tn_odes[x_top] = beta * x_top / x_bot + p_pos * x_bot - gamma * x_top
-        tn_odes[x_bot] = beta + p_neg * x_bot ** 2 / x_top - gamma * x_bot
-        tn_inits[x_top] = initial_values[x]*scale
-        tn_inits[x_bot] = scale
+        tn_odes[x_t] = beta * x_t / x_b + p_pos * x_b - gamma * x_t
+        tn_odes[x_b] = beta + p_neg * x_b ** 2 / x_t - gamma * x_b
+        tn_inits[x_t] = initial_values.get(x, 0) * scale
+        tn_inits[x_b] = scale
 
-    return tn_odes, tn_inits, tn_ratios
+    return tn_odes, tn_inits, tn_syms
 
 
 def split_polynomial(expr: sp.Expr) -> tuple[sp.Expr, sp.Expr]:
@@ -324,60 +344,46 @@ def comma_separated(elts: Iterable[Any]) -> str:
 
 
 def main():
-    x_sp, y_sp = gp.species('x y')
-    rxns = [
-        x_sp >> x_sp + y_sp,
-        (3 * y_sp | 2 * y_sp).k(11).r(16.5),
-        (y_sp >> gp.empty).k(6.5),
-    ]
-    odes = gp.crn_to_odes(rxns)
-    # extract symbols from odes
-    for var in odes.keys():
-        if var.name == 'x':
-            x = var
-        if var.name == 'y':
-            y = var
-    # for v,ode in odes.items():
-    #     print(f"{v}' = {ode}")
+    import gpac as gp
+    import numpy as np
+    import sympy as sp
+    from ode2tn import plot_tn, ode2tn
+
+    P = 1
+    I = 1
+    D = 1
+    val, setpoint, bias, integral, derivative_p, derivative_m, delayed_val = \
+        sp.symbols('val setpoint bias integral derivative_p derivative_m delayed_val')
+    proportional_term = P * (setpoint - val)
+    integral_term = I * (integral - 10)
+    # derivative_term = D * (temperature - delayed_temperature)
+    c = 1
+    odes = {
+        val: proportional_term + integral_term,  # + derivative_term,
+        integral: setpoint - val,
+        delayed_val: c * (val - delayed_val),
+        setpoint: 0,
+    }
     inits = {
-        x: 1,
-        y: 0.5,
+        val: 5,
+        setpoint: 7,
+        integral: 10,
     }
-    gamma = 20
-    beta = 1
-    scale = 0.1
-    import numpy as np
-    t_eval = np.linspace(0, 20, 500)
-
-    tn_odes, tn_inits, tn_ratios = ode2tn(odes, inits, gamma=gamma, beta=beta, scale=scale)
-    for ratio_symbol in tn_inits.keys():
-        if ratio_symbol.name == 'x_t':
-            xt = ratio_symbol
-        if ratio_symbol.name == 'x_b':
-            xb = ratio_symbol
-        if ratio_symbol.name == 'y_t':
-            yt = ratio_symbol
-        if ratio_symbol.name == 'y_b':
-            yb = ratio_symbol
-    from IPython.display import display
-    for sym, expr in tn_odes.items():
-        print(f"{sym}' = ", end='')
-        display(sp.simplify(expr))
-    print(f'{tn_inits=}')
-    print(f'{tn_ratios=}')
-    # for var, val in tn_inits.items():
-    #     tn_inits[var] *= 0.1
-    # print(f'after reducing t/b values by 10x: {tn_inits=}')
-    figsize = (15, 6)
+    t_eval = np.linspace(0, 40, 500)
+    figsize = (16, 4)
     resets = {
-        5: {x: 0.5},
-        10: {x: 0.01},
-        15: {x: 0.5},
+        10: {val: 9},
+        20: {val: 3},
+        30: {bias: 2},
     }
-    scale = 0.1
-    plot_tn(odes, inits, gamma=gamma, beta=beta, scale=scale,
-            t_eval=t_eval, resets=resets, figure_size=figsize,
-            symbols_to_plot=[[x, y], [xt, xb, yt, yb]])
+    gamma = 1
+    beta = 1
+    # plot_tn(odes, inits, t_eval, gamma=gamma, beta=beta, resets=resets, figure_size=figsize)
+    tn_odes, tn_inits, tn_syms = ode2tn(odes, inits, gamma=gamma, beta=beta)
+    val_top = tn_syms[val][0]
+    tn_odes[val_top] += bias
+    tn_odes[bias] = 0
+    gp.plot(tn_odes, tn_inits, t_eval, resets=resets, figure_size=figsize)
 
 
 if __name__ == '__main__':

{ode2tn-1.0.0.dist-info → ode2tn-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ode2tn
-Version: 1.0.0
+Version: 1.0.1
 Summary: A Python package to turn arbitrary polynomial ODEs into a transcriptional network simulating it.
 Author-email: Dave Doty <doty@ucdavis.edu>
 License: MIT
@@ -15,7 +15,7 @@ Requires-Dist: sympy>=1.13
 Dynamic: license-file
 
 # ode-to-transcription-network
-ode2tn is a Python package to turn arbitrary polynomial ODEs into a transcriptional network simulating it.
+ode2tn is a Python package to compile arbitrary polynomial ODEs into a transcriptional network simulating the ODEs.
 
 See this paper for details: TODO
 
@@ -53,12 +53,12 @@ inits = { # inits maps each symbol to its initial value
 gamma = 2 # uniform decay constant; should be set sufficiently large that ???
 beta = 1 # constant introduced to keep values from going to infinity or 0
 t_eval = np.linspace(0, 6*pi, 1000)
-tn_odes, tn_inits, tn_ratios = ode2tn(odes, inits, gamma, beta)
-for sym, expr in tn_odes.items():
-    print(f"{sym}' = {expr}")
-print(f'{tn_inits=}')
-print(f'{tn_ratios=}')
-plot_tn(odes, inits, gamma, beta, t_eval=t_eval)
+# tn_odes, tn_inits, tn_syms = ode2tn(odes, inits, gamma, beta)
+# for sym, expr in tn_odes.items():
+#     print(f"{sym}' = {expr}")
+# print(f'{tn_inits=}')
+# print(f'{tn_syms=}')
+plot_tn(odes, inits, gamma=gamma, beta=beta, t_eval=t_eval)
 ```
 
 This will print
@@ -69,7 +69,7 @@ x_b' = 2*x_b**2/x_t - 2*x_b + 1
 y_t' = 2*y_b - 2*y_t + y_t/y_b
 y_b' = -2*y_b + 1 + x_t*y_b**2/(x_b*y_t)
 tn_inits={x_t: 2, x_b: 1, y_t: 1, y_b: 1}
-tn_ratios={x: x_t/x_b, y: y_t/y_b}
+tn_syms={x: (x_t, x_b), y: (y_t, y_b)}
 ```
 
 showing that the variables `x` and `y` have been replace by pairs `x_t,x_b` and `y_t,y_b`, whose ratios `x_t/x_b` and `y_t/y_b` will track the values of the original variable `x` and `y` over time.
@@ -85,7 +85,7 @@ The `OdeResult` object returned by `gpac.integrate_odes` is the same returned by
 t_eval = np.linspace(0, 2*pi, 5)
 sol = gp.integrate_odes(tn_odes, tn_inits, t_eval)
 print(f'times = {sol.t}')
-print(f'x_y = {sol.y[0]}')
+print(f'x_t = {sol.y[0]}')
 print(f'x_b = {sol.y[1]}')
 print(f'y_t = {sol.y[2]}')
 print(f'y_b = {sol.y[3]}')
@@ -95,7 +95,7 @@ which would print
 
 ```
 times = [0.         1.57079633 3.14159265 4.71238898 6.28318531]
-x_y = [2.         1.78280757 3.67207594 2.80592514 1.71859172]
+x_t = [2.         1.78280757 3.67207594 2.80592514 1.71859172]
 x_b = [1.         1.78425369 1.83663725 0.93260227 0.859926  ]
 y_t = [1.         1.87324904 2.14156469 2.10338162 2.74383426]
 y_b = [1.         0.93637933 0.71348949 1.05261915 2.78279691]

ode2tn-1.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+ode2tn/__init__.py,sha256=b_mINIsNfCWzgG7QVYMsRsWKDLvp2QKFAzRqWtYqwDA,30
+ode2tn/transform.py,sha256=0ok_lcHA2lOV8yrB-MBC9es-i7zVP50EktKeuUuhs0k,16148
+ode2tn-1.0.1.dist-info/licenses/LICENSE,sha256=VV9UH0kkG-2edZvwJOqgtN12bZIzs2vn9_cq1SjoUJc,1091
+ode2tn-1.0.1.dist-info/METADATA,sha256=klLivWzfNVnR3VDVSkWvSuGQDnBrdLCpL7lUOpTCTlc,4228
+ode2tn-1.0.1.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+ode2tn-1.0.1.dist-info/top_level.txt,sha256=fPQ9s5yLIYfazJS7wBBfU9EsWa9RGALq8VL-wUYRlao,7
+ode2tn-1.0.1.dist-info/RECORD,,

ode2tn-1.0.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-ode2tn/__init__.py,sha256=b_mINIsNfCWzgG7QVYMsRsWKDLvp2QKFAzRqWtYqwDA,30
-ode2tn/transform.py,sha256=k_yzuUck-RGgS-WI7cUzNRfC4nKIMip_q5mJfVukg28,15847
-ode2tn-1.0.0.dist-info/licenses/LICENSE,sha256=VV9UH0kkG-2edZvwJOqgtN12bZIzs2vn9_cq1SjoUJc,1091
-ode2tn-1.0.0.dist-info/METADATA,sha256=UQ7FvLFnOyzWs9qK3fS8NZtsVxd8ESDwT3_QdHpl-cE,4198
-ode2tn-1.0.0.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
-ode2tn-1.0.0.dist-info/top_level.txt,sha256=fPQ9s5yLIYfazJS7wBBfU9EsWa9RGALq8VL-wUYRlao,7
-ode2tn-1.0.0.dist-info/RECORD,,