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

ode2tn/transform.py

@@ -17,6 +17,8 @@ def plot_tn(
         beta: float,
         scale: float = 1.0,
         t_span: tuple[float, float] | None = None,
+        show_factors: bool = False,
+        latex_legend: bool = True,
         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 +56,18 @@ 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`.
+        latex_legend: If True, surround each symbol name with dollar signs, unless it is already surrounded with them,
+            so that the legend is interpreted as LaTeX. If this is True, then the symbol name must either
+            start and end with `$`, or neither start nor end with `$`. Unlike in the gpac package, this is True
+            by default. The names of transcription factors are automatically surrounded by dollar signs.
+            This option makes sure the legend showing original variables (or dependent symbols) also have `$` added
+            so as to be interpreted as LaTeX.
         resets:
             If specified, this is a dict mapping times to "configurations"
             (i.e., dict mapping symbols/str to values).
@@ -77,12 +91,18 @@ 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.
     """
+    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$'
@@ -99,6 +119,7 @@ def plot_tn(
         dependent_symbols=dependent_symbols_tn,
         resets=resets,
         figure_size=figure_size,
+        latex_legend=latex_legend,
         symbols_to_plot=symbols_to_plot,
         legend=legend,
         show=show,
@@ -317,7 +338,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:
@@ -347,43 +368,19 @@ def main():
     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 = {
-        val: 5,
-        setpoint: 7,
-        integral: 10,
-    }
-    t_eval = np.linspace(0, 40, 500)
-    figsize = (16, 4)
-    resets = {
-        10: {val: 9},
-        20: {val: 3},
-        30: {bias: 2},
-    }
+    from ode2tn import plot_tn
+
+    x = gp.species('X')
+    rxns = [2 * x >> 3 * x]
+    odes = gp.crn_to_odes(rxns)
+    inits = {x: 1}
+    t_eval = np.linspace(0, 1, 100)
     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)
+    # 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.1.dist-info → ode2tn-1.0.3.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: ode2tn
-Version: 1.0.1
+Version: 1.0.3
 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
@@ -14,7 +14,7 @@ Requires-Dist: scipy>=1.15
 Requires-Dist: sympy>=1.13
 Dynamic: license-file
 
-# ode-to-transcription-network
+# ode2tn
 ode2tn is a Python package to compile arbitrary polynomial ODEs into a transcriptional network simulating the ODEs.
 
 See this paper for details: TODO
@@ -52,53 +52,69 @@ 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_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)
+tn_odes, tn_inits, tn_syms = ode2tn(odes, inits, gamma=gamma, beta=beta)
+gp.display_odes(tn_odes)
+print(f'{tn_inits=}')
+print(f'{tn_syms=}')
 ```
 
-This will print
+When run in a Jupyter notebook, this will show
+
+![](ode-display.png)
+
+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.
 
+If not in a Jupyter notebook, one could also inspect the transcriptional network ODEs via
+```python
+for var, ode in tn_odes.items():
+    print(f"{var}' = {ode}")
+```
+which would print a text-based version of the equations:
 ```
 x_t' = x_b*y_t/y_b - 2*x_t + x_t/x_b
 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_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:
+The function `plot_tn` above does this conversion on the *original* odes and then plots the ratios.
+Running 
 
-![](sine-cosine-plot.png)
+```python
+t_eval = np.linspace(0, 6*pi, 1000)
+# note below it is odes and inits, not tn_odes and tn_inits
+# plot_tn calls ode2tn to convert the ODEs before plotting
+plot_tn(odes, inits, gamma=gamma, beta=beta, t_eval=t_eval, show_factors=True)
+```
+
+in a Jupyter notebook will show this figure:
+
+![](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 parameter `show_factors` above indicates to show a second subplot with the underlying transcription factors ($x^\top, x^\bot, y^\top, y^\bot$ above).
+If left unspecified, it defaults to `False` and plots only the original values (ratios of pairs of transcription factors, $x,y$ above).
+
+One could also hand the transcriptional network ODEs to [gpac](https://github.com/UC-Davis-molecular-computing/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`:
 
-```
+```python
 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_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]}')
+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_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]
+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.3.dist-info/RECORD

@@ -0,0 +1,7 @@
+ode2tn/__init__.py,sha256=b_mINIsNfCWzgG7QVYMsRsWKDLvp2QKFAzRqWtYqwDA,30
+ode2tn/transform.py,sha256=8GciVR2iGRRWgKyvPoYoQ5TZjKrOdNyzaH_ZukJiVsw,16829
+ode2tn-1.0.3.dist-info/licenses/LICENSE,sha256=VV9UH0kkG-2edZvwJOqgtN12bZIzs2vn9_cq1SjoUJc,1091
+ode2tn-1.0.3.dist-info/METADATA,sha256=RbwHIvSA6PgVWV9I57Fs9n2OdU7ocksS65YPaxs7174,4882
+ode2tn-1.0.3.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+ode2tn-1.0.3.dist-info/top_level.txt,sha256=fPQ9s5yLIYfazJS7wBBfU9EsWa9RGALq8VL-wUYRlao,7
+ode2tn-1.0.3.dist-info/RECORD,,

{ode2tn-1.0.1.dist-info → ode2tn-1.0.3.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.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-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,,