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

ode2tn/transform.py

@@ -10,13 +10,14 @@ 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,
         beta: float,
         scale: float = 1.0,
         t_span: tuple[float, float] | None = None,
+        show_factors: bool = False,
         resets: dict[float, dict[sp.Symbol | str, float]] | None = None,
         dependent_symbols: dict[sp.Symbol | str, sp.Expr | str] | None = None,
         figure_size: tuple[float, float] = (10, 3),
@@ -54,6 +55,12 @@ def plot_tn(
         scale: "scaling factor" for the transcription network ODEs. Each variable `x` is replaced by a pair
             (`x_top`, `x_bot`). The initial `x_bot` value is `scale`, and the initial `x_top` value is
             `x*scale`.
+        show_factors: if True, then in addition to plotting the ratios x_top/x_bot,
+            also plot the factors x_top and x_bot separately in a second plot.
+            Mutually exlusive with `symbols_to_plot`, since it is equivalent to setting
+            `symbols_to_plot` to ``[ratios, factors]``, where ratios is a list of dependent symbols
+            `x=x_top/x_bot`, and factors is a list of symbols with the transcription factors `x_top`, `x_bot`,
+            for each original variable `x`.
         resets:
             If specified, this is a dict mapping times to "configurations"
             (i.e., dict mapping symbols/str to values).
@@ -77,44 +84,25 @@ 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)
+    if show_factors and symbols_to_plot is not None:
+        raise ValueError("Cannot use both show_factors and symbols_to_plot at the same time.")
+
+    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
 
+    if show_factors:
+        symbols_to_plot = [symbols_to_plot, [factor for pair in tn_syms.values() for factor in pair]]
+
+    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 +113,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 +126,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 +181,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 +190,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 +212,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 +233,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 +247,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 +263,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]:
@@ -297,7 +330,7 @@ def split_polynomial(expr: sp.Expr) -> tuple[sp.Expr, sp.Expr]:
             else:
                 # For negative coefficients, add the negated term to p2
                 p_neg += -term
-    elif expanded.is_Mul:
+    elif expanded.is_Mul or expanded.is_Pow:
         # If it's a single term, just check the sign; is_Mul for things like x*y or -x (represented as -1*x)
         coeff = next((arg for arg in expanded.args if arg.is_number), 1)
         if coeff > 0:
@@ -324,60 +357,22 @@ 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),
-    ]
+    import gpac as gp
+    import numpy as np
+    import sympy as sp
+    from ode2tn import plot_tn
+
+    x = gp.species('X')
+    rxns = [2 * x >> 3 * x]
     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}")
-    inits = {
-        x: 1,
-        y: 0.5,
-    }
-    gamma = 20
+    inits = {x: 1}
+    t_eval = np.linspace(0, 1, 100)
+    gamma = 1
     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)
-    resets = {
-        5: {x: 0.5},
-        10: {x: 0.01},
-        15: {x: 0.5},
-    }
-    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]])
+    # figsize = (16,4)
+
+    # gp.plot_crn(rxns, inits, t_eval, figure_size=figsize)
+    plot_tn(odes, inits, t_eval, gamma=gamma, beta=beta)
 
 
 if __name__ == '__main__':

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: ode2tn
-Version: 1.0.0
+Version: 1.0.2
 Summary: A Python package to turn arbitrary polynomial ODEs into a transcriptional network simulating it.
 Author-email: Dave Doty <doty@ucdavis.edu>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/UC-Davis-molecular-computing/ode-to-transcription-network
 Project-URL: Issues, https://github.com/UC-Davis-molecular-computing/ode-to-transcription-network/issues
 Requires-Python: >=3.10
@@ -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,7 @@ 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)
+plot_tn(odes, inits, gamma=gamma, beta=beta, t_eval=t_eval, show_factors=True)
 ```
 
 This will print
@@ -69,14 +64,14 @@ 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.
 The function `plot_tn` above does this conversion and then plots the ratios.
 Running the code above in a Jupyter notebook will print the above text and show this figure:
 
-![](sine-cosine-plot.png)
+![](sine-cosine-plot.svg)
 
 One could also hand the transcriptional network ODEs to gpac to integrate, if you want to directly access the data being plotted above.
 The `OdeResult` object returned by `gpac.integrate_odes` is the same returned by [`scipy.integrate.solve_ivp`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.solve_ivp.html), where the return value `sol` has a field `sol.y` that has the values of the variables in the order they were inserted into `tn_odes`, which will be the same as the order in which the original variables `x` and `y` were inserted, with `x_t` coming before `x_b`:
@@ -85,20 +80,20 @@ 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_b = {sol.y[1]}')
-print(f'y_t = {sol.y[2]}')
-print(f'y_b = {sol.y[3]}')
+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]}')
 ```
 
 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_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]
+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.2.dist-info/RECORD

@@ -0,0 +1,7 @@
+ode2tn/__init__.py,sha256=b_mINIsNfCWzgG7QVYMsRsWKDLvp2QKFAzRqWtYqwDA,30
+ode2tn/transform.py,sha256=8gQVHaCRTdiACQPZdkB3OPfc2KOZTA3YwMgbXDDnNkE,16155
+ode2tn-1.0.2.dist-info/licenses/LICENSE,sha256=VV9UH0kkG-2edZvwJOqgtN12bZIzs2vn9_cq1SjoUJc,1091
+ode2tn-1.0.2.dist-info/METADATA,sha256=MSGeKttEB-ImlNvBof07AeyxR1rOCBf48tUNinaIgS0,4095
+ode2tn-1.0.2.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+ode2tn-1.0.2.dist-info/top_level.txt,sha256=fPQ9s5yLIYfazJS7wBBfU9EsWa9RGALq8VL-wUYRlao,7
+ode2tn-1.0.2.dist-info/RECORD,,

{ode2tn-1.0.0.dist-info → ode2tn-1.0.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.1)
+Generator: setuptools (79.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

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