diff --git a/basico/task_lna.py b/basico/task_lna.py index 003f4f1..2a57131 100644 --- a/basico/task_lna.py +++ b/basico/task_lna.py @@ -13,11 +13,21 @@ # LNA is available since COPASI 4.45.295+ _have_lna_method = int(COPASI.__version__.split('.')[-1]) > 295 -def run_lna(**kwargs): - """ Runs the LNA task, the result is obtained by calling: - - * `get_lna_solution` +def run_lna(return_results=False, **kwargs): + """ Runs the LNA task + + :param return_results: if True the results are returned (by call `get_lna_solution`), otherwise only the status is returned + :param kwargs: optional arguments + + - | `model`: to specify the data model to be used (if not specified + | the one from :func:`.get_current_model` will be taken) + + - `settings`: a dictionary with settings for the LNA task + + - `use_initial_values`: if True the initial values are used, otherwise the current state is used + :return: the status of the LNA task and the results (if `return_results` is True), otherwise only + the status is returned """ model = model_io.get_model_from_dict_or_default(kwargs) assert (isinstance(model, COPASI.CDataModel)) @@ -38,7 +48,7 @@ def run_lna(**kwargs): if not task.initializeRaw(COPASI.CCopasiTask.OUTPUT_UI): logger.error('Could not initialize LNA Task: {0}'.format( basico.model_info.get_copasi_messages(num_messages_before, 'No output'))) - return get_lna_solution() + return get_lna_solution() if return_results else get_lna_status() if not task.processRaw(use_initial_values): logger.error('Could not run LNA Task: {0}'.format( @@ -47,7 +57,7 @@ def run_lna(**kwargs): task.restore() - return get_lna_solution() + return get_lna_solution() if return_results else get_lna_status() def _get_lna_status(**kwargs): diff --git a/docs/index.rst b/docs/index.rst index d9a2463..4875760 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -44,6 +44,7 @@ complexity of the underlying SWIG generated language bindings. notebooks/MCA notebooks/Working_with_Widgets notebooks/AllTaskSettings + notebooks/LinearNoiseApproximation.ipynb .. toctree:: :maxdepth: 2 diff --git a/docs/notebooks/LinearNoiseApproximation.ipynb b/docs/notebooks/LinearNoiseApproximation.ipynb new file mode 100644 index 0000000..440e641 --- /dev/null +++ b/docs/notebooks/LinearNoiseApproximation.ipynb @@ -0,0 +1,455 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Linear Noise Approximation\n", + "This notebook demonstrates how to use Metabolic Control Analysis using basico. We start as always, by importing basico: " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import display, HTML\n", + "from basico import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "now we load BioModel #11" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + "

MAPK cascade in solution (no scaffold)

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Description
This model describes a basic 3-\n", + "\t\t\t\t\t\t\tstage Mitogen Activated Protein Kinase (MAPK)\n", + "\t\t\t\t\t\t\t cascade in solution. This cascade is typically expressed as RAF=\n", + "\t\t\t\t\t\t\t=>MEK==>MAPK (alternative forms are K3==>K2==>\n", + "\t\t\t\t\t\t\tK1 and KKK==>KK==>K)\n", + "\t\t\t\t\t\t\t. The input signal is RAFK (RAF Kinase)\n", + "\t\t\t\t\t\t\t and the output signal is MAPKpp (\n", + "\t\t\t\t\t\t\tdoubly phosphorylated form of MAPK)\n", + "\t\t\t\t\t\t\t. RAFK phosphorylates RAF once to RAFp. RAFp,\n", + "\t\t\t\t\t\t\t the phosphorylated form of RAF induces two phoshporylations of MEK,\n", + "\t\t\t\t\t\t\tto MEKp and MEKpp. MEKpp,\n", + "\t\t\t\t\t\t\t the doubly phosphorylated form of MEK,\n", + "\t\t\t\t\t\t\t induces two phosphorylations of MAPK to MAPKp and MAPKpp.
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Rate constant      Reaction
a10 = 5.MAPKPH + MAPKpp -> MAPKppMAPKPH
a1 = 1.RAF + RAFK -> RAFRAFK
a2 = 0.5RAFp + RAFPH -> RAFpRAFPH
a3 = 3.3MEK + RAFp -> MEKRAFp
a4 = 10.MEKp + MEKPH -> MEKpMEKPH
a5 = 3.3MEKp + RAFp -> MEKpRAFp
a6 = 10.MEKPH + MEKpp -> MEKppMEKPH
a7 = 20.MAPK + MEKpp -> MAPKMEKpp
a8 = 5.MAPKp + MAPKPH -> MAPKpMAPKPH
a9 = 20.MAPKp + MEKpp -> MAPKpMEKpp
d10 = 0.4MAPKppMAPKPH -> MAPKPH + MAPKpp
d1 = 0.4RAFRAFK -> RAF + RAFK
d2 = 0.5RAFpRAFPH -> RAFp + RAFPH
d3 = 0.42MEKRAFp -> MEK + RAFp
d4 = 0.8MEKpMEKPH -> MEKp + MEKPH
d5 = 0.4MEKpRAFp -> MEKp + RAFp
d6 = 0.8MEKppMEKPH -> MEKPH + MEKpp
d7 = 0.6MAPKMEKpp -> MAPK + MEKpp
d8 = 0.4MAPKpMAPKPH -> MAPKp + MAPKPH
d9 = 0.6MAPKpMEKpp -> MAPKp + MEKpp
k10 = 0.1MAPKppMAPKPH -> MAPKp + MAPKPH
k1 = 0.1RAFRAFK -> RAFK + RAFp
k2 = 0.1RAFpRAFPH -> RAF + RAFPH
k3 = 0.1MEKRAFp -> MEKp + RAFp
k4 = 0.1MEKpMEKPH -> MEK + MEKPH
k5 = 0.1MEKpRAFp -> MEKpp + RAFp
k6 = 0.1MEKppMEKPH -> MEKp + MEKPH
k7 = 0.1MAPKMEKpp -> MAPKp + MEKpp
k8 = 0.1MAPKpMAPKPH -> MAPK + MAPKPH
k9 = 0.1MAPKpMEKpp -> MAPKpp + MEKpp
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
VariableIC  ODE
MAPK0.3MAPK'[t] == d7*MAPKMEKpp[t] + k8*MAPKpMAPKPH[t] -\n", + "\t\t\t\t\t\t\t a7*MAPK[t]*MEKpp[t]
MAPKMEKpp0MAPKMEKpp'[t] == -(d7*MAPKMEKpp[t]) - k7*MAPKMEKpp[t]\n", + "\t\t\t\t\t\t\t + a7*MAPK[t]*MEKpp[t]
MAPKp0MAPKp'[t] == k7*MAPKMEKpp[t] - a8*MAPKp[t]*MAPKPH[t]\n", + "\t\t\t\t\t\t\t + d8*MAPKpMAPKPH[t] + d9*MAPKpMEKpp[t] + k10*\n", + "\t\t\t\t\t\t\tMAPKppMAPKPH[t] - a9*MAPKp[t]*MEKpp[t]
MAPKPH0.3MAPKPH'[t] == -(a8*MAPKp[t]*MAPKPH[t]) + d8*MAPKpMAPKPH[\n", + "\t\t\t\t\t\t\tt] + k8*MAPKpMAPKPH[t] - a10*MAPKPH[t]*MAPKpp[t] +\n", + "\t\t\t\t\t\t\t d10*MAPKppMAPKPH[t] + k10*MAPKppMAPKPH[t]
MAPKpMAPKPH0MAPKpMAPKPH'[t] == a8*MAPKp[t]*MAPKPH[t] - d8*\n", + "\t\t\t\t\t\t\tMAPKpMAPKPH[t] - k8*MAPKpMAPKPH[t]
MAPKpMEKpp0MAPKpMEKpp'[t] == -(d9*MAPKpMEKpp[t]) - k9*MAPKpMEKpp[t]\n", + "\t\t\t\t\t\t\t + a9*MAPKp[t]*MEKpp[t]
MAPKpp0MAPKpp'[t] == k9*MAPKpMEKpp[t] - a10*MAPKPH[t]*MAPKpp[t]\n", + "\t\t\t\t\t\t\t + d10*MAPKppMAPKPH[t]
MAPKppMAPKPH0MAPKppMAPKPH'[t] == a10*MAPKPH[t]*MAPKpp[t] - d10*\n", + "\t\t\t\t\t\t\tMAPKppMAPKPH[t] - k10*MAPKppMAPKPH[t]
MEK0.2MEK'[t] == k4*MEKpMEKPH[t] + d3*MEKRAFp[t] -\n", + "\t\t\t\t\t\t\t a3*MEK[t]*RAFp[t]
MEKp0MEKp'[t] == -(a4*MEKp[t]*MEKPH[t]) + d4*MEKpMEKPH[t]\n", + "\t\t\t\t\t\t\t + k6*MEKppMEKPH[t] + d5*MEKpRAFp[t] + k3*MEKRAFp[\n", + "\t\t\t\t\t\t\tt] - a5*MEKp[t]*RAFp[t]
MEKPH0.2MEKPH'[t] == -(a4*MEKp[t]*MEKPH[t]) + d4*MEKpMEKPH[t]\n", + "\t\t\t\t\t\t\t + k4*MEKpMEKPH[t] - a6*MEKPH[t]*MEKpp[t] + d6*\n", + "\t\t\t\t\t\t\tMEKppMEKPH[t] + k6*MEKppMEKPH[t]
MEKpMEKPH0MEKpMEKPH'[t] == a4*MEKp[t]*MEKPH[t] - d4*MEKpMEKPH[t]\n", + "\t\t\t\t\t\t\t - k4*MEKpMEKPH[t]
MEKpp0MEKpp'[t] == d7*MAPKMEKpp[t] + k7*MAPKMEKpp[t] +\n", + "\t\t\t\t\t\t\t d9*MAPKpMEKpp[t] + k9*MAPKpMEKpp[t] - a7*MAPK[t]*\n", + "\t\t\t\t\t\t\tMEKpp[t] - a9*MAPKp[t]*MEKpp[t] - a6*MEKPH[t]*MEKpp[t]\n", + "\t\t\t\t\t\t\t + d6*MEKppMEKPH[t] + k5*MEKpRAFp[t]
MEKppMEKPH0MEKppMEKPH'[t] == a6*MEKPH[t]*MEKpp[t] - d6*MEKppMEKPH[\n", + "\t\t\t\t\t\t\tt] - k6*MEKppMEKPH[t]
MEKpRAFp0MEKpRAFp'[t] == -(d5*MEKpRAFp[t]) - k5*MEKpRAFp[t]\n", + "\t\t\t\t\t\t\t + a5*MEKp[t]*RAFp[t]
MEKRAFp0MEKRAFp'[t] == -(d3*MEKRAFp[t]) - k3*MEKRAFp[t] +\n", + "\t\t\t\t\t\t\t a3*MEK[t]*RAFp[t]
RAF0.4RAF'[t] == -(a1*RAF[t]*RAFK[t]) + k2*RAFpRAFPH[t] +\n", + "\t\t\t\t\t\t\t d1*RAFRAFK[t]
RAFK0.1RAFK'[t] == -(a1*RAF[t]*RAFK[t]) + d1*RAFRAFK[t] +\n", + "\t\t\t\t\t\t\t k1*RAFRAFK[t]
RAFp0RAFp'[t] == d5*MEKpRAFp[t] + k5*MEKpRAFp[t] +\n", + "\t\t\t\t\t\t\t d3*MEKRAFp[t] + k3*MEKRAFp[t] - a3*MEK[t]*RAFp[t]\n", + "\t\t\t\t\t\t\t - a5*MEKp[t]*RAFp[t] - a2*RAFp[t]*RAFPH[t] + d2*\n", + "\t\t\t\t\t\t\tRAFpRAFPH[t] + k1*RAFRAFK[t]
RAFPH0.3RAFPH'[t] == -(a2*RAFp[t]*RAFPH[t]) + d2*RAFpRAFPH[t]\n", + "\t\t\t\t\t\t\t + k2*RAFpRAFPH[t]
RAFpRAFPH0RAFpRAFPH'[t] == a2*RAFp[t]*RAFPH[t] - d2*RAFpRAFPH[t]\n", + "\t\t\t\t\t\t\t - k2*RAFpRAFPH[t]
RAFRAFK0RAFRAFK'[t] == a1*RAF[t]*RAFK[t] - d1*RAFRAFK[t] -\n", + "\t\t\t\t\t\t\t k1*RAFRAFK[t]
\n", + "

Generated by Cellerator Version 1.4.3 (6-March-2004) using Mathematica 5.0 \n", + "\t\t\t\tfor Mac OS X (November 19, 2003), March 6, 2004 12:18:07, using (PowerMac,\n", + "\t\t\t\tPowerPC,Mac OS X,MacOSX,Darwin)

\n", + "

author=B.E.Shapiro

\n", + "

This model originates from BioModels Database: A Database of Annotated Published Models (http://www.ebi.ac.uk/biomodels/). It is copyright (c) 2005-2010 The BioModels.net Team.
\n", + " For more information see the terms of use\n", + " .
\n", + " To cite BioModels Database, please use: Li C, Donizelli M, Rodriguez N, Dharuri H, Endler L, Chelliah V, Li L, He E, Henry A, Stefan MI, Snoep JL, Hucka M, Le Novère N, Laibe C (2010) BioModels Database: An enhanced, curated and annotated resource for published quantitative kinetic models. BMC Syst Biol., 4:92.

\n", + " \n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "dm = load_biomodel(11)\n", + "display(HTML(get_notes()))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The LNA is computed runing `run_lna` the optional argument `return_results` (default `False`) indicates whether the full result is returned, or only the status of the computation. To retrieve the results after a computation of the LNA the following methods may be used: \n", + "\n", + "* `get_lna_status` returns the status of the last computation\n", + "* `get_lna_covariance_matrix` returns the full covariance matrix\n", + "* `get_lna_reduced_covariance_matrix` returns the reduced covariance matrix\n", + "* `get_lna_reduced_b_matrix` returns the reduced b Matrix\n", + "* `get_lna_solution` returns the tuple: `(status, covariance matrix, reduced covariance matrix, reduced b matrix)`" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Steady State found.'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "run_lna()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Get the covariance matrix\n", + "df_cov_matrix = get_lna_covariance_matrix()\n", + "\n", + "# Generate heatmap\n", + "plt.figure(figsize=(10, 8))\n", + "plt.imshow(df_cov_matrix, cmap='viridis', aspect='auto')\n", + "plt.colorbar()\n", + "plt.title('LNA Covariance Matrix Heatmap')\n", + "plt.xticks(range(df_cov_matrix.shape[1]), df_cov_matrix.columns, rotation=90)\n", + "plt.yticks(range(df_cov_matrix.shape[0]), df_cov_matrix.index)\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "petab-edit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tests/test_lna.py b/tests/test_lna.py index f11ebed..b717d76 100644 --- a/tests/test_lna.py +++ b/tests/test_lna.py @@ -8,7 +8,7 @@ class TestLNA(unittest.TestCase): def test_lna(self): dm = basico.load_example('brusselator') self.assertIsNotNone(dm) - status, cv, cv_red, b = basico.run_lna() + status = basico.run_lna() self.assertEqual(status, 'The reduced system has non-negative Eigen values! No LNA calculated!') @@ -16,7 +16,7 @@ def test_lna(self): dm = basico.load_example('Yeast') self.assertIsNotNone(dm) - status, cv, cv_red, b = basico.run_lna() + status, cv, cv_red, b = basico.run_lna(return_results=True) # this model has reversible reactions, so the LNA should not be calculated # and the matrices should be empty @@ -30,7 +30,7 @@ def test_lna(self): dm = basico.load_model(os.path.join(os.path.dirname(__file__), 'test_data', 'BM11.cps')) self.assertIsNotNone(dm) - status, cv, cv_red, b = basico.run_lna() + status, cv, cv_red, b = basico.run_lna(return_results=True) self.assertEqual(status, 'Steady State found.') # ensure matrices are not empty