diff --git a/.coveragerc b/.coveragerc index 8b49eeb..210fb3c 100644 --- a/.coveragerc +++ b/.coveragerc @@ -1,6 +1,6 @@ [run] branch = True -source = autoreduce +source = autoreduce [report] exclude_lines = @@ -10,4 +10,4 @@ exclude_lines = if __name__ == .__main__.: ignore_errors = True omit = - tests/* \ No newline at end of file + tests/* diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index ceac110..abf6eb9 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -1,13 +1,8 @@ -# This workflow will install Python dependencies, run tests and lint with a variety of Python versions -# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python - name: build on: push: - branches: [ "master" ] - pull_request: - branches: [ "master" ] + branches: ["main"] jobs: build: @@ -15,23 +10,24 @@ jobs: strategy: matrix: os: [windows-latest, ubuntu-latest, macos-latest] - python-version: [3.9, 3.11, 3.12] + python-version: ["3.10", "3.13"] steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v3 + uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} + cache: "pip" - name: Install dependencies run: | python -m pip install --upgrade pip - pip install -r requirements.txt - name: Install autoreduce - run: pip install ".[all, test]" + run: pip install -e ".[test]" - name: Test autoreduce - run: pytest --cov --junitxml=junit.xml -o junit_family=legacy - - name: Upload test results to Codecov + run: pytest --cov=autoreduce --cov-report=xml --junitxml=junit.xml -o junit_family=legacy + - name: Upload coverage to Codecov if: ${{ !cancelled() }} - uses: codecov/test-results-action@v1 + uses: codecov/codecov-action@v4 with: + fail_ci_if_error: false token: ${{ secrets.CODECOV_TOKEN }} diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index f3be98b..15e96fb 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -2,6 +2,9 @@ name: Lint on: push: + branches: ["main"] + pull_request: + branches: ["main"] jobs: lint: @@ -12,13 +15,13 @@ jobs: - name: Set up Python uses: actions/setup-python@v5 with: - python-version: "3.11" + python-version: "3.13" cache: 'pip' - name: Install dependencies run: | python -m pip install --upgrade pip - pip install flake8 + pip install ruff - - name: Run flake8 - run: flake8 autoreduce tests \ No newline at end of file + - name: Run ruff + run: ruff check autoreduce tests diff --git a/.github/workflows/pypi-deploy.yml b/.github/workflows/pypi-deploy.yml index ec4ad85..a405c9d 100644 --- a/.github/workflows/pypi-deploy.yml +++ b/.github/workflows/pypi-deploy.yml @@ -2,14 +2,23 @@ name: PyPI Deploy on: workflow_dispatch: + inputs: + ref: + description: "Tag, branch, or commit to build. Leave blank to use the selected ref." + required: false + default: "" jobs: pypi-publish: runs-on: ubuntu-latest permissions: id-token: write + environment: Release Deploy steps: - uses: actions/checkout@v4 + with: + fetch-depth: 0 + ref: ${{ inputs.ref || github.ref }} - name: Set up Python uses: actions/setup-python@v5 with: @@ -18,7 +27,6 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - pip install -r requirements.txt pip install build - name: Build the package diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 6ce033e..2fa62d9 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -2,33 +2,30 @@ name: test on: push: - branches: ["*","!master"] + branches: ["*", "!main"] + pull_request: + branches: ["main"] jobs: test: runs-on: ubuntu-latest - strategy: - matrix: - python-version: ["3.9", "3.12"] steps: - uses: actions/checkout@v4 - - name: show directory tree - run: ls -R . - - name: Set up Python ${{ matrix.python-version }} + - name: Set up Python 3.13 uses: actions/setup-python@v5 with: - python-version: ${{ matrix.python-version }} - cache: 'pip' + python-version: "3.13" + cache: "pip" - name: Install dependencies run: | python -m pip install --upgrade pip - pip install -r requirements.txt - name: Install autoreduce - run: pip install ".[all, test]" + run: pip install -e ".[test]" - name: Test autoreduce - run: pytest --cov --junitxml=junit.xml -o junit_family=legacy - - name: Upload test results to Codecov + run: pytest --cov=autoreduce --cov-report=xml --junitxml=junit.xml -o junit_family=legacy + - name: Upload coverage to Codecov if: ${{ !cancelled() }} - uses: codecov/test-results-action@v1 + uses: codecov/codecov-action@v4 with: + fail_ci_if_error: false token: ${{ secrets.CODECOV_TOKEN }} diff --git a/.gitignore b/.gitignore index 1931718..3f4974b 100644 --- a/.gitignore +++ b/.gitignore @@ -61,6 +61,7 @@ instance/ # Sphinx documentation docs/_build/ +docs/generated/ # PyBuilder target/ @@ -107,3 +108,12 @@ dmypy.json # Package specific examples/reduced_gene_expression.xml +autoreduce/_version.py +examples/biological/models/design1_regulated_promoter.xml +examples/biological/models/example_1.xml +examples/biological/models/example1.xml +examples/biological/models/reduced_gene_expression.xml +examples/biological/models/reduced_gfp_expression.xml +*.xml +*.pptx +*.png diff --git a/.readthedocs.yaml b/.readthedocs.yaml index 6341bf6..3ea7846 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -9,12 +9,15 @@ version: 2 build: os: ubuntu-24.04 tools: - python: "3.13" + python: "3.12" # Build documentation in the docs/ directory with Sphinx sphinx: configuration: docs/conf.py python: - install: - - requirements: docs/requirements.txt + install: + - method: pip + path: . + extra_requirements: + - docs diff --git a/.vscode/settings.json b/.vscode/settings.json index 24c2a3f..6179e79 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,5 +1,6 @@ { - "python.pythonPath": "C:\\Users\\apand\\Anaconda3\\python.exe", + "python.pythonPath": "C:\\Users\\ayush\\anaconda3\\Scripts\\conda.exe", + "python.condaPath": "C:\\Users\\ayush\\anaconda3\\Scripts\\conda.exe", "python.linting.enabled": true, "python.linting.pylintEnabled": false, "python.linting.pycodestyleEnabled": true, @@ -36,5 +37,7 @@ "black-formatter.args": [ "--line-length", "79" - ] + ], + "python-envs.defaultEnvManager": "ms-python.python:conda", + "python-envs.defaultPackageManager": "ms-python.python:conda" } diff --git a/IJRNC_examples/gene expression analysis.ipynb b/IJRNC_examples/gene expression analysis.ipynb deleted file mode 100644 index c51a275..0000000 --- a/IJRNC_examples/gene expression analysis.ipynb +++ /dev/null @@ -1,1467 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "$G_i + P \\quad[k^{b_P}_i]<->[k^{u_P}_i] \\quad G_i:P \\\\\n", - "G_i:P \\quad --> [k_i^{tx}] \\quad G_i + P + T_i \\\\\n", - "T_i + R \\quad [k^{b_R}_i]<->[k^{u_R}_i]\\quad T_i:R \\\\\n", - "T_i:R \\quad -->[k_i^{tl}]\\quad T_i + R + X_i \\\\\n", - "T_i + E \\quad [k^{b_E}_i]<->[k^{u_E}_i] \\quad T_i:E \\\\\n", - "T_i:E \\quad-->[\\delta_i]\\quad E \\\\\n", - "T \\quad-->[d_T]\\quad \\\\\n", - "X \\quad-->[d]\\quad $" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "from IPython.core.interactiveshell import InteractiveShell # type: ignore\n", - "InteractiveShell.ast_node_interactivity = \"all\"\n", - "from autoreduce import *\n", - "import numpy as np # type: ignore\n", - "from sympy import symbols # type: ignore" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Post conservation law and other approximations phenomenological model at the RNA level\n", - "n = 8 # Number of states : P, C1, T, R, C2, E, C3, X\n", - "nouts = 1 # Number of outputs, X_i\n", - "\n", - "# Inputs by user \n", - "x_init = np.zeros(n)\n", - "x_init[0] = 100\n", - "x_init[3] = 400\n", - "x_init[5] = 20\n", - "C = np.zeros((nouts,n), dtype=int)\n", - "C[0][7] = 1\n", - "\n", - "nstates_tol_max = 3\n", - "nsatees_tol_min = 2\n", - "error_tol = 3000\n", - "# System dynamics symbolically\n", - "\n", - "# k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d = params, len(params) = 10\n", - "\n", - "\n", - "x0 = symbols('P')\n", - "x1 = symbols('C1') # G:P\n", - "x2 = symbols('T')\n", - "x3 = symbols('R')\n", - "x4 = symbols('C2') # T:R\n", - "x5 = symbols('E')\n", - "x6 = symbols('C3') # T:E\n", - "x7 = symbols('X')\n", - "\n", - "x = [x0, x1, x2, x3, x4, x5, x6, x7]\n", - "\n", - "G = symbols('G')\n", - "k_bp = symbols('k_bp')\n", - "k_up = symbols('k_up')\n", - "k_tx = symbols('k_tx')\n", - "k_br = symbols('k_br')\n", - "k_ur = symbols('k_ur')\n", - "k_tl = symbols('k_tl')\n", - "k_be = symbols('k_be')\n", - "k_ue = symbols('k_ue')\n", - "d_i = symbols('d_i')\n", - "d = symbols('d')\n", - "d_T = symbols('d_T')\n", - "\n", - "E_tot = symbols('E_tot')\n", - "P_tot = symbols('P_tot')\n", - "R_tot = symbols('R_tot')\n", - "params = [k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d, d_T, E_tot, P_tot, R_tot, G]\n", - "# f0 = (k_bp + k_tx) * x1 - k_up * G * x0\n", - "f0 = (k_up + k_tx) * x1 - k_bp * G * x0\n", - "f1 = k_bp * G * x0 - (k_up + k_tx)*x1\n", - "f2 = k_tx * x1 + (k_ur + k_tl) * x4 + k_ue * x6 - k_br * x2 * x3 - k_be * x2 * x5 - d_T * x2\n", - "f3 = (k_ur + k_tl) * x4 - k_br * x2 * x3\n", - "f4 = k_br * x2 * x3 - (k_ur + k_tl) * x4\n", - "f5 = (k_ue + d_i) * x6 - k_be * x2 * x5\n", - "f6 = k_be * x2 * x5 - (k_ue + d_i) * x6\n", - "f7 = k_tl * x4 - d * x7\n", - " \n", - "f = [f0,f1,f2,f3,f4,f5,f6,f7]\n", - "# parameter values\n", - "# E_tot = 20\n", - "# P_tot = 100\n", - "# R_tot = 400\n", - "params_values = [80, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 100, 400, 10]\n", - "# params_values = [100, 10, 4, 10, 0.25, 2, 10, 0.5, 1, 1, 1000, 1000, 1000, 10]\n", - "sys = System(x, f, params = params, params_values = params_values, C = C, x_init = x_init)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Time')" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, '[Outputs]')" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from autoreduce.utils import get_ODE\n", - "timepoints_ode = np.linspace(0, 24, 100)\n", - "sys_ode = get_ODE(sys, timepoints_ode)\n", - "sol = sys_ode.solve_system().T\n", - "try:\n", - " import matplotlib.pyplot as plt # type: ignore\n", - " plt.plot(timepoints_ode, np.transpose(np.array(C)@sol));\n", - " plt.xlabel('Time');\n", - " plt.ylabel('[Outputs]');\n", - " plt.show();\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "from autoreduce.utils import get_reducible\n", - "timepoints_ssm = np.linspace(0,2,10)\n", - "timepoints_ode = np.linspace(0,2,100)\n", - "sys_reduce = get_reducible(sys, timepoints_ode, timepoints_ssm)\n", - "sys_reduce.nstates_tol_min = 2\n", - "sys_reduce.nstates_tol_max = 3" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "P, C1, T, R, C2, E, C3, X = sys.x\n", - "conserved_quantities = [P + C1 - P_tot, R + C2 - R_tot, E + C3 - E_tot]\n", - "states_to_eliminate = [C1, C2, C3]\n", - "f_cons = sys_reduce.set_conservation_laws(conserved_quantities, states_to_eliminate)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[-G*P*k_bp + (-P + P_tot)*(k_tx + k_up),\n", - " -E*T*k_be - R*T*k_br - T*d_T + k_tx*(-P + P_tot) + k_ue*(-E + E_tot) + (-R + R_tot)*(k_tl + k_ur),\n", - " -R*T*k_br + (-R + R_tot)*(k_tl + k_ur),\n", - " -E*T*k_be + (-E + E_tot)*(d_i + k_ue),\n", - " -X*d + k_tl*(-R + R_tot)]" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "f_cons" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Time')" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, '[X]')" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from autoreduce.utils import get_ODE\n", - "timepoints_ode = np.linspace(0, 24, 100)\n", - "# params = [k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d, E_tot, P_tot, R_tot, G]\n", - "# params_values = [100, 10, 4, 10, 0.25, 2, 10, 0.5, 1, 10, 10000, 10000, 10000, 0.01]\n", - "# params_values = [30, 10, 0.50, 80, 2, 8, 10, 2, 1, 0.5, 0.01, 20, 100, 400, 10]\n", - "# sys_reduce.params_values = params_values\n", - "sys_ode = get_ODE(sys_reduce, timepoints_ode)\n", - "sol = sys_ode.solve_system().T\n", - "try:\n", - " import matplotlib.pyplot as plt # type: ignore\n", - " fig, ax = plt.subplots()\n", - " plt.plot(timepoints_ode, np.transpose(np.array(sys_reduce.C)@sol), linewidth = 3)\n", - " plt.xlabel('Time', fontsize = 18)\n", - " plt.ylabel('[X]', fontsize = 18)\n", - " ax.tick_params(axis='both', which='major', labelsize=14)\n", - " # plt.legend()\n", - " plt.show();\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[-G*P*k_bp + (-P + P_tot)*(k_tx + k_up),\n", - " -E*T*k_be - R*T*k_br - T*d_T + k_tx*(-P + P_tot) + k_ue*(-E + E_tot) + (-R + R_tot)*(k_tl + k_ur),\n", - " -R*T*k_br + (-R + R_tot)*(k_tl + k_ur),\n", - " -E*T*k_be + (-E + E_tot)*(d_i + k_ue),\n", - " -X*d + k_tl*(-R + R_tot)]" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sys_reduce.f" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[P, T, R, E, X]" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sys_reduce.x" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful time-scale separation solution obtained with states: [T, R, X]!\n" - ] - } - ], - "source": [ - "reduced_sys_trx, fast_ss = sys_reduce.solve_timescale_separation([T, R, X], fast_states = [P, E], debug = False)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle \\frac{- E_{tot} T d_{i} k_{be} \\left(G k_{bp} + k_{tx} + k_{up}\\right) + G P_{tot} k_{bp} k_{tx} \\left(T k_{be} + d_{i} + k_{ue}\\right) - \\left(G k_{bp} + k_{tx} + k_{up}\\right) \\left(T k_{be} + d_{i} + k_{ue}\\right) \\left(R T k_{br} + T d_{T} + \\left(R - R_{tot}\\right) \\left(k_{tl} + k_{ur}\\right)\\right)}{\\left(G k_{bp} + k_{tx} + k_{up}\\right) \\left(T k_{be} + d_{i} + k_{ue}\\right)}$" - ], - "text/plain": [ - "(-E_tot*T*d_i*k_be*(G*k_bp + k_tx + k_up) + G*P_tot*k_bp*k_tx*(T*k_be + d_i + k_ue) - (G*k_bp + k_tx + k_up)*(T*k_be + d_i + k_ue)*(R*T*k_br + T*d_T + (R - R_tot)*(k_tl + k_ur)))/((G*k_bp + k_tx + k_up)*(T*k_be + d_i + k_ue))" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "reduced_sys_trx.f[0]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Reduced model (obtained using time-scale separation above) vs Full model" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "reduced_sys = reduced_sys_trx\n", - "try:\n", - " fig, ax = plt.subplots() \n", - " # params = [k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d, d_T, E_tot, P_tot, R_tot, G]\n", - " params_values_new = [80, 2, 0.5, 80, 2, 0.5, 8, 0.2, 0.1, 0.5, 0.05, 100, 100, 400, 0.1]\n", - " # Set new parameters \n", - " sys.params_values = params_values_new\n", - " reduced_sys.params_values = params_values_new\n", - " # Set new initial conditions \n", - " sys.x_init[0] = params_values_new[-3]\n", - " sys.x_init[3] = params_values_new[-2]\n", - " sys.x_init[5] = params_values_new[-4]\n", - " if P in reduced_sys.x:\n", - " ind = reduced_sys.x.index(P)\n", - " reduced_sys.x_init[ind] = params_values[-3]\n", - " if R in reduced_sys.x:\n", - " ind = reduced_sys.x.index(R)\n", - " reduced_sys.x_init[ind] = params_values[-2]\n", - " if E in reduced_sys.x:\n", - " ind = reduced_sys.x.index(E)\n", - " reduced_sys.x_init[ind] = params_values[-4]\n", - " # Solve ODEs and plot\n", - " sys_ode = get_ODE(sys, timepoints_ode)\n", - " sol = sys_ode.solve_system().T\n", - " _ = plt.plot(timepoints_ode, np.transpose(np.array(sys.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - " reduced_ode = get_ODE(reduced_sys, timepoints_ode)\n", - " reduced_sol = reduced_ode.solve_system().T\n", - " _ = plt.plot(timepoints_ode, np.transpose(np.array(reduced_sys.C)@reduced_sol), 'r', label = 'Reduced model', linewidth = 2)\n", - " \n", - " plt.savefig('trx.svg')\n", - " plt.show()\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Robustness [T, R, X]" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - } - ], - "source": [ - "Se_trx = sys_reduce.get_robustness_metric(reduced_sys_trx)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([3.83705486e+00, 3.36388190e+00, 8.76099204e-01, 2.00297842e-01,\n", - " 3.83705488e+00, 3.83705470e+00, 2.00297556e-01, 1.97825897e+04,\n", - " 5.23385286e-08, 1.79232933e+02, 5.08471194e-07, 6.58560796e-08,\n", - " 1.39836314e+02, 2.74921437e+01, 2.74921441e+01]),\n", - " 0.003875416964245933)" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Se_trx" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Uncomment to run all the other reduced models." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# [T, X] model" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful time-scale separation solution obtained with states: [T, X]!\n" - ] - } - ], - "source": [ - "reduced_sys_tx, fast_ss = sys_reduce.solve_timescale_separation([T, X], fast_states = [P, R, E], debug = False)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "Robustness Metric Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - } - ], - "source": [ - "# Se_tx = sys_reduce.get_robustness_metric(reduced_sys_tx)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful time-scale separation solution obtained with states: [T, E, X]!\n" - ] - } - ], - "source": [ - "# reduced_sys_tex, fast_ss = sys_reduce.solve_timescale_separation([T, E, X], fast_states = [P, R], debug = False)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "Robustness Metric Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - } - ], - "source": [ - "# Se_tex = sys_reduce.get_robustness_metric(reduced_sys_tex)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful time-scale separation solution obtained with states: [P, R, X]!\n" - ] - } - ], - "source": [ - "# reduced_sys_prx, fast_ss = sys_reduce.solve_timescale_separation([P, R, X], fast_states = [T, E], debug = False)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "Robustness Metric Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - } - ], - "source": [ - "# Se_prx = sys_reduce.get_robustness_metric(reduced_sys_prx)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful time-scale separation solution obtained with states: [P, T, X]!\n" - ] - } - ], - "source": [ - "# reduced_sys_ptx, fast_ss = sys_reduce.solve_timescale_separation([P, T, X], fast_states = [R, E], debug = False)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "Robustness Metric Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - } - ], - "source": [ - "# Se_ptx = sys_reduce.get_robustness_metric(reduced_sys_ptx)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful time-scale separation solution obtained with states: [R, E, X]!\n" - ] - } - ], - "source": [ - "# reduced_sys_rex, fast_ss = sys_reduce.solve_timescale_separation([R, E, X], fast_states = [P, T], debug = False)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "Robustness Metric Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - } - ], - "source": [ - "# Se_rex = sys_reduce.get_robustness_metric(reduced_sys_rex)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Summarize all results and plot together:" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [], - "source": [ - "# list_reduced_sys = [reduced_sys_tx, reduced_sys_trx, reduced_sys_tex, reduced_sys_ptx, reduced_sys_rex]\n", - "# list_Se = [Se_tx, Se_trx, Se_tex, Se_ptx, Se_rex]\n", - "# results = {}\n", - "# for sys_i, Se_i in zip(list_reduced_sys, list_Se):\n", - "# results[sys_i] = [0, Se_i]" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{: [0,\n", - " array([4.01010552e+00, 4.00190311e+00, 4.00045764e+00, 4.01524248e+00,\n", - " 4.02930535e+00, 1.33032194e+03, 4.00063837e+00, 4.00253744e+00,\n", - " 4.00029480e+00, 7.12978562e+05, 4.00000180e+00, 4.01821795e+00,\n", - " 4.00071742e+00, 4.73181094e+02, 4.00180321e+00])],\n", - " : [0,\n", - " array([2.34797304e+14, 1.06001240e+17, 6.80058919e+17, 2.67590553e+16,\n", - " 2.19708962e+17, 9.65207085e+15, 3.79110429e+16, 4.19550099e+16,\n", - " 6.12252762e+16, 1.46880080e+16, 1.04076100e+17, 9.15204508e+16,\n", - " 3.15062972e+16, 1.75632793e+16, 6.06933058e+17])],\n", - " : [0,\n", - " array([1.02582593e+15, 5.70223611e+17, 4.10266873e+18, 1.41079850e+18,\n", - " 1.64965843e+18, 5.19174398e+16, 2.35612025e+17, 2.21166126e+17,\n", - " 1.03221762e+19, 1.66635739e+17, 6.05365149e+17, 4.12377641e+18,\n", - " 1.69468548e+17, 8.42525662e+14, 3.26126391e+18])],\n", - " : [0,\n", - " array([1.02582591e+15, 5.70160468e+17, 4.10279073e+18, 1.43933547e+17,\n", - " 1.65529800e+18, 5.19194805e+16, 1.93130444e+17, 5.62395436e+17,\n", - " 3.27077618e+17, 1.88286275e+15, 4.08027114e+17, 2.25640738e+18,\n", - " 1.69469658e+17, 4.72063691e+15, 3.26126389e+18])],\n", - " : [0,\n", - " array([3.55857269e+15, 5.73075320e+17, 3.03540902e+18, 1.44051163e+17,\n", - " 2.53015870e+17, 5.21024887e+16, 2.36534933e+17, 2.23459324e+17,\n", - " 3.31567557e+17, 2.82642221e+16, 1.18014351e+17, 1.42858033e+17,\n", - " 1.69468479e+17, 8.42537335e+14, 3.26126477e+18])]}" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# results" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Limited Resource - RNAP (strict)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "# fig, ax = plt.subplots() \n", - "# count = 0\n", - "# # params = [k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d, d_T, E_tot, P_tot, R_tot, G]\n", - "# # params_values = [80, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 100, 400, 10]\n", - "\n", - "# params_values_new = [80, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 40, 400, 0.1]\n", - "# sys.params_values = params_values_new\n", - "# sys.x_init[0] = params_values_new[-3]\n", - "# sys.x_init[3] = params_values_new[-2]\n", - "# sys.x_init[5] = params_values_new[-4]\n", - "# # print(sys.x_init)\n", - "# timepoints_ode = np.linspace(0,40,100)\n", - "# sys_ode = get_ODE(sys, timepoints_ode)\n", - "# sol = sys_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(np.array(sys.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - "# for key,value in results.items():\n", - "# # error = value[0]\n", - "# # if error > 1e-5:\n", - "# sys_i = key\n", - "# sys_i.params_values = params_values_new\n", - "# if P in sys_i.x:\n", - "# ind = sys_i.x.index(P)\n", - "# sys_i.x_init[ind] = params_values[-3]\n", - "# if R in sys_i.x:\n", - "# ind = sys_i.x.index(R)\n", - "# sys_i.x_init[ind] = params_values[-2]\n", - "# if E in sys_i.x:\n", - "# ind = sys_i.x.index(E)\n", - "# sys_i.x_init[ind] = params_values[-4]\n", - "# if len(sys_i.x) >=4:\n", - "# continue\n", - "# # _ = plt.subplots(count%3, count%3)\n", - "# sys_i_ode = get_ODE(sys_i, timepoints_ode)\n", - "# sol_i = sys_i_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(sys_i.C@sol_i), label = str(sys_i.x), linewidth = 2)\n", - "# _ = plt.xlabel('Time', FontSize = 18)\n", - "# _ = plt.ylabel('[X]', FontSize = 18)\n", - "# _ = ax.tick_params(axis='both', which='major', labelsize=14)\n", - "# _ = plt.legend(prop={'size': 8})\n", - "# count += 1\n", - "\n", - "# # _ = plt.axvline(x=timepoints_ode[6], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[15], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[30], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# _ = plt.savefig('resource_strict.svg')\n", - "# plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Limited Resource - RNAP (mild)" - ] - }, - { - "cell_type": "code", - "execution_count": 369, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# fig, ax = plt.subplots() \n", - "# count = 0\n", - "# # params = [k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d, d_T, E_tot, P_tot, R_tot, G]\n", - "# # params_values = [80, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 100, 400, 10]\n", - "\n", - "# params_values_new = [80, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 80, 400, 0.1]\n", - "# sys.params_values = params_values_new\n", - "# sys.x_init[0] = params_values_new[-3]\n", - "# sys.x_init[3] = params_values_new[-2]\n", - "# sys.x_init[5] = params_values_new[-4]\n", - "# # print(sys.x_init)\n", - "# timepoints_ode = np.linspace(0,24,100)\n", - "# sys_ode = get_ODE(sys, timepoints_ode)\n", - "# sol = sys_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(np.array(sys.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - "# for key,value in results.items():\n", - "# sys_i = key\n", - "# sys_i.params_values = params_values_new\n", - "# if P in sys_i.x:\n", - "# ind = sys_i.x.index(P)\n", - "# sys_i.x_init[ind] = params_values[-3]\n", - "# if R in sys_i.x:\n", - "# ind = sys_i.x.index(R)\n", - "# sys_i.x_init[ind] = params_values[-2]\n", - "# if E in sys_i.x:\n", - "# ind = sys_i.x.index(E)\n", - "# sys_i.x_init[ind] = params_values[-4]\n", - "# if len(sys_i.x) >=4:\n", - "# continue\n", - "# sys_i_ode = get_ODE(sys_i, timepoints_ode)\n", - "# sol_i = sys_i_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(sys_i.C@sol_i), label = str(sys_i.x), linewidth = 2)\n", - "# _ = plt.xlabel('Time', FontSize = 18)\n", - "# _ = plt.ylabel('[X]', FontSize = 18)\n", - "# _ = ax.tick_params(axis='both', which='major', labelsize=14)\n", - "# _ = plt.legend(prop={'size': 8})\n", - "# count += 1\n", - "\n", - "# # _ = plt.axvline(x=timepoints_ode[6], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[15], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[30], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# _ = plt.savefig('resource_mild.svg')\n", - "# plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Unlimited resources" - ] - }, - { - "cell_type": "code", - "execution_count": 364, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# fig, ax = plt.subplots() \n", - "# count = 0\n", - "# # params = [k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d, d_T, E_tot, P_tot, R_tot, G]\n", - "# # params_values = [80, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 100, 400, 10]\n", - "\n", - "# params_values_new = [80, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 2000, 2000, 2000, 0.1]\n", - "# sys.params_values = params_values_new\n", - "# sys.x_init[0] = params_values_new[-3]\n", - "# sys.x_init[3] = params_values_new[-2]\n", - "# sys.x_init[5] = params_values_new[-4]\n", - "# # print(sys.x_init)\n", - "# timepoints_ode = np.linspace(0,24,100)\n", - "# sys_ode = get_ODE(sys, timepoints_ode)\n", - "# sol = sys_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(np.array(sys.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - "# for key,value in results.items():\n", - "# sys_i = key\n", - "# sys_i.params_values = params_values_new\n", - "# if P in sys_i.x:\n", - "# ind = sys_i.x.index(P)\n", - "# sys_i.x_init[ind] = params_values[-3]\n", - "# if R in sys_i.x:\n", - "# ind = sys_i.x.index(R)\n", - "# sys_i.x_init[ind] = params_values[-2]\n", - "# if E in sys_i.x:\n", - "# ind = sys_i.x.index(E)\n", - "# sys_i.x_init[ind] = params_values[-4]\n", - "# if len(sys_i.x) >=4:\n", - "# continue\n", - "# sys_i_ode = get_ODE(sys_i, timepoints_ode)\n", - "# sol_i = sys_i_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(sys_i.C@sol_i), label = str(sys_i.x), linewidth = 2)\n", - "# _ = plt.xlabel('Time', FontSize = 18)\n", - "# _ = plt.ylabel('[X]', FontSize = 18)\n", - "# _ = ax.tick_params(axis='both', which='major', labelsize=14)\n", - "# _ = plt.legend(prop={'size': 8})\n", - "# count += 1\n", - "\n", - "# # _ = plt.axvline(x=timepoints_ode[6], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[15], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[30], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# _ = plt.savefig('resource_unlimited.svg')\n", - "# plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# RBS strength (very weak)" - ] - }, - { - "cell_type": "code", - "execution_count": 356, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# fig, ax = plt.subplots() \n", - "# count = 0\n", - "# # params = [k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d, d_T, E_tot, P_tot, R_tot, G]\n", - "# # params_values = [80, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 100, 400, 10]\n", - "\n", - "# params_values_new = [80, 2, 0.50, 0.4, 4, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 100, 400, 0.1]\n", - "# sys.params_values = params_values_new\n", - "# sys.x_init[0] = params_values_new[-3]\n", - "# sys.x_init[3] = params_values_new[-2]\n", - "# sys.x_init[5] = params_values_new[-4]\n", - "# # print(sys.x_init)\n", - "# timepoints_ode = np.linspace(0,24,100)\n", - "# sys_ode = get_ODE(sys, timepoints_ode)\n", - "# sol = sys_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(np.array(sys.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - "# for key,value in results.items():\n", - "# sys_i = key\n", - "# sys_i.params_values = params_values_new\n", - "# if P in sys_i.x:\n", - "# ind = sys_i.x.index(P)\n", - "# sys_i.x_init[ind] = params_values[-3]\n", - "# if R in sys_i.x:\n", - "# ind = sys_i.x.index(R)\n", - "# sys_i.x_init[ind] = params_values[-2]\n", - "# if E in sys_i.x:\n", - "# ind = sys_i.x.index(E)\n", - "# sys_i.x_init[ind] = params_values[-4]\n", - "# if len(sys_i.x) >=4:\n", - "# continue\n", - "# sys_i_ode = get_ODE(sys_i, timepoints_ode)\n", - "# sol_i = sys_i_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(sys_i.C@sol_i), label = str(sys_i.x), linewidth = 2)\n", - "# _ = plt.xlabel('Time', FontSize = 18)\n", - "# _ = plt.ylabel('[X]', FontSize = 18)\n", - "# _ = ax.tick_params(axis='both', which='major', labelsize=14)\n", - "# _ = plt.legend(prop={'size': 8})\n", - "# count += 1\n", - "\n", - "# # _ = plt.axvline(x=timepoints_ode[6], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[15], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[30], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# _ = plt.savefig('rbs_very_weak.svg')\n", - "# plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# RBS weak (mild)" - ] - }, - { - "cell_type": "code", - "execution_count": 355, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# fig, ax = plt.subplots() \n", - "# count = 0\n", - "# # params = [k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d, d_T, E_tot, P_tot, R_tot, G]\n", - "# # params_values = [80, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 100, 400, 10]\n", - "\n", - "# params_values_new = [80, 2, 0.50, 10, 4, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 100, 400, 0.1]\n", - "# sys.params_values = params_values_new\n", - "# sys.x_init[0] = params_values_new[-3]\n", - "# sys.x_init[3] = params_values_new[-2]\n", - "# sys.x_init[5] = params_values_new[-4]\n", - "# # print(sys.x_init)\n", - "# timepoints_ode = np.linspace(0,24,100)\n", - "# sys_ode = get_ODE(sys, timepoints_ode)\n", - "# sol = sys_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(np.array(sys.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - "# for key,value in results.items():\n", - "# sys_i = key\n", - "# sys_i.params_values = params_values_new\n", - "# if P in sys_i.x:\n", - "# ind = sys_i.x.index(P)\n", - "# sys_i.x_init[ind] = params_values[-3]\n", - "# if R in sys_i.x:\n", - "# ind = sys_i.x.index(R)\n", - "# sys_i.x_init[ind] = params_values[-2]\n", - "# if E in sys_i.x:\n", - "# ind = sys_i.x.index(E)\n", - "# sys_i.x_init[ind] = params_values[-4]\n", - "# if len(sys_i.x) >=4:\n", - "# continue\n", - "# sys_i_ode = get_ODE(sys_i, timepoints_ode)\n", - "# sol_i = sys_i_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(sys_i.C@sol_i), label = str(sys_i.x), linewidth = 2)\n", - "# _ = plt.xlabel('Time', FontSize = 18)\n", - "# _ = plt.ylabel('[X]', FontSize = 18)\n", - "# _ = ax.tick_params(axis='both', which='major', labelsize=14)\n", - "# _ = plt.legend(prop={'size': 8})\n", - "# count += 1\n", - "\n", - "# # _ = plt.axvline(x=timepoints_ode[6], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[15], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[30], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# _ = plt.savefig('rbs_weak_mild.svg')\n", - "# plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Polymerase very weak " - ] - }, - { - "cell_type": "code", - "execution_count": 370, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# fig, ax = plt.subplots() \n", - "# count = 0\n", - "# # params = [k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d, d_T, E_tot, P_tot, R_tot, G]\n", - "# # params_values = [80, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 100, 400, 10]\n", - "\n", - "# params_values_new = [10, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 100, 400, 0.1]\n", - "# sys.params_values = params_values_new\n", - "# sys.x_init[0] = params_values_new[-3]\n", - "# sys.x_init[3] = params_values_new[-2]\n", - "# sys.x_init[5] = params_values_new[-4]\n", - "# # print(sys.x_init)\n", - "# timepoints_ode = np.linspace(0,40,100)\n", - "# sys_ode = get_ODE(sys, timepoints_ode)\n", - "# sol = sys_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(np.array(sys.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - "# for key,value in results.items():\n", - "# sys_i = key\n", - "# sys_i.params_values = params_values_new\n", - "# if P in sys_i.x:\n", - "# ind = sys_i.x.index(P)\n", - "# sys_i.x_init[ind] = params_values[-3]\n", - "# if R in sys_i.x:\n", - "# ind = sys_i.x.index(R)\n", - "# sys_i.x_init[ind] = params_values[-2]\n", - "# if E in sys_i.x:\n", - "# ind = sys_i.x.index(E)\n", - "# sys_i.x_init[ind] = params_values[-4]\n", - "# if len(sys_i.x) >=4:\n", - "# continue\n", - "# sys_i_ode = get_ODE(sys_i, timepoints_ode)\n", - "# sol_i = sys_i_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(sys_i.C@sol_i), label = str(sys_i.x), linewidth = 2)\n", - "# _ = plt.xlabel('Time', FontSize = 18)\n", - "# _ = plt.ylabel('[X]', FontSize = 18)\n", - "# _ = ax.tick_params(axis='both', which='major', labelsize=14)\n", - "# _ = plt.legend(prop={'size': 8})\n", - "# count += 1\n", - "\n", - "# # _ = plt.axvline(x=timepoints_ode[6], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[15], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[30], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# _ = plt.savefig('RNAP_weak_strict.svg')\n", - "# plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# RNAP weak (mild)" - ] - }, - { - "cell_type": "code", - "execution_count": 373, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# fig, ax = plt.subplots() \n", - "# count = 0\n", - "# # params = [k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d, d_T, E_tot, P_tot, R_tot, G]\n", - "# # params_values = [80, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 100, 400, 10]\n", - "\n", - "# params_values_new = [30, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 100, 400, 0.1]\n", - "# sys.params_values = params_values_new\n", - "# sys.x_init[0] = params_values_new[-3]\n", - "# sys.x_init[3] = params_values_new[-2]\n", - "# sys.x_init[5] = params_values_new[-4]\n", - "# # print(sys.x_init)\n", - "# timepoints_ode = np.linspace(0,30,100)\n", - "# sys_ode = get_ODE(sys, timepoints_ode)\n", - "# sol = sys_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(np.array(sys.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - "# for key,value in results.items():\n", - "# sys_i = key\n", - "# sys_i.params_values = params_values_new\n", - "# if P in sys_i.x:\n", - "# ind = sys_i.x.index(P)\n", - "# sys_i.x_init[ind] = params_values[-3]\n", - "# if R in sys_i.x:\n", - "# ind = sys_i.x.index(R)\n", - "# sys_i.x_init[ind] = params_values[-2]\n", - "# if E in sys_i.x:\n", - "# ind = sys_i.x.index(E)\n", - "# sys_i.x_init[ind] = params_values[-4]\n", - "# if len(sys_i.x) >=4:\n", - "# continue\n", - "# sys_i_ode = get_ODE(sys_i, timepoints_ode)\n", - "# sol_i = sys_i_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(sys_i.C@sol_i), label = str(sys_i.x), linewidth = 2)\n", - "# _ = plt.xlabel('Time', FontSize = 18)\n", - "# _ = plt.ylabel('[X]', FontSize = 18)\n", - "# _ = ax.tick_params(axis='both', which='major', labelsize=14)\n", - "# _ = plt.legend(prop={'size': 8})\n", - "# count += 1\n", - "\n", - "# # _ = plt.axvline(x=timepoints_ode[6], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[15], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[30], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# _ = plt.savefig('RNAP_weak_mild.svg')\n", - "# plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Endonuclease binding" - ] - }, - { - "cell_type": "code", - "execution_count": 417, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# fig, ax = plt.subplots() \n", - "# count = 0\n", - "# # params = [k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d, d_T, E_tot, P_tot, R_tot, G]\n", - "# # params_values = [80, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 100, 400, 10]\n", - "\n", - "# params_values_new = [80, 2, 0.50, 80, 2, 0.5, 1, 40, 0.1, 0.5, 0.01, 100, 100, 400, 0.1]\n", - "# sys.params_values = params_values_new\n", - "# sys.x_init[0] = params_values_new[-3]\n", - "# sys.x_init[3] = params_values_new[-2]\n", - "# sys.x_init[5] = params_values_new[-4]\n", - "# # print(sys.x_init)\n", - "# timepoints_ode = np.linspace(0,24,100)\n", - "# sys_ode = get_ODE(sys, timepoints_ode)\n", - "# sol = sys_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(np.array(sys.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - "# for key,value in results.items():\n", - "# sys_i = key\n", - "# sys_i.params_values = params_values_new\n", - "# if P in sys_i.x:\n", - "# ind = sys_i.x.index(P)\n", - "# sys_i.x_init[ind] = params_values[-3]\n", - "# if R in sys_i.x:\n", - "# ind = sys_i.x.index(R)\n", - "# sys_i.x_init[ind] = params_values[-2]\n", - "# if E in sys_i.x:\n", - "# ind = sys_i.x.index(E)\n", - "# sys_i.x_init[ind] = params_values[-4]\n", - "# if len(sys_i.x) >=4:\n", - "# continue\n", - "# sys_i_ode = get_ODE(sys_i, timepoints_ode)\n", - "# sol_i = sys_i_ode.solve_system().T\n", - "# _ = plt.plot(timepoints_ode, np.transpose(sys_i.C@sol_i), label = str(sys_i.x), linewidth = 2)\n", - "# _ = plt.xlabel('Time', FontSize = 18)\n", - "# _ = plt.ylabel('[X]', FontSize = 18)\n", - "# _ = ax.tick_params(axis='both', which='major', labelsize=14)\n", - "# _ = plt.legend(prop={'size': 8})\n", - "# count += 1\n", - "\n", - "# # _ = plt.axvline(x=timepoints_ode[6], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[15], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# # _ = plt.axvline(x=timepoints_ode[30], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# _ = plt.savefig('endo_weak_strict.svg')\n", - "# plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(5.5, -0.5)" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# # fig, ax = plt.subplots() \n", - "# fig = plt.figure(num=None, figsize=(10, 8), dpi=80, facecolor='w', edgecolor='k')\n", - "# # count = 0\n", - "# import seaborn as sn\n", - "# # params_names = ['$'+str(i)+'$' for i in params]\n", - "# params_names = ['$k_{bp}$', '$k_{up}$', '$k_{tx}$', '$k_{br}$', '$k_{ur}$', '$k_{tl}$',\n", - "# '$k_{be}$', '$k_{ue}$', '$d_E$',\n", - "# '$d_X$', '$d_T$', '$E_{tot}$', '$P_{tot}$', '$R_{tot}$']\n", - "\n", - "# rob_2d_all = []\n", - "# rob_2d = []\n", - "# sys_reduced_x = []\n", - "# # plt.plot(timepoints_ode, np.transpose(np.array(sys_reduce.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - "# # params_names[0] = '$k_b$'\n", - "# for key,value in results.items():\n", - "# sys_i = key\n", - "# Se = value[1]\n", - "# Se = np.delete(Se, [14])\n", - "# if len(sys_i.x) >= 4:\n", - "# continue\n", - "# sys_reduced_x.append(str(sys_i.x))\n", - "# rob_2d.append(Se)\n", - "# # rob_2d = [ Se_x, Se_tx, Se_rx, Se_px]\n", - "# sn_ax = sn.heatmap(np.array(rob_2d), cbar_kws={'label': 'Robustness metric ($\\|S_e\\|$)', \n", - "# 'orientation':'horizontal','fraction':0.2,\n", - "# })\n", - "\n", - "# # cbar_axes = sn_ax.figure.axes[-1]\n", - "# sn_ax.figure.axes[-1].xaxis.label.set_size(20)\n", - "# ax = fig.axes\n", - "# _ = plt.xlabel('All Parameters', FontSize = 20)\n", - "# _ = plt.ylabel('Reduced models', FontSize = 20)\n", - "# _ = ax[0].tick_params(axis='x', which='major', labelsize=18)\n", - "# _ = ax[0].tick_params(axis='y', which='major', labelsize=18)\n", - "# _ = ax[0].set_xticklabels(params_names)\n", - "# _ = ax[1].tick_params(axis = 'x', labelsize = 18)\n", - "# bottom, top = ax[0].get_ylim()\n", - "# ax[0].set_ylim(bottom + 0.5, top - 0.5)\n", - "# _ = ax[0].set_yticklabels(sys_reduced_x, rotation = 0)\n", - "# # h.set_rotation(0)\n", - "# _ = plt.savefig('robustness_with_all.svg')\n", - "# plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(5.5, -0.5)" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# # fig, ax = plt.subplots() \n", - "# fig = plt.figure(num=None, figsize=(8, 8), dpi=80, facecolor='w', edgecolor='k')\n", - "# # count = 0\n", - "# import seaborn as sn\n", - "# # params_names = ['$'+str(i)+'$' for i in params]\n", - "# params_names = ['$k_{bp}$', '$k_{up}$', '$k_{tx}$', '$k_{br}$', '$k_{ur}$', '$k_{tl}$',\n", - "# '$k_{be}$', '$k_{ue}$', '$d_E$',\n", - "# '$d_X$', '$d_T$', '$E_{tot}$', '$P_{tot}$', '$R_{tot}$']\n", - "# # params_names = ['$k_{bp}$', '$k_{up}$', '$k_{tx}$', '$k_{ur}$',\n", - "# # '$k_{be}$', '$k_{ue}$', '$d_E$',\n", - "# # '$d_T$', '$E_{tot}$', '$P_{tot}$']\n", - "\n", - "# rob_2d_all = []\n", - "# rob_2d = []\n", - "# sys_reduced_x = []\n", - "# # plt.plot(timepoints_ode, np.transpose(np.array(sys_reduce.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - "# # params_names[0] = '$k_b$'\n", - "# for key,value in results.items():\n", - "# sys_i = key\n", - "# Se = value[1]\n", - "# Se = np.delete(Se, [14])\n", - "\n", - "# if len(sys_i.x) >= 4:\n", - "# continue\n", - "# sys_reduced_x.append(str(sys_i.x))\n", - "# rob_2d.append(Se)\n", - "# # rob_2d = [ Se_x, Se_tx, Se_rx, Se_px]\n", - "# sn_ax = sn.heatmap(np.array(rob_2d), cbar_kws={'label': 'Robustness metric ($\\|S_e\\|$)', \n", - "# 'orientation':'horizontal','fraction':0.2,\n", - "# })\n", - "\n", - "# # cbar_axes = sn_ax.figure.axes[-1]\n", - "# sn_ax.figure.axes[-1].xaxis.label.set_size(20)\n", - "# ax = fig.axes\n", - "# _ = plt.xlabel('All Parameters', FontSize = 20)\n", - "# _ = plt.ylabel('Reduced models', FontSize = 20)\n", - "# _ = ax[0].tick_params(axis='x', which='major', labelsize=18)\n", - "# _ = ax[0].tick_params(axis='y', which='major', labelsize=18)\n", - "# _ = ax[0].set_xticklabels(params_names)\n", - "# _ = ax[1].tick_params(axis = 'x', labelsize = 18)\n", - "# bottom, top = ax[0].get_ylim()\n", - "# ax[0].set_ylim(bottom + 0.5, top - 0.5)\n", - "# _ = ax[0].set_yticklabels(sys_reduced_x, rotation = 0)\n", - "# # h.set_rotation(0)\n", - "# _ = plt.savefig('robustness_except_ktl.svg')\n", - "# plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "py311-new", - "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.11.13" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/IJRNC_examples/population-control.ipynb b/IJRNC_examples/population-control.ipynb deleted file mode 100644 index df5dc26..0000000 --- a/IJRNC_examples/population-control.ipynb +++ /dev/null @@ -1,924 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from autoreduce import *\n", - "import numpy as np\n", - "from sympy import symbols" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "n = 8 # Number of states \n", - "x_init = np.zeros(n)\n", - "x_init[6] = 100\n", - "x_init[7] = 500\n", - "timepoints_ode = np.linspace(0, 40, 100)\n", - "error_tol = 1000\n", - "nstates_tol = 5\n", - "# x = 0, T1, 1, A1, 2, S1, 3, S2, 4, T2, 5, A2, 6, C1, 7, C2\n", - "# P = 0, beta_S1, 1, l_S1, 2, K_S1, 3, kb, 4, beta_S2, 5, l_S2, 6,\n", - "# K_S2, 7, beta_lac, 8, l_lac, 9, K_lac, 10, beta_tet, 11, l_tet, 12,\n", - "# K_tet, 13, kc, 14, C_max, 15, dc, 16, 17, I, 18, atc, 20,K_tox\n", - "P = np.zeros(22)\n", - "P[0] = 6\n", - "P[1] = 2e-3\n", - "P[2] = 430\n", - "P[3] = 30\n", - "P[4] = 6\n", - "P[5] = 2e-3\n", - "P[6] = 190\n", - "P[7] = 19.8e-3\n", - "P[8] = 1.5e-3\n", - "P[9] = 1.4e5\n", - "P[10] = 14.4e-3\n", - "P[11] = 2.1e-4\n", - "P[12] = 13\n", - "P[13] = 0.6\n", - "P[14] = 5500\n", - "P[15] = 0.8\n", - "P[16] = 1e6 #17 -> 16\n", - "P[17] = 324 # 19 -> 17\n", - "P[18] = 1 #20 -> 18\n", - "P[19] = 0.1 #21 -> 19\n", - "P[20] = 1.5 #22 -> 20\n", - "P[21] = 0.5 #23 ->21\n", - "params_values = P.copy()\n", - "\n", - "params = P\n", - "n = 8\n", - "x, f, P = load_ODE_model(n, len(params_values))\n", - "\n", - "beta_S1 = symbols('beta_S1')\n", - "l_S1 = symbols('l_S1')\n", - "K_S1 = symbols('K_S1')\n", - "kb = symbols('kb')\n", - "beta_S2 = symbols('beta_S2')\n", - "l_S2 = symbols('l_S2')\n", - "K_S2 = symbols('K_S2')\n", - "beta_lac = symbols('beta_lac')\n", - "l_lac = symbols('l_lac')\n", - "K_lac = symbols('K_lac')\n", - "beta_tet = symbols('beta_tet')\n", - "l_tet = symbols('l_tet')\n", - "K_tet = symbols('K_tet')\n", - "kc = symbols('kc')\n", - "C_max = symbols('C_max')\n", - "dc = symbols('dc')\n", - "I = symbols('I')\n", - "atc = symbols('atc')\n", - "K_tox = symbols('K_tox')\n", - "d = symbols('d')\n", - "d_T = symbols('d_T')\n", - "d_S = symbols('d_S')\n", - "P = [beta_S1, l_S1, K_S1, kb, beta_S2, l_S2, K_S2, beta_lac, l_lac, \n", - " K_lac, beta_tet, l_tet, K_tet, kc, C_max, dc, I,\n", - " atc, K_tox, d, d_T, d_S]\n", - "y0 = symbols('y0')\n", - "y1 = symbols('y1')\n", - "\n", - "# T1 and A1\n", - "f[0] = P[0]*(P[1] + x[2]**2/(P[2]+x[2]**2)) - P[3]*x[0]*x[1] - P[20] * x[0]\n", - "f[1] = 5*P[4]*(P[5] + x[3]**2/(P[6]+x[3]**2)) - P[20] * x[1] - P[3]*x[0]*x[1]\n", - "\n", - "\n", - "# f[0] = P[0]*(x[2]**2/(P[2]+x[2]**2)) - P[3]*x[0]*x[1]\n", - "# f[1] = P[4]*(x[3]**2/(P[6]+x[3]**2)) - P[3]*x[0]*x[1]\n", - "\n", - "# S1 and S2 (scaled with cell count)\n", - "f[2] = P[7]*(P[8] + P[16]**2/(P[9]+P[16]**2))*x[6] - P[21] * x[2]\n", - "f[3] = P[10]*(P[11] + P[17]**2/(P[12]+P[17]**2))*x[7] - P[21] * x[3]\n", - "\n", - "# f[2] = P[7]*(P[16]**2/(P[9]+P[16]**2))*x[6] - P[21] * x[2]\n", - "# f[3] = P[10]*(P[17]**2/(P[12]+P[17]**2))*x[7] - P[21] * x[3]\n", - "\n", - "# T2 and A2\n", - "f[4] = P[4]*(P[5] + x[3]**2/(P[6]+x[3]**2)) - P[3]*x[4]*x[5] - P[20] * x[4]\n", - "f[5] = 5*P[0]*(P[1] + x[2]**2/(P[2]+x[2]**2)) - P[20] * x[5]-P[3]*x[4]*x[5]\n", - "\n", - "# f[4] = P[4]*(x[3]**2/(P[6]+x[3]**2)) - P[3]*x[4]*x[5] - P[20] * x[4]\n", - "# f[5] = P[0]*(x[2]**2/(P[2]+x[2]**2)) - P[20] * x[5]-P[3]*x[4]*x[5]\n", - "\n", - "# Cell 1 and Cell 2\n", - "f[6] = P[13]*(1 - (x[6] + x[7])/P[14])*x[6] - P[15]*x[6]*(x[0]/(P[18] + x[0])) - P[19] * x[6]\n", - "f[7] = P[13]*(1 - (x[6] + x[7])/P[14])*x[7] - P[15]*x[7]*(x[4]/(P[18] + x[4])) - P[19] * x[7]\n", - "\n", - "C = np.zeros((2,len(x)), dtype=int)\n", - "C[0][6] = 1\n", - "C[1][7] = 1\n", - "C = C.tolist()\n", - "\n", - "sys = System(x, f, params = P, params_values = params_values, C = C, x_init = x_init)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from autoreduce.utils import get_ODE\n", - "sys_ode = get_ODE(sys, timepoints_ode)\n", - "sol = sys_ode.solve_system().T\n", - "try:\n", - " import matplotlib.pyplot as plt\n", - " plt.plot(timepoints_ode, np.transpose(np.array(C)@sol))\n", - " plt.xlabel('Time')\n", - " plt.ylabel('[Product]')\n", - " plt.show()\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "from autoreduce.utils import get_SSM\n", - "timepoints_ssm = np.linspace(0,100,5)\n", - "sys_ssm = get_SSM(sys, timepoints_ssm)\n", - "# Uncomment to run\n", - "# Ss = sys_ssm.compute_SSM() # len(timepoints) x len(params) x len(states)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "# nouts = 2\n", - "# out_Ss = []\n", - "# for i in range(len(params)):\n", - "# out_Ss.append((np.array(C)@(Ss[:,i,:].T)))\n", - "# out_Ss = np.reshape(np.array(out_Ss), (len(timepoints_ssm), len(params), nouts))" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "# try:\n", - " # import seaborn as sn\n", - " # for j in range(nouts):\n", - " # sn.heatmap(out_Ss[:,:,j].T)\n", - " # plt.xlabel('Time')\n", - " # plt.ylabel('Parameters')\n", - " # plt.title('Sensitivity of output[{0}] with respect to all parameters'.format(j))\n", - " # plt.show()\n", - "# except:\n", - "# print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "from autoreduce.utils import get_reducible\n", - "timepoints_ssm = np.linspace(0,100,10)\n", - "timepoints_ode = np.linspace(0, 100, 100)\n", - "sys_reduce = get_reducible(sys, timepoints_ode, timepoints_ssm)\n", - "# Uncomment to run:\n", - "# results = sys_reduce.reduce_simple(skip_numerical_computations = True, debug = True)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful time-scale separation solution obtained with states: [x1, x5, x6, x7]!\n" - ] - } - ], - "source": [ - "reduced_sys_1567, collapsed_sys = sys_reduce.solve_timescale_separation([x[1], x[5], x[6], x[7]], debug = False)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\apand\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\scipy\\linalg\\_solvers.py:196: RuntimeWarning: Input \"a\" has an eigenvalue pair whose sum is very close to or exactly zero. The solution is obtained via perturbing the coefficients.\n", - " RuntimeWarning)\n", - "C:\\Users\\apand\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\autoreduce\\model_reduction.py:217: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " Se[j] = max_eig_P + 2*len(reduced_ssm.timepoints)*S_metric_max\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Robustness Metric Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - } - ], - "source": [ - "Se_1567 = sys_reduce.get_robustness_metric(reduced_sys_1567)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful time-scale separation solution obtained with states: [x0, x4, x6, x7]!\n", - "Successful time-scale separation solution obtained with states: [x0, x5, x6, x7]!\n", - "Successful time-scale separation solution obtained with states: [x1, x4, x6, x7]!\n" - ] - } - ], - "source": [ - "reduced_sys_0467, collapsed_sys = sys_reduce.solve_timescale_separation([x[0], x[4], x[6], x[7]], debug = False)\n", - "reduced_sys_0567, collapsed_sys = sys_reduce.solve_timescale_separation([x[0], x[5], x[6], x[7]], debug = False)\n", - "reduced_sys_1467, collapsed_sys = sys_reduce.solve_timescale_separation([x[1], x[4], x[6], x[7]], debug = False)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "Robustness Metric Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "Robustness Metric Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\apand\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\scipy\\integrate\\odepack.py:247: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", - " warnings.warn(warning_msg, ODEintWarning)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "Robustness Metric Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - } - ], - "source": [ - "Se_0467 = sys_reduce.get_robustness_metric(reduced_sys_0467)\n", - "Se_0567 = sys_reduce.get_robustness_metric(reduced_sys_0567)\n", - "Se_1467 = sys_reduce.get_robustness_metric(reduced_sys_1467)" - ] - }, - { - "cell_type": "code", - "execution_count": 107, - "metadata": {}, - "outputs": [], - "source": [ - "reduced_sys_0467.C = np.array([[0., 0., 1., 0],[0., 0., 0, 1.]])\n", - "reduced_sys_0567.C = np.array([[0., 0., 1., 0],[0., 0., 0, 1.]])\n", - "reduced_sys_1467.C = np.array([[0., 0., 1., 0],[0., 0., 0, 1.]])\n", - "reduced_sys_1567.C = np.array([[0., 0., 1., 0],[0., 0., 0, 1.]])" - ] - }, - { - "cell_type": "code", - "execution_count": 108, - "metadata": {}, - "outputs": [], - "source": [ - "results = {}\n", - "results[reduced_sys_0467] = [0, Se_0467]\n", - "results[reduced_sys_0567] = [0, Se_0567]\n", - "results[reduced_sys_1467] = [0, Se_1467]\n", - "results[reduced_sys_1567] = [0, Se_1567]" - ] - }, - { - "cell_type": "code", - "execution_count": 137, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots() \n", - "count = 0\n", - "# sys.params_values = params_values_new\n", - "# sys.x_init[0] = params_values[-3]\n", - "# sys.x_init[3] = params_values[-2]\n", - "# sys.x_init[5] = params_values[-4]\n", - "# print(sys.x_init)\n", - "timepoints_ode = np.linspace(0,24,100)\n", - "sys_ode = get_ODE(sys, timepoints_ode)\n", - "sol = sys_ode.solve_system().T\n", - "_ = plt.plot(timepoints_ode, np.sum(np.transpose(np.array(sys.C)@sol), axis = 1), 'k--', label = 'Full model', linewidth = 5)\n", - "for key,value in results.items():\n", - "# error = value[0]\n", - "# if error > 1e-5:\n", - " sys_i = key\n", - " sys_i.params_values = params_values\n", - "# _ = plt.subplots(count%3, count%3)\n", - " sys_i_ode = get_ODE(sys_i, timepoints_ode)\n", - " sol_i = sys_i_ode.solve_system().T\n", - " _ = plt.plot(timepoints_ode, np.sum(np.transpose(np.array(sys_i.C)@sol_i), axis = 1), label = str(sys_i.x), linewidth = 2)\n", - " _ = plt.xlabel('Time', FontSize = 18)\n", - " _ = plt.ylabel('Total Population', FontSize = 18)\n", - " _ = ax.tick_params(axis='both', which='major', labelsize=14)\n", - " _ = plt.legend(prop={'size': 12})\n", - " count += 1\n", - "\n", - "# _ = plt.axvline(x=timepoints_ode[6], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# _ = plt.axvline(x=timepoints_ode[15], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# _ = plt.axvline(x=timepoints_ode[30], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "_ = plt.savefig('pop_control_error.svg')\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 134, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAESCAYAAAAfXrn0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdd3hURdvA4d9sSTa90DsoPSAlFMUIoQlREQHLS4nET7pYsSAqKBaiCPJiA6QK2KiiiAhqKIJIeJHem3QIIWXTts33xy6RsJuyyS4kMPd1nSvJnDlnngTNk3PmnGeElBJFURTl1qa50QEoiqIoN55KBoqiKIpKBoqiKIpKBoqiKAoqGSiKoiiA7kYHUBzly5eXtWvXvtFhKIqilCnbtm1LklJWcLWvTCaD2rVrk5iYeKPDUBRFKVOEECfy26duEymKoigqGSiKoihl9DaRoihlW0pKCmfPnr3RYdzUDAYD1atXR6/XF6m/28lACOEP1AbKAeLa/VLK9e6eU1GUW0tSUhK1a9fGz8/vRodyU5JScunSJU6dOkWdOnWKdEyRk4EjCUwGnsjnOAFIQFvUcyqKcmsym80YDIYbHcZNSwhBuXLluHjxYpGPcefK4L/Ak8BPwG/AJffCy0sI8SYw7prm81LKyiU5b2F27NjBpUuXrsSATqdDq9Wi1+sJDg4mJCSE0NBQ9R+qoniZEE43FhQPcvfn604yeAj4WkrZ360RCnYAiL7qa6sHz+3EJm288vprrP5xZaF9K1asSP369alfvz6tWrUiJiYG9W6DopQdCQkJDBw4MPc2yffff09ISIhTv+joaNauXcs777xDVFQUXbp0yd2XmZnJc889x8GDBzGbzQwZMoQOHTrQtm1bGjdujNVqZfbs2dStW5e4uDisVivz588HICoqio0bN3rs+5k7dy4AcXFxTvuOHz/O66+/zoIFC4p9fneeJvIDEoo9kmsWKeW5q7aiX9MUw6r/68DoS0foFFm90L4XLlxg48aNzJ49mxEjRlCnTh0aN27MmDFjOHXqlDfDVBTFQ2JjY0lISCAhIcFlIijMW2+9RYcOHUhISGDjxo25iaVr1678/vvvvPfee0ybNi23/86dOzlz5ozH4r+e3EkGiUA9D49/mxDitBDimBDiGyHEbfl1FEIMEUIkCiES3bkPdkWO2Ux6UjKVkqFx+xAqD2jmYvq7YPv27WPChAncdtttDBo0SCUFRfGAN998EyFEsbc333yzyGNFRUXlfh4dHV1o/02bNtG/v/1miBCC9u3b59mfkpKS5+vhw4fz6aefujxXQkICDz30ED179iQqKoqFCxfSuXNn7r//fqSUWCwW+vbtS/v27enbty8WiwWTyUTPnj3p3r07q1evzj3X+PHjiY6OplOnThw/fryI333B3EkGo4EnhBCtPTIybAHigBhgMFAZ2CSEKOeqs5RyhpSylZSyVYUKLt+mLpCvXs/dd0QC0OC0jfJdrNSLb4020P35brPZzLx587DZbG4fqyjK9TN//nyio6N54oknPHreNWvW0Lp1a0aMGMEzzzyT296lSxc2bdpEVlaWy+OklHz//ffcd999/PXXX/z6669Uq1aN7du3s2zZMho3bsz69euJiIhgyZIlLF++nDZt2vDzzz8TFBQEwK5duzh9+jQJCQl8+umnTJgwwSPfkztzBkOAU8BmIcRm4CjO9/illPLJopxMSrnq6q+FEH86zjkQ+1NLHle+fTeMS7Zy93Ebn5vD8K2URuOXOhKwyojJZCItLY3U1FSSk5OxWguevhgwYAA1a9b0RpiKonhIbGws77zzjlN7SVd47Nq1KwsWLOC1115j9+7deX4X9O/fP3fe4FpNmjQBoGrVqlz5o7Zq1apcvnyZI0eO0LJlSwBatWrFtm3b0Gq1tGjRAoDISPsfs/v27SMhISH3yqZKlSol+l6ucOfKIA5o5jjmbiDW0XbtVixSSiOwB8/fispluOdBhFZiSBW8VPUVpNQga57n06Uz2bZtG4cOHeLChQtkZWVx8OBBfvzxR9544w1atWqV5zxCCF555RVvhakoipdIKcnJyWHXrl1F6t+uXTsWLlyYe+y1E8IvvfQSEydOzNM2YMCA3GOudfUTPld/LqXktttuY9u2bQAkJiZy++23U6dOHXbs2AHA9u3bAWjQoAH33ntv7lzIl19+WaTvpTBFTgZSSk0RtmK/YyCEMAANAa+9lij8gzBU9gWgT8oxwizRICSvJLyT5y8FvV5PvXr1uP/++xk/fjxbt27l7NmzjB07lrCwMHr37k3Dhg29FaaiKF4SFxdHVFQUixYtKlL/cePGsW7dOqKjo7n77rs5cuRInv2hoaHUqFGD//3vf7ltBoOBe+65x+3YevXqxZ49e2jfvj27du2iT58+PPTQQ2zatIlu3brlzk80a9aMypUrEx0dTceOHZkzZ47bY7kiSnq5VOyBhfgQ+AH4B6gIvAG0B5pKKfOtrAfQqlUrWdyqpReeepBLvx6iXLcm7Hv6Q55a/whCm8VbbSfRu+G9hR6fnp5OWloa1apVK9b4iqLYb3U0atToRodx07v25yyE2CalbOWqr9uF6oRdSyHEw46tpSje2yPVga+xv2uwFMgB7iwsEZSUX+u2AGTuPUKHurWoq+8NwPt/TcRsMxd6fFBQUKGJ4OTJk7z88stqgllRlDLDrWQghOgOHAG2At86tq3AYSFEN3fOJaX8j5SyqpTSR0pZTUrZR0q5151zFIdfp14AZJ/JRGZn81HMCGym8mTKc3z611clPv/Fixfp2rUrEydOZOzYsSU+n6IoyvVQ5GQghLgbWAGEAVOxP100BHuZijBghRCinTeC9CRdzcb4hIK0CrL/XE2d8sG0C+8HwNcHvy7RUwZpaWl0796dAwcOAPDuu+96bHJHURTFm9y5MhgLnAMaSymfl1LOcmwvABHAeUefUs/vdvsjXZkbfgHgjY7/wWYOJlOe5ucjG4p1TqvVSs+ePfNMJAEMGjSI9etVIVdFUUo3d5JBW2CGlNLpaR9H2xfAnZ4KzJv8m90BQNYO++NlNcODqO3TGYCPt80t1jm1Wq3LNxrNZjO9evXi5MmTxTqvoijK9eBOMvAB0gvYn+boU+r5tbdPb2QeTcq9LfRsm1ikTcvJrESOpfxTrPOOHTuWfv36ObUnJyczcOBANaGsKNfR3LlzadCgAevWrXO532KxEBsbS1RUFPHx8W6fPysri8qVK7N27Vq3jluzZg2dOnUiOjo6972CooiPjyc6Opro6GgCAgJITk5m48aNNGzYkJkzZ7obvhN3ksE+4D9CCKe3lh1tjzn6lHo+kfei9bVhzZSYD9qvDro2qIu/ORKE5P0/ZhfrvEIIZs2aRbt2zlMnv//+Ox999FGJ4lYUxT0vvfQSHTp0cLlvxYoVNGrUiI0bN7Jx40bOnTvn1rlnzJiR+0ZxUWVlZTF9+nTWrFlDQkJC7lvFRTF69GgSEhJYvHgxrVu3Jjw8nKioKEaPHu1WDPlxJxl8jv1W0a9CiPuFEHUc2wPAr459n3kkKi8Tel/8agQAkPnbCnubEDxavy8Amy+uItOcWaxzGwwGli9f7vLx0zFjxuS+TagoyvWzffv23Kv2AQMGkJiYyObNm3PLVXfs2JGtW7e6PPbFF19k5cqVnDt3jq5du2K1WjGZTGzZsiVP4btrGY1GOnbsiNFoZNq0aUyZMoXNmzej0WiIiYkhNjaWjIwMl8f+8MMPvPTSS9hsNrp3757nNvOKFSt48MEHi/ujyFeRaxNJKWcKIeoBLwKufgITpZSzPBaZl/k3rY/x8A4yt2widLi9bUS7aOYdqIXNcILp2xbz/J2PF+vcFSpUYO7cuXTt2jVPu8lkon///iQmJqrFcxQFqD268LVFiuJ4/P0F7m/RogV16tRh6NChVK1alVatWjF9+nSCg4MBCAkJ4fLlyy6Pffvtt4mJiSE0NJSJEyei1WqZOXMmsbGxbNmyJd8xAwMDGTNmDIMHDyY5OZlVq1bx7bffcvbsWRISEpgxYwbTp0/nhRdecDq2R48eLFq0iCFDhtCjRw9q1KiRu2/ZsmVMnTq1KD8Wt7j1noGU8hWgEfYKptOBGcArQCMppWeuVa4T//b2t40z9/07P+Dvo+PO8j0AWHpoWYnO36VLF55//nmn9j179hTr/qSiKCUzbNgwZs2axbPPPgvYS0mkpaUB9sfCQ0NDXR7n5+dH165dycrKonnz5lgsFlavXk1MTEyhY3bp0oVt27YRFxeHRqMhJCSEqKgotFotnTp1Yt++/O+sDx06lO+++45BgwblthmNRpKSkoq8rrE73KlaCoCU8iAwsdCOpZyhfS80+vcxp4L52CH0dez18Z5r14fHVn1BCofZm3SIxuWLXzfvvffeY82aNezevTtPe3x8PLGxsdx+++0l+h4Upawr7C96Txo9ejT//e9/GTt2LLNmzeKuu+7i119/pU2bNvz+++/07duXrKwssrKyCA8Pzz3u7NmzrFu3jjp16pCQkEC9evU4efIk3bt35/Dhw6xcuZLIyEjMZjNhYWHo9frcY6dNm0ZsbCxffPEFvXv3pnXr1syYMQOAv//+O/eX+unTp/PcWrbZbLz99tuMGzeO+Ph4xo2zrxD8008/FSkJFYfb5ShuFiIgDP8afgBk/PJdbntElfKE2OylOz7565sSjWEwGFi4cGGe/zgAcnJyePrpp0tcRldRlKJZvnw5tWrV4qmnniIwMJA1a9bQo0cPdu/eTVRUFHfddRdVqlThjz/+4PPPP89z7LPPPsukSZOYOHEib731FuHh4WzdupWff/6ZAQMGMGHCBMLCwnjhhRe4cOFC7nEnT55kxYoVvPbaa4wcOZLx48dToUIFOnToQPv27ZkzZw7Dhg3DYrE4LWU5depUevXqxahRo9i1axd79uwB7LeIevfu7Z0fkpTS5QbMBmYB2qu+Lmybld/5PLlFRkZKT0ga/Zjc26ChPD0wJk97/G8/ySZzm8jmc6KkxWop8TivvPKKBJy2ZcuWlfjcilIW7d271+tjLFq0SEZGRsqEhIQiHzN58mR56NChYo03fPjwYh2XmJgoZ82aVaxjN2zYICMjI+U333zjcv+1P2cgUebzezXfqqVCCJvjl5aflNLk+LoIuaX4ZayLqiRVS6+WtWoWx5//EH2Ilrpb/r2Vk5Jp4u6F96LxucTbd07hoQadSzSO0WikUaNGTstk1qxZk7179xIQEFCi8ytKWaOqll4fHqlaKh3rE0gpTVd97bX1DG4EQ/veaPQ2zKlWzMcO5baH+vtwu19HAObsKFrd84IEBgYyZcoUp/Z//vmHDz/8sMTnVxRFKalbds4Arp03yPtL/4lmfZBScDRzC6nZqSUeq3fv3nTr5lzY9cMPP8xzn1FRFOVGcKdq6VEhRL5vOgghHhBCHPVMWNeP/x0NAMjcnHc5uwcjItDm1ANhYfr/lpZ4HCEEH3/8cZ7J5AoVKvDee+/l+0iboijK9eLOlUFtILCA/QFArRJFcwP4d7C/GHb1+wYAWo3gzor2v+R/PPKjR8aqV68eQ4cOJTAwkDfffJMjR47w9NNP4+NTJko6KYpyE/PkbaJKQPFqONxAeeYNjh/Os++pNj2RNj2XbQeLXbzuWleSwLhx4wgKCvLIORVFcebNQnVxcXG0bduW6OhovvrKvUWxtm/fTteuXenYsSMrVxb9Dey5c+fmFqoLCwvj77//5vDhwzRv3pzXX3/drRhcKfClMyFEeyD6qqbeQoi6LrqGA/8B/i5xRNeZCAjHv4YB41ETGau/I3TomNx9d1SrhL+lGVk+iUxLXMr7XZ4r8XjlypUr8TkURSmaohSqmz9/Pg888ADnzp2jcuXKRT73woULqVvX1a/Dgr3zzjt8//33+Pv7u3VcXFwccXFxWCwWWrVqRbNmzRBCMGXKFLcrp7pS2JVBR+BNxyaB3ld9ffX2DPYS1s71F8oA/2YNAcjc6LwITcfq9rIV606vvq4xKYriOZ4uVCeE4PHHH6dHjx6cOOF62Xar1Uq3bt04ffo0q1ev5rnnnuPo0aNkZ2fz8MMP89BDD3H+/Pkix3vF+vXrad++PcVbej5/hZWjmALMBQRwFHgO+P6aPhIwSimTPRrZdRTQ+X5YtpOMvSftL19c9UMe3vZ+Vi7/iAztKf4+v4/mldSz0YriMW+GeOg8BT/x5+lCdZMmTSI8PJyNGzcyatQoFi9e7HScVqtl8uTJDB8+nLS0NFauXMnOnTs5cOAAO3fuZN26dbz77rsui865iveKpUuX0qdPH3d+OkVS4JWBlDJVSnlCSnkc+1XCN46vr97+KcuJAMD3nt5oDTYsGTZMu/MuNlE7PJgwxzsaM7YtuRHhKYriAZ4qVAfk1i6KiooqcB2EiIgIsrKy6NatGwEBAYSEhNC6dWv8/f0LLVR3bbxgrxixceNG2rdv7943XwTulLB2PQtzExC+gQTcHkzaHiMZP32Db9O8L+jF1LmPr09uYMuFtUj5mscvz644ffo0H374IcOGDaNBgwZeGUNRSpVC/qL3JE8VqouOjiYtLY3g4GAOHDiQm0SSk5Px8/PDz88v99hVq1bRqFEj1q5dy+DBg6lXrx4XLlzAarUWWKjOVbwAW7dupWXLlmi1nn+/N99kIIQYi/0W0LtSSpvj68JIKeXbHovuOgpo3ZK0PevJ+PMvwq/ZN6RNF746OgGT/hLr/tlKdK02Hh37xIkTvP/++8yaNQuTycTly5eZO3euR8dQlFvZ1YXqnn322dxCdUuWLCEqKor77ruPKlWqsHbtWrZs2cJrr72We+yVQnW1atWiZ8+etG3blv79+3P58mWEELmF7SZPnkxMTAx33303AOnp6XzwwQesXLmSPXv2MGrUKObNm8fgwYOJjo5Go9Hk/n/ev39/EhISCoy3a9euN6xQnQ2wAj5XfV3YZs3vfJ7cPFWo7mqm7b/IvQ0ayn0RDaUtJ8dpf5c5L8omc5vIActe9ui4P//8s9TpdHkK2Gm1WnnkyBGPjqMopcnNWKhu5MiR0mq1un1cUlKSHDt2bLHGPHTokGzbtq388MMPXe73VKG6Wo5kceLqr4uQXFxPrXuQpwrV5WGzcuSuxphSNdT67AP8O/XIs/vzTev47NBItDKIxMfXo9O4vRSES0ajkdq1a3Pp0qU87UOHDmXatGkeGUNRShtVqO768FShuhNX/2KXzhPHLjePfifXk0ZLQMNKAGSsWe60O7ZlO6SpPFaRzqrDf3hs2MDAQJfL3s2bN0/VLFIU5bop8RvIQojyjrWRy7yAdvZ7fRmJO532BRr01PK171+wyzlZlMTIkSNzH3G7Ijs7m88++8yj4yiKouTHnUJ1jwshZlzTNgE4D+wXQvwhhCjT9RX8Y/qBkGSdSsea6vyUw6ONHgBgf/ofmK1mj40bHBzM0KFDndo//fRTsrKyPDaOoihKfty5MhjKVU8fCSFaAa8AG4AvgDaA8/2OMkRbowl+lQRIQeZVS2Fe8Vjz1sicKthEFsv2/+bRsZ955hl0urzzEElJSXz55ZceHUdRFMUVd5JBXeDq+yePAMnAvVLKYcBM4FEPxnb9CUFAE/tzv8ZfVzntNui11AuIAuDrvT94dOjq1avTt29fp/bJkydjsxVlkTlFUa5WWKG67du307RpU2rXrl2s82dlZVG5cmW36wKtWbOGTp06ER0dzbZt2wo/wCE+Pj63UF1AQADJycls3LiRhg0bMnPmTHfDd+JOMggBrr530hlYKx0roQGJQM0SR3SDBXbuDkDG9kMuF6zvG2Ff0uFIxp9kW7I9OvaoUaOc2g4ePMiPP3qmhLai3GoKKlRXt25d/vzzT6pXr16sc8+YMYMmTZq4dUxWVhbTp09nzZo1JCQkEBkZWeRjR48eTUJCAosXL6Z169aEh4cTFRXF6NGj3Q3dJXeSwTmgHoAQogLQHPstoisCsb+XUKYZuvZH62PDnGrBtN95IvmhJndATg2kyOHb3b94dOxmzZrRtWtXp/ZJkyZ5dBxFudW4KvwWFBRUpPXHXRWqM5lMbNmyhaioqHyPMxqNdOzYEaPRyLRp05gyZQqbN29Go9EQExNDbGwsGRkZLo/94YcfeOmll7DZbHTv3p2TJ0/m7luxYgUPPpjvOmPF5s7D8r8BTwkhkrHXKZLA1cW4GwCnPRjbDSECyxFwexBp+zIwrpiPb6Nmefb76DQ0Cr6HfTlfsWj/Dwxs7tl/lBdffJE1a9bkaVu/fj07d+7kjjvu8OhYinKjNZ3X1CPn2TVwV4H7Cyr8VhhXhepmzpxJbGwsW7Zsyfe4wMBAxowZw+DBg0lOTmbVqlV8++23nD17loSEBGbMmMH06dNdPlreo0cPFi1axJAhQ+jRowc1atTI3bds2TKXxe1Kyp0rg7HAWeADIAaYIO0F7BBC6IA+wE1RvyiwXWsAMjZscrn/8aY9ATiRvQ2jyejRsbt27UpERIRT+8cff+zRcRTlVuOq8FtRXFuozmKxsHr1amJiYgo9tkuXLmzbto24uDg0Gg0hISFERUWh1WoLLVQ3dOhQvvvuOwYNGpTbZjQaSUpKyq1p5EnuFKo7JYSIABoDqVLKq5f+8geGADs8HN8NEdCjP8z6ncyjydiMRjSBeVf7jGnUiDF/1EH6HmPBzlUMa/WIx8YWQvD0008zbNiwPO0LFiwgPj5eLY6j3FQK+4vek1wVfrtWUQrV1atXj5MnT9K9e3cOHz7MypUriYyMxGw2ExYWlmed82nTphEbG8sXX3xB7969ad26NTNm2J/QL6hQnc1m4+2332bcuHHEx8czbtw4AH766aciJaHicOulMymlVUq565pEgJQyTUr5/ZUrhbJO1+BuDBVA2gQZvyxy2q/VCO4ItU9KLT/0k8fHHzBggFM53ezsbI88MaAot6KrC78FBgayZs0aTp48SZcuXdi9ezddunTh+PHj/PHHH7mF5664Uqhu4sSJvPXWW4SHh7N161Z+/vlnBgwYwIQJEwgLC+OFF17IUzXg5MmTrFixgtdee42RI0cyfvx4KlSoQIcOHWjfvj1z5sxh2LBhWCwW4uLi8ow5depUevXqxahRo9i1axd79uwBuDGF6vLbsM8XTAV+dGxTgWh3z1OSzRuF6q514akYubdBQ3lmaC+X+9ceOCgj5jSVTeY0k5czUzw+/qhRo/IUrwNkjRo1pNls9vhYinK93YyF6oYPH16s4xITE+WsWbOKdeyGDRtkZGSk/Oabb1zu90ihumsJITTAPKAf9pXPrjz8rnH8sloIDJRFPWEJeKVQ3TWyln/M8dGfoQ/WcvuWXU5rGNhskpYz+2D1PcSTDV7huTsHeHT8o0ePUrduXafHW5csWeK9vwwU5TpRhequD48UqnNhFNAfWAy0APwcW3PgO8e+Mv0G8tUM9w5A62vDnGbFtNd5KkSjEbQs1xGAH4/87PHxb7vtNnr0+Ldyqlar5ZFHHvHKxJGiKIo7ySAO+EVK+ZiUcoeU0uzYdkop+wJrgP/zSpQ3gPAPI6CuvdSScYXrkhBPtnwQKTWcN+/iYuYll31K4umnn6ZcuXKMGTOGY8eO8d1339GiRQuPj6MoiuJOMrgNKKgGww+OPjeNwHZtATBu2Oxyf7vaNdGbGoKwMet/33t8/M6dO3Pq1CnefffdPM8ZK4qieJo7ySADqFTA/sqOPjeNwIeeACHJPHYZa3Ky034hBG0r2m8VrTru+VtFQggMBoPHz6soinItd5LBBmCk412DPIQQjYGngPWeCqw00N4WiX9VDUiBcfkcl30GRz6ItOlItuzndPrZ6xyhoij58Wahuri4ONq2bUt0dDRfffWVW8du376drl270rFjR1auXFn4AQ5z587NLVQXFhbG33//zeHDh2nevDmvv/66u9+CE3fKUYwF/gS2CyG+B/Y62iOAHoAJGFfiiEoTIQi68w4yl+wg/ZdVhPyfcyG5ltWrYDBHkOO7g+mJyxjfccQNCFRRFFeKUqiuW7duxTr3woULqVu3rtvHvfPOO3z//ff4+/u7dVxcXBxxcXFYLBZatWpFs2bNEEIwZcoUtyunulLkKwMp5S6gA7AVe+mJNxxbb0dbtKPPTSXoQXtZ6Yw9p7Hl5DjtF0JwTxV7cblfT66+rrEpilI0ni5UJ4Tg8ccfp0ePHpw44Xq1X6vVSrdu3Th9+jSrV6/mueee4+jRo2RnZ/Pwww/z0EMPcf78+SLHe8X69etp37690+PuJeXWqu5SykTgbkfV0jrY3zc4KqW86NGoShF9q/vxDX+ZnGQNmWuWEviA85oDw9o8wJqVU0nTHuXQpePUK1fb63FZLBZ27NjhVglcRSlt9jX0zLsGjfbnX+MHPF+obtKkSYSHh7Nx40ZGjRrF4sWLnY7TarVMnjyZ4cOHk5aWxsqVK9m5cycHDhxg586drFu3jnfffddl0bmC4l26dCl9+vQpcvxFVaw1kKWUF6WUf0kpt9zMiQAArY6g5rUBSP/BuTQFQINK5QiyNQdg2rYlXg3n7NmzvP3229SpU4e7776bS5c8/0irotyMPFWoDsitXRQVFcW5c+fyPTYiIoKsrCy6detGQEAAISEhtG7dGn9//0IL1bmKV0rJxo0bad++vVvfQ1G4dWUAIIRoA/Ti38dIjwLLpZT513It2nnHAO8Cn0opR5bkXJ4WGPMgSb99gnHbAaTNhtA459BONbqx4txfbDi7Bvv7eZ43fPhwZs6cicViyW378ssvef75570ynqJ4W2F/0XuSpwrVRUdHk5aWRnBwMAcOHMitI5acnIyfnx9+fn65x65atYpGjRqxdu1aBg8eTL169bhw4QJWq7XAQnX5xbt161ZatmyJVqv16M8G3LgyEEJohRCzgM3Y1z5+xLG9AmwSQswRQhQrQiHEncBg8i6rWWoYuj6Ozs+KxWgjO3Gjyz7D28Ygrf5kcZrt5/a67FNS/v7+eRIBwPTp012uyKYoyr88WaguKyuL/v37ExUVxaBBg4iPjwfsS9T+73//yz0uPT2dDz74gPj4eOLj4xk1ahR6vZ7BgwcTHR3Nyy+/zKuvvgpA//79C40XSp/wZ9kAACAASURBVEmhOuxPCtmApcCdQLBjuwtYhn2Vs3FFPd9V5w0BjgCdgATgk8KOuR6F6q51pl87ubdBQ3n+lf/Lt889s4bLJnObyKE/jvdKDPv373cqXgfIdevWeWU8RfGWm7FQ3ciRI6XVanX7uKSkJDl27NhijXno0CHZtm1b+eGHH7rc761CdSeA/VJKl89hCSHWAPWllLXcSUZCiG+B41LKV4QQCcBu6eI2kRBiCPY1E6hZs2ZkfjP43mKcM5aT7y/Cp7wvt2/822WfCb/9yFcnX8VHlidx4G8en+0H6NixIwkJCXna+vXrx8KFCz0+lqJ4iypUd314q1BdRWBFAfuXO/oUmRBiMFAX+yOqBZJSzpBStpJStqpQoYI7w3hEQK9haHxsmJJyyNnjOhkMbdsFaQ7GJJJIOPGXV+IYOnSoU9vixYtJSkryyniKotwa3EkGB7GXnMhPFUefIhFCNADeA/pLKU1uxHFDiNCqBDUIASDt62ku+4QHGKiqbwfArO1LvRJHr169KF++fJ42k8nEvHnzvDKeonhLUe9KKMXj7s/XnWQwAXhKCNHs2h1CiBbACOy/3IvqLqA8sFsIYRFCWLC/1DbC8bWvG+e6LoLv7QJA+vr8H5x6uMGDAOxKWYfZZvZ4DL6+vk6rIgHMmDFD/c+llBl6vZ7s7OwbHcZNS0rJpUuX3Kpt5s6cwVjgQaAZ8AuwH/sEZmOgK/b1j6+9jSSllG/nc75QoPo1zXOAQ9iTyh6ZT3DXY3EbV2TyKQ526IzNrOG2Zd/g28gpL5JlstB6XneEz3lej5zIY026ezyOQ4cOUb9+faf2hISEfF+9V5TSJCUlhbNnVS0vbzIYDFSvXj3PmswFzRm4857Bm1d9HuPYrtbSsV1NAi6TgZQyBUi5uk0IkQEkSyl3uxHXdSPCqxPUIJjU3UbSv5mB71ufOvXx89FRP6A9h8yLWLh3uVeSQb169ejUqRO//fZbnvYvvvhCJQOlTAgNDXVa51u5sdy5TVSnGNtNtb4BQFDXzgCkJWzKt8/ApvbngI9l/oXRZPRKHIMHD3ZqW7x4MckuSm0riqIUxp1CdSeKs7kTjJQy2tVjpaVJwMMj0Oht5JzPJueA6wuYByIi0OTUAWFmzt8/eiWOXr16Ua5cuTxtOTk5zJ8/3yvjKYpycytWbaJbmaZcTYLq25fDTP9muss+Wo2gRbj9CmL5oYIWhys+X19fBg4c6NSuJpIVRSkOt5KBEKKWEOJdIcR3QohfhRC/XbP96q1AS5OgLp0ASPvVdWkKgKGRvZBSywXzLs6kuy5TW1KubhXt3buXzZtdL9OpKIqSH3dqEz2I/T2CV4F7sc8H3PRzBK4EPvY0Wh8bOReyyd7p+qmmO2vXwGCOACH55K/vvBJHw4YNXVYvnDFjhlfGUxTl5uXOlcH7wEmgmZQyVEpZx9XmpThLFRFeg6CIMADS5n/iuo8QdKp2HwC/nvrJa7duXF0dfPfdd6SkpLjorSiK4po7yaA2MFXehKuZFUfIgw8BkJqQiLTZXPZ5pt2DSIs/mZzir9Pe+bH16dOHsLCwPG1ZWVksX77cK+MpinJzcicZHANK3VvBN4pfz2HoA6xY0q1kJqxy2ad6aBAVNHcC8Pm2b70Th58fsbGxgH1SuV+/fvz+++8uJ5cVRVHy404ymAIMEkIUvmjoLUD4hxIcWQOAtK9n5tvvkQb2K4jtyb97pTwF2Be9mTJlCmfOnGHhwoVER0d7pWKqoig3ryK/gSylnCGECAb2CCHmAcexr2Fwbb8vPRde6RbyyAAurf+AtL/2UyknB42v84VTXOQ9fLanIjafCyzes5a+Ta99cbvkGjZsSMOGDT1+XkVRbh3uPE1UCegN1MRecnoWMPeabY6H4yvVfDv2xzfchi0HjCsWuOzj76ujYYD9UdQFe7xTyVRRFKWk3LlNNA1oDXyEPSl0dLF18nSApZrOh5B29oUj0hZ/nW+3QS37IKXgn+ytXMq6fL2iUxRFKTJ3kkFn4L9SylFSyuVSynWuNm8FWloF9xsGQpK+6xSWixdc9unWoAF6UwMQVj7e4p2JZEVRlJJwJxnkAIe9FUhZpW/RjYCaWrAJUudMdtlHCEF01QcA+PnEClUuQlGUUsedZLAS+7oFytWEIPQ+ex2i1B9W5/uL/vl2vZAWfzI4yaZTrpfN9LScnBy++eYbPvvss+synqIoZZc7yeAFoIYQYqoQ4nahnl3MFRT7MlpfGzkXs8n+M8Fln5rhwVTW3g3Ap1u/8mo8+/fvZ9SoUVSrVo2+ffsyZswYMjMzvTqmoihlmzvJIAmIBJ7CXqPIIoSwXrNZvBJlKSfCqxPS0r48dMqcj/PtNyDiEQB2pyaQafbOL+fMzExatWrF5MmTuXTpEgCpqaksXrzYK+MpinJzcCcZfFmE7ZYtph/a/wkA0jbvw5aR4bJP/5ZtETk1kZpsZm33Tmlrf39/HnvsMad2VbxOUZSCuLO4TZyU8onCNm8GW5r5dhyAX0WJzQxpX7u+R6/Xamhdzr4M5uKDS7wWy5AhQ5za/vjjD/bs2eO1MRVFKdvU4jaeotUR2qUNACmL8/9F/+ydjyJtepKt+9iXdMQrobRp04amTZs6tc+cmX/ZDEVRbm1uJwMhREfHJPKPjm2qEKKjN4Ira4LiXkKjs5F1PJXsHVtd9rmjWiVCbfak8eHmeV6JQwjh8upg3rx5ZGdne2VMRVHKNnfKUWiEEPOBtcBIoLtjGwmsFUJ8eas/YaSt2ZSQZuEAXP48Pt9+/RrZ7+knJv1CtsU7v5z79++PwWDI03b58mWWLPHe7SlFUcoud64MRgH9gcVAC8DPsTUHvnPse8HTAZY1YXH2xWZSN+7Fms8CM0+2aY/IqY5Nk8EX//POugNhYWE8+uijTu3Tp7tet1lRlFubO8kgDvhFSvmYlHKHlNLs2HZKKfsCa4D/80qUZYhv54H4VxVIC6TO/MB1H52WNuXtbyR/e8A7S2KC64nkDRs2sHfvXq+NqShK2eROMrgNKOh5yB+4RdZALpBGS1jPLgBcXroy31XQXr77P0irgVTbIRJPe+cpn3bt2hEREeHUrh4zVRTlWu4kgwygUgH7Kzv63PKCnngdnb8VU7KJjJ9d36OvX6kcFYX9jeTJW7w3kTx06FCn9nnz5pGVleWVMRVFKZvcSQYbgJFCCKc/NYUQjbG/mbzeU4GVZSK4ImFR9QC4PCv/ukBP3NEXgN2pv5GeY/RKLLGxsfj5+eVpS0lJYdGiRV4ZT1GUssmdZDAW+xrI24UQi4QQbzm2xcB2QA+M80aQZVHo0JcQGolxz1lMB13fBurXog3anNuRmhwm/7nQO3GEhrp8I1lNJCuKcjV33kDeBXQAtgJ9sK929gb2hW62AtGOPgqgi4gmOCIIEFya7DpHajWCztX6APDDsUXYpOv5hZJydato06ZN7Nql/rkURbFz66UzKWWilPJu7HMHdwJ3AZWklFFSym3eCLAsKzf0KQBSN+zBcuGcyz6j2/dBmsPIEef5bs8ar8TRtm1b7rjjDqf2adOmeWU8RVHKnmKVo5BSXpRS/iWl3CKlvOjpoG4Wvp0eJ7C2FmmFy/91fXVQIcifxoExAMzYcX0nkufPn4/R6J25CkVRypYCk4EQIkwI8acQ4p1C+r0rhNgkhAj2bHhlnEZDucf7AXB55YZ8q5m+GvU40qbnomUX28/u90ooAwYMICAgIE9b06ZNOXv2rFfGUxSlbCnsymAo0BTIv0i/3cfAHYDzW063OL9HXsCvosSaLUmZ7rpERYvq1SiP/THT9zd94ZU4goOD6d+/P4GBgQwfPpwdO3bwxx9/UK9ePa+MpyhK2VJYMugBLJNSni+ok5TyHLAU6OmpwG4WQm8g/OFuACR/uxxpNrvsN6z5QAD2pP1OUmayV2IZP348Z86c4bPPPnM5h6Aoyq2rsGTQGPiziOf6C3B+3VUh6Mlx+ARbMadaSJ37X5d9Hm0Wid7UCDRm3tngnVLTlSpVIigoyCvnVhSlbCssGfgDRZ1hNAIBhfa6BYmAcMr3vgeApFlfurw60GgEj9weC8DvZ5Z5bVlMRVEUVwpLBpeAWkU8Vy1Hf8WF4JHv4xNsw5xiJnX2ZJd9nouKQZhqYtMYmbhpwXWOUFGUW1lhySAReLiI5+rj6K+4IALLU75PewCSZi9weXXg56OjWzV7iYrvj32F2eZ6fkFRFMXTCksGc4EIIUT+K7UAQogJ2OcL5ngorptS8FPx+ITYMKdaSJn5ocs+r0U/DKYKmMUlpicuvW6xSSm5fPnydRtPUZTSpcBkIKVcCqwEXhJCbBRCDBRCNBdC3CaEaCaEiBNCbABeBn6UUi67HkGXVSKwHOUf7gDApTlfYTOZnPqE+hu4s5y9RMX8fXORUno1pvT0dD777DOaNGlCv379vDqWoiilV1HeQH4UWAi0A2YD24BDwP+AWcDdwALgP16K8aYSPCIen1Ab5jQLKR+/5bLPm50eR1qCyOQU3+xe7ZU4jEYjTz/9NNWqVeOpp55i7969/Pzzzxw+fNgr4ymKUroVmgyklFlSyseBZsDbwDLgV8fHt4FmUsqBUkpVIL8IREA4FR+/H4Ck+cuwXnZ+p6BaaBBNA+2vbEzd/qlXrg78/Pz46aefSE9Pz9P+2Wf5l9xWFOXm5VbVUinlm1LKh6WU9zo+vqkqlbovcNC7+FcVWLMlSe+4Xjb6vS5DkJYgjPI4C3b95PEYtFotI0aMcGqfPXs2GfmUzVAU5eZVrEJ1SskIHz8qPmMvHHd51Z+Yjhxw6lOnXBjNg3oD8On2T71S3vqJJ57AYDDkaUtNTWXBAvVYq6LcalQyuEH8ej5DcCM/pE1wcdxzLvtM6DoYaQkmg5PM+/tHj8cQHh5O//79ndqnTp3q9YlrRVFKF5UMbhQhqPjqWwiNJC3xOJkbfnHqUiMshJYh9tc8Pt/5mVeuDkaOHOnUtnfvXtauXevxsRRFKb1UMriB9G16EH5PVQDOvT4aabE49ZnQZRDSHEIWp5mxzfPvHTRv3pz27ds7tf/3v65rKCmKcnNSyeAGKz/+C/SBNnLOZ5E8+Q2n/dVCg7gz3P7U7oxdn5BjyfF4DM8++6xT28qVKzl06JDHx1IUpXRSyeAG01S6ncqDegCQNH855n+OOfV5v9uTYKqMWXOJN9fN8HgMPXv2pFYt5xJUn3zyicfHUhSldLphyUAI8ZQQYqcQIs2xbRZC3H+j4rmRAgfHE3S7HpsZzr/svDxluQA/eteyt6/8Zz4XMjy73oFWq3U5dzBnzhzS0tI8OpaiKKWTW8lACPEfIcQfQogLQgiri835pnf+TgGvAC2BVsBvwHIhxK236opWR6Xx7yN0NtL/Pkn6krlOXV7v3Bu9qSFSk8WLa1zXNSqJJ598En9//zxt6enpzJ492+NjKYpS+hQ5GQghXsJelqIe9gVvvnSxzS/q+aSU30spV0kpD0spD0opXwPSgbvciP+moY+MoeJ9jQE4++4HWC6cy7tfq+HZFi8gpWB7ykp2nfds2YiwsDAGDhzo1D5lyhQsLia2FUW5uYiiPk8uhDgOnAE6e7r0hBBCCzyCPaFEunqrWQgxBMcayzVr1ow8ceKEJ0MoFWRWKv/cfxeZZyRBLWpS7aufEUL8u19K2s8ZQYp2IxV1d7C234I8+0tq//79NGrUyKn922+/5dFHH/XYOIqi3BhCiG1Sylau9rlzm6gysMCTiUAI0VQIYQRygGlAr/zKW0gpZ0gpW0kpW1WoUMFTIZQqwi+EKu9NQKOzkb79H9Lm553AFUIwsdNopNWPC5adTEtc4tHxGzZsyP33O0/bTJo0Sb2Epig3OXeSwWEg1MPjHwCaA3cCnwPzhBBNPDxGmeJzZ08qPhwJwLlJnzk9XXRn7Vq0DX0cgGm7J3MpM8Wj448aNcqp7a+//uKPP/7w6DiKopQu7iSDScCTQgiPragupTQ55gwSpZSvAn8Dz3vq/GVV6JhZBNbWYcuB00P6Oq2KNvX+oWhNt2HTpPPUqnc8OnZ0dDQtWrRwal+yxLNXIYqilC7uJAMrcAHYJ4QYL4R4Qgjx+LWbB+LxLeE5yjzh40eVjz5H52cj63gqF14dkmd/gK+eV1q9hpRa9hhXs/rwn54bW4g8VwcxMTGsWbOGyZNdr9usKMrNwZ0J5KIUxpFSSm0RzxePfRW1k0AQ0A/7o6b3SylXFXRsq1atZGLizb/ccubXEzgxfh5IQfV3XiLo4f/Ls//++a/xj20FelsFEvqtINg30CPjms1mXnnlFZ588kkiIiI8ck5FUW68giaQ3UkGHYrST0q5rojnmwt0xD4xnQrsBCZKKQtd2utWSQYAl17owYWfDqPxgTpLFuNT799fzmdT0+n23cNInzPU9+/Ikkem3sBIFUUp7TySDEqTWykZSFMmpx66E+NRMz7lfKj9w29ow8vl7v/27628vX0IQmNhRMSbDG/V5wZGqyhKaeapR0uvPWl5IUT54oelFIXw8afq9K/xDbNhumTiVOyDyJx/i9U91rw1rYLsUzWf73qfQ5f+uVGhKopShrlbjqKqEGKeECIFOA+cF0JcFkLMFUJU806IirZGBDU+mYLWYCPzSDJnn+qb57n/aT2fxmBugtRk8fiPI8k0qeWoFUVxjzvlKGoCiUAscBT4yrEdBR4H/hJC1PBGkIq9XEWNN0cgtDZSN+4jaey/heUMeh3Tu38A5jCMHOORpc96ZSGcK6SUWK1Wr51fUZTrz50rg7eBMOABKWVLKWWsY4sE7gfCHX0UL/F76FmqDrkXhCRp0W9cmvBS7r6W1WvwRutJSKsv/+RsZuSqeI+Pb7VaWbx4Ma1bt1YF7BTlJuNOMrgX+ExK+dO1OxyPgn4OdPdUYIprwc9MpUr/NgBcmPcjyR+Nzd33aLPWPFZrDFIKNlz8mkmbPLOwfU5ODl988QWNGjXikUceYdu2bcTHx6sCdopyE3EnGYQBBS19dQjPl6tQriUEoa/No/LDTQE4P30Rlz8en7v7jc69iQyIA2DOwQ94f+OXJR5yz549DBkyJM/KZ0ePHuWrr74q8bkVRSkd3EkGp4DoAva3d/RRvE0IwsZ/Q6Ue9QE49+nXJI1/LndSeXaf56mnfwQhJAuOTGTc7yVbHa1ly5bExMQ4tb/77rtq7kBRbhLuJINFwCNCiAlCiJArjUKIYCHEe8CjwLeeDlDJh0ZD+PvLHFcIkotfrebCCwORNhtajWDxf96gqV8sAEv/+ZhnVk0s0aTyG284r8988OBBFi1aVOxzKopSerjzBrI/8AvQDnudojOOXVUBLfAHcK+n1zpw5VZ66axQUpI2aTinZyWAFAS3rkOVGUvQ+PkhpeTJZVPZmj4TgPKaZix86COqBhWvBHiXLl349ddf87RFRESwc+dONBq1nLailHYeeelMSpkJdACGYk8KGUAmsBr7ojMdr0ciUK4hBMEvTqPGqN4InY20rcc4cX8U5pPHEEIwu/ezPFx9HNLqT5JtBzGLevPtrt+LNdTYsWOd2vbs2cOyZctK+l0oinKDqXIUN5HsX+Zwakw8ZqMGrb+g+keT8O9gv9e/8dghnvn1Rcz6owBU1EYS33E0ras1dGuMDh06sH79+jxtTZo0YceOHerqQFFKOa+Uo1BKH8O9T1D76wX4VxVYMyUnhj1P0tvPIW02ourUI2HAN0T4PYq0+XDBuo0n1jxGz2+eJeHY30Uew9Xcwe7du9XcgaKUcfleGVy1NsF8KaUs6loFUsqSP8tYCHVlUDCZdpELz/Qh+c+LAPjXDafq9K/QV6sFwLZTJxj92wectW1ACPu/f6CsxwN1ejGsdU/K+Qfnf24pueeee5xWPmvQoAG7d+9Gp9N56btSFKWkilW11LF+gQT8pJSmq74uaAX2Iq9nUBIqGRSBlBi/GMOZT5dizdGg8YVKT8URMvhlhLD/E/58YAdTt87jH9N6hNZe/E7adFTQNaNrza4MbNGNasHOtQh///13OnXq5NQ+d+5cBg4c6N3vS1GUYituMugA/65P4On1DEpCJYOiM+9Zz9kXniLjhP1t4YB65ag85Qt8bm+U2+d0ymXe3/gVm86vJVt7JPdqQUpBgLyNJuFtuK/uPdxfvy0GvQ8AnTt35rfffsszVp06dThw4AB6vf46fXeKorhDrWdwi5PmbNImPc35r9ZjNWkQWkl4jyjKvz4FTWDe1dG2nTrGF//7nu1Jm8jQHESIq14qs/kQoqlPo9Bm1LKVZ2y/EcjsvOszT5s2jaFDh16Pb0tRFDd5aqWz2cB0KeWWfPa3AYZJKf/P1X5PUsmgeCz7N3P+1ZGk7csEQBeoocKwOEKeeAGhdb67dyYthS//XsuGk5s4lbUTm/58nv1SarCkh2A6pyfzSAbGvWcJSbFyaP9B/P39r8v3pChK0XkqGdiAAVJKlwVphBCPAV+pOYNSTkoyF03i/NRZZCfZm3zK+1BhxDCC/jMUUcDjodtPn+D7/RtIPLed09l7MWtP595Syj29TYPGVIHqQfW5PbQeLSs3IqpmE+qWq5Y7V6Eoyo1xvZLB/2GvamoodqRFpJJBycnsdFI/eoGkJesxG+0JwLeigXJPxBI84GlEEe77n01L5T+vP81R01kMNbXowzPRGFKcEgQANl/8qEp53+rUDKpFg3K30bxKPSKr1CXYEOjcX1EUjyt2MnAsaFPb8WUC8A6w1kXXcOA17E8eNSlJsEWhkoHnyNTzpEx+kaQVf2HJsicFfbCW8D4xhAx5FW1YeIHHHzx4kMaNG+cWrNOFhhDRI5oW993Ject5LuQcJ1ucQWgz8z2HsAbhp6lImL4Slf2rUSukGnXDa9C4Yi0iKtbCoPP63xeKcksoSTIYB4zD/khpgWMANuAJKeX84gZaVCoZeJ7t8hnSPn2NSz9swpRqTwpCByF31ids2IsYWt2T77EjRozg888/p379+kyYMIFevXrluSVks0n2nj/DppN72XvxCMfSjnMh6ySZtvNYtUkITcGVT4UtAF/CCdSVI9SnAhX9K1AtqDI1QipzW1gV6pWrSqWAcmg1Xr9DqShlWkmSQTOgOfZf9rOBGcDma7pJwAhslVKe9EjEhVDJwHtkdjrG2eNJXvoTmaf+rXLqW8lA6H2dCR74ArrKVfMcc/78eZYuXcqgQYPcfqw0I8fEjrMn2H3hGAcv/cPJtFNczD5LmuUiOfISUpea94mmfAMXaGQQPgTjpw0lSB9KqE8Y4X7hVAwoT5WAclQJLk+N4ArUCClPiCEYjVAv4Cu3Fk/NGYwDlkgpd3syuOJQyeA6kJKc9d9yefbnpG0/h9Xk+MUpJAF1wwnuHkPgf4ahK1e8CqhFZcwxse/CGQ5cPMmxlDOcSj/HhcwLpJiSMFoukyMvY9OkFXgbyiUpENIfHQH4iEAM2kACdMEE6oMI9gkm1BBCmCGYcv4hlPcPpUJACJUDw6jgH0KgbyB6jXqXQil71HsGSonYLp/BuGASqT+twXjcBNJxC0hI/OuEEtQhisCHB+Fzu3tF7zwWn01ywZjB0eQLHLt8ltNpFzmXkcTFzEukmpJJN6eSaUklR6ZjxYjUZCC02SUbVOrRSD90+KETfvho/PHV+mHQ+uOvC8Bf50+ATwCBen+CfQMJ9g0gxBBIqONjuH8gYYZAgnztffValVwU7/NoMhBCVAJaYV8G0+k6W9UmurlZjySS/s3npCVsIeOU5d/EAPiE6wloXp+ALg/g37UP2qCgGxhp/sxWG5eMWZxMTeJ0+iUuGFO4mJnMpcwUUnLSSDOlkWFOJ8tqJNuagUlmYJGZ2EQWaLJAk+P6iamSkBqE9EGDLxp80Qof9MIXncYXvfDFR2vAV+uLr8YXX60Bg96AQWvAX2/AT2f/GKA3EODjR4Dej0BfPwL1BgJ9/Qn0NRDkY8CgM+Cj9cFH46PmV25RnrpNpAE+BQZRQLVT9Z7BrcN6dDvGZbMwbtiM8YgRm/mq/yyExFAtkIBmjfG/pzN+HXoU+mRSWWC22kjPMnMxI53zxhQuZaWRnJnO5ew0UnOMpJsySM8xkmHOINuaSZYli2xrJmZbNmaZjUVmYSUHGzlIYUJoTKAxYX9y+zqSGoTUI9Aj0KFBj1bo0Qg9WsfnOo0OnfBBp9GjE3r0Wh98NHr0Gh98tD7oNXp8tT74aPX46uxtBp0Pvo6PVzZfx0c/vQ9+Ol/89HrHR198dXr0mn83nUan3kfxIk8lg5eBeGAB9sVtvgReAdKB54BU4FUp5W/5nsRDVDIofWTaBbJ+WUjG779g3HWc7Isyz1UDgG8FH/zq18TQPBK/e2LwbRKJuIWrnEopybHYyMixkJqVRWpOBinZmaRmZ5BuysSYk0m6KZNMczYZZvvHbIt9y7HlkGPNxmTNwWzLwSxNWGwmLNKEVZqwYcaGCYkZKSxIYUYICzg2j1/ZeJLUAFqE1CHQOjYdGrRohL1NI3RoHR81QodWaNEKPVqhRafRoRU6tBodOqFzJDXHR639c71Gh16rcyQgLXqtHh+tHr1Gh49GZ/9aZ+/nq7Pv88n9XIevzge9VodBq0ev0+Gn88FHq0Or0eYZTyu0aISm1CQ4TyWDPcA/UsoYIUQ54CLQRUr5mxAiANgJTJNSTvRU4PlRyaCUkxLrqT2cWPAJF39dS4jRBmk+SFve/yGEFnwr+2OoWxNDRFN8W0bh27wd2kD1Epqn2WwSk9VGjtlGltlCptmEMScbozmLDFM2meYcssw5ZJqzyTKbyLJkk20xkWPNIducQ47VhMlqxmQzYbKaMNvMmK1mzDYTFmnBYjNjkWas0oLVZsaCGZu02DfMSKzYsCCxIrECFqSwgLA5kpTV8XkRnhwri6QW0CCufERzVaLTOBKc42uhsSc+R5tGaNGgQSO0aIWOiHLN+aj7s8UKo6Bk4M6fwMb2BQAAGilJREFUZbcB0x2fX7mm1QNIKTOEEHOw30LyejJQSjkheH7iDD75ZAZX/tioFaTh+bsbMaB5BNn7jpB1Kg2zUUv26UyyT++HdfsB+wI5+hAtPlXC8K1TC98GjfGJiMQ3ojXa8LJ/m+lG0WgEBo0Wg15LCHrADwi5oTFJKbHaJGarPVFZrDZMFhtZFhPZZhM5VjOZZpMjGVnsH20WTBYTOVYTORYLJpsZk9ViT1BWCyarGbPNnpzMVgtmacFqs2C5skn7R6vNgkVa7clLWrBJKzZpwer4aMPm+GhFSqv9I1YktqsSmv1rxJWPNsBqv+XnSG5gs1+F/X979x4nRXUmfPz39GV67shlBoQdRMEFNWCCmk1EDaLgB91E1zdiwHW9RHGVXDZeyGp8E1bXuHETL69rAjGaTSQqa/Jq1FeNuPloRGVdiYrogkEQmAkzDLe5T1+qnvePqhmHmZ6e6ZnuaWb6+X4+51Nd51RXPz2XfrrqVJ0j/vbiDezY7+My7bmxU5+do+l09toGdAxR2YwXYmWX9lqgKkNxmWFu7NixdD3q3NHk8g8vvE/5ohu44s4rwHVwtr9N+/qXaH/3LaLbdtL+5waiB4V4g0O8YS8tm/fC8xsA7z7GYKEQHldMwZHjKKiqInz0sRQcO5Pw9BMJjZ+Qclwlc/gREUJBIRSEIrp2NRblLKbBcF0l7ro4rpJwlYTjJbuYkyAajxNzHWKJRGcii7sJookYMSdBwnFod+I4rkPcTRBLxEmo/9hJ4LgOMSdOwnWYNmZi38EMQDqnid4G/lNVb/TXtwBvqeol/vrjwF+p6tFZibQLO010+Gtvb2fWrFn86U9/OqR+7NixbN68mXHjek6agyp6oJrYu68S3bSB6IebiVXXEdvTTLRB0USKD/sAhMvDhMeWEq4YQ2jCeMJVUwj/xTGEpkwnVHUMwdGjD5tzt8bkQqb6DH4EXKCqU/31W4HbgFfw7lA+Hfihqn47I1GnYMlgeHjppZeYP39+j/orrriChx9+OK19acs+ElvfJr75bWJb/4fYrmritfuI7W0h3uTiRPu+iE0CECoNERpVRGh0KcExowlVVBKqnEBw/CRCE6cQmjiF4LhKAmVlljjMiJOpZHAkMAt4WVWjIhIE7gH+FnCAXwPfUtVB3s3TN0sGw8eSJUt47LHHetT/7ne/Y8GCBZl5kXgbbu1W4lvfJb5tC/GaXSRqa4nX7ydxsIV4Y5xEqxx66WtfAhAqChIsCRMsKyJYWkxwVBnBI0YTHDOG4OhxBMeOJzB2PMGKiQTHVBIoH0WgpNiSiDls2R3IJmdqa2uZMWMGDQ0Nh9RXVVWxadMmysvLsx+EKrQ34NbvILFzC4nq7SRqa0jU7yGxdx/OwUYSja0kmmM4bS5OewA31SmpVAQCBUKwMEigKEywKEKguJBAaTHBkhICpaUEysoIlI0iUHYEgfIjCJSPJjhqLDJqrFdXUkyguBgpKLDEYjLKkoHJqZUrV3Lttdf2qF+6dCmrVq1K8owcch1oO4i7vwZnzy6c2l049btx9teT2L8fp6ERt6kZp7kVpyWK0xrHbXdwYoITl9T9GukSCISFQEEAKQgSKAgRiIQIRAqQwgICkQiBwghSVESgsMhbFhUhRSUEikuQ4lICRaVIcQmBkjKkuBwpKSNQVIIUFhKIRJBIxEs6SWa6MyPPgJKBP5dB2lR150Celw5LBsOL67rMnz+f3/++5/2Ia9eu5eyzz85BVBkWb4doI9q8D2fvbtwDdTgH9uIe2IfTeBC3qRG3udkrra24rVGctihuexw3lsCNOrhxxY2DmwigCelxX0ZWBSAQFCQkSCiAhAMEQgEkFPRKOIiEw0g4hITDBApCSLjAqysIIwV+UulYRiL+40JvWViERAq99UghEin65HFhMYQLvef5+5dQqLMQDtsRUoYMNBm4pHE5bAcbjsIks337dmbOnElLS8sh9VVVVbz77ruMHj06R5EdZhIxiDVDrAVtOYjbeAC36QBuUwNuSwPa3ITb2ozb0oy2t3qJpa0NbY/iRqNoNIYbjaGxBG4sgcYdNO7gxl3UUdy4og6oI7iu+I+HwSW5Ae8CAAkIEvQKAfHXA0gwAP5SQv4yGIRg0K8LeduEQkgw6CeaoLceCiHBkPc4HEKC4U/qQ2EvGYW8BEXIT4DhMIQ66sMQLkBCBUi4wH8chnDET5gRf9ugF5MfAx1xBPy4OpZZTHwDvensNgaQDIxJ5uijj+auu+5i2bJlh9Tv2rWLa665hjVr1ti3P4BQAYTGQPEY5IgqgpMg49+unDgkon5pR+Nt0N6M29qEtjajba1eomlrQaNtaFubt4y240bb0VgMjUbReMcyjiYSaMxfxhN+nYsmHG/dUdRx/eI/Tijq+snJuz8LdQV1QdVfuuINa+J622iyu7BGGvGKBLx7MfCToJf8oHT2sRy56snMv6z1GZih4rouZ511Fi+//HKPtoceeogrr7xy6IMyhwfXBTcOTsxLVk7cX4+jiRjEvGSk8ai3jLah8SjEYl5SintJiXjUS1Zx73ka69hH3EtKiTh0JCwn4T1OJFDXS1wkEqjjgOOijuMnL3/d9ZIYjuM9drWzHn/9k8d4j9VPYv55FlXAFW/ZkfA6HvvLvpTPHMukJ9YN6MdsHcjmsLFjxw5OPPHEHlcXFRcX88c//pHp06fnKDJjskjVuzjBTXhFHW/diX/y2I37iSeOxmOQiHsJLx5HO+qcBDKqktD0UwcURkbGJupvh/JQdCCb4euoo45i5cqVLF68+JD61tZWFi9ezGuvvUZR0fAcjsCYXolAMOSVVJt1Ww6ldHqOPga296MYk9JXvvIVLr/88h719fX17Nxp3yWMyYV0BqpL1qEcAqYC5wPvAc9nKC4zwt1///289tprnWMXnXnmmTz++ONUVlb28UxjTDb0Oxmo6ore2kTkGOANwE7km34pLS3lscceY86cOXz961/nzjvvJJTHE90Yk2sZ+e9T1W0isgr4J+D/ZWKfZuQ76aST2LJlC0cddVSuQzEm72XybpMa4PgM7s/kAUsExhweMpkMLgAOZHB/xhhjhkg6l5Z+t5emMcA84FPAXWns72bgQmA6EAXWAzer6qb+7sOMfI2NjaxatYrrr7+eoA2mZkzWpNNnsCJFWy1wK/CDNPY3F/gx8N94l9XeBrwkIser6v409mNGqOrqas477zw2btzI5s2befDBBwnY1JbGZEU6ySDZdJYK7FfV5nRfWFXP6bouIpcCDcAc4Jl092dGlo0bN3LuuedSU1MDwMMPP0wwGGTlypWWEIzJgnQuLd2RzUCAMrw+jKT9DiKyFFgKMHnygEbXNsNEbW0tp59+Oo2NjYfUdxwZPPDAA3bKyJgMG9BXLBGZLiIL/ZKpwWTuA97Bu1+hB1X9qaqerKonV1RUZOglzeFowoQJfO9730vatmrVKi6++GLa27M+u6oxeSWtZCAi80TkfeAD4Fm/fCAi74vIWQMNQkTuBk4D/peqOgPdjxk5rr/+en7wg+RdUL/5zW9YsGAB+/db15IxmdLvZCAi84AXgMnAg8C3gOuBnwFVwPP+NmkRkXuAxcA8Vd2W7vPNyLV8+XLuuOOOpG2vvvoqp556Ku+///4QR2XMyJTOkcH3gTpghqr+var+H1W9T1WvwbvZbA+Q/D+3FyJyH7AELxFsTue5Jj/ccsst3HVX8iuWt2zZwmc/+1lWr149xFEZM/KkkwxmAatUtaZ7g6pWA6uAE/u7MxF5ALgC76jggIhM8EtpGjGZPHDTTTfxq1/9inA43KOttbWVSy+9lKuvvrpHh7Mxpv/SSQYNQFOK9kbgYBr7uw7vCqL/BHZ3KTemsQ+TJ5YsWcLzzz9PWVlZ0vaf/exnnHDCCTz77LNDHJkxI0M6yeAJYLGI9LgcVUTCeN/wn+jvzlRVeikr0ojJ5JGzzjqL9evXc9xxxyVtr66u5otf/CKLFi3io48+GuLojBne0kkGK/HuS/iDiFwkIjNF5FMisgj4A9683StFZHLXko2gTf46/vjjefPNN1myZEmv2zzxxBPMmTOHWCw2hJEZM7ylcwfyJrw7jgV4vFubdNmmO7s7yGRUaWkpq1ev5owzzuCGG26gpaWlxzY33ngjBQUFOYjOmOFJVLtPXtbLhiIr6DnTWZ9U9Z/SfU5fTj75ZH3rLZtHx8DHH3/MNddcw4svvthZV1VVxYcffkhhYWEOIzPm8CMiG1T15GRtGZnpzJhcmTJlCi+88AKPPPIIy5cvp66ujttvvz1lIojH49x0000sXLiQM888044gjCGNI4PDiR0ZmGSam5v5+c9/znXXXZdy7KKnn36a888/H4BRo0ZxzjnnMH/+fObPn2+T7ZgRLdWRQVrJQEQCwGXA3wDH+NXbgP8L/FJV3UHG2i+WDMxgXHjhhTz55JNJ26ZOncqcOXM47bTT+PznP89xxx1ng+KZESMjyUBEioDngDPw+g52+01H4nUgvwKcq6pZH0HMkoEZqPr6eiZOnEgikejX9sXFxcyePZvZs2czc+ZMZs2axQknnEBJSUmWIzUm8zLSZ4A3ec0XgB8Cd6rqAX/nRwA3AzcB3wH+9+DCNSZ7Hn300X4nAvDucF63bh3r1q07pH7y5MksW7aM5cuXZzpEY3IinWRwMfAfqnrIX7+qHgS+LSJH4d14ZsnAHLauvPJKJk6cyJNPPsmzzz5LU1Oqm+p7t3Pnzj6Typo1a3jnnXeoqqpi0qRJTJo0iYkTJ1JZWUkolM6/njHZl85f5F/gHRX05hXggsGFY0x2lZWVcdFFF3HRRRcRjUZ54403WLt2LWvXrmXDhg24bv+7vWbMmJGy/emnn+bRRx/tUR8IBKioqODII49k/PjxVFZWMn78eCoqKhg3bhwVFRWMHTu2s4wePdr6LUzWpZMMDgLHpmifRnpjExmTU5FIhLlz5zJ37lzuuOMOGhsbWb9+PevWreP1119nw4YNHDzY+590b8NidNi1a1fSetd1qauro66url9xzpkzp8dpqq527NjBb3/7W8rLyxk1ahRlZWWUl5dTVlbWWUpLSy2hmJTSSQZrgetE5EVV/V3XBhFZAFxLGmMTGXO4KS8vZ8GCBSxYsAAAVWXbtm1s2LCB9957j40bN/Lee+/x8ccfEwwGmTZtWsr97dy5MyNxjRkzJmX7xo0b+eY3v9nnfoqKiigtLaWkpKRz2VGKi4spLi7m9ttvZ9KkSb3uY926dSQSCQoLC5OWSCRCJBKxeaqHoXQ7kM8BnhORt4GOWUVOAD4D7AW+m9nwjMkdEWHq1KlMnTqVRYsWdda3trayY8eOpENqd3Ach5qaHqO9D0hfyaChoaFf+2lra6OtrY36+vpet7n55ptT7uOyyy5j27a+56AKh8OdiaFrKSgoIBKJ8KUvfYlbb7211+evX7+eNWvWEA6HKSgoOGTZUUKh0CHrXetCoVDn41NOOYVIJNLra9XX1yMihEIhgsFg53ODwWBeJbV07kDeISInA3cCXwRm+01NwGPALaqama9CxhzGiouL+zxF5DgOP/nJT9i5cyfV1dXU1NRQU1PD7t27056us69kkOpUVrqKi4tTtvd37ul4PE48Hqe5uTlp+4knpp76ZOPGjdx77739eq2+1NTUMHHixF7bZ82aRW1tba/tXZNE12VH6Vi/5JJLuO2223rdz1NPPcW9997bmWS6LruWQCCQtD0QCHDSSSexdOnSQf08en2f6Wzsf9hfIiICVODdX7BHh+NtzMZkUUFBAVdddVXStmg0Sl1dHbW1tdTV1bFnzx727NlDfX09e/bsYe/evezbt6+zZOrIoD/6SgZtbW0ZeZ2+hgCJx+MZeR0g5REc0OdVYYlEgkQiQTQaTbndvn37UrZXV1fzyiuvpNymL1/+8pdzmwxEpALvjuO9qvqR/+G/JysRGTPCRSIRJk+ezOTJ/Rvhva/vWrNnz2bZsmU0NDTQ0NBAU1NTj9LbN/Tu+rqZrr9HBn1JddoGyOjw431dxpvOfSep9NVB7zjOoF8jm6etUv6U/OEnfgxchT9MtYi8AfyNqvZ+4tEYkzHegXjvFi5cyMKFC1Nu47oubW1tNDc309TUREtLS2dpbW2ltbWVlpaWPr9Fz507l5aWFtrb2zv7IKLRKNFotPNxfz7I+zoysGQwsNcYjL6ODL4GLAX+DLyBd2npqXjzHV+YtaiMMRkVCAQ6rxwaP378gPfz3HPP9bmNqhKLxTqTRPcSi8WYMGFCyn3MmzePH/3oR8Risc7+h66loz6RSHTWdZzO6V7fV4IbM2YMkUik8zmO4+A4TtpJYrgfGaQcm0hE3gKKgM+papNf9yBwOVDh33085GxsImPMUHBdl0QicUiC6LretZSXl1NRUdHrvnbt2sXWrVtxHAfXdTuf57puj/Vk2ziOw7Rp0zj77LMH/H4GMzbRdOC2jkTgux/4KvCXwJsDjsoYYw5zgUAgY/NdVFVVUVVVlZF9ZUNfxxwleKeIuvpzlzZjjDEjQH9OQHU/j9SxnrpXyxhjzLDRn0tLzxWRrr09xXgJ4SIR+XS3bVVV78lYdMYYY4ZEf5LBEr90d02SOgUsGRhjzDDTVzI4c0iiMMYYk1Mpk4GqDu7eaWOMMcNCv+dAPpyISD2wY4BPH4c3wmo+sfecH+w954fBvOejVDXpzRDDMhkMhoi81dtNFyOVvef8YO85P2TrPefPYN3GGGN6ZcnAGGNMXiaDn+Y6gByw95wf7D3nh6y857zrMzDGGNNTPh4ZGGOM6caSgTHGGEsGxhhj8iwZiMh1IrJdRNpFZIOInJ7rmLJFRG4Wkf8WkUYRqReRZ0TkU7mOa6iIyC0ioiLyb7mOJZtE5EgR+YX/O24XkQ9E5Au5jitbRCQoIrd3+T/eLiL/LCL9ms99OBCRM0TkaRGp8f+GL+/WLiKyQkT+LCJtIvKyiJww2NfNm2QgIhcD9wHfBz4DvA48LyL9m5V8+JmLN3/1qcA8IAG8JCJjchnUUBCRzwFXAxtzHUs2icgRwGt4w8mfBxwHfB3Yk8u4suzbwDLgG8AM4Jv++s25DCrDSoFNeO+tLUn7cuAGvN/1KXi/77UiUjaYF82bq4lE5L+Ajap6dZe6PwG/VtWR9IeUlIiUAg3ABar6TK7jyRYRGQX8ES8ZfBfYpKpfy21U2SEi3we+oKpzch3LUBGRZ4F9qnpZl7pfAGNV9a9zF1l2iEgz8DVV/Xd/XfAmGPs3Vb3DryvCSwg3quqqgb5WXhwZiEgBcBLwYremF/G+OeeDMrzf94FcB5JlP8VL8L/PdSBD4ALgv0RkjYjsEZF3RORr/gfGSLUOOFNEZgCIyPF4R77P5TSqoXM0MIEun2Wq2gb8gUF+lo2Y82x9GAcEgbpu9XXAwGeXHl7uA94B3sh1INkiIlcD04BLcx3LEDkGuA5vDpF/AT6NN0c5wEjtK/kB3hebD0TEwfsMu0NVf5zbsIZMx0RjyT7LJg1mx/mSDDp0PycmSepGHBG5GzgNOE1VnVzHkw0iMh2vP+h0VY3lOp4hEgDe6nKa820RORbvHPpITQYXA3+HN+HW+3gJ8D4R2a6qD+U0sqGV8c+yvDhNhDfcq8MnWbVDJT0z7IgiIvcAi4F5qrot1/Fk0efxjgA3iUhCRBLAF4Dr/PVIbsPLit3AB93q/gcYqRdFAPwr8ENVfVxV31PVR4C7GVkdyKnU+suMf5blRTLwvyluAOZ3a5qPd1XRiCQi9+F9g5qnqptzHU+WPQXMxPum2FHeAh73H4/Eo4XXgOnd6v6Sgc/1MRwU432x68ohTz7LgO14CaHzs0xECoHTGeRnWT6dJrobeERE3sT7J/p7YCKwMqdRZYmIPIB37vwC4ICIdHyTaFbV5txFlh2qehA42LVORFqA/aq6KTdRZd09wOsi8h1gDd4l098AbslpVNn1DPCPIrId7zTRZ4DrgV/mNKoM8q/8m+avBoDJIvJpvL/lnSJyL/AdEdkMfAjcCjQDjw7qhVU1bwpeZ9vHQBTvSOGMXMeUxfeqvZQVuY5tCH8GL+NdgpfzWLL4Hs8D3gXa/Q+Gb+BfMj4SC17n8b14Rz9twDa8vqLCXMeWwfc4t5f/3X/32wVYgXeasB14BfjUYF83b+4zMMYY07t8Oc9mjDEmBUsGxhhjLBkYY4yxZGCMMQZLBsYYY7BkYIwxBksGxvSLiEzxJxpZketYjMmGfLoD2ZhOIpLODTZHZy0QYw4TlgxMvuo+zPXpwFK8+RBe7dZWD7QCRXgzxhkz4lgyMHlJVVd3Xffn0F0KvNG9rYv2rAdmTI5Yn4Ex/ZCsz6BrnYgs8mcaaxORrSJyhb/NZBH5tYjsF5EmEVmdbK5af2L7n4jIThGJ+ZOd/1REKofwbZo8ZkcGxgzeX+ONgvtjYD/wVeBhEYnhDaL2e7yRRE8BrsQ7wriq48kiMhlvBroC4CHgI7xRK6/Fm+LxZFVtGLJ3Y/KSJQNjBu844HhV3QEgImuAXcAjeJOU3+1vt1JERgN/JyL/oJ8MJX4/EAY+o6rVHTsVkSeA9cC38EapNCZr7DSRMYP3VEciAFDVemAL4AIPdNv2VbwP/ikAIjIK78jiaaBdRMZ1FLzh1rcCC7L9BoyxIwNjBi/ZdKIHgN2qGk1SDzDWX07H+1L2Vb/0d//GZJQlA2MGr/s0jH3VgzdBSdflauAXvWzbNpCgjEmHJQNjcmsr3ixWBar6Uq6DMfnL+gyMySFV3Qc8B1woIp/r3i6eiqGPzOQbOzIwJveuBdYBfxCRXwJv431ROwY4H2+y9xU5i87kBUsGxuSYqu4SkZOAb+N9+P8t3r0Iu4BngP/IYXgmT4hqOuN1GWOMGYmsz8AYY4wlA2OMMZYMjDHGYMnAGGMMlgyMMcZgycAYYwyWDIwxxmDJwBhjDJYMjDHGAP8fVHsvbG5e/HsAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots() \n", - "count = 0\n", - "# sys.params_values = params_values_new\n", - "# sys.x_init[0] = params_values[-3]\n", - "# sys.x_init[3] = params_values[-2]\n", - "# sys.x_init[5] = params_values[-4]\n", - "# print(sys.x_init)\n", - "timepoints_ode = np.linspace(0,10,100)\n", - "sys_ode = get_ODE(sys, timepoints_ode)\n", - "sol = sys_ode.solve_system().T\n", - "_ = plt.plot(timepoints_ode, np.transpose(np.array(sys.C)@sol)[:,1]/np.transpose(np.array(sys.C)@sol)[:,0], 'k--', label = 'Full CRN model', linewidth = 5)\n", - "for key,value in results.items():\n", - "# error = value[0]\n", - "# if error > 1e-5:\n", - " sys_i = key\n", - " sys_i.params_values = params_values\n", - "# _ = plt.subplots(count%3, count%3)\n", - " sys_i_ode = get_ODE(sys_i, timepoints_ode)\n", - " sol_i = sys_i_ode.solve_system().T\n", - " _ = plt.plot(timepoints_ode, np.transpose(np.array(sys_i.C)@sol_i)[:,1]/np.transpose(np.array(sys_i.C)@sol_i)[:,0], label = str(sys_i.x), linewidth = 2)\n", - " _ = plt.xlabel('Time', FontSize = 18)\n", - " _ = plt.ylabel('Population Composition', FontSize = 18)\n", - " _ = ax.tick_params(axis='both', which='major', labelsize=14)\n", - " _ = plt.legend(prop={'size': 8})\n", - " count += 1\n", - "\n", - "# _ = plt.axvline(x=timepoints_ode[6], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# _ = plt.axvline(x=timepoints_ode[15], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "# _ = plt.axvline(x=timepoints_ode[30], color = 'k',linestyle = ':',linewidth = 1.5)\n", - "_ = plt.savefig('pop_control_composition.svg')\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 138, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# fig, ax = plt.subplots() \n", - "fig = plt.figure(num=None, figsize=(10, 8), dpi=80, facecolor='w', edgecolor='k')\n", - "# count = 0\n", - "import seaborn as sn\n", - "# params_names = ['$'+str(i)+'$' for i in params]\n", - "# beta_S1 = symbols('beta_S1')\n", - "# l_S1 = symbols('l_S1')\n", - "# K_S1 = symbols('K_S1')\n", - "# kb = symbols('kb')\n", - "# beta_S2 = symbols('beta_S2')\n", - "# l_S2 = symbols('l_S2')\n", - "# K_S2 = symbols('K_S2')\n", - "# beta_lac = symbols('beta_lac')\n", - "# l_lac = symbols('l_lac')\n", - "# K_lac = symbols('K_lac')\n", - "# beta_tet = symbols('beta_tet')\n", - "# l_tet = symbols('l_tet')\n", - "# K_tet = symbols('K_tet')\n", - "# kc = symbols('kc')\n", - "# C_max = symbols('C_max')\n", - "# dc = symbols('dc')\n", - "# I = symbols('I')\n", - "# atc = symbols('atc')\n", - "# K_tox = symbols('K_tox')\n", - "# d = symbols('d')\n", - "# d_T = symbols('d_T')\n", - "# d_S = symbols('d_S')\n", - "params_names = ['$\\\\beta_{R1}$', '$l_{R1}$', '$K_{R1}$', '$k_{b}$', '$\\\\beta_{R2}$', '$l_{R2}$', '$K_{R2}$',\n", - " '$\\\\beta_{tac}$', '$l_{tac}$', '$K_{tac}$', \n", - " '$\\\\beta_{sal}$', '$l_{sal}$', '$K_{sal}$', \n", - " '$k_c$', '$C_{max}$', '$d_c$',\n", - " '$K_{tox}$', '$d$', '$d_T$', '$d_S$'\n", - " ]\n", - "\n", - "rob_2d_all = []\n", - "rob_2d = []\n", - "sys_reduced_x = []\n", - "# plt.plot(timepoints_ode, np.transpose(np.array(sys_reduce.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - "# params_names[0] = '$k_b$'\n", - "for key,value in results.items():\n", - " sys_i = key\n", - " Se = value[1]\n", - " Se = np.delete(Se, [16])\n", - " Se = np.delete(Se, [16])\n", - " sys_reduced_x.append(str(sys_i.x))\n", - " rob_2d.append(Se)\n", - "# rob_2d = [ Se_x, Se_tx, Se_rx, Se_px]\n", - "sn_ax = sn.heatmap(np.array(rob_2d), cbar_kws={'label': 'Robustness metric ($\\|S_{\\zeta}\\|$)', \n", - " 'orientation':'horizontal','fraction':0.2,\n", - " })\n", - "\n", - "# cbar_axes = sn_ax.figure.axes[-1]\n", - "sn_ax.figure.axes[-1].xaxis.label.set_size(20)\n", - "ax = fig.axes\n", - "_ = plt.xlabel('All Parameters', FontSize = 20)\n", - "_ = plt.ylabel('Reduced models', FontSize = 20)\n", - "_ = ax[0].tick_params(axis='x', which='major', labelsize=14)\n", - "_ = ax[0].tick_params(axis='y', which='major', labelsize=18)\n", - "_ = ax[0].set_xticklabels(params_names)\n", - "_ = ax[1].tick_params(axis = 'x', labelsize = 18)\n", - "bottom, top = ax[0].get_ylim()\n", - "# ax[0].set_ylim(bottom + 0.5, top - 0.5)\n", - "# _ = ax[0].set_yticklabels(sys_reduced_x, rotation = 0)\n", - "# h.set_rotation(0)\n", - "_ = plt.savefig('pop_control_robustness1.svg')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# fig, ax = plt.subplots() \n", - "fig = plt.figure(num=None, figsize=(10, 8), dpi=80, facecolor='w', edgecolor='k')\n", - "# count = 0\n", - "import seaborn as sn\n", - "# params_names = ['$'+str(i)+'$' for i in params]\n", - "# beta_S1 = symbols('beta_S1')\n", - "# l_S1 = symbols('l_S1')\n", - "# K_S1 = symbols('K_S1')\n", - "# kb = symbols('kb')\n", - "# beta_S2 = symbols('beta_S2')\n", - "# l_S2 = symbols('l_S2')\n", - "# K_S2 = symbols('K_S2')\n", - "# beta_lac = symbols('beta_lac')\n", - "# l_lac = symbols('l_lac')\n", - "# K_lac = symbols('K_lac')\n", - "# beta_tet = symbols('beta_tet')\n", - "# l_tet = symbols('l_tet')\n", - "# K_tet = symbols('K_tet')\n", - "# kc = symbols('kc')\n", - "# C_max = symbols('C_max')\n", - "# dc = symbols('dc')\n", - "# I = symbols('I')\n", - "# atc = symbols('atc')\n", - "# K_tox = symbols('K_tox')\n", - "# d = symbols('d')\n", - "# d_T = symbols('d_T')\n", - "# d_S = symbols('d_S')\n", - "params_names = ['$\\\\beta_{R1}$', '$l_{R1}$', '$K_{R1}$', '$k_{b}$', '$\\\\beta_{R2}$', '$l_{R2}$', '$K_{R2}$',\n", - " '$K_{tac}$', \n", - " '$\\\\beta_{sal}$', '$l_{sal}$', '$K_{sal}$', \n", - " '$k_c$', '$C_{max}$', '$d_c$',\n", - " '$K_{tox}$', '$d_T$', '$d_S$'\n", - " ]\n", - "\n", - "rob_2d_all = []\n", - "rob_2d = []\n", - "sys_reduced_x = []\n", - "# plt.plot(timepoints_ode, np.transpose(np.array(sys_reduce.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - "# params_names[0] = '$k_b$'\n", - "for key,value in results.items():\n", - " sys_i = key\n", - " Se = value[1]\n", - " Se = np.delete(Se, [16])\n", - " Se = np.delete(Se, [16])\n", - " Se = np.delete(Se, [17])\n", - " Se = np.delete(Se, [7])\n", - " Se = np.delete(Se, [7])\n", - "# if len(sys_i.x) >= 4:\n", - "# continue\n", - " sys_reduced_x.append(str(sys_i.x))\n", - " rob_2d.append(Se)\n", - "# rob_2d = [ Se_x, Se_tx, Se_rx, Se_px]\n", - "sn_ax = sn.heatmap(np.array(rob_2d), cmap=\"YlGnBu\",cbar_kws={'label': 'Robustness metric ($\\|S_{\\zeta}\\|$)', \n", - " 'orientation':'horizontal','fraction':0.2,\n", - " })\n", - "\n", - "# cbar_axes = sn_ax.figure.axes[-1]\n", - "sn_ax.figure.axes[-1].xaxis.label.set_size(20)\n", - "ax = fig.axes\n", - "_ = plt.xlabel('Relevant Parameters', FontSize = 20)\n", - "_ = plt.ylabel('Reduced models', FontSize = 20)\n", - "_ = ax[0].tick_params(axis='x', which='major', labelsize=14)\n", - "_ = ax[0].tick_params(axis='y', which='major', labelsize=18)\n", - "_ = ax[0].set_xticklabels(params_names)\n", - "_ = ax[1].tick_params(axis = 'x', labelsize = 18)\n", - "bottom, top = ax[0].get_ylim()\n", - "# ax[0].set_ylim(bottom + 0.5, top - 0.5)\n", - "# _ = ax[0].set_yticklabels(sys_reduced_x, rotation = 0)\n", - "# h.set_rotation(0)\n", - "_ = plt.savefig('pop_control_robustness.svg')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# fig, ax = plt.subplots() \n", - "fig = plt.figure(num=None, figsize=(10, 8), dpi=80, facecolor='w', edgecolor='k')\n", - "# count = 0\n", - "import seaborn as sn\n", - "# params_names = ['$'+str(i)+'$' for i in params]\n", - "# beta_S1 = symbols('beta_S1')\n", - "# l_S1 = symbols('l_S1')\n", - "# K_S1 = symbols('K_S1')\n", - "# kb = symbols('kb')\n", - "# beta_S2 = symbols('beta_S2')\n", - "# l_S2 = symbols('l_S2')\n", - "# K_S2 = symbols('K_S2')\n", - "# beta_lac = symbols('beta_lac')\n", - "# l_lac = symbols('l_lac')\n", - "# K_lac = symbols('K_lac')\n", - "# beta_tet = symbols('beta_tet')\n", - "# l_tet = symbols('l_tet')\n", - "# K_tet = symbols('K_tet')\n", - "# kc = symbols('kc')\n", - "# C_max = symbols('C_max')\n", - "# dc = symbols('dc')\n", - "# I = symbols('I')\n", - "# atc = symbols('atc')\n", - "# K_tox = symbols('K_tox')\n", - "# d = symbols('d')\n", - "# d_T = symbols('d_T')\n", - "# d_S = symbols('d_S')\n", - "params_names = ['$\\\\beta_{R1}$', '$l_{R1}$', '$K_{R1}$', '$k_{b}$', '$\\\\beta_{R2}$', '$l_{R2}$', '$K_{R2}$',\n", - " '$K_{tac}$', \n", - " '$\\\\beta_{sal}$', '$l_{sal}$', '$K_{sal}$', \n", - " '$k_c$', '$C_{max}$', '$d_c$',\n", - " '$K_{tox}$', '$d$', '$d_T$', '$d_S$'\n", - " ]\n", - "\n", - "rob_2d_all = []\n", - "rob_2d = []\n", - "sys_reduced_x = []\n", - "# plt.plot(timepoints_ode, np.transpose(np.array(sys_reduce.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - "# params_names[0] = '$k_b$'\n", - "for key,value in results.items():\n", - " sys_i = key\n", - " Se = value[1]\n", - " Se = np.delete(Se, [16])\n", - " Se = np.delete(Se, [16])\n", - " Se = np.delete(Se, [7])\n", - " Se = np.delete(Se, [7])\n", - " if sys_i == reduced_sys_1467:\n", - " continue\n", - " sys_reduced_x.append(str(sys_i.x))\n", - " rob_2d.append(Se)\n", - "# rob_2d = [ Se_x, Se_tx, Se_rx, Se_px]\n", - "sn_ax = sn.heatmap(np.array(rob_2d), cbar_kws={'label': 'Robustness metric ($\\|S_{\\zeta}\\|$)', \n", - " 'orientation':'horizontal','fraction':0.2,\n", - " })\n", - "\n", - "# cbar_axes = sn_ax.figure.axes[-1]\n", - "sn_ax.figure.axes[-1].xaxis.label.set_size(20)\n", - "ax = fig.axes\n", - "_ = plt.xlabel('Relevant Parameters', FontSize = 20)\n", - "_ = plt.ylabel('Reduced models', FontSize = 20)\n", - "_ = ax[0].tick_params(axis='x', which='major', labelsize=14)\n", - "_ = ax[0].tick_params(axis='y', which='major', labelsize=18)\n", - "_ = ax[0].set_xticklabels(params_names)\n", - "_ = ax[1].tick_params(axis = 'x', labelsize = 18)\n", - "bottom, top = ax[0].get_ylim()\n", - "# ax[0].set_ylim(bottom + 0.5, top - 0.5)\n", - "# _ = ax[0].set_yticklabels(sys_reduced_x, rotation = 0)\n", - "# h.set_rotation(0)\n", - "_ = plt.savefig('pop_control_robustness2.svg')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 139, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "43909785610.40579" - ] - }, - "execution_count": 139, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Se = np.array(Se_0467)\n", - "Se = np.delete(Se, [16])\n", - "Se = np.delete(Se, [16])\n", - "Se = np.delete(Se, [7])\n", - "Se = np.delete(Se, [7])\n", - "np.sum(Se)#/np.max(Se)" - ] - }, - { - "cell_type": "code", - "execution_count": 140, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "59844157626.83096" - ] - }, - "execution_count": 140, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Se = np.array(Se_0567)\n", - "Se = np.delete(Se, [16])\n", - "Se = np.delete(Se, [16])\n", - "Se = np.delete(Se, [7])\n", - "Se = np.delete(Se, [7])\n", - "np.sum(Se)\n", - "# /np.max(Se)" - ] - }, - { - "cell_type": "code", - "execution_count": 141, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "5.8524912484795736e+16" - ] - }, - "execution_count": 141, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Se = np.array(Se_1467)\n", - "Se = np.delete(Se, [16])\n", - "Se = np.delete(Se, [16])\n", - "Se = np.delete(Se, [7])\n", - "Se = np.delete(Se, [7])\n", - "np.sum(Se)#/np.max(Se)" - ] - }, - { - "cell_type": "code", - "execution_count": 142, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "47101313026.60535" - ] - }, - "execution_count": 142, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Se = np.array(Se_1567)\n", - "Se = np.delete(Se, [16])\n", - "Se = np.delete(Se, [16])\n", - "Se = np.delete(Se, [7])\n", - "Se = np.delete(Se, [7])\n", - "np.sum(Se)#/np.max(Se)" - ] - }, - { - "cell_type": "code", - "execution_count": 143, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Stored 'Se_0467' (ndarray)\n" - ] - } - ], - "source": [ - "%store Se_0467 " - ] - }, - { - "cell_type": "code", - "execution_count": 144, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Stored 'Se_0567' (ndarray)\n" - ] - } - ], - "source": [ - "%store Se_0567 " - ] - }, - { - "cell_type": "code", - "execution_count": 145, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Stored 'Se_1467' (ndarray)\n" - ] - } - ], - "source": [ - "%store Se_1467 " - ] - }, - { - "cell_type": "code", - "execution_count": 146, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Stored 'Se_1567' (ndarray)\n" - ] - } - ], - "source": [ - "%store Se_1567 " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.9.12 ('base')", - "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.9.12" - }, - "vscode": { - "interpreter": { - "hash": "086edbbad6d007afd932f3998127bea1c36f47a35b43b79d0f508f10f9e57cc3" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/IJRNC_examples/toggle-switch example.ipynb b/IJRNC_examples/toggle-switch example.ipynb deleted file mode 100644 index 907d71a..0000000 --- a/IJRNC_examples/toggle-switch example.ipynb +++ /dev/null @@ -1,289 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from autoreduce import *\n", - "import numpy as np\n", - "from sympy import symbols" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# Post conservation law and other approximations phenomenological model at the RNA level\n", - "n = 4 # Number of states \n", - "nouts = 2 # Number of outputs\n", - "\n", - "# Inputs by user \n", - "x_init = np.zeros(n)\n", - "n = 4 # Number of states \n", - "timepoints_ode = np.linspace(0, 100, 100)\n", - "C = [[0, 0, 1, 0], [0, 0, 0, 1]]\n", - "nstates_tol = 3\n", - "error_tol = 0.3\n", - "# System dynamics symbolically\n", - "\n", - "# params = [100, 50, 10, 5, 5, 0.02, 0.02, 0.01, 0.01]\n", - "# params = [1, 1, 5, 0.1, 0.2, 1, 1, 100, 100] # Parameter set for which reduction doesn't work\n", - "# K,b_t,b_l,d_t,d_l,del_t,del_l,beta_t,beta_l = params\n", - "\n", - "x0 = symbols('x0')\n", - "x1 = symbols('x1')\n", - "x2 = symbols('x2')\n", - "x3 = symbols('x3')\n", - "x = [x0, x1, x2, x3]\n", - "\n", - "K = symbols('K')\n", - "b_t = symbols('b_t')\n", - "b_l = symbols('b_l')\n", - "d_t = symbols('d_t')\n", - "d_l = symbols('d_l')\n", - "del_t = symbols('del_t')\n", - "del_l = symbols('del_l')\n", - "beta_t = symbols('beta_t')\n", - "beta_l = symbols('beta_l')\n", - "params = [K,b_t,b_l,d_t,d_l,del_t,del_l,beta_t,beta_l]\n", - "f0 = K * b_t**2/(b_t**2 + x[3]**2) - d_t * x[0]\n", - "f1 = K * b_l**2/(b_l**2 + x[2]**2) - d_l * x[1]\n", - "f2 = beta_t * x[0] - del_t * x[2]\n", - "f3 = beta_l * x[1] - del_l * x[3]\n", - "f = [f0,f1,f2,f3]\n", - "# parameter values\n", - "params_values = [100, 50, 10, 5, 5, 0.02, 0.02, 0.01, 0.01]\n", - "sys = System(x, f, params = params, params_values = params_values, C = C, x_init = x_init)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from autoreduce.utils import get_ODE\n", - "sys_ode = get_ODE(sys, timepoints_ode)\n", - "sol = sys_ode.solve_system().T\n", - "try:\n", - " import matplotlib.pyplot as plt\n", - " plt.plot(timepoints_ode, np.transpose(np.array(C)@sol))\n", - " plt.xlabel('Time')\n", - " plt.ylabel('[Outputs]')\n", - " plt.show()\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - } - ], - "source": [ - "from autoreduce.utils import get_SSM\n", - "timepoints_ssm = np.linspace(0,100,100)\n", - "sys_ssm = get_SSM(sys, timepoints_ssm)\n", - "Ss = sys_ssm.compute_SSM() # len(timepoints) x len(params) x len(states)\n", - "out_Ss = []\n", - "for i in range(len(params)):\n", - " out_Ss.append((np.array(C)@(Ss[:,i,:].T)))\n", - "out_Ss = np.reshape(np.array(out_Ss), (len(timepoints_ssm), len(params), nouts))" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEZCAYAAABsPmXUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAxXUlEQVR4nO3deZwkRZ338c+3e3oO5uQSGQYZFBABF1YQwVVhhRV0VRDXXbxARGd1WcVrFeR5HsRdFI9VURfXcVHAAwQPRHZFEAUvYBhXkFtHDhkZEJBj7pnu/j1/RFRXTk1Vd1Z3VXdXzfc9r3xNVkRkZuTRUVGRkZGKCMzMrLv0THQGzMys9Vy4m5l1IRfuZmZdyIW7mVkXcuFuZtaFXLibmXWhSV+4S1ol6enDxN8m6dAS63m9pCtbmbdhtvVXkn6X8370eGyzVSS9SdJAzvuzSi7zY0nrJP18jNse9hxJOlTS8rFsw6okXSPpLXn+TWM9fza5NFW4S3qBpF9KekLSnyX9QtJz25U5gIiYFRF35+2fJ+nfauL3johrSqzn6xHxkspnSSFpt5ZnOPkw8Pmc90tbueJW57vB+q7Leb+jkO7dkh7M5/7LkqZV4iLixcDbxpqXcT5HE65YuDaIX5iPwZTxzFc32ZK/tEoX7pLmAJcDnwO2AXYCzgDWtydrHW0X4LaJzkSrSDoCOAU4DFgIPJ107juGkkn/S7XbddoXVafldxMRUWoCDgAeHyHNm4E7gMeAHwK7FOKCVLv7XY7/D0A5bjfgWuAJ4BHgmzXL7QYsAjYCG4BVwPdz/L3A4cB8YC2wTWHZv8zr6wPeBPw8h/80r3d1Xtc/ALcCrygs25eX3a/Bvr4VWAb8GbgMmJ/Dfw8M5rysAqbVWfZZwDXA46QvgVcW4q4B3lL4PFK+DwWWAx/M+b0XeP0Y1jcUX1jmG8BHCp8PAx6sSbPZcoW4a4FX5/kX5G2+LH8+HLipyX19L/AnYAVwwjDX4zXAmcAv8vnYDdgTuCqft7uAvy+kfxlwO7AS+CPwvhw+0jGeBnwS+APwEPCfwIxC/FHATcCT+fo4MudrAFiX9+/zdfL/h3wMVuXpYFKF7P8A9+VjcAEwt8H+b02qkD1M+pu7HFhQ79oY4fwtzPlYBDyQj/t7C/EHAteRrucVwOeBqTV/wyeR/vbvyWFnA/fnY/Ir4IWF9B8CLgG+ls/FLcAewKl5n+8HXlJIPxc4N2/7j8C/Ab2kv7N1+TivIpdfw52vwrn+APAg8FVgu3zsHiddNz8DesqWnRM1NVO4zwEeBc4HXgpsXRN/NKmwexYwJV+Av6w5wZcD84Cn5QvuyBx3IXBavnCnAy+oWW63PH8e8G81270XODzP/xh4ayHuE8B/1rt4i+vNn9/Ppl8qRwG3NDgWLyb9kT8nXyifA35aL091lu3Lx+mDwNS8rpXAM2v/4Erm+1CgH/hUzsshpAJxtOvbJD6H3Qz8Q+Hzdnm5bYdbrhD3YeBzef6DpALuY4W4s5vc1w/n4/gyYA0112Ih/TWkP+C9SdfkXFLBcEL+/Jx8HvfO6VeQCxlSwficksf4M6Qv+G2A2cD3gY/muANJlZa/IV3fOwF71js3dfK/MB+DKYWwN5Oun6cDs4DvAF9tsPy2wKuBrXK+LgEurTk+zRTuFwIzgWeT/n4rf3f7AwflY7qQVMF7V815vCofn0oh+oacvymkL+sHgek57kOkQvmIHH8BcA+pjOgjVazuKaz/UuCLOW9PAZYA/zjM9Tzc+aqc64/lcz0D+CjpC6AvTy8kV0wn89Rc4lRwn0f6ZuvPB2iHHPcD4MRC2h7SH94uhRNcLLQvBk7J8xcAiynUKur9gTNy4f4W4Md5XqQ/5BeVLDjmkwrZOfnzt4D3NzgO5wIfL3yeRfpVsbA2T3WWfWG+kHsKYRcCH6r3B18i35WLcWbNsf2/o1zfJvE57PfkL+L8uS8vt3C45QpxhwG/yfNX5PN0ff58LXBME/u6lk0Luz8BBzXY7jXAhwuf/wH4WU2aLwKn5/k/AP9YuQbKHON8na0GnlGIO5hqDfWLwKeHyV+zhfvVwD8VPj8zX3tTGq2nkHY/4LF62x/h/FXysWch7OPAuQ3Svwv4bs15fPEIeXsM2DfPfwi4qhD3ClLNuzd/np3XOQ/YgdQ0XPyl9FrgJw2uqZHO16Gk1oHphfgPA98rXoudMDXVBhkRd0TEmyJiAbAPqUD8TI7eBThb0uOSHif9fBGpplLxYGF+DalQhFRrFrAk9355czP5KvgWcLCk+cCLSBfAz8osGBEPkH6+v1rSPNKvk683SD6f9LO4suwq0q+anRqkr132/ogYLITdV3LZRh6LiNU165s/hvXVWkX65VZRmV9ZcvnrgD0k7UAqYC4Adpa0Halm+9Mm8vJoRPQXPhevo3ruL8zvAjyvco3m6/T1wFNz/KtJvwbuk3StpIMLyzY6xtuTasa/KqzzihwOsDPpy7FVNrn28vwUUiG3CUlbSfqipPskPUk6zvMk9Y5y28VjOXSNSdpD0uX5hvuTwEdIv+4aLYuk90q6I9+gf5z0q6q4zEOF+bXAIxExUPgM6bzvQqpsrCgc/y+SavD1jHS+AB6OiHWFz58g/Vq6UtLdkk5psO5JZdQ3mCLiTlJNep8cdD/pp9C8wjQjIn5ZYl0PRsRbI2I+qeZ0ToNeEjHCeh4HrgT+HngdcGHkr96Szif9XHwNqcfIHxuke4B0UQEgaSbpJ2aj9LXL7lxzc+9phWVXky6+iqcysq1zHorre2AM66t1G7Bv4fO+wEMR8WiZhSNiDald9WTg1ojYAPwSeA/w+4h4ZBR5Kqt4/u8Hrq25RmdFxNtzPm+MiKNIBcOlpNp5RaNj/AipsNm7sM65EVH5wrkfeEaJvJWN3+Tay/noZ9PCsOK9pJr98yJiDqnCA6kiNRo712y3co19AbgT2D1v54N1tjG0L5JeSGrT/ntSk9o8UtPVaPJ1P6nmvl3h+M+JiL1rt5uNdL42WyYiVkbEeyPi6aRfEe+RdNgo8jqumukts2f+tl2QP+9M+vlzfU7yn8CpkvbO8XMlvabkul9TWS/p51mQboLUeojU1jicbwDHkWph3xgmXb11XUpqhz2ZVLscbhsnSNovdwn8CHBDRNw7Qt4AbiAVuO+X1Jf76L8CuCjH3wQck2tduwEnlsg3wBmSpuY/nJeT2lfHsr6iC4ATJe0laWvS/ZTzRlim1rXAP+f/ITUJFD/XUyZvzbic9AvijfnY90l6rqRn5WP3eklzI2Ij6UZf7TW42THOv8C+BHxa0lMAJO2UexhBasI7QdJhknpy3J4l9+9h0s35YpoLgXdL2lXSLNK1982aXzMVs0kF2eOStgFOL3WUGvu/+Tram3Tf4puF7TwJrMr79vYR1jOb9IX0MDBF0v9j01+GpUXEClKF7t8lzcnH+BmSDslJHgIWSJqa0490vjYj6eWSdpMkqtdFvfJpUmmm5r4SeB5wg6TVpEL9VlLtgIj4LukmxEX5p9mtpKaNMp6b17uK1I5/ckTcUyfducBe+efUpQ3WdRmwO6lmefMw2/wQcH5e19/nfVgLfBvYlXSjqq6IuJrU3vpt0k24ZwDHDrOt4rIbgFeSjs0jwDnAcfmXEMCnSW1+D5F+SdQ2DW2Wb1Jz12OkmtTXgbeNcX21eb6C1Mb6E9LP8ftovqC4lvRH/dMGn+sZMW/NiIiVwEtI5+oB0nGr3DgDeCNwb75+30b6FVcx3DH+AOln+/V52R+RasxExBJSQfhpUu30Wqo177OBv5P0mKTP1snvGnJvn3wMDgK+TOrB8VPSTcZ1wDsa7PJnSDcEHyH9vV4x4kEa3rV5P68GPhkRlQfO3kf6pbySVHB+s/7iQ35Iukf3W9K1tI6aZpsmHUfqnHA76Rx9C9gxx/2Y9MvzQUmVX4gNz1cDu+c0q0hNjOdEiWdrJlqlK6JluRaxR0S8YcTEk0Cu+X8t3wdpxfreSGqz3AAcHIUHmYZZ5ipSb4klETHpf642q9XHuNNIWkj6Iulr8AvBJqHO7aDfBvmn64mkGtwWKSK+SqoZNrPM37QpO2Y2Sn5iL5P0VtJPwx9ERDO9N8zMJh03y5iZdSHX3M3MupALdzOzLjRpb6guXXD0sO1FPaof3dOTwvsHhv/eKi5fWaZopOXbrbeQp4HB6rMds7baMDSvnGblqqHRd+vuV3Fd6zdWH07cZus1APz5seIzTuMnIu3X2oHqZbguqvmrPMJbPBPb9FUfHOwfTDFrCstP76l2P36A6Ztt85Ep1WP5ibW3V7c7kAY3/YtZTxsK27N37tD8eY8sBeCqefswGpXzMmtWdRDVWVtX5wc2pn3ZuK66/9sfUt2vMy5Pefn5hhVDYZ+KbYfmPzl1IwALNGMo7D3z/jw0v8MZ6Z53z67VZ9H6v/lfQ/N//E71YeNdvvUvANxyxOdK7Fljqzb2Dc0/0jN1aH7OYDpHv5pe3b/+wnND73h+ejZq2gmFx2TWrRmaHbztFgAGlj0wFDbn3KtG+2DWkI1/+l3pNuq+p+w+5u2126Qt3M3MxtUmI4J0PjfLmJkBDA6Wn4YhabqkJZJuVhor64wcvo2kq5Te0nZVftq7ssypkpZJumu4p2Wb4cLdzAyIGCw9jWA9aRTMfUkD5R2Zny4+Bbg6InYnPeV7CoCkvUhPTe9NGuv/HI1+cLchLtzNzKBlNfdIVuWPlTHgg/SOiPNz+Pmkd2CQwy+KiPV52JVlpNFSx8SFu5kZpDb3kpOkRZKWFqZFxVVJ6pV0E+l9A1dFxA2kd1+sgKEBzyrDEu/EpmPrLGdsQ4ADvqFqZpYMbCydNCIWk14w1Ch+ANhP6d0Q35U0XDerej1vxvx0qQt3MzMYsbllNCLicUnXkNrSH5K0Y0SskLQjqVYPqaZeHCt/AdWx8kfNzTJmZrTuhqqk7XONHUkzSC+Bv5M0HPnxOdnxpFf3kcOPlTRN0q6kIYaXjHV/XHM3M4NW1tx3JL2HoJdUgb44Ii6XdB1wsaQTSe/rfQ1ARNwm6WLSePT9wEmFVwqOWtsK9/xGlqNINwaC9DPjsjLjg5uZjbsWPcQUEb8B/rJO+KOkl8XXW+ZM0otZWqYtzTKSPkB6bZxIPy9uzPMXqkNeLmtmW5jBgfJTB2hXzf1E0gtoN7n9LOlTpFdenVVvodydaBHAqfP25ZiZC9uUPTOzGgPd9ZKpdt1QHQTm1wnfkep4UJuJiMURcUBEHOCC3czGVRP93DtBu2ru7wKulvQ7qp3znwbsRnrjvZnZ5NKGrpATqS2Fe0RcIWkP0iO0O5Ha25cDN7biLrCZWat1W9HUtt4ykTqDXt+u9ZuZtVSHNLeU5X7uZmbQdTdUXbibmUHHdHEsy4W7mRm4WcbMrCu5t4yZWRdyzd3MrAu55m5m1n2iiZd1dAIX7kBE9UUoA4P1XooysXpUfSmLegrzGv5lLZXliul6e+qvayIM5uM+WMhGse40kF9Q06gPQ2X5KLzIZqBwLguzQ+t9sjDgRn9Uu74N5J/kTw6uHwp7sGfd0PxV84Z7kU55vb3F418NnzJtMIdFMXBodk0+ClJ1px4dnDo0vy7WArBe1SM4fU6hsJo1L/3fU92otp03NL/dHn+qpu2rbncsBgqjmxSvtI35fL1ofeH4Tqtus2fOVIajGdPT/7OntyCXBa65m5l1Ibe5m5l1Idfczcy6kGvuZmZdyMMPmJl1ITfLmJl1IRfuZmZdyG3uZmZdyDV3M7Mu5Jq7mVkXcm8ZM7Mu1GXNMj0jJ2ktSScME7dI0lJJS7+z+t5xzJWZbfEGB8tPw5C0s6SfSLpD0m2STs7h20i6StLv8v9bF5Y5VdIySXdJOqIVuzPuhTtwRqOIiFgcEQdExAHHzFw4jlkysy1eRPlpeP3AeyPiWcBBwEmS9gJOAa6OiN2Bq/NnctyxwN7AkcA5knrHujttaZaR9JtGUcAO7dimmdmYtKhZJiJWACvy/EpJdwA7AUcBh+Zk5wPXAB/I4RdFxHrgHknLgAOB68aSj3a1ue8AHAE8VhMu4Jdt2qaZ2eg1UbhLWgQsKgQtjojFddItBP4SuAHYIRf8RMQKSU/JyXYCri8stjyHjUm7CvfLgVkRcVNthKRr2rRNM7PRa6K3TC7INyvMiyTNAr4NvCsiniyOxV+btN4mSmemgbYU7hFx4jBxr2vHNs3MxmTktvTSJPWRCvavR8R3cvBDknbMtfYdgcobUpYDOxcWXwA8MNY8TMQNVTOzyad1vWUEnAvcERGfKkRdBhyf548HvlcIP1bSNEm7ArsDS8a6O+7nbmYGrezn/lfAG4FbJN2Uwz4InAVcLOlE4A/AawAi4jZJFwO3k3ranBQRjd4uWZoLdzMzaNnwAxHxc+q3owMc1mCZM4EzW5KBzIW7mRkQ/WOuLE8qLtzNzMADh5mZdaXB1vWWmQy6onDv6RnbSZGKyzfsizquGuWpGN6jcvtdTDeld3LXTrbrWzc0v6J/BgCDDc5JxObhA4WwnXvWDs3fQ1rXk6rufxS6vg3kWtvKgeoyf+6ZVlhzcb55lS7OxfOnwnWr3jTf01dd5q5vVZ9AXz0lNRn0FI7FY73V+A35/ttAoXt039zC+udsW9loNWzbbYfmp+4+rxo+ZerIOzSMynkpXmnF+fX5YKyOavHTX7yuZ0/PK6oudcdJPxua3/O0hSndzOljyudmumzgsK4o3M3MxsyFu5lZF2rhQ0yTgQt3MzMA95YxM+tC7i1jZtaF3FvGzKz7hG+ompl1Idfczcy6kNvczcy6kHvLmJl1oS5rlmnbyzok7SnpsPyqqWL4ke3appnZqMVg+akDtKVwl/RO0ltG3gHcKumoQvRHhllukaSlkpZ+Z/W97ciamVl9g1F+6gDtapZ5K7B/RKzKb//+lqSFEXE2w4zMVXzp7NIFR3fGETSzruCukOX0RsQqgIi4V9KhpAJ+FybLsItmZkX93VW4t6vN/UFJ+1U+5IL+5cB2wLPbtE0zs9Hrsjb3dtXcjyO96HVIRPQDx0n6Ypu2aWY2eh3Sll5WWwr3iFg+TNwv2rFNM7OxCBfuZmZdyIW7mVkXcm8ZM7Mu1GW9ZVy4m5mx6QvTu0Hbhh8wM+soLXxCVdKXJf1J0q2FsG0kXSXpd/n/rQtxp0paJukuSUe0YndcuJuZQauHHzgPqB1H6xTg6ojYHbg6f0bSXsCxwN55mXMk9Y51d7a4ZpkeTe6fXvXyp0JYMV4jfDVLlXTVZXqptis++ujMUeayNSq5Giw8tDwwWN2pgRzeqCV0sOZ/ABXWtbGwrsGeFL6S+sO6fm+rfQB4w8a7h8Ke6FlbTdAzrUEuyqmcw+K5UG/hvEytbKe6zKqNfUPzq3vX5+jq/j1RSNsfab8GqK5zyrzCn/fUGXn9hYXmzBua7Zn/lKH537yo4fBPTRko5HWw8Fz6xhy+iuK5rtKsrdJMf/VRmblz11XjZ6R9iWlTaaVWdoWMiJ/moVeKjgIOzfPnA9cAH8jhF0XEeuAeScuAA4HrxpIH19zNzGA8Bg7bISJWAOT/K9+oOwH3F9Itz2FjssXV3M3M6on+8oW2pEXAokLQ4jzw4WjUG29rzD8jXLibmUFTNfLiCLZNeEjSjhGxQtKOwJ9y+HJg50K6BcADTa57M26WMTODdPOm7DQ6lwHH5/njSe+8qIQfK2mapF2B3YElo95K5pq7mRmtvaEq6ULSzdPtJC0HTgfOAi6WdCLwB+A1ABFxm6SLgdtJAy6eFBFjfqGrC3czMxhLjXwzEfHaBlGHNUh/JnBm63Lgwt3MDGjuhmoncOFuZkbHvIOjNBfuZmbQ0maZyaBUbxlJz5A0Lc8fKumdkua1NWdmZuOoy96yV7or5LeBAUm7AecCuwLfGG4BSQdKem6e30vSeyS9bEy5NTNrl/Z3hRxXZQv3wfwO1FcBn4mIdwM7Nkos6XTgs8AXJH0U+DwwCzhF0mnDLLdI0lJJS7+z+t6y+2BmNmbdVnMv2+a+UdJrSR3vX5HD+oZJ/3fAfsA04EFgQUQ8KekTwA006PJTfOpr6YKju+vWtZlNaoP9I6fpJGVr7icABwNnRsQ9+Smqrw2Tvj8iBiJiDfD7iHgSICLW0jE/asxsixIqP3WAEWvueVzhD0bEGyphEXEP6WmrRjZI2ioX7vsX1jUXF+5mNgl1SnNLWSMW7hExIGl7SVMjYkPJ9b4oj01MxCaHrI/q2ApmZpNGDHZGjbyssm3u9wK/kHQZsLoSGBGfqpe4UrDXCX8EeKTJPJqZtd0WV3PPHshTDzC7fdkxM5sYgwNbYM09Is4AkDQzIlaPlN7MrNN0W7NM2SdUD5Z0O3BH/ryvpHPamjMzs3EUUX7qBGW7Qn4GOAJ4FCAibgZe1KY8mZmNuxhU6akTlB44LCLulzbZqTEPJm9mNll0SqFdVtnC/X5JzwdC0lTgneQmGjOzbtApzS1llS3c3wacDexEepnrlcA/tStTtqnenupV9/iTM4bmt9l6zWZpVafyUQxT7+S+ggcKT//119mZKMRHfml8FF4eP7BJ2t5C2mQl1WfMi79EH4xpAKzeuHYobM2U6dWVjfFtwz2KvM1q2B+XzRuaX/icxzfbzkpV/zzX1OnH8Hjhujhl3XYAfL23+ihKz9xpQ/PpWUSgtzBqyLztqvHbPVFY88ONdqOUwXyOBgrnZbAwvzHv48bCuXx1/6pqXmblfBX6Js7cptC7emrer77Wjlg+ONBdr5Que3SeGRGvLwZI+ivgF63PkpnZ+Ou2fu5lv6o+VzLMzKwjDYZKT51g2Jq7pIOB5wPbS3pPIWoO0Ft/KTOzzhMdUmiXNVKzzFTSOOxT2PTJ1CdJw/qamXWFLaq3TERcC1wr6byIuM9PqJpZt+q23jJl29zn+wlVM+tmAwM9padO4CdUzcxIbe5lp07gJ1TNzNhym2U2eUJV0vvwE6pm1kVa2RVS0pGS7pK0TNIp45D9zZQt3N8GnET1CdX98mczs67QqmaZ/GrS/wBeCuwFvFbSXuOwC5soO577I8DrR0w4DEkXRMRxY1mHmVm7DLSuK+SBwLKIuBtA0kXAUcDtrdpAGaUKd0m7Au8AFhaXiYhXNkh/WW0Q8NeS5o2w3CJgEcCp8/blmJkLy2TPzGzMmrlRWiyrssURsTjP7wTcX4hbDjxvzBlsUtkbqpcC5wLfB8qMwLCA9C31X6QxmwQcAPz7cAvlg7MYYOmCo7vs9oaZTWbNDCtQLKvqqLeicS/Pyhbu6yLis02s9wDgZOA04F8i4iZJa/NDUWZmk04LS9/lwM6FzwtI76AeV2UL97MlnU4a6ndo7M2I+N96iSNiEPi0pEvy/w81sS0zs3HXwgHBbgR2z83ZfwSOBV7XqpWXVbbAfTbwRuDFVJtlIn9uKCKWA6+R9Lek8WjMzCalVj2cFBH9kv4Z+CFpgMUvR8RtLVl5E8oW7q8Cnh4RG0ZMWUdE/Dfw36NZ1sxsPAzUbSofnYj4H+B/WrbCUShbuN8MzAP+1L6smJlNnMEu68JRtnDfAbhT0o1s2uZet0ujmVmnGWxhzX0yKFu4n97WXJiZTbDYEgt3d2E0s27XZa9QLTe2jKSDJN0oaZWkDZIGJLn3i5l1jUClp05Qtlnm86S+mpeQHlA6Dti9XZkyMxtv/ROdgRZrZjz3ZZJ6I2IA+IqkX7YxX00p9k9t4eA/E6pH1Vv3Ksz39hTCe4a/vb9+Y3qHeV9fdej9kZYZT5WHRoo1oYHCuazMNvNzudidrbine/asAuB7DQbtfrAv/Yhd9eS6obA5Uws9f8f4CF7lVQjF4983pbpnmpoSaEo1/0/2VN9Bv3Zw42brXKXq8n+akjIYVPPcM3fmZsvc8uJPDs3v8903Ds3HvG1H3omSKntY/FMcKMxv1ObxM2dsKH7ICar7N3XrwnmbNg0ATaken1bolBp5WWUv2TWSpgI3Sfo4sALY/MoxM+tQXVIvHFJ2PPc35rT/DKwmjZvw6nZlysxsvA2i0lMnGLHmngeePzMi3gCsA85oe67MzMbZ5GmwbI0RC/eIGJC0vaSpox1+wMxssutXZ9TIyyrb5n4v8Iv8Eo7VlcCI+FQ7MmVmNt62uJp79kCeeoDZ7cuOmdnE6LaHmMo+oep2djPrat3WW6bsO1S3B94P7A1Mr4RHxLDjuZuZdYpO6QVTVtmukF8H7gR2JfWWuZf0thEzs64QTUydoGzhvm1EnAtsjIhrI+LNwEFtzJeZ2bjqV/mpE5S9oVp59nlFfmXeA6SXvpYi6QXAgcCtEXFlc1k0M2u/TqmRl1W25v5vkuYC7wXeB/wX8O5GiSUtKcy/lTTw2GzgdEmnDLPcIklLJS39zup7S2bNzGzsBlV+6gTD1twlTQfeBuwG7AScGxF/XWK9fYX5RcDfRMTDkj4JXA+cVW+hiFgMLAZYuuDobvsiNbNJbEvrCnk+qUnmZ8BLgb2Ak0ust0fS1qRfBoqIhwEiYrWkbhtZ08y6wJZWuO8VEc8GkHQusGSE9BVzgV8BAkLSUyPiQUmzcpiZ2aQSXVYyjVS4Dw0iHRH9Kjn2QkQsbBA1CLyq1ErMzMZRtzUpjFS471t4nZ6AGfmzgIiIOc1sLCLWAPc0n00zs/bqtpt8wxbuEdHaV52YmU1SndILpqyyXSHNzLraYBPTWEh6jaTbJA1KOqAm7lRJyyTdJemIQvj+km7JcZ9ViTZyF+5mZoxf4Q7cChwD/LQYKGkv4FjSGF5HAufklyUBfIHUrXz3PB050kZcuJuZkV7iXXYai4i4IyLuqhN1FHBRRKyPiHuAZcCBknYE5kTEdRERwAXA0SNtx4W7mRnN1dyLT9PnaVELsrATcH/h8/IctlOerw0fVtmxZczMulozvWWKT9PXI+lHwFPrRJ0WEd9rtFiDbDUKH5YLdzMzYLCFnSEj4vBRLLYc2LnweQFpkMblbDpQYyV8WF1RuEvFk9Jl/ZmAnsL+Tektfzunspx6qstveqwmVtR5JHCgELZzz1oA7mHGUNhgIX4w70rxiAwUzv9AIXzVxjTc0SqtqpuXP+VjtL5/6Lk91g+07n3wqnMu+vqqOdTU1EKqKdX8ryo0mq4dTPnqU7V38urCnj/au3mvZc2ZtVnYttuursbP2mZoPmY/NvJOlFQ5R8WXX+xVOO5LNCvHV82YWT3umrl5vnu3qQ5Xdd8pPwfgaYvmtyS/FZNg+IHLgG9I+hQwn3TjdElEDEhaKekg4AbgOOBzI63Mbe5mZozfyzokvUrScuBg4L8l/RAgIm4DLgZuB64AToqISg3g7aTReJcBvwd+MNJ2uqLmbmY2VuP1Eo6I+C7w3QZxZwJn1glfCuzTzHZcuJuZ0do298nAhbuZGVvY2DJmZluKSXBDtaVcuJuZ4WYZM7OuNDByko7iwt3MDNfczcy6UncV7W16iEnS8yTNyfMzJJ0h6fuSPiZpbju2aWY2FuM45O+4aNcTql8G1uT5s0kvzP5YDvtKm7ZpZjZq0cS/TtCuZpmeiKi8b/aAiHhOnv+5pJsaLZSHzVwEcOq8fTlm5sI2Zc/MbFOdUiMvq10191slnZDnb668SkrSHsDGRgtFxOKIOCAiDnDBbmbjaYAoPXWCdhXubwEOkfR7YC/gOkl3A1/KcWZmk8ogUXrqBG1plomIJ4A3SZoNPD1vZ3lEPNSO7ZmZjVW3Ncu0tStkRKwEbm7nNszMWqFTbpSW5X7uZma45m5m1pVcczcz60L94cLdzKzrdFfR7sLdzAzwwGFmZl3Jbe5mZl3IvWUmWI9a8+3a0zO5v6VVeBO7CnntLVyCjz46s85yxf3SZmGtOn6tMFjzP4Co7vjGwfQA9WDP8K+l365v3dD8iv4ZhfVXl1uZL/UnB9cPhUXhBtojSkMhfXubQ4bC/nHdr0fYg/J6e9NeFs/rlCnV10P0TO/NM9UEqwrPjw8MpuX76B0KW1N4vcRKpf1710DhaM6ZNTQbkdLOnr9hKExbVQdo1YzZpfdlJBFpH4pX2oaBar439qX/+wvx0+cURiXZKl/XUd2XntnTh+bnPmV1Dhz+umjWQJcV7x1XuJuZtUN3Fe0u3M3MgE1/yXUDF+5mZnRfb5l2jQppZtZRxutNTJI+IelOSb+R9F1J8wpxp0paJukuSUcUwveXdEuO+6ykEW84uHA3M2Nc38R0FbBPRPwF8FvgVABJewHHAnsDRwLnSKrcif4C6UVGu+fpyJE24sLdzAwYiMHS01hExJWFN9VdDyzI80cBF0XE+oi4B1gGHChpR2BORFwX6cbABcDRI23Hbe5mZkxYb5k3A9/M8zuRCvuK5TlsY56vDR+WC3czM5p7QrX4vudscUQsLsT/CHhqnUVPi4jv5TSnkbr7f72yWN1sNQ4flgt3MzOa6y2TC/LFw8QfPtzyko4HXg4cFtU+mMuBnQvJFgAP5PAFdcKH5TZ3MzNSP/ey01hIOhL4APDKiFhTiLoMOFbSNEm7km6cLomIFcBKSQflXjLHAd8baTttqblLeifw3Yi4vx3rNzNrtXHs5/55YBpwVe7ReH1EvC0ibpN0MXA7qbnmpKiMGwFvB84DZgA/yNOw2tUs86/AKZJ+D1wIXBIRD4+0ULEd69R5+3LMzIVtyp6Z2abG2gumrIjYbZi4M4Ez64QvBfZpZjvtapa5m9Qu9K/A/sDtkq6QdLykhiMURcTiiDggIg5wwW5m4ymamDpBuwr3iIjB3J/zRGA+cA6p4/3dbdqmmdmoDRKlp07QrmaZTbruRMRG0s2CyyTNqL+ImdnE6ZRCu6x2Fe7/0CgiIta2aZtmZqPmUSFLiIjftmO9Zmbt4pd1mJl1Idfczcy6kNvczcy6kGvuZmZdyDV3M7Mu1IKXcEwqLtzNzBi/4QfGiwv3SabemxGLYerdvHbRo/o1DuXwYrwmeBzQiOrORH7WLQrPvA1skrY3xxfCCvODebmBwepODRTWVfxTXdWT1rVqYF0hvrq2P8cGAJZNnTkU1r+mmJuxqZxD9VS3OWVqNYfLr5kKwM5/U93myuJ5y/tVzPO6qKZdpbSumTM2VJeZPWezfEydP7UaP3NeNWL6zM3SjtZgzf8AGwrnaGP+v79wXffNLpzZmTnfG6rnqmd29dnHaduvzIGtvZgH3eZuZtZ93CxjZtaFXHM3M+tCrrmbmXUh19zNzLrQYLTuBvpk4MLdzAw/xGRm1pU8/ICZWRdyzd3MrAu55m5m1oU8/EAJkqYCxwIPRMSPJL0OeD5wB7A4v1PVzGzScM29nK/kdW8l6XhgFvAd4DDgQOD4egtJWgQsAjh13r4cM3Nhm7JnZrYpt7mX8+yI+AtJU4A/AvMjYkDS14CbGy0UEYuBxQBLFxzdXUfazCa1bqu5t2uMwJ7cNDMb2AqYm8OnAX1t2qaZ2agNRpSexkLSv0r6jaSbJF0paX4h7lRJyyTdJemIQvj+km7JcZ+V6o0fu6l2Fe7nAncCNwGnAZdI+hJwI3BRm7ZpZjZqEVF6GqNPRMRfRMR+wOXA/wOQtBfpXuXewJHAOZJ68zJfIDVZ756nI0faSFuaZSLi05K+mecfkHQBcDjwpYhY0o5tmpmNxXj1lomIJwsfZ1J9TcFRwEURsR64R9Iy4EBJ9wJzIuI6gFyeHg38YLjttK0rZEQ8UJh/HPhWu7ZlZjZW4zlwmKQzgeOAJ4C/zsE7AdcXki3PYRvzfG34sCb4vTxmZpNDNPFP0iJJSwvTouK6JP1I0q11pqMAIuK0iNgZ+Drwz5XF6marcfiw/BCTmRnN1dyLPfsaxB9eclXfAP4bOJ1UI9+5ELcAeCCHL6gTPizX3M3MGL8bqpJ2L3x8JanzCcBlwLGSpknalXTjdElErABWSjoo95I5DvjeSNtxzd3MjHF9E9NZkp5Jeof4fcDbACLiNkkXA7cD/cBJEUODzL8dOA+YQbqROuzNVHDhbmYGwODguPWWefUwcWcCZ9YJXwrs08x2XLibmVHiDmWnaaadaSImYFEr07Ur7URvv5PyOtHb76S8TvT2Oy2vngrHbaIzUOLELm1lunalnejtd1JeJ3r7nZTXid5+p+XVU3Vybxkzsy7kwt3MrAt1QuHe8EGBUaZrV9qJ3n4zabf07TeTdkvffjNpJ3r7VqDcpmVmZl2kE2ruZmbWJBfuZmZdyIW7mVkXmlSFu6Q9JX0gv0bq7Dz/rJLLXtAgfKqk4yQdnj+/TtLnJZ0kadK/8k/SUyZ4+9u2YZ1dt095vV23X924T1uKSVO4S/oA6RV8ApaQXskn4EJJp9Skvaxm+j5wTOVzzaq/AvwtcLKkrwKvAW4Angv8V4v3YbMLUdJcSWdJulPSo3m6I4fNq0m7Tc20LbBE0taStimkO0DSTyR9TdLOkq6S9ISkGyX9Zc0650j6qKSvSnpdTdw5NZ/PkrRdYRt3AzdIuk/SIe3cp3btV9l98rnqrHNlJUz0U1SFp9B+C/TVCZ8K/K4m7H+BrwGHAofk/1fk+UNq0v4m/z8FeAjozZ9ViSuknQN8FPgq8LqauHNqPp8FbJfnDwDuBpaRRnk7pJDuh8AHgKcWwp6aw66qWecgcE/NtDH/f3ch3RLgpcBrgfuBv8vhhwHX1azz2zmvR5OGFP02MK1yHGvS3lKY/wnw3Dy/B4WnBNuxT+3ar7L75HPVWefK08jThGegcDLvBHapE74LcFdNWA/wbuAqYL8cdneD9d5K+oLYGlgJbJPDpwN31KRtxx/XXfXyVS8OeB9wBfDsQtg9dZb7dWH+D43i8uebaj6fBvwC2LbOPt0JTMnz1w+zvy3fp3btV9l98rnqrHPlaeRpMo0K+S7gakm/I9UEAJ4G7Eb1NVQARMQg8GlJl+T/H6LxCJfnki6aXtJFdUn+uXcQqRmo6BlRHY7zUkmnAT+W9Mo66+2TNCUi+oEZEXFjzttvJU0rpLtP0vuB8yPiIQBJOwBvKuxnZb8+KemivE/3k97OEnW2vU7SS4C5QEg6OiIuzT9dB2rSTpPUk48ZEXGmpOXAT4FZNWn/A/gfSWcBV0j6DPAdUm3spjbvU7v2q+w+tWu/fK7ac65sJBP97VKcSDXyg4BXA3+X53tLLPe3wEeGiZ8PzM/z8/K6D6yT7g6gpybseOA24L6a8HcAVwIvBj4EfAZ4EXAG8NVCuq2Bj5G+YB4D/py38zHyr4gGeX4F6WW5D9aJ25f0c/sHwJ7A2cDjOZ/Pr0n7ceDwOus4kprmrhx+KPBN4NfALcD/AIsoNJnV2afH8j59fIR9emWjfcrx+9XZr8fyfv3VaPerzD6N87ka8z7l8L8exbkqu08jnau27FfhXP1vYZ/+sfZceRp5mvAMTKaphQXhlJp0ewKHA7Nq11tnnXuSaiqzSG9d2adeWuBZlXQl1nkg1WajvYD3AC9rcAyKafcG3tsobc1yXx0pTU43A7ikiXNSdr0vyPv1khHSvTDv02bpgOcBc/P8VsCHgctzQTi3Tto5hbQfB35Um7ZmnTNGWOc7gZ1L7m+ptKQmyeMr1zXwelIN+aTaAjOnPa6Q9o3Aj4dJW2q9Of4ZpGafs4F/J719aG6DdP8CfBb4VKN0nkaePPxASZJOiIivNJtW0jtJF/wdpJrpyRHxvRz3vxHxnMJypdLmdP9Eqo2NtM7TSTe+ppDuUTwPuIb0ZfPDSG9+aZT2QODa2rTavEcSpF8wPwaIiKFmrDamXRIRB+b5t+bj9l3gJcD3I+KsOunektNdWpsux98G7BsR/ZIWA6tJ910Oy+HHNJu2yXU+keN/D1xI+hJ8uM4xqU37jZz2kTrpvk46nzOAJ4CZ+TgdRhp+5Pg6abci/RJsVdp3Ai8nNcO8jNTE8hjwKuCfIuKanO5k0q/wYdNZSRP97dIpEzU3jcqmJdXoZ+X5hcBSUmEMm994KpV2FOvsJf0RPkm1tjmDzXsLlUpLc72Vmkn762bSFuZvBLbP8zPZ9IZiqXQ57I5ivmvibhpN2ibX+WtS0+RLSPeKHibd4DwemD2atDTXW6xdaW8pxG8FXJPnn8bm1/WI6TyVmyZNP/fJQNJvGky3ADuMMm1vRKwCiIh7SQXWSyV9ivSHwCjSNrPO/ogYiIg1wO8j4sm83FpS17fRpD0A+BXpBvUTkWpUayPi2oi4tmadzaTdv4m0Pbn/9bakmuLDOa+rSS8XbjYdwK2STsjzN0s6AEDSHqQugaNJ28w6IyIGI+LKiDiRdK/oHFKz4N2jTNsjaSowm1Rgzs3h04Dah/jalRaqHR6m5WWIiD/USVs2nY1kor9dJtNEqoHsR+p+WZwWAg+MJi2pSWG/mmWnABcAAzXhpdI2uc4bgK3yfE8hfC6b1yRLp83hC4BLgM8zwi+bVqcF7iUVYvfk/5+aw2exac25VLrCfp5Hauq4gVT43k1qmtp3NGmbXOevhzkmM0aTltRl+G7S8xfvBK4GvkSqJZ9es1y70p4M/IY0dO+dwAk5fHvgp82m81RumvAMTKaJ9PP2BQ3ivjGatLmgemqDdLW9CkqlbXKd0xqk245Cf+Zm09bED9tbaTzSFpbZCth1LOlINcZ9Sb8kdhhhPaXSlkkH7NHEfjaTtlRvsTan3TvH7zlCXkul8zTy5BuqZmZdyG3uZmZdyIW7mVkXcuFuE0rStpJuytODkv6Y51epZiREMyvPbe42aUj6ELAqIj450Xkx63SuudukJOlQSZfn+Q9JOl/SlZLulXSMpI9LukXSFcovXZG0v6RrJf1K0g8l7Tixe2E2cVy4W6d4Bqlr5FGkp1h/EhHPBtYCf5sL+M+RxhXfH/gycGajlZl1u8k05K/ZcH4QERvzE8C9pEftIT00sxB4JrAPcJUkcpoVE5BPs0nBhbt1ivWQxvKXtDGqN4sGSdexgNsi4uCJyqDZZOJmGesWdwHbSzoYQFKfpL0nOE9mE8aFu3WFiNhAemz9Y5JuJg0X+/wJzZTZBHJXSDOzLuSau5lZF3LhbmbWhVy4m5l1IRfuZmZdyIW7mVkXcuFuZtaFXLibmXUhF+5mZl3o/wOoFXryCeXcSgAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "try:\n", - " import seaborn as sn\n", - " import matplotlib.pyplot as plt\n", - " for j in range(nouts):\n", - " sn.heatmap(out_Ss[:,:,j].T)\n", - " plt.xlabel('Time')\n", - " plt.ylabel('Parameters')\n", - " plt.title('Sensitivity of output[{0}] with respect to all parameters'.format(j))\n", - " plt.show()\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful time-scale separation solution obtained with states: [x2, x3]!\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "Successful time-scale separation solution obtained with states: [x0, x2, x3]!\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "Successful time-scale separation solution obtained with states: [x1, x2, x3]!\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - } - ], - "source": [ - "from autoreduce.utils import get_reducible\n", - "timepoints_ssm = np.linspace(0,100,10)\n", - "timepoints_ode = np.linspace(0, 100, 100)\n", - "sys_reduce = get_reducible(sys, timepoints_ode, timepoints_ssm)\n", - "results = sys_reduce.reduce_simple()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle \\frac{K b_{l}^{2} \\beta_{l} - d_{l} del_{l} x_{3} \\left(b_{l}^{2} + x_{2}^{2}\\right)}{d_{l} \\left(b_{l}^{2} + x_{2}^{2}\\right)}$" - ], - "text/plain": [ - "(K*b_l**2*beta_l - d_l*del_l*x3*(b_l**2 + x2**2))/(d_l*(b_l**2 + x2**2))" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "list(results.keys())[0].f[1]" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful time-scale separation solution obtained with states: [x0, x1]!\n" - ] - } - ], - "source": [ - "reduced_system, collapsed_system = sys_reduce.solve_timescale_separation([x0,x1], fast_states = [x3, x2])" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle \\frac{K b_{l}^{2}}{b_{l}^{2} + \\frac{\\beta_{t}^{2} x_{0}^{2}}{del_{t}^{2}}} - d_{l} x_{1}$" - ], - "text/plain": [ - "K*b_l**2/(b_l**2 + beta_t**2*x0**2/del_t**2) - d_l*x1" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "reduced_system.f[1]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.9.12 ('base')", - "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.9.12" - }, - "vscode": { - "interpreter": { - "hash": "086edbbad6d007afd932f3998127bea1c36f47a35b43b79d0f508f10f9e57cc3" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/IJRNC_examples/two_member_population_control.ipynb b/IJRNC_examples/two_member_population_control.ipynb deleted file mode 100644 index 726d712..0000000 --- a/IJRNC_examples/two_member_population_control.ipynb +++ /dev/null @@ -1,283 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from autoreduce import *\n", - "import numpy as np\n", - "from sympy import symbols" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "n = 8 # Number of states \n", - "x_init = np.zeros(n)\n", - "x_init[6] = 100\n", - "x_init[7] = 500\n", - "timepoints_ode = np.linspace(0, 40, 100)\n", - "error_tol = 1000\n", - "nstates_tol = 5\n", - "# x = 0, T1, 1, A1, 2, S1, 3, S2, 4, T2, 5, A2, 6, C1, 7, C2\n", - "# P = 0, beta_S1, 1, l_S1, 2, K_S1, 3, kb, 4, beta_S2, 5, l_S2, 6,\n", - "# K_S2, 7, beta_lac, 8, l_lac, 9, K_lac, 10, beta_tet, 11, l_tet, 12,\n", - "# K_tet, 13, kc, 14, C_max, 15, dc, 16, 17, I, 18, atc, 20,K_tox\n", - "P = np.zeros(22)\n", - "P[0] = 6\n", - "P[1] = 2e-3\n", - "P[2] = 430\n", - "P[3] = 30\n", - "P[4] = 6\n", - "P[5] = 2e-3\n", - "P[6] = 190\n", - "P[7] = 19.8e-3\n", - "P[8] = 1.5e-3\n", - "P[9] = 1.4e5\n", - "P[10] = 14.4e-3\n", - "P[11] = 2.1e-4\n", - "P[12] = 13\n", - "P[13] = 0.6\n", - "P[14] = 5500\n", - "P[15] = 0.8\n", - "P[16] = 1e6 #17 -> 16\n", - "P[17] = 324 # 19 -> 17\n", - "P[18] = 1 #20 -> 18\n", - "P[19] = 0.1 #21 -> 19\n", - "P[20] = 1.5 #22 -> 20\n", - "P[21] = 0.5 #23 ->21\n", - "params_values = P.copy()\n", - "\n", - "params = P\n", - "n = 8\n", - "x, f, P = system.load_ODE_model(n, len(params_values))\n", - "\n", - "beta_S1 = symbols('beta_S1')\n", - "l_S1 = symbols('l_S1')\n", - "K_S1 = symbols('K_S1')\n", - "kb = symbols('kb')\n", - "beta_S2 = symbols('beta_S2')\n", - "l_S2 = symbols('l_S2')\n", - "K_S2 = symbols('K_S2')\n", - "beta_lac = symbols('beta_lac')\n", - "l_lac = symbols('l_lac')\n", - "K_lac = symbols('K_lac')\n", - "beta_tet = symbols('beta_tet')\n", - "l_tet = symbols('l_tet')\n", - "K_tet = symbols('K_tet')\n", - "kc = symbols('kc')\n", - "C_max = symbols('C_max')\n", - "dc = symbols('dc')\n", - "I = symbols('I')\n", - "atc = symbols('atc')\n", - "K_tox = symbols('K_tox')\n", - "d = symbols('d')\n", - "d_T = symbols('d_T')\n", - "d_S = symbols('d_S')\n", - "P = [beta_S1, l_S1, K_S1, kb, beta_S2, l_S2, K_S2, beta_lac, l_lac, \n", - " K_lac, beta_tet, l_tet, K_tet, kc, C_max, dc, I,\n", - " atc, K_tox, d, d_T, d_S]\n", - "y0 = symbols('y0')\n", - "y1 = symbols('y1')\n", - "\n", - "# T1 and A1\n", - "f[0] = P[0]*(P[1] + x[2]**2/(P[2]+x[2]**2)) - P[3]*x[0]*x[1] - P[20] * x[0]\n", - "f[1] = 5*P[4]*(P[5] + x[3]**2/(P[6]+x[3]**2)) - P[20] * x[1] - P[3]*x[0]*x[1]\n", - "\n", - "\n", - "# f[0] = P[0]*(x[2]**2/(P[2]+x[2]**2)) - P[3]*x[0]*x[1]\n", - "# f[1] = P[4]*(x[3]**2/(P[6]+x[3]**2)) - P[3]*x[0]*x[1]\n", - "\n", - "# S1 and S2 (scaled with cell count)\n", - "f[2] = P[7]*(P[8] + P[16]**2/(P[9]+P[16]**2))*x[6] - P[21] * x[2]\n", - "f[3] = P[10]*(P[11] + P[17]**2/(P[12]+P[17]**2))*x[7] - P[21] * x[3]\n", - "\n", - "# f[2] = P[7]*(P[16]**2/(P[9]+P[16]**2))*x[6] - P[21] * x[2]\n", - "# f[3] = P[10]*(P[17]**2/(P[12]+P[17]**2))*x[7] - P[21] * x[3]\n", - "\n", - "# T2 and A2\n", - "f[4] = P[4]*(P[5] + x[3]**2/(P[6]+x[3]**2)) - P[3]*x[4]*x[5] - P[20] * x[4]\n", - "f[5] = 5*P[0]*(P[1] + x[2]**2/(P[2]+x[2]**2)) - P[20] * x[5]-P[3]*x[4]*x[5]\n", - "\n", - "# f[4] = P[4]*(x[3]**2/(P[6]+x[3]**2)) - P[3]*x[4]*x[5] - P[20] * x[4]\n", - "# f[5] = P[0]*(x[2]**2/(P[2]+x[2]**2)) - P[20] * x[5]-P[3]*x[4]*x[5]\n", - "\n", - "# Cell 1 and Cell 2\n", - "f[6] = P[13]*(1 - (x[6] + x[7])/P[14])*x[6] - P[15]*x[6]*(x[0]/(P[18] + x[0])) - P[19] * x[6]\n", - "f[7] = P[13]*(1 - (x[6] + x[7])/P[14])*x[7] - P[15]*x[7]*(x[4]/(P[18] + x[4])) - P[19] * x[7]\n", - "\n", - "C = np.zeros((2,len(x)), dtype=int)\n", - "C[0][6] = 1\n", - "C[1][7] = 1\n", - "C = C.tolist()\n", - "\n", - "sys = System(x, f, params = P, params_values = params_values, C = C, x_init = x_init)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": "
", - "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "from autoreduce.utils import get_ODE\n", - "sys_ode = get_ODE(sys, timepoints_ode)\n", - "sol = sys_ode.solve_system().T\n", - "try:\n", - " import matplotlib.pyplot as plt\n", - " plt.plot(timepoints_ode, np.transpose(np.array(C)@sol))\n", - " plt.xlabel('Time')\n", - " plt.ylabel('[Product]')\n", - " plt.show()\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "from autoreduce.utils import get_SSM\n", - "timepoints_ssm = np.linspace(0,100,5)\n", - "sys_ssm = get_SSM(sys, timepoints_ssm)\n", - "# Uncomment to run:\n", - "# Ss = sys_ssm.compute_SSM() # len(timepoints) x len(params) x len(states)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "# nouts = 2\n", - "# out_Ss = []\n", - "# for i in range(len(params)):\n", - "# out_Ss.append((np.array(C)@(Ss[:,i,:].T)))\n", - "# out_Ss = np.reshape(np.array(out_Ss), (len(timepoints_ssm), len(params), nouts))" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# try:\n", - " # import seaborn as sn\n", - " # for j in range(nouts):\n", - " # sn.heatmap(out_Ss[:,:,j].T)\n", - " # plt.xlabel('Time')\n", - " # plt.ylabel('Parameters')\n", - " # plt.title('Sensitivity of output[{0}] with respect to all parameters'.format(j))\n", - " # plt.show()\n", - "# except:\n", - "# print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from autoreduce.utils import get_reducible\n", - "timepoints_ssm = np.linspace(0,100,10)\n", - "timepoints_ode = np.linspace(0, 100, 100)\n", - "sys_reduce = get_reducible(sys, timepoints_ode, timepoints_ssm)\n", - "sys_reduce.nstates_tol = 4\n", - "sys_reduce.nstates_tol_min = 2\n", - "# results = sys_reduce.reduce_simple(skip_numerical_computations = True)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Successful time-scale separation solution obtained with states: [x1, x5, x6, x7]!\n" - ] - } - ], - "source": [ - "reduced_sys, collapsed_sys = sys_reduce.solve_timescale_separation([x[1], x[5], x[6], x[7]], debug = False)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.4-final" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} \ No newline at end of file diff --git a/README.md b/README.md index 7e56b34..f78590b 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,10 @@ -# AutoReduce: An automated model reduction tool +# AutoReduce: An Automated Model Reduction Toolbox -Python toolbox to automatically obtain reduced model expressions using time-scale separation, conservation laws, and other assumptions. +![AutoReduce banner](graphics/autoreduce_banner.png) + +Python toolbox to obtain reduced model expressions using time-scale +separation, conservation laws, sensitivity analysis, and projection-based +interfaces to established reduction libraries. [![Build](https://github.com/ayush9pandey/autoreduce/actions/workflows/build.yml/badge.svg)](https://github.com/ayush9pandey/autoreduce/actions/workflows/build.yml) [![Lint](https://github.com/ayush9pandey/autoreduce/actions/workflows/lint.yml/badge.svg)](https://github.com/ayush9pandey/autoreduce/actions/workflows/lint.yml) @@ -10,41 +14,67 @@ Python toolbox to automatically obtain reduced model expressions using time-scal ## Overview -AutoReduce is a Python package for automated model reduction of SBML models. It provides tools for: +AutoReduce is a Python package for automated model reduction of nonlinear +dynamical systems. It provides tools for: + - Automated model reduction using QSSA (Quasi-Steady State Approximation) -- Hill function approximation +- Conservation-law based reductions +- Local sensitivity analysis +- SBML import/export through python-libsbml - Integration with [BioCRNPyler](https://biocrnpyler.readthedocs.io/) for synthetic biology models -- Analysis of gene expression models +- Optional python-control and PyDMD interfaces -Refer to the [bioRxiv paper](https://www.biorxiv.org/content/10.1101/2020.02.15.950840v2.full.pdf) and [Journal of Robust and Nonlinear Control paper](https://onlinelibrary.wiley.com/doi/full/10.1002/rnc.6013) for more details. +See the [bioRxiv paper](https://doi.org/10.1101/2020.02.15.950840) +and [International Journal of Robust and Nonlinear Control paper](https://doi.org/10.1002/rnc.6013) +for the model-reduction background. ## Quick Start ```python -from autoreduce.converters import load_sbml - -# Load your SBML model -sys = load_sbml('your_sbml_file.xml', outputs=['your_output']) - -# Solve conservation laws -conservation_laws = sys.solve_conservation_laws( - conserved_sets=[ - ['species1', 'species2', 'species3'], # First conserved set - ['species4', 'species5'] # Second conserved set - ], - states_to_eliminate=['species_to_eliminate1', 'species_to_eliminate2'] +import numpy as np +from sympy import symbols + +from autoreduce import System, solve_timescale_separation + +S, C, P, k1, k2, k3, E_total = symbols("S C P k1 k2 k3 E_total") + +E = E_total - C +x = [S, C, P] +f = [ + -k1 * E * S + k2 * C, + k1 * E * S - (k2 + k3) * C, + k3 * C, +] + +system = System( + x, + f, + params_dict={k1: 1.0, k2: 0.5, k3: 0.25, E_total: 1.0}, + x_init=[10.0, 0.0, 0.0], + C=np.array([[1, 0, 0], [0, 0, 1]]), +) + +reduced_system, collapsed_system = solve_timescale_separation( + system, + [S, P], + fast_states=[C], ) +``` + +`params_dict` can be used to set, get, and update parameters: -# Solve timescale separation using QSSA -reduced_qssa_model = sys.solve_timescale_separation( - ['fast_species1', 'fast_species2'] - ) +```python +system.set_param(k1, 2.0) +system.get_param(k1) +system.set_param_dict({k2: 1.0, k3: 0.1}) ``` For more examples, check out the [documentation](https://autoreduce.readthedocs.io/en/latest/examples.html). ## Installation +Supported Python versions are 3.9 - 3.13. + Install the latest version of AutoReduce: ```bash @@ -57,12 +87,20 @@ Install with all optional dependencies: pip install autoreduce[all] ``` +Install optional integrations explicitly: + +```bash +pip install "autoreduce[bio]" +pip install "autoreduce[control]" +pip install "autoreduce[dmd]" +``` + For development installation: ```bash git clone https://github.com/ayush9pandey/autoreduce.git cd autoreduce -pip install -e ".[all]" +pip install -e ".[dev]" ``` ## Documentation @@ -71,14 +109,8 @@ Full documentation is available at [autoreduce.readthedocs.io](https://autoreduc ## Contributing -We welcome contributions! Please see our [contributing guide](https://autoreduce.readthedocs.io/en/latest/contributing.html) for details. - -## Versions - -AutoReduce versions: -- 0.3.0 (current release): Major updates including improved API and documentation -- 0.2.0 (alpha release): `pip install autoreduce==0.2.0` -- 0.1.0 (alpha release): `pip install autoreduce==0.1.0` +We welcome contributions. Developer notes and release instructions are in the +[documentation](https://autoreduce.readthedocs.io/en/latest/develop.html). ## Contact @@ -89,5 +121,3 @@ For questions, feedback, or suggestions, please contact: ## License Released under the BSD 3-Clause License (see `LICENSE`) - -Copyright (c) 2025, Ayush Pandey. All rights reserved. diff --git a/autoreduce/__init__.py b/autoreduce/__init__.py index ff3029d..f710751 100644 --- a/autoreduce/__init__.py +++ b/autoreduce/__init__.py @@ -1,6 +1,75 @@ -"""AutoReduce: Automated model reduction tools for SBML models.""" +"""AutoReduce public API and package metadata.""" -__version__ = "0.3.0" +try: + from ._version import version as __version__ +except Exception: + __version__ = "0+unknown" -from .system import System # noqa: F401 -from .converters import load_sbml, load_ODE_model # noqa: F401 +from autoreduce.reductions.abundance import solve_approximations +from autoreduce.reductions.conservation import ( + apply_conservation_laws, + find_conserved_sets, + setup_conservation_laws, + solve_conservation_laws, +) +from autoreduce.reductions.core import ( + Reduce, + ReduceUtils, + create_system, + get_error_metric, + get_robustness_metric, +) +from autoreduce.reductions.timescale import ( + explore_all_QSS_models, + reduce_with_input, + solve_timescale_separation, +) +from autoreduce.solvers.ode import ODE +from autoreduce.solvers.ssm import SSM +from autoreduce.solvers.utils import ( + get_ODE, + get_ode_solutions, + get_SSM, + solve_ode, + solve_ODE_SSM, + solve_sensitivity, + solve_ssm, +) +from autoreduce.system.system import System +from autoreduce.utils.converters import ( + load_ode_model, + load_sbml, + ode_to_sympy, + sympy_to_sbml, +) + +__all__ = [ + "ODE", + "Reduce", + "ReduceUtils", + "SSM", + "System", + "__version__", + "apply_conservation_laws", + "create_system", + "explore_all_QSS_models", + "find_conserved_sets", + "get_ODE", + "get_SSM", + "get_error_metric", + "get_ode_solutions", + "get_robustness_metric", + "load_ode_model", + "load_sbml", + "ode_to_sympy", + "reduce_with_input", + "setup_conservation_laws", + "solve_ODE_SSM", + "solve_approximations", + "solve_conservation_laws", + "solve_ode", + "solve_sensitivity", + "solve_ssm", + "solve_timescale_separation", + "sympy_to_sbml", +] diff --git a/autoreduce/model_reduction.py b/autoreduce/model_reduction.py deleted file mode 100644 index 8af1198..0000000 --- a/autoreduce/model_reduction.py +++ /dev/null @@ -1,1379 +0,0 @@ -"""Model reduction""" - -import warnings -from itertools import combinations - -from sympy import Symbol, solve, Eq # type: ignore -import sympy # type: ignore -import numpy as np # type: ignore - -from scipy.linalg import solve_lyapunov, block_diag # type: ignore -from scipy.linalg import eigvals, norm # type: ignore - -from .system import System -from autoreduce import utils - - -class Reduce(System): - """ - The class can be used to compute the various - possible reduced models for the System object - and then find out the best reduced - model choice using doi : https://doi.org/10.1101/640276 - """ - - def __init__( - self, - x, - f, - params=None, - C=None, - g=None, - h=None, - u=None, - params_values=None, - x_init=None, - timepoints_ode=None, - timepoints_ssm=None, - error_tol=None, - nstates_tol=None, - nstates_tol_min=None, - **kwargs, - ): - super().__init__( - x, f, params, C, g, h, u, params_values, x_init, **kwargs - ) - self.f_hat = [] # Should be a list of Sympy objects - if nstates_tol is None: - self.nstates_tol = self.n - 1 - else: - self.nstates_tol = nstates_tol - if nstates_tol_min is None: - self.nstates_tol_min = 1 - else: - self.nstates_tol_min = nstates_tol_min - if error_tol is None: - self.error_tol = 1e6 - else: - self.error_tol = error_tol - if timepoints_ode is None: - self.timepoints_ode = np.linspace(0, 100, 100) - else: - self.timepoints_ode = timepoints_ode - if timepoints_ssm is None: - self.timepoints_ssm = np.linspace(0, 100, 10) - else: - self.timepoints_ssm = timepoints_ssm - self.results_dict = {} - self.x_c = [] - self.x_sol = None - self.x_sol2 = None - self.full_ssm = None - return - - def get_output_states(self): - if self.C is None and self.h is None: - return [] - outputs = np.dot(np.array(self.C), np.array(self.x)) # Get y = C*x - if type(outputs) is not np.ndarray: - outputs = [outputs] - else: - outputs = outputs.tolist() - output_symbols = [list(i.free_symbols) for i in outputs] - output_states = [ - item for sublist in output_symbols for item in sublist - ] - return output_states - - def get_all_combinations(self): - """ - Combinatorially create sets of all states - that can be reduced in self.all_reductions. - In addition, returns the possible reductions - list after removing the sets that - contain states involved in the outputs. - """ - from itertools import combinations - - possible_reductions = [] - n = self.n - for i in range(n): - if i != n - 1: - comb = combinations(list(range(n)), i + 1) - possible_reductions.append(list(comb)) - possible_reductions = [ - list(item) for sublist in possible_reductions for item in sublist - ] - self.all_combinations = [i for i in possible_reductions] - output_states = self.get_output_states() - restart = False - x = self.x - for attempt in self.all_combinations: - states_attempt = [x[i] for i in attempt] - if ( - not len(set(states_attempt).intersection(set(output_states))) - == len(output_states) - or len(attempt) > self.nstates_tol - ): - restart = True - if restart: - possible_reductions.remove(attempt) - restart = False - - # Remove state(s) that consist of input(s) - if self.u is not None: - for i, _ in enumerate(self.g): - if self.g[i] != 0: - if i in possible_reductions: - # This index state variable should - # not be in possible_reductions list - possible_reductions.remove(i) - return possible_reductions - - def get_T(self, attempt): - non_attempt = [i for i in range(self.n) if i not in attempt] - T = np.zeros((self.n, self.n)) - n_hat = len(attempt) - n = self.n - n_c = n - n_hat - T1 = np.zeros((self.n, n_hat)) - T2 = np.zeros((self.n, n_c)) - # For x_hat - for ni in range(0, n_hat): - set_T = False - for i in range(n): - if i in attempt and not set_T: - T[ni, i] = 1 - attempt.remove(i) - set_T = True - # For x_c - for ni in range(n_hat, n): - set_T = False - for i in range(n): - if i in non_attempt and not set_T: - T[ni, i] = 1 - non_attempt.remove(i) - set_T = True - T1 = T[0:n, 0:n_hat] - T2 = T[0:n, n_hat : n + 1] # noqa: E203 - return T, T1, T2 - - def get_error_metric_with_input(self, reduced_sys): - """ - Returns the error defined as the 2-norm of y - y_hat. - y = Cx and y_hat = C_hat x_hat OR - y = h(x, P), y_hat = h_hat(x_hat, P). - Important : What is the input? - """ - reduced_ode = utils.get_ODE(reduced_sys, self.timepoints_ode) - x_sol, _, _ = self.get_solutions() - y = self.C @ x_sol - x_sols_hat = reduced_ode.solve_system().T - reduced_sys.x_sol = x_sols_hat - y_hat = np.array(reduced_sys.C) @ np.array(x_sols_hat) - if np.shape(y) == np.shape(y_hat): - e = np.linalg.norm(y - y_hat) - else: - raise ValueError( - "The output dimensions must be the same for" - + "reduced and full model. Choose C and C_hat accordingly" - ) - if np.isnan(e): - print("The error is NaN, something wrong...continuing.") - return e - - def get_error_metric(self, reduced_sys): - # Give option for get_error_metric(sys1, sys2) - """ - Returns the error defined as the 2-norm of y - y_hat. - y = Cx and y_hat = C_hat x_hat OR - y = h(x, P), y_hat = h_hat(x_hat, P) - """ - reduced_ode = utils.get_ODE(reduced_sys, self.timepoints_ode) - x_sol, _, _ = self.get_solutions() - y = self.C @ x_sol - x_sols_hat = reduced_ode.solve_system().T - reduced_sys.x_sol = x_sols_hat - y_hat = np.array(reduced_sys.C) @ np.array(x_sols_hat) - if np.shape(y) == np.shape(y_hat): - e = np.linalg.norm(y - y_hat) - else: - raise ValueError( - "The output dimensions must be the same for" - + "reduced and full model. Choose C and C_hat accordingly" - ) - if np.isnan(e): - print("The error is NaN, something wrong...continuing.") - return e - - def get_robustness_metric_with_input(self, reduced_sys): - return - - def get_robustness_metric(self, reduced_sys, **kwargs): - # Create an option so the default way this is - # done is given two systems compute robustness metric. - # Implementing Theorem 2 - if "method" in kwargs: - method = kwargs.get("method") - else: - method = "direct" - timepoints_ssm = self.timepoints_ssm - _, x_sols, full_ssm = self.get_solutions() - S = full_ssm.compute_SSM() - self.S = S - reduced_ssm = utils.get_SSM(reduced_sys, timepoints_ssm) - x_sols_hat = ( - utils.get_ODE(reduced_sys, timepoints_ssm).solve_system().T - ) - x_sols = np.reshape(x_sols, (len(timepoints_ssm), self.n)) - x_sols_hat = np.reshape( - x_sols_hat, (len(timepoints_ssm), reduced_sys.n) - ) - Se = np.zeros(len(self.params_values)) - S_hat = reduced_ssm.compute_SSM() - reduced_sys.S = S_hat - S_bar = np.concatenate((S, S_hat), axis=2) - S_bar = np.reshape( - S_bar, - ( - len(timepoints_ssm), - self.n + reduced_sys.n, - len(self.params_values), - ), - ) - C_bar = np.concatenate((self.C, -1 * reduced_sys.C), axis=1) - C_bar = np.reshape( - C_bar, (np.shape(self.C)[0], (self.n + reduced_sys.n)) - ) - weighted_Se_sum = 0 - P_prev = None - prev_time = None - if method == "bound": - for j, _ in enumerate(self.params_values): - S_metric_max = 0 - sens_max = 0 - max_eig_P = 0 - max_eig_dot_P = 0 - for k in range(len(self.timepoints_ssm)): - curr_time = self.timepoints_ssm[k] - J = full_ssm.compute_J(x_sols[k, :]) - J_hat = reduced_ssm.compute_J(x_sols_hat[k, :]) - J_bar = block_diag(J, J_hat) - # print(J) - # print(J_bar) - # if np.isnan(J).any() or np.isnan(J_hat).any() - # or np.isfinite(J).all() or np.isfinite(J_hat).all(): - # warnings.warn('NaN or - # inf found in Jacobians, continuing') - # continue - P = solve_lyapunov(J_bar, -1 * C_bar.T @ C_bar) - eig_P = max(eigvals(P)) - # if k == 0: # used when proof I thought s - # aid that lambda_max_P - # was at time 0 for IC term. - if max_eig_P < eig_P: - max_eig_P = eig_P - if k != 0: - dot_P = (P - P_prev) / (curr_time - prev_time) - eig_dot_P = max(eigvals(dot_P)) - if max_eig_dot_P < eig_dot_P: - max_eig_dot_P = eig_dot_P - Z = full_ssm.compute_Zj(x_sols[k, :], j) - Z_hat = reduced_ssm.compute_Zj(x_sols_hat[k, :], j) - Z_bar = np.concatenate((Z, Z_hat), axis=0) - Z_bar = np.reshape(Z_bar, ((self.n + reduced_sys.n), 1)) - S_metric = norm(Z_bar.T @ P @ S_bar[k, :, j]) - if S_metric > S_metric_max: - S_metric_max = S_metric - sens_norm = norm(S_bar[k, :, j]) ** 2 - if sens_norm > sens_max: - sens_max = sens_norm - P_prev = P - prev_time = curr_time - utils.printProgressBar( - int(j + k * len(self.params_values)), - len(timepoints_ssm) * len(self.params_values) - 1, - prefix="Robustness Metric Progress:", - suffix="Complete", - length=50, - ) - dot_P_term = ( - max_eig_dot_P * len(reduced_ssm.timepoints) * sens_max - ) - Se[j] = ( - max_eig_P - + 2 * len(reduced_ssm.timepoints) * S_metric_max - + dot_P_term - ) - weighted_Se_sum += self.params_values[j] * Se[j] - elif method == "direct": - for j in range(len(self.params_values)): - Se[j] = norm(C_bar @ S_bar[:, :, j].T) - weighted_Se_sum += self.params_values[j] * Se[j] - err_norm = norm(self.get_error_metric(reduced_sys)) - R = 1 / (1 + (weighted_Se_sum / err_norm)) - reduced_sys.R = R - reduced_sys.Se = Se - return Se, R - - def get_invariant_manifold(self, reduced_sys): - timepoints_ode = self.timepoints_ode - x_c = reduced_sys.x_c - fast_states = reduced_sys.fast_states - x_hat = reduced_sys.x - x_sols_hat = reduced_sys.get_ODE().solve_system().T - x_sol_c = np.zeros((len(timepoints_ode), np.shape(x_c)[0])) - # Get the collapsed states by substituting the solutions - # into the algebraic relationships obtained - for i in range(np.shape(x_sols_hat)[0]): - # for each reduced variable (because collapsed variables are only - # functions of reduced variables, algebraically) - for k in range(len(x_sols_hat[:, i])): - for j in range(len(x_c)): - subs_result = fast_states[j].subs( - x_hat[i], x_sols_hat[:, i][k] - ) - if subs_result == fast_states[j]: - continue - elif isinstance(subs_result, sympy.Expr): - # continue substituting other variables, - # until you get a float - fast_states[j] = subs_result - else: - x_sol_c[k][j] = fast_states[j].subs( - x_hat[i], x_sols_hat[:, i][k] - ) - return x_sol_c - - def solve_timescale_separation( - self, slow_states, fast_states=None, **kwargs - ): - """ - This function solves the time-scale separation - problem for the System object passed through. - Arguments: - * slow_states: List of states assumed to - have slow dynamics => retained in the reduced model. - This is list of Sympy Symbol objects - corresponding to the System.x list. - * fast_states: List of states assumed to - have fast dynamics => states that will be collapsed. Usually, - this is automatically populated as all those - states that are in System.x but not in slow_states. - """ - # Get 'debug' keyword (if called in debug = True mode): - if "debug" in kwargs: - debug = kwargs.get("debug") - else: - debug = False - # If slow_states is empty, then reduced model = given model - # and collapsed model is None - if not slow_states: - return self.get_system(), None - x, f, x_init = self.x, self.f, self.x_init - - len_slow_states = len(slow_states) - x_hat = [None] * len_slow_states - x_hat_init = [None] * len_slow_states - f_hat = [None] * len_slow_states - - max_len_fast_states = len(x) - len(slow_states) - x_c = [None] * max_len_fast_states - x_c_init = [None] * max_len_fast_states - f_c = [None] * max_len_fast_states - # print('f_c',f_c) - # Populate the list of states that will retained (x_hat) - # and those that will be collapsed (x_c) - x_hat = slow_states - # Make sure fast_states (direct sum) slow_states is all of it. - # Check if fast states are already provided as well: - if fast_states: - x_c = fast_states - else: - # If not, automatically fill it up. - count_x_c = 0 - for i in x: - if i not in slow_states: - x_c[count_x_c] = i - count_x_c += 1 - fast_states = x_c - # Consistency check for slow and fast states: - if len(slow_states) + len(fast_states) != len(self.x): - raise RuntimeError( - "Number of slow states plus number of fast" - "states must equal the number of total states." - ) - for state in slow_states: - if state in fast_states: - raise RuntimeError( - "Found a state that is both fast and slow!" - "Unfortunately, that is not yet possible in this reality." - ) - # Now populate the default corresponding - # f_c and f_hat dynamics from self.f - # and inital conditions from self.x_init - for i in x: - state_index = x.index(i) - if i in x_c: - x_c_index = x_c.index(i) - f_c[x_c_index] = f[state_index] - if self.parameter_dependent_ic: - param_as_ic = self.ic_parameters[state_index] - value_ic = self.set_ic_from_params( # noqa: F841 - x_c_init, param_as_ic, x_c_index - ) - else: - x_c_init[x_c_index] = x_init[state_index] - if i in x_hat: - x_hat_index = x_hat.index(i) - f_hat[x_hat_index] = f[state_index] - if self.parameter_dependent_ic: - param_as_ic = self.ic_parameters[state_index] - value_ic = self.set_ic_from_params( # noqa: F841 - x_hat_init, param_as_ic, x_hat_index - ) - else: - x_hat_init[x_hat_index] = x_init[state_index] - self.f_hat = f_hat - self.f_c = f_c - if debug: - print("Reduced set of variables is", x_hat) - print("f_hat = ", self.f_hat) - print("Collapsed set of variables is", x_c) - - # Get the reduced (slow system) dynamics: - # Check after substituting each solution into - # f_hat whether resulting f_hat sympy ODE - # has any remaining variables that should have been collapsed. - loop_sanity = True - count = 0 - solution_dict = {} - while ( - sympy_variables_exist( - ode_function=self.f_hat, variables_to_check=x_c - )[0] - and loop_sanity - ): - # print(sympy_solve_and_substitute(ode_function = self.f_hat, - # collapsed_states = x_c, - # collapsed_dynamics = self.f_c, - # solution_dict = solution_dict, - # debug = debug)) - self.f_hat, solution_dict, self.f_c = sympy_solve_and_substitute( - ode_function=self.f_hat, - collapsed_states=x_c, - collapsed_dynamics=self.f_c, - solution_dict=solution_dict, - debug=debug, - ) - if count > 2: - warnings.warn( - "Solve time-scale separation failed." - "Check model consistency." - ) - print( - f"Did not work to retain: {slow_states}" - " because either a collapsed state-variables appears" - ) - print(" in the reduced model or a solution is not possible.") - loop_sanity = False - return None, None - count += 1 - - # Get the collapsed (fast system) dynamics to create collapsed_system - for i, _ in enumerate(x_hat): - for j, _ in enumerate(self.f_c): - # The slow variables stay at steady state in the fast subsystem - self.f_c[j] = self.f_c[j].subs(x_hat[i], x_hat_init[i]) - - # Create C_hat - C_hat = self.create_C_hat(x_hat) - for index, _ in enumerate(f_hat): - f_hat[index] = sympy.simplify(f_hat[index]) - for index, _ in enumerate(f_c): - f_c[index] = sympy.simplify(f_c[index]) - reduced_sys = create_system( - x_hat, - self.f_hat, - params=self.params, - C=C_hat, - params_values=self.params_values, - x_init=x_hat_init, - ) - fast_subsystem = create_system( - x_c, - self.f_c, - params=self.params, - params_values=self.params_values, - x_init=x_c_init, - ) - reduced_sys.fast_states = fast_states - # If you got to here, - print(f"Successful solution obtained with states: {reduced_sys.x}!") - return reduced_sys, fast_subsystem - - def solve_timescale_separation_with_input(self, attempt_states): - attempt = [] - for state in attempt_states: - attempt.append(self.x.index(state)) - print("attempting to retain:", attempt) - x_c = [] - fast_states = [] - f_c = [] - f_hat = [] - x_hat_init = [] - x_c_init = [] - x_hat = [] - x, f, g, u, x_init = self.x, self.f, self.g, self.u, self.x_init - f_g = [fi + gi for fi, gi in zip(f, g)] - for i in range(self.n): - if i not in attempt: - x_c.append(x[i]) - f_c.append(f_g[i]) - x_c_init.append(x_init[i]) - else: - f_hat.append(f_g[i]) - x_hat.append(x[i]) - x_hat_init.append(x_init[i]) - # print('Reduced set of variables is', x_hat) - # print('f_hat = ',f_hat) - # print('Collapsed set of variables is', x_c) - - solved_states = [] - lookup_collapsed = {} - for i, _ in enumerate(x_c): - x_c_sub = solve(Eq(f_c[i], 0), x_c[i]) - lookup_collapsed[x_c[i]] = x_c_sub - if len(x_c_sub) == 0: - # print('Could not find solution for this collapsed variable : - # {0} from {1}'.format(x_c[i], f_c[i])) - fast_states.append([]) - continue - elif len(x_c_sub) > 1: - # print('Multiple solutions obtained. - # Chooosing non-zero solution, - # check consistency. The solutions are ', x_c_sub) - for sub in x_c_sub: - if sub == 0: - x_c_sub.remove(0) - else: - for sym in x_c_sub[0].free_symbols: - if sym in solved_states and sym in x: - # print('The state {0} has been solved for but appears - # in the solution for the next variable, - # making the sub with - # {1} into the corresponding f_c - # and solving again should - # fix this.'.format(sym, lookup_collapsed[sym][0])) - f_c[i] = f_c[i].subs(sym, lookup_collapsed[sym][0]) - # print('Updating old x_c_sub then') - x_c_sub = solve(Eq(f_c[i], 0), x_c[i]) - if len(x_c_sub) > 1: - print("Multiple solutions obtained.") - print( - "Chooosing non-zero solution," - "check consistency." - ) - print(" The solutions are ", x_c_sub) - for sub in x_c_sub: - if sub == 0: - x_c_sub.remove(0) - # print('with ',x_c_sub) - lookup_collapsed[x_c[i]] = x_c_sub - else: - solved_states.append(x_c[i]) - # print('Solved for - # {0} to get {1}'.format(x_c[i], x_c_sub[0])) - # This x_c_sub should not contain previously eliminated - # variables otherwise circles continue - fast_states.append(x_c_sub[0]) - - for i in range(len(fast_states)): - if fast_states[i] == []: - continue - for j in range(len(f_hat)): - # print('Substituting {0} for - # variable {1} - # into f_hat{2}'.format(fast_states[i], x_c[i], j)) - f_hat[j] = f_hat[j].subs(x_c[i], fast_states[i]) - # print('f_hat = ',f_hat[j]) - for j in range(len(f_c)): - # print('Substituting {0} for - # variable {1} into f_c{2}'.format(fast_states[i], x_c[i], j)) - f_c[j] = f_c[j].subs(x_c[i], fast_states[i]) - # print('f_c = ',f_c[j]) - - # Continue - for i in range(len(x_hat)): - for j in range(len(f_c)): - # The slow variables stay at steady state in the fast subsystem - f_c[j] = f_c[j].subs(x_hat[i], x_hat_init[i]) - - # Create C_hat - output_states = self.get_output_states() - C_hat = np.zeros((np.shape(self.C)[0], np.shape(x_hat)[0])) - is_output = 0 - for i in range(len(x_hat)): - if x_hat[i] in output_states: - is_output = 1 - for row_ind in range(np.shape(C_hat)[0]): - C_hat[row_ind][i] = 1 * is_output - - # Create list of all free symbols - flag = False - free_symbols_all = [] - for fi in f_hat: - fi = sympy.sympify(fi) - for sym in fi.free_symbols: - if sym not in free_symbols_all: - free_symbols_all.append(sym) - bugged_states = [] - for syms in free_symbols_all: - if syms not in x_hat + u + self.params: - bugged_states.append(syms) - flag = True - if flag: - warnings.warn("Check model consistency") - print( - f"The time-scale separation that retains states {attempt},\ - does not work" - ) - print( - f"because the state-variables {bugged_states} \ - appear in the reduced model" - ) - # return None, None - - reduced_sys = create_system( - x_hat, - f_hat, - params=self.params, - C=C_hat, - params_values=self.params_values, - x_init=x_hat_init, - ) - fast_subsystem = create_system( - x_c, - f_c, - params=self.params, - params_values=self.params_values, - x_init=x_c_init, - ) - reduced_sys.x_c = x_c - reduced_sys.bugged_states = bugged_states - reduced_sys.fast_states = fast_states - return reduced_sys, fast_subsystem - - def create_C_hat(self, x_hat): - """ - Returns C_hat matrix for the reduced system - given the x_hat (reduced system state vector) - and using the C matrix for the full system (if any) - """ - if self.C is None: - C_hat = None - else: - output_states = self.get_output_states() - C_hat = np.zeros((np.shape(self.C)[0], np.shape(x_hat)[0])) - is_output = 0 - for i in range(len(x_hat)): - if x_hat[i] in output_states: - is_output = 1 - for row_ind in range(np.shape(C_hat)[0]): - C_hat[row_ind][i] = 1 * is_output - return C_hat - - def get_conservation_laws(self, num_conservation_laws: int, **kwargs): - """Finds sets of conserved species. - Only linear combinations with coefficient = 1 supported. - - Args: - num_conservation_laws (int): The null space of the - stoichiometry matrix. In other words, - the number of expected - conservation laws. - Returns: - List of conserved species (list) - """ - all_conserved_sets = [] - ode_list = [i for i in self.f if i != 0] - for d in range(num_conservation_laws): - curr_depth = d + 1 - for i in combinations(ode_list, curr_depth): - sum_terms = 0 - for element in i: - if element == 0: - continue - sum_terms += element - if sum_terms == 0: - conserved_species = [] - for element in i: - for ode_i in range(len(self.f)): - if str(self.f[ode_i]) == str(element): - conserved_species.append(self.x[ode_i]) - if len(conserved_species) <= 1: - continue - all_conserved_sets.append(conserved_species) - if not all_conserved_sets: - raise ValueError( - "No conserved sets found. Try increasing the " - "depth of search by increasing the number of " - "possible conservation laws: num_conservation_laws" - ) - return all_conserved_sets - - def setup_conservation_laws( - self, total_quantities: dict, conserved_sets: list - ): - """Setup conservation laws and return a - list of conservation laws where - each conservation law is each sublist of - conserved_sets equated to the corresponding - total quantity in the total quantities dictionary. - - Args: - total_quantities (dict): Dictionary with total quantities - string keys and total value - conserved_sets (list): A list of list consisting - where each sublist is a - set of species that are conserved - Returns: - conservation_laws (list): A list of conservation laws - """ - # Setup conservation laws - params = self.params - params_values = self.params_values - conservation_laws = [] - for conserved_set, tot in zip(conserved_sets, total_quantities.keys()): - total_symbol = Symbol(tot) - params.append(total_symbol) - params_values.append(total_quantities[tot]) - law = 0 - for x in conserved_set: - law += x - law += -total_symbol - conservation_laws.append(law) - self.params = params - self.params_values = params_values - return conservation_laws - - def solve_conservation_laws( - self, - conservation_laws: list = None, - total_quantities: dict = None, - conserved_sets: list = None, - states_to_eliminate: list = None, - num_conservation_laws: int = 0, - **kwargs, - ): - """User interface wrapper to find and set - conservation laws for a given Reduce System object - - Args: - conservation_laws (list, optional): A list consisting of - conservation laws - in the form: LHS - RHS. - The RHS is assumed to be zero. - If None is provided, - then attempts to find - conservation laws, - if num_conservation_laws set. - total_quantities (dict, optional): A dictionary of total - quantities with keys - consisting of strings of - total quantities - (RHS of conservation law) - and a float value. - If None provided, then a - dict with parameter name - is created from the state - name appended by keyword - "_total" and with zero value. - conserved_sets (list of list, optional): A list of list where each - sublist consists - of species in System.x, - for which, - if corresponding elements - in System.f - are added would be equal - to zero. - If None is provided, - then attempts to find the - conserved_sets, - if num_conservation_laws - is set. - states_to_eliminate (list, optional): A list of states to eliminate - from the set - of conserved species. - Each element in this - list must correspond to each - sublist in conserved_sets - and/or conservation_laws, - depending on - which is passed in. - If None is provided, - then creates a default - list of - states to eliminate from - variables in each law in - conservation_laws list. - num_conservation_laws (int, optional): The dimension of the - nullspace of the - stoichiometry - matrix. In other words, - the number of expected - conservation laws. - Defaults to 0 but then - expects that either - conservation_laws or - conserved_sets is given. - Returns: - conserved_system (Reduce): The reduced system with - conservation laws applied. - - """ - debug = kwargs.get("debug", False) - if ( - num_conservation_laws == 0 - and conserved_sets is None - and conservation_laws is None - ): - raise ValueError( - "Must pass in something to set conservation laws! " - "Either the list of conservation_laws, or" - "number of conservation " - "laws through num_conservation_laws " - "argument or the conserved_sets list" - ) - if ( - conservation_laws is None - and num_conservation_laws == 0 - and conserved_sets is not None - ): - if conserved_sets: - self.num_conservation_laws = len(conserved_sets) - self.conserved_sets = conserved_sets - else: - raise ValueError("List of conserved sets must not be empty.") - elif ( - conservation_laws is None - and num_conservation_laws != 0 - and conserved_sets is None - ): - self.num_conservation_laws = num_conservation_laws - self.conserved_sets = self.get_conservation_laws( - self.num_conservation_laws - ) - else: - self.conserved_sets = conserved_sets - - if conservation_laws is None: - if total_quantities is None: - total_quantities = {} - for c_set in self.conserved_sets: - total_quantities[str(c_set[0]) + "_total"] = 0 - self.total_quantities = total_quantities - else: - self.total_quantities = total_quantities - self.conservation_laws = self.setup_conservation_laws( - self.total_quantities, self.conserved_sets - ) - print("Found conservation laws:", self.conservation_laws) - else: - self.conservation_laws = conservation_laws - # Remove duplicate laws - for law_i, law in enumerate(self.conservation_laws): - list_conservation_laws = list(self.conservation_laws) - list_conservation_laws.remove(law) - if law in list_conservation_laws: - if debug: - print( - "Found duplicate law {0} on index {1}." - "This will be removed. Check conservation_laws" - "attribute to confirm.".format(law, law_i) - ) - self.conservation_laws.remove(law) - if self.conservation_laws is not None and states_to_eliminate is None: - # Conservation laws are passed in as a list - # but states_to_eliminate list is not available - # Then, create it by choosing one variable from each law - states_to_eliminate = [] - for law in self.conservation_laws: - list_of_symbols_in_law = list(law.free_symbols) - chosen_var = None - index = 0 - while chosen_var is None: - if list_of_symbols_in_law[index] in self.x: - chosen_var = list_of_symbols_in_law[index] - index += 1 - if index == len(list_of_symbols_in_law): - raise ValueError( - "No variable found in conservation" - "law {0} that can be eliminated".format(law) - ) - states_to_eliminate.append(chosen_var) - self.states_to_eliminate = states_to_eliminate - print("Choosing states to eliminate:", self.states_to_eliminate) - else: - self.states_to_eliminate = states_to_eliminate - - self.f = self.set_conservation_laws( - conservation_laws=self.conservation_laws, - states_to_eliminate=self.states_to_eliminate, - ) - return self - - def set_conservation_laws(self, conservation_laws, states_to_eliminate): - """ - From the conserved_quantities list, - this method computes the expressions - for each of the state indices in states_to_eliminate, - and substitutes into the full model dynamics. - Both lists should contain symbolic variables - referencing states in self.f. - Returns the dynamics self.f. - - Args: - conservation_laws (list): List of conservation laws - states_to_eliminate (list): List of Symbols of states - to eliminate when applying the - conservation laws - - Returns: - Conserved ODE[list]: Conserved ODE as a list of expressions. - """ - states_to_eliminate_new = [] - for state in states_to_eliminate: - states_to_eliminate_new.append(self.x.index(state)) - states_to_eliminate = states_to_eliminate_new - for i in range(len(states_to_eliminate)): - state = self.x[states_to_eliminate[i]] - state_sub = solve(Eq(conservation_laws[i], 0), state) - for j in range(len(self.f)): - self.f[j] = self.f[j].subs(state, state_sub[0]) - - arr_x = np.array(self.x) - self.x = np.delete(arr_x, states_to_eliminate).tolist() - arr_f = np.array(self.f) - self.f = np.delete(arr_f, states_to_eliminate).tolist() - self.x_init = np.delete(self.x_init, states_to_eliminate).tolist() - if self.parameter_dependent_ic: - self.ic_parameters = np.delete( - self.ic_parameters, states_to_eliminate - ).tolist() - self.C = np.delete(np.array(self.C), states_to_eliminate, axis=1) - self.n = self.n - len(states_to_eliminate) - return self.f - - def solve_approximations(self): - pass - - def get_solutions(self): - if self.x_sol is None: - x_sol = utils.get_ode_solutions( - self.get_system(), self.timepoints_ode - ) - self.x_sol = x_sol - if self.x_sol2 is None: - x_sol2 = utils.get_ode_solutions( - self.get_system(), self.timepoints_ssm - ) - self.x_sol2 = x_sol2 - if self.full_ssm is None: - full_ssm = utils.get_SSM(self.get_system(), self.timepoints_ssm) - self.full_ssm = full_ssm - return self.x_sol, self.x_sol2, self.full_ssm - - def reduce_simple(self, **kwargs): - if "skip_numerical_computations" in kwargs: - skip_numerical_computations = kwargs.get( - "skip_numerical_computations" - ) - else: - skip_numerical_computations = False - if "skip_error_computation" in kwargs: - skip_error_computation = kwargs.get("skip_error_computation") - else: - skip_error_computation = False - if "skip_robustness_computation" in kwargs: - skip_robustness_computation = kwargs.get( - "skip_robustness_computation" - ) - else: - skip_robustness_computation = False - if self.u is not None: - raise ValueError("For models with inputs use reduce_with_input.") - results_dict = {} - possible_reductions = self.get_all_combinations() - if not len(possible_reductions): - print("No possible reduced models found.") - print(" Try increasing tolerance for number of states.") - return - for attempt in possible_reductions: - if len(attempt) < self.nstates_tol_min: - continue - elif len(attempt) > self.nstates_tol: - continue - attempt_states = [self.x[i] for i in attempt] - # Create reduced systems - reduced_sys, fast_subsystem = self.solve_timescale_separation( - attempt_states, **kwargs - ) - if reduced_sys is None or fast_subsystem is None: - continue - if skip_numerical_computations: - results_dict[reduced_sys] = None - else: - # Get metrics for this reduced system - if skip_error_computation: - e = np.nan - else: - e = self.get_error_metric(reduced_sys) - if skip_robustness_computation: - Se = np.nan - R = np.nan - else: - Se, R = self.get_robustness_metric(reduced_sys, **kwargs) - results_dict[reduced_sys] = [e, Se, R] - self.results_dict = results_dict - return self.results_dict - - def reduce_with_input(self): - if self.u is None: - raise ValueError("For models with no inputs use reduce_simple") - results_dict = {} - possible_reductions = self.get_all_combinations() - if not len(possible_reductions): - print("No possible reduced models found.") - print(" Try increasing tolerance for number of states.") - return - for attempt in possible_reductions: - attempt_states = [self.x[i] for i in attempt] - # Create reduced systems - r_sys, f_sys = self.solve_timescale_separation_with_input( - attempt_states - ) - if r_sys is None or f_sys is None: - continue - # Get metrics for this reduced system - e = self.get_error_metric_with_input(r_sys) - Se, R = self.get_robustness_metric_with_input(r_sys) - results_dict[r_sys] = [e, Se, R] - self.results_dict = results_dict - return self.results_dict - - def reduce_general(self): - results_dict = {} - possible_reductions = self.get_all_combinations() - if not len(possible_reductions): - print("No possible reduced models found.") - print(" Try increasing tolerance for number of states.") - return - - self.results_dict = results_dict - return self.results_dict - - def compute_reduced_model(self): - if self.C is not None and self.g is None: - # Call y = Cx based model reduction - print("Using model reduction algorithm with y = Cx") - print(" linear output relationship and no inputs (g = 0).") - self.results_dict = self.reduce_simple() - return self.results_dict - else: - print("Using general model reduction algorithm") - print(" with inputs and nonlinear output relationship") - self.results_dict = self.reduce_general() - return self.results_dict - - def get_system(self): - return System( - self.x, - self.f, - params=self.params, - C=self.C, - g=self.g, - h=self.h, - u=self.u, - params_values=self.params_values, - x_init=self.x_init, - ) - - -def sympy_variables_exist(ode_function, variables_to_check, **kwargs): - """ - To check whether any variable in variables_to_check - appears in any Sympy equation - in the ode_function list of functions. - Arguments: - * ode_function: A list of Sympy functions - that need to be checked. - * variables_to_check: A list of variables that - need to be checked for in the ode_function - * kwargs: - Returns a tuple: - True, variables_that_appear: - If any variable found, True is returned - along with a list of variables that appear - False, []: - If no variable found, False is returned - with a None (since no variables are found in ode_function). - """ - flag = False - all_free_symbols = [] - if "debug" in kwargs: - debug = kwargs.get("debug") - else: - debug = False - if debug: - print( - "In sympy_variables_exist. Checking for presence of ", - variables_to_check, - ) - for fi in ode_function: - fi = sympy.sympify(fi) - for sym in fi.free_symbols: - if sym not in all_free_symbols: - all_free_symbols.append(sym) - - variables_that_appear = [] - for sym in all_free_symbols: - if sym in variables_to_check: - variables_that_appear.append(sym) - flag = True - if flag and debug: - print("Found! The following: ", variables_that_appear) - return flag, variables_that_appear - - -def sympy_solve_and_substitute( - ode_function, - collapsed_states, - collapsed_dynamics, - solution_dict, - debug=False, -): - """A function to solve using sympy and substitute into the equation""" - for s in collapsed_states: - index = collapsed_states.index(s) - f = collapsed_dynamics[index] - if debug: - print("In sympy_solve_and_substitute, solving for ", s) - print("From ", f) - solution_dict = sympy_get_steady_state_solutions( - collapsed_variables=[s], - collapsed_dynamics=[f], - solution_dict=solution_dict, - debug=debug, - ) - if debug: - print("Solution found: ", solution_dict) - print("current state", s) - if solution_dict[s] is None or len(solution_dict[s]) == 0: - continue - for func in ode_function: - func = sympy.sympify(func) - func_index = ode_function.index(func) - updated_func = func.subs(s, solution_dict[s][0]) - ode_function[func_index] = updated_func - for func in collapsed_dynamics: - if func == f: - continue - func_index = collapsed_dynamics.index(func) - updated_func = func.subs(s, solution_dict[s][0]) - collapsed_dynamics[func_index] = updated_func - if debug: - print("Updated f_hat now is ", ode_function) - # print('returning', ode_function) - # print('returning', solution_dict) - # print('returning', collapsed_dynamics) - # returned_tuple = (ode_function, solution_dict, collapsed_dynamics) - # if len(returned_tuple) == 3: - # print('WTF is happening') - # return returned_tuple - return (ode_function, solution_dict, collapsed_dynamics) - - -def sympy_get_steady_state_solutions( - collapsed_variables, collapsed_dynamics, solution_dict=None, debug=False -): - """ - Solve for each collapsed_variable from - corresponding collapsed_dynamics one by one. - Return the solutions as a lookup dictionary - as a map for variables and their solutions. - """ - if solution_dict is None: - solution_dict = {} - x_c = collapsed_variables - f_c = collapsed_dynamics - for i, _ in enumerate(x_c): - x_c_sub = solve(Eq(f_c[i], 0), x_c[i]) - if x_c_sub is None or len(x_c_sub) == 0: - print(f"Could not find solution for: {x_c[i]} from {f_c[i]}") - warnings.warn( - "Solve time-scale separation failed. Check model consistency." - ) - elif len(x_c_sub) > 1: - if debug: - print(f"Multiple solutions obtained for {x_c[i]}.") - print("Chooosing one non-zero solution, check consistency. ") - print(f"The solutions are {x_c_sub}.") - print(" Highly recommend manuallly solving for this") - print(" variable first then try this function.") - for sub in x_c_sub: - if sub == 0: - x_c_sub.remove(0) - elif not any(x_c_sub): - warnings.warn( - "Solve time-scale separation failed. Check model consistency." - ) - if debug: - warnings.warn(f"Zero solution(s) for: {x_c[i]} from {f_c[i]}.") - # Search for variables existing in x_c_sub - # that might have been solved for before: - # flag, solved_vars = sympy_variables_exist(ode_function = x_c_sub, - # variables_to_check = - # list(solution_dict.keys()), - # debug = debug) - # if debug and flag: - # print('Found variables while solving - # that have already been solved:', solved_variables) - # if flag: - # for solved_variable in solved_Vars: - # for sub_func in x_c_sub: - # i = x_c_sub.index(sub_func) - # sub_func = sub_func.subs(solved_variable, - # solution_dict[solved_variable][0]) - # x_c_sub[i] = sub_func - # Store solution in a lookup dictionary: - solution_dict[x_c[i]] = x_c_sub - return solution_dict - - -class ReduceUtils(Reduce): - """ - For various utility methods developed - on top of Reduce class and other utility functions - """ - - def __init__( - self, - x, - f, - params=None, - C=None, - g=None, - h=None, - u=None, - params_values=None, - x_init=None, - timepoints_ode=None, - timepoints_ssm=None, - error_tol=None, - nstates_tol=None, - ): - super().__init__( - x, - f, - params, - C, - g, - h, - params_values, - x_init, - timepoints_ode, - timepoints_ssm, - error_tol, - nstates_tol, - ) - - def write_results(self, filename): - """ - Write the model reduction results in a file given by filename. - The symbolic data is written in LaTeX. - """ - from sympy.printing import latex - - f1 = open(filename, "w") - f1.write("Model reduction results.\n") - for key, value in self.results_dict.items(): - f1.write("A possible reduced model: \n \n") - f1.write("\n$x_{hat} = ") - f1.write(str(key.x)) - f1.write("$\n\n\n\n") - for k in range(len(key.f)): - f1.write("\n$f_{hat}(" + str(k + 1) + ") = ") - f1.write(latex(key.f[k])) - f1.write("$\n\n") - f1.write("\n\n\n") - f1.write("\nError metric:") - f1.write(str(value[0])) - f1.write("\n\n\n") - f1.write("\nRobustness metric:") - f1.write(str(value[1])) - f1.write("\n\n\n") - f1.write("Other properties") - f1.write("\n\n\n") - f1.write("\n C = ") - f1.write(str(key.C)) - f1.write("\n$ g = ") - f1.write(str(key.g)) - f1.write("$\n h = ") - f1.write(str(key.h)) - f1.write("\n$h = ") - f1.write(str(key.h)) - f1.write("$\n Solutions : \n") - f1.write(str(key.x_sol)) - f1.write("\n\n\n\n") - f1.write("\n Sensitivity Solutions : \n") - f1.write(str(key.S)) - f1.write("\n\n\n\n") - f1.close() - - def get_valid_reduced_models(self, nstates_tol=None, error_tol=None): - """ - Returns the reduced models obtained and - stored in results_dict that satisfy the given - tolerances for number of states and the - error tolerance. Among the return reduced - model objects you may access robustness metric - for each by looking at reduced_sys.Se. - Choose the reduced model with lowest robustness metric. - """ - if nstates_tol is None: - nstates_tol = self.nstates_tol - if error_tol is None: - error_tol = self.error_tol - valid_reduced_models = [] - results_dict = self.results_dict - for key, value in results_dict.items(): - error = value[0] - if error <= error_tol and len(key.x) <= nstates_tol: - valid_reduced_models.append(key) - self.valid_reduced_models = valid_reduced_models - return valid_reduced_models - - -def create_system( - x, - f, - params=None, - C=None, - g=None, - h=None, - u=None, - params_values=None, - x_init=None, -): - return System( - x, - f=f, - params=params, - C=C, - g=g, - h=h, - u=u, - params_values=params_values, - x_init=x_init, - ) diff --git a/autoreduce/reductions/__init__.py b/autoreduce/reductions/__init__.py new file mode 100644 index 0000000..2c95fcd --- /dev/null +++ b/autoreduce/reductions/__init__.py @@ -0,0 +1,8 @@ +"""Model-reduction algorithms.""" + +from autoreduce.reductions.abundance import * # noqa: F403 +from autoreduce.reductions.conservation import * # noqa: F403 +from autoreduce.reductions.core import * # noqa: F403 +from autoreduce.reductions.projection import * # noqa: F403 +from autoreduce.reductions.timescale import * # noqa: F403 +from autoreduce.reductions.utils import * # noqa: F403 diff --git a/autoreduce/reductions/abundance.py b/autoreduce/reductions/abundance.py new file mode 100644 index 0000000..bd6a949 --- /dev/null +++ b/autoreduce/reductions/abundance.py @@ -0,0 +1,6 @@ +"""Abundance-based model-reduction methods.""" + + +def solve_approximations(*args, **kwargs): + """Not implemented.""" + raise NotImplementedError("Abundance-based reduction is not implemented.") diff --git a/autoreduce/reductions/conservation.py b/autoreduce/reductions/conservation.py new file mode 100644 index 0000000..8064ac8 --- /dev/null +++ b/autoreduce/reductions/conservation.py @@ -0,0 +1,340 @@ +"""Conservation-law reduction methods.""" + +from itertools import combinations + +import numpy as np +from sympy import Eq, Symbol, simplify, solve + +from autoreduce.system.system import System + +__all__ = [ + "apply_conservation_laws", + "find_conserved_sets", + "setup_conservation_laws", + "solve_conservation_laws", +] + + +def _as_reducible(system_obj, in_place=False): + """Return a working system for conservation-law reduction.""" + from autoreduce.reductions.core import get_reducible + + if in_place: + if not isinstance(system_obj, System): + raise TypeError("system_obj must be an AutoReduce System object.") + return system_obj + if not isinstance(system_obj, System): + raise TypeError("system_obj must be an AutoReduce System object.") + return get_reducible(system_obj) + + +def find_conserved_sets(system_obj, search_depth, **kwargs): + """Find conserved species sets by summing ODE terms. + + Only linear combinations with coefficient 1 are currently supported. + `search_depth` is the maximum number of ODE terms to add while searching + for sums that cancel to zero. + """ + _ = kwargs + if search_depth is None or search_depth <= 0: + raise ValueError( + "Pass search_depth when conserved_sets or conservation_laws are " + "not provided." + ) + + all_conserved_sets = [] + seen = set() + ode_terms = [ + (index, ode) + for index, ode in enumerate(system_obj.f) + if simplify(ode) != 0 + ] + for depth in range(1, search_depth + 1): + for candidate in combinations(ode_terms, depth): + candidate_indices = [index for index, _ in candidate] + sum_terms = sum(ode for _, ode in candidate) + if simplify(sum_terms) != 0: + continue + conserved_species = [system_obj.x[index] for index in candidate_indices] + if len(conserved_species) <= 1: + continue + key = tuple(conserved_species) + if key in seen: + continue + seen.add(key) + all_conserved_sets.append(conserved_species) + + if not all_conserved_sets: + raise ValueError( + f"No conserved sets found up to search_depth={search_depth}. " + "Increase search_depth when a conserved quantity requires " + "summing more ODE terms, or pass conserved_sets/conservation_laws " + "explicitly." + ) + return all_conserved_sets + + +def setup_conservation_laws(system_obj, total_quantities, conserved_sets): + """Create conservation-law expressions from conserved species sets.""" + if total_quantities is None: + raise ValueError("total_quantities must be provided.") + if not isinstance(total_quantities, dict): + raise TypeError("total_quantities must be a dictionary.") + if conserved_sets is None or len(conserved_sets) == 0: + raise ValueError("conserved_sets must not be empty.") + if len(total_quantities) != len(conserved_sets): + raise ValueError( + "total_quantities must have one entry for each conserved set." + ) + + _add_total_quantities(system_obj, total_quantities) + conservation_laws = [] + for conserved_set, total_name in zip(conserved_sets, total_quantities): + total_symbol = Symbol(str(total_name)) + law = sum(conserved_set) - total_symbol + conservation_laws.append(law) + + return conservation_laws + + +def _add_total_quantities(system_obj, total_quantities): + """Add conservation total parameters to a system if they are absent.""" + if total_quantities is None: + return + if not isinstance(total_quantities, dict): + raise TypeError("total_quantities must be a dictionary.") + params = [] if system_obj.params is None else list(system_obj.params) + params_values = ( + [] if system_obj.params_values is None else list(system_obj.params_values) + ) + for total_name, total_value in total_quantities.items(): + total_symbol = Symbol(str(total_name)) + if total_symbol in params: + continue + params.append(total_symbol) + params_values.append(total_value) + system_obj.params = params + system_obj.params_values = params_values + system_obj.params_dict = dict(zip(system_obj.params, system_obj.params_values)) + + +def _unique_laws(conservation_laws, debug=False): + """Return conservation laws with symbolic duplicates removed.""" + unique = [] + for law in conservation_laws: + duplicate = any(simplify(law - existing) == 0 for existing in unique) + if duplicate: + if debug: + print( + "Found a duplicate conservation law. " + "It will be removed." + ) + continue + unique.append(law) + return unique + + +def _choose_states_to_eliminate(system_obj, conservation_laws): + """Choose one state from each conservation law, in system order.""" + states_to_eliminate = [] + for law in conservation_laws: + chosen_var = None + for state in system_obj.x: + if state in law.free_symbols: + chosen_var = state + break + if chosen_var is None: + raise ValueError( + f"No state variable in conservation law {law} can be eliminated." + ) + states_to_eliminate.append(chosen_var) + return states_to_eliminate + + +def _delete_values(values, indices): + """Delete state-indexed values while tolerating absent values.""" + if values is None: + return values + if len(values) == 0: + return [] + return np.delete(np.asarray(values, dtype=object), indices).tolist() + + +def _substitute_collection(values, substitutions): + """Substitute eliminated states in a scalar or collection of expressions.""" + def substitute_expr(expr): + result = expr + for old, new in substitutions: + if hasattr(result, "subs"): + result = result.subs(old, new) + return result + + if values is None: + return None + if isinstance(values, np.ndarray): + result = values.copy() + return np.vectorize(substitute_expr)(result) + if isinstance(values, (list, tuple)): + return [substitute_expr(expr) for expr in values] + return substitute_expr(values) + + +def apply_conservation_laws( + system_obj, conservation_laws, states_to_eliminate +): + """Apply conservation laws to a system in place.""" + if conservation_laws is None or len(conservation_laws) == 0: + raise ValueError("conservation_laws must not be empty.") + if states_to_eliminate is None or len(states_to_eliminate) == 0: + raise ValueError("states_to_eliminate must not be empty.") + if len(conservation_laws) != len(states_to_eliminate): + raise ValueError( + "conservation_laws and states_to_eliminate must have the same length." + ) + + state_indices = [system_obj.x.index(state) for state in states_to_eliminate] + if system_obj.C is not None: + c_array = np.asarray(system_obj.C) + if c_array.ndim == 1: + eliminated_output_columns = c_array[state_indices] + else: + eliminated_output_columns = c_array[:, state_indices] + if np.any(eliminated_output_columns != 0): + raise ValueError( + "Cannot eliminate states that appear in the linear output C@x." + ) + substitutions = [] + for law, state in zip(conservation_laws, states_to_eliminate): + state_solutions = solve(Eq(law, 0), state) + if not state_solutions: + raise ValueError( + f"Could not solve conservation law {law} for state {state}." + ) + substitutions.append((state, state_solutions[0])) + + for old_state, replacement in substitutions: + system_obj.f = [ode.subs(old_state, replacement) for ode in system_obj.f] + system_obj.h = _substitute_collection( + system_obj.h, [(old_state, replacement)] + ) + + system_obj.x = _delete_values(system_obj.x, state_indices) + system_obj.f = _delete_values(system_obj.f, state_indices) + system_obj.x_init = _delete_values(system_obj.x_init, state_indices) + if getattr(system_obj, "parameter_dependent_ic", False): + system_obj.ic_parameters = _delete_values( + system_obj.ic_parameters, state_indices + ) + if system_obj.C is not None: + c_array = np.asarray(system_obj.C) + if c_array.ndim == 1: + system_obj.C = np.delete(c_array, state_indices).tolist() + else: + system_obj.C = np.delete(c_array, state_indices, axis=1) + system_obj.n = len(system_obj.x) + return system_obj.f + + +def solve_conservation_laws( + system_obj, + conservation_laws=None, + total_quantities=None, + conserved_sets=None, + states_to_eliminate=None, + search_depth=None, + in_place=False, + **kwargs, +): + """Find and apply conservation laws to a `System`. + + Plain `System` inputs are converted to a `Reduce` working object + internally, so callers can pass a plain `System`. + """ + debug = kwargs.get("debug", False) + if not isinstance(system_obj, System): + raise TypeError("system_obj must be an AutoReduce System object.") + _add_total_quantities(system_obj, total_quantities) + reducible_system = _as_reducible(system_obj, in_place=in_place) + reducible_system.search_depth = search_depth + + if ( + search_depth is None + and conserved_sets is None + and conservation_laws is None + ): + raise ValueError( + "Pass conservation_laws, conserved_sets, or search_depth." + ) + + if conservation_laws is None: + if total_quantities is None: + raise ValueError( + "Pass total_quantities when deriving conservation_laws from " + "conserved_sets or search_depth." + ) + if conserved_sets is None: + conserved_sets = find_conserved_sets( + reducible_system, + search_depth=search_depth, + debug=debug, + ) + elif not conserved_sets: + raise ValueError("conserved_sets must not be empty.") + reducible_system.conserved_sets = conserved_sets + + conservation_laws = setup_conservation_laws( + reducible_system, total_quantities, conserved_sets + ) + if debug: + print("Found conservation laws:", conservation_laws) + else: + params = set([] if reducible_system.params is None else reducible_system.params) + states = set(reducible_system.x) + missing = sorted( + { + symbol + for law in conservation_laws + for symbol in law.free_symbols + if symbol not in states and symbol not in params + }, + key=str, + ) + if missing: + raise ValueError( + "Conservation laws contain undeclared parameter symbols " + f"{missing}. Pass total_quantities or add them to system.params." + ) + + reducible_system.total_quantities = total_quantities + reducible_system.conservation_laws = _unique_laws( + conservation_laws, debug=debug + ) + if states_to_eliminate is None: + states_to_eliminate = _choose_states_to_eliminate( + reducible_system, reducible_system.conservation_laws + ) + if debug: + print("Choosing states to eliminate:", states_to_eliminate) + reducible_system.states_to_eliminate = states_to_eliminate + reducible_system.f = apply_conservation_laws( + reducible_system, + conservation_laws=reducible_system.conservation_laws, + states_to_eliminate=reducible_system.states_to_eliminate, + ) + if in_place: + return reducible_system + + if hasattr(reducible_system, "get_system"): + conserved_system = reducible_system.get_system() + else: + conserved_system = reducible_system + for attr in ( + "search_depth", + "conserved_sets", + "total_quantities", + "conservation_laws", + "states_to_eliminate", + ): + if hasattr(reducible_system, attr): + setattr(conserved_system, attr, getattr(reducible_system, attr)) + return conserved_system diff --git a/autoreduce/reductions/core.py b/autoreduce/reductions/core.py new file mode 100644 index 0000000..f0adbad --- /dev/null +++ b/autoreduce/reductions/core.py @@ -0,0 +1,705 @@ +"""Core reduction objects and shared reduction utilities.""" + +import numpy as np +from scipy.linalg import block_diag, eigvals, norm, solve_lyapunov + +from autoreduce.solvers import utils as solver_utils +from autoreduce.system.system import System + +__all__ = [ + "Reduce", + "ReduceUtils", + "create_system", + "get_error_metric", + "get_reducible", + "get_robustness_metric", +] + + +class Reduce(System): + """ + Working system used to build and compare reduced models. + + The object stores reduction tolerances, candidate-reduction results, and + shared routines used by the specific reduction algorithms. + """ + + def __init__( + self, + x, + f, + params=None, + C=None, + g=None, + h=None, + u=None, + params_values=None, + x_init=None, + input_values=None, + timepoints_ode=None, + timepoints_ssm=None, + error_tol=None, + nstates_tol=None, + nstates_tol_min=None, + **kwargs, + ): + super().__init__( + x, + f, + params, + C, + g, + h, + u, + params_values, + x_init, + input_values, + timepoints_ode=timepoints_ode, + timepoints_ssm=timepoints_ssm, + **kwargs, + ) + self.f_hat = [] + self.nstates_tol = self.n - 1 if nstates_tol is None else nstates_tol + self.nstates_tol_min = ( + 1 if nstates_tol_min is None else nstates_tol_min + ) + self.error_tol = 1e6 if error_tol is None else error_tol + self.results_dict = {} + self.x_c = [] + + def get_output_states(self): + """Return state symbols that appear in the system output.""" + if self.C is None and self.h is None: + return [] + outputs = np.dot(np.array(self.C), np.array(self.x)) + if type(outputs) is not np.ndarray: + outputs = [outputs] + else: + outputs = outputs.tolist() + output_symbols = [list(i.free_symbols) for i in outputs] + return [item for sublist in output_symbols for item in sublist] + + def get_all_combinations(self): + """ + Return retained-state index sets allowed by the current tolerances. + + Candidate sets that exclude output states or exceed `nstates_tol` are + removed before returning. + """ + from itertools import combinations + + possible_reductions = [] + n = self.n + for i in range(n): + if i != n - 1: + comb = combinations(list(range(n)), i + 1) + possible_reductions.append(list(comb)) + possible_reductions = [ + list(item) for sublist in possible_reductions for item in sublist + ] + self.all_combinations = [i for i in possible_reductions] + output_states = self.get_output_states() + restart = False + x = self.x + for attempt in self.all_combinations: + states_attempt = [x[i] for i in attempt] + if ( + not len(set(states_attempt).intersection(set(output_states))) + == len(output_states) + or len(attempt) > self.nstates_tol + ): + restart = True + if restart: + possible_reductions.remove(attempt) + restart = False + + if self.u is not None: + for i, _ in enumerate(self.g): + if self.g[i] != 0 and i in possible_reductions: + possible_reductions.remove(i) + return possible_reductions + + def get_T(self, attempt): + """Construct transformation matrices for retained and collapsed states.""" + non_attempt = [i for i in range(self.n) if i not in attempt] + T = np.zeros((self.n, self.n)) + n_hat = len(attempt) + n = self.n + n_c = n - n_hat + T1 = np.zeros((self.n, n_hat)) + T2 = np.zeros((self.n, n_c)) + for ni in range(0, n_hat): + set_T = False + for i in range(n): + if i in attempt and not set_T: + T[ni, i] = 1 + attempt.remove(i) + set_T = True + for ni in range(n_hat, n): + set_T = False + for i in range(n): + if i in non_attempt and not set_T: + T[ni, i] = 1 + non_attempt.remove(i) + set_T = True + T1 = T[0:n, 0:n_hat] + T2 = T[0:n, n_hat : n + 1] # noqa: E203 + return T, T1, T2 + + def create_C_hat(self, x_hat): + """Return the linear output matrix for a reduced state vector.""" + if self.C is None: + return None + output_states = self.get_output_states() + C_hat = np.zeros((np.shape(self.C)[0], np.shape(x_hat)[0])) + is_output = 0 + for i in range(len(x_hat)): + if x_hat[i] in output_states: + is_output = 1 + for row_ind in range(np.shape(C_hat)[0]): + C_hat[row_ind][i] = 1 * is_output + return C_hat + + def get_error_metric_with_input(self, reduced_sys): + """Return the full-vs-reduced output error for systems with inputs.""" + if self.timepoints_ode is None: + raise ValueError( + "Set timepoints_ode before calling get_error_metric_with_input." + ) + reduced_ode = solver_utils.get_ODE(reduced_sys, self.timepoints_ode) + x_sol, _, _ = self.get_solutions() + y = self.C @ x_sol + x_sols_hat = reduced_ode.solve_system().T + y_hat = np.array(reduced_sys.C) @ np.array(x_sols_hat) + if np.shape(y) != np.shape(y_hat): + raise ValueError( + "The output dimensions must be the same for reduced and full " + "model. Choose C and C_hat accordingly." + ) + e = np.linalg.norm(y - y_hat) + if np.isnan(e): + print("The error is NaN, something wrong...continuing.") + return e + + def get_error_metric(self, reduced_sys): + """Return the full-vs-reduced output error.""" + if self.timepoints_ode is None: + raise ValueError( + "Set timepoints_ode before calling get_error_metric." + ) + reduced_ode = solver_utils.get_ODE(reduced_sys, self.timepoints_ode) + x_sol, _, _ = self.get_solutions() + y = self.C @ x_sol + x_sols_hat = reduced_ode.solve_system().T + y_hat = np.array(reduced_sys.C) @ np.array(x_sols_hat) + if np.shape(y) != np.shape(y_hat): + raise ValueError( + "The output dimensions must be the same for reduced and full " + "model. Choose C and C_hat accordingly." + ) + e = np.linalg.norm(y - y_hat) + if np.isnan(e): + print("The error is NaN, something wrong...continuing.") + return e + + def get_robustness_metric_with_input(self, reduced_sys): + """Return the robustness metric for systems with inputs.""" + return + + def get_robustness_metric(self, reduced_sys, **kwargs): + """Compute robustness metrics comparing full and reduced systems.""" + method = kwargs.get("method", "direct") + timepoints_ssm = self.timepoints_ssm + if timepoints_ssm is None: + raise ValueError( + "Pass timepoints_ssm to get_robustness_metric to specify " + "the timepoints for sensitivity computations." + ) + if self.timepoints_ode is None: + raise ValueError( + "Set timepoints_ode before calling get_robustness_metric." + ) + system_obj = self.get_system() + x_sols = solver_utils.get_ODE(system_obj, timepoints_ssm).solve_system().T + full_ssm = solver_utils.get_SSM(system_obj, timepoints_ssm) + S = full_ssm.compute_SSM() + self.S = S + reduced_ssm = solver_utils.get_SSM(reduced_sys, timepoints_ssm) + x_sols_hat = ( + solver_utils.get_ODE(reduced_sys, timepoints_ssm).solve_system().T + ) + x_sols = np.reshape(x_sols, (len(timepoints_ssm), self.n)) + x_sols_hat = np.reshape( + x_sols_hat, (len(timepoints_ssm), reduced_sys.n) + ) + Se = np.zeros(len(self.params_values)) + S_hat = reduced_ssm.compute_SSM() + reduced_sys.S = S_hat + S_bar = np.concatenate((S, S_hat), axis=2) + S_bar = np.reshape( + S_bar, + ( + len(timepoints_ssm), + self.n + reduced_sys.n, + len(self.params_values), + ), + ) + C_bar = np.concatenate((self.C, -1 * reduced_sys.C), axis=1) + C_bar = np.reshape( + C_bar, (np.shape(self.C)[0], (self.n + reduced_sys.n)) + ) + weighted_Se_sum = 0 + P_prev = None + prev_time = None + if method == "bound": + for j, _ in enumerate(self.params_values): + S_metric_max = 0 + sens_max = 0 + max_eig_P = 0 + max_eig_dot_P = 0 + for k in range(len(self.timepoints_ssm)): + curr_time = self.timepoints_ssm[k] + J = full_ssm.compute_J(x_sols[k, :]) + J_hat = reduced_ssm.compute_J(x_sols_hat[k, :]) + J_bar = block_diag(J, J_hat) + P = solve_lyapunov(J_bar, -1 * C_bar.T @ C_bar) + eig_P = max(eigvals(P)) + if max_eig_P < eig_P: + max_eig_P = eig_P + if k != 0: + dot_P = (P - P_prev) / (curr_time - prev_time) + eig_dot_P = max(eigvals(dot_P)) + if max_eig_dot_P < eig_dot_P: + max_eig_dot_P = eig_dot_P + Z = full_ssm.compute_Zj(x_sols[k, :], j) + Z_hat = reduced_ssm.compute_Zj(x_sols_hat[k, :], j) + Z_bar = np.concatenate((Z, Z_hat), axis=0) + Z_bar = np.reshape(Z_bar, ((self.n + reduced_sys.n), 1)) + S_metric = norm(Z_bar.T @ P @ S_bar[k, :, j]) + if S_metric > S_metric_max: + S_metric_max = S_metric + sens_norm = norm(S_bar[k, :, j]) ** 2 + if sens_norm > sens_max: + sens_max = sens_norm + P_prev = P + prev_time = curr_time + solver_utils.printProgressBar( + int(j + k * len(self.params_values)), + len(timepoints_ssm) * len(self.params_values) - 1, + prefix="Robustness Metric Progress:", + suffix="Complete", + length=50, + ) + dot_P_term = ( + max_eig_dot_P * len(reduced_ssm.timepoints) * sens_max + ) + Se[j] = ( + max_eig_P + + 2 * len(reduced_ssm.timepoints) * S_metric_max + + dot_P_term + ) + weighted_Se_sum += self.params_values[j] * Se[j] + elif method == "direct": + for j in range(len(self.params_values)): + Se[j] = norm(C_bar @ S_bar[:, :, j].T) + weighted_Se_sum += self.params_values[j] * Se[j] + err_norm = norm(self.get_error_metric(reduced_sys)) + R = 1 / (1 + (weighted_Se_sum / err_norm)) + reduced_sys.R = R + reduced_sys.Se = Se + return Se, R + + def get_solutions(self): + """Return full-model ODE, SSM-time ODE, and SSM objects.""" + if self.timepoints_ode is None: + raise ValueError( + "Set timepoints_ode before calling get_solutions." + ) + system_obj = self.get_system() + x_sol = solver_utils.get_ode_solutions( + system_obj, self.timepoints_ode + ) + if self.timepoints_ssm is None: + return x_sol, None, None + x_sol2 = solver_utils.get_ode_solutions( + system_obj, self.timepoints_ssm + ) + full_ssm = solver_utils.get_SSM(system_obj, self.timepoints_ssm) + return x_sol, x_sol2, full_ssm + + def find_conserved_sets(self, search_depth, **kwargs): + """Find conserved species sets using the conservation module.""" + from autoreduce.reductions.conservation import find_conserved_sets + + return find_conserved_sets(self, search_depth=search_depth, **kwargs) + + def setup_conservation_laws( + self, total_quantities: dict, conserved_sets: list + ): + """Create conservation-law expressions from conserved species sets.""" + from autoreduce.reductions.conservation import setup_conservation_laws + + return setup_conservation_laws(self, total_quantities, conserved_sets) + + def solve_conservation_laws( + self, + conservation_laws=None, + total_quantities=None, + conserved_sets=None, + states_to_eliminate=None, + search_depth=None, + **kwargs, + ): + """Apply conservation laws using the conservation module.""" + from autoreduce.reductions.conservation import solve_conservation_laws + + return solve_conservation_laws( + self, + conservation_laws=conservation_laws, + total_quantities=total_quantities, + conserved_sets=conserved_sets, + states_to_eliminate=states_to_eliminate, + search_depth=search_depth, + in_place=True, + **kwargs, + ) + + def set_conservation_laws(self, conservation_laws, states_to_eliminate): + """Apply conservation laws using the conservation module.""" + from autoreduce.reductions.conservation import apply_conservation_laws + + return apply_conservation_laws( + self, + conservation_laws=conservation_laws, + states_to_eliminate=states_to_eliminate, + ) + + def solve_approximations(self): + """Run abundance-based approximations from the abundance module.""" + from autoreduce.reductions.abundance import solve_approximations + + return solve_approximations(self) + + def solve_timescale_separation( + self, slow_states, fast_states=None, **kwargs + ): + """Solve a time-scale separation reduction.""" + from autoreduce.reductions.timescale import solve_timescale_separation + + return solve_timescale_separation( + self, + slow_states, + fast_states=fast_states, + in_place=True, + **kwargs, + ) + + def solve_timescale_separation_with_input(self, attempt_states): + """Solve time-scale separation for systems with inputs.""" + from autoreduce.reductions.timescale import ( + solve_timescale_separation_with_input, + ) + + return solve_timescale_separation_with_input( + self, attempt_states, in_place=True + ) + + def explore_all_QSS_models(self, **kwargs): + """Explore candidate QSS reductions for autonomous systems.""" + from autoreduce.reductions.timescale import explore_all_QSS_models + + return explore_all_QSS_models(self, in_place=True, **kwargs) + + def reduce_with_input(self): + """Compute candidate QSS reductions for systems with explicit inputs.""" + from autoreduce.reductions.timescale import reduce_with_input + + return reduce_with_input(self, in_place=True) + + def reduce_general(self): + """Return the placeholder result set for the general reduction path.""" + results_dict = {} + possible_reductions = self.get_all_combinations() + if not len(possible_reductions): + print("No possible reduced models found.") + print(" Try increasing tolerance for number of states.") + return + + self.results_dict = results_dict + return self.results_dict + + def compute_reduced_model(self): + """Dispatch to the reduction workflow matching the system structure.""" + if self.C is not None and self.g is None: + print("Using model reduction algorithm with y = Cx") + print(" linear output relationship and no inputs (g = 0).") + self.results_dict = self.explore_all_QSS_models() + return self.results_dict + print("Using general model reduction algorithm") + print(" with inputs and nonlinear output relationship") + self.results_dict = self.reduce_general() + return self.results_dict + + def get_system(self): + """Return the current reduction object as a base `System`.""" + return System( + self.x, + self.f, + params=self.params, + C=self.C, + g=self.g, + h=self.h, + u=self.u, + params_values=self.params_values, + x_init=self.x_init, + input_values=self.input_values, + timepoints_ode=self.timepoints_ode, + timepoints_ssm=self.timepoints_ssm, + parameter_dependent_ic=getattr( + self, "parameter_dependent_ic", False + ), + ic_parameters=getattr(self, "ic_parameters", None), + ) + + +class ReduceUtils(Reduce): + """Utility methods for reduction result objects.""" + + def __init__( + self, + x, + f, + params=None, + C=None, + g=None, + h=None, + u=None, + params_values=None, + x_init=None, + input_values=None, + timepoints_ode=None, + timepoints_ssm=None, + error_tol=None, + nstates_tol=None, + ): + super().__init__( + x=x, + f=f, + params=params, + C=C, + g=g, + h=h, + u=u, + params_values=params_values, + x_init=x_init, + input_values=input_values, + timepoints_ode=timepoints_ode, + timepoints_ssm=timepoints_ssm, + error_tol=error_tol, + nstates_tol=nstates_tol, + ) + + def write_results(self, filename): + """Write model reduction results to a text file.""" + from sympy.printing import latex + + with open(filename, "w") as f1: + f1.write("Model reduction results.\n") + for key, value in self.results_dict.items(): + f1.write("A possible reduced model: \n \n") + f1.write("\n$x_{hat} = ") + f1.write(str(key.x)) + f1.write("$\n\n\n\n") + for k in range(len(key.f)): + f1.write("\n$f_{hat}(" + str(k + 1) + ") = ") + f1.write(latex(key.f[k])) + f1.write("$\n\n") + f1.write("\n\n\n") + f1.write("\nError metric:") + f1.write(str(value[0])) + f1.write("\n\n\n") + f1.write("\nRobustness metric:") + f1.write(str(value[1])) + f1.write("\n\n\n") + f1.write("Other properties") + f1.write("\n\n\n") + f1.write("\n C = ") + f1.write(str(key.C)) + f1.write("\n$ g = ") + f1.write(str(key.g)) + f1.write("$\n h = ") + f1.write(str(key.h)) + if hasattr(key, "x_sol"): + f1.write("$\n Solutions : \n") + f1.write(str(key.x_sol)) + f1.write("\n\n\n\n") + f1.write("\n Sensitivity Solutions : \n") + f1.write(str(key.S)) + f1.write("\n\n\n\n") + + def get_valid_reduced_models(self, nstates_tol=None, error_tol=None): + """Return reduced models satisfying state-count and error tolerances.""" + if nstates_tol is None: + nstates_tol = self.nstates_tol + if error_tol is None: + error_tol = self.error_tol + valid_reduced_models = [] + results_dict = self.results_dict + for key, value in results_dict.items(): + error = value[0] + if error <= error_tol and len(key.x) <= nstates_tol: + valid_reduced_models.append(key) + self.valid_reduced_models = valid_reduced_models + return valid_reduced_models + + +def create_system( + x, + f, + params=None, + C=None, + g=None, + h=None, + u=None, + params_values=None, + x_init=None, + input_values=None, + timepoints_ode=None, + timepoints_ssm=None, + parameter_dependent_ic=False, + ic_parameters=None, +): + """Create a base `System` from symbolic model data.""" + return System( + x, + f=f, + params=params, + C=C, + g=g, + h=h, + u=u, + params_values=params_values, + x_init=x_init, + input_values=input_values, + timepoints_ode=timepoints_ode, + timepoints_ssm=timepoints_ssm, + parameter_dependent_ic=parameter_dependent_ic, + ic_parameters=ic_parameters, + ) + + +def _copy_model_value(value): + """Copy model containers without deep-copying symbolic expressions.""" + if value is None: + return None + if isinstance(value, np.ndarray): + return value.copy() + if isinstance(value, list): + return [ + item.copy() if isinstance(item, (list, np.ndarray)) else item + for item in value + ] + if isinstance(value, tuple): + return list(value) + return value + + +def get_reducible( + system_obj, timepoints_ode=None, timepoints_ssm=None, **kwargs +): + """Create a `Reduce` working object from a base `System`.""" + if not isinstance(system_obj, System): + raise TypeError("system_obj must be an AutoReduce System object.") + if timepoints_ode is None: + timepoints_ode = getattr(system_obj, "timepoints_ode", None) + if timepoints_ssm is None: + timepoints_ssm = getattr(system_obj, "timepoints_ssm", None) + + return Reduce( + _copy_model_value(system_obj.x), + _copy_model_value(system_obj.f), + C=_copy_model_value(system_obj.C), + params=_copy_model_value(system_obj.params), + g=_copy_model_value(system_obj.g), + h=_copy_model_value(system_obj.h), + u=_copy_model_value(system_obj.u), + params_values=_copy_model_value(system_obj.params_values), + x_init=_copy_model_value(system_obj.x_init), + input_values=_copy_model_value( + getattr(system_obj, "input_values", None) + ), + parameter_dependent_ic=getattr( + system_obj, "parameter_dependent_ic", False + ), + ic_parameters=_copy_model_value( + getattr(system_obj, "ic_parameters", None) + ), + timepoints_ode=_copy_model_value(timepoints_ode), + timepoints_ssm=_copy_model_value(timepoints_ssm), + **kwargs, + ) + + +def _as_reducible( + system_obj, + timepoints_ode=None, + timepoints_ssm=None, + in_place=False, + **kwargs, +): + """Return a `Reduce` object for direct reduction calls.""" + if in_place and isinstance(system_obj, Reduce): + if timepoints_ode is not None: + system_obj.timepoints_ode = timepoints_ode + if timepoints_ssm is not None: + system_obj.timepoints_ssm = timepoints_ssm + for option in ("error_tol", "nstates_tol", "nstates_tol_min"): + if option in kwargs and kwargs[option] is not None: + setattr(system_obj, option, kwargs[option]) + return system_obj + if in_place: + raise ValueError("in_place=True requires a Reduce object.") + if not isinstance(system_obj, System): + raise TypeError("system_obj must be an AutoReduce System object.") + return get_reducible( + system_obj, + timepoints_ode=timepoints_ode, + timepoints_ssm=timepoints_ssm, + **kwargs, + ) + + +def get_error_metric( + system_obj, + reduced_system, + timepoints_ode=None, + timepoints_ssm=None, + in_place=False, +): + """Compute the full-vs-reduced output error from systems.""" + reducible_system = _as_reducible( + system_obj, + timepoints_ode=timepoints_ode, + timepoints_ssm=timepoints_ssm, + in_place=in_place, + ) + return reducible_system.get_error_metric(reduced_system) + + +def get_robustness_metric( + system_obj, + reduced_system, + timepoints_ode=None, + timepoints_ssm=None, + in_place=False, + **kwargs, +): + """Compute robustness metrics from systems.""" + reducible_system = _as_reducible( + system_obj, + timepoints_ode=timepoints_ode, + timepoints_ssm=timepoints_ssm, + in_place=in_place, + ) + return reducible_system.get_robustness_metric(reduced_system, **kwargs) + diff --git a/autoreduce/reductions/projection/__init__.py b/autoreduce/reductions/projection/__init__.py new file mode 100644 index 0000000..30fd232 --- /dev/null +++ b/autoreduce/reductions/projection/__init__.py @@ -0,0 +1 @@ +"""Projection-based reduction methods.""" diff --git a/autoreduce/reductions/projection/dmd.py b/autoreduce/reductions/projection/dmd.py new file mode 100644 index 0000000..59b2f5e --- /dev/null +++ b/autoreduce/reductions/projection/dmd.py @@ -0,0 +1,89 @@ +"""Projection-based reduced models using PyDMD.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Optional + +import numpy as np + +try: + from pydmd import DMD, DMDc +except ImportError as exc: + raise ImportError( + "PyDMD is required for autoreduce.reductions.projection.dmd. " + "Install it with `pip install autoreduce[dmd]`." + ) from exc + + +@dataclass(frozen=True) +class DMDReduction: + """Fitted PyDMD model and the data used to construct it.""" + + model: object + snapshots: np.ndarray + control_inputs: Optional[np.ndarray] = None + + @property + def reduced_dimension(self) -> int: + """Return the number of DMD modes in the fitted model.""" + return int(self.model.modes.shape[1]) + + +def fit_dmd(snapshots, *, svd_rank: int, **dmd_options) -> DMDReduction: + """Fit a dynamic mode decomposition model to state snapshots. + + Parameters + ---------- + snapshots + State snapshot matrix accepted by `pydmd.DMD.fit`. + svd_rank + Rank passed directly to PyDMD. + dmd_options + Additional keyword arguments passed directly to `pydmd.DMD`. + + Returns + ------- + DMDReduction + Fitted PyDMD model and snapshot data. + """ + snapshot_array = np.asarray(snapshots) + model = DMD(svd_rank=svd_rank, **dmd_options) + model.fit(snapshot_array) + return DMDReduction(model=model, snapshots=snapshot_array) + + +def fit_dmdc( + snapshots, + control_inputs, + *, + svd_rank: int, + **dmdc_options, +) -> DMDReduction: + """Fit a dynamic mode decomposition with control model. + + Parameters + ---------- + snapshots + State snapshot matrix accepted by `pydmd.DMDc.fit`. + control_inputs + Input snapshot matrix accepted by `pydmd.DMDc.fit`. + svd_rank + Rank passed directly to PyDMD. + dmdc_options + Additional keyword arguments passed directly to `pydmd.DMDc`. + + Returns + ------- + DMDReduction + Fitted PyDMDc model, state snapshots, and control inputs. + """ + snapshot_array = np.asarray(snapshots) + control_array = np.asarray(control_inputs) + model = DMDc(svd_rank=svd_rank, **dmdc_options) + model.fit(snapshot_array, control_array) + return DMDReduction( + model=model, + snapshots=snapshot_array, + control_inputs=control_array, + ) diff --git a/autoreduce/reductions/timescale.py b/autoreduce/reductions/timescale.py new file mode 100644 index 0000000..11e1df9 --- /dev/null +++ b/autoreduce/reductions/timescale.py @@ -0,0 +1,453 @@ +"""Time-scale separation reduction methods.""" + +import warnings + +import numpy as np +import sympy +from sympy import Eq, solve + +from autoreduce.reductions.core import _as_reducible, create_system +from autoreduce.reductions.utils import ( + sympy_solve_and_substitute, + sympy_variables_exist, +) + +__all__ = [ + "explore_all_QSS_models", + "reduce_with_input", + "solve_timescale_separation", + "solve_timescale_separation_with_input", +] + + +def solve_timescale_separation( + system_obj, + slow_states, + fast_states=None, + timepoints_ode=None, + timepoints_ssm=None, + in_place=False, + **kwargs, +): + """Solve a time-scale separation reduction for a system.""" + reducible_system = _as_reducible( + system_obj, + timepoints_ode=timepoints_ode, + timepoints_ssm=timepoints_ssm, + in_place=in_place, + ) + return _solve_timescale_separation( + reducible_system, + slow_states, + fast_states=fast_states, + **kwargs, + ) + + +def _solve_timescale_separation( + reducible_system, slow_states, fast_states=None, **kwargs +): + debug = kwargs.get("debug", False) + if not slow_states: + return reducible_system.get_system(), None + x, f, x_init = ( + reducible_system.x, + reducible_system.f, + reducible_system.x_init, + ) + + len_slow_states = len(slow_states) + x_hat_init = [None] * len_slow_states + f_hat = [None] * len_slow_states + + max_len_fast_states = len(x) - len(slow_states) + x_c = [None] * max_len_fast_states + x_c_init = [None] * max_len_fast_states + f_c = [None] * max_len_fast_states + x_hat = slow_states + if fast_states: + x_c = fast_states + else: + count_x_c = 0 + for state in x: + if state not in slow_states: + x_c[count_x_c] = state + count_x_c += 1 + fast_states = x_c + + if len(slow_states) + len(fast_states) != len(reducible_system.x): + raise RuntimeError( + "Number of slow states plus number of fast states must equal " + "the number of total states." + ) + for state in slow_states: + if state in fast_states: + raise RuntimeError( + "Found a state that is both fast and slow. Pass disjoint " + "slow_states and fast_states." + ) + + for state in x: + state_index = x.index(state) + if state in x_c: + x_c_index = x_c.index(state) + f_c[x_c_index] = f[state_index] + if reducible_system.parameter_dependent_ic: + param_as_ic = reducible_system.ic_parameters[state_index] + reducible_system.set_ic_from_params( + x_c_init, param_as_ic, x_c_index + ) + else: + x_c_init[x_c_index] = x_init[state_index] + if state in x_hat: + x_hat_index = x_hat.index(state) + f_hat[x_hat_index] = f[state_index] + if reducible_system.parameter_dependent_ic: + param_as_ic = reducible_system.ic_parameters[state_index] + reducible_system.set_ic_from_params( + x_hat_init, param_as_ic, x_hat_index + ) + else: + x_hat_init[x_hat_index] = x_init[state_index] + reducible_system.f_hat = f_hat + reducible_system.f_c = f_c + if debug: + print("Reduced set of variables is", x_hat) + print("f_hat = ", reducible_system.f_hat) + print("Collapsed set of variables is", x_c) + + loop_sanity = True + count = 0 + solution_dict = {} + while ( + sympy_variables_exist( + ode_function=reducible_system.f_hat, variables_to_check=x_c + )[0] + and loop_sanity + ): + ( + reducible_system.f_hat, + solution_dict, + reducible_system.f_c, + ) = sympy_solve_and_substitute( + ode_function=reducible_system.f_hat, + collapsed_states=x_c, + collapsed_dynamics=reducible_system.f_c, + solution_dict=solution_dict, + debug=debug, + ) + if count > 2: + warnings.warn( + "Solve time-scale separation failed. Check model consistency." + ) + print( + f"Did not work to retain: {slow_states} because either a " + "collapsed state variable appears" + ) + print(" in the reduced model or a solution is not possible.") + loop_sanity = False + return None, None + count += 1 + + for i, _ in enumerate(x_hat): + for j, _ in enumerate(reducible_system.f_c): + reducible_system.f_c[j] = reducible_system.f_c[j].subs( + x_hat[i], x_hat_init[i] + ) + + C_hat = reducible_system.create_C_hat(x_hat) + for index, _ in enumerate(f_hat): + f_hat[index] = sympy.simplify(f_hat[index]) + for index, _ in enumerate(f_c): + f_c[index] = sympy.simplify(f_c[index]) + reduced_sys = create_system( + x_hat, + reducible_system.f_hat, + params=reducible_system.params, + C=C_hat, + params_values=reducible_system.params_values, + x_init=x_hat_init, + timepoints_ode=reducible_system.timepoints_ode, + timepoints_ssm=reducible_system.timepoints_ssm, + ) + fast_subsystem = create_system( + x_c, + reducible_system.f_c, + params=reducible_system.params, + params_values=reducible_system.params_values, + x_init=x_c_init, + timepoints_ode=reducible_system.timepoints_ode, + timepoints_ssm=reducible_system.timepoints_ssm, + ) + reduced_sys.fast_states = fast_states + print(f"Successful solution obtained with states: {reduced_sys.x}!") + return reduced_sys, fast_subsystem + + +def solve_timescale_separation_with_input( + system_obj, + attempt_states, + timepoints_ode=None, + timepoints_ssm=None, + in_place=False, +): + """Solve time-scale separation for a system with explicit inputs.""" + reducible_system = _as_reducible( + system_obj, + timepoints_ode=timepoints_ode, + timepoints_ssm=timepoints_ssm, + in_place=in_place, + ) + return _solve_timescale_separation_with_input( + reducible_system, attempt_states + ) + + +def _solve_timescale_separation_with_input(reducible_system, attempt_states): + attempt = [] + for state in attempt_states: + attempt.append(reducible_system.x.index(state)) + print("attempting to retain:", attempt) + x_c = [] + fast_states = [] + f_c = [] + f_hat = [] + x_hat_init = [] + x_c_init = [] + x_hat = [] + x, f, g, u, x_init = ( + reducible_system.x, + reducible_system.f, + reducible_system.g, + reducible_system.u, + reducible_system.x_init, + ) + f_g = [fi + gi for fi, gi in zip(f, g)] + for i in range(reducible_system.n): + if i not in attempt: + x_c.append(x[i]) + f_c.append(f_g[i]) + x_c_init.append(x_init[i]) + else: + f_hat.append(f_g[i]) + x_hat.append(x[i]) + x_hat_init.append(x_init[i]) + + solved_states = [] + lookup_collapsed = {} + for i, _ in enumerate(x_c): + x_c_sub = solve(Eq(f_c[i], 0), x_c[i]) + lookup_collapsed[x_c[i]] = x_c_sub + if len(x_c_sub) == 0: + fast_states.append([]) + continue + elif len(x_c_sub) > 1: + for sub in x_c_sub: + if sub == 0: + x_c_sub.remove(0) + else: + for sym in x_c_sub[0].free_symbols: + if sym in solved_states and sym in x: + f_c[i] = f_c[i].subs(sym, lookup_collapsed[sym][0]) + x_c_sub = solve(Eq(f_c[i], 0), x_c[i]) + if len(x_c_sub) > 1: + print("Multiple solutions obtained.") + print("Choosing non-zero solution, check consistency.") + print(" The solutions are ", x_c_sub) + for sub in x_c_sub: + if sub == 0: + x_c_sub.remove(0) + lookup_collapsed[x_c[i]] = x_c_sub + else: + solved_states.append(x_c[i]) + fast_states.append(x_c_sub[0]) + + for i in range(len(fast_states)): + if fast_states[i] == []: + continue + for j in range(len(f_hat)): + f_hat[j] = f_hat[j].subs(x_c[i], fast_states[i]) + for j in range(len(f_c)): + f_c[j] = f_c[j].subs(x_c[i], fast_states[i]) + + for i in range(len(x_hat)): + for j in range(len(f_c)): + f_c[j] = f_c[j].subs(x_hat[i], x_hat_init[i]) + + output_states = reducible_system.get_output_states() + C_hat = np.zeros((np.shape(reducible_system.C)[0], np.shape(x_hat)[0])) + is_output = 0 + for i in range(len(x_hat)): + if x_hat[i] in output_states: + is_output = 1 + for row_ind in range(np.shape(C_hat)[0]): + C_hat[row_ind][i] = 1 * is_output + + flag = False + free_symbols_all = [] + for fi in f_hat: + fi = sympy.sympify(fi) + for sym in fi.free_symbols: + if sym not in free_symbols_all: + free_symbols_all.append(sym) + bugged_states = [] + for syms in free_symbols_all: + if syms not in x_hat + u + reducible_system.params: + bugged_states.append(syms) + flag = True + if flag: + warnings.warn("Check model consistency") + print( + f"The time-scale separation that retains states {attempt}, " + "does not work" + ) + print( + f"because the state variables {bugged_states} appear in the " + "reduced model" + ) + + reduced_sys = create_system( + x_hat, + f_hat, + params=reducible_system.params, + C=C_hat, + params_values=reducible_system.params_values, + x_init=x_hat_init, + timepoints_ode=reducible_system.timepoints_ode, + timepoints_ssm=reducible_system.timepoints_ssm, + ) + fast_subsystem = create_system( + x_c, + f_c, + params=reducible_system.params, + params_values=reducible_system.params_values, + x_init=x_c_init, + timepoints_ode=reducible_system.timepoints_ode, + timepoints_ssm=reducible_system.timepoints_ssm, + ) + reduced_sys.x_c = x_c + reduced_sys.bugged_states = bugged_states + reduced_sys.fast_states = fast_states + return reduced_sys, fast_subsystem + + +def explore_all_QSS_models( + system_obj, + timepoints_ode=None, + timepoints_ssm=None, + in_place=False, + **kwargs, +): + """Explore candidate QSS reductions for an autonomous system. + + When ``skip_numerical_computations`` is ``False``, both + ``timepoints_ode`` and ``timepoints_ssm`` must be provided because the + user indicated to compute all metrics. ``timepoints_ode`` is used for + accuracy and ``timepoints_ssm`` is used for robustness computation. + """ + constructor_kwargs = {} + for option in ("error_tol", "nstates_tol", "nstates_tol_min"): + if option in kwargs: + constructor_kwargs[option] = kwargs.pop(option) + reducible_system = _as_reducible( + system_obj, + timepoints_ode=timepoints_ode, + timepoints_ssm=timepoints_ssm, + in_place=in_place, + **constructor_kwargs, + ) + skip_numerical_computations = kwargs.get( + "skip_numerical_computations", False + ) + skip_error_computation = kwargs.get("skip_error_computation", False) + skip_robustness_computation = kwargs.get( + "skip_robustness_computation", False + ) + if not skip_numerical_computations and ( + reducible_system.timepoints_ode is None + or reducible_system.timepoints_ssm is None + ): + raise ValueError( + "timepoints_ode and timepoints_ssm are needed when " + "skip_numerical_computations=False because the user indicated to " + "compute all metrics. timepoints_ode is used for accuracy and " + "timepoints_ssm is used for robustness computation." + ) + if reducible_system.u is not None: + raise ValueError("For models with inputs use reduce_with_input.") + results_dict = {} + possible_reductions = reducible_system.get_all_combinations() + if not len(possible_reductions): + print("No possible reduced models found.") + print(" Try increasing tolerance for number of states.") + return + for attempt in possible_reductions: + if len(attempt) < reducible_system.nstates_tol_min: + continue + elif len(attempt) > reducible_system.nstates_tol: + continue + attempt_states = [reducible_system.x[i] for i in attempt] + reduced_sys, fast_subsystem = _solve_timescale_separation( + reducible_system, attempt_states, **kwargs + ) + if reduced_sys is None or fast_subsystem is None: + continue + if skip_numerical_computations: + results_dict[reduced_sys] = None + else: + if skip_error_computation: + e = np.nan + else: + e = reducible_system.get_error_metric(reduced_sys) + if skip_robustness_computation: + Se = np.nan + R = np.nan + else: + Se, R = reducible_system.get_robustness_metric( + reduced_sys, **kwargs + ) + results_dict[reduced_sys] = [e, Se, R] + reducible_system.results_dict = results_dict + return reducible_system.results_dict + + +def reduce_with_input( + system_obj, + timepoints_ode=None, + timepoints_ssm=None, + in_place=False, + **kwargs, +): + """Compute candidate QSS reductions for systems with explicit inputs.""" + constructor_kwargs = {} + for option in ("error_tol", "nstates_tol", "nstates_tol_min"): + if option in kwargs: + constructor_kwargs[option] = kwargs.pop(option) + reducible_system = _as_reducible( + system_obj, + timepoints_ode=timepoints_ode, + timepoints_ssm=timepoints_ssm, + in_place=in_place, + **constructor_kwargs, + ) + if reducible_system.u is None: + raise ValueError("For models with no inputs use explore_all_QSS_models.") + results_dict = {} + possible_reductions = reducible_system.get_all_combinations() + if not len(possible_reductions): + print("No possible reduced models found.") + print(" Try increasing tolerance for number of states.") + return + for attempt in possible_reductions: + attempt_states = [reducible_system.x[i] for i in attempt] + reduced_sys, fast_subsystem = _solve_timescale_separation_with_input( + reducible_system, attempt_states + ) + if reduced_sys is None or fast_subsystem is None: + continue + e = reducible_system.get_error_metric_with_input(reduced_sys) + Se, R = reducible_system.get_robustness_metric_with_input(reduced_sys) + results_dict[reduced_sys] = [e, Se, R] + reducible_system.results_dict = results_dict + return reducible_system.results_dict + diff --git a/autoreduce/reductions/utils.py b/autoreduce/reductions/utils.py new file mode 100644 index 0000000..0fe5815 --- /dev/null +++ b/autoreduce/reductions/utils.py @@ -0,0 +1,122 @@ +"""Symbolic helper functions for reduction algorithms.""" + +import warnings + +import sympy +from sympy import Eq, solve + +__all__ = [ + "sympy_get_steady_state_solutions", + "sympy_solve_and_substitute", + "sympy_variables_exist", +] + + +def sympy_variables_exist(ode_function, variables_to_check, **kwargs): + """Check whether variables appear in symbolic ODE expressions.""" + flag = False + all_free_symbols = [] + debug = kwargs.get("debug", False) + if debug: + print( + "In sympy_variables_exist. Checking for presence of ", + variables_to_check, + ) + for fi in ode_function: + fi = sympy.sympify(fi) + for sym in fi.free_symbols: + if sym not in all_free_symbols: + all_free_symbols.append(sym) + + variables_that_appear = [] + for sym in all_free_symbols: + if sym in variables_to_check: + variables_that_appear.append(sym) + flag = True + if flag and debug: + print("Found! The following: ", variables_that_appear) + return flag, variables_that_appear + + +def sympy_solve_and_substitute( + ode_function, + collapsed_states, + collapsed_dynamics, + solution_dict, + debug=False, +): + """Solve collapsed-state equations and substitute into ODEs.""" + for state in collapsed_states: + index = collapsed_states.index(state) + dynamics = collapsed_dynamics[index] + if debug: + print("In sympy_solve_and_substitute, solving for ", state) + print("From ", dynamics) + solution_dict = sympy_get_steady_state_solutions( + collapsed_variables=[state], + collapsed_dynamics=[dynamics], + solution_dict=solution_dict, + debug=debug, + ) + if debug: + print("Solution found: ", solution_dict) + print("current state", state) + if solution_dict[state] is None or len(solution_dict[state]) == 0: + continue + for func in ode_function: + func = sympy.sympify(func) + func_index = ode_function.index(func) + ode_function[func_index] = func.subs( + state, solution_dict[state][0] + ) + for func in collapsed_dynamics: + if func == dynamics: + continue + func_index = collapsed_dynamics.index(func) + collapsed_dynamics[func_index] = func.subs( + state, solution_dict[state][0] + ) + if debug: + print("Updated f_hat now is ", ode_function) + return ode_function, solution_dict, collapsed_dynamics + + +def sympy_get_steady_state_solutions( + collapsed_variables, collapsed_dynamics, solution_dict=None, debug=False +): + """ + Solve each collapsed variable from its steady-state equation. + + Returns a dictionary mapping each collapsed variable to the SymPy + solutions found for that variable. + """ + if solution_dict is None: + solution_dict = {} + x_c = collapsed_variables + f_c = collapsed_dynamics + for i, _ in enumerate(x_c): + x_c_sub = solve(Eq(f_c[i], 0), x_c[i]) + if x_c_sub is None or len(x_c_sub) == 0: + print(f"Could not find solution for: {x_c[i]} from {f_c[i]}") + warnings.warn( + "Solve time-scale separation failed. Check model consistency." + ) + elif len(x_c_sub) > 1: + if debug: + print(f"Multiple solutions obtained for {x_c[i]}.") + print("Choosing one non-zero solution, check consistency. ") + print(f"The solutions are {x_c_sub}.") + print(" Highly recommend manually solving for this") + print(" variable first then try this function.") + for sub in x_c_sub: + if sub == 0: + x_c_sub.remove(0) + elif not any(x_c_sub): + warnings.warn( + "Solve time-scale separation failed. Check model consistency." + ) + if debug: + warnings.warn(f"Zero solution(s) for: {x_c[i]} from {f_c[i]}.") + solution_dict[x_c[i]] = x_c_sub + return solution_dict + diff --git a/autoreduce/solvers/__init__.py b/autoreduce/solvers/__init__.py new file mode 100644 index 0000000..8602a71 --- /dev/null +++ b/autoreduce/solvers/__init__.py @@ -0,0 +1,25 @@ +"""Numerical solvers for AutoReduce systems.""" + +from autoreduce.solvers.ode import ODE +from autoreduce.solvers.ssm import SSM +from autoreduce.solvers.utils import ( + get_ODE, + get_ode_solutions, + get_SSM, + solve_ode, + solve_ODE_SSM, + solve_sensitivity, + solve_ssm, +) + +__all__ = [ + "ODE", + "SSM", + "get_ODE", + "get_SSM", + "get_ode_solutions", + "solve_ODE_SSM", + "solve_ode", + "solve_sensitivity", + "solve_ssm", +] diff --git a/autoreduce/ode.py b/autoreduce/solvers/ode.py similarity index 85% rename from autoreduce/ode.py rename to autoreduce/solvers/ode.py index 5460b5d..38ad94c 100644 --- a/autoreduce/ode.py +++ b/autoreduce/solvers/ode.py @@ -1,12 +1,12 @@ -"""ODE class""" +"""Numerical solvers for ordinary differential equation systems.""" import time # type: ignore import numpy as np # type: ignore -from sympy import lambdify # type: ignore from scipy.integrate import odeint # type: ignore +from sympy import lambdify # type: ignore -from .system import System +from autoreduce.system.system import System class ODE(System): @@ -51,6 +51,7 @@ def solve_system(self, **kwargs): fun = lambdify((self.x, self.params), self.f) def fun_ode(t, x, params): + """Evaluate the lambdified autonomous ODE right-hand side.""" y = fun(x, params) return np.array(y) @@ -85,6 +86,7 @@ def solve_system_with_inputs(self, **kwargs): fun = lambdify((self.x, self.u, self.params), f_g) def fun_ode(t, x, u, params): + """Evaluate the lambdified input-dependent ODE right-hand side.""" y = fun(x, u, params) return np.array(y) @@ -118,11 +120,12 @@ def get_system(self): return System( self.x, self.f, - self.params, - self.C, - self.g, - self.h, - self.u, - self.params_values, - self.x_init, + params=self.params, + C=self.C, + g=self.g, + h=self.h, + u=self.u, + params_values=self.params_values, + x_init=self.x_init, + input_values=self.input_values, ) diff --git a/autoreduce/local_sensitivity.py b/autoreduce/solvers/ssm.py similarity index 93% rename from autoreduce/local_sensitivity.py rename to autoreduce/solvers/ssm.py index 630713f..3cbeac0 100644 --- a/autoreduce/local_sensitivity.py +++ b/autoreduce/solvers/ssm.py @@ -1,11 +1,10 @@ -"""Local sensitivity analysis module.""" +"""Local sensitivity analysis solvers.""" import numpy as np # type: ignore -from scipy.integrate import solve_ivp, odeint # type: ignore +from scipy.integrate import odeint, solve_ivp # type: ignore from sympy import lambdify # type: ignore -from autoreduce import utils -from .system import System +from autoreduce.system.system import System class SSM(System): @@ -126,6 +125,7 @@ def compute_J(self, x, **kwargs): fun_l = lambdify((self.x, self.params), fun) def fun_ode(t, x, params): + """Evaluate the lambdified function for numeric Jacobians.""" y = fun_l(x, params) return np.array(y) @@ -193,6 +193,7 @@ def compute_SSM(self, normalize=False, **kwargs): return self.solve_extended_ode(**kwargs) def sens_func(t, x, J, Z): + """Evaluate the sensitivity ODE for a fixed Jacobian and Z term.""" # forms ODE to solve for sensitivity coefficient S dsdt = J @ x + Z return dsdt @@ -201,8 +202,10 @@ def sens_func(t, x, J, Z): S0 = np.zeros(self.n) # Initial value for S_i SSM = np.zeros((len(self.timepoints), len(P), self.n)) # solve for all x's in timeframe set by timepoints + from autoreduce.solvers.utils import get_ODE, printProgressBar + system_obj = self.get_system() - sol = utils.get_ODE(system_obj, self.timepoints).solve_system().T + sol = get_ODE(system_obj, self.timepoints).solve_system().T xs = sol xs = np.reshape(xs, (len(self.timepoints), self.n)) self.xs = xs @@ -217,7 +220,7 @@ def sens_func(t, x, J, Z): # Solve for S = dx/dp for all x and all P # (or theta, the parameters) at time point k for j in range(len(P)): - utils.printProgressBar( + printProgressBar( int(j + k * len(P)), len(self.timepoints) * len(P) - 1, prefix="SSM Progress:", @@ -230,6 +233,7 @@ def sens_func(t, x, J, Z): # solve for S def sens_func_ode(t, x): + """Evaluate the sensitivity ODE closure passed to odeint.""" return sens_func(t, x, J, Zj) sol = odeint(sens_func_ode, S0, timepoints, tfirst=True) @@ -261,16 +265,18 @@ def normalize_SSM(self): return SSM_normalized def get_system(self): + """Return the sensitivity solver state as a base `System`.""" return System( self.x, self.f, - self.params, - self.C, - self.g, - self.h, - self.u, - self.params_values, - self.x_init, + params=self.params, + C=self.C, + g=self.g, + h=self.h, + u=self.u, + params_values=self.params_values, + x_init=self.x_init, + input_values=self.input_values, ) """ Code contributed by Sam Clamons below """ @@ -358,6 +364,7 @@ def solve_extended_ode( # Solve ODE. def ode_func(t, xs): + """Evaluate the original ODE with fixed parameter values.""" return ode(t, xs, params) ode_jac = nd.Jacobian(lambda x: ode_func(0, x)) diff --git a/autoreduce/solvers/utils.py b/autoreduce/solvers/utils.py new file mode 100644 index 0000000..4fac10d --- /dev/null +++ b/autoreduce/solvers/utils.py @@ -0,0 +1,178 @@ +"""Convenience functions for AutoReduce solvers.""" + +import numpy as np + + +def get_ODE(system_obj, timepoints, **kwargs): + """Create an ODE solver for a system.""" + from autoreduce.solvers.ode import ODE + + return ODE( + system_obj.x, + system_obj.f, + C=system_obj.C, + g=system_obj.g, + h=system_obj.h, + u=system_obj.u, + params=system_obj.params, + params_values=system_obj.params_values, + x_init=system_obj.x_init, + timepoints=timepoints, + **kwargs, + ) + + +def solve_ode(system_obj, timepoints, **kwargs): + """Solve a system over the given timepoints.""" + return get_ODE(system_obj, timepoints).solve_system(**kwargs) + + +def solve_ODE_SSM(system_obj, timepoints_ode, timepoints_ssm, **kwargs): + """Return state, output, and local sensitivity solutions.""" + ode = get_ODE(system_obj, timepoints_ode) + x_sol = ode.solve_system().T + y = system_obj.C @ x_sol + sensitivities = solve_sensitivity(system_obj, timepoints_ssm, **kwargs) + return x_sol, y, sensitivities + + +def get_SSM(system_obj, timepoints, **kwargs): + """Create an SSM solver for a system.""" + from autoreduce.solvers.ssm import SSM + + return SSM( + system_obj.x, + system_obj.f, + g=system_obj.g, + C=system_obj.C, + h=system_obj.h, + u=system_obj.u, + params=system_obj.params, + params_values=system_obj.params_values, + x_init=system_obj.x_init, + timepoints=timepoints, + **kwargs, + ) + + +def solve_sensitivity(system_obj, timepoints, normalize=False, **kwargs): + """Solve the coupled state and local sensitivity equations.""" + from scipy.integrate import odeint + from sympy import Matrix, lambdify + + x_symbols = list(system_obj.x) + param_symbols = [] if system_obj.params is None else list(system_obj.params) + n_states = len(x_symbols) + n_params = len(param_symbols) + if n_params == 0: + return np.zeros((len(timepoints), 0, n_states)) + + f_matrix = Matrix(system_obj.f) + jacobian = f_matrix.jacobian(x_symbols) + parameter_jacobian = f_matrix.jacobian(param_symbols) + rhs = lambdify( + (x_symbols, param_symbols), + (f_matrix, jacobian, parameter_jacobian), + modules="numpy", + ) + + params_values = list(system_obj.params_values) + sensitivity_init = np.zeros((n_states, n_params)) + if getattr(system_obj, "parameter_dependent_ic", False): + ic_parameters = getattr(system_obj, "ic_parameters", None) + if ic_parameters is not None: + for state_index, ic_parameter in enumerate(ic_parameters): + if ic_parameter in param_symbols: + param_index = param_symbols.index(ic_parameter) + sensitivity_init[state_index, param_index] = 1.0 + + y0 = np.concatenate( + [ + np.asarray(system_obj.x_init, dtype=float), + sensitivity_init.reshape(n_states * n_params), + ] + ) + + def extended_rhs(t, y): + state = y[:n_states] + sensitivity = y[n_states:].reshape((n_states, n_params)) + f_eval, jacobian_eval, parameter_jacobian_eval = rhs( + state, params_values + ) + f_eval = np.asarray(f_eval, dtype=float).reshape(n_states) + jacobian_eval = np.asarray(jacobian_eval, dtype=float).reshape( + n_states, n_states + ) + parameter_jacobian_eval = np.asarray( + parameter_jacobian_eval, dtype=float + ).reshape(n_states, n_params) + sensitivity_rhs = jacobian_eval @ sensitivity + parameter_jacobian_eval + return np.concatenate( + [f_eval, sensitivity_rhs.reshape(n_states * n_params)] + ) + + solution = odeint(extended_rhs, y0, timepoints, tfirst=True, **kwargs) + state_solution = solution[:, :n_states] + sensitivities = solution[:, n_states:].reshape( + len(timepoints), n_states, n_params + ) + sensitivities = np.transpose(sensitivities, (0, 2, 1)) + + if normalize: + normalized = np.zeros_like(sensitivities) + for param_index, param_value in enumerate(params_values): + numerator = sensitivities[:, param_index, :] * param_value + normalized[:, param_index, :] = np.divide( + numerator, + state_solution, + out=np.zeros_like(numerator), + where=state_solution != 0, + ) + return normalized + return sensitivities + + +def solve_ssm(system_obj, timepoints, normalize=False, **kwargs): + """Compute the local sensitivity matrix for a system.""" + return solve_sensitivity( + system_obj, timepoints, normalize=normalize, **kwargs + ) + + +def get_ode_solutions(system_obj, timepoints, **kwargs): + """Solve a system over time and return transposed state trajectories.""" + return get_ODE(system_obj, timepoints, **kwargs).solve_system().T + + +def printProgressBar( + iteration, total, prefix="", suffix="", decimals=1, length=100, fill="#" +): + """ + Print a terminal progress bar. + + Parameters + ---------- + iteration + Current iteration. + total + Total number of iterations. + prefix + Text printed before the bar. + suffix + Text printed after the percentage. + decimals + Number of decimal places in the percentage. + length + Character length of the bar. + fill + Character used for the filled part of the bar. + """ + percent = ("{0:." + str(decimals) + "f}").format( + 100 * (iteration / float(total)) + ) + filledLength = int(length * iteration // total) + bar = fill * filledLength + "-" * (length - filledLength) + print("\r%s |%s| %s%% %s" % (prefix, bar, percent, suffix), end="\r") + if iteration == total: + print() + diff --git a/autoreduce/system/__init__.py b/autoreduce/system/__init__.py new file mode 100644 index 0000000..bdd1e60 --- /dev/null +++ b/autoreduce/system/__init__.py @@ -0,0 +1,6 @@ +"""System model representations and import adapters.""" + +from autoreduce.system.pydmd import from_dmd_model, from_linear_operator +from autoreduce.system.system import System + +__all__ = ["System", "from_dmd_model", "from_linear_operator"] diff --git a/autoreduce/system/control.py b/autoreduce/system/control.py new file mode 100644 index 0000000..db19e26 --- /dev/null +++ b/autoreduce/system/control.py @@ -0,0 +1,122 @@ +"""Conversion from python-control input/output systems.""" + +from __future__ import annotations + +from collections.abc import Sequence +from typing import Optional + +import numpy as np + +try: + import control as ct +except ImportError as exc: + raise ImportError( + "python-control is required for autoreduce.system.control. " + "Install it with `pip install autoreduce[control]`." + ) from exc + +from autoreduce.system.system import System + + +def from_nonlinear_io_system( + io_system: ct.NonlinearIOSystem, + state_symbols: Sequence, + *, + params: Optional[Sequence] = None, + params_values: Optional[Sequence] = None, + input_symbols: Optional[Sequence] = None, + input_values: Optional[Sequence] = None, + x_init: Optional[Sequence] = None, + output_matrix=None, + time=0, +) -> System: + """Create an AutoReduce `System` from a `NonlinearIOSystem`. + + Parameters + ---------- + io_system + python-control nonlinear input/output system. + state_symbols + Symbolic states used by AutoReduce. + params + Symbolic parameters passed to the python-control update and output + functions by string name. + params_values + Numeric parameter values in the same order as `params`. + input_symbols + Symbolic input variables. Required when `io_system` has inputs. + input_values + Numeric input values in the same order as `input_symbols`. + x_init + Initial conditions in the same order as `state_symbols`. + output_matrix + Linear output matrix. Cannot be supplied when `io_system` defines a + nonlinear output function. + time + Time value used when evaluating the symbolic update and output + functions. + + Returns + ------- + System + AutoReduce system with symbolic dynamics from `io_system`. + """ + if not isinstance(io_system, ct.NonlinearIOSystem): + raise TypeError("io_system must be a control.NonlinearIOSystem.") + if io_system.updfcn is None: + raise ValueError("io_system must define an update function.") + + states = list(state_symbols) + if len(states) != io_system.nstates: + raise ValueError("state_symbols length must equal io_system.nstates.") + + params = [] if params is None else list(params) + params_values = [] if params_values is None else list(params_values) + if len(params) != len(params_values): + raise ValueError("params and params_values must have the same length.") + + if io_system.ninputs: + if input_symbols is None: + raise ValueError("input_symbols are required for systems with inputs.") + inputs = list(input_symbols) + if len(inputs) != io_system.ninputs: + raise ValueError("input_symbols length must equal io_system.ninputs.") + else: + inputs = None + + if input_values is not None and inputs is None: + raise ValueError("input_values require input_symbols.") + if input_values is not None and len(input_values) != len(inputs): + raise ValueError("input_values length must equal input_symbols length.") + + if x_init is not None and len(x_init) != io_system.nstates: + raise ValueError("x_init length must equal io_system.nstates.") + + if output_matrix is not None and io_system.outfcn is not None: + raise ValueError( + "output_matrix cannot be supplied when io_system defines outfcn." + ) + + control_params = {str(param): param for param in params} + state_vector = np.asarray(states, dtype=object) + input_vector = np.asarray([] if inputs is None else inputs, dtype=object) + dynamics = list(io_system.updfcn(time, state_vector, input_vector, control_params)) + + output_function = None + if io_system.outfcn is not None: + output_function = list( + io_system.outfcn(time, state_vector, input_vector, control_params) + ) + + return System( + states, + dynamics, + params=params, + params_values=params_values, + C=output_matrix, + g=None, + h=output_function, + u=inputs, + input_values=input_values, + x_init=x_init, + ) diff --git a/autoreduce/system/pydmd.py b/autoreduce/system/pydmd.py new file mode 100644 index 0000000..18af6b3 --- /dev/null +++ b/autoreduce/system/pydmd.py @@ -0,0 +1,120 @@ +"""Conversion from PyDMD-style linear operators.""" + +from __future__ import annotations + +from collections.abc import Sequence +from typing import Optional + +import numpy as np +from sympy import Matrix, symbols + +try: + import pydmd as _pydmd # noqa: F401 +except ImportError: + _pydmd = None + +from autoreduce.system.system import System + +__all__ = ["from_dmd_model", "from_linear_operator"] + + +def from_linear_operator( + operator, + state_symbols: Optional[Sequence] = None, + *, + params: Optional[Sequence] = None, + params_values: Optional[Sequence] = None, + x_init: Optional[Sequence] = None, + output_matrix=None, + timepoints_ode=None, + timepoints_ssm=None, + discrete_time=True, +) -> System: + """Create a `System` from a linear DMD operator matrix. + + PyDMD operators are discrete-time maps by default. With + `discrete_time=True`, the returned dynamics are `(A - I) x`, which is the + unit-step state increment. Set `discrete_time=False` when the operator is + already a continuous-time linear dynamics matrix. + """ + operator_array = np.asarray(operator, dtype=object) + if operator_array.ndim != 2 or operator_array.shape[0] != operator_array.shape[1]: + raise ValueError("operator must be a square matrix.") + + n_states = operator_array.shape[0] + if state_symbols is None: + states = list(symbols(f"x0:{n_states}")) + else: + states = list(state_symbols) + if len(states) != n_states: + raise ValueError("state_symbols length must match operator dimension.") + + if discrete_time: + operator_array = operator_array - np.eye(n_states, dtype=object) + + dynamics = list(Matrix(operator_array) * Matrix(states)) + return System( + states, + dynamics, + params=[] if params is None else list(params), + params_values=[] if params_values is None else list(params_values), + C=output_matrix, + x_init=None if x_init is None else list(x_init), + timepoints_ode=timepoints_ode, + timepoints_ssm=timepoints_ssm, + ) + + +def from_dmd_model( + dmd_model, + state_symbols: Optional[Sequence] = None, + *, + params: Optional[Sequence] = None, + params_values: Optional[Sequence] = None, + x_init: Optional[Sequence] = None, + output_matrix=None, + timepoints_ode=None, + timepoints_ssm=None, + discrete_time=True, +) -> System: + """Create a `System` from a fitted PyDMD model.""" + if _pydmd is None: + raise ImportError( + "PyDMD is required for autoreduce.system.pydmd.from_dmd_model. " + "Install it with `pip install autoreduce[dmd]`." + ) + operator = _extract_operator(dmd_model) + return from_linear_operator( + operator, + state_symbols, + params=params, + params_values=params_values, + x_init=x_init, + output_matrix=output_matrix, + timepoints_ode=timepoints_ode, + timepoints_ssm=timepoints_ssm, + discrete_time=discrete_time, + ) + + +def _extract_operator(dmd_model): + """Return a matrix-like operator from a fitted PyDMD object.""" + operator = getattr(dmd_model, "operator", None) + if operator is not None: + as_numpy_array = getattr(operator, "as_numpy_array", None) + if as_numpy_array is not None: + return as_numpy_array() if callable(as_numpy_array) else as_numpy_array + for attr in ("A", "atilde", "_Atilde"): + value = getattr(operator, attr, None) + if value is not None: + return value() if callable(value) else value + + for attr in ("A", "atilde", "_Atilde"): + value = getattr(dmd_model, attr, None) + if value is not None: + return value() if callable(value) else value + + raise ValueError( + "Could not find a linear operator on the PyDMD model. Fit the model " + "first or pass an explicit operator to from_linear_operator." + ) diff --git a/autoreduce/system.py b/autoreduce/system/system.py similarity index 55% rename from autoreduce/system.py rename to autoreduce/system/system.py index 4ea5a26..a785384 100644 --- a/autoreduce/system.py +++ b/autoreduce/system/system.py @@ -1,10 +1,25 @@ -# Import required libraries and dependencies -from sympy import Symbol +"""Core symbolic representation of nonlinear dynamical systems.""" + +from warnings import warn + import libsbml import numpy as np -from .sbmlutil import create_sbml_model, add_species, add_reaction -from .sbmlutil import add_parameters -from warnings import warn +from sympy import Symbol +from sympy.printing import latex + +from autoreduce.utils.sbml import ( + add_parameters, + add_reaction, + add_species, + create_sbml_model, +) + + +def _values_equal(left, right): + """Return value equality for scalars, lists, tuples, and arrays.""" + if isinstance(left, np.ndarray) or isinstance(right, np.ndarray): + return np.array_equal(np.asarray(left), np.asarray(right)) + return left == right class System(object): @@ -25,6 +40,9 @@ def __init__( params_values=None, x_init=None, input_values=None, + timepoints_ode=None, + timepoints_ssm=None, + params_dict=None, **kwargs, ): """ @@ -38,8 +56,8 @@ def __init__( Written symbolically with symbols x = [x_0, x_1, ...] for states and P = [P_0, P_1, ...] for parameters. - params : (Symbolic) parameters used to - define f, g, h. None if no symbolic parameters. + params_dict : Dictionary mapping symbolic parameters to numerical + values. Use params_dict to set, get, and update parameters. g : The actuator / input dynamics. None by default if the system is autonomous. @@ -51,29 +69,59 @@ def __init__( h : The output description y = h(x, P) where x are states and P are parameters. - params_values : Values for model parameters - u : List of inputs x_init : Model initial conditions + + Parameter values can be read and changed with get_param, + set_param, set_param_dict, and update_param_dict. """ + if C is not None and h is not None: + raise ValueError("Set either C or h, not both.") + if len(x) != len(f): + raise ValueError("x and f must have the same length.") + if params_dict is not None and ( + params is not None or params_values is not None + ): + raise ValueError( + "Use either params_dict or params/params_values, not both." + ) + if params is not None and params_values is not None: + if len(params) != len(params_values): + raise ValueError( + "params and params_values must have the same length." + ) + if x_init is not None and len(x_init) != len(x): + raise ValueError("x_init must have the same length as x.") + self.x = x self.n = len(x) self.f = f - self.params = params self.C = C self.g = g self.h = h self.u = u - if params_values is not None: - self.params_values = params_values + if params_dict is not None: + self.params_dict = dict(params_dict) + self.params = list(self.params_dict.keys()) + self.params_values = list(self.params_dict.values()) else: - self.params_values = [] + self.params = params + if params_values is not None: + self.params_values = params_values + else: + self.params_values = [] + if self.params is None: + self.params_dict = {} + else: + self.params_dict = dict(zip(self.params, self.params_values)) if input_values is not None: self.input_values = input_values else: self.input_values = [] + self.timepoints_ode = timepoints_ode + self.timepoints_ssm = timepoints_ssm if x_init is not None: self.x_init = x_init else: @@ -99,6 +147,110 @@ def __init__( self.ic_parameters = None return + def get_param(self, param_name): + """Get one parameter value from params_dict.""" + if param_name not in self.params_dict: + raise ValueError( + f"Parameter {param_name!r} was not found. " + f"Available parameters are: {list(self.params_dict.keys())}." + ) + return self.params_dict[param_name] + + def set_param(self, param_name, param_value): + """Set one parameter value in params_dict and params_values.""" + if param_name not in self.params_dict: + raise ValueError( + f"Parameter {param_name!r} was not found. " + f"Available parameters are: {list(self.params_dict.keys())}." + ) + self.params_dict[param_name] = param_value + param_index = self.params.index(param_name) + self.params_values[param_index] = param_value + return param_value + + def set_param_dict(self, params_dict): + """Set parameter values from a dictionary.""" + unknown_params = [ + param_name + for param_name in params_dict + if param_name not in self.params_dict + ] + if unknown_params: + raise ValueError( + f"Parameters {unknown_params!r} were not found. " + f"Available parameters are: {list(self.params_dict.keys())}." + ) + self.params_dict.update(params_dict) + self.update_param_dict() + return self.params_dict + + def update_param_dict(self): + """Update params_values from params_dict.""" + params_dict_keys = set(self.params_dict.keys()) + params_keys = set([] if self.params is None else self.params) + if params_dict_keys != params_keys: + raise ValueError( + "params_dict keys must exactly match params. " + f"params_dict keys are {list(self.params_dict.keys())}; " + f"params are {self.params}." + ) + self.params_values = [self.params_dict[param] for param in self.params] + return self.params_dict + + def _count_inputs(self): + """Return the number of declared inputs, if any.""" + if self.u is None: + return 0 + if isinstance(self.u, (list, tuple, np.ndarray)): + return len(self.u) + return 1 + + def _count_outputs(self): + """Return the number of declared outputs, if any.""" + if self.C is not None: + shape = np.shape(self.C) + if len(shape) == 0: + return 1 + if len(shape) == 1: + return 1 + return shape[0] + if self.h is not None: + if isinstance(self.h, (list, tuple, np.ndarray)): + return len(self.h) + return 1 + return 0 + + @staticmethod + def _pluralize(count, singular, plural=None): + """Return a count-aware label.""" + if plural is None: + plural = singular + "s" + label = singular if count == 1 else plural + return f"{count} {label}" + + def _pretty_print_text(self): + """Build the human-readable system summary used by pretty_print.""" + parts = [ + "AutoReduce System object with " + + self._pluralize(self.n, "state variable") + ] + input_count = self._count_inputs() + if input_count: + parts.append(self._pluralize(input_count, "input")) + output_count = self._count_outputs() + if output_count: + parts.append(self._pluralize(output_count, "output")) + summary = ", ".join(parts) + "." + return f"{summary}\nsystem equations:\n{latex(self.f)}" + + def pretty_print(self): + """Print a concise model summary with LaTeX system equations.""" + print(self._pretty_print_text()) + + def __str__(self): + """Return the symbolic dynamics for concise string display.""" + return str(self.f) + def set_dynamics( self, f=None, g=None, h=None, C=None, u=None, params=None ): @@ -159,6 +311,10 @@ def set_parameters(self, params_values=None, x_init=None): ) else: self.params_values = [] + if self.params is None: + self.params_dict = {} + else: + self.params_dict = dict(zip(self.params, self.params_values)) if x_init is not None: self.x_init = [pi for pi in x_init] else: @@ -259,21 +415,22 @@ def __eq__(self, other): return False # Compare basic attributes - if ( - self.x != other.x - or self.f != other.f - or self.params != other.params - or self.params_values != other.params_values - or self.x_init != other.x_init - or self.C != other.C - or self.g != other.g - or self.h != other.h - or self.u != other.u - or self.input_values != other.input_values - ): - return False - - return True + attributes = ( + "x", + "f", + "params", + "params_values", + "x_init", + "C", + "g", + "h", + "u", + "input_values", + ) + return all( + _values_equal(getattr(self, attr), getattr(other, attr)) + for attr in attributes + ) def __hash__(self): """Hash for System to use as dict key diff --git a/autoreduce/utils.py b/autoreduce/utils.py deleted file mode 100644 index 904d253..0000000 --- a/autoreduce/utils.py +++ /dev/null @@ -1,131 +0,0 @@ -from autoreduce import ode -from autoreduce import local_sensitivity -from autoreduce import model_reduction - - -def get_ODE(system_obj, timepoints, **kwargs): - """ - For the given timepoints, - create an ODE class object for this System object. - """ - ode_obj = ode.ODE( - system_obj.x, - system_obj.f, - C=system_obj.C, - g=system_obj.g, - h=system_obj.h, - u=system_obj.u, - params=system_obj.params, - params_values=system_obj.params_values, - x_init=system_obj.x_init, - timepoints=timepoints, - **kwargs, - ) - return ode_obj - - -def solve_ODE_SSM(system_obj, timepoints_ode, timepoints_ssm, **kwargs): - """ - For the given timepoints, - returns the full solution - (states, sensitivity coefficients, outputs) - """ - ode = system_obj.get_ODE(timepoints_ode) - ssm = system_obj.get_SSM(timepoints_ssm) - x_sol = ode.solve_system().y - y = system_obj.C @ x_sol - Ss = ssm.compute_SSM() - return x_sol, y, Ss - - -def get_SSM(system_obj, timepoints, **kwargs): - """ - For the given timepoints, - create an SSM class object for this System object. - """ - ssm_obj = local_sensitivity.SSM( - system_obj.x, - system_obj.f, - g=system_obj.g, - C=system_obj.C, - h=system_obj.h, - u=system_obj.u, - params=system_obj.params, - params_values=system_obj.params_values, - x_init=system_obj.x_init, - timepoints=timepoints, - **kwargs, - ) - return ssm_obj - - -def get_reducible( - system_obj, timepoints_ode=None, timepoints_ssm=None, **kwargs -): - red_obj = model_reduction.Reduce( - system_obj.x, - system_obj.f, - C=system_obj.C, - params=system_obj.params, - g=system_obj.g, - h=system_obj.h, - u=system_obj.u, - params_values=system_obj.params_values, - x_init=system_obj.x_init, - parameter_dependent_ic=system_obj.parameter_dependent_ic, - ic_parameters=system_obj.ic_parameters, - timepoints_ode=timepoints_ode, - timepoints_ssm=timepoints_ssm, - **kwargs, - ) - return red_obj - - -def reduce_utils(reduce_obj, **kwargs): - reduce_utils_obj = model_reduction.ReduceUtils( - reduce_obj.x, - reduce_obj.f, - C=reduce_obj.C, - params=reduce_obj.params, - g=reduce_obj.g, - h=reduce_obj.h, - u=reduce_obj.u, - params_values=reduce_obj.params_values, - x_init=reduce_obj.x_init, - timepoints_ode=reduce_obj.timepoints_ode, - timepoints_ssm=reduce_obj.timepoints_ssm, - error_tol=reduce_obj.error_tol, - nstates_tol=reduce_obj.nstates_tol, - ) - return reduce_utils_obj - - -def get_ode_solutions(system_obj, timepoints, **kwargs): - x_sol = get_ODE(system_obj, timepoints, **kwargs).solve_system().T - return x_sol - - -def printProgressBar( - iteration, total, prefix="", suffix="", decimals=1, length=100, fill="█" -): - """ - Call in a loop to create terminal progress bar - @params: - iteration - Required : current iteration (Int) - total - Required : total iterations (Int) - prefix - Optional : prefix string (Str) - suffix - Optional : suffix string (Str) - decimals - Optional : positive number of decimals - in percent complete (Int) - length - Optional : character length of bar (Int) - fill - Optional : bar fill character (Str) - """ - percent = ("{0:." + str(decimals) + "f}").format( - 100 * (iteration / float(total)) - ) - filledLength = int(length * iteration // total) - bar = fill * filledLength + "-" * (length - filledLength) - print("\r%s |%s| %s%% %s" % (prefix, bar, percent, suffix), end="\r") - # Print New Line on Complete - if iteration == total: - print() diff --git a/autoreduce/utils/__init__.py b/autoreduce/utils/__init__.py new file mode 100644 index 0000000..12b21b5 --- /dev/null +++ b/autoreduce/utils/__init__.py @@ -0,0 +1 @@ +"""Utility modules for model conversion and SBML export.""" diff --git a/autoreduce/converters.py b/autoreduce/utils/converters.py similarity index 50% rename from autoreduce/converters.py rename to autoreduce/utils/converters.py index 4d03bbd..e0ba7a8 100644 --- a/autoreduce/converters.py +++ b/autoreduce/utils/converters.py @@ -1,20 +1,61 @@ -"""All model import/export functions""" +"""Model import and symbolic conversion utilities.""" + +from pathlib import Path import numpy as np # type: ignore -from sympy import Symbol, Integer, parse_expr # type: ignore from libsbml import ( - readSBMLFromFile, + LIBSBML_OPERATION_SUCCESS, LIBSBML_SEV_FATAL, ConversionProperties, - LIBSBML_OPERATION_SUCCESS, + readSBMLFromFile, ) +from sympy import Integer, Symbol, parse_expr # type: ignore -from .model_reduction import Reduce +from autoreduce.system.system import System -def load_ODE_model(n_states, n_params=0): - """Directly load ODE with sympy""" - return ode_to_sympy(n_states, n_params) +def _species_symbol_map(model, rename_species=None): + """Map SBML species identifiers to SymPy symbols.""" + rename_species = {} if rename_species is None else dict(rename_species) + species_ids = [species.getId() for species in model.getListOfSpecies()] + unknown_species = sorted(set(rename_species) - set(species_ids)) + if unknown_species: + unknown_names = ", ".join(str(species) for species in unknown_species) + available_names = ", ".join(sorted(species_ids)) + raise ValueError( + "Species rename keys did not match SBML species: " + f"{unknown_names}. Available species are: {available_names}." + ) + mapping = {} + used_names = set() + for species in model.getListOfSpecies(): + species_id = species.getId() + new_name = str(rename_species.get(species_id, species_id)) + if new_name in used_names: + raise ValueError( + f"Species rename for {species_id!r} creates duplicate " + f"symbol {new_name!r}." + ) + used_names.add(new_name) + mapping[species_id] = Symbol(new_name) + return mapping + + +def load_ode_model(n_states, n_params=0, outputs=None): + """Directly load an ODE skeleton with SymPy symbols.""" + x, f, P = ode_to_sympy(n_states, n_params) + if outputs: + output_names = [outputs] if isinstance(outputs, str) else list(outputs) + states = [str(state) for state in x] + missing_outputs = [ + output for output in output_names if output not in states + ] + if missing_outputs: + raise ValueError( + "Outputs did not match any state in the ODE model: " + f"{missing_outputs}. Available states are: {states}." + ) + return x, f, P def ode_to_sympy(odesize, n_params=0): @@ -27,22 +68,19 @@ def ode_to_sympy(odesize, n_params=0): x = [] P = [] for i in range(odesize): - str_var = "x" + str(i) - str_f = "f" + str(i) - vars()[str_f] = symbols("f%d" % i) - vars()[str_var] = symbols("x%d" % i) - f.append(vars()[str_f]) - x.append(vars()[str_var]) + f.append(symbols("f%d" % i)) + x.append(symbols("x%d" % i)) for k in range(n_params): - str_P = "P" + str(k) - vars()[str_P] = symbols("P" + "%d" % k) - P.append(vars()[str_P]) + P.append(symbols("P" + "%d" % k)) return x, f, P def sympy_to_sbml(model): - sbml_doc = None - return sbml_doc + """Return an SBML document for a SymPy-backed model. + + This conversion path is not implemented yet. + """ + raise NotImplementedError("SymPy-to-SBML conversion is not implemented.") # SBML to ODE # @@ -61,23 +99,38 @@ def sympy_to_sbml(model): # -def load_sbml(filename, **kwargs): - """A function that takes in an SBML file and returns x,f,P,params_values. - x is a list of species written as Sympy objects - f is a list of functions written as Sympy objects - P is a list of parameters written as Sympy objects - params_values is a list of parameter values, in the same order as P - x_init is a list of initial conditions, in the same order as x +def load_sbml(filename, outputs=None, rename_species=None, **kwargs): + """Load an SBML file as a System object. - Returns: A reducible Reduce(System) object + Parameters + ---------- + filename + Path to the SBML file. + outputs + Optional SBML species identifier or list of SBML species identifiers + to use as linear outputs. A row is added to ``C`` for each output. + rename_species + Optional mapping from SBML species identifiers to shorter symbol names + used in the returned ``System``. + + The returned ``System`` has species in ``x``, dynamics in ``f``, + parameter values in ``params_dict``, and initial conditions in ``x_init``. + + Returns: A System object """ # Get the sbml file, check for errors, and perform conversions + sbml_path = Path(filename) + if not sbml_path.is_file(): + raise FileNotFoundError(f"SBML file not found: {filename}") + filename = str(sbml_path) + doc = readSBMLFromFile(filename) if doc.getNumErrors(LIBSBML_SEV_FATAL): - print("Encountered serious errors while reading file") - print(doc.getErrorLog().toString()) - return + raise ValueError( + "Encountered serious errors while reading SBML file " + f"{filename}:\n{doc.getErrorLog().toString()}" + ) doc.getErrorLog().clearLog() # Convert local params to global params props = ConversionProperties() @@ -99,6 +152,10 @@ def load_sbml(filename, **kwargs): print(doc.getErrorLog().toString()) # Get model and define important lists, dictionaries mod = doc.getModel() + if mod is None: + raise ValueError(f"No SBML model found in file: {filename}") + + species_symbols = _species_symbol_map(mod, rename_species=rename_species) x = [] x_init = [] P = [] @@ -109,7 +166,7 @@ def load_sbml(filename, **kwargs): # x[i] corresponds to x_init[i] for i in range(mod.getNumSpecies()): species = mod.getSpecies(i) - x.append(Symbol(species.getId())) + x.append(species_symbols[species.getId()]) if species.isSetInitialConcentration(): x_init.append(species.getInitialConcentration()) elif species.isSetInitialAmount(): @@ -127,9 +184,7 @@ def load_sbml(filename, **kwargs): kinetics = reaction.getKineticLaw() formula = kinetics.getFormula() # Create a mapping of species/parameter IDs to their symbols - symbol_map = {} - for species in mod.getListOfSpecies(): - symbol_map[species.getId()] = Symbol(species.getId()) + symbol_map = dict(species_symbols) for param in mod.getListOfParameters(): symbol_map[param.getId()] = Symbol(param.getId()) # Parse the formula using sympy's parse_expr with local_dict @@ -144,7 +199,7 @@ def load_sbml(filename, **kwargs): # subtract reactant kinetic formula for j in range(reaction.getNumReactants()): ref = reaction.getReactant(j) - species = Symbol(ref.getSpecies()) + species = species_symbols[ref.getSpecies()] curr_index = x.index(species) if ref.getStoichiometry() == 1.0: f[curr_index] += -reactions[reaction.getId()] @@ -155,7 +210,7 @@ def load_sbml(filename, **kwargs): # add product kinetic formula for j in range(reaction.getNumProducts()): ref = reaction.getProduct(j) - species = Symbol(ref.getSpecies()) + species = species_symbols[ref.getSpecies()] curr_index = x.index(species) if ref.getStoichiometry() == 1.0: f[curr_index] += +reactions[reaction.getId()] @@ -163,23 +218,28 @@ def load_sbml(filename, **kwargs): f[curr_index] += ( +reactions[reaction.getId()] * ref.getStoichiometry() ) - if "outputs" in kwargs: - outputs = kwargs["outputs"] - if not isinstance(outputs, list): - outputs = [outputs] - C = np.zeros((len(outputs), len(x))) - output_count = 0 - for output in outputs: - index_output = x.index(Symbol(output)) - C[output_count, index_output] = 1 - output_count += 1 - else: + if outputs is None or outputs == []: C = None - sys = Reduce( + else: + output_names = [outputs] if isinstance(outputs, str) else list(outputs) + species_ids = [species.getId() for species in mod.getListOfSpecies()] + missing_outputs = [ + output for output in output_names if output not in species_ids + ] + if missing_outputs: + raise ValueError( + "Outputs did not match any species in the SBML model: " + f"{missing_outputs}. Available species are: {species_ids}." + ) + C = np.zeros((len(output_names), len(x))) + for output_count, output in enumerate(output_names): + index_output = x.index(species_symbols[output]) + C[output_count, index_output] = 1 + print(f"Your output {output!r} is now set using the system.C matrix!") + sys = System( x, f, - params=P, - params_values=params_values, + params_dict=dict(zip(P, params_values)), x_init=x_init, C=C, **kwargs, diff --git a/autoreduce/sbmlutil.py b/autoreduce/utils/sbml.py similarity index 99% rename from autoreduce/sbmlutil.py rename to autoreduce/utils/sbml.py index 3de57da..f3f1bc0 100644 --- a/autoreduce/sbmlutil.py +++ b/autoreduce/utils/sbml.py @@ -1,3 +1,5 @@ +"""SBML model construction utilities.""" + import libsbml import numpy as np diff --git a/docs/CONTRIBUTING.md b/docs/CONTRIBUTING.md deleted file mode 100644 index 4dd75e3..0000000 --- a/docs/CONTRIBUTING.md +++ /dev/null @@ -1,39 +0,0 @@ -# Contributing to BioCRNpyler - -Thank you for your interest in contributing to BioCRNpyler! - -In this file you will find detailed instructions on how you can start making contributions to the package. BioCRNpyler is hosted on the [BuildACell](https://github.com/buildacell) organization page on GitHub. For more information on getting started with the package, refer to the README file on the [home page](https://github.com/BuildACell/biocrnpyler) and the tutorial style example jupyter notebooks under the [examples](https://github.com/BuildACell/BioCRNPyler/tree/master/examples) directory. For a detailed software documentation refer to the BioCRNpyler documentation [here](https://readthedocs.org/projects/biocrnpyler/). - -## How to contribute? -To get started, set up your BioCRNpyler fork - detailed instructions for doing so can be found [here](https://github.com/BuildACell/BioCRNPyler/wiki/How-to-sync-your-BioCRNPyler-fork). All contributions to BioCRNpyler should be made as a Github pull request to the **dev** branch [here](https://github.com/BuildACell/BioCRNPyler/tree/dev). - -### Reporting Bugs/Asking for help - -Use the Github issues page on BioCRNpyler to report a bug or to ask for help with running BioCRNpyler. The Github issues have labels that you can use so that the issues can be filtered easily: - -* If you are unsure where to begin contributing to BioCRNpyler, you can start by looking through the issues with the label `beginner` or `help-wanted`. A beginner issue usually requires only changing a few lines of code to fix something or add a new enhancement. The `help-wanted` issues are slightly more involved and may require an understanding of the BioCRNpyler modules. - -* If you have a particular feature idea in mind, feel free to suggest that as an `enhancement` or a `feature-request` tagged issue. If you would like to get in touch with the developers working on the package to discuss your contribution ideas, you can also join our Slack channel (details at the end of this page). - -### Pull Requests - -All pull requests should be made to the `dev` branch of BioCRNpyler. To maintain code readability and validity, we encourage you to document your pull requests using the following ways: -* Add a detailed comment when creating the pull request that summarizes the changes, features and/or bugs fixed. -* All new functions and classes must have [docstrings](https://www.python.org/dev/peps/pep-0257/) so that automated documentation can be generated. -* If possible, we encourage you to add test functions in the Tests directory that validate the code contributions. -* If your pull request is adding a new feature to the package, we also highly recommend a jupyter notebook example that goes along with that feature that discusses the use case. - -## Styleguides - -* Following the PEP8 guideline, limit the first line to 72 characters or less -* Reference issues and pull requests in your pull request comment -* - -## Have any questions? - -If you have questions or would like to connect to the BioCRNpyler team on a regular basis, you can join our Slack channel. BioCRNpyler is a channel under the Synthetic Biology Modeling and Analysis Tools (SBTools) slack team. - -* [Join the SBTools Slack](https://join.slack.com/t/sbtools/shared_invite/zt-g82qjmvm-GAsNFLjyXGPlRBapqGDgFg) - * Use the `#biocrnpyler` channel for general questions or discussion about BioCRNpyler - * Use the `#general` channel for general questions about SBTools - * There are many other channels available for other synthetic biology modeling and analysis tools, check the channel list diff --git a/docs/_static/css/custom.css b/docs/_static/css/custom.css new file mode 100644 index 0000000..166224c --- /dev/null +++ b/docs/_static/css/custom.css @@ -0,0 +1,5 @@ +.py.class, +.py.function, +.py.method { + font-weight: 600; +} diff --git a/docs/api.rst b/docs/api.rst deleted file mode 100644 index 6be841e..0000000 --- a/docs/api.rst +++ /dev/null @@ -1,34 +0,0 @@ -API Reference -============= - -System ------- - -.. autoclass:: autoreduce.system.System - :members: - :undoc-members: - :show-inheritance: - -Reduce ------- - -.. autoclass:: autoreduce.model_reduction.Reduce - :members: - :undoc-members: - :show-inheritance: - -Utils ------ - -.. automodule:: autoreduce.utils - :members: - :undoc-members: - :show-inheritance: - -Converters ----------- - -.. automodule:: autoreduce.converters - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/conf.py b/docs/conf.py index c68c55d..4a4f1dc 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -5,28 +5,27 @@ # For the full list of built-in configuration values, see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html -# -- Path setup -------------------------------------------------------------- - -# If extensions (or modules to document with autodoc) are in another directory, -# add these directories to sys.path here. If the directory is relative to the -# documentation root, use os.path.abspath to make it absolute, like shown here. import os import sys +from os.path import dirname, relpath +import inspect +import sphinx +from setuptools_scm import get_version sys.path.insert(0, os.path.abspath("..")) +import autoreduce + # -- Project information ----------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information project = "autoreduce" -copyright = "2025, Ayush Pandey" +copyright = "2026, Ayush Pandey" author = "Ayush Pandey" -# The short X.Y version -version = "0.3" -# The full version, including alpha/beta/rc tags -release = "0.3.0" +release = get_version(root="..", relative_to=__file__) +version = ".".join(release.split(".", 2)[:2]) # -- General configuration --------------------------------------------------- @@ -41,11 +40,18 @@ # ones. extensions = [ "sphinx.ext.autodoc", + "sphinx.ext.autosummary", + "sphinx.ext.doctest", + "sphinx.ext.linkcode", + "sphinx.ext.mathjax", "sphinx.ext.napoleon", - "sphinx.ext.viewcode", - "sphinx.ext.githubpages", - "sphinx_autodoc_typehints", + "sphinx_copybutton", + "sphinx_toggleprompt", + "sphinx_math_dollar", "nbsphinx", + "nbsphinx_link", + "recommonmark", + "numpydoc", ] # Add any paths that contain templates here, relative to this directory. @@ -55,7 +61,7 @@ # You can specify multiple suffix as a list of string: # # source_suffix = ['.rst', '.md'] -source_suffix = ".rst" +source_suffix = {".rst": "restructuredtext"} # The master toctree document. master_doc = "index" @@ -71,10 +77,18 @@ # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. -exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] +exclude_patterns = ["_build", "_autogen_*.rst", "Thumbs.db", ".DS_Store"] +suppress_warnings = ["config.cache"] + +autosummary_generate = True +autodoc_default_options = { + "exclude-members": "__init__, __weakref__, __repr__, __str__, __hash__", +} +autoclass_content = "class" +autodoc_mock_imports = ["control", "pydmd"] # The name of the Pygments (syntax highlighting) style to use. -pygments_style = None +pygments_style = "sphinx" # -- Options for HTML output ------------------------------------------------- @@ -84,6 +98,7 @@ # a list of builtin themes. # html_theme = "sphinx_rtd_theme" +default_role = "py:obj" # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the @@ -95,6 +110,29 @@ # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ["_static"] +html_css_files = ["css/custom.css"] + +sphinx_version = tuple(int(x) for x in sphinx.__version__.split(".")[:2]) +if sphinx_version >= (4, 0): + mathjax3_config = { + "tex": { + "inlineMath": [["\\(", "\\)"]], + "displayMath": [["\\[", "\\]"]], + } + } +else: + mathjax_config = { + "tex2jax": { + "inlineMath": [["\\(", "\\)"]], + "displayMath": [["\\[", "\\]"]], + }, + } + +copybutton_prompt_text = r">>> |\.\.\. " +copybutton_prompt_is_regexp = True +numpydoc_show_class_members = False +numpydoc_class_members_toctree = False +nbsphinx_execute = "never" # Custom sidebar templates, must be a dictionary that maps document names # to template names. @@ -185,6 +223,7 @@ "scipy": ("https://docs.scipy.org/doc/scipy/", None), "sympy": ("https://docs.sympy.org/latest/", None), } +intersphinx_disabled_reftypes = ["py:keyword"] # Napoleon settings napoleon_google_docstring = True @@ -200,7 +239,58 @@ napoleon_use_rtype = True napoleon_type_aliases = None -# -- Extension configuration ------------------------------------------------- autodoc_member_order = "bysource" autodoc_typehints = "description" add_module_names = False + + +def linkcode_resolve(domain, info): + """Resolve documented Python objects to GitHub source links.""" + if domain != "py": + return None + + module_name = info["module"] + full_name = info["fullname"] + module = sys.modules.get(module_name) + if module is None: + return None + + obj = module + for part in full_name.split("."): + try: + obj = getattr(obj, part) + except AttributeError: + return None + + obj = inspect.unwrap(obj) + try: + source_file = inspect.getsourcefile(obj) + source, line_number = inspect.getsourcelines(obj) + except (OSError, TypeError): + return None + if not source_file: + return None + + source_module = inspect.getmodule(obj) + if source_module is not None and not source_module.__name__.startswith( + "autoreduce" + ): + return None + + relative_file = relpath(source_file, start=dirname(autoreduce.__file__)) + line_spec = f"#L{line_number}-L{line_number + len(source) - 1}" + if release != version: + return ( + "https://github.com/ayush9pandey/AutoReduce/blob/" + f"main/autoreduce/{relative_file}{line_spec}" + ) + return ( + "https://github.com/ayush9pandey/AutoReduce/blob/" + f"v{version}/autoreduce/{relative_file}{line_spec}" + ) + + +doctest_global_setup = """ +import numpy as np +import autoreduce +""" diff --git a/docs/contributing.rst b/docs/contributing.rst index 0ad3ddc..48fd3c2 100644 --- a/docs/contributing.rst +++ b/docs/contributing.rst @@ -1,18 +1,19 @@ Contributing ============ -We welcome contributions to AutoReduce! This document provides guidelines and instructions for contributing. +We welcome contributions to AutoReduce. See :doc:`develop` for the full +developer notes and release checklist. Development Setup ----------------- +----------------- 1. Fork the repository 2. Clone your fork: .. code-block:: bash - git clone https://github.com//autoreduce.git - cd autoreduce + git clone https://github.com//AutoReduce.git + cd AutoReduce 3. Create a new branch: @@ -24,16 +25,18 @@ Development Setup .. code-block:: bash - pip install -e ".[all]" - pip install pytest pytest-cov nbval + pip install -e ".[dev]" Code Style ---------- -We use flake8 for code style checking. The configuration is in ``pyproject.toml``. Key points: +We use ruff for linting and formatting. Configuration is defined in +``pyproject.toml``. -* Maximum line length: 80 characters -* Follow PEP 8 guidelines +.. code-block:: bash + + ruff check autoreduce tests + ruff format autoreduce tests Running Tests ------------- @@ -48,7 +51,7 @@ For coverage report: .. code-block:: bash - pytest --cov=autoreduce + pytest --cov=autoreduce --cov-report=xml Documentation ------------- @@ -59,7 +62,7 @@ The documentation is built using Sphinx. To build it locally: .. code-block:: bash - pip install sphinx sphinx_rtd_theme nbsphinx myst_parser + pip install -e ".[docs]" 2. Build the docs: @@ -71,13 +74,12 @@ The documentation is built using Sphinx. To build it locally: 3. View the documentation by opening ``docs/_build/html/index.html`` Pull Request Process -------------------- +-------------------- 1. Update the documentation if needed 2. Add tests for new features 3. Ensure all tests pass -4. Update the changelog -5. Submit a pull request +4. Submit a pull request For major changes, please open an issue first to discuss the proposed changes. diff --git a/docs/develop.rst b/docs/develop.rst new file mode 100644 index 0000000..6e0b8ce --- /dev/null +++ b/docs/develop.rst @@ -0,0 +1,151 @@ +.. currentmodule:: autoreduce + +*************** +Developer Notes +*************** + +This chapter contains notes for developers contributing to AutoReduce. + +Package Structure +================= + +The package source is organized by model-reduction responsibility: + +- `autoreduce.system` contains the core `System` representation and model + import adapters. +- `autoreduce.solvers` contains numerical ODE and sensitivity solvers. +- `autoreduce.reductions` contains time-scale, conservation, abundance, and + projection-based reduction methods. +- `autoreduce.utils` contains conversion, SBML, and reduction-constructor + utilities. +- `examples` is split into biological, canonical, and ecological examples. +- `tests` contains the pytest suite. + +Code Style +========== + +AutoReduce uses `ruff `_ for linting and +formatting configuration. Run these commands from the repository root: + +.. code-block:: bash + + ruff check autoreduce tests + ruff format autoreduce tests + +Docstrings should follow NumPy style. Public modules, classes, and functions +should explain the scientific object being represented, the assumptions made, +and the expected symbolic or numeric dimensions. + +Testing +======= + +Install the test dependencies and run pytest: + +.. code-block:: bash + + pip install -e ".[dev]" + pytest + +Run coverage explicitly when needed: + +.. code-block:: bash + + pytest --cov=autoreduce --cov-report=xml + +Documentation +============= + +Documentation is built with Sphinx from the ``docs`` directory. Install the +documentation extra from the repository root: + +.. code-block:: bash + + python -m pip install -e ".[docs]" + +Build the HTML documentation locally: + +.. code-block:: bash + + python -m sphinx -b html docs docs/_build/html + +On Windows, if a synchronized folder or a browser locks files under +``docs/_build``, build to a fresh output directory instead: + +.. code-block:: bash + + python -m sphinx -b html docs %TEMP%\autoreduce-sphinx-html + +Read the Docs +------------- + +AutoReduce is configured for Read the Docs with ``.readthedocs.yaml`` at the +repository root. The Read the Docs project should: + +1. Import the GitHub repository. +2. Use the repository configuration file, ``.readthedocs.yaml``. +3. Build with the Sphinx configuration in ``docs/conf.py``. +4. Install the package with the ``docs`` extra. + +The current Read the Docs configuration uses Python 3.12. Reproduce any Read +the Docs failure locally by running: + +.. code-block:: bash + + python -m pip install -e ".[docs]" + python -m sphinx -b html docs docs/_build/html + +Releasing New Versions +====================== + +AutoReduce uses semantic versioning (`MAJOR.MINOR.PATCH`) and Git tags through +`setuptools_scm`. Package wheels and source distributions are published to +PyPI by the manual GitHub Actions release workflow. + +PyPI Setup +---------- + +The PyPI project should use trusted publishing from GitHub Actions. In the +PyPI project settings for ``autoreduce``, add a trusted publisher with: + +- Owner: ``ayush9pandey`` +- Repository: ``AutoReduce`` +- Workflow: ``pypi-deploy.yml`` +- Environment: ``Release Deploy`` + +In GitHub, create the ``Release Deploy`` environment so that it matches the +workflow environment in ``.github/workflows/pypi-deploy.yml``. Add reviewer +protection there if releases should require manual approval. + +Release checklist: + +1. Ensure the working tree is clean and CI is green. +2. Update documentation and examples as needed. +3. Run the package checks from the release environment: + + .. code-block:: bash + + python -m pip install -e ".[dev]" + pytest + ruff check autoreduce tests + python -m sphinx -b html docs docs/_build/html + python -m build --no-isolation + +4. Commit and push all release changes. +5. Create an annotated tag on the release commit: + + .. code-block:: bash + + git tag -a vX.Y.Z -m "Release X.Y.Z" + git push --tags + +6. Run the PyPI release workflow from the tag or provide the tag in the + workflow `ref` input. +7. Verify the published package from a clean environment: + + .. code-block:: bash + + python -m pip install autoreduce==X.Y.Z + python -c "import autoreduce; print(autoreduce.__version__)" + +Generated build outputs such as ``build/``, ``dist/``, ``*.egg-info``, and +``autoreduce/_version.py`` are setuptools artifacts. They must not be committed. diff --git a/docs/examples.rst b/docs/examples.rst index b5fd365..0452b47 100644 --- a/docs/examples.rst +++ b/docs/examples.rst @@ -1,39 +1,45 @@ Examples ======== -This section contains examples of using AutoReduce for different types of model reduction tasks. +This section contains the current AutoReduce example notebooks. Examples are +organized by scientific domain. -Michaelis-Menten Model Reduction -------------------------------- +Biological examples +------------------- -This example demonstrates how to reduce a simple Michaelis-Menten model using QSSA. +.. toctree:: + :maxdepth: 1 -.. nbgallery:: - :caption: Michaelis-Menten Example - :name: michaelis-menten + notebooks/gene_expression_analysis + notebooks/toggle_switch + notebooks/biocrnpyler_interface + notebooks/bacterial_population_control + notebooks/hill_function_derivation - ../examples/michaelis-menten example.ipynb +Canonical examples +------------------ -Gene Expression Analysis ------------------------ +.. toctree:: + :maxdepth: 1 -This example shows how to analyze and reduce gene expression models. + notebooks/michaelis_menten + notebooks/parameter_sensitivity + notebooks/qss_with_python_control -.. nbgallery:: - :caption: Gene Expression Analysis - :name: gene-expression +Cyber-physical examples +----------------------- - ../examples/gene expression analysis.ipynb +.. toctree:: + :maxdepth: 1 -BioCRNPyler Integration ----------------------- + notebooks/motor_control -This example demonstrates how to use AutoReduce with BioCRNPyler for synthetic biology models. +Ecological examples +------------------- -.. nbgallery:: - :caption: BioCRNPyler Integration - :name: biocrnpyler +.. toctree:: + :maxdepth: 1 - ../examples/AutoReduce-BioCRNpyler interface.ipynb + notebooks/viral_spread -Each example notebook contains detailed explanations and can be downloaded from the `GitHub repository `_. +Each example notebook can be downloaded from the `GitHub repository `_. diff --git a/docs/generate_library_docs.py b/docs/generate_library_docs.py new file mode 100644 index 0000000..8a6f117 --- /dev/null +++ b/docs/generate_library_docs.py @@ -0,0 +1,59 @@ +"""Generate autosummary fragments for the AutoReduce reference manual.""" + +import ast +from pathlib import Path + + +AUTOSUMMARY = """ +.. autosummary:: + :toctree: generated/ + :nosignatures: +""" + + +def get_public_objects(py_path): + """Return public top-level classes and functions in a Python file.""" + with py_path.open(encoding="utf-8") as handle: + tree = ast.parse(handle.read(), filename=str(py_path)) + public_objects = [] + for node in tree.body: + if isinstance(node, (ast.ClassDef, ast.FunctionDef)): + if not node.name.startswith("_"): + public_objects.append(node.name) + return public_objects + + +def write_section(handle, title, module_name, objects): + """Write one module section to an RST file handle.""" + handle.write(f"{title}\n") + handle.write("-" * len(title) + "\n\n") + handle.write(f".. automodule:: {module_name}\n\n") + if objects: + handle.write(AUTOSUMMARY) + handle.write("\n") + for obj in objects: + handle.write(f" {module_name}.{obj}\n") + handle.write("\n") + + +def generate_module_rst(package_dir, docs_dir, package_name, output_name): + """Generate an RST fragment for all modules under a package directory.""" + output_path = docs_dir / output_name + with output_path.open("w", encoding="utf-8") as handle: + for py_path in sorted(package_dir.rglob("*.py")): + if py_path.name == "__init__.py": + continue + relative = py_path.relative_to(package_dir.parent) + module_name = ".".join( + [package_name] + list(relative.with_suffix("").parts[1:]) + ) + title = module_name.replace("_", " ") + objects = get_public_objects(py_path) + write_section(handle, title, module_name, objects) + + +if __name__ == "__main__": + docs = Path(__file__).resolve().parent + root = docs.parent + package = root / "autoreduce" + generate_module_rst(package, docs, "autoreduce", "_autogen_library.rst") diff --git a/docs/index.rst b/docs/index.rst index a972037..f98f033 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -1,70 +1,100 @@ -.. BioCRNPyler documentation master file, created by - sphinx-quickstart on Thu Jan 31 19:56:36 2019. - You can adapt this file completely to your liking, but it should at least - contain the root `toctree` directive. - -Welcome to AutoReduce's documentation! -===================================== - -AutoReduce is a Python package for automated model reduction of SBML models. It provides tools for: - -* Automated model reduction using QSSA (Quasi-Steady State Approximation) -* Hill function approximation -* Integration with BioCRNPyler for synthetic biology models -* Analysis of gene expression models - -Installation ------------ - -You can install AutoReduce using pip: - -.. code-block:: bash - - pip install autoreduce - -For development installation with all optional dependencies: - -.. code-block:: bash - - pip install -e ".[all]" - -Quick Start ----------- - -Here's a simple example of using AutoReduce to reduce a model using conservation laws and timescale separation: - -.. code-block:: python - - from autoreduce.converters import load_sbml - - # Load your SBML model - sys = load_sbml('your_sbml_file.xml', outputs=['your_output']) - - # Solve conservation laws - conservation_laws = sys.solve_conservation_laws( - conserved_sets=[ - ['species1', 'species2', 'species3'], # First conserved set - ['species4', 'species5'] # Second conserved set - ], - states_to_eliminate=['species_to_eliminate1', 'species_to_eliminate2'] - ) - - # Solve timescale separation using QSSA - reduced_qssa_model = sys.solve_timescale_separation(['fast_species1', 'fast_species2']) - -For more detailed examples, see the :doc:`examples` section. - -Contents --------- +######################################################## +AutoReduce: An Automated Model Reduction Toolbox +######################################################## + +AutoReduce is a tool for obtaining reduced-order models of +nonlinear dynamical systems using symbolic computation in Python. +It is designed for workflows where the reduced model should remain +interpretable. That is, users provide symbolic system +equations, select states or constraints that define the reduction problem, +and obtain reduced dynamics that can be inspected, simulated, and exported. + +More specifically, the package supports model reduction by +time-scale separation, conservation laws, abundance assumptions, +local sensitivity analysis, and (coming soon!) projection-based methods. +Models can be imported in multiple formats: +`SymPy `_, +`SBML `_, +`BioCRNpyler `_, +`python-control's NonlinearIOSystem `_, +and PyDMD. The reduced models are returned as symbolic dynamics that +can be exported through supported compatibility routes. + +.. rubric:: Main features + +- Quasi-steady-state approximation (QSSA) through time-scale separation. +- Numerical simulation of full and reduced systems. +- Quantification of error between full and reduced models. +- Conservation-law reduction for systems with invariant total quantities. +- Local sensitivity analysis for parameter-dependent systems to + rank (and choose) parameter effects. +- Robustness computation for reduced models that are closest to the full model + even under perturbations of the parameters. + +.. rubric:: Background + +AutoReduce was originally developed for automated construction of +phenomenological models from more detailed biological circuit descriptions. +The original workflow combines time-scale separation, conservation laws, and +species abundance assumptions to produce smaller models that retain +the input-output relationships needed for design analysis [PandeyMurray2020]_. + +The robustness tools in AutoReduce are connected to structured model +reduction guarantees for dynamical systems, with biomolecular examples +developed in [PandeyMurray2023]_. + +Compatibility notes: + +- SymPy is used for symbolic ODE definitions. +- SciPy is used for numerical ODE simulation. +- python-libsbml supports SBML import and export. +- BioCRNpyler models can be used through SBML-based workflows. +- python-control `NonlinearIOSystem` models are supported for model imports. +- PyDMD-based DMD and DMDc reductions are supported by the ``dmd`` extra. + +.. rubric:: Related research + +The optional PyDMD and python-control integrations build on [Demo2018]_ and +[Fuller2021]_, respectively. + +.. [PandeyMurray2020] Ayush Pandey and Richard M. Murray. "Model Reduction + Tools For Phenomenological Modeling of Input-Controlled Biological + Circuits." bioRxiv, 2020. https://doi.org/10.1101/2020.02.15.950840 + +.. [PandeyMurray2023] Ayush Pandey and Richard M. Murray. "Robustness + guarantees for structured model reduction of dynamical systems with + applications to biomolecular models." *International Journal of Robust and + Nonlinear Control*, 33(9):5058-5086, 2023. + https://doi.org/10.1002/rnc.6013 + +.. [Demo2018] Nicola Demo, Marco Tezzele, and Gianluigi Rozza. "PyDMD: + Python Dynamic Mode Decomposition." *Journal of Open Source Software*, + 3(22):530, 2018. https://doi.org/10.21105/joss.00530 + +.. [Fuller2021] Sawyer Fuller, Ben Greiner, Jason Moore, Richard Murray, + Rene van Paassen, and Rory Yorke. "The Python Control Systems Library + (python-control)." In *2021 60th IEEE Conference on Decision and Control + (CDC)*, 4875-4881, 2021. https://doi.org/10.1109/CDC45484.2021.9683368 .. toctree:: - :maxdepth: 2 - :caption: Contents: + :caption: User Guide + :maxdepth: 1 + :numbered: 2 + introduction installation usage - api + systems + solvers + reductions examples + +.. toctree:: + :caption: Reference Manual + :maxdepth: 1 + + library + develop contributing Indices and tables diff --git a/docs/installation.rst b/docs/installation.rst index b7e8b22..551386b 100644 --- a/docs/installation.rst +++ b/docs/installation.rst @@ -4,20 +4,26 @@ Installation Requirements ------------ -AutoReduce requires Python 3.9 or higher and the following dependencies: +Supported Python versions are: 3.9 - 3.13. + +Required runtime dependencies are listed below +but will be automatically installed with pip when you install the package: * python-libsbml * sympy * scipy * numpy -Optional dependencies (for visualization and advanced features): +Optional compatibility and visualization dependencies: * matplotlib * seaborn +* biocrnpyler, for BioCRNpyler model construction workflows +* control, for python-control `NonlinearIOSystem` adapters +* pydmd, for DMD and DMDc projection workflows Basic Installation ------------------ +------------------ You can install AutoReduce using pip: @@ -25,29 +31,43 @@ You can install AutoReduce using pip: pip install autoreduce +To install AutoReduce with all optional compatibility packages, use: + +.. code-block:: bash + + pip install "autoreduce[all]" + Or install from source: .. code-block:: bash - git clone https://github.com/yourusername/autoreduce.git - cd autoreduce + git clone https://github.com/ayush9pandey/AutoReduce.git + cd AutoReduce pip install . Development Installation ------------------------ +------------------------ -For development, you can install the package in editable mode with all optional dependencies: +For development, install the package in editable mode with the dependencies +needed for the task: .. code-block:: bash git clone https://github.com/ayush9pandey/AutoReduce.git cd AutoReduce - pip install -e ".[all]" + pip install -e ".[dev]" -This will install the package in development mode, allowing you to modify the code and see changes immediately. +Use the feature extras explicitly when working on optional integrations: + +.. code-block:: bash + + pip install -e ".[all]" + pip install -e ".[bio]" + pip install -e ".[control]" + pip install -e ".[dmd]" Verifying Installation ---------------------- +----------------------- To verify your installation, you can run Python and import the package: @@ -57,15 +77,3 @@ To verify your installation, you can run Python and import the package: print(autoreduce.__version__) If you don't see any errors, the installation was successful. - -Troubleshooting --------------- - -If you encounter any issues during installation: - -1. Make sure you have Python 3.9 or higher installed -2. Try creating a fresh virtual environment -3. Check that all dependencies are properly installed -4. If using conda, you might need to install some packages through conda instead of pip - -For more help, please open an issue on the `GitHub repository `_. diff --git a/docs/introduction.rst b/docs/introduction.rst new file mode 100644 index 0000000..8ced7d4 --- /dev/null +++ b/docs/introduction.rst @@ -0,0 +1,32 @@ +Introduction +============ + +AutoReduce can be used to obtain smaller dynamical models from higher +dimensional models. We consider a generalized nonlinear system description as + +.. math:: + + \dot{x} = f(x, \theta, u), \qquad y = h(x, \theta, u), + +where ``x`` is the state vector, ``theta`` is the parameter vector, ``u`` is an +optional input, and ``y`` is the measured or designed output. + +Reduction Methods +----------------- + +AutoReduce currently provides: + +- Time-scale separation for quasi-steady-state approximation (QSSA). +- Conservation-law reduction for invariant total quantities. +- Local sensitivity analysis for ranking parameter effects + and quantifying robustness of reduced models. + +Model Sources +------------- + +Models can be constructed directly with SymPy expressions. AutoReduce also +provides compatibility modules for common scientific modeling workflows: + +- SBML import and export through python-libsbml. +- BioCRNpyler integration through SBML files. +- python-control `NonlinearIOSystem`. diff --git a/docs/library.rst b/docs/library.rst new file mode 100644 index 0000000..dc17425 --- /dev/null +++ b/docs/library.rst @@ -0,0 +1,166 @@ +********************** +The AutoReduce Library +********************** + +This chapter documents the public modules, classes, and functions that make up +AutoReduce. + +Systems +======= + +.. automodule:: autoreduce.system.system + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + System + +.. automodule:: autoreduce.system.control + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + from_nonlinear_io_system + +.. automodule:: autoreduce.system.pydmd + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + from_linear_operator + from_dmd_model + +Solvers +======= + +.. automodule:: autoreduce.solvers.ode + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + ODE + +.. automodule:: autoreduce.solvers.ssm + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + SSM + +Reductions +========== + +.. automodule:: autoreduce.reductions.core + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + Reduce + ReduceUtils + get_error_metric + get_robustness_metric + create_system + +.. automodule:: autoreduce.reductions.timescale + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + solve_timescale_separation + explore_all_QSS_models + reduce_with_input + +.. automodule:: autoreduce.reductions.utils + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + sympy_variables_exist + sympy_solve_and_substitute + sympy_get_steady_state_solutions + +.. automodule:: autoreduce.reductions.conservation + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + find_conserved_sets + setup_conservation_laws + apply_conservation_laws + solve_conservation_laws + +.. automodule:: autoreduce.reductions.abundance + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + solve_approximations + +.. automodule:: autoreduce.reductions.projection.dmd + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + DMDReduction + fit_dmd + fit_dmdc + +Utilities +========= + +.. automodule:: autoreduce.utils.converters + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + load_ode_model + ode_to_sympy + sympy_to_sbml + load_sbml + +``load_sbml(filename, outputs=None, rename_species=None, **kwargs)`` accepts +an optional ``outputs`` argument naming one species or a list of species to +preserve as linear outputs in the returned ``System``. Output names must exactly +match SBML species identifiers. If an output cannot be matched, ``load_sbml`` +raises a ``ValueError`` listing the available species instead of failing with an +internal lookup error. + +The optional ``rename_species`` argument maps long SBML species identifiers to +shorter SymPy symbol names for subsequent AutoReduce analysis. + +.. automodule:: autoreduce.solvers.utils + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + get_ODE + solve_ODE_SSM + get_SSM + solve_ode + solve_ssm + solve_sensitivity + get_ode_solutions + +.. automodule:: autoreduce.utils.sbml + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + create_sbml_model + add_species + add_reaction + add_parameters diff --git a/docs/notebooks/bacterial_population_control.nblink b/docs/notebooks/bacterial_population_control.nblink new file mode 100644 index 0000000..c51e749 --- /dev/null +++ b/docs/notebooks/bacterial_population_control.nblink @@ -0,0 +1,3 @@ +{ + "path": "../../examples/biological/Bacterial population control.ipynb" +} diff --git a/docs/notebooks/biocrnpyler_interface.nblink b/docs/notebooks/biocrnpyler_interface.nblink new file mode 100644 index 0000000..cbcf5b2 --- /dev/null +++ b/docs/notebooks/biocrnpyler_interface.nblink @@ -0,0 +1,3 @@ +{ + "path": "../../examples/biological/BioCRNPyler interface.ipynb" +} diff --git a/docs/notebooks/gene_expression_analysis.nblink b/docs/notebooks/gene_expression_analysis.nblink new file mode 100644 index 0000000..483cb9c --- /dev/null +++ b/docs/notebooks/gene_expression_analysis.nblink @@ -0,0 +1,3 @@ +{ + "path": "../../examples/biological/Exploration of gene expression models.ipynb" +} diff --git a/docs/notebooks/hill_function_derivation.nblink b/docs/notebooks/hill_function_derivation.nblink new file mode 100644 index 0000000..4df908d --- /dev/null +++ b/docs/notebooks/hill_function_derivation.nblink @@ -0,0 +1,3 @@ +{ + "path": "../../examples/biological/Derivation of Hill functions.ipynb" +} diff --git a/docs/notebooks/michaelis_menten.nblink b/docs/notebooks/michaelis_menten.nblink new file mode 100644 index 0000000..e74ae48 --- /dev/null +++ b/docs/notebooks/michaelis_menten.nblink @@ -0,0 +1,3 @@ +{ + "path": "../../examples/canonical/Michaelis Menten.ipynb" +} diff --git a/docs/notebooks/motor_control.nblink b/docs/notebooks/motor_control.nblink new file mode 100644 index 0000000..c1bcb54 --- /dev/null +++ b/docs/notebooks/motor_control.nblink @@ -0,0 +1,3 @@ +{ + "path": "../../examples/cyber-physical/Motor control.ipynb" +} diff --git a/docs/notebooks/parameter_sensitivity.nblink b/docs/notebooks/parameter_sensitivity.nblink new file mode 100644 index 0000000..66c9d40 --- /dev/null +++ b/docs/notebooks/parameter_sensitivity.nblink @@ -0,0 +1,3 @@ +{ + "path": "../../examples/canonical/Parameter sensitivity.ipynb" +} diff --git a/docs/notebooks/qss_with_python_control.nblink b/docs/notebooks/qss_with_python_control.nblink new file mode 100644 index 0000000..21093d9 --- /dev/null +++ b/docs/notebooks/qss_with_python_control.nblink @@ -0,0 +1,3 @@ +{ + "path": "../../examples/canonical/QSS with python-control.ipynb" +} diff --git a/docs/notebooks/toggle_switch.nblink b/docs/notebooks/toggle_switch.nblink new file mode 100644 index 0000000..43638b6 --- /dev/null +++ b/docs/notebooks/toggle_switch.nblink @@ -0,0 +1,3 @@ +{ + "path": "../../examples/biological/Toggle switch.ipynb" +} diff --git a/docs/notebooks/viral_spread.nblink b/docs/notebooks/viral_spread.nblink new file mode 100644 index 0000000..a9b6c4d --- /dev/null +++ b/docs/notebooks/viral_spread.nblink @@ -0,0 +1,3 @@ +{ + "path": "../../examples/ecological/Viral spread.ipynb" +} diff --git a/docs/reductions.rst b/docs/reductions.rst new file mode 100644 index 0000000..f9d7437 --- /dev/null +++ b/docs/reductions.rst @@ -0,0 +1,40 @@ +.. currentmodule:: autoreduce + +********** +Reductions +********** + +AutoReduce implements reduction algorithms in `autoreduce.reductions`. + +Time-Scale Separation +===================== + +Use `solve_timescale_separation` for QSSA-style reductions from a plain +`System`. Use `explore_all_QSS_models` to search across candidate QSSA +reductions directly from a `System`. `reductions.core.Reduce` remains +available for advanced search workflows. + +Conservation Laws +================= + +Use `solve_conservation_laws` to apply conservation-law reductions from a +plain `System`. When conserved sets are detected automatically, the +`search_depth` argument controls how many ODE terms are summed while looking +for cancellations. + +Projection Methods +================== + +Projection-based DMD and DMDc wrappers are implemented in +`autoreduce.reductions.projection.dmd`. They require the `dmd` extra. + +.. code-block:: bash + + pip install "autoreduce[dmd]" + +Abundance-Based Methods +======================= + +The `autoreduce.reductions.abundance` module marks the package location for +abundance-based reduction methods. The implementation currently raises +`NotImplementedError` until the algorithm is added. diff --git a/docs/requirements.txt b/docs/requirements.txt index 6e2442b..c0bcbb4 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -2,7 +2,14 @@ sphinx sphinx_rtd_theme sphinx-copybutton sphinx-toggleprompt -sphinx-autodoc-typehints nbsphinx nbsphinx-link recommonmark +pandoc +numpy>=1.23 +python-libsbml>=5.21.1 +scipy>=1.10 +setuptools-scm +sympy>=1.11 +numpydoc +sphinx-math-dollar diff --git a/docs/solvers.rst b/docs/solvers.rst new file mode 100644 index 0000000..8d74b53 --- /dev/null +++ b/docs/solvers.rst @@ -0,0 +1,21 @@ +.. currentmodule:: autoreduce + +******* +Solvers +******* + +AutoReduce provides numerical solvers in `autoreduce.solvers`. + +ODE Solver +========== + +`solvers.ode.ODE` evaluates a symbolic `System` and solves the resulting ODE +with SciPy. +For most workflows, call `solve_ode(system, timepoints)` directly. + +Sensitivity Solver +================== + +`solvers.ssm.SSM` computes local sensitivity coefficients and Jacobian +approximations for symbolic systems. +For most workflows, call `solve_sensitivity(system, timepoints)` directly. diff --git a/docs/systems.rst b/docs/systems.rst new file mode 100644 index 0000000..7c9f29e --- /dev/null +++ b/docs/systems.rst @@ -0,0 +1,53 @@ +.. currentmodule:: autoreduce + +******* +Systems +******* + +AutoReduce represents models with `system.system.System`. A system stores +symbolic states, symbolic dynamics, parameters, initial conditions, and either +a linear output matrix or a nonlinear output function. + +Core System +=========== + +Use `System` when model equations are already available as SymPy expressions. + +.. code-block:: python + + from sympy import Symbol + + from autoreduce import System + + x = Symbol("x") + k = Symbol("k") + system = System([x], [-k * x], params_dict={k: 1.0}, x_init=[2.0]) + +Parameters can be read and updated through ``params_dict``: + +.. code-block:: python + + system.get_param(k) + system.set_param(k, 0.5) + system.set_param_dict({k: 2.0}) + +python-control Adapter +====================== + +The python-control adapter is implemented in `autoreduce.system.control` and +requires the `control` extra. + +.. code-block:: bash + + pip install "autoreduce[control]" + +The adapter converts a `control.NonlinearIOSystem` into an AutoReduce +`System` by evaluating the python-control update and output functions with +symbolic states, inputs, and parameters. + +PyDMD Adapter +============= + +The PyDMD adapter is implemented in `autoreduce.system.pydmd`. It converts a +DMD operator matrix, or a fitted PyDMD model when PyDMD is installed, into a +linear symbolic `System`. diff --git a/docs/usage.rst b/docs/usage.rst index 31fa68f..6bdcd67 100644 --- a/docs/usage.rst +++ b/docs/usage.rst @@ -1,25 +1,131 @@ Usage ===== -Basic Usage ----------- +QSSA Example +------------ -Here's a simple example of how to use autoReduce: +Quasi-steady-state approximation (QSSA) assumes that selected fast states +relax quickly compared with the states retained in the reduced model. For a +Michaelis-Menten-style mechanism with enzyme conservation, + +.. math:: + + E = E_T - C, + +the full symbolic system can be written as + +.. math:: + + \begin{aligned} + \dot{S} &= -k_1(E_T - C)S + k_2C, \\ + \dot{C} &= k_1(E_T - C)S - (k_2 + k_3)C, \\ + \dot{P} &= k_3C. + \end{aligned} + +If ``C`` is treated as the fast state, AutoReduce solves +``dot(C) = 0`` and substitutes the resulting algebraic expression into the +slow dynamics for ``S`` and ``P``. + +.. code-block:: python + + import numpy as np + from sympy import Symbol, simplify + + from autoreduce import System, solve_timescale_separation + + S = Symbol("S") + C = Symbol("C") + P = Symbol("P") + k1 = Symbol("k1") + k2 = Symbol("k2") + k3 = Symbol("k3") + E_total = Symbol("E_total") + + E = E_total - C + x = [S, C, P] + f = [ + -k1 * E * S + k2 * C, + k1 * E * S - (k2 + k3) * C, + k3 * C, + ] + + system = System( + x, + f, + params_dict={k1: 1.0, k2: 0.5, k3: 0.25, E_total: 1.0}, + x_init=[10.0, 0.0, 0.0], + C=np.array([[1, 0, 0], [0, 0, 1]]), + ) + + reduced_system, collapsed_system = ( + solve_timescale_separation( + system, + [S, P], + fast_states=[C], + ) + ) + + reduced_dynamics = [simplify(expr) for expr in reduced_system.f] + +The reduced dynamics are + +.. math:: + + \begin{aligned} + \dot{S} &= -\frac{E_T S k_1 k_3}{S k_1 + k_2 + k_3}, \\ + \dot{P} &= \frac{E_T S k_1 k_3}{S k_1 + k_2 + k_3}. + \end{aligned} + +Conservation-Law Example +------------------------ + +Conservation laws remove states whose values are determined by invariant +total quantities. For the enzyme-substrate mechanism, + +.. math:: + + E + C = E_T, + +AutoReduce can eliminate ``E`` before applying other reductions. .. code-block:: python - from autoreduce import System - from autoreduce.utils import get_reducible + import numpy as np + from sympy import Symbol, simplify + + from autoreduce import System, solve_conservation_laws + + S = Symbol("S") + E = Symbol("E") + C = Symbol("C") + P = Symbol("P") + k1 = Symbol("k1") + k2 = Symbol("k2") + k3 = Symbol("k3") + + x = [S, E, C, P] + f = [ + -k1 * S * E + k2 * C, + -k1 * S * E + (k2 + k3) * C, + k1 * S * E - (k2 + k3) * C, + k3 * C, + ] - # Create a system - x = [Symbol('x1'), Symbol('x2')] - f = [-x[0] + x[1], -x[1]] - system = System(x, f) + system = System( + x, + f, + params_dict={k1: 1.0, k2: 0.5, k3: 0.25}, + x_init=[10.0, 1.0, 0.0, 0.0], + C=np.eye(4), + ) - # Get reducible system - reducible_system = get_reducible(system) + conserved_system = solve_conservation_laws( + system, + total_quantities={"E_total": 1.0}, + conserved_sets=[[E, C]], + states_to_eliminate=[E], + ) - # Get reduced model - reduced_system, collapsed_system = reducible_system.solve_timescale_separation([x[0]]) + conserved_dynamics = [simplify(expr) for expr in conserved_system.f] -For more examples, see the :doc:`examples` section. +For more worked examples, see the :doc:`examples` section. diff --git a/examples/AutoReduce-BioCRNpyler interface.ipynb b/examples/AutoReduce-BioCRNpyler interface.ipynb deleted file mode 100644 index 5633867..0000000 --- a/examples/AutoReduce-BioCRNpyler interface.ipynb +++ /dev/null @@ -1,791 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Create SBML models using BioCRNpyler" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "try:\n", - " from biocrnpyler import (\n", - " Enzyme,\n", - " Mixture,\n", - " BasicCatalysis,\n", - " MichaelisMenten,\n", - " )\n", - "\n", - " default_parameters = {\"kb\": 100, \"ku\": 10, \"kcat\": 1.0}\n", - " E = Enzyme(\"E\", substrates=\"S\", products=\"P\")\n", - " mech_cat = BasicCatalysis()\n", - " default_mechanisms = {mech_cat.mechanism_type: mech_cat}\n", - " M = Mixture(\n", - " \"Catalysis Mixture\",\n", - " components=[E],\n", - " parameters=default_parameters,\n", - " mechanisms=default_mechanisms,\n", - " )\n", - " CRN = M.compile_crn()\n", - " CRN.write_sbml_file(\"models/example_1.xml\")\n", - "except Exception as e:\n", - " print(e)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Species = dna_X, protein_RNAP_machinery, rna_X, complex_dna_X_protein_RNAP_machinery_, protein_Ribo_machinery, protein_X, complex_protein_Ribo_machinery_rna_X_\n", - "Reactions = [\n", - "\tdna[X]+protein[RNAP(machinery)] <--> complex[dna[X]:protein[RNAP]]\n", - "\tcomplex[dna[X]:protein[RNAP]] --> dna[X]+rna[X]+protein[RNAP(machinery)]\n", - "\trna[X]+protein[Ribo(machinery)] <--> complex[protein[Ribo]:rna[X]]\n", - "\tcomplex[protein[Ribo]:rna[X]] --> rna[X]+protein[X]+protein[Ribo(machinery)]\n", - "\trna[X] --> \n", - "\tprotein[X] --> \n", - "] \n", - " Species(N = 7) = {\n", - "complex[protein[Ribo]:rna[X]] (@ 0), complex[dna[X]:protein[RNAP]] (@ 0), protein[X] (@ 0), rna[X] (@ 0), dna[X] (@ 0), protein[Ribo] (@ 0), protein[RNAP] (@ 0), \n", - "}\n", - "\n", - "Reactions (6) = [\n", - "0. dna[X]+protein[RNAP] <--> complex[dna[X]:protein[RNAP]]\n", - " Kf=k_forward * dna_X * protein_RNAP_machinery\n", - " Kr=k_reverse * complex_dna_X_protein_RNAP_machinery_\n", - " k_forward=100.0\n", - " found_key=(mech=None, partid=None, name=kb).\n", - " search_key=(mech=transcription_mm, partid=strong, name=kb).\n", - " k_reverse=0.5\n", - " found_key=(mech=None, partid=strong, name=ku).\n", - " search_key=(mech=transcription_mm, partid=strong, name=ku).\n", - "\n", - "1. complex[dna[X]:protein[RNAP]] --> dna[X]+rna[X]+protein[RNAP]\n", - " Kf=k_forward * complex_dna_X_protein_RNAP_machinery_\n", - " k_forward=3.926187672\n", - " found_key=(mech=None, partid=strong, name=ktx).\n", - " search_key=(mech=transcription_mm, partid=strong, name=ktx).\n", - "\n", - "2. rna[X]+protein[Ribo] <--> complex[protein[Ribo]:rna[X]]\n", - " Kf=k_forward * rna_X * protein_Ribo_machinery\n", - " Kr=k_reverse * complex_protein_Ribo_machinery_rna_X_\n", - " k_forward=100.0\n", - " found_key=(mech=None, partid=None, name=kb).\n", - " search_key=(mech=translation_mm, partid=weak, name=kb).\n", - " k_reverse=5.0\n", - " found_key=(mech=None, partid=weak, name=ku).\n", - " search_key=(mech=translation_mm, partid=weak, name=ku).\n", - "\n", - "3. complex[protein[Ribo]:rna[X]] --> rna[X]+protein[X]+protein[Ribo]\n", - " Kf=k_forward * complex_protein_Ribo_machinery_rna_X_\n", - " k_forward=0.05\n", - " found_key=(mech=None, partid=None, name=ktl).\n", - " search_key=(mech=translation_mm, partid=weak, name=ktl).\n", - "\n", - "4. rna[X] --> \n", - " Kf=k_forward * rna_X\n", - " k_forward=0.001\n", - " found_key=(mech=None, partid=None, name=kdil).\n", - " search_key=(mech=rna_degradation, partid=rna_X, name=kdil).\n", - "\n", - "5. protein[X] --> \n", - " Kf=k_forward * protein_X\n", - " k_forward=0.001\n", - " found_key=(mech=None, partid=None, name=kdil).\n", - " search_key=(mech=protein_degradation, partid=protein_X, name=kdil).\n", - "\n", - "] \n", - "\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\ayush\\anaconda3\\envs\\py311-new\\Lib\\site-packages\\biocrnpyler\\parameter.py:507: UserWarning: parameter file contains no unit column! Please add a column named ['unit', 'units'].\n", - " warn(f\"parameter file contains no {accepted_name} column! Please add a \"\n", - "c:\\Users\\ayush\\anaconda3\\envs\\py311-new\\Lib\\site-packages\\biocrnpyler\\global_mechanism.py:104: UserWarning: species complex_protein_Ribo_machinery_rna_X_ has multiple attributes(or material type) which conflict with global mechanism filter rna_degradation. Using default value False.\n", - " warn(f\"species {repr(s)} has multiple attributes(or material type) which conflict with global mechanism filter {repr(self)}. Using default value {self.default_on}.\")\n", - "c:\\Users\\ayush\\anaconda3\\envs\\py311-new\\Lib\\site-packages\\biocrnpyler\\global_mechanism.py:104: UserWarning: species protein_RNAP_machinery has multiple attributes(or material type) which conflict with global mechanism filter protein_degradation. Using default value False.\n", - " warn(f\"species {repr(s)} has multiple attributes(or material type) which conflict with global mechanism filter {repr(self)}. Using default value {self.default_on}.\")\n", - "c:\\Users\\ayush\\anaconda3\\envs\\py311-new\\Lib\\site-packages\\biocrnpyler\\global_mechanism.py:104: UserWarning: species complex_dna_X_protein_RNAP_machinery_ has multiple attributes(or material type) which conflict with global mechanism filter protein_degradation. Using default value False.\n", - " warn(f\"species {repr(s)} has multiple attributes(or material type) which conflict with global mechanism filter {repr(self)}. Using default value {self.default_on}.\")\n", - "c:\\Users\\ayush\\anaconda3\\envs\\py311-new\\Lib\\site-packages\\biocrnpyler\\global_mechanism.py:104: UserWarning: species protein_Ribo_machinery has multiple attributes(or material type) which conflict with global mechanism filter protein_degradation. Using default value False.\n", - " warn(f\"species {repr(s)} has multiple attributes(or material type) which conflict with global mechanism filter {repr(self)}. Using default value {self.default_on}.\")\n", - "c:\\Users\\ayush\\anaconda3\\envs\\py311-new\\Lib\\site-packages\\biocrnpyler\\global_mechanism.py:104: UserWarning: species complex_protein_Ribo_machinery_rna_X_ has multiple attributes(or material type) which conflict with global mechanism filter protein_degradation. Using default value False.\n", - " warn(f\"species {repr(s)} has multiple attributes(or material type) which conflict with global mechanism filter {repr(self)}. Using default value {self.default_on}.\")\n" - ] - } - ], - "source": [ - "#Also notice that the names of transcript and protein can be changed, or set to Species.\n", - "total_RNAP = 10\n", - "total_Ribo = 50\n", - "total_DNA = 0.5\n", - "x0_dict = {\"protein_RNAP_machinery\":total_RNAP,\n", - " \"protein_Ribo_machinery\":total_Ribo,\n", - " \"dna_X\":total_DNA}\n", - "\n", - "try:\n", - " from biocrnpyler import * # type: ignore\n", - " class GeneExpressionExtract(Mixture):\n", - " def __init__(self, name=\"\", rnap=\"RNAP\", ribosome=\"Ribo\", **kwargs):\n", - " \"\"\"Initializes a TxTlExtract instance.\n", - "\n", - " :param name: name of the mixture\n", - " :param rnap: name of the RNA polymerase, default: RNAP\n", - " :param ribosome: name of the ribosome, default: Ribo\n", - " :param kwargs: keywords passed into the parent Class (Mixture)\n", - " \"\"\"\n", - " # Always call the superlcass Mixture.__init__(...)\n", - " Mixture.__init__(self, name=name, **kwargs)\n", - "\n", - " # create default Components to represent cellular machinery\n", - " self.rnap = Protein(rnap, attributes=[\"machinery\"])\n", - " self.ribosome = Protein(ribosome, attributes=[\"machinery\"])\n", - "\n", - " default_components = [self.rnap, self.ribosome]\n", - " self.add_components(default_components)\n", - "\n", - " # Create default TxTl Mechanisms\n", - " mech_tx = Transcription_MM(rnap=self.rnap.get_species())\n", - " mech_tl = Translation_MM(ribosome=self.ribosome.get_species())\n", - " mech_cat = MichaelisMenten()\n", - " mech_bind = One_Step_Binding()\n", - "\n", - " default_mechanisms = {\n", - " mech_tx.mechanism_type: mech_tx,\n", - " mech_tl.mechanism_type: mech_tl,\n", - " mech_cat.mechanism_type: mech_cat,\n", - " mech_bind.mechanism_type: mech_bind\n", - " }\n", - " self.add_mechanisms(default_mechanisms)\n", - " # global mechanisms for dilution and rna degredation\n", - " mech_rna_deg_global = Dilution(name=\"rna_degradation\",\n", - " filter_dict={\"rna\": True,\n", - " \"complex\":False},\n", - " default_on=False)\n", - " mech_protein_deg_global = Dilution(name=\"protein_degradation\",\n", - " filter_dict={\"protein\": True,\n", - " \"machinery\":False,\n", - " \"complex\":False},\n", - " default_on=False)\n", - " global_mechanisms = {\"rna_degradation\": mech_rna_deg_global,\n", - " \"protein_degradation\":mech_protein_deg_global}\n", - " self.add_mechanisms(global_mechanisms)\n", - " G = DNAassembly(\"X\", promoter = \"strong\", rbs = \"weak\",\n", - " transcript = None, protein = None)\n", - "\n", - " model_txtl = GeneExpressionExtract(\n", - " \"txtl\", components = [G],\n", - " parameter_file = \"default_parameters.txt\",\n", - " initial_condition_dictionary = x0_dict\n", - " )\n", - "\n", - " CRN = model_txtl.compile_crn()\n", - " print(repr(CRN),\"\\n\", CRN.pretty_print(show_attributes = False,\n", - " show_material = True,\n", - " show_rates = True),\"\\n\\n\")\n", - " CRN.write_sbml_file(\"models/biocrnpyler_gene_expression.xml\")\n", - "except Exception as e:\n", - " print(e)\n", - " # print('BioCRNpyler not found. To run this notebook, make sure you run pip install biocrnpyler first.')" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from IPython.core.interactiveshell import InteractiveShell\n", - "InteractiveShell.ast_node_interactivity = \"all\"\n", - "\n", - "from autoreduce import *\n", - "import numpy as np\n", - "from sympy import symbols" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "from autoreduce.converters import load_sbml\n", - "from sympy import Symbol\n", - "sys = load_sbml('models/biocrnpyler_gene_expression.xml',\n", - " outputs = ['protein_X'])\n", - "for x, x_ic in x0_dict.items():\n", - " curr_ind = sys.x.index(Symbol(x))\n", - " sys.x_init[curr_ind] = x_ic" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[dna_X,\n", - " protein_RNAP_machinery,\n", - " rna_X,\n", - " complex_dna_X_protein_RNAP_machinery_,\n", - " protein_Ribo_machinery,\n", - " protein_X,\n", - " complex_protein_Ribo_machinery_rna_X_]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sys.x" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "new_params_values = [100.0, 0.5, 3.926187672,\n", - " 5.0, 0.05, 0.01]\n", - "sys.params_values = new_params_values" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Create and solve the ODE for the model" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Time')" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, '[Outputs]')" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from autoreduce.utils import get_ODE\n", - "import numpy as np\n", - "timepoints_ode = np.linspace(0, 200, 100)\n", - "sys_ode = get_ODE(sys, timepoints_ode)\n", - "sol = sys_ode.solve_system().T\n", - "try:\n", - " import matplotlib.pyplot as plt\n", - " full_model = np.transpose(np.array(sys.C)@sol)\n", - " plt.plot(timepoints_ode, full_model)\n", - " plt.xlabel('Time')\n", - " plt.ylabel('[Outputs]')\n", - " plt.show()\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Local sensitivity analysis for BioCRNpyler model" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "from autoreduce.utils import get_SSM\n", - "timepoints_ssm = np.linspace(0,20,10)\n", - "sys_ssm = get_SSM(sys, timepoints_ssm)\n", - "# Uncomment to run\n", - "# Ss = sys_ssm.compute_SSM() # len(timepoints) x len(params) x len(states)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "# out_Ss = []\n", - "# for i in range(len(sys.params)):\n", - "# out_Ss.append((np.array(sys.C)@(Ss[:,i,:].T)))\n", - "# out_Ss = np.reshape(np.array(out_Ss), (len(timepoints_ssm), len(sys.params), 1))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Plot heatmap for sensitivity analysis" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "# try:\n", - "# import seaborn as sn\n", - "# import matplotlib.pyplot as plt\n", - "# sn.heatmap(out_Ss[:,:,0].T)\n", - "# plt.xlabel('Time')\n", - "# plt.ylabel('Parameters')\n", - "# plt.title('Sensitivity of protein with all parameters'.format(j))\n", - "# plt.show()\n", - "# except:\n", - "# print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Model reduction starts here:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "sys = load_sbml('models/biocrnpyler_gene_expression.xml',\n", - " outputs = ['protein_X'])\n", - "for x, x_ic in x0_dict.items():\n", - " curr_ind = sys.x.index(Symbol(x))\n", - " sys.x_init[curr_ind] = x_ic" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[dna_X,\n", - " protein_RNAP_machinery,\n", - " rna_X,\n", - " complex_dna_X_protein_RNAP_machinery_,\n", - " protein_Ribo_machinery,\n", - " protein_X,\n", - " complex_protein_Ribo_machinery_rna_X_]" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sys.x" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Conservation Laws (if any)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found conservation laws: [complex_dna_X_protein_RNAP_machinery_ + protein_RNAP_machinery - protein_RNAP_machinery_total, complex_protein_Ribo_machinery_rna_X_ + protein_Ribo_machinery - protein_Ribo_machinery_total]\n" - ] - } - ], - "source": [ - "G, P, T, C1, R, X, C2 = sys.x\n", - "conserved_sets = [[P,C1],[R,C2]]\n", - "con = sys.solve_conservation_laws(conserved_sets=conserved_sets,\n", - " states_to_eliminate=[P, R])" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "sys.params_values = new_params_values + [total_RNAP, total_Ribo]" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[dna_X,\n", - " rna_X,\n", - " complex_dna_X_protein_RNAP_machinery_,\n", - " protein_X,\n", - " complex_protein_Ribo_machinery_rna_X_]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sys.x" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Time')" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, '[Outputs]')" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from autoreduce.utils import get_ODE\n", - "timepoints_ode = np.linspace(0, 200, 100)\n", - "sys_ode = get_ODE(sys, timepoints_ode)\n", - "sol = sys_ode.solve_system().T\n", - "try:\n", - " import matplotlib.pyplot as plt\n", - " plt.plot(timepoints_ode, np.transpose(np.array(sys.C)@sol),\n", - " lw = 3, label = 'Reduced model')\n", - " plt.plot(timepoints_ode, full_model, '--',\n", - " alpha = 0.5, lw = 5, label = 'Full model')\n", - " plt.xlabel('Time')\n", - " plt.ylabel('[Outputs]')\n", - " plt.legend()\n", - " plt.show()\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[dna_X,\n", - " rna_X,\n", - " complex_dna_X_protein_RNAP_machinery_,\n", - " protein_X,\n", - " complex_protein_Ribo_machinery_rna_X_]" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sys.x" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Derive model with no intermediate complexes" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful solution obtained with states: [dna_X, rna_X, protein_X]!\n" - ] - } - ], - "source": [ - "reduced_sys, fast_ss = sys.solve_timescale_separation([G,T,X])" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[dna_X, rna_X, protein_X]" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "reduced_sys.x" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Time')" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, '[Outputs]')" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAaEtJREFUeJzt3Qd0VNXWB/B/eu+9EZJACDX0LiIgTVEEUbEB8vCpqE+x4lOxfWLXZ/f5FFRsKAqigiJNkV5CqIGEUEISUiCd9HxrnzExkzpJ7iSZyf+31qyQOzdz7jBJZuecffa2qKioqAARERGRmbJs6wsgIiIiMiYGO0RERGTWGOwQERGRWWOwQ0RERGaNwQ4RERGZNQY7REREZNYY7BAREZFZs27rC2gPysvLkZycDBcXF1hYWLT15RAREZEBpFRgbm4uAgMDYWlZ//wNgx1ABTohISFtfRlERETUDGfOnEFwcHC99zPYAdSMTuV/lqura1tfDhERERkgJydHTVZUvo/Xh8EOULV0JYEOgx0iIiLT0lgKChOUiYiIyKwx2CEiIiKzxmCHiIiIzBpzdpqwPb24uLitL4PMmI2NDaysrNr6MoiIzA6DHQNIkJOYmKgCHiJjcnd3h7+/P+s9ERFpiMGOAQWLUlJS1F/csr2toaJFRC35PisoKEBaWpr6PCAgoK0viYjIbDDYaURpaal6E5LqjI6Ojm19OWTGHBwc1EcJeHx9fbmkRUSkEU5TNKKsrEx9tLW1betLoQ6gMqAuKSlp60shIjIbDHYMxBwKag38PiMi0h6DHSIiIjJrDHaIiIjIrDHYoSbZtGmTWmrJyspq0+t46qmn0LdvX7S10aNH47777jP4/KVLl6rt5UREHUVmXhF+OZSKb3afabNrYLBjpmbPnq2CErlJsbqwsDA8/PDDKCwsREdw8uRJ9dxlR9PZs2f17pNSAtbW1up+OY+IiLQro3EqMx/f7knCoytiMfbVTRjw3G/452d78OLao+r+tsCt501QXl6BCwVtW0XZw9EWlpaGJbFOnDgRS5YsUTt79uzZg1mzZqk3+BdffBEdRVBQED799FMsXLiw6tgnn3yijp8+fbpNr42IyBzeF4+l5WJn4vmqW1puUZ3nZuQVIzEjH+E+zq1+nQx2mkACHYlQ29Kex8fBy9nOoHPt7OxUNV4hBRHHjRuHdevWVQU7UhFa/v3f//4XqampiIyMxBNPPIFrr7226jF+/vlntUxz5swZDB06VAVMNZeTVq5ciZiYmKpjb7zxhrpVnzX5+OOP8eqrryI+Ph6enp6YPn063n77bXWfLIk9+OCDWLVqFYqKijBw4EC8/vrriI6Orvr6F154QR2TmkfXXXcdfHx8DPo/kOuVgK96sCOfy/Fnn31W79zNmzfjoYcewv79+9U1yjnPPfecmgUS+fn5uPPOO/Hdd9/BxcVFXXNNcv3//ve/8eWXX6rn1atXL/V/LMtdRESmrqy8AoeTc7AjMRPbT5zHrpPnkX3R8FIZu09eaJNgh8tYHcTBgwexdetWvXpBixcvVrMe77//Pg4dOoT7778fN998s3rTFxLgTJs2DVOmTFHBzD/+8Q88+uijTR77vffew/z583H77bfjwIED+OGHH9ClS5eq+2fMmKEK6a1Zs0bNQPXv3x9jx47F+fPn1f3Lly9XQdXzzz+P3bt3q+rC7777rkFjX3XVVbhw4QK2bNmiPpeP8rk8p+pkqWvy5MkYNGiQCnbkmj/66CMV7FSSQEj+byQo+/XXX1X+0t69e/Ue5+6778a2bdvw1VdfITY2Vj03mWE7fvx4k//fiIjaWmlZOWKTsvDf3xNw29Jd6Pv0r5jy9hY899MR/HbknMGBjoONFUZ08YK7ow3aAmd2zNiPP/4IZ2dnVQVaZhyk1UXlbIp8LsHDb7/9hmHDhqlj4eHhKhj44IMPcOmll6o3/IiICDUjI7p166aClaYug0nA8MADD+Bf//pX1TEJKoSMt3PnThXsyEyUeOWVV9Rs0bfffqsCJJklmjt3rrpVPp5ctyH5R5KvJAGczCyNHDlSfZTP5Xh1EjzJ7Jf8/8hSX1RUFJKTk/HII4/gySefVDNKEvwsW7ZMBWKVy2HBwcFVjyHLYjJrJB+l4raQ2Z+1a9eq4/L/TUTU3mdujqTkYFtCJradyMSuxPPILSpt8uN4OdliUGdPDOzsgcFhnuge4Aobq7abX2GwY8Yuu+wyFbDI8ossAclyjCwfCVlOkjfwyy+/vFbT0379+ql/HzlyBEOGDNG7vzIwMpQEMRI0VAYINcksSl5eHry8vPSOX7x4EQkJCVXXcccdd9S6jo0bNxp0DbfddhuGDx+ugo1vvvlGzbxIAFidjCGPWb2o34gRI9S1JSUlqdkg+b+p/v8hS10SAFaSQFAqbstyYHUSWNZ8fkRE7UFFRQXi0/LwZ3wGtiZkYkdi05alKgV7OGBwZ08V2AwK80S4t1O7KpLKYKeJycGSM9PW12AoJyenquUimdGQHBiZnZAZEnkTFz/99JNK1q2ucobFEDJbVDO7vnqrg8p+T/WR65BlKVkSqkmrLdq9e/dWMzUzZ85E9+7dVR5N9Rwjrchzkd1fshRXs6+VzLAREbUHZ7Mu4s/jGfgzQRfgpNeTUNwQCWaGhOuCm8FhXghyr/G7/mIWcCERuHASCOgLeIahLTHYaQLZBWVocnB7I0HJY489hgULFuDGG29Ejx49VFAjSy6yZFUXCQwkv6a67du3630uicKS3CwBT2UUXz2QkETezp07Y/369WqmqSbJz5Gvl1knOa++69ixYwduvfXWeq/DkNmdu+66S8101TfGihUr9J7Hn3/+qa5flqpkFkeWvuQ6OnXqpO6X2Z5jx45V/f/JjJjM7Mhs1iWXXNKk6yMiMpbsghJsO5GBLfEZ+DM+U+2IaqoIHycMDffCkHAvDA3zhK+rvf4JpUXAhVO6AOd8InDxwt/32Toz2KHWI8mykmT7zjvvqFwSuUlSsuzKknyW7Oxs9Qbv6uqqdiLJ0pHk68jXSHKyzFhIUbzqZJdReno6XnrpJbWLS/JTJNFYHqOSJBfLY0kn70mTJiE3N1eNc88996gdYrJ8NHXqVPUYsgQky14y43TNNdeonVmS6yN1g+TfsrT0+eefq4RqyTEy1Lx589Tzr2+2SAIhyQ2Sa5Ik47i4OCxatEgFhxIoysyMzIjJ/4UsSclzkV1Xcl8lufabbrpJBWXy/ybBj/zfSKDXp08fXHHFFc163YiImqKkrBz7Tmfhj+Pp+ON4hkowLm9ieZswb11wMyzCC0PDPeHrUiO4kRn93BRdYHP+BJCTDFSU1/1gMrvTxhjsdCAyeyJv5BJUyBZq2XotMzOyK+vEiRMqEJCZFpkBEjKDIbMdEhC99dZbGDx4sMp7kVmS6jMiktwrx+XxJCdIgijZzl5JAidJJpa8IbnP29u7anu7zKLI9nYJHObMmaOCA9kuP2rUKPj5+alzrr/+epW/U1kUUcaQ6//ll1+a9Nxl3PrIUp5chwQzstwnMzkS3Dz++ONV57z88stqqUp2csmMjyRdS4BYnSQiVyZkyw4vGVO27F955ZUGXysRUVOdzMhXwc3mYxnYfiITeU1MKg5ws8fwCG+1Y0oCnAC3OlIQivL+mrk5oQtySi4a9uD5GUBhDmD/9x/Brc2ioq3KGbYjOTk5cHNzU29c1WckhLy5JiYmqgrE9vY1IlsijfH7jYgMkV9UqnZMbTqWht+PZeD0+YImfb27ow1GRHhjeBcvFeR09nKsnVBcXg7kJgOZCcD5BCD3XPMvOOoKIKAPWvP9uzrO7BAREbVzMi9xPC0Pm+LSsPlYOnYlXkBxWT3LRnWwtbZUu6VGdvXGyC7e6BHgWn81/vQ4IO2IbhanRKMWQypRWftgx1AMdoiIiNqhguJSbI3PxMa4NGyKS1e7qJpCAppLunrjkq4+qt6NvY3+LtF6ZRzTBTtayk7S5fm00XZ0BjtERETtxOnMAmw4eg4b4tKxPSGzSbM33s52GNXVG6MifTCiizd8XJq5e9gzAkg9iBZz8QM8OgMeYYBbSJsFOoLBDhERURu2Y9h7Ogvrj5zD+qNpqsCfoawtLTAg1AOXdvPBpZE+6O7fwNJUebnUIDHsgT3DAQvL+ndX1cfOWRfYyNd7hAK2TmgvGOwQERG1opzCEmyOS1cBzqZj6cgqMLxicaCb/V/Bja/aOeViX0+vKVkyKsjULUllHAccPYHu+j0B62VjD7gFAVlnGj7P0hpwD/k7wHHybtPZm4Yw2CEiIjIyybf57fA51TxTtoaXlFUYPHsj+Taju/nism6+iPRzrr8Ng8ze5Jz9O8CpXtjv4vkmzu5E1B3sSNAkgY3c3DsBVm3T2LOpGOwQEREZYffU0dRc/HroHH49nIpDyTlNaqIpwc2YKF9cEukN1/pmb0RZKZB16q8A5xhQXM8W9JJCIPuMbnnJoIvoApzYpJu9ka+pDHAk2DFBDHaIiIg06hi+59QF/HIoVQU4Z84bvntKuoKP664LcKKD3evPvRGlxbrCfhlxQGa87nNDZB43PNiRJak+15nU7E1DGOxQnaQNRN++fVULBSF9q+677z51aysnT55Uxfb27dunrq05z4OISEvFpeXYmpChApx1h88hI8+wwMPWylJVKlYBTne/2o0065qZkcBGAhwJdGRGp6ky4oGIsYbl1cg5XhEwFwx2zJT0kvrkk09qHT9+/HhVJ3QtSf+rp59+GhMmTFD9saqTNgvS6kEaZtbV3ZyIyJQUlpSpwn5rD6aqHJzcwlKDqxaP6eaLy3v44ZJIHzjbNfIWLO0YJPdGivxJgb/yspZd+MULQMF5wMkLHQ2DHTM2ceJE1aupOumFZSwBAQHYuHEjkpKSVKfwSh9//HFVp3AiIlMt8LfxaDp+PpiCjUfTUFBsWOAhMzYTevqrAGdQZw9YW1k2PoMjuTfpR3VVh1sa4FRn7wYU5TDYoSY4uQU4tdX44/S/FXDxb9aX2tnZqaaadc36ZGVlYeXKlVXHZHkqJiamRTMv0gl8wIABakZJGnuKrVu3IiMjQ3UcP3z4cNW50mldGmZKw1Bp/ikNRV944QUVoFXauXMn/vnPf+LIkSPo1atX1WNWd/DgQdW8848//oCTkxPGjx+vGo421PSTiKgpAc5PB5LVx4slhgUeUf4uGN/THxN6+qkqxvXunqoku6TSDgFpR7WZwalO3j+8uwLekYCTT7vdGm5sBu5BMw7ptj1o0CDVQVreKKdOnYq4uLhajRHnz58PLy8vODs7q47X587pNyM7ffo0rrjiCjg6OqrHkTe/0tJmrGc2hdQwkG9IY99MjHREX7p0qd6szk033QRbW1u98/7zn//g1VdfxSuvvILY2Fi1/HXVVVepZTYh3cWlU3iPHj2wZ88etUwmHdOrk4BtzJgx6NevH3bv3q2Wz+R747rrrmulZ0tE5rhEteZACuZ/vhf9n12H+V/sxc8HUhsNdPp3csdjk6Ow+aHRWHvfKCy4PBI9A90aD3SEnJP4uy4np6W/96UYoCQhdx0PDLsLGDgH6DwScPbtsIFOm8/sbN68WQUyEvBIcPLYY4+pv8xlBkD+Shf3338/fvrpJ3zzzTeqs+ndd9+NadOm4c8//1T3l5WVqUBHZjBkFiElJQW33norbGxs8Pzzz6Mj+/HHH1WAWGnSpEnq/9GYJEC544478Pvvv6tZnuXLl2PLli0q6KlOgpxHHnkEN9xwg/r8xRdfVEtgkkj8zjvv4IsvvlCzPx999JHq/t2zZ0+1PHbnnXdWPcbbb7+tAp3qr7OMExISgmPHjiEyMtKoz5WIzENRaZnqHP5jbLKqhZNvwBKVbJYa1NkTk3sHqGUqfzf75l+ABCG+3YHTO5r39bI93DMM8Ommq49j69j8azFTbRrs1ExklRkBmZmRv+RHjRqlWrbLm5288clf8EJyUGTJY/v27Rg6dCh+/fVXFRz99ttv8PPzUztvnn32WfVGKrMBNWcUOpLLLrsM7733XtXnlQGkMUmQefPNN6vX6cSJEyrg6NNHv9NtTk4OkpOTMWLECL3j8vn+/fvVv2XpSr5OAp1Kw4YN0ztfzpUAqXpAVykhIYHBDhE1uE18W0Imfth/ViUa5xiQZGxlaYFh4V6Y1FuWqPxVLyrN+PZoWrAj28GlFo5PlK7+jXXHfa8zuZwdCW6Ep6euaJEEPSUlJRg3blzVOVFRUSrZddu2bSrYkY+9e/dWgU4lWRKRGYBDhw6pv/xrKioqUrfqb77mSIKbunZeWVpaqoJX1cn/s5ZLWUOGDFH5NPJvY5GlrilTpqhZobqSpYmIqpPfezFnsrAqJhk/xqYgI+/v94GGApzhEV5qBmd8Dz94GRrg5KXpeksZmnPp7Ac4eOhXPa7J2k6XeyMzONKiwapdvYW3a+3mf0qWLCRJVv66l2RUkZqaqmZm3N3d9c6VwEbuqzyneqBTeX/lffXlCsk26Y5KdmRJIFKdJCfLrIwWZMlJbpKLc+ONN9a639XVFYGBgWopUrajV5LPBw8erP4ts3efffaZytmqnN2R2bzq+vfvjxUrVqgaQNbW7eZbmYjaGWmu+UPMWazan4xTmfVUGK6xRDU03AtX9gnExF7+8HQycNakMAdIOwycOwjkpevq1EhhvqYsZdXc+CJ9qlSAE6XrIG5pZdjjkZ528w4huTvyBiz5Hca2cOFCLFiwQG9mR/I8mkS+MU30m06WBKX2zaeffqqWhpYtW6b+7+uaBWuuDRs2qNmimoFqJUkiX7RoESIiItTSoyx7ScD1+eefq/slSJLdV/PmzVOvlxQUlDyfmt8zH374IWbOnKnq+MiMYHx8PL766iv873//g5WVab4+RNRy6blFWL0/GStjziI2Sbdq0BjZGj4lWhfg+LoYmINTWqSrg3PukK5tQ/VZ8/OJQHG+4d2/ZSlLgh2ZwZHZGwY45hXsSNKxJNNKUmv1+iySdFxcXKx23VR/05QdN5VbquWjbFGurnK3Vl3briu3ZMutRSS7XW4mSJb5nnjiCRUgyMyJLDVJUveBAwc0G6Ox/KB7771XLVs+8MADSEtLU7uufvjhB3Tt2lXdL3k4q1evVsnOEoTJ/bJcJbvxKlXODkl+liS2y9JkaGio2r4uS3VE1LFcLC5TbRq+33cWfxzPUHk5jekV5IqrogNxRZ/AxqsYV98qLoFN6gFdReP6qhnLMlbaESB4oGGP6+wD9J0JuIUwwNGYRUXN5I1WJEPfc889+P7771V9l8o3ukryZihLLl9++WXVm5xsTZe8ncqcnTVr1qgdQLILS5KbhdRukZkDeRM1JKiRmR3Z6SXjyRJLdRIMJCYmqjYF1ZNliYyB329ETVNeXoGdJ8/ju71Jaot4XlHjicadvRxxdd8gXNU3EBE+tTc41Cs/Ezh3AEg9CBTlGvY1roHAgFmGj0FN0tD7d7uZ2ZFlCNlptWrVKlVrpzLHRi7cwcFBfZw7d65acpIlCnkiEhzJ0osEOkL+ope/+m+55Ra89NJL6jEef/xx9dgtnr0hIqJ26XRmAVbsTVK3pAuNN9yUnVNTogMwtW8Q+gQbWP+mcplK8nBkFif7bNMvNCdZ16LBRLuFm4s2DXYqt0VLs8bqJH9DqvwKqYYrSxIysyPLFLIE8+6771adK3kZsgQmu68kCJLlk1mzZuGZZ55p5WdDRETGlF9Uip8PpODbPUnYkXi+0fMdbKxU/s3UfkEYEeHVeKuGSrLgkXUaSI3VtW1oTtPN6iSfJ+ySlj0Gme4yVnvBZSxqL/j9RqRP3qL2nLqA5bvPqO3ijfWkkgmbkV28Ma1/EMb38IdTY802a+6mkp1UKbENbwE3lKMX4NcT8Ouh21ZOHXMZi4iIqC5pOYX4dm8Svt2dhBMZ+Y2eH+nnjOn9g1UuTpOqGUt7hswEIGU/cD5BfzdVc0j1Yl8JcHrqaux04BYN7QmDHQNxAoxaA7/PqCMrLSvH5mPp+GrXGWw4mtbobip3RxtcHR2IaweEqF1VBufhVDq7R7fVuyivZRcu7Rq8uwB+vXVtG7iTqt1hsNOIylotsgVekqaJjKmgQFfwTKsCj0SmIOlCAZbvOoPlu5OQmlPYaMG/0d18MWNAMMZ094WddQsCC5nVaUmg4xYE+PcGfLrriv9Ru8VgpxFSmVe6qaenp6s3INZvIWPN6EigI+USpKYUCyKSuSspK8f6I2n4atdpNZvT2KRmuLcTZgwMUbk4fq4aBRZ+vYATm5rWadzOBfDvBfj34Q4rE8JgpxEyLSp9liRp9NSpU219OWTmJNCprxgmkTk4m3URX+08ja93nUFablGju6mu6BOAGwaFYECoR9OXqQzJr5FWDFL4ryGyLCXnySyO9KTiH70mh8GOAaQ/lxQ8lKUsImORmUPO6JA5ktyb34+l4/Mdp1QuTmOFjaOD3XD9oE6qLo6LfROXdEsKm7akFBBdf7Dj7Ku7X5KNbZjGYMoY7BhIlq+4FZiIyHCZeUUqD0eCnMYK/7nYWeOa/kG4YVAn9AisfwtxnWQNLOcscHavri7OwLmAk5dhXyu9pxzcgYtZus+lL5UEN7JMxd1UZoPBDhERaZp/tvd0FpZtP4WfYlNQXFbe4Pn9O7lj5uBOarnK0baJb0llJbrqxrKrKlfXE1FJ3gd0HWfYY0gwE9AXyIwHAvvqmm9acYOAuWGwQ0RELVZYUoYf9ifj020ncfBsToPnOsssTr8g3DikE7oHuDZjsGzdLE5KjG7ZqiapfBw2CrC2NezxOg0FQoc1/TrIZDDYISKiFm0bX7ZdEo5P40JBSYPn9gx0xc1DQ1WX8SZVNq7ewkFmcTKONVz8r7KflczUGIJLVWaPwQ4RETV5qWpn4nks+fMkfj2c2mDCsa21Ja7sE4Bbhoaib4h703dUSV8qCVySdgF5aYZ/nSxlGRrskNljsENERE1aqpIg50hKw0tVwR4OahbnuoEh8HQycDmpOin2JwFL8l6gWFdss0lyU3Udx10Dm/61ZHYY7BARUYPSc4vw2fZT+Hz7KWTmN1yC45Ku3rh1WGeMifKFlZQ7bqq8dCBpp65TeFOK/dWsi+PbHbCya97Xk9lhsENERHWS2ZuPtiTih5jkBndVOdla4doBwbhlWGd08XVu+kCSf3MhETizCzh/ovkXbO8KBPbT1caxdWr+45DZYbBDRER6+TjSvuF/fyRiS3xGg+eGejli1rDOuHZgMFybWvxPyMyN5OOc2aGb0Wkuj1AgaADg1ZXVjalODHaIiAhFpWVYFZOMj/5IRNy53AbPHdHFC7eNCFMNOZu1VCXbxWXbeNJuoKjhseplZa3rbRU0EHD2ad5jUIfBYIeIqAPLvliCL3acxpI/ExvsVWVrZYmr+wbitpFhzauNU138OiD1YPOXqmQWR5aq2MKBDMRgh4ioA0rJvoiPtyTiy51nkFdUWu95Xk62aleV3HxcNEr4ldmYpgY7bkFA8CDAuxuXqqjJGOwQEXUg8Wm5eH/zCazcdxalDRTIifBxwj8uCVeVju1tNG5Q6xqg60l14WTD51lYAj7dgJDB3EJOLcJgh4ioA9h7+gLe35SAXw9X6yFVh6Hhnrh9VDhGR/rCsjn5OIbqNKT+YEfaPEi/KlmukiadRC3EYIeIyIx3Vv0Zn4l3NsZj24nMes+TmGZS7wD8c1Q4+gQ3M7iobN9gaIVkjzDAxU+/gafk48hSleTjSPdxIo0w2CEiMjPl5RVYd+Qc3t0Yj/1J2fWeZ2dtqSoc/+OSMIR6OTU/yEmPA079qVtu8u9t2NdJUBQyFDi8CnD21TXjlI7jUhCQSGMMdoiIzERZeQV+jE1WMznHzuXVe56rvTVmDe+sbt7OzZxBKS/X1cg5vQ3I/6sez6ltgG9PwxOIJbjp6wi4h7IZJxkVgx0iIhNXUlauEo7f3ZSAxIz8es/zc7XDP0aGY+aQTnBuatfx6kHOuYO6IKfgvP59BZlARpyuVYMhJCiSRGUiI2OwQ0RkoopLy7FibxLe3RSPM+cv1nteJ09H3HFpBKYPCIKddTOXiaTaceoBXZBzMav+805t1c3YcKaG2hEGO0REJhjkfLsnSS1Xnc2qP8iJ9HPGXaO74Mo+AbC2smx+kCMzORLENBTkVMpLAzITAO8uzRuPyAgY7BARmVCQ882eM3h3Y0KDQU7PQFfcM6Yrxvfwa/728crlKkk8NiTIqU6+xiuCszvUbjDYISIygZwcmcl5e0PDMzl9Q9xx79guuKybLyyaG2hUJh5LwFIzJ8cQ0m1clrFklxaDHWonGOwQEbVTpWXl+H7fWby54XiDOTkDQz3wr3FdMbKLd/ODnMot5Cf/+Ht3VVPYuQCdhgEBfQCrZnRAJzIiBjtERO2wTs7q2GS88dvxBndXDersgfvGRWJ4hFfLghzJsUncrMu3aSp7NyB0GODXW9eJnKgd4ncmEVE7qnj8y6FzeH3dMcSdy20wyLl/XCSGtSTIERdO6YKc7LNN/1pp4yAzOVJEkIUAqZ1jsENE1A6CnD+OZ+CVX+MQ20DF4/6d3LHg8m4Y0aWFQU5OCpD4O3D+RPOCnNDhgF8vBjlkMhjsEBG1cYPOl9YexfYT9ScDRwe74f7LI3FppE/LghwRtwZIjmnmctVwzuSQSWKwQ0TUBo6dy8XLv8RhXQNdyKP8XfDA+G4Y170Fu6vqClqamngsQY4052SQQyaKwQ4RUStKzrqocnKk8nH5X43Cawr3dlIzOVf0Dmh+nZz6BA0EknYDxfUnPldtIVdBTl8mHpPJ43cwEVEryCooxnubErBk60lVHLAuAW72uG9cV0zvH9z8iseNsbYFOo8Ajv1a9/029rrE46AB3EJOZoPBDhGRERWWlOGTrSdVa4ecwtI6z/F0ssVdoyNw89BQ2Nu0wlKRzNac2QVcvPD3MQlsQoYAwYN0AQ+RGWGwQ0RkpFo5q/afxSu/HKu36rGjrRX+cUk45l0SBhf7Fs6iNKViseTehI0CDq8CLK2BoH662RxZuiIyQwx2iIg0tjU+A8+vOYKDZ3PqvN/a0gI3Dumk+lf5uNi1bDCZnTmxCbBzBbqMNfzrfLsDBZm6isdNTVomMjEMdoiINJKQnofFPx/Bb0fqr0QsHcgfHN8Nnb1bOItSUqjrX3V2j64zuczWBPUHHDwM+3qZBQq7pGXXQGQiGOwQEbXQhfxi/Gf9cSzbfgql9WyxGhLmiccmd0d0iHvLBpNGnSkxuqKAJdWWxyTgObEZ6Dm1ZY9PZIYY7BARNZPsqvp020m8uf54vcnHXXyd8ejEKIzVolaOVDyOX19/o860I7oEY7eglo1DZGYY7BARNaO9w/ojafi/n4/U26jT29lW1cq5fmBIy7eRF5wHEjYAGccbPzdhPdDvFsOTlYk6AAY7RERNEJeai+d+Oqx6WdXF1tpS7a66c3QXONu18FdsaZEuL0eKAMoylSGkqWd6HOAb1bKxicwIgx0iIgOLAkrl42U7TqOsnrycq/sG4qEJ3RDs4djybeSpB3S7rBqrdFydzOZI7yrXwJaNT2RmGOwQETVAApsvd57Gq7/G4UJBSZ3n9A1xx5NTeqB/JwN3QjXWkfz4r0BOctO+ziMUiBgLuPi1/BqIzAyDHSKieuw6eR6LVh3C4ZS66+X4u9rj0UlRuCo6sOU9rIoLgMTNQMp+3cyOoWSrecQYwLsr83SI6sFgh4iohrScQixecxTf7ztb5/121pb456URuOPScDjaWmuwlXzfX1vJCw3/Oms7oPNIXQ8rdiMnahCDHSKiv5SUlas+Vm/8dhx5RXVvJZ/c21/Vy2lxXo6QpapjvwC5qYZ/jczeSG8rKQjI9g5EBmGwQ0QEYPuJTDy56iCOncur8/5ufi5YdFUPDI/wbvlgzV2ycg8BulzOvByiJmKwQ0QdWnpukWrx8F09S1Yu9tZYcHkkbhka2vJ6OWqXVSyQsFG/+nFj7F11eTk+UczLIWoGBjtE1GF3WX2x4xRe+iUOufVUP752QDAemRjV8mad1aXEGh7oSC5OyBBdR3JrW+2ugaiDYbBDRB3OgaRsPPb9ARw4m13n/T0DXfHM1b0wIFSDreTVyaxM5ERg98dARXnD58ruKpnNcfTU9hqIOiAGO0TUYeQWluDVX4+pflZ11QWUJSspCnjTkFBYtXQreX2cfYCQwcDp7XXf7+Cuy8vx7mKc8Yk6IAY7RNQhelmtPZiKp1YfwrmcojrPuaZfEBZOjoKvi73xLyh0hK5pZ2G1mSVLa6DTUN3Nysb410DUgTDYISKzlpx1Ue2y+u1IWr1dyZ+9uheGRXi13kVJ/k3Xy4ED3+o+94oAuozjkhWRkTDYISKzTUCW5apXfolDfnFZnYUB7x3bFfMuCVfNO1tMdlo1ZaeU5OQE9Qc8OgPekdxlRWREDHaIyOwcScnBo98dwP4zWXXef0lXbzw3tRdCvTQoyifdyM/sADLjgb43Na2aceSElo9PRI1isENEZqOwpAxvbTiODzafQGkdGcjeznaqYeeUPgGw0GImRZp2xv0M5P21RHZmJxA6rOWPS0SaYrBDRGbTtPORFbE4kZ5f5/0zB4fg0Ynd4eaoQfJvWSlw8g9dcFN9C/nJLYBPN+beELUzDHaIyKRJD6uX1h7Fp9tO1Xl/uI8TFl/TG0PCNUpAzjoDxK0BCjJr31deqruv743MwSFqRxjsEJHJ+v1YOhZ+dwBns2pXJLa2tMBdoyNw12VdYG+jQVfw0mJdP6uzexruZ5V1WtfzKrBvy8ckIk0w2CEik5NTWIL/+/EIvt59ps77o4Pd8ML0Puge4KrNgBdO6XJzLtad8FzLiY2Abw+2eCBqJxjsEJFJ2RiXhse+O4CU7MJa99nbWOLB8d0wZ0SYNhWQK2dzknYb/jVO3kC3SQx0iNoRBjtEZDKzOc+uPoxv9iTVef/QcE+8OL2PNtvJK5ejjspszgXDzrewBEKH65p2WvFXK1F7wp9IIjKJ3BzZaVXXbI6TrRUWTu6OGwd3gqUWszllJX/P5jSUm1Odiz8QdQXg7Nvy8YlIcwx2iKhd77T6v5+O4Mudp+stDrh4Wm8EezhqM2BOMnD0JyA/w7DzpZ9V2CVA8GDAUoMqzERkFG360/n7779jypQpCAwMVAW+Vq5cqXf/7Nmz1fHqt4kTJ+qdc/78edx0001wdXWFu7s75s6di7y8vFZ+JkSktR0nMjHxjd/rDHSc7azxwrTe+PS2wdoEOlIFOfF3YO9nhgc6bkHAwNt0jTsZ6BC1a206s5Ofn4/o6GjcdtttmDZtWp3nSHCzZMmSqs/t7Oz07pdAJyUlBevWrUNJSQnmzJmD22+/HV988YXRr5+IjFMF+dVf4/C/LYl1riKN7OKNF6/tgyB3B20GlODmyA9A7jnDZ3PCLwWCBjLIITIRbRrsTJo0Sd0aIsGNv79/nfcdOXIEa9euxa5duzBw4EB17K233sLkyZPxyiuvqBkjIjIdB89mY8HyGBw7V3t21tHWCo9N7o6bhnTSptWDRFJSMydho64YoKGzOd2uAJxasUM6EZl/zs6mTZvg6+sLDw8PjBkzBs899xy8vHS/aLZt26aWrioDHTFu3DhYWlpix44duOaaa+p8zKKiInWrlJOT0wrPhIga6lD+/uYEvL7uWJ09rQZ39sQrM6LRyUuj3JzCHF1uzoWTTcjNGQUED+JsDpEJatfBjixhyfJWWFgYEhIS8Nhjj6mZIAlyrKyskJqaqgKh6qytreHp6anuq8/ixYvx9NNPt8IzIKLGnDlfgPu/jsHuU7W3eNtaWeKhCd0wd2SYNjutKmd0Dn2vS0Y2dKdV9ym6+jlEZJLadbBzww03VP27d+/e6NOnDyIiItRsz9ixY5v9uAsXLsSCBQv0ZnZCQkJafL1EZLiKigqs2HsWT/1wSO26qqlnoCteu64vuvm7aDuwLIF1vVyXjFy9iWet8yyBziN0dXMsNWg3QURtpl0HOzWFh4fD29sb8fHxKtiRXJ60tDS9c0pLS9UOrfryfCrzgGomOhNR68kqKMZj3x/Azwdqz8DKBM5do7vg3rFdYWttpCUj10DdlvETm+u+X2Zxoq4EXAOMMz4RtSqTCnaSkpKQmZmJgADdL6Bhw4YhKysLe/bswYABA9SxDRs2oLy8HEOGDGnjqyWiumxLyFRJyHUVCAzxdMAb1/fFgFBP419IyFDg/AldF/PqJC9HdltZ2Rj/GojI/IMdqYcjszSVEhMTERMTo3Ju5CZ5NdOnT1ezNJKz8/DDD6NLly6YMGGCOr979+4qr2fevHl4//331dbzu+++Wy1/cScWUftSUlauEpDf25xQ55byGQOCseiqnqqGTquQRGOZvdn9ka4Hlp2LrgqyZ1jrjE9ErcaiQhbO24jk3lx22WW1js+aNQvvvfcepk6din379qnZGwlexo8fj2effRZ+fn5V58qSlQQ4q1evVruwJDh688034ezsbPB1SM6Om5sbsrOzVXFCItLWqcx83PvlPuxPyq51n7ujjSoQOLFXGy0ZnTsEZMYDXScANvZtcw1E1CyGvn+3abDTXjDYITKelfvO4t/fH0B+cVmt+0Z08VJJyH6uGgUZZaW6ZGIt6vAQkdm8f5tUzg4RmY78olI8ueoQVuyt3aXcxsoCD47vhnmXhGu3pVwqIR9eqatsHNhXm8ckIrPAYIeIjFIJWZatTmTk17ov3NsJ/7mhH3oHu2kzmExOpx4Ajv+im9mJXwe4BgHOPto8PhGZPAY7RKQZWRX/dNsp1am8uKx2DZvrBgZj0ZSecNIqCbm0CDj2iy7vppIEPDLDM2A2d1QRkcJgh4g0kX2xBI98G4u1h2rXzpEdVv93TS9c3TdIuwHz0nSVkAvO172kFf8b0K3h3ntE1DEw2CGiFos5k4W7v9iLpAsXa90XHeyGN2f2Q6iXk3bLVin7gePrGm7gmRwDuIcCfj20GZeITBaDHSJq0bLVx3+exAtrjqCkrPbGzttHhatEZM0qIUs9nGNr9ZetGpK8D/Dtzt1ZRB0cgx0iapacwhI8/E3dy1YejjZ49bpojIn6uyZWi8nSlCxbyUdDBA8Ewi9joENEDHaIqHm7reZ/sRenMgtq3Teos4datgpwc9BuQJnJiftZl3zcGCkM2O0KwCdSu/GJyKQx2CGiJi1bfbXrDBb9cAjFpbV3W901OgILLo+EtZVGy1YS3CSsB87uNex8tyCgx9WAvUbb2onILDDYISKDXCwuw79XHsB3e8/W2fLh9ev74rJuvtoNWJitW7bKSTHs/E5DgLBLdRWUiYiqYbBDRAb1tvrnZ3twNDW31n19Q9zxzk39EeSu4bKVdCM//ANQUnt3V53LVtLQ07urduMTkVlhsENEDfrt8DncvzwGuYW182VuGxGGRydFabfbSraVn94GJP6u+3djXAOAHlMBB3dtxicis8Rgh4jqVFZegdfXHcPbG+Nr3edka4WXZ0Rjcm8NO5VLNeQjq4GM44bvtooYw2UrImoUgx0iqiWroBj3fhWD34+l17qvq68z3r9lACJ8nLUbULaTH1xRdzXkmqQFRLfJLBZIRAZjsENEeg4n5+Cfy3bjzPna+TJXRQdi8bTe2vW2EunHgCM/AGUljZ/r5A30nAY4eWk3PhGZPQY7RFRl5b6zePS7WBSW6G8rt7a0wONXdMes4Z1hoWWRvvQ44OB3hp0rMzmRkwBrW+3GJ6IOgcEOEaG0rBwvrDmK/21JrHWfj4sd3r2pPwZ19tR+YM9wwNlX19SzPhaWutwcydFhNWQiagYGO0Qd3IX8Ytzz5T5sia/dhqF/J3e8d/MA+LnaG2dwyb/pNR3Ys7Tubea2TkDPqYB7J+OMT0QdAoMdog7saGoO5n1ad37OTUM6YdGUntptK6+PbBuXgGb/10BFuX415J7XAHYuxh2fiMwegx2iDmrNgRQ88M1+FBSX6R23tbLEs1N74vpBrTib4tEZiLgMiF+v+zyoP9BlHLeVE5EmGOwQdTDl5RX4z/rj6laTr4udWrYaEOrR+hcWPEi3Bd01EAjs2/rjE5HZYrBD1IEUFJfigeX7seZgap1tHz64xYj5OY2R5OOoyW0zNhGZNQY7RB3E2ayLmPfJbhxOyal137UDgvHc1F6wt9Fw2ejiBcDenTuoiKjNMdgh6gD2nLqAf362Gxl5xXrHLS2Ax6/ogTkjNK6fk3YUOLoaCB0JhA7T7nGJiJqBwQ5RBygU+PC3sSgu0y8U6GJvjbdv7I9LI320G0yad57aqmvkKU5sAhy9AJ9I7cYgImoiBjtEZpyI/MZvx/DmhtqNPMO9nfDhrIHa9rcqKwXifgbOHdI/Lq0g7G8BXPy0G4uIqAmMXECDiNrCxeIyVSiwrkDnkq7e+P6uEdoGOsUFwP4vawc6QnpeHfwWKMrTbjwioiZgsENkZtJyC3HDf7fhpwMpte6bNSwUS2YPgpujjXYD5mcCez8FspPqP6cwR9fVXGZ/iIhaGZexiMxIXGoublu6S+28qs7K0gJPTemBW4Z11nbACyd1jTxLixo/1zVI1+eKiKi9BjuxsbFNfvAePXrA2prxFFFr+P1YOuZ/vhe5RaW1EpHfubE/RmmZiCxSDwBxa4By/QrMtUiAEzkeCOyn7fhERAYyOBLp27ev2ppaIbstDGBpaYljx44hPDzc0CGIqJm+2HEaT6w6iLJy/Z/PEE8HtWzVxddF4x1XfwKJfzR+ro29rr+VtIMgImojTZp22bFjB3x8Gv/rUAKiXr16teS6iMjAHVcv/nIUH2w+UWfH8g9vHQgvZzsNByzTzebIrE5jHDyA3jMAJy/txiciMmawc+mll6JLly5wd3c36PxRo0bBwcGhOddERAYoLCnDg9/sx4+xtRORr+wTgFdmRGtbEbmkEDj0HXDhVOPnuocAPacBto7ajU9E1EwWFYauS5mxnJwcuLm5ITs7G66urm19OUSNyiooxu2f7cHOxPO17pt/WQQeuLwbLKU8slZkN1Xs17pGnY3x7wVETgKsmK9HRO3j/VuT30ZlZWU4cOAAQkND4eHRBt2SiTqQM+cLMHvJTiSk59facfX8Nb1w/aBO2g6Yl64LdIpyGz837BIgdAT7YRFRu9KsfaD33XcfPvroo6pAR5a4+vfvj5CQEGzatEnraySivxw8m41r3t1aK9BxsrXCx7MHaR/oyNbyfZ81HuhYWgHdrwQ6j2SgQ0TtTrOCnW+//RbR0dHq36tXr0ZiYiKOHj2K+++/H//+97+1vkYiAvDH8XRc/8E2ZOTp17Txc7XD8juGadvjSpw7DMQub7yGjrUd0Oc6wL+3tuMTEbVlsJORkQF/f3/1759//hkzZsxAZGQkbrvtNrWcRUTa+n5fEuYs2YX8Yv2aNt38XFTrh56BbtoOeGYXcHhV4zV07N2A/rdyazkRmV+w4+fnh8OHD6slrLVr1+Lyyy9XxwsKCmBlpeHuD6IOTvYPvL85Afd/vR+lNWroDAv3UjM6ge4a7nqU/QoJG4H43xo/Vxp7SqDj5K3d+ERERtCsBOU5c+bguuuuQ0BAgCo0OG7cuKo6PFFRUVpfI1GHraHz7E+HseTPk3VuLX/1umjYWWv8x8XpbcDp7Y2f5xmmKxYoS1hEROYY7Dz11FOqaOCZM2fUEpadne4XnszqPProo1pfI1GHU1xajoe+3Y9VMcm17ps7Mgz/ntxd263llQL6AqkHgYLM+s+R3Jxuk3RJyURE5hrsfPrpp7j++uurgpxKM2fOxFdffaXVtRF1SPlFpbjz872q11VNEuTMG2XEFixSBFCSjdUOrLza94cOB8JGcccVEZl/UUGZwUlJSYGvr6/e8czMTHVMcnlMCYsKUntxPr8Yc5buwv4zWXrHrS0t1LLV1X2DWudC8tKAfcv+3oklwU3Xy4GgAa0zPhGRhu/fzUpQlvhIcnVqSkpKUoMSUdMlZ13EjPe31gp0HG2t8NHsQa0X6AhnX6D3tYCltW65qsdUBjpE1DGWsfr166eCHLmNHTsW1tZ/f7nM5ki9nYkTJxrjOonMWkJ6Hm753w4kZxfqHfdwtFHFAvt1aoPK5O6dgB5X65KQPUJbf3wiorYIdqZOnao+xsTEYMKECXB2dq66z9bWFp07d8b06dO1ujaiDlMVedbHO5GZX6x3PNDNHp/OHYIuvn//nLU6n8i2G5uIqC2CnUWLFqmPEtRIgrK9vb1W10HUIe04kYl/fLIbuUWlesclwPls7mAEuGlYQ4eIqINq1m6sWbNmaX8lRB3MxqNpuGPZHhSVlusdjw52w9I5g+HhZKvtgOlxQFmJris5EVEH0qxgx9LSss4E5UqmthuLqLX9GJuM+76KqbMq8oezBsLZrlk/mvVLiQXifpZtVYCVLZeniKhDadZv1O+++04v2CkpKcG+ffvwySef4Omnn9by+ojMzvLdZ/DoiljUiHNweQ8/vDWzH+xtNC7Wl7QHOP7rX59UAIdXAr1n6KogExF1AM2qs1OfL774Al9//TVWrVoFU8I6O9Ralv6ZiKdWH651fFr/ILw0vQ+srZpVDaJ+0vpBel3VZGUNRM8E3IK1HY+IyFzq7NRn6NChWL9+vZYPSWQ23tkYX2egc+uwULxybbS2gY78DZP4R92BjigrBWKXA7nntBuTiKid0iwx4OLFi3jzzTcRFNSKhc+ITIBMnr766zG8vTG+1n13jo7AwxO6NZgD14wBgYQNwJmdDZ8n1ZHPJ+i6lxMRmbFmBTseHh56v5zll3lubi4cHR2xbNkyLa+PyKTJz8bzPx/Bh38k1rrvoQndMP+yLloPCBxfB5zd0/i54aOB0GHajk9EZC7BzhtvvFFrd5aPjw+GDBmiAiEiAsrLK/DU6kP4dNupWvctmtIDc0aEaR/oxK0BUvY3fm7X8UAw2z8QUcfAOjtERlBWXoF/f38AX+06o3dcJkQXX9MbNwzupO2A5eW6reWpBxo+Ty6g2yQgIFrb8YmIzDFn58KFC/joo49w5MgR9XmPHj0wZ84ceHp6anl9RCYZ6Dz0zX58t++s3nFLC6jO5df0C9Y+0Dn6I3DuUMPnWVgC3a8E/HpqOz4RUTvXrO0fv//+u2oZIQnJEvTITf4dFham7iPqqErLynH/1zG1Ah1rSwu8NbO/cQKdIz80HuhI5/Ke1zDQIaIOqVl1dnr37o1hw4bhvffeg5WVVVXV5Lvuugtbt27FgQONTKW3M6yzQ1oFOvd9HYMfY1P0jttYWeCdG/tjfE9/bQcsLwMOr9K1gWiIpTXQaxrgFaHt+EREJvL+3axgx8HBQXU+79atm97xuLg49O3bV21DNyUMdqilSiTQ+SoGPx3QD3RsrS3xwc0DcFmUb9sEOlI8sNe1rJZMRGbJqEUF+/fvX5WrU50ci45m4iN1vEDn3i/31Qp07Kwt8b9bB7ZhoGMD9L6OgQ4RdXjNSlC+99578a9//Qvx8fGqarLYvn073nnnHbzwwguIjY2tOrdPnz7aXS1ROwx07vliH9YeStU7bm8jgc4gjOzq3TaBjrWtLtBxD9F2fCIiE9SsZSypq9Pgg1pYqGJq8tEUOqBzGYtaMqOz5mDtQOfjWYMwvEsbBjp9bgDcWM2ciMyboe/fzZrZSUysXQ2WqMMlI38VUyvQcbCxwsezB2FYhJdxdl01GujYAdE3AK6B2o5PRGTCmhXsnDp1CsOHD4e1tf6Xl5aWqt1Yo0aN0ur6iNrn9vLl+2vl6Eigs2TOIAwNN0Kgc3Q1kHa04fMY6BARaZegfNlll+H8+fO1jss0ktxHZM4FAx/8Zj9W70+utXT10eyB2gc6ojALyKzdRFQPAx0iIm2Dncp8nJoyMzPh5OTUnIckMoleV4+siMXKmORau64+khydCI1zdCo5egLRN+oCmrow0CEi0i7YmTZtmrpJoDN79uyqz+V29dVXY8KECWp5y1BSbXnKlCkIDAxUj7ly5cpaQdWTTz6JgIAAVdtn3LhxOH78uN45MsN00003qcQkd3d3zJ07F3l5eU15WkSNku/Ff688iG/3JNUZ6IzQOhm5JtcAoO+NgI29/nEGOkRE2gY7kvEsN/nF7+LiUvW53Pz9/XH77bdj2bJlBj9efn6+qssjW9br8tJLL6k2FO+//z527NihZo0koCosLKw6RwKdQ4cOYd26dfjxxx9VACXXQaQV+X5/6odD+HLn6VoFAz+8daD228vr4+Kvm+Gxcai26+p6BjpERMbYev7000/jwQcf1HTJSmZ2vv/+e0ydOlV9LpclMz4PPPCAGqsyJ8jPzw9Lly7FDTfcoIoYSgPSXbt2YeDAgeqctWvXYvLkyUhKSlJfX5eioiJ1q751LSQkhFvPqRb5Pnz+5yP48I/EWi0gPrhlAMZE+bX+ReWlAwdX6Jp6umnca4uIyIQYtYLyokWLjJ6bI9vbU1NT1dJVJXlCQ4YMwbZt29Tn8lGWrioDHSHnSx0gmQmqz+LFi/VmpSTQIarLa+uO1Qp0rP5q6tkmgY5w9gEG385Ah4jImFvPpbt5XQnKlU6cOIGWkkBHyExOdfJ55X3y0ddXvxS/bIf39PSsOqcuCxcuxIIFC2rN7BBV9+6meLy1QX8XlKUF8Mb1fTGxl8ZNPZuqkcKeRETUwmDnvvvu0/u8pKQE+/btU0tIDz30ENo7Ozs7dSOqzydbT+KltfoF/CS+f2VGNKZEM0eGiMjsgx3pi1UXSTTevXs3tCAJz+LcuXNqN1Yl+Vw6q1eek5aWVquwoezQqvx6oqb6ZvcZLPrhUK3jz1/TG9P6G2HpSKoiO3oDTkao0UNERM3L2anPpEmTsGLFCk0eS5bKJGBZv3693nKT5OIMGzZMfS4fs7KysGfPnqpzNmzYgPLycpXbQ9RUP8WmqFo6NT1xZQ/MHNxJ+wEz4oFDK4GYZUBu/UuvRETUyjM79fn2229VvoyhpB6OdE6vnpQcExOjHqNTp05quey5555D165dVfDzxBNPqB1WlTu2unfvjokTJ2LevHlqe7osp919991qp1Z9O7GI6rPxaBr+9dU+lNfYn/jA5ZGYOzJM+wEvnAQOfQ9UlAPFBUDMF0DvGexUTkTUHoKdfv366SUoy/ZcSQhOT0/Hu+++a/DjyJJX9fYSlUnDs2bNUtvLH374YVWLR+rmyAzOyJEjVV6Qvf3fhdU+//xzFeCMHTtW7cKaPn26qs1D1BQ7E8/jjmV7UFoj0rnj0gjcPaaL9gNmnwUOfAuUl/59rLQIiP0K6DUd8AzXfkwiog6q2XV2qpMgw8fHB6NHj0ZUVBTMdZ8+maeDZ7Mx87/bkVtULfAAcOuwUDx9Vc8Gdx42u06OLFuV/F0cU4+lFdDjasCnm7bjEhGZGUPfv62bW2eHyBwkpOdh1sc7awU60/oF4akpRgh0LmbpZm/qC3REeRmQl8Zgh4hII80Kds6ePasSkY8dO6Y+79atm+qPFRQUpNV1ERnd2ayLuOV/O5CZX6x3/PIefnjp2j6wlKI6WirKA/Z/pfvYkOBBQOeR2o5NRNSBNTnYkZwcya0pLi6umjKSaSSpr/Paa6/hrrvuMsZ1EmnqfH4xbvloB5Kz9WdYhkd44a2Z/WBtpXHRPpnJif0auHih4fMC+gBdxuqK+hARkSaa9Bv9p59+wr333qsSgmV2R5KG5Sb/liBH6u/8/PPP2lwZkZHkF5VizpKdOJGer3c8OsQd/711IOxtrLQdsKwEOPitbmmqIb5RQOQkBjpERG2ZoCwJyLIjSraD1+Xxxx/Hli1bsGnTJpgSJih3HMWl5Zj7yS78cTxD73hXX2cs/+cweDjZajtgeTlw6Dsg43jD53mG6badS3IyERG1XSPQvXv34pZbbqn3frlPziFqj8rLK7BgeUytQCfI3QGfzR2ifaAjf0ccW9t4oOMaCPScxkCHiMhImhTslJWVwcbGpt775T45h6i9kQnMp1cfwo+xKXrHPZ1s8encwfB3+7t2k2YSfwdS9jd8jpM30Oc6wFrjQIuIiJoX7PTs2ROrVq2q9/6VK1eqc4jam7c3xOOTbaf0jjnZWmHpnEGI8HHWfsCkPcCprQ2fY+8G9LkesHHQfnwiImrebqz58+fjzjvvVB3DpaqxtbV1VfPNDz74QOXsNKWCMlFrWL7rDF5dpyuTUMnGygIf3DIQfYLdtR8w7QgQv67hc2wdgegbAHvmiBERtatgR9o4HDhwQO3GWrhwISIiItTywIkTJ1SfK9mpNXv2bONdLVETbTh6Dgu/P6B3TDY7vX59X4zs6q39gBdOAUdW6/J16mNlo5vRcTS8jxwREbVyu4jt27fjyy+/xPHjusTLyMhI1Xxz6NChMEXcjWWe9p2+gJkfbkdhSbne8aem9MDsEUZo7CltIPZ9putxVR9JQpZdV7L7ioiI2le7iNjYWPTq1Uv1wZKgprHA5tChQ6qycuVSF1FrOpGeh9uW7qoV6Nw5OsI4gU5hjq5oYEOBjkwpRV3JQIeIqL0mKEun88zMTIMfeNiwYTh9+nRzr4uo2dJzizBryU5cKCjROz6tfxAenmCEflNSHfnAcqAot+HzuowD/HpoPz4RETXI4GkXWe164okn4OjoaND50k6CqLUVFJeqooFnzl/UOz4q0gcvTu+jfWPPslJd0UBZwmpIp6FA8EBtxyYiIm2DnVGjRiEuLq5JMzsODtxSS62ntKwcd3+xD7FJ2XrHewe54b2b+sNG635X4sJJXVJyQ/x7AeGjtR+biIi0DXZMrQUEdSwy87joh0PYcFS//1SIpwM+nj0ITnZGyh3z7gL0nAoc+REoL619v+TndJvMfldERG3ICH/qErW+9zYn4PMd+jli7o42WDpnMHxc7Iw7uG93oO/M2sUBnX2BntewDQQRURtjsEMmb1XMWby0Vn+J1dbaEh/eOtA41ZHr4hYM9L8VcPCoVh1Z2kAYOdAiIqJGMdghk7br5Hk89E1s7aKB1/XFoM6tXLRPigRKwOPdVRfo2Lm07vhERFQnFsEhk5WYkY95n+5GcZl+LZ1/T+6OK/oEtM1FSRuI3te2zdhERFQnzuyQSbqQX4w5S3Yiq0YtnVnDQjF3JIv2ERHR3xjskMkpKi3D7Z/txsnMAr3jY6N88eSUntrX0iEiIpPGYIdMbov5w9/GYtfJC3rHewa64s2Z/WBlaYRARwoHEhGRyWKwQyblzfXxWBWTrHfM39UeH80yUi2ds3uBvUuBQv1ChUREZDoY7JDJ+GF/Ml7/7ZjeMSdbK1U00N/NXvsBz58Ajq/TtYLY8wmQox9kERGRaWCwQyZh3+kLePCb/XrHZMXq7Rv7o0egq/YD5mcCh1YCFX/t9CrOB2I+B9KOaj8WEREZFYMdavfOZl3EvE/3oLhUf4v5E1f2wGVRvtoPWFwAHPgGKC2qo+nn98CpbZI8pP24RERkFAx2qF3LKyrF3KW7kJGnH3jcPLQTZg/vrP2A5WW6gOaifgK0nhObgNxU7ccmIiKjYLBD7VZZeQXu+2ofjqbm6h2/pKs3Fhlji7nM1hz/FcjS77FVi3Qwd22jooVERNRkDHao3Xrl1zj8dkS/i3mEj5PK07GxMsK37tk9QHJMw+cE9AE6DdV+bCIiMhoGO9Qufb8vCe9tStA75uFoo3ZeuTnYaD9gZgIQ/1vD57iHAF0n6JpvERGRyWCwQ+1y59UjKw7oHbO2tMB7Nw9AqJeT9gMWnAcOr2o46Vi6mPe8BrBiOzkiIlPDYIfalZTsi7j9s9o7r565uheGhntpP2BJIXDg29o7r6qztgV6zwBsjRBoERGR0THYoXbjYnEZbv90D9Jzi2o197xxSCftBywvB478ABRk1n+OLFn1mAo4+2g/PhERtQoGO9Ruel49+l0sDpzVb8swsou3qqdjFImbdLk6DYkYA3hFGGd8IiJqFQx2qF347+8navW86uzliLdv7AdrY+y8Sj0InN7R8Dn+vYHgQdqPTURErYrBDrW5zcfS8eJa/TYMLnbW+N+sgXB3tNV+wJwUIG5Nw+e4BQGRE7nziojIDDDYoTZ1MiMf93yxF+XVNkJJfPHGDX3RxddF+wGlx9XBFUB5af3n2LkAPadx5xURkZlgsENtJrewBP/4dDdyCvUDjwcuj8TY7n7GawVRpF+RWY+lNdBrOmDnrP34RETUJhjsUJsoL6/AguX7EZ+Wp3d8cm9/zL+si3EGTdgAZJ1p+JyoyWwFQURkZhjsUJt4Z2M81h0+p3csyt8FL18brX3PK5ESCyTtbvgcaQPh11P7sYmIqE0x2KFWt/FoGl777ZjeMXdHG3x460A42RkhTyYnGTj2S8PneIYDYZdqPzYREbU5BjvU6gnJ9361T68zg6UF8PbM/gjxdNR+wNJiXZ5OQwnJDh5Aj6sAS/44EBGZI/52p1aTX1SKf362B7k1EpIfmRiFkV29jTOotHroPFKXeFwXKxtdQrKNg3HGJyKiNsdgh1qtQvLDK2IRd05/J9QVfQJw+6hw4w4eEA30u1nXzLOmqCvZCoKIyMwx2KFW8dGWRPwUm6J3rJufC16a3sc4Cck1yQ6rAbMBz7C/j4UOA3yjjD82ERG1KVZNI6PbcSITi9fUqJBsb40PbhlgnITk+tg6Ar2vA07+DuSeAzqPar2xiYiozTDYIaNKyynE3V/uQ1n1EskA/nNDX3T2dmr9C5Ik5PDRuo7nTEgmIuoQ+NuejKakrBzzv9iL9NwiveP3ju2KMVFGqJDcFAx0iIg6DP7GJ6N5Yc1R7Dp5Qe/YqEgf/Gts1za7JiIi6ngY7JBR/BibrJKSqwtyd8B/ru8LKymsQ0RE1EoY7JDmEtLz8Mi3sXrHbK0s8d7N/eHhZGucTubFBdo/LhERmQUGO6Spi8VluGvZXuQXl+kdf/rqnugT7K79gJJofHgVsGcJkH1W+8cnIiKTx2CHNC0c+PjKg7UKB147IBg3DAoxzqAn/wAunAIKc4CYz4GkPXIhxhmLiIhMEoMd0szy3WewYm9SrU7mz17dyziFAzMTgFNb//68vAw4/qtupkd6YhERETHYIa0cSs7Gk6sO6R1ztrPGuzf1h4OtlfYDykzOkdV135d2BNj7CVBwXvtxiYjI5DDYoRbLKSzB/M/3oqi0XO/4i9P7INzHWfsBZQZHZm9KLtZ/TlkJm3sSEZHCYIdanKezcMUBnMzU3w01e3hn1eTTKBI3A9n6y2V6LK2Antcw2CEiIoXBDrXIsu2n8NMB/QaffUPc8djk7sYZMOM4cHpHw+d0Gatr/ElERMRgh1ri4NlsPPvjEb1jbg42ePvGfrC1NsK31sUs4OiPDZ/j2x0I7K/92EREZLIY7FCz5BaW4O4v9qK4TD9P59UZ0Qj2cDROns6RH4CSwvrPcfQEuk0CjLHzi4iITBaDHWpWns5j3x+slafzj5FhGNfDSA0+E39vuGigpbUuT8fazjjjExGRyWKwQ0325c4zWL0/We9YdIg7Hp4YZZwBpZ7O6e0Nn9P1csDZ1zjjExGRSWOwQ01yNDUHT6/Wr6fjam+Nt2caKU+nKLfxPB3/XkBAtPZjExGRWWCwQ03qe3X3F/tq1dN5eUY0QjyNkadTrisc2FCTT0cvoOsE5ukQEVG9GOyQwZ758RDi0/Jq1dOZ0NPfOAOe3qrre9VQnk6PqwFrI3RSJyIis8FghwzyY2yyytWprmegKxZONlKeTtYZ4OSWhs/pMgZwMVJCNBERmY12Hew89dRTqoFk9VtU1N9vroWFhZg/fz68vLzg7OyM6dOn49y5c216zebozPkCVSW5OkdbK7w1sx/srI3Q90raQMg284a6l/t0Yz0dIiIy/WBH9OzZEykpKVW3LVv+/mv//vvvx+rVq/HNN99g8+bNSE5OxrRp09r0es1NSVk57vlyH3KLSvWOSydzo/S9kgAnbo2u0Wd97N2AbpOZp0NERAaxRjtnbW0Nf//aOSHZ2dn46KOP8MUXX2DMmDHq2JIlS9C9e3ds374dQ4cOrfcxi4qK1K1STk4Db6wd3GvrjiHmTJbesWv6BWH6gGDjDJgSA6TH1X+/hSXQcypgY2+c8YmIyOy0+5md48ePIzAwEOHh4bjppptw+vRpdXzPnj0oKSnBuHHjqs6VJa5OnTph27ZtDT7m4sWL4ebmVnULCQkx+vMwRVsTMvD+5gS9Y529HPHs1F7GGTAvHTj+W8PnhF8KuAYaZ3wiIjJL7TrYGTJkCJYuXYq1a9fivffeQ2JiIi655BLk5uYiNTUVtra2cHd31/saPz8/dV9DFi5cqGaGKm9nzugn3hJwIb8YC77er5c2Y2Nlgbdm9oeznREmBMtKgSOrgHL95TI9nmFAyBDtxyYiIrPWrpexJk2aVPXvPn36qOAnNDQUy5cvh4ODQ7Mf187OTt2o/nYQj34Xi9Qc/T5UD0+IQu9gN+MMWpChKyBYH1tHIOpK5ukQEZF5zezUJLM4kZGRiI+PV3k8xcXFyMrSzyeR3Vh15fiQ4b7adQa/HNLf1XZJV2/MHRlmvEFd/IGBcwGPznXfL4GOnRESoomIyOyZVLCTl5eHhIQEBAQEYMCAAbCxscH69eur7o+Li1M5PcOGDWvT6zRlUjSwZjsITydb1c3c0tLIsyr2rkD0DUDEGMCy2pb2kEGAV4RxxyYiIrPVrpexHnzwQUyZMkUtXcm28kWLFsHKygozZ85UicVz587FggUL4OnpCVdXV9xzzz0q0GloJxbVr6i0DP/6ah8KS/TbQbw0vQ98XVtp95MsU3UaopvhObwKsLIGwka3zthERGSW2nWwk5SUpAKbzMxM+Pj4YOTIkWpbufxbvP7667C0tFTFBGUr+YQJE/Duu++29WWb9DbzQ8n62/BvHRaKcT3aoEqxVEYeOEdXYFACHiIiomayqJBs1A5O6uzITJHszJIZoo5oW0Imbvzfdr3dV5F+zvjh7pGwtzFClWQiIqJWev82qZwdMo7siyV4YHmMXqBja2WJ/9zQj4EOERGZPAY7hCdXHURydo1t5hO7oXtAx5zlIiIi88Jgp4NbFXMWq2KS9Y4Nj/DCbSOMuM2ciIioFTHY6cDOZl3E4ysP6h1ztbfGq9cZaZt5SSGQqd9+goiIyNi4zaWDKi+vwIPL9yO3UL89w/PTeiPArfnVqRt0/Ffg3CEgsJ+ulo61rXHGISIiqoYzOx3Ukq0nse1EZq1u5lf2MVKTzXOHdYGOSN4H7FkC5OgvnxERERkDg50O6Pi5XLy49qjesSB3Bzx9dU/jDFiYAxxbq3+s4Dyw9zPg5BaZZjLOuERERAx2Op6SsnIsWL4fxaX6AcYrM6Lham+j/YCyn/3oT0BpUR33lQOJfwAnNmg/LhER0V8Y7HQwb22Ix4Gz2XrHpMHnsAgv4wx4di9w4WT991vbAcGDjTM2ERERg52OJeZMFt7ZGK93rIuvMx6a0M04A8pSVWOzNpETdQ1AiYiIjITBTgdxsbgMC5bHoKz87zLJ1pYWeP26vsapkix5OEdWA2X6u730+PUE/HpoPzYREVE1DHY6iJd+OYoT6fl6x+4d2xW9g92MM+CZ7Q3vtrJzAbqON87YRERE1TDY6QC2n8jEkj/182aiQ9xx1+gI4wyYm6pLPG5I1GTAxt444xMREVXDYMfM5ReV4qFv9+sds7O2xKszomFtZYSXX5atZPlKdlrVJ2gA4Bmu/dhERER1YLBj5havOYIz5y/qHZOEZElMNoqTfwD5GfXf7+gJRFxmnLGJiIjqwGDHjG05noFl20/rHRvU2QNzjNXkMzsJOLOj/vstLICoKwErI9TzISIiqgeDHTOVU1iCh2ssXznYWKnigVbGaPJZVqIrHihFBOvTaRjgFqT92ERERA1gsGOmnvvxMJKzC/WOLZwchVAvJ+MMeGKTrq5OfZx9gc4jjTM2ERFRAxjsmKFNcWlYvjtJ79jwCC/cPCTUOANKheSk3fXfb2kFdJ+i+0hERNTKGOyYmdzCEiz87oDeMSdbK7x0bR9YGmP5SnpeHf254XNkRkdmdoiIiNoAgx0z8/zPR5FSY/nqsSu6I9jD0TgDxq8HCvV7belxDQRChhpnbCIiIgMw2DEjf8Zn4Mudp2stX904uJNxBsyIB1L0k6D1WFrrdl9Z8tuMiIjaDt+FzEReUSke/jZW75ijrRVenN4HFrLlW2vFBUBcI8tX4aMBJyN1UyciIjIQgx0z8eKaozibpV888NFJUQjxNMLylWwvP/4LUKzfa0uPeycgeKD2YxMRETURgx0z6X312fZTeseGhHkab/eVNPhMO1r//VI0UHpfGWNGiYiIqIkY7Ji4wpIyPLoitlbxQKPtvhJSGLD3tYBtPbNGXcYBDh7GGZuIiKiJGOyYuNfXHcPJzIJava+MVjywkndXYNA/AJ9I/eNeXYCAaOOOTURE1AQMdkxYbFIWPvzjhN6x/p3cMWt459a5AFsnoOc0XcFAazvAxgHoNonLV0RE1K5Yt/UFUPMUl5ar3Vfl1VpR2VpZqt1XRul9VR8JbPx7Ae4hwMUswM5I3dSJiIiaicGOifpgcwKOpubqHbtnTBd09XNpmwuyd9PdiIiI2hkuY5mg4+dy8daGeL1jUf4u+OelEW12TURERO0Vgx0TU15egUdWxKK4rLzqmKxaye4rW2u+nERERDXx3dHELNtxCntPZ+kdm3dJOPoEu7fZNREREbVnDHZMSEr2Rby0Nk7vWKiXI+4bV2P7txbKSoEs/T5bREREpojBjomoqKjAk6sOqR5Y1S2+pjccbK20HzBhPRDzBXDyT117CCIiIhPFYMdErD2YinWHz+kdmzEgGMO7eGs/WOoB4OxeXZCT+Dtw4FugpFD7cYiIiFoBgx0TkH2xBIt+OKR3zMvJFo9N7q79YLnngLi1+scy44E9S4G8NO3HIyIiMjIGOybgxbVHkZZbpHfsySk94OFkq+1AJReBQ98B5fpLZcrFC8DeT4D0Y9qOSUREZGQMdtq5XSfP44sd+onCo7v54KroQG0HKi8HjqzWVUGulwXg6KntuEREREbGYKedt4RY+N2BWh3Nn5vaCxZa9586sRHITGj4nKgrAScj5AgREREZEYOddkyafMan5ekde2B8JII9HLUdSJKRz+xs+JxOQwDfKG3HJSIiagUMdtqpU5n5eHP9cb1jvYJcMWdEmLYDnT8BHF/X8DnunYCw0dqOS0RE1EoY7LTTmjqPrzyIolL9lhCLr9G4o3leOnDoe6Di73FqsXMBelwNWPJbhYiITBPfwdqh1bEp+ON4ht6xW4d1Ru9gDbuKF+UBB74BSovrP8fSGug1DbBz1m5cIiKiVsZgpx3W1Hlm9WG9Y36udipXRzNSIPDAcqAwu+Hzuk8BXDXe9UVERNTKGOy0My+tPYqMPP2aOk9f1RMu9jbaDCAzOTKjI8UDGxI+mgnJRERkFhjstCP7Tl/AFzv1a+qMjfLFhJ7+2jX3lKKB2UkNnxcQDXQaqs2YREREbYzBTjtRWlaukpKr99yUmjpPX91Tm5o6qmjgKuB8YsPneYQCkRMArev4EBERtREGO+3Esu2ncCg5R+/Yv8Z11aamjgQ6cT813upBCgb2vAawNEIXdSIiojZi3VYD09/Scgrx6q/6gUiknzPmjtSgpk55ma4NRNqRhs9zcAf6XA/YOLR8TCIionaEwU478NxPR5BbpN9887mpvWFj1cKJt7IS4NBKXdfyhsjW8ugbAHvXlo1HRETUDjHYaWN/xmfgh/3Jesem9w/G4LAWNtwsLQIOrgAunGr4PJnJiZ4JOHi0bDwiIqJ2ijk7baiotAxPrDqod8zNwQYLJ2uw5TsnGcjS39lVi7WtbumKzT2JiMiMMdhpQ//7IxEn0vP1jj08sRu8ne1a/uCeYUC3yfXfb2UD9L4OcA1o+VhERETtGIOdNpJ0oQBvbdBv9Bkd4o6ZgzppN0hAH6Dr+NrHre10S1fuIdqNRURE1E4xZ6eNPPfjERSW6Df6/L+pvWCpZaNPETwAKCsCTmzWfW7rqAt0nH21HYeIiKidYrDTBjYfS8faQ6l6x24aEopeQRo2+qwudLguYTntsC7QcWxh8jMREZEJYbDTBknJT/1wSO+Yp5MtHhzfzbgDS6+rkCG6mR0iIqIOhDk7bZCUnJihn5T8yMRucHO0aVpFZKmh0xTS/oGBDhERdUAMdlrR2ayLeHuDfoG/viHumDGgCYnC+RlAzOfA8XXaXyAREZEZ4jJWK/q/nw7jYkmZ3mTLM1f3NCwpuaQQOLUFSNoDVJTrOpd7RQA+Rl7+IiIiMnEMdlqxUvLPB/STkmcO7oQ+we4Nf6G0QU/ZDyRuBooL9O+LWwO4BgJ2Lka4YiIiIvPAYKcVlJSVY1GNpGQPRxs81FBSclkpkHYIOLNTt3RV5wNfBI7+pKuCLNNEREREVAuDnVbwydaTiE/L0zv20IQoeDjZ1r1clbwPOLsbKNL/mjqdTwSSdgMhgzS8YiIiIvPBYMfI0nOL8J/f9Csl9wpyxfWDqiUlSw2cjONA+lFd8FKu3wG9USkxQNAAwJL55kRERDUx2DGyl9YeRW6RfvDyzORwWF04AeSm6hp2XjjZ9ABHWFgCQf2BsEsZ6BAREZl7sPPOO+/g5ZdfRmpqKqKjo/HWW29h8ODBbXpN+05lImPfaky0LIE9imFnUYJhQbbofzoWaKQheaM8QoEulwPOPhpdLRERkXkyi+mAr7/+GgsWLMCiRYuwd+9eFexMmDABaWlpbXZN5eUVeGr1EfS0OIkoy9PobJmKUOsLuDzcoWUPbO8G9Jr2V38rBjpEREQdIth57bXXMG/ePMyZMwc9evTA+++/D0dHR3z88cdtdk3f7knC/qRsFOLvJOQhYZ5wsrNufpDT9XJg8DxdbR3uviIiIuoYy1jFxcXYs2cPFi5cWHXM0tIS48aNw7Zt2+r8mqKiInWrlJOTo+k1ZV8swYtrj+rGgg2ccREejrboG+LR9Adz8QNChgI+UczLISIi6ojBTkZGBsrKyuDn56d3XD4/elQXcNS0ePFiPP3000a7pu/2JiEzv1j9u3Jm59JIH1gZUilZWNsCXl2BgD6AeyhncYiIiDpysNMcMgskOT7VZ3ZCQprQn6oRs4d3hrezHZ7/+QiKcm0Q7uOMzl5OjQc43pG6GRyPMMCqQ740REREmjP5d1Rvb29YWVnh3Llzesflc39//zq/xs7OTt2MxcLCAlOiAzG2uy/WrTiOS93Sam8Zl+RiZ3/ARW4BgLMvYGlltGsiIiLqqEw+2LG1tcWAAQOwfv16TJ06VR0rLy9Xn999991tem2Otta4evIUoDgfsLYDbBx0H22dGdgQERG1EpMPdoQsSc2aNQsDBw5UtXXeeOMN5Ofnq91Zbc4tqK2vgIiIqEMzi2Dn+uuvR3p6Op588klVVLBv375Yu3ZtraRlIiIi6ngsKioqKtDBSYKym5sbsrOz4erq2taXQ0RERBq+f7NwCxEREZk1BjtERERk1hjsEBERkVljsENERERmjcEOERERmTUGO0RERGTWGOwQERGRWWOwQ0RERGaNwQ4RERGZNbNoF9FSlUWkpRIjERERmYbK9+3GmkEw2AGQm5urPoaEhLT1pRAREVEz3selbUR92BsLQHl5OZKTk+Hi4gILCwtNI04JoM6cOWO2PbfM/Tny+Zk+c3+OfH6mz9yfY44Rn5+EMBLoBAYGwtKy/swczuxI4pKlJYKDg432+PLimuM3cEd6jnx+ps/cnyOfn+kz9+foaqTn19CMTiUmKBMREZFZY7BDREREZo3BjhHZ2dlh0aJF6qO5MvfnyOdn+sz9OfL5mT5zf4527eD5MUGZiIiIzBpndoiIiMisMdghIiIis8Zgh4iIiMwagx0iIiIyawx2jOidd95B586dYW9vjyFDhmDnzp0wRYsXL8agQYNUhWlfX19MnToVcXFxeueMHj1aVZ+ufrvjjjtgCp566qla1x4VFVV1f2FhIebPnw8vLy84Oztj+vTpOHfuHEyJfB/WfI5yk+dliq/f77//jilTpqiqqXKtK1eu1Ltf9l08+eSTCAgIgIODA8aNG4fjx4/rnXP+/HncdNNNqsiZu7s75s6di7y8PLT351dSUoJHHnkEvXv3hpOTkzrn1ltvVVXgG3vNX3jhBZjKazh79uxa1z9x4kSzeA1FXT+Pcnv55ZdN4jVcbMD7giG/O0+fPo0rrrgCjo6O6nEeeughlJaWan69DHaM5Ouvv8aCBQvUdru9e/ciOjoaEyZMQFpaGkzN5s2b1Tfs9u3bsW7dOvXLdvz48cjPz9c7b968eUhJSam6vfTSSzAVPXv21Lv2LVu2VN13//33Y/Xq1fjmm2/U/4W8qUybNg2mZNeuXXrPT15HMWPGDJN8/eR7T36m5A+Kusi1v/nmm3j//fexY8cOFRTIz5/88q0kb5KHDh1S/xc//vijenO6/fbb0d6fX0FBgfqd8sQTT6iP3333nXqTueqqq2qd+8wzz+i9pvfccw9M5TUUEtxUv/4vv/xS735TfQ1F9eclt48//lgFMxIQmMJruNmA94XGfneWlZWpQKe4uBhbt27FJ598gqVLl6o/VDQnW89Je4MHD66YP39+1edlZWUVgYGBFYsXL64wdWlpaVKuoGLz5s1Vxy699NKKf/3rXxWmaNGiRRXR0dF13peVlVVhY2NT8c0331QdO3LkiHr+27ZtqzBV8lpFRERUlJeXm/zrJ6/F999/X/W5PCd/f/+Kl19+We91tLOzq/jyyy/V54cPH1Zft2vXrqpz1qxZU2FhYVFx9uzZivb8/Oqyc+dOdd6pU6eqjoWGhla8/vrrFaagruc4a9asiquvvrrerzG311Ce65gxY/SOmdJrmFbjfcGQ350///xzhaWlZUVqamrVOe+9916Fq6trRVFRkabXx5kdI5Aodc+ePWrqvHr/Lfl827ZtMHXZ2dnqo6enp97xzz//HN7e3ujVqxcWLlyo/gI1FbLEIdPN4eHh6q9FmVoV8jrKXyzVX0tZ4urUqZPJvpby/bls2TLcdttteo1vTfn1qy4xMRGpqal6r5n0zpGl5MrXTD7KssfAgQOrzpHz5edUZoJM8WdSXkt5TtXJkocsIfTr108tjxhjecCYNm3apJY2unXrhjvvvBOZmZlV95nTayhLOz/99JNahqvJVF7D7BrvC4b87pSPshzr5+dXdY7MwErjUJmx0xIbgRpBRkaGmp6r/gIK+fzo0aMw9Q7x9913H0aMGKHeFCvdeOONCA0NVQFDbGysyimQqXWZYm/v5E1Qpk7lF6pMEz/99NO45JJLcPDgQfWmaWtrW+tNRF5Luc8USe5AVlaWyokwh9evpsrXpa6fv8r75KO8iVZnbW2tflGb2usqS3Pyes2cOVOvyeK9996L/v37q+ckSwQSwMr392uvvQZTIEtYsuQRFhaGhIQEPPbYY5g0aZJ6g7SysjKr11CWbyT3pebyuKm8huV1vC8Y8rtTPtb1c1p5n5YY7FCTyBqtBAHVc1pE9XVyidQlMXTs2LHql1RERATaM/kFWqlPnz4q+JE3/uXLl6vkVnPz0UcfqecsgY05vH4dmfzlfN1116mE7Pfee0/vPskZrP59LW88//znP1ViqSm0Jbjhhhv0viflOcj3osz2yPemOZF8HZlRls0spvgazq/nfaE94TKWEchSgPzlUTPrXD739/eHqbr77rtVEuDGjRsRHBzc4LkSMIj4+HiYGvlLJDIyUl27vF6y7CMzIebwWp46dQq//fYb/vGPf5jt61f5ujT08ycfa24WkOUB2d1jKq9rZaAjr6kkiFaf1anvNZXnePLkSZgiWWKW362V35Pm8BqKP/74Q82iNvYz2V5fw7vreV8w5HenfKzr57TyPi0x2DECib4HDBiA9evX603zyefDhg2DqZG/GuUb+vvvv8eGDRvUtHJjYmJi1EeZITA1snVVZjTk2uV1tLGx0Xst5ReT5PSY4mu5ZMkSNfUvOyDM9fWT70/5RVn9NZMcAMnjqHzN5KP8Epa8gkryvS0/p5WBnikEOpJrJsGr5HQ0Rl5TyWepufRjKpKSklTOTuX3pKm/htVnWuX3jOzcMqXXsKKR9wVDfnfKxwMHDugFrZWBe48ePTS/YDKCr776Su3+WLp0qdo1cPvtt1e4u7vrZZ2bijvvvLPCzc2tYtOmTRUpKSlVt4KCAnV/fHx8xTPPPFOxe/fuisTExIpVq1ZVhIeHV4waNarCFDzwwAPqucm1//nnnxXjxo2r8Pb2VrsLxB133FHRqVOnig0bNqjnOGzYMHUzNbIjUJ7HI488onfcFF+/3Nzcin379qmb/Bp77bXX1L8rdyO98MIL6udNnktsbKza6RIWFlZx8eLFqseYOHFiRb9+/Sp27NhRsWXLloquXbtWzJw5s6K9P7/i4uKKq666qiI4OLgiJiZG72eycgfL1q1b1S4euT8hIaFi2bJlFT4+PhW33nprRXvR0HOU+x588EG1a0e+J3/77beK/v37q9eosLDQ5F/DStnZ2RWOjo5qB1JN7f01vLOR9wVDfneWlpZW9OrVq2L8+PHqea5du1Y9x4ULF2p+vQx2jOitt95SL7Stra3air59+/YKUyQ/qHXdlixZou4/ffq0emP09PRUAV6XLl0qHnroIfWDbAquv/76ioCAAPU6BQUFqc8lAKgkb5B33XVXhYeHh/rFdM0116gfalPzyy+/qNctLi5O77gpvn4bN26s83tStitXbj9/4oknKvz8/NRzGjt2bK3nnZmZqd4YnZ2d1VbXOXPmqDeo9v785M2/vp9J+TqxZ8+eiiFDhqg3I3t7+4ru3btXPP/883qBQnt+jvKGKW+A8sYn25dlC/a8efNq/bFoqq9hpQ8++KDCwcFBbdOuqb2/hmjkfcHQ350nT56smDRpkvp/kD8y5Y/PkpISza/X4q+LJiIiIjJLzNkhIiIis8Zgh4iIiMwagx0iIiIyawx2iIiIyKwx2CEiIiKzxmCHiIiIzBqDHSIiIjJrDHaIiIjIrDHYISKTN3v2bEydOrWtL4OI2inrtr4AIqKGWFhYNHj/okWL8J///Ec1JiQiqguDHSJq11JSUqr+/fXXX+PJJ59U3ZMrOTs7qxsRUX24jEVE7Zq/v3/Vzc3NTc30VD8mgU7NZazRo0fjnnvuwX333QcPDw/4+fnhww8/RH5+PubMmQMXFxd06dIFa9as0Rvr4MGDmDRpknpM+ZpbbrkFGRkZbfCsiUhLDHaIyCx98skn8Pb2xs6dO1Xgc+edd2LGjBkYPnw49u7di/Hjx6tgpqCgQJ2flZWFMWPGoF+/fti9ezfWrl2Lc+fO4brrrmvrp0JELcRgh4jMUnR0NB5//HF07doVCxcuhL29vQp+5s2bp47JclhmZiZiY2PV+W+//bYKdJ5//nlERUWpf3/88cfYuHEjjh071tZPh4hagDk7RGSW+vTpU/VvKysreHl5oXfv3lXHZJlKpKWlqY/79+9XgU1d+T8JCQmIjIxslesmIu0x2CEis2RjY6P3ueT6VD9WucurvLxcfczLy8OUKVPw4osv1nqsgIAAo18vERkPgx0iIgD9+/fHihUr0LlzZ1hb81cjkTlhzg4REYD58+fj/PnzmDlzJnbt2qWWrn755Re1e6usrKytL4+IWoDBDhERgMDAQPz5558qsJGdWpLfI1vX3d3dYWnJX5VEpsyigmVHiYiIyIzxzxUiIiIyawx2iIiIyKwx2CEiIiKzxmCHiIiIzBqDHSIiIjJrDHaIiIjIrDHYISIiIrPGYIeIiIjMGoMdIiIiMmsMdoiIiMisMdghIiIimLP/B8GBLTwwm352AAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from autoreduce.utils import get_ODE\n", - "timepoints_ode = np.linspace(0, 200, 100)\n", - "# reduced_sys.params_values = new_params_values + []\n", - "reduced_ode = get_ODE(reduced_sys, timepoints_ode)\n", - "sol = reduced_ode.solve_system().T\n", - "try:\n", - " import matplotlib.pyplot as plt\n", - " plt.plot(timepoints_ode, sol[2,:], lw = 3, label='Reduced Model')\n", - " plt.plot(timepoints_ode, full_model, '--', lw = 5, alpha = 0.5, label='Full Model')\n", - " plt.xlabel('Time')\n", - " plt.ylabel('[Outputs]')\n", - " plt.legend()\n", - " plt.show()\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Write the reduced model to an SBML file to integrate other tools!" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "reduced_sys.write_sbml(\"models/reduced_gene_expression.xml\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "py311-new", - "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.11.13" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/AutoReduce-BioCRNpyler interface.pdf b/examples/AutoReduce-BioCRNpyler interface.pdf deleted file mode 100644 index 8630c90..0000000 Binary files a/examples/AutoReduce-BioCRNpyler interface.pdf and /dev/null differ diff --git a/examples/biological/Bacterial population control.ipynb b/examples/biological/Bacterial population control.ipynb new file mode 100644 index 0000000..631b71a --- /dev/null +++ b/examples/biological/Bacterial population control.ipynb @@ -0,0 +1,571 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "bacterial-population-control-00", + "metadata": {}, + "source": [ + "# Bacterial Population Control\n", + "\n", + "In this example, we apply AutoReduce to a biological circuit that implements population control in a bacterial consortium. Two cell types mutually repress each other's growth by activating toxin production in the opposite cell type. The detailed model has 8 states, and the goal is to derive and inspect a lower-dimensional model that preserves the population-level behavior.\n", + "\n", + "This system model and the resulting reduced models were applied in practice to design a synthetic bacterial consortium that can maintain a stable population ratio between two cell types. Read more [here](https://www.biorxiv.org/content/10.1101/632174v1.abstract): McCardell, Reed D., Ayush Pandey, and Richard M. Murray. \"Control of density and composition in an engineered two-member bacterial community.\" BioRxiv (2019): 632174.\n" + ] + }, + { + "cell_type": "markdown", + "id": "affe547d", + "metadata": {}, + "source": [ + "## Model description\n", + "\n", + "In other example notebooks, we import models written in the standard biological modeling language, the Systems Biology Markup Language (SBML). To demonstrate the versatility of AutoReduce, we define the ODE model directly in Python here and use `load_ode_model` to create the symbolic state and parameter containers needed by AutoReduce.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "bacterial-population-control-01", + "metadata": {}, + "outputs": [], + "source": [ + "from autoreduce import System, load_ode_model\n", + "import numpy as np\n", + "from sympy import symbols" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bacterial-population-control-02", + "metadata": {}, + "outputs": [], + "source": [ + "n = 8 # Number of states\n", + "x_init = np.zeros(n)\n", + "# initial population of cell 1 and cell 2\n", + "x_init[6] = 100\n", + "x_init[7] = 500\n", + "\n", + "timepoints_ode = np.linspace(0, 40, 100) # timepoints for ODE simulation\n", + "\n", + "# define tolerance levels for the error and\n", + "# for minimum number of states required for the reduced model\n", + "\n", + "error_tol = 1000\n", + "nstates_tol = 5\n" + ] + }, + { + "cell_type": "markdown", + "id": "6e4ed40f", + "metadata": {}, + "source": [ + "## Define all symbols\n", + "\n", + "The model has 8 state variables: toxin and antitoxin species for each cell type, two signal species, and the two cell populations. The numerical parameter values come from the population-control model in the cited work, while the symbolic parameter names are used by AutoReduce for sensitivity analysis and symbolic reduction.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2c39910d", + "metadata": {}, + "outputs": [], + "source": [ + "# the parameter values below come from the literature (see paper cited above)\n", + "# x = 0, T1, 1, A1, 2, S1, 3, S2, 4, T2, 5, A2, 6, C1, 7, C2\n", + "# P = 0, beta_S1, 1, l_S1, 2, K_S1, 3, kb, 4, beta_S2, 5, l_S2, 6,\n", + "# K_S2, 7, beta_lac, 8, l_lac, 9, K_lac, 10, beta_tet, 11, l_tet, 12,\n", + "# K_tet, 13, kc, 14, C_max, 15, dc, 16, 17, I, 18, atc, 20,K_tox\n", + "\n", + "P = np.zeros(22)\n", + "P = [\n", + " 6, 2e-3, 430, 30, 6, 2e-3, 190, 19.8e-3, 1.5e-3, 1.4e5,\n", + " 14.4e-3, 2.1e-4, 13, 0.6, 5500, 0.8, 1e6,\n", + " 324, 1, 0.1, 1.5, 0.5\n", + "]\n", + "\n", + "params_values = P.copy()\n", + "\n", + "params = P\n", + "\n", + "n = 8\n", + "\n", + "x, f, P = load_ode_model(n, len(params_values))\n", + "\n", + "beta_S1, l_S1, K_S1 = symbols('beta_S1, l_S1, K_S1')\n", + "kb, beta_S2, l_S2, K_S2 = symbols('kb, beta_S2, l_S2, K_S2')\n", + "beta_lac, l_lac, K_lac = symbols('beta_lac, l_lac, K_lac')\n", + "beta_tet, l_tet, K_tet = symbols('beta_tet, l_tet, K_tet')\n", + "kc, C_max, dc = symbols('kc, C_max, dc')\n", + "I, atc, K_tox = symbols('I, atc, K_tox')\n", + "d, d_T, d_S = symbols('d, d_T, d_S')\n", + "y0, y1 = symbols('y0, y1')\n", + "\n", + "P = [beta_S1, l_S1, K_S1, kb, beta_S2, l_S2, K_S2, beta_lac, l_lac,\n", + " K_lac, beta_tet, l_tet, K_tet, kc, C_max, dc, I,\n", + " atc, K_tox, d, d_T, d_S]" + ] + }, + { + "cell_type": "markdown", + "id": "8672e83e", + "metadata": {}, + "source": [ + "## Define the ODE model\n", + "\n", + "The first six equations describe gene-expression and toxin-antitoxin dynamics. The last two equations describe logistic growth of the two cell populations, with toxin-mediated growth inhibition coupling the intracellular circuit to population dynamics.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "363efe5e", + "metadata": {}, + "outputs": [], + "source": [ + "# T1 and A1\n", + "f[0] = P[0]*(P[1] + x[2]**2/(P[2]+x[2]**2)) - P[3]*x[0]*x[1] - P[20] * x[0]\n", + "f[1] = 5*P[4]*(P[5] + x[3]**2/(P[6]+x[3]**2)) - P[20] * x[1] - P[3]*x[0]*x[1]\n", + "\n", + "\n", + "# S1 and S2 (scaled with cell count)\n", + "f[2] = P[7]*(P[8] + P[16]**2/(P[9]+P[16]**2))*x[6] - P[21] * x[2]\n", + "f[3] = P[10]*(P[11] + P[17]**2/(P[12]+P[17]**2))*x[7] - P[21] * x[3]\n", + "\n", + "# T2 and A2\n", + "f[4] = P[4]*(P[5] + x[3]**2/(P[6]+x[3]**2)) - P[3]*x[4]*x[5] - P[20] * x[4]\n", + "f[5] = 5*P[0]*(P[1] + x[2]**2/(P[2]+x[2]**2)) - P[20] * x[5]-P[3]*x[4]*x[5]\n", + "\n", + "# Cell 1 and Cell 2\n", + "f[6] = P[13]*(1 - (x[6] + x[7])/P[14])*x[6] - P[15]*x[6]*(x[0]/(P[18] + x[0])) - P[19] * x[6]\n", + "f[7] = P[13]*(1 - (x[6] + x[7])/P[14])*x[7] - P[15]*x[7]*(x[4]/(P[18] + x[4])) - P[19] * x[7]\n" + ] + }, + { + "cell_type": "markdown", + "id": "f83b4137", + "metadata": {}, + "source": [ + "## Declare outputs using the C matrix\n", + "\n", + "The output matrix selects the two population states, `C1` and `C2`. These are the quantities we want the reduced model to match because the biological design objective is about population density and composition.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d48ead2a", + "metadata": {}, + "outputs": [], + "source": [ + "C = np.zeros((2,len(x)), dtype=int)\n", + "C[0][6] = 1\n", + "C[1][7] = 1\n", + "C = C.tolist()" + ] + }, + { + "cell_type": "markdown", + "id": "cdd17b58", + "metadata": {}, + "source": [ + "## Create a System\n", + "\n", + "The `System` object stores the state equations, parameter values, outputs, and initial condition in the format used by the solvers and reduction routines.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d28861a1", + "metadata": {}, + "outputs": [], + "source": [ + "sys = System(x, f, params = P, params_values = params_values, C = C, x_init = x_init)" + ] + }, + { + "cell_type": "markdown", + "id": "e92ea566", + "metadata": {}, + "source": [ + "## Solve the full system using AutoReduce solvers\n", + "\n", + "Before reducing the model, we simulate the full 8-state system. This gives a baseline trajectory for the two population outputs.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "42d2cebb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from autoreduce import solve_ode\n", + "\n", + "try:\n", + " import matplotlib.pyplot as plt\n", + "\n", + " full_solution = solve_ode(sys, timepoints_ode).T\n", + " full_outputs = np.asarray(C) @ full_solution\n", + "\n", + " fig, ax = plt.subplots(figsize=(7, 4))\n", + " ax.plot(timepoints_ode, full_outputs[0], label='Cell 1')\n", + " ax.plot(timepoints_ode, full_outputs[1], label='Cell 2')\n", + " ax.set_xlabel('Time')\n", + " ax.set_ylabel('Population')\n", + " ax.legend()\n", + " fig.tight_layout()\n", + " plt.show()\n", + "except ImportError:\n", + " print('Plotting libraries missing.')\n" + ] + }, + { + "cell_type": "markdown", + "id": "2e975231", + "metadata": {}, + "source": [ + "## Optional sensitivity analysis\n", + "\n", + "The sensitivity solver can be run directly on the `System`. For this larger model, the time grid is kept short so the example remains lightweight when rerun. The heatmaps below show how each population output changes with respect to the model parameters over the selected time points.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bacterial-population-control-04", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5, 22, 8)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\ayush\\Box\\Research\\autoReduce_HPC\\autoreduce\\solvers\\utils.py:114: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", + " solution = odeint(extended_rhs, y0, timepoints, tfirst=True, **kwargs)\n" + ] + } + ], + "source": [ + "from autoreduce import solve_sensitivity\n", + "timepoints_ssm = np.linspace(0,100,5)\n", + "Ss = solve_sensitivity(sys, timepoints_ssm)\n", + "print(Ss.shape) # Should be (5, 10, 8) - len(timepoints) x len(params) x len(states)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "bacterial-population-control-05", + "metadata": {}, + "outputs": [], + "source": [ + "nouts = 2\n", + "out_Ss = []\n", + "for i in range(len(params)):\n", + " out_Ss.append((np.array(C)@(Ss[:,i,:].T)))\n", + "out_Ss = np.reshape(np.array(out_Ss), (len(timepoints_ssm), len(params), nouts))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "bacterial-population-control-06", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "try:\n", + " import seaborn as sn\n", + " for j in range(nouts):\n", + " sn.heatmap(out_Ss[:,:,j].T)\n", + " plt.xlabel('Time')\n", + " plt.ylabel('Parameters')\n", + " plt.title('Sensitivity of output[{0}] with respect to all parameters'.format(j))\n", + " plt.show()\n", + "except:\n", + " print('Plotting libraries missing.')" + ] + }, + { + "cell_type": "markdown", + "id": "dd24e674", + "metadata": {}, + "source": [ + "## Explore reduced models\n", + "\n", + "Using `explore_all_QSS_models`, we can scan for QSS reductions without manually creating an intermediate reducible object. Here we skip numerical error and robustness calculations during the scan so the notebook can quickly list symbolic candidate reductions. After the scan, we choose one biologically meaningful four-state model and inspect it in more detail.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cecea5da", + "metadata": {}, + "outputs": [], + "source": [ + "from autoreduce import explore_all_QSS_models\n", + "\n", + "reduction_timepoints_ode = np.linspace(0, 24, 25)\n", + "reduction_timepoints_ssm = np.linspace(0, 24, 2)\n", + "\n", + "results = explore_all_QSS_models(\n", + " sys,\n", + " timepoints_ode=reduction_timepoints_ode,\n", + " timepoints_ssm=reduction_timepoints_ssm,\n", + " nstates_tol=7,\n", + " nstates_tol_min=6,\n", + " skip_numerical_computations=True,\n", + " debug=False,\n", + ")\n", + "\n", + "print(f'Found {len(results)} candidate reduced models.')\n" + ] + }, + { + "cell_type": "markdown", + "id": "c03d3f52", + "metadata": {}, + "source": [ + "## Choose a reduced model\n", + "\n", + "For the detailed comparison, we retain the two antitoxin states and the two population states. The toxin and signal states are treated as fast variables and collapsed using the QSS equations produced by `solve_timescale_separation`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "407cad85", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Successful solution obtained with states: [x1, x5, x6, x7]!\n" + ] + } + ], + "source": [ + "from autoreduce import solve_timescale_separation\n", + "\n", + "retained_states = [x[1], x[5], x[6], x[7]]\n", + "reduced_sys_1567, collapsed_sys_1567 = solve_timescale_separation(\n", + " sys,\n", + " retained_states,\n", + " timepoints_ode=reduction_timepoints_ode,\n", + " timepoints_ssm=reduction_timepoints_ssm,\n", + " skip_numerical_computations=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "4b35de7c", + "metadata": {}, + "source": [ + "## Compare the reduced model with the full model\n", + "\n", + "The comparison below focuses on the total population, `C1 + C2`. Plotting a single reduced model keeps the visual check tied to the model we selected, rather than mixing many candidate reductions in the same figure.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45361e0e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from autoreduce import solve_ode\n", + "\n", + "try:\n", + " import matplotlib.pyplot as plt\n", + "\n", + " comparison_timepoints = np.linspace(0, 24, 100)\n", + " full_solution = solve_ode(sys, comparison_timepoints).T\n", + " reduced_solution = solve_ode(reduced_sys_1567, comparison_timepoints).T\n", + "\n", + " full_total_population = (np.asarray(sys.C) @ full_solution).sum(axis=0)\n", + " reduced_total_population = (\n", + " np.asarray(reduced_sys_1567.C) @ reduced_solution\n", + " ).sum(axis=0)\n", + "\n", + " fig, ax = plt.subplots(figsize=(7, 4))\n", + " ax.plot(\n", + " comparison_timepoints,\n", + " full_total_population,\n", + " 'k--',\n", + " linewidth=2.5,\n", + " label='Full model',\n", + " )\n", + " ax.plot(\n", + " comparison_timepoints,\n", + " reduced_total_population,\n", + " linewidth=2,\n", + " label='Reduced model',\n", + " )\n", + " ax.set_xlabel('Time')\n", + " ax.set_ylabel('Total population')\n", + " ax.legend()\n", + " fig.tight_layout()\n", + " fig.savefig('pop_control_reduced_model_comparison.svg', bbox_inches='tight')\n", + " plt.show()\n", + "except ImportError:\n", + " print('Plotting libraries missing.')\n" + ] + }, + { + "cell_type": "markdown", + "id": "9aaff8a8", + "metadata": {}, + "source": [ + "## Plot one robustness metric\n", + "\n", + "Finally, we compute the robustness metric for the same selected reduced model. The heatmap has one row because we are comparing one reduced model against the full system; each column is the contribution from one model parameter.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c5e37137", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\ayush\\Box\\Research\\autoReduce_HPC\\autoreduce\\solvers\\ode.py:64: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", + " sol = odeint(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from autoreduce import get_robustness_metric\n", + "from sympy import latex\n", + "\n", + "try:\n", + " import matplotlib.pyplot as plt\n", + " import seaborn as sns\n", + "\n", + " robustness_timepoints = np.linspace(0, 24, 2)\n", + " Se_1567, R_1567 = get_robustness_metric(\n", + " sys,\n", + " reduced_sys_1567,\n", + " timepoints_ode=comparison_timepoints,\n", + " timepoints_ssm=robustness_timepoints,\n", + " )\n", + "\n", + " parameter_labels = [f'${latex(parameter)}$' for parameter in P]\n", + "\n", + " fig, ax = plt.subplots(figsize=(11, 2.6))\n", + " sns.heatmap(\n", + " np.asarray([Se_1567]),\n", + " ax=ax,\n", + " cmap='YlGnBu',\n", + " xticklabels=parameter_labels,\n", + " yticklabels=['Reduced model'],\n", + " cbar_kws={'label': r'Robustness metric ($\\|S_\\zeta\\|$)'},\n", + " )\n", + " ax.set_xlabel('Parameters')\n", + " ax.set_ylabel('')\n", + " ax.set_title(f'Robustness score R = {R_1567:.3g}')\n", + " plt.setp(ax.get_xticklabels(), rotation=45, ha='right')\n", + " fig.tight_layout()\n", + " fig.savefig('pop_control_robustness.svg', bbox_inches='tight')\n", + " plt.show()\n", + "except ImportError:\n", + " print('Plotting libraries missing.')\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "autoreduce", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/biological/BioCRNPyler interface.ipynb b/examples/biological/BioCRNPyler interface.ipynb new file mode 100644 index 0000000..a53f846 --- /dev/null +++ b/examples/biological/BioCRNPyler interface.ipynb @@ -0,0 +1,753 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "biocrnpyler-interface-00", + "metadata": {}, + "source": [ + "# BioCRNPyler-AutoReduce Interface\n", + "\n", + "The goal of this notebook is to demonstrate how to use BioCRNpyler models with AutoReduce, which is pretty simple: load the saved SBML file into AutoReduce!\n", + "\n", + "In this example, we build a simple GFP expression model with BioCRNpyler and load it into AutoReduce to perform model reduction and explore various reduced models. Note that BioCRNpyler is an optional dependency for AutoReduce, you can install the package with the bio tag: `autoreduce[bio]` to get it or simply install biocrnpyler in your environment: `pip install biocrnpyler`.\n" + ] + }, + { + "cell_type": "markdown", + "id": "biocrnpyler-interface-01", + "metadata": {}, + "source": [ + "## Pipeline workflow\n", + "\n", + "This pipeline consists of five steps: (1) mechanisticmodeling, (2) SBML import, (3) reduction, (4) validation, and (5) model export.\n", + "\n", + "1. The detailed CRN is generated from components and mechanisms. This keeps the mechanistic assumptions explicit. Here, transcription and translation mechanisms introduce two reversible binding reactions, two production reactions, and degradation reactions for transcript and protein.\n", + "2. The full model is loaded into AutoReduce with a specified output. The choice of output matters because a reduced model that preserves one species may not preserve all species. Here, the selected output is the GFP protein species, `protein_GFP`.\n", + "3. Conservation laws are applied when the model contains conserved totals. This reduction is algebraic and exact for the reaction network under the included reactions. Here, we have DNA, RNAP, and ribosome species, that are conserved because free and bound forms sum to fixed totals when the resource machinery is not produced or degraded.\n", + "4. Time-scale separation is applied to remove intermediate complexes (assuming certain reactions occur much faster than others). \n", + "5. The reduced model is exported so it can be reused in the same modeling workflow as the full model, while retaining a record of the reduction assumptions used to obtain it.\n" + ] + }, + { + "cell_type": "markdown", + "id": "58db72cc", + "metadata": {}, + "source": [ + "### Package imports and setup " + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "biocrnpyler-interface-02", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "\n", + "import numpy as np\n", + "from sympy import Symbol\n", + "\n", + "try:\n", + " import biocrnpyler as bcp\n", + "except ModuleNotFoundError as exc:\n", + " raise ModuleNotFoundError(\n", + " \"BioCRNpyler is required for this notebook. Install with \"\n", + " \"`pip install autoreduce[bio]`.\"\n", + " ) from exc\n", + "\n", + "from autoreduce import (\n", + " load_sbml,\n", + " solve_conservation_laws,\n", + " solve_ode,\n", + " solve_sensitivity,\n", + " solve_timescale_separation,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "4d051b11", + "metadata": {}, + "source": [ + "### Set initial conditions" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "d9677b8f", + "metadata": {}, + "outputs": [], + "source": [ + "TOTAL_DNA = 0.01\n", + "TOTAL_RNAP = 10\n", + "TOTAL_RIBOSOME = 20\n", + "TOTAL_RNAASE = 2.0\n", + "\n", + "initial_conditions = {\n", + " \"dna_gfp\": TOTAL_DNA,\n", + " \"protein_RNAP\": TOTAL_RNAP,\n", + " \"protein_Ribo\": TOTAL_RIBOSOME,\n", + " \"protein_RNase\": TOTAL_RNAASE,\n", + "}\n" + ] + }, + { + "cell_type": "markdown", + "id": "biocrnpyler-interface-03", + "metadata": {}, + "source": [ + "## Build CRN using BioCRNpyler\n", + "\n", + "We use the BioCRNpyler component `DNAassembly` as the main part in the system. We initialize this component in a mechanistic transcription-translation extract mixture. This mixture instantiates the resources needed for protein expression: RNAP and ribosomes. The transcription reaction produces the mRNA species and the translation of the mRNA to the final protein is included via complex formation. BioCRNpyler automatically generates the species, reactions, and parameters for this system from the high-level specification.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "biocrnpyler-interface-05", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Species: 9\n", + " dna_gfp\n", + " protein_RNAP\n", + " rna_gfp\n", + " complex_dna_gfp_protein_RNAP_\n", + " protein_Ribo\n", + " protein_GFP\n", + " complex_protein_Ribo_rna_gfp_\n", + " protein_RNase\n", + " complex_protein_RNase_rna_gfp_\n", + "\n", + "Reactions: 7\n", + " dna[gfp]+protein[RNAP] <--> complex[dna[gfp]:protein[RNAP]]\n", + " complex[dna[gfp]:protein[RNAP]] --> dna[gfp]+rna[gfp]+protein[RNAP]\n", + " rna[gfp]+protein[Ribo] <--> complex[protein[Ribo]:rna[gfp]]\n", + " complex[protein[Ribo]:rna[gfp]] --> rna[gfp]+protein[GFP]+protein[Ribo]\n", + " protein[GFP] --> \n", + " rna[gfp]+protein[RNase] <--> complex[protein[RNase]:rna[gfp]]\n", + " complex[protein[RNase]:rna[gfp]] --> protein[RNase]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\ayush\\anaconda3\\envs\\autoreduce\\Lib\\site-packages\\biocrnpyler\\core\\parameter.py:1575: UserWarning: parameter file contains no unit column! Please add a column named ['unit', 'units'].\n", + " warn(\n" + ] + } + ], + "source": [ + "gfp_dna = bcp.DNAassembly(\n", + " name=\"gfp\",\n", + " promoter=\"pconst\",\n", + " rbs=\"rbs_strong\",\n", + " protein=\"GFP\",\n", + ")\n", + "\n", + "degradation = bcp.Dilution(\n", + " mechanism_type=\"global_mechanism\",\n", + " filter_dict = {\"GFP\": True},\n", + " default_on = False\n", + ")\n", + "\n", + "\n", + "txtl_extract = bcp.TxTlExtract(\n", + " name=\"txtl\",\n", + " components=[gfp_dna],\n", + " parameter_file=\"default_parameters.txt\",\n", + " initial_condition_dictionary=initial_conditions,\n", + " global_mechanisms=[degradation]\n", + ")\n", + "\n", + "gfp_crn = txtl_extract.compile_crn()\n", + "\n", + "gfp_crn.write_sbml_file(\"models/biocrnpyler_gfp_expression.xml\")\n", + "\n", + "# print the model particulars\n", + "print(f\"Species: {len(gfp_crn.species)}\")\n", + "for species in gfp_crn.species:\n", + " print(f\" {repr(species)}\")\n", + "\n", + "print(f\"\\nReactions: {len(gfp_crn.reactions)}\")\n", + "for reaction in gfp_crn.reactions:\n", + " print(f\" {reaction}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "biocrnpyler-interface-06", + "metadata": {}, + "source": [ + "## AutoReduce: `load_sbml` to load the BioCRNpyler model\n", + "\n", + "When loading the model, we select `protein_GFP` as the output to preserve. The initial conditions will be set after import so the AutoReduce `System` object uses the same DNA and machinery totals as the BioCRNpyler model.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "e15a4ddd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'dna_gfp': 0.01, 'protein_RNAP': 10, 'protein_Ribo': 20, 'protein_RNase': 2.0}" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "initial_conditions" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "biocrnpyler-interface-07", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Your output 'protein_GFP' is now set using the system.C matrix!\n" + ] + } + ], + "source": [ + "full_system = load_sbml(\"models/biocrnpyler_gfp_expression.xml\",\n", + " outputs=[\"protein_GFP\"])\n", + "\n", + "# set the initial conditions for the system\n", + "species_to_index = {\n", + " str(state): index for index, state in enumerate(full_system.x)\n", + "}\n", + "\n", + "for species_name, concentration in initial_conditions.items():\n", + " if species_name in species_to_index:\n", + " full_system.x_init[species_to_index[species_name]] = concentration" + ] + }, + { + "cell_type": "markdown", + "id": "20ad8a48", + "metadata": {}, + "source": [ + "### Print the `System` attributes" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "7cc155ad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "States and initial conditions\n", + " 0: dna_gfp = 0.01\n", + " 1: protein_RNAP = 10\n", + " 2: rna_gfp = 0.0\n", + " 3: complex_dna_gfp_protein_RNAP_ = 0.0\n", + " 4: protein_Ribo = 20\n", + " 5: protein_GFP = 0.0\n", + " 6: complex_protein_Ribo_rna_gfp_ = 0.0\n", + " 7: protein_RNase = 2.0\n", + " 8: complex_protein_RNase_rna_gfp_ = 0.0\n", + "\n", + "Parameters\n", + " kb__ = 100.0\n", + " ku__ = 10.0\n", + " ktx__ = 0.05\n", + " ktl__ = 0.05\n", + " kdil__ = 0.001\n", + " kdeg__rna_degradation_mm = 0.01\n" + ] + } + ], + "source": [ + "print(\"States and initial conditions\")\n", + "for index, state in enumerate(full_system.x):\n", + " print(f\" {index}: {state} = {full_system.x_init[index]}\")\n", + "\n", + "print(\"\\nParameters\")\n", + "for parameter, value in zip(full_system.params, full_system.params_values):\n", + " print(f\" {parameter} = {value}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "biocrnpyler-interface-08", + "metadata": {}, + "source": [ + "### Use the `solvers` module for simulation \n", + "\n", + "Full model simulation\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "biocrnpyler-interface-09", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "timepoints = np.linspace(0, 10000, 5)\n", + "full_solution = solve_ode(full_system, timepoints)\n", + "full_gfp_index = full_system.x.index(Symbol(\"protein_GFP\"))\n", + "full_gfp = full_solution[:, full_gfp_index]\n", + "\n", + "try:\n", + " import matplotlib.pyplot as plt\n", + "\n", + " fig, ax = plt.subplots(figsize=(6, 4))\n", + " ax.plot(timepoints, full_gfp, label=\"full model\")\n", + " ax.set_xlabel(\"time\")\n", + " ax.set_ylabel(\"protein_GFP\")\n", + " ax.legend()\n", + "except ModuleNotFoundError:\n", + " print(\"matplotlib is not installed; skipping plot.\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "biocrnpyler-interface-10", + "metadata": {}, + "source": [ + "### Reduction step 1: Apply conservation laws\n", + "\n", + "We have four conserved quantities: (1) DNA, (2) RNAP, (3) ribosome, and (4) RNAase. Applying these laws removes free DNA, free RNAP, free ribosome, and free RNAase from the full system and introduces total quantities as parameters.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "biocrnpyler-interface-11", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "States after conservation law reduction\n", + " 0: rna_gfp\n", + " 1: complex_dna_gfp_protein_RNAP_\n", + " 2: protein_GFP\n", + " 3: complex_protein_Ribo_rna_gfp_\n", + " 4: complex_protein_RNase_rna_gfp_\n" + ] + } + ], + "source": [ + "state = {str(symbol): symbol for symbol in full_system.x}\n", + "\n", + "conserved_sets = [\n", + " [\n", + " state[\"dna_gfp\"],\n", + " state[\"complex_dna_gfp_protein_RNAP_\"],\n", + " ],\n", + " [\n", + " state[\"protein_RNAP\"],\n", + " state[\"complex_dna_gfp_protein_RNAP_\"],\n", + " ],\n", + " [\n", + " state[\"protein_Ribo\"],\n", + " state[\"complex_protein_Ribo_rna_gfp_\"],\n", + " ],\n", + " [\n", + " state[\"protein_RNase\"],\n", + " state[\"complex_protein_RNase_rna_gfp_\"],\n", + " ]\n", + "]\n", + "\n", + "total_quantities = {\n", + " \"DNA_total\": TOTAL_DNA,\n", + " \"RNAP_total\": TOTAL_RNAP,\n", + " \"Ribo_total\": TOTAL_RIBOSOME,\n", + " \"RNAase_total\": TOTAL_RNAASE,\n", + "}\n", + "\n", + "states_to_eliminate = [\n", + " state[\"dna_gfp\"],\n", + " state[\"protein_RNAP\"],\n", + " state[\"protein_Ribo\"],\n", + " state[\"protein_RNase\"]\n", + "]\n", + "\n", + "conserved_system = solve_conservation_laws(\n", + " full_system,\n", + " conserved_sets=conserved_sets,\n", + " total_quantities=total_quantities,\n", + " states_to_eliminate=states_to_eliminate,\n", + ")\n", + "\n", + "print(\"States after conservation law reduction\")\n", + "for index, state_symbol in enumerate(conserved_system.x):\n", + " print(f\" {index}: {state_symbol}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "9b0c4a02", + "metadata": {}, + "source": [ + "### Print model equations at this stage:" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "eead642b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[complex_dna_gfp_protein_RNAP_*ktx__ + complex_protein_RNase_rna_gfp_*ku__ + complex_protein_Ribo_rna_gfp_*ktl__ + complex_protein_Ribo_rna_gfp_*ku__ - kb__*rna_gfp*(RNAase_total - complex_protein_RNase_rna_gfp_) - kb__*rna_gfp*(Ribo_total - complex_protein_Ribo_rna_gfp_),\n", + " -complex_dna_gfp_protein_RNAP_*ktx__ - complex_dna_gfp_protein_RNAP_*ku__ + kb__*(DNA_total - complex_dna_gfp_protein_RNAP_)*(RNAP_total - complex_dna_gfp_protein_RNAP_),\n", + " complex_protein_Ribo_rna_gfp_*ktl__ - kdil__*protein_GFP,\n", + " -complex_protein_Ribo_rna_gfp_*ktl__ - complex_protein_Ribo_rna_gfp_*ku__ + kb__*rna_gfp*(Ribo_total - complex_protein_Ribo_rna_gfp_),\n", + " -complex_protein_RNase_rna_gfp_*kdeg__rna_degradation_mm - complex_protein_RNase_rna_gfp_*ku__ + kb__*rna_gfp*(RNAase_total - complex_protein_RNase_rna_gfp_)]" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "conserved_system.f" + ] + }, + { + "cell_type": "markdown", + "id": "biocrnpyler-interface-12", + "metadata": {}, + "source": [ + "### Reduction step 2: Apply time-scale separation\n", + "\n", + "Assume that complex formation is a fast process relative to the other steps. This collapses the model to mRNA and GFP protein dynamics. AutoReduce can obtain the reduced model by applying such a time-scale separation assumption. " + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "biocrnpyler-interface-13", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Successful solution obtained with states: [rna_gfp, protein_GFP]!\n", + "Reduced states\n", + " rna_gfp\n", + " protein_GFP\n", + "\n", + "Reduced dynamics\n", + " drna_gfp/dt = (-RNAase_total*kb__**2*kdeg__rna_degradation_mm*rna_gfp + ktx__*(kb__*rna_gfp + kdeg__rna_degradation_mm + ku__)*(DNA_total*kb__ + RNAP_total*kb__ + ktx__ + ku__ - sqrt(DNA_total**2*kb__**2 - 2*DNA_total*RNAP_total*kb__**2 + 2*DNA_total*kb__*ktx__ + 2*DNA_total*kb__*ku__ + RNAP_total**2*kb__**2 + 2*RNAP_total*kb__*ktx__ + 2*RNAP_total*kb__*ku__ + ktx__**2 + 2*ktx__*ku__ + ku__**2))/2)/(kb__*(kb__*rna_gfp + kdeg__rna_degradation_mm + ku__))\n", + " dprotein_GFP/dt = (Ribo_total*kb__*ktl__*rna_gfp - kdil__*protein_GFP*(kb__*rna_gfp + ktl__ + ku__))/(kb__*rna_gfp + ktl__ + ku__)\n" + ] + } + ], + "source": [ + "state = {str(symbol): symbol for symbol in conserved_system.x}\n", + "\n", + "slow_states = [state[\"rna_gfp\"], state[\"protein_GFP\"]]\n", + "\n", + "reduced_system, fast_subsystem = solve_timescale_separation(\n", + " conserved_system,\n", + " slow_states=slow_states\n", + ")\n", + "\n", + "print(\"Reduced states\")\n", + "for state_symbol in reduced_system.x:\n", + " print(f\" {state_symbol}\")\n", + "\n", + "print(\"\\nReduced dynamics\")\n", + "for state_symbol, ode in zip(reduced_system.x, reduced_system.f):\n", + " print(f\" d{state_symbol}/dt = {ode}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "biocrnpyler-interface-14", + "metadata": {}, + "source": [ + "## Compare: Error and robustness \n", + "\n", + "AutoReduce provides methods to compare the performance of the full model vs the reduced model in terms of the accuracy of the output (error) and the robustness of the reduced model to perturbations in the parameters. This is achieved by computing the numerical metrics as shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "biocrnpyler-interface-15", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Output error over time horizon: 5.78\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from autoreduce import get_error_metric\n", + "\n", + "conserved_gfp = solve_ode(conserved_system, timepoints)\n", + "output_conserved_gfp = conserved_gfp[:, conserved_system.x.index(Symbol(\"protein_GFP\"))]\n", + "reduced_gfp = solve_ode(reduced_system, timepoints)\n", + "output_reduced_gfp = reduced_gfp[:, reduced_system.x.index(Symbol(\"protein_GFP\"))]\n", + "\n", + "error = get_error_metric(full_system, reduced_system, timepoints)\n", + "\n", + "print(f\"Output error over time horizon: {error:.3g}\")\n", + "\n", + "try:\n", + " import matplotlib.pyplot as plt\n", + "\n", + " fig, ax = plt.subplots(figsize=(6, 4))\n", + " ax.plot(timepoints, full_gfp, label=\"full model\", ls='--', lw=2)\n", + " ax.plot(timepoints, output_conserved_gfp, label=\"conserved model\", alpha=0.5)\n", + " ax.plot(timepoints, output_reduced_gfp, \"--\", label=\"reduced model\")\n", + " ax.set_xlabel(\"time\")\n", + " ax.set_ylabel(\"protein_GFP\")\n", + " ax.legend()\n", + "except ModuleNotFoundError:\n", + " print(\"matplotlib is not installed; skipping plot.\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "c6382fc5", + "metadata": {}, + "source": [ + "Removing all complex formation steps led to some inaccuracies! " + ] + }, + { + "cell_type": "markdown", + "id": "biocrnpyler-interface-16", + "metadata": {}, + "source": [ + "### Robustness computation\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "biocrnpyler-interface-17", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SSM Progress: |######################----------------------------| 44.9% Complete\r" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\ayush\\Box\\Research\\autoReduce_HPC\\autoreduce\\solvers\\ssm.py:239: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", + " sol = odeint(sens_func_ode, S0, timepoints, tfirst=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\ayush\\anaconda3\\envs\\autoreduce\\Lib\\site-packages\\numpy\\linalg\\_linalg.py:2768: RuntimeWarning: overflow encountered in dot\n", + " sqnorm = x.dot(x)\n" + ] + } + ], + "source": [ + "from autoreduce import get_robustness_metric\n", + "\n", + "# resolution for robustness analysis\n", + "# timepoints kept low for quick tests\n", + "sensitivity_timepoints = np.linspace(0, 5000, 5)\n", + "robustness_metric = get_robustness_metric(\n", + " full_system,\n", + " reduced_system,\n", + " timepoints_ode=sensitivity_timepoints,\n", + " timepoints_ssm=sensitivity_timepoints,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "biocrnpyler-interface-robustness-output", + "metadata": {}, + "source": [ + "The robustness metric contains a tuple `(Se, R)`. \n", + "\n", + "* `Se` is an array with one entry per parameter, in the same order as `full_system.params`; each entry reports the sensitivity-weighted output mismatch for that parameter over `sensitivity_timepoints`. \n", + "\n", + "* `R` is the scalar robustness score computed from these sensitivity mismatches and the output trajectory error. This comparison is specific to the selected output, here GFP protein, and to the initial conditions, parameter values, and time horizon used above." + ] + }, + { + "cell_type": "markdown", + "id": "06db1e8f", + "metadata": {}, + "source": [ + "Sensitivity of the reduced model's prediction of GFP to all parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "d271ef46", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[9.53112797e+00 inf 1.54056980e-01 5.05857784e+29\n", + " 5.05857784e+29 7.20435940e+00 1.07537090e+01 2.43902090e+04\n", + " 7.51941542e+30 7.51941542e+30]\n" + ] + } + ], + "source": [ + "print(robustness_metric[0])" + ] + }, + { + "cell_type": "markdown", + "id": "824e9a47", + "metadata": {}, + "source": [ + "The overall robustness score (higher is better)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "c3b5da50", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n" + ] + } + ], + "source": [ + "print(robustness_metric[1])" + ] + }, + { + "cell_type": "markdown", + "id": "biocrnpyler-interface-18", + "metadata": {}, + "source": [ + "## Export\n", + "\n", + "The final reduced model can be written back to SBML with the `write_sbml` function in AutoReduce." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "biocrnpyler-interface-19", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reduced_system.write_sbml(\"models/reduced_gfp_expression.xml\")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "89d47809", + "metadata": {}, + "outputs": [], + "source": [ + "#end" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "autoreduce", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/biological/Derivation of Hill functions.ipynb b/examples/biological/Derivation of Hill functions.ipynb new file mode 100644 index 0000000..86e0083 --- /dev/null +++ b/examples/biological/Derivation of Hill functions.ipynb @@ -0,0 +1,240 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "hill-functions-00", + "metadata": {}, + "source": [ + "# Derivation of Hill Functions\n", + "\n", + "This notebook follows (and automates) Example 3.11 in Del Vecchio and Murray, *Biomolecular Feedback Systems*, and shows how a Hill function can be derived by applying a quasi-steady-state approximation to fast reversible binding reactions using AutoReduce.\n" + ] + }, + { + "cell_type": "markdown", + "id": "hill-functions-01", + "metadata": {}, + "source": [ + "## Model\n", + "\n", + "A transcription factor $X$ dimerizes before binding a promoter site $p$. The bound complex $C$ activates production of the mRNA $m_Y$, which is translated into protein $Y$:\n", + "\n", + "$$\n", + "X + X \\xrightleftharpoons[k_2]{k_1} X_2, \\qquad\n", + "X_2 + p \\xrightleftharpoons[d]{a} C, \\qquad\n", + "C \\xrightarrow{k_f} m_Y + C,\n", + "$$\n", + "\n", + "$$\n", + "m_Y \\xrightarrow{\\kappa} m_Y + Y, \\qquad\n", + "m_Y \\xrightarrow{\\delta} \\emptyset, \\qquad\n", + "Y \\xrightarrow{\\gamma} \\emptyset, \\qquad\n", + "p + C = p_{tot}.\n", + "$$\n", + "\n", + "Treating $X(t)$ as an input, the ODE model is\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\frac{dX_2}{dt} &= k_1X^2-k_2X_2-aX_2(p_{tot}-C)+dC, \\\\\n", + "\\frac{dC}{dt} &= aX_2(p_{tot}-C)-dC, \\\\\n", + "\\frac{dm_Y}{dt} &= k_fC-\\delta m_Y, \\\\\n", + "\\frac{dY}{dt} &= \\kappa m_Y-\\gamma Y.\n", + "\\end{aligned}\n", + "$$\n" + ] + }, + { + "cell_type": "markdown", + "id": "369c3121", + "metadata": {}, + "source": [ + "### Construct an AutoReduce `System`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "hill-functions-02", + "metadata": {}, + "outputs": [], + "source": [ + "from sympy import simplify, symbols\n", + "from autoreduce import System, solve_timescale_separation\n", + "\n", + "X, X2, C, mY, Y = symbols(\"X X2 C m_Y Y\")\n", + "k1, k2, a, d, kf, delta, kappa, gamma, p_tot = symbols(\n", + " \"k1 k2 a d k_f delta kappa gamma p_tot\"\n", + ")\n", + "\n", + "system = System(\n", + " [X2, C, mY, Y],\n", + " [\n", + " k1 * X**2 - k2 * X2 - a * X2 * (p_tot - C) + d * C,\n", + " a * X2 * (p_tot - C) - d * C,\n", + " kf * C - delta * mY,\n", + " kappa * mY - gamma * Y,\n", + " ],\n", + " params=[X, k1, k2, a, d, kf, delta, kappa, gamma, p_tot],\n", + " params_values=[1.0] * 10,\n", + " x_init=[0.0, 0.0, 0.0, 0.0],\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "hill-functions-03", + "metadata": {}, + "source": [ + "## Reduction step 1: fast binding limit\n", + "\n", + "The binding reactions are much faster than mRNA and protein production and decay. With\n", + "\n", + "$$\n", + "K_m := \\frac{k_2}{k_1}, \\qquad K_d := \\frac{d}{a}, \\qquad c := \\frac{k_2}{d}, \\qquad \\epsilon := \\frac{\\gamma}{d},\n", + "$$\n", + "\n", + "the fast equations are written in singular perturbation form by using\n", + "\n", + "$$\n", + "d=\\frac{\\gamma}{\\epsilon}, \\qquad\n", + "a=\\frac{\\gamma}{K_d\\epsilon}, \\qquad\n", + "k_1=c\\frac{\\gamma}{K_m\\epsilon}, \\qquad\n", + "k_2=c\\frac{\\gamma}{\\epsilon}.\n", + "$$\n", + "\n", + "Setting $\\epsilon=0$ gives the slow manifold\n", + "\n", + "$$\n", + "X_2 = \\frac{X^2}{K_m}, \\qquad\n", + "C = \\frac{p_{tot}X^2/(K_mK_d)}{1 + X^2/(K_mK_d)}.\n", + "$$\n" + ] + }, + { + "cell_type": "markdown", + "id": "hill-functions-04", + "metadata": {}, + "source": [ + "### Solve the QSSA reduction\n", + "\n", + "AutoReduce obtains the slow model by retaining $m_Y$ and $Y$ and treating $X_2$ and $C$ as fast states. This can be done using `solve_timescale_separation` in AutoReduce.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "hill-functions-05", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Successful solution obtained with states: [m_Y, Y]!\n" + ] + }, + { + "data": { + "text/plain": [ + "[(X**2*a*k1*k_f*p_tot - delta*m_Y*(X**2*a*k1 + d*k2))/(X**2*a*k1 + d*k2),\n", + " -Y*gamma + kappa*m_Y]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reduced_system, collapsed_system = solve_timescale_separation(\n", + " system,\n", + " slow_states=[mY, Y],\n", + " fast_states=[X2, C],\n", + ")\n", + "\n", + "reduced_equations = [simplify(expr) for expr in reduced_system.f]\n", + "reduced_equations\n" + ] + }, + { + "cell_type": "markdown", + "id": "hill-functions-06", + "metadata": {}, + "source": [ + "## Reduction step 2: obtain the Hill function form by parameter lumping\n", + "\n", + "From the example in the book, we have that the reduced mRNA dynamics can be written as\n", + "\n", + "$$\n", + "\\frac{dm_Y}{dt} = k_f\\frac{p_{tot}X^2/(K_mK_d)}{1+X^2/(K_mK_d)} - \\delta m_Y,\n", + "$$\n", + "\n", + "and the protein equation remains\n", + "\n", + "$$\n", + "\\frac{dY}{dt}=\\kappa m_Y-\\gamma Y.\n", + "$$\n", + "\n", + "Letting $\\alpha=k_fp_{tot}$ and $K=\\sqrt{K_mK_d}$ gives the standard Hill expression\n", + "\n", + "$$\n", + "F(X)=\\alpha\\frac{(X/K)^2}{1+(X/K)^2}.\n", + "$$\n", + "\n", + "\n", + "Using SymPy, the Hill function can now be written in a more compact form by performing the substitution for the lumped parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "hill-functions-07", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\frac{X^{2} k_{f} p_{tot}}{K_{d} K_{m} + X^{2}}$" + ], + "text/plain": [ + "X**2*k_f*p_tot/(K_d*K_m + X**2)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Km, Kd = symbols(\"K_m K_d\")\n", + "\n", + "production_term = simplify(reduced_system.f[0] + delta * mY)\n", + "hill_form = simplify(production_term.subs({k2: Km * k1, d: Kd * a}))\n", + "\n", + "hill_form\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "autoreduce", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/biological/Exploration of gene expression models.ipynb b/examples/biological/Exploration of gene expression models.ipynb new file mode 100644 index 0000000..251f8ca --- /dev/null +++ b/examples/biological/Exploration of gene expression models.ipynb @@ -0,0 +1,1293 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b708cae6", + "metadata": {}, + "source": [ + "# Models of Gene Expression: How to Choose One? \n", + "\n", + "This notebook shows how AutoReduce can be used to explore many possible models of gene expression and identify the most accurate model in different parameter regimes. The accuracy of a model depends on the selected output of interest, the parameter values, initial conditions and time interval. Using AutoReduce, many possible candidates can be explored and validated in different regions of parameter space. We use BioCRNpyler to build mechanistic models of gene expression as our starting point in this notebook.\n", + "\n", + "But, first, let's set some plot settings for the notebook:" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "badf10e0", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "\n", + "warnings.filterwarnings(\n", + " \"ignore\",\n", + " message=\"parameter file contains no unit column\",\n", + ")\n", + "\n", + "plt.rcParams.update(\n", + " {\n", + " \"axes.spines.top\": False,\n", + " \"axes.spines.right\": False,\n", + " \"axes.grid\": True,\n", + " \"grid.alpha\": 0.25,\n", + " \"figure.figsize\": (7.5, 4.5),\n", + " \"font.size\": 11,\n", + " }\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "82d6185e", + "metadata": {}, + "source": [ + "## Build CRN using BioCRNpyler\n", + "\n", + "We use the BioCRNpyler component `DNAassembly` as the main Component of the system. We initialize this component in a mechanistic transcription-translation mixture. This mixture instantiates the resources needed for protein expression: RNAP, ribosomes, endonucleases. The transcription reaction produces the mRNA species and the translation of the mRNA to the final protein is included via complex formation. BioCRNpyler automatically generates the species, reactions, and parameters for this system from the high-level specification.\n", + "\n", + "The species in this model include the RNA polymerase $P$, the gene-polymerase complex $C_1$, the mRNA transcript $T$, the free ribosomes $R$, the free endonucleases $E$, the transcript-ribosome complex $C_2$, the endonuclease-mRNA complex $C_3$, and the expressed protein $X$. Thus, we denote the state vector and output as\n", + "\n", + "$$\n", + "x=\\begin{bmatrix}P&C_1&T&E&R&C_2&C_3&X\\end{bmatrix}^{\\mathsf T},\n", + "\\qquad y=X.\n", + "$$\n", + "\n", + "Let's create this model using BioCRNpyler:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "00073e13", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Species: 9\n", + " dna_X\n", + " protein_RNAP\n", + " rna_X\n", + " complex_dna_X_protein_RNAP_\n", + " protein_Ribo\n", + " protein_X\n", + " complex_protein_Ribo_rna_X_\n", + " protein_RNase\n", + " complex_protein_RNase_rna_X_\n", + "\n", + "Reactions: 7\n", + " dna[X]+protein[RNAP] <--> complex[dna[X]:protein[RNAP]]\n", + " complex[dna[X]:protein[RNAP]] --> dna[X]+rna[X]+protein[RNAP]\n", + " rna[X]+protein[Ribo] <--> complex[protein[Ribo]:rna[X]]\n", + " complex[protein[Ribo]:rna[X]] --> rna[X]+protein[X]+protein[Ribo]\n", + " protein[X] --> \n", + " rna[X]+protein[RNase] <--> complex[protein[RNase]:rna[X]]\n", + " complex[protein[RNase]:rna[X]] --> protein[RNase]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\ayush\\anaconda3\\envs\\autoreduce\\Lib\\site-packages\\biocrnpyler\\mechanisms\\global_mechanisms.py:204: UserWarning: species rna_X has multiple attributes (or material type) which conflict with global mechanism filter {repr(self)}. Using default value False.\n", + " warn(\n", + "c:\\Users\\ayush\\anaconda3\\envs\\autoreduce\\Lib\\site-packages\\biocrnpyler\\mechanisms\\global_mechanisms.py:204: UserWarning: species complex_dna_X_protein_RNAP_ has multiple attributes (or material type) which conflict with global mechanism filter {repr(self)}. Using default value False.\n", + " warn(\n", + "c:\\Users\\ayush\\anaconda3\\envs\\autoreduce\\Lib\\site-packages\\biocrnpyler\\mechanisms\\global_mechanisms.py:204: UserWarning: species complex_protein_Ribo_rna_X_ has multiple attributes (or material type) which conflict with global mechanism filter {repr(self)}. Using default value False.\n", + " warn(\n", + "c:\\Users\\ayush\\anaconda3\\envs\\autoreduce\\Lib\\site-packages\\biocrnpyler\\mechanisms\\global_mechanisms.py:204: UserWarning: species dna_X has multiple attributes (or material type) which conflict with global mechanism filter {repr(self)}. Using default value False.\n", + " warn(\n" + ] + } + ], + "source": [ + "import biocrnpyler as bcp\n", + "from biocrnpyler.components import DNAassembly\n", + "\n", + "\n", + "TOTAL_DNA = 0.01\n", + "TOTAL_RNAP = 10\n", + "TOTAL_RIBOSOME = 20\n", + "TOTAL_RNAASE = 2.0\n", + "\n", + "initial_conditions = {\n", + " \"dna_X\": TOTAL_DNA,\n", + " \"protein_RNAP\": TOTAL_RNAP,\n", + " \"protein_Ribo\": TOTAL_RIBOSOME,\n", + " \"protein_RNase\": TOTAL_RNAASE,\n", + "}\n", + "\n", + "gene = DNAassembly(\n", + " name=\"X\",\n", + " promoter=\"strong\",\n", + " rbs=\"strong\",\n", + " transcript=\"X\",\n", + " protein=\"X\",\n", + ")\n", + "degradation = bcp.Dilution(\n", + " mechanism_type=\"global_mechanism\",\n", + " filter_dict = {\"X\": True, \"dna\": False, \"rna\":False},\n", + " default_on = False\n", + ")\n", + "\n", + "txtl_extract = bcp.TxTlExtract(\n", + " name=\"txtl\",\n", + " components=[gene],\n", + " parameter_file=\"default_parameters.txt\",\n", + " initial_condition_dictionary=initial_conditions,\n", + " global_mechanisms=[degradation]\n", + ")\n", + "\n", + "crn = txtl_extract.compile_crn()\n", + "crn.write_sbml_file(\"models/biocrnpyler_gene_expression_resource.xml\")\n", + "\n", + "print(f\"Species: {len(crn.species)}\")\n", + "for species in crn.species:\n", + " print(f\" {species}\")\n", + "\n", + "print(f\"\\nReactions: {len(crn.reactions)}\")\n", + "for reaction in crn.reactions:\n", + " print(f\" {reaction}\")" + ] + }, + { + "cell_type": "markdown", + "id": "aa639c93", + "metadata": {}, + "source": [ + "## Load and rename the species\n", + "\n", + "The SBML model can be loaded into AutoReduce using `load_sbml`. The SBML species names are descriptive but long. So, we use the `rename_species` argument in thie function that maps them to short symbols before the model is used for analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "8601de93", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Your output 'protein_X' is now set using the system.C matrix!\n" + ] + } + ], + "source": [ + "from autoreduce import load_sbml\n", + "from sympy import symbols\n", + "\n", + "G, P, T, C_1, R, X, C_2, E, C_3 = symbols(\"G P T C_1 R X C_2 E C_3\")\n", + "G_tot, P_tot, R_tot, E_tot, kb = symbols(\"G_tot P_tot R_tot E_tot kb__\")\n", + "species_rename = {\n", + " \"dna_X\": \"G\",\n", + " \"protein_RNAP\": \"P\",\n", + " \"rna_X\": \"T\",\n", + " \"complex_dna_X_protein_RNAP_\": \"C_1\",\n", + " \"protein_Ribo\": \"R\",\n", + " \"protein_X\": \"X\",\n", + " \"complex_protein_Ribo_rna_X_\": \"C_2\",\n", + " \"complex_protein_RNase_rna_X_\": \"C_3\",\n", + " \"protein_RNase\": \"E\",\n", + "}\n", + "\n", + "system = load_sbml(\n", + " \"models/biocrnpyler_gene_expression_resource.xml\",\n", + " outputs=[\"protein_X\"],\n", + " rename_species=species_rename,\n", + ")\n", + "\n", + "species_to_index = {str(state): index for index, state in enumerate(system.x)}\n", + "for species_name, concentration in initial_conditions.items():\n", + " state_name = species_rename[species_name]\n", + " system.x_init[species_to_index[state_name]] = concentration" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "6b119a32", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "States and initial conditions:\n", + " G: 0.01\n", + " P: 10\n", + " T: 0.0\n", + " C_1: 0.0\n", + " R: 20\n", + " X: 0.0\n", + " C_2: 0.0\n", + " E: 2.0\n", + " C_3: 0.0\n" + ] + } + ], + "source": [ + "print(\"States and initial conditions:\")\n", + "for state, value in zip(system.x, system.x_init):\n", + " print(f\" {state}: {value}\")" + ] + }, + { + "cell_type": "markdown", + "id": "283044b4", + "metadata": {}, + "source": [ + "## Show the ODEs" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "50838e3c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\begin{aligned}\\dot{G} &= C_{1} ktx_{strong } + C_{1} ku_{strong } - G P kb^{}\\\\\\dot{P} &= C_{1} ktx_{strong } + C_{1} ku_{strong } - G P kb^{}\\\\\\dot{T} &= C_{1} ktx_{strong } + C_{2} ktl^{} + C_{2} ku_{strong } + C_{3} ku^{} - E T kb^{} - R T kb^{}\\\\\\dot{C_{1}} &= - C_{1} ktx_{strong } - C_{1} ku_{strong } + G P kb^{}\\\\\\dot{R} &= C_{2} ktl^{} + C_{2} ku_{strong } - R T kb^{}\\\\\\dot{X} &= C_{2} ktl^{} - X kdil^{}\\\\\\dot{C_{2}} &= - C_{2} ktl^{} - C_{2} ku_{strong } + R T kb^{}\\\\\\dot{E} &= C_{3} kdeg^{rna}_{degradation mm} + C_{3} ku^{} - E T kb^{}\\\\\\dot{C_{3}} &= - C_{3} kdeg^{rna}_{degradation mm} - C_{3} ku^{} + E T kb^{}\\end{aligned}$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import Math, display\n", + "from sympy import latex, simplify\n", + "\n", + "rows = []\n", + "for state, rhs in zip(system.x, system.f):\n", + " rows.append(rf\"\\dot{{{latex(state)}}} &= {latex(simplify(rhs))}\")\n", + "\n", + "display(Math(r\"\\begin{aligned}\" + r\"\\\\\".join(rows) + r\"\\end{aligned}\"))" + ] + }, + { + "cell_type": "markdown", + "id": "bd33254e", + "metadata": {}, + "source": [ + "## Simulate the full model\n", + "\n", + "The selected output is protein $X$." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "ad60e301", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from autoreduce import solve_ode\n", + "\n", + "timepoints = np.linspace(0.0, 6000.0, 200)\n", + "solution = solve_ode(system, timepoints)\n", + "output = (system.C @ solution.T)[0]\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(timepoints/60, output, color=\"#0072B2\",\n", + " linewidth=2.4, label=\"TX-TL model of gene expression\")\n", + "ax.set_xlabel(\"Time (in minutes)\")\n", + "ax.set_ylabel(\"Protein $X$\")\n", + "ax.legend(frameon=False)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "3a8db172", + "metadata": {}, + "source": [ + "## Compute output sensitivity\n", + "\n", + "The sensitivity calculation uses the initial conditions imported from the SBML model. If the initial conditions are zero, then sensitivity computation can error out." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "3e4f6c90", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from autoreduce import solve_sensitivity\n", + "from sympy import latex\n", + "\n", + "sensitivity_timepoints = np.linspace(0.0, 10.0, 6)\n", + "state_sensitivities = solve_sensitivity(\n", + " system,\n", + " sensitivity_timepoints,\n", + " normalize=True,\n", + ")\n", + "output_sensitivities = []\n", + "for sensitivities_at_time in state_sensitivities:\n", + " output_sensitivities.append(np.asarray(system.C) @ sensitivities_at_time.T)\n", + "output_sensitivities = np.asarray(output_sensitivities)[:, 0, :]\n", + "\n", + "fig, ax = plt.subplots(figsize=(8.5, 4.5))\n", + "image = ax.imshow(\n", + " output_sensitivities.T,\n", + " aspect=\"auto\",\n", + " origin=\"lower\",\n", + " cmap=\"coolwarm\",\n", + ")\n", + "fig.colorbar(image, ax=ax, label=\"Normalized sensitivity\")\n", + "ax.set_xticks(range(len(sensitivity_timepoints)))\n", + "ax.set_xticklabels([f\"{time:.1f}\" for time in sensitivity_timepoints])\n", + "ax.set_yticks(range(len(system.params)))\n", + "ax.set_yticklabels([f\"${latex(param)}$\" for param in system.params])\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_ylabel(\"Parameter\")\n", + "ax.set_title(\"Sensitivity of protein $X$\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "21ecdb8a", + "metadata": {}, + "source": [ + "## Apply conservation laws using AutoReduce\n", + "\n", + "We use AutoReduce to find and apply the conservation laws in the system. \n", + "\n", + "We already know that it should find four conservation laws: one for the DNA, and three for the resources (RNAP, ribosomes, and endonucleases). The conservation laws are:\n", + "$$\n", + "G + C_1 = G_{\\mathrm{tot}},\\quad P+C_1=P_{\\mathrm{tot}},\\qquad R+C_2=R_{\\mathrm{tot}},\\quad E+C_3=E_{\\mathrm{tot}}.\n", + "$$\n", + "\n", + "Let's see if AutoReduce finds the same conservation laws. " + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "a6d20dfb", + "metadata": {}, + "outputs": [], + "source": [ + "from autoreduce import find_conserved_sets\n", + "\n", + "conserved_sets = find_conserved_sets(system, search_depth=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "732ad46e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[G, C_1], [P, C_1], [R, C_2], [E, C_3]]" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "conserved_sets" + ] + }, + { + "cell_type": "markdown", + "id": "eb01fb28", + "metadata": {}, + "source": [ + "Perfect! Let's apply these laws!" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "25354ec7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "States after conservation laws:\n", + " T\n", + " C_1\n", + " X\n", + " C_2\n", + " C_3\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle \\begin{aligned}\\dot{T} &= C_{1} ktx_{strong } + C_{2} ktl^{} + C_{2} ku_{strong } + C_{3} ku^{} + T kb^{} \\left(C_{2} - R_{tot}\\right) + T kb^{} \\left(C_{3} - E_{tot}\\right)\\\\\\dot{C_{1}} &= - C_{1} ktx_{strong } - C_{1} ku_{strong } + kb^{} \\left(C_{1} - G_{tot}\\right) \\left(C_{1} - P_{tot}\\right)\\\\\\dot{X} &= C_{2} ktl^{} - X kdil^{}\\\\\\dot{C_{2}} &= - C_{2} ktl^{} - C_{2} ku_{strong } - T kb^{} \\left(C_{2} - R_{tot}\\right)\\\\\\dot{C_{3}} &= - C_{3} kdeg^{rna}_{degradation mm} - C_{3} ku^{} - T kb^{} \\left(C_{3} - E_{tot}\\right)\\end{aligned}$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import Math, display\n", + "from autoreduce import solve_conservation_laws\n", + "from sympy import latex, simplify\n", + "\n", + "conserved_system = solve_conservation_laws(\n", + " system,\n", + " total_quantities={\n", + " \"G_tot\": TOTAL_DNA,\n", + " \"P_tot\": TOTAL_RNAP,\n", + " \"R_tot\": TOTAL_RIBOSOME,\n", + " \"E_tot\": TOTAL_RNAASE,\n", + " },\n", + " conserved_sets=conserved_sets,\n", + " states_to_eliminate=[G, P, R, E],\n", + ")\n", + "\n", + "print(\"States after conservation laws:\")\n", + "for state in conserved_system.x:\n", + " print(f\" {state}\")\n", + "\n", + "rows = []\n", + "for state, rhs in zip(conserved_system.x, conserved_system.f):\n", + " rows.append(rf\"\\dot{{{latex(state)}}} &= {latex(simplify(rhs))}\")\n", + "\n", + "display(Math(r\"\\begin{aligned}\" + r\"\\\\\".join(rows) + r\"\\end{aligned}\"))" + ] + }, + { + "cell_type": "markdown", + "id": "8501d9b1", + "metadata": {}, + "source": [ + "## Quasi-steady-state analysis\n", + "\n", + "We can apply time-scale separation using AutoReduce. Here, we may assume that the complexes $C_1$, $C_2$, and $C_3$ are fast states, that is, their production and degradation rates are much faster than those of the retained transcript and protein. We use the `solve_timescale_separation` method in AutoReduce to solve their steady-state equations and substitute back to get the reduced model." + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "a4575215", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Successful solution obtained with states: [T, X]!\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle \\begin{aligned}\\dot{T} &= \\frac{- E_{tot} T \\left(kb^{}\\right)^{2} kdeg^{rna}_{degradation mm} + \\frac{ktx_{strong } \\left(T kb^{} + kdeg^{rna}_{degradation mm} + ku^{}\\right) \\left(G_{tot} kb^{} + P_{tot} kb^{} + ktx_{strong } + ku_{strong } - \\sqrt{G_{tot}^{2} \\left(kb^{}\\right)^{2} - 2 G_{tot} P_{tot} \\left(kb^{}\\right)^{2} + 2 G_{tot} kb^{} ktx_{strong } + 2 G_{tot} kb^{} ku_{strong } + P_{tot}^{2} \\left(kb^{}\\right)^{2} + 2 P_{tot} kb^{} ktx_{strong } + 2 P_{tot} kb^{} ku_{strong } + ktx_{strong }^{2} + 2 ktx_{strong } ku_{strong } + ku_{strong }^{2}}\\right)}{2}}{kb^{} \\left(T kb^{} + kdeg^{rna}_{degradation mm} + ku^{}\\right)}\\\\\\dot{X} &= \\frac{R_{tot} T kb^{} ktl^{} - X kdil^{} \\left(T kb^{} + ktl^{} + ku_{strong }\\right)}{T kb^{} + ktl^{} + ku_{strong }}\\end{aligned}$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reduced model MAE for protein X: 44.47\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from IPython.display import Math, display\n", + "from autoreduce import solve_ode, solve_timescale_separation\n", + "from sympy import latex, simplify\n", + "\n", + "reduced_system, fast_subsystem = solve_timescale_separation(\n", + " conserved_system,\n", + " slow_states=[T, X],\n", + " fast_states=[C_1, C_2, C_3],\n", + " debug=False,\n", + ")\n", + "\n", + "reduced_system.f = [simplify(rhs) for rhs in reduced_system.f]\n", + "\n", + "rows = []\n", + "for state, rhs in zip(reduced_system.x, reduced_system.f):\n", + " rows.append(rf\"\\dot{{{latex(state)}}} &= {latex(rhs)}\")\n", + "\n", + "display(Math(r\"\\begin{aligned}\" + r\"\\\\\".join(rows) + r\"\\end{aligned}\"))\n", + "\n", + "reduced_solution = solve_ode(reduced_system, timepoints)\n", + "reduced_output = np.ravel(np.asarray(reduced_system.C) @ reduced_solution.T)\n", + "mae = np.mean(np.abs(output - reduced_output))\n", + "print(f\"Reduced model MAE for protein X: {mae:.4g}\")\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(timepoints, output, color=\"#1b1f23\", linestyle=\":\", linewidth=3.0, label=\"full model\")\n", + "ax.plot(timepoints, reduced_output, color=\"#009E73\", linewidth=2.4, label=\"QSS reduced model\")\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_ylabel(\"Protein $X$\")\n", + "ax.set_title(\"Reduced gene expression model\")\n", + "ax.legend(frameon=False)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "0a2b04c8", + "metadata": {}, + "source": [ + "## Is mRNA-protein the only reduced model? Let's explore:\n", + "\n", + "In AutoReduce, a method called `explore_all_QSS_models` is available to explore all possible reduced models of a system. Let's apply it to the gene expression model that we have built to see what we get." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "bae2cadf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[C_1*ktx_strong_ + C_2*ktl__ + C_2*ku_strong_ + C_3*ku__ - T*kb__*(-C_2 + R_tot) - T*kb__*(-C_3 + E_tot),\n", + " -C_1*ktx_strong_ - C_1*ku_strong_ + kb__*(-C_1 + G_tot)*(-C_1 + P_tot),\n", + " C_2*ktl__ - X*kdil__,\n", + " -C_2*ktl__ - C_2*ku_strong_ + T*kb__*(-C_2 + R_tot),\n", + " -C_3*kdeg__rna_degradation_mm - C_3*ku__ + T*kb__*(-C_3 + E_tot)]" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "conserved_system.f" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "bee613a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Successful solution obtained with states: [T, X]!\n", + "Successful solution obtained with states: [C_1, X]!\n", + "Successful solution obtained with states: [X, C_2]!\n", + "Successful solution obtained with states: [X, C_3]!\n", + "Successful solution obtained with states: [T, C_1, X]!\n", + "Successful solution obtained with states: [T, X, C_2]!\n", + "Successful solution obtained with states: [T, X, C_3]!\n", + "Successful solution obtained with states: [C_1, X, C_2]!\n", + "Successful solution obtained with states: [C_1, X, C_3]!\n", + "Successful solution obtained with states: [X, C_2, C_3]!\n", + "Successful solution obtained with states: [T, C_1, X, C_2]!\n", + "Successful solution obtained with states: [T, C_1, X, C_3]!\n", + "Successful solution obtained with states: [T, X, C_2, C_3]!\n", + "Successful solution obtained with states: [C_1, X, C_2, C_3]!\n" + ] + } + ], + "source": [ + "from autoreduce import explore_all_QSS_models\n", + "all_reduced_models = explore_all_QSS_models(conserved_system,\n", + " skip_numerical_computations=True,\n", + " nstates_tol_min = 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "6d7f27a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of reduced models found: 14\n" + ] + } + ], + "source": [ + "print(f\"Number of reduced models found: {len(all_reduced_models)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "d85a3b31", + "metadata": {}, + "source": [ + "### Are any of these reduced models any good?\n", + "\n", + "We explore some realistic parameter conditions below. " + ] + }, + { + "cell_type": "markdown", + "id": "27fe45e3", + "metadata": {}, + "source": [ + "## Limited RNAP resources\n", + "\n", + "Under limited RNAP, we assume that the TOTAL_RNAP is lower than the default value. Under this condition, let's see how the different reduced models perform. Now that we have the shortlisted reduced models, we simulate and plot them under this parameter condition." + ] + }, + { + "cell_type": "markdown", + "id": "ff08c292", + "metadata": {}, + "source": [ + "Currently, the total RNAP is set to:" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "297fe0cf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "TOTAL_RNAP" + ] + }, + { + "cell_type": "markdown", + "id": "2c2d07c8", + "metadata": {}, + "source": [ + "Under limited RNAP, we set" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "e2882438", + "metadata": {}, + "outputs": [], + "source": [ + "TOTAL_RNAP = 1.0" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "6cfe6158", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\ayush\\Box\\Research\\autoReduce_HPC\\autoreduce\\solvers\\ode.py:64: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", + " sol = odeint(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from autoreduce import get_error_metric\n", + "from sympy import latex\n", + "\n", + "default_parameters = conserved_system.params_dict.copy()\n", + "limited_rnap_parameters = {\n", + " **default_parameters,\n", + " P_tot: TOTAL_RNAP,\n", + "}\n", + "\n", + "conserved_system.set_param_dict(limited_rnap_parameters)\n", + "\n", + "limited_rnap_solution = solve_ode(conserved_system, timepoints)\n", + "limited_rnap_output = (conserved_system.C @ limited_rnap_solution.T)[0]\n", + "\n", + "fig, ax = plt.subplots(figsize=(8.5, 4.8))\n", + "ax.plot(\n", + " timepoints / 60,\n", + " limited_rnap_output,\n", + " color=\"#1b1f23\",\n", + " linewidth=2.8,\n", + " label=\"full model\",\n", + ")\n", + "\n", + "limited_rnap_errors = []\n", + "limited_rnap_labels = []\n", + "for reduced_model in all_reduced_models:\n", + " reduced_model.set_param_dict(limited_rnap_parameters)\n", + " reduced_error = get_error_metric(\n", + " conserved_system,\n", + " reduced_model,\n", + " timepoints_ode=timepoints,\n", + " )\n", + " reduced_label = \", \".join(rf\"${latex(state)}$\" for state in reduced_model.x)\n", + " limited_rnap_errors.append(reduced_error)\n", + " limited_rnap_labels.append(reduced_label)\n", + " if reduced_error > 5000:\n", + " continue\n", + " reduced_solution = solve_ode(reduced_model, timepoints)\n", + " reduced_output = (reduced_model.C @ reduced_solution.T)[0]\n", + " ax.plot(\n", + " timepoints / 60,\n", + " reduced_output,\n", + " linewidth=1.8,\n", + " label=reduced_label,\n", + " )\n", + "\n", + "ax.set_xlabel(\"Time (in minutes)\")\n", + "ax.set_ylabel(\"Protein $X$\")\n", + "ax.set_title(\"Limited RNAP\")\n", + "ax.legend(frameon=False)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "45c82a05", + "metadata": {}, + "source": [ + "## Unlimited resources\n", + "\n", + "Another possibility is that the resources are abundant. In this case, we can set the `TOTAL_RNAP`, `TOTAL_RIBOSOMES`, and `TOTAL_ENDONUCLEASES` to a high value. " + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "0d27830d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0UAAAHTCAYAAADoJ7PCAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAy4VJREFUeJzs3QdYU2cXB/A/O+ytsmQKinvvvfde1dZRrdqqba3W1X7WLmvde2+r1qp1b+veewICAjKUIXtlAN9zXiQShgKCgJzf86QlNzc3N8k1ybnnvOdVS0tLSwNjjDHGGGOMlVHqxb0DjDHGGGOMMVacOChijDHGGGOMlWkcFDHGGGOMMcbKNA6KGGOMMcYYY2UaB0WMMcYYY4yxMo2DIsYYY4wxxliZxkERY4wxxhhjrEzjoIgxxhhjjDFWpnFQxBhjjDHGGCvTOChijLEy4Ndff4Wamhp8fHxQEhkYGKBfv37FvRuMMcbKKA6KGGOslPPw8BABD12uXbtW3LtTos2fP1+8To8ePSruXWGMMVaCcFDEGGOl3IYNG6Curg5tbW3xN2OMMcbyh4MixhgrxeRyObZt24b27dujV69e+Pvvv5GQkFDcu8UYY4yVKhwUMcZYKXbo0CGEhYVh5MiR4hIXF4fdu3fnun5qaip+/vln2NnZQVdXFw0bNsTp06dV1hk7dqwoMVMoFNnuL5FIMGjQoBzHKi1cuBCOjo5inTp16mTbLqGytU6dOkFfXx8WFhbisXIK4ijY2759O9q0aQNLS0vo6emhQYMG+Oeff7Ktm9d9GDp0KKZMmSL+rl69urLk8Keffnrra5yxfW9vb8ydOxdOTk7Q1NRUbptKFnv06AEzMzPo6OigatWqWLZsGdLS0lS2c+XKFXTu3BkVKlQQz79mzZr4/fffER8fr7IePcfGjRuLdWisVbNmzcT7nBXt06hRo7It37x5s7jt3LlzymW2trZo164dnj9/jj59+sDU1BSVKlUSt9H7vHjxYvF60WOWL18evXv3xr1791S2S+vR60v7TceOsbExunXrlm29lJQUzJs3D9WqVRP7T8+3Y8eOOHXq1FtfZ8YYK1ZpjDHGSq0uXbqkmZmZpSUnJ6elpKSk2drapjVt2jTber/88gv9Qk/r16+f+H/mi6amZtrp06eV644ZM0Ysl8vl2bajo6OTNnDgwGzbHTp0aLbt0rpPnz5Vruvj45NmYmKSbb3OnTun6evrp/Xt21e57j///JNtvYzLli1bcnxu79qHIUOG5Li9WbNmvfU1ztj+gAEDVO534sSJtH379onXL6ftfv3118pt0D7o6enluN6iRYuU6y1cuDDX571mzRqV/aJln3/+ebb93bRpk7jt7NmzymU2NjZpDRo0SHNwcFBuz9HRMU2hUIhjKKfHc3NzU96fjq3u3bvnuB49r9u3byvXnTlzZq7PISkp6a2vNWOMFRfOFDHGWCkVEhKCEydO4JNPPhEZChpXNGzYMFy+fBleXl453ufo0aNi3NGrV68QFBSEGTNmiAzAxIkT32tfKJOxdetWsV3KXI0bNw5SqRSbNm1SrjNz5kxER0eLTBNlXWJjY8X97t+/ny1bRM9nzJgxuH79OmJiYhAZGYm9e/eK7NKPP/6YLQuTl32gzBNlMMjDhw/FNujyrkxRhiNHjojXLjw8XNyvSZMmIlNDWaz169fj5cuXSExMxNWrV1G3bl0sXboUnp6e4r4nT54Ut02fPh0vXrxAUlKSyJr973//g6GhoViHtku309gwui89B9omZac0NDTw3XffidevoG7cuCGyNjdv3hSvy7Nnz8R+0zFB2TV6fekxaT/2798vMkeZs0/0+rZq1UocX5TdioiIwOrVq8XxQ/uW4cCBA+J9OnPmjFiP3g/6m7JFlMFijLESqdjCMcYYY+/lt99+E2ffM5+lp2yMmppa2vfff59jtoPuk1W3bt3EbRkZlYJkilauXKmynlQqTZNIJGLbhDISBgYGaZUqVcq23YMHD4ptZM4U5YayKrQuPc/87gOZN2+eWPfhw4fvfKys2//9999Vlu/evVssX79+fbb7PHnyRNy2YMECcX3Xrl3i+p07d3J9HMqA0TrTp0/PdtuXX34pbqMMWkEzRfRahISEqKzbokWLNHV19Xe+Hm3atEkzMjJKS0hIyHbbxIkTxTZiY2PF9VatWqU1bNgwLTU19a3bZIyxkoQzRYwxVgrRb2LKgND4jsxn9J2dndG8eXNs2bIlxzFBNK4kt2WUOSgoeszMKNthbW2tHC9D2Qf6mzINNB4n6+NnzSDQuJRFixahfv36MDIyUo7/+fbbb5VZsvzuw/tq27ZttlbohLJFGfuXcXF3dxe3UTaO0BxMAwYMQMuWLUWmjMbmUMYmc8bLz89P/J8yKlnRWKT3fY+qVKkCKysrlWWUsXNxcRHjf96Gnitl9mjMUdbnSlktGqtGGbCMtuf0/tDYKnq/qBEIZbwYY6wk46CIMcZKofPnz4vGAlR6lvVH6oULFxAaGirKvQqCyvBI1hI1CrJyCrQINTbIivYlYxs5lbu9DZXzTZo0Cbdu3RLNI7Ki8q/87sP7okYKmeVluzKZTPyfyt+oMyAFQtQ44cmTJ+jfv78IHDIaFWRsL68lZrk9NyrNy8v+5/U55Pe5UukgHZvUvIGaMdDzpmD9888/z/X4YYyx4sZBEWOMlUIbN24s0Do5dYTLWEZd1Qh1eyP+/v7ZuqdRBqcgypUrJzqRUUe0rD+M6fEz/+imv2nfK1euLDq70TgaelxavmTJEryPjICvoM8jM1dXV/F/+tGfMT4p62X58uUq93Fzc8P48ePFWB5fX1+RzcroIJfx+tM4sawylmWsk/E+ZX2PyMWLF/P1HCiAoSDtXetRVzoKfHJ7rpmzTfS8OnToIMZrHT58WOw/vac0NokxxkoiDooYY6yUocYDe/bsgYODgyhbyukHKpXU0QD6rGVL1AKafpxGRUWJEidqfkA/WqncK6NFMwUjhEqfqIUzlZ/Rj9rhw4cXeJ8pU9K1a1dRrvXpp5+KgIAyQJTNorbcmdH+UxaEflhTEwJqZECNFv766y/Mnj0b74NaURN6Pjllm/KDng9lX6ihAzVgCA4OFkFDYGCgeF49e/bE3bt3xbrUBn3y5Mmi2QG9f9R0gQJEKq/LKJujEjlqMLFgwQKsXLlSNDKgxgd0fdWqVSKozFz+SO/T2bNnRRklvUf0ftLrs3Pnzjw/B2rSQccQtRSn5gr0mNQY4eDBg+K2DPSeUfaRWnBTJpICVXoOjx8/FhmhzG3aKRNG+0TvNb0edAzSMUYynitjjJU4xT2oiTHGWP6sWrVKDKT/9ddf37nOH3/8odIsgJoZvKslNzUooNbeWdfr379/ro0WvL29s+2Ds7NzWsuWLQvUknvQoEE5tnTOWH7q1KkC7YOXl5doRFGQltw5bZ+aRGhra+fagvrmzZtiPWrPnds648aNU26PGjPktSX33r17s61DDQ8yWo9nbbTQtm3bbPtPDTA6duyYp5bcOR07GZe6desq16VjJKd1tLS00m7duvXW15oxxooLZ4oYY6yUoawEZV5GjBiR6zp0lp8GxWctoaNMEbWBpgYElJWgCVGPHTum0kSAMjSU6aCmCDROh8q0vvnmGzFg/n3QuBIq7aKyKsr+UJaFxpnkNNkstXr+8ssvxX7SPtSuXVu0jKbsy/ugMrA1a9aI/2dt+FAQ3bt3F9kfypRQu2t67ezt7UXmhVpYZzTBoDIyaq5Ak+XSOBsTExMx9oYmeaVGBRloHBWV49F6NEEqvU7U+pvaXH/xxRcqj02TsFIzCno8etwaNWqI9XJqppEbOo5oP//8808xoS0dExmTt+7atUul7JDeJ3rtaN8yJpal+1AGLPN7SGWWVBJImUfano2NjdjXS5cuiefMGGMlkRpFRsW9E4wxxhhjjDFWXDhTxBhjjDHGGCvTOChijDHGGGOMlWkcFDHGGGOMMcbKNA6KGGOMMcYYY2UaB0WMMcYYY4yxMo2DIsYYY4wxxliZxkHRe6KO5rGxseL/jDHGGGOMsdKHg6L3FBcXJybio/8Xp9TUVERERIj/M8bHB+PPDsbfLYx/d7DikloKf5dyUMQYY4wxxhgr0zgoYowxxhhjjJVpHBQxxhhjjDHGyjQOihhjjDHGGGNlGgdFjDHGGGOMsTKNgyLGGGOMMcZYmcZBEWOMMcYYY6xM46CIMcYYY4wxVqZxUMQYY4wxxhgr0zgoYowxxhhjjJVpHBQxxhhjjDHGyjQOihhjjDHGGGNlGgdFjDHGGGOMsTKNgyKWL8HBwTh58iT279+P1NTUPN0nMTFRrB8ZGZnj9ZLk6tWruHPnTr7uU5KfD2OMMcYYezcOiliebd26FW5ubliwYAE2b96MlJSUPN0vLCwMvXv3xpMnT3K8XpLMnj0bS5cuzdd9SvLzYYwxxhhj76aZh3UYEyhY+OqrrzB37lx+RRhjjDHGGKJjInHvwS0E+PsjMjwKSfGpSEnWgbrUENVbGaNH9wGl4lXioIi9U0xMDM6ePQt/f3+RFaFSMRsbGzg6OuLSpUvo3LkzdHR0lOtfuXIFenp6qFWrVoFf3bi4OJw5cwatW7eGVCrF48ePIZFI0KBBA2hoaIiStZs3b4p169atCwMDgxz3+/bt21AoFKhduzYsLS2zrRMSEoL79+/DxMQE9erVy3V/aB9oW7TNatWqwc7OrsDPjTHGGGOstAgPD8X9R3cQGOCPqIgYJMWnIU0qgbrMCNoyM+jKjV+HFC7QBsQlQ+DzeygtOCgqBnUbNkVCQnyhbzctLQ1qamp5Wldf3wC3r1/O07o0VobK5RISEkQgEhUVhSZNmojrVDb24sULVKhQQbn+//73Pzg4OGD9+vUFfi4BAQFi2xRwUVmaq6ureGx7e3tMnz4dU6ZMQaVKlfD8+XMkJyfj3LlzcHZ2Vt5/7dq1+Pbbb0W5n7a2Nu7du4dp06bhp59+Uq6zePFiTJ06VQRvVAook8nE/zM/F3Lo0CGMGjUK+vr64vFpPyZOnIjff/+9wM+PMcYYY6wkiE+Iw737t+Dr64VXodEi6ElN1oOGzAg6MlNIFEYA6OS3m/jvm9PgOUtFKpK1oyHTikY5HS2UFhwUFQMKiOLjE1BaUEaIskO2trYYPnw4Jk+eLJZTIFLUNDU18fTpUxHYeHp6omrVqpgwYQJu3bqFihUriiwQZXjmzJmjDMIoiKIyPxr7RMEL2bt3L/r164emTZuiffv2IvNEz2PDhg0YNmyYWGfFihUYP3486tevr3x8Ly8v9O/fX6yzatUqqKuriwCrYcOGaNu2rbgwxhhjjJVkAYHPROATEhiM2KgkyBO1AKkhtKVm0JWZQh0aAFzzGPSkIEk7GnLtKKRpx0FXLQnlU9RhkaIJoxQJJKkSaKbpQjvNAjoG79paycFBESvRKKihgIhUrlwZVlZW6NWrlwiIMoKmZs2aidK2DNu3b0e5cuVEgJOhb9++osxu06ZNIijatm2byGZlBERk3LhxIrjKjIImyr5RgEUBEaHMEgVYFERxUMQYY4yx4paiUIgStydPHiL8ZQSS4mhcjy40pCaQSM2hk6IPwEJcsg84UJWqRkFP5OugJx6a2lJYQg3lU7RhJteGRK4NdbkWNBXG0FWzh46GXvodNV5fMonx90VpwUFRMaDStaKQ3/K50sDCgv4Bv0HjinJalpSUpLzu6+sLFxcXZRCTgUrp6Dbi5+cn1smM1s9cgkd8fHxEOd3p06dVllOZHWWwGGOMMcY+VODz1McDDx/dRUjQSyTGpCA1SQ8aUlPoSi2hlUpZGUdoi8vbSTUSkKzzCqna0VDXTYKBRA02qdqokCKBvlQTaQlpUJfpQjulPPTkxtBQ11KNHt4SQchSkpGsiIEsJQ56joYoLTgoKgZ5HcuTHzRnEI39MTMzyxYMFJWMx6FgLDMa41OcKGjy8PDItpzGQmUEVObm5qJxRE7rULlgBiMjI8THx4sxVVllLrNjjDHGGCusUre7d28g6Hkw4qJkUCTqiMBHIrWETgplZWyhBVtQe4O3l7hFQa4TiTSdOGjpyWFoJIE99FBBKoFmtByp8WnQSDKHjtwEuolGUFfL9PvxLVEV/e5LUsRCmhIDBRKhppsKbTNd6DtVgFntKjB0slP5XVpacFDECozGGBFvb29R1kYiIiLw4MEDUepWXFq0aIHVq1eLsUXu7u5iGXXNO3/+PGbNmqVcZ926dSJjlBEE0fo01qhOnTrKbXXt2hUHDx4UZXQUSGUWGhr6QZ8XY4wxxj4OcpkMt+9fh8fjRwh/GQ1ZvCbUkk0gSbZ83digHNRQDvTX2xoaJOlEQqb9CpDEQscwDeYWRnDWM0e5eA3IQ+KQEqMG9bhy0E40gl6MCTTUMv30f8twn5RUORJFticWqRrJUDdQh24FYxi62sGsfjXoGJeeDFBecVDECszJyQnNmzfHmDFjRDc46t5GwciHylTlZsCAAaLpQseOHfH999+LMUlLliwR+5vReIHWWb58Odq1aycaLtAZjXnz5sHQUPUfOY0dOnz4MBo3bozRo0eLsUyBgYEiUKLtz5w5s5ieJWOMMcZKutjYGFy9fgHPfH0RE5EIeYIuNJPNoCst97rczQ002ocuuUnUioJMJwJpkhho66fA1NIQDuVtYJ+oBbl/EmSv1KEWawmteEPoRZhCSz0j2ikPUNVbLg3gFKkyJMqjIEuNRZq2DJom2tCzs4BJDReYuFeChnbp6RxXGDgoYnnWqVMn0QY7s6NHj4pJXWlOIWtra5FRoYCBGh1koDmLevbsqcy0ZL2eEypbo3WMjVWTw9QkIWsWiuYNojE+GWhc1ZEjR7BlyxZcuHBB3EYBDV1o/BGhwO3EiROiWQLNwWRqaoq//vpLPA+asyjztmg7x48fF8ERdb2jBg3UkIE62eX1+TDGGGPs4xUUEogbNy4iMCAY8VEKpCUZQCvZAnpSC6iLkKcG3pZbkWkkIkkShhSdKGgZSGFsqgt7RwdUtbBHqmcS4v00oYg2hnqcLiQRptDzNn49jtwYoHPRujlvNyUtBUnyKEgp46OZDA0jTejZmcO0ViWY1Kws5n4sComJifDxfQYN/wDUr1cXpYFaWtYBISxfYmNjxQ93mtSTfsgXl+IYU8RKDz4+GB8bjD87GH+vvL/omEhcuXoevt6+iH0lR1qiIbSTy0NflrcTo5T1kUrCAUkMdI3SUM7aHDWq14J1sjai73kjMTBKjPXRTDOArqYZJJpvyyFlHuMTI5obpKgnQt1ADbpWxjCp5gizetWhqZd+QrgwKRQKhLx4gefPA/E8MBCBgUF4TpfnzxEYFISIiFdiPVsbG1y7fB6lAWeKGGOMMcYYyzLmh8rePDyeIDIsHinxetBMtoS+tBzU04yhjjp4U1eSvclBoiQCcp0IqOnGw8BUExXtbVGndkMYxljj1bVHSAxQR2qwOrSDjaB3PwZSdR3oory45DbWh7I+ifJI0eCAyt20LSQwcrNFueZ1oGNuWujvX1JSEgKeByIgIAABz58jIOA5/AOei7+DgoJFYPQuFDjJ5XJoaZX8UjwOihhjjDHGWJltc/3Y4z7u3L2JsJAoSGO1oZFsDv3kCtBMpRZs1XJtdkDBT4IkHHJJODT1E2BiqQeXSs5oWL8F1KMTEH7hDuJ8XiLFPxWafmlQXPZGoobem+AnlwSOPFWKRFkkZGmxUNNLgaSCIYyrOaFC4/qFmvWhDFN0dHR6oBOQHuxk/J+WFUZDKapUocDI/vX8kiUZB0WMMcYYY+yjR1OGXLp6Fl5PPBATLkVqggl0k6xed3tzfWvDg0TtSEgloVDXi4WhmRYcKzmhWeOW0IUWws7dRIxHIOTeUqh7ROHl0YvQ0zKGFoxhRmN+csn8SFOSkCiPgEItXpS86dmZwrSuG6xquRfqWJ+4uDj4+Qfg2TM/PPOji7/ovuvn54/YuDgUNjU1NVSoUB5WFSrA0dEhz3NoFjcOihhjjDHG2EclPDwU5y+ewvNnQUiMVod6kgX0kqxed3yrlescP1LNeCRJXiJNNwp6JoCtvTUaN2wGO7s2iHr0FOEX7yPxeSTgG42Xpy5AT8sM6mraMIFzrp3eFKlyJMgiIEMs1PVToWdvBvOGVWFVzbXQgh+pVCrG9qQHPv7pwc+z9MAnLDwchc3I0BD29hXFxc7WDhXtbGFnZ4uKdnawsbEW5XKlbaw7B0WMMcYYY6zU8vB8iBs3L+NlYBRkcRJoJZWHfnI5qMMaOuKSW+lbKBR6YdAxlKK8rTlq16mPalVaIUUuR/jFO4i66w3ptUREXbwEqZYnJJoGNPWpuOTU7S01LRUJYsxPFNIkcuhaGcCsjiusGjUqlPbWVO4WGhYGb28f+D57hmfP0oMfyvoEBgWLUrXCVL58eThQ4FMxPfjJ+D8to069b8sAFfa+fAgcFDHGGGOMsVITAF27dgmhQVFQxBlCJ9EaenJqMuAKg1zuI1dPRoJuCNL0XsHAVA2OLvZo3rwtzEwtkBweiZf/XUesZwgUd27icZoXDLQtoamuDSM4pv9SzuHXcpIiFonyV0jVShIND4yrVkT5FvUKZVJTmkqEOrhR8OPt4wsfH194+/jAx9cXcXHxKCyUzbG1tXkT7FR8HfzYVxQZH13dXPp8f6Q4KGKMMcYYYyWOr583Ll06ixeBEZDH6osAKL31tVuuc/4kacUgWTcE6vqxMCknEXMZNm7YDlra2kgMDsWLU9cQfz0Uz88cQKiGGfS1zKCpZgAzuOY49icj+5OcEgk1/RToO5rBsnlt2FZuXiglbzTWx8fHB0+9fV4HP7549uwZpDIZCguVszk5OsLJ0QGO4v+OcHJyEO2yNTU5FMhQ7K/EvXv3sHz5cvE31VXSBKDt2rVTToyZFU2iefLkSZGy69y5s1j3Q6zHGGOMMcaKbvLTc+dOIiQgFNJYPWgnWsFAagnABYZwyfE+CToRkOmGQMsoEeVtzVC3XiNUd28jbqMM0IsTVxF70h+P9gRAomEOAy1z6KiZQQdmOZa/KVJliJeFQ64WC01TdRhWsYVVm4bv3e5aJpPB95kfvLyewtPLC0+fesPb11fM8ZN58vn3YWZm+jrweR38OKX/7eBgD93XE9ezEh4UmZqaolGjRuJvOjAeP36M9u3bY9y4cViwYIHKupMnT8aGDRvw3XffiXX79u2LCRMm4Ndffy3S9RhjjDHGWOF1gTt34QQ8Hnki4ZUGNBMqwCC5AtTgCH1xyaX7m24INI3jYWVnhmZNW8HZKT0AkkbF4MXJK4j5+ybuxtyCjpopDLQtoKVmBHNqqJ1DAJSsiEeCPFyUv+mU14V5PVdYNX2/sT80jiYoOFgZ/Hh6PoXn06fw9X2Wpzl93oWyOo4O9nBxcUElF2c4vQ58qMObqUlusyaxvFJLo1FbJcyqVavw5ZdfinSis7OzWHb37l3UqVMHBw4cQI8ePcSy3bt3Y/DgwXj06BGqVKlSJOu9S2xsLIyNjRETEwMjo9w62Rc9+odY2rp8sA+Hjw/Gxwbjzw5WXN8rD5/cw7UrFxEeHI+0eDPoJdhCOzX38SrpJXDB0DSMQzlbYzRs1AxVq9QQt8njE/Dy1FVEPQhASlQqtNVMYahtAXW13Lu4SVMSkSALQ4p2InRtDWHZvCZMalZ+r85v9Nw9PL3g+ToAokDI66k3EhIS8L4kEokIelxcnFHJxUX839XFRYz1KQ2ToJbW3x3FninKCQUrhLppZARFf//9N8zNzdG9e3flen369IGenp4IZmbNmlUk67E3bt26hfnz54uLra2tcjl9AHz99deiTnXmzJkF+odz+vRp/Pfff3j58iUsLCxQo0YNDBw4EDo6uTT3Z4wxxliJExsbg5OnD8HPOxDSaAm0E2xfjwOqmmMbbJl6EhL1g6BmEAlLawPUb9AItWqmZ4DIqzuPEXbsLu6uvwrNFCMYaZeHhjoVwLnmOPmpLCUJ8RQAaSVAYq0Pi8bVYNWgSYEDILlcLkrfHj1+jCdPPNIDIU8vhEdE4H3RSfWM4Me1kgtcnNMzQDQGqLQEEh+TEhkUHT16VBwoGcERefjwocjeZG7/R2lENzc3cVtRrcfeoEDl4sWLoqxx0aJFyoCGsms3b97E9evX8/1y0WBCCn7CwsIwbNgwtGzZUmQIJ02ahGnTpiEgIKDUnBVhjDHGyho/fx+cPXcSoc/jgHgLGCTYQTPNGnqgi6o0pCJe8hIKg5cwMEtFleqV0bJ5B5EZIdJXUQg+ehH3/l4LJGhBX7McdLWMYAh7GOYwB5A8VYp4aSgUmvHQqaALi4ZVYNW04AEQneSloIcCoMdPPPD48RORAXrfpgf6+vpwc62EypXdUNnNTfztWqkSLCzMS83EpmVBiQmK5s2bBw8PD3h5eYlStBMnToiUWwZKwVEGISvqk063FdV6OXUKoUvm8rmM4KA4e7LTY1MlZFHuAwWN3377LX766SfMmDFDZNro+pkzZ0SWh7JH+Xn80NBQEQRVrVpV3J8+NDKMGTMGn376qfhgK4297kuaD3F8sNKJjw3GxwfLqxSFAldvXMDd23cRFw5oxlvDMNkKgDtyGtGSpBmLZP1AaBrFwcbeEi1btoetTXoWiMZyR1y6A5+FOyELl0MHVAZnKcrhLGCabRxQaloK4mThkCIK2pZaMKvvCtvmzXMcA5SX7zqa0JQyP48eP8ETDwqAPOAfECC+KwuKTuI6OzmJoMfNzVVcKru5ii5vOQU/9FglcBTLR/fdktesW4kJitzd3cWYHEtLS2zevFl0pKtbt66yVSA9oZwOHHqxM58RKOz1spozZw5mz56dbXlUVFShDKIrKNrvuLg48ZyKMuXar18//P777/jzzz/Fe0Xv08aNG0WZ49uCyZyMGjVKvGYrVqzIFmxSGSMdB/ndJive44OVPnxsMD4+WG4SE+Jx+epZPH8WAlmsAXQTKkJXbgxN1KWwRfWzhLJAuiFQ6L+AkSXgXq0GalRtBA3NZuJ2RWISIs/cxF3Po1BP1IWhthUkmvowoc5yOVTKJynikCALRYpuEiTOFjBtVQflzaqprBMTH/fON4++90JCXuCxh4coe/N6SmOAnuLVq/f7fWFtbYVKzpnG/Tg75Trmh34jljWpJeh3R05JkBIdFHXt2lX592effSb6yrdu3RojR45UzqobHByc7X4RERGirCtDYa+X1fTp00VpV+ZMkZ2dneiiV9yNFugsBO1HUR58lL2jDn0LFy5EUlIS5s6dKzI6+UUlilQmSQEWjUXK7bFY6To+WOnDxwbj44NlHg90/OQB+D8NgSLGFAYJDtBKtYcB7LO9SHJ1KRL0nkPNKBJW9iZo07oT7GzfjAVKeB6CkH3nkegXDU2ZAQx1rGCkbgkjWCJrXV1KqhxxslDINWKhY6WLci1rw7puzlOzvA39AH/5MhQPHj7Eg4ePcP9B+v+jo6ML/CbT2OYqld1Q1d0d7u5V4F6lssgEGRjkNlUsK63fLSUmKMqaNaJMgbe3t3JZ/fr1RUkdZRMyBt/Hx8fD09NTGTgVxXpZ0bo5Df6nN7y433Q6+D7EfrRp0wY///yzCGSprXlBUNe/jAA4L/sbGBiI27dvw8nJ6a1BKyv+44OVPnxsMD4+yqbIqAgcP3EQAd4vkRprDoMEe2imVoQhKmZbN0krGkn6gZCYJsLV3QltW3dBcrJU2V0s4sZ9eOzcBtlLKXRgLkrh9NWsoa9hna0UTmSB5KFQM1LAuIYdbDo1hZZhbtOx5i4i4hXuUwD04CHuP3iABw8eibK4gqIf8NWquqMqXdyriAu1vOYJTsvGd0uxB0U0cSrNU5Q5y7Jr1y4kJiaqTOA6ZMgQUba2cuVKMY6FLFu2TKQpBw0aVGTrFZXZhx7jSUj6eKTCQh1S8tqUwN3aCLO6V833Y4SEhGDo0KGiEQZ1o6O5BjIGSOYHzUdF77mNjc0716UAbMuWLahevbpo5kAdA9euXZvvx2SMMcbKsojIMBw7dgBBzyKQGvM6CEpzgBEcsq0brxMGuWEgjMoB9erXR8P6PaDxekgDjQcKv3QLIWfuITBGA/qaFaCnZQxjOGUrhaPsTbwsAsmIgFY5bZRrUQNWjfLfDCE6JgYPX2d/0jNADxEcHFLg18K+op04CU+BDwVClAWyqlCBGx+UYcUeFFG5GmVt7O3tUa5cOZEdooYL9EO4W7duyvUqVqyI9evXiwH4NLCf0nLnz58X404qVKhQZOsVFQqIrvuVrvEylEmj94Tep1OnTomMDY0nojml8ouCKQqs8oIe5+nTp+IDlFp203tHLdPzElAxxhhjZbkc7sixffB/+hKpMRYwTLCHRpozjJA+3UlmcaIrXBBMrTTRtFlzlbbYFASFnbuJiMuPkPJKDfpaFaCraYRycM+WBaJSuFjZSyg046DvaAKrzk1g59Qi3yd5ae6fO3fvKS9+fv4FzlZQ84MaNaqhRrVqqFatKqpUrgxj4+Ib8sBKphIxeStlhSgDQFkIKysr0WAhtx/ML168wIULF8RBTp3LaGzQh1ivsCdvLW2ZIvpA7NmzJ+7fv48bN26I94nKDM+ePSsC2fymlqdOnSrmO6KgmNLVWT148CDHMjkarGhtbS061xXnGK7SpjROosY+DD42GB8fHw+5TIYTZw7jyX0vyCKNYBDvBK3UnOf7i5O8gMIwGGbWWmjesjWqu9dS+c4PPXMVEVc8kRql/joIyrm8TZaSjDhZCNL0pTCpbgubbs3zXQoXGhaGO3cyAqC7IhNEJ08LmgGqUb06atasgRrVq6F6taowLEBpHit73y0lIigqzQoaFJW2g2/8+PHYunUrLl26pAxWKHtDcz1RaRuV1GW4e/euaMBA5Yk071NOaC4i2k7fvn2xbt06ZQkePQcqZ6xVq5ayrDHzc6TSRldXV/z666+F/hw/ZqXxw4l9GHxsMD4+Srcr18/j+uVriA/XgV6cIySKnAOAWN0QpBgEw9xGB61atUWVytWVt4n22BduIvT8I6RGacBAK70zXE5octRYWQhgIIOOewU492kPbd0s6aK3oLHc1Ab77t17uH3nLu7cu1fgMjgrqwoiAKpVs7r4PwVBOZ1oZR9eain83VHs5XOs5KNOc6tXr8ahQ4dUsjcUnPTp0wd//PGHGKOV0YOfmiL8/fff2YKazFxcXMT2KNtE3edq164tPigpY9i+fXv06tVLZX36wB4xYoRoq/jLL78U4bNljDHGSi4v78c4c+oEIkNSoB1nD32pBbRRH1n7tSZqR0Jq6A8TKzW0bNMW1d3flMORqIdeCDlyDbKXcuhrpI8JMoNbtnI4aUqiyARRUwTzBi6w79hazA2U8aNXM4fmU5nROrdu38GNW7dx8+YtPHz0CDKZPN/P29zcDDVr1EDNGtXFhYKgcuUs870dxnLDQRF7K5pHiFqOU5lc8+bNs92+YMECXLlyRYw3ykhPP3r0CA4ODqhXr95bt922bVv4+vrizp07CAoKEgEPDXrM2k+eygI/+eQTMZaJ5kXi2Z8ZY4yVFYmJCTh0dC98nwQB0VYwSrSDGmplmydIqpGARMNn0LNIQr2G9dC0cS9lYwSSEPQCgfvOIck/FpI0SxjqWKY3RsjSK0mqSECc/AXUjBUwb+QKh3ZtcpwgNSdUfBTw/Dlu3ryNG7duif/7+Prm+znTUABqgV2ndq30S51asLO15e9/VqS4fO49lZXyufzo0qULOnXqhIkTJxbK9iggosDphx9+UC6j7ed1Mi5Wso4PVrLwscH4+Ch5bt+7hotnLyAuVBv6cS7QSdHLftJSXYY4fT9omUajcg1ndOnQC1ra2srbpTFxCNp3BrFPQqElN4aRjhXU1bJ//itSZYiRBgMGyTBvVAlWHZvlKQiiz46wsDC8eBmK2yITdAu3bt0pUEtsKoOrW6f26yCotmiJrVuAzras5Egthb87OFPECh11o6OJdwsLNVagf1DHjx9XLmvcuDEHRYwxxj4K0TGROHRoL557R0A91g5GSdbQQr1sJXGxuoFIMwmBnYsFunfrCxPjTiq3h56/jpdnHgAxOjDWsYGOujksNcyBTN2vU9NSECMNgUI7DsbVrWDXqzUc8tiIgMrc7967j2vXb+DqteuiMQJN5J4fOtraqFGjOuq8DoJq16oJayurfG2DsaLAmaL3xJkiVhqUxjM27MPgY4Px8VE8rlw9h6uXriEx3ACG8c45domTasYjwdAXRhUUaNOuLapXraNye2JwKJ7v/Q9JfnHQU68Afa2cmwzESkMhVX8FfWdT2PVuDV2rvI3FoclZ7967JwIgCoSoMQIFRvlBjQ8a1KuL+vXroX7dOqIlts47xiGx0i+1FP7u4EwRY4wxxlgRoxbT+w/uwrMnL6AeXRGGyVaQoIHKkJ5UpCJOPwBqJqFwq+6ALp36qEyQTk2HQg6dw6vrPtBINICRxAYGarYwyBJjJCniEK8IgY6NNqy7N4Vt5eZ53EepaIlNQRBdqEOcVCbL1/O0t6+IBvXqoX79uuL/zs5OPBaIlQocFDHGGGOMFYGAwGc4cmg/XgUB+rEu0FFUhDEqqqyTpBWDJCNfmNuoo0unLnB2aqdye4y3H4L2XYDshRyGmjaQaBrAIsukqSlpCsQkByNVPxEWzdzg1LGjmPA8L0HQ7Tt33gRB9+7lqzMcPUZV9ypoQFkgkQmqyx3hWKnFQRFjjDHGWCG5eOUMrl28AVmEKYzinaGeVktlbFAaUhGr/xzqZqGoVscNndv3UOkSR9mglycvI/yCBzSSjGCsYw1jtexd4uJlkUhKC4WesxHs+7eDffnWeSppevzkCS5euoJLly/jxs3b+ZoklbrCUTvsxo0aomGDBnBytIetrW2pKY9i7G04KGKMMcYYKyAKKv49sBPPnoRCI4bK4ipADw2RuV+cXF2KeENvGFglo22HDqjurpoNkkbFIGDXSSQ8jYK+uhX0tEzSs0GZAiF5qhSx0mComcpRoV0tVG7WM08tsv0DAnD58lVcvHwZl69cQ3R0dL6CIGqE0KhhAxEIUYc4PT09lTEjjH0sOChijDHGGMtnt7i9e3fihW8SdGMqQaKwhwnss0+eauwLGxcj9O41ECbGnVVuj7zvgeCDV5AaoQFjHTvRKEFPp4LKOvGyV0hSC4Vh1XIiG6SVhy5x4eERuHzldRB0+SqCgoPz/Ly0tSkIqoVGjRqiccMGIgjS1c0ymytjHykOihhjjDHG3iHkZRD2//sPIp8D+jGu0E6tojKBauayuJr1KqND217ZyuKC9p9B5HU/aMtMYSyxgilcVcYGUbvs6OQgpBkmokLbGqjcutc73xfqBnfj5i2cO38B5y9egqenV77GBFEmqGnTJmjSqKFok83zA7GyioMixhhjjLEcePt44MjhQ4h/oQfD2ErQTKupEgilqCkQa/gUBtaJaN+xE6pWUS2LUyQmw3/nUcQ9ioCBug10tYxgqa5aFidNSUSsPBA6dhJU7N8GFSu2eud74efvL4Kgc+cv4srVa/maK8jNtRKaNW2K5s2aoGGD+jDM4xxFjH3sOChijDHGGHvtzr0b+O/UGUjDzGAU5yQmUc0cCMnVkxFn/BTmdqno06s/bK07qLx2yeGR8P/rGJL8k2CkVRESDUtIdFTnBYqVhkGqEQGTOraw79sOmu+YtychIUF0hzsrAqELCAh4nuf3y8qqApo3bYpmzZqgaZPGKF+uHL/XjOWAgyKWJ5cuXUJQUNBb13F1dUWdOqoTy+WGtkXb7Nq1a7azVCdPnhRfAL179y7Qu6NQKHDnzh28ePFCTBpXpUoVWFrmbaI6xhhjZc/tu1dx5sQ5KMLLwzjBAbpomLmqTUyimmj8FBWcJRjcexDMTLuo3D/ONwABu89C8RIw0bGDgXpFGGTKBqWmpSI6ORBpxkmw6dYAtg2av7NBgqfX09fZoAu4eetWnltlGxsZoUmTxmjWtLEIhhwdHXieIMbygIMilieHDx+Gv7+/MujYu3cvateuLQKhDJ9++mmeX00DAwOMGTMG06ZNw/Tp05XLN2/ejJEjR2Lbtm35fmeoXnvBggX4448/YGVlBRcXF7HPjx8/xqBBg7Bu3ToeMMoYY0x48PA2Thw7BVmoBUwSnKCPhiqvTKJWFKQmPnCoYoE+vQZBT6+Hyu2v7jxG0P4rUIvRhYnEDiZqzirjgxSpcsRIn0OjfBrsB7ZBReeWb33lqQTu0uUrOH3mLM6cPYuXL0Pz9E5RO+xaNWugVcsW4kIts/MyRxFjTJVaGp2OYAUWGxsLY2NjxMTEwMjIqNheyYzWmGZmZkU+X8DDhw9Ro0YN7N+/Hz17vrslaG4oINq0aZMIXKi7zdmzZ9GxY0fMnDkTs2bNyte26DAeMmQITp06hR07dqB9+/bK22g/KdAKCwuDZqZBr2XJhzw+WOnCxwYrS8eHh+dDHD18BMkvzWAc7wQ1qD6neJ1wpJg+Q5VaDujRrb9KowQSceM+gg5ch2aCMUwk1tm2L0tJQozsOXQddeEwpDMklplnKMou5MUL/PffOZw6858IiKhpQl5QCVx6ENQczZo1hamJCT60j+3YYIWrNB4fZfMXInsv9+7dE/+vVavWe23n22+/xZIlS7Bx40a0a9cOffv2xcCBA/MdEJHFixdj9+7duHDhApo0aaJyW69evWBjY1NmAyLGGCvLfJ954tCBA4gPMYJxnAskaKAyD2qC9ivITX1RrZ4junXum2MgFHzgOjReB0IWqKLSKCFJEYv4lGAYVDWHw6BOcDJQHWOU9Yfi/QcPcfq/szh9+gweP/HI83xB9evVVWaDqlR245I4xgoZ/0pkBQqKaKyOvb3qnAz5Vb58eYwYMQJ//vknFi1ahOrVq2PDhg353k5cXBx+/vlnUSKXNSDKUL9+/ffaV8YYY6VHQOAz7N+3F3HBejCOc4VWWn2VZglUGicz9YFrLRv06TEoeyB08wGC91+DRoIRTCQ2MM8SCCXIIpGo/hKmDe3h1KfTW8vVaIzsxUtXcOrMGZEVCo+IyNNzsLO1RetW6UFQk8aNRNk5Y6zocFDEChQU1axZs1BeuYkTJ2LVqlVwdnbGv//+C21t7Xxvg8rjaIbu0aNH5/k+crlcnHljjDH2cYiNjcHfu7fhpU8KjGIqQzOtrkoglKQZi2RTLzhXK4cveg+BVpbvm4jbDxH871VoxOcWCEUhUf0FLJo6w6VHt7cGQjSB6olTp3H8xElcuXo1T00SqMSIskFt27RG+3Zt4OLszNkgxj4gDoqKy7FpwMuHhbY5NaTBWK6Amha9pWrvvkOF6kDnPwr0WPfv389XU4W3jQOaPXu2+Ju+XEwKWBN9/fp18cXRoEGDd6575coVTJo0SQR25ubmoilDYTwXxhhjH14KNf45sBNP772AXlRl6CjckXkUT7JmHJJMvGBfxRSf9/0UEonqZKiR9z0QuOciNOIMYSKxzR4IyaOQqPYC5k2c4NKz61sDoYDnz0UQdPzEKdy6fUd8x72LkaEhWrdqibZtW6N1yxaiCoMxVjw4KCouFBAFXCq0zVEY9CHyHoGBgXj16tV7jyci1FDhwIEDWLt2Lb744gvs27cP/fr1y/d2aH9oIB81a3gXerylS5eKcrr//vsPXbp0EU0ZKlSoUMBnwRhj7EM7d/Ekrp67DfUIJxhIbWAKG+VtcnUp4kw8YOumi2H9hsJAX7UhUPzzEPhtPY60cG2YSirCXC1rIBSNRLUQmDV2hEuv3AMhCno8PDxx7HUg5OHpmad9d3JyRLs2rdGubRuRGeKqBcZKBg6KigtlagpRGtKgkCugqaUJtbxmioqxyQKNHZo7d65ojkANFihYmTNnToGCIgpooqKikJycDIkk8/DZdPHx8cpabHrMDG3atIG+vr4oveOgiDHGSjYv78c4tP8gZC/T5xIyytRCOxWpiDH0hnHFBAzoPwjWFTqr3FcaE4dnGw9A6i+HqY4DTNUrqbTPTpRHIwEhMGvkCJc+XXINhGjqh9t37oqM0ImTpxDwPPCd+03batigPtq1bY12bdqIoIgxVvJwUFRcCli6lpu01FTEvG59qFaErQ8pKKJxP+7u7jne7u3tjdu3b4tW3bllbk6fPo2xY8eK0jUKiMiMGTPQtGlTMXFrhw5vOvdERESI9Vu0aAFr6+ztTwkFUtR9jsYmUUe7zI4dOyb254cffsh2P2oHThO7urm55es1YIwx9mFERkVg186tiAzQhnGsG3TTVCdVjdULhEa5EHTu3hHVq45TuW+KTA6/7UcQ9yAcxlr2MNSwh2GmOycrEhCX8hymDe3g3D/3QIjm5rty9RqOHD2Ok6dO56lRAp2gowYJnTq2FxkhE2Pjgr8IjLEPgoMilu+giAKi3NL9J06cwIQJE0SZna2tbbbbHz16JIIY6jo3ZcoU5XLqGkeBD2WLMgdFnp6eGDx4MA4dOpRrUETB1E8//YTJkyfjzp07aNasmfgSo4Do/PnzIhuVFTV1oECKgjAaj8QYY6zkOHB4Nx5e94NeZFXopNRS7RynHQm5uTfqN6uG9m2HZcvkhBw6h4iLPjBQs4WupjkkEnPl7fJUKaKl/tCvbAynYd2hqZe9uoDQd8i16zdw6PBRHD1+QlQjvIuxkRHatWuDzh07omWLZjxZOGOlDAdFLF+cnJzQqlWrXG8PDg6GnZ1djuVoVH+9bds2DBs2DAsWLMh2+2+//YYVK1YgNDRUtOvO2B4FYO8q16O5jXr06IG9e/fi8uXLookCzU/0119/icl1M6PJXSlLRQERl80xxljJ4O3jgf37DkDxwhpGSbYwhYXyNplGIhJMPOFU3Qxf9BmavXPczQcI2nsVOrJyMNS2gKXWm2qG1LQURCUHQMtWDU7Du8HRsl2Oj08BFQVCh48cw9Hjx/HqVeQ795m+qzp1aIdOHTugUcMGPD6IsVJMLS0v7VFYrmJjY8WP7piYGBgZGaGszxzcvHlz9O7dW3R4KwyUdaLXduvWrYWyvc2bN4vg6/Dhw8rAi8YbfewTu5aU44OVPHxssOI8Pmgs6M6/NyHYQwqjGHdopL35LE5DKqINvWHqmITBgz+DmamF6n3DI+G74RBSXmiIhglZs/5RyYFIM0mE/ZC2MK7kmGsgdOPmLRw+chRHjh1HRMSrd+4zjQnq1KG9CIRq1axRZj9T+bODfWzHx8f9S5B9cJUqVcrXfEHvQhkfGn9UWKjBQ3h4OBo2fDNAl5o8tGzZstAegzHG2NtdunIWF05fg1a4K/TkbirlcQnaEUgt54O2nVuhft0s44RSUvD87+OIvhECEy0HGGs4qTRMiJOGQyoJh02Phqje+JNcf6zdvHUbh44cxdGjxxEWHv7Ot8u1kgu6de2Crl06wbVSJS67ZuwjxJmi98SZIlYalMYzNuzD4GODfajjIzw8FLt2bkPsc0OYxFdSuU2hLkOsyRM4VjPGwH6f5jixatA/VyCRlYeB9psxQkSakohYRQAsWjjBukfrHBsmUFHMo8ePse/fAzh4+Kgo034XZycndO/WRVzcXF0L/Lw/VvzZwT6244MzRYwxxhgrMsdPHsCti57Qj6wK7ZQ6yDxNd4yePyQ24eg7oD/s7Tqp3E/6Kgo+6w8iJUQdphJ7WKi5A69jpdS0VEQl+0PbQQMuo3pCy7BjrhOq7j9wCP/uPwgfX9937qujowN6dOsqskKV3Vw5I8RYGcJBEWOMMcYKVURkGP7atgUJz81gnOAIU9RX3pasGYdkcw/Ua1YVHduPzFYeF/jPSURdD4KxZs7lcTK9CFQc3AoVq+Vc9kxnp6k0jrJCNKfQuzg42KN71y7iUqVKZQ6EGCujOChijDHGWKE4ffYYrp99AN1X7tBJqQvjLE0TLFykGD14BIyMeqrcL84/CM82HoNWnBmMdMrBUqey8jZpShJiFf4wa+YA1149cyyPS0pKwomTp/HvgYM4f+GiaKn9NhXt7NJL47p2QdWq7hwIMcY4KGKMMcZYwUXHRGL7tk2I8TeCSbwzTFSyQrGQWnqgVYfGaNI4t6YJL2Cq7QRz9cqATubyuABo26vD6fOe0DF+M39dBgp8Ll2+gn37D+D4iVNITEx8636amZmie7eu6NOzB+rUqc2BEGNMBWeKGGOMMZZv125exJkjlyCJcIdEUVtlrFC04VOYOiVh9JCRMDLqpXK/uGeBeLbpOLQTzGGobQlLyZvpLBLl0UjUCoHd4OaoWCvn8rin3t7YvWcf9u3b/87OcRKJBB07tEefXj3QonkznkeIMZYrDooYY4wxlicpCgW279yIwEdSGMdUgQneTG8g1YxHkvkTNG1XB62aj82WFQrYcRQxt0JhpvM6K6RsmpCCyGQ/6LkbwHlEL2hoa2V73OiYGBw8eBh/79mL+/cfvHUfqbyuebOm6N2rh5hPSF9fn99dxtg7cVDEGGOMsbcKCgnC7p1/QRFsD8NkF5V5haL1n8HIIRrDhw6HmWkPlfvFevvDb8tJaCdawlDbApa6b/JJCfIoJGm/gP2QVqhYvVW2x6RA6sLFS/hnzz6cOHkKUpnsrftYq2ZNEQhR9zhLS9WJXhlj7F04KGKMMcZYjs6co8YJj6D/qhp0U99khRRqMsSZPUKNxvb4qtuobPfz330cUZeDYKbjDHP1KsqsUEpaCqKS/aBfzRAuw3rmmBXy9X2G3Xv2Ys++/e+cT8i+oh369umNXj17wMnRgd9FxliBcVDE3ntyrqKalEsmk4mBsFpa2b80k5OToampKS4ldf8ZY6w0kstk2Lx1LUK9NGEa56rSTjtBOwKw8kHfgX3g7JRlXqGoGHiv2ge1MH0YS6xgqev25n6ySCRLXsL+07awr5I9KxQbG4dDR45g9z9739lGW09PT3SNG9C/LxrUr8cNExhjhYKDIpZvR48exYoVK3DlyhXExcWhfPnyaNSoEb7//ns0bPjmTOL7+vLLL3Hu3Dl4eXmptGD95ptvsG7dOnFb/fpvvqzzGgRt2LABmzdvxv3790XgZWtri/bt22Pq1KlwcnIqtP1njLHSJORlEHZs24aUIEcYSN1VSuSiDL1QoXIKPh8ySjQvyCzi2n0E7rkGIzUHmGi4AJI3HeQik5/BoKYJXIZ2y5YVSktLw63bd/DXjl04fPSYONn1No0aNsDA/v3QpXNHHifEGCt0HBSxPKMvsK+//hrr16/Hr7/+io0bN8LCwgJ37twRgcrYsWNx9+67J8rLKwpSNm3ahH/++QeDBg0SyygYW7ZsGfbs2ZPvgIjatfbo0UMEWXPnzkW3bt3El/vp06dFAEYBEwVbjDFWlty4dRmnDl2EXkQ16Ka8ObElU09CgsUj1G5cCeM6jlHJqtN4n2eb9iPxYRxMJY6w1HRX3pasiEec+nNUHNQMFeu0zLFpwt59+7Fj5y54PfV+677Z2tigX9/e6N+vD+wrViy058wYY1lxUMTybN68eVi1ahX+++8/NG/eXLmcgpOzZ89i9erVhfpqVqpUCf369cMff/whgqJjx46JoIwCmt69e+d7eyNGjMDDhw9x+/ZtkR3K0KVLF5H1oswTY4yVFf/s2w6vGxEwjq4KEzRQKZFTs/HFoCGDYWPdGZGRkW9uC3oBn7WHoRNvAQPtctDVLae8LTo5CGrWMriO6wMtQ8NsJ9Vu3rqNv3buwuEjxyCVSnPdLzpZRdkgygo1btSQS5wZYx+EWhp9UrECi42NhbGxMWJiYmBk9GauhQ+Nshz0xWVmZlYkXyAhISGitIwyKgsXLsSHcu/ePdSuXVsERr/99hsGDx6MNWvW5Hs7J06cQKdOnfDXX3/hk08+QVlT1McHK7342ChbEhMTsGnzGsT4mMA4UbUxQbSBL8wrJWL4sDHKErmM4yP5lgfCT3jARMsJWuo6bxoupMoRJfOFRUtH2PVul+3xoqKjlVmhp94+b923enXriHFCNF7IMEtQxUoe/uxgH9vxUeyZIhrTsWvXLlEi9ezZM1hbW2PgwIHirH7mcSS+vr5o27ZttvtTxmDRokXZApWff/4ZJ0+eFAMwO3fujB9//DFbDXJe12PA2rVrxXv11VdffdCXo1atWuJ9mTZtGjp06CDK5wqCSu5o7FP//v0LfR8ZY6w0jBf6a8s2ILgS9GS1YPx6eYqaAjGm1EXOBl91H61yHyqR81m7F8meUpjrOsBSp4pqO22dl3Ae3REOzm1U7kfnWm/cvCWyQkcoK/SWVtp0UrFfn974ZPAAuLm6FvKzZoyxUhQUUTkUBUS///47mjZtKsan0DIqZ6IxKxnkcjkCAgJw5MgRuLu/qV02MDDI9mHcvXt30QCAfsjThzqNdaHtUvCT3/WKytwbc+EZ6Vmo26TXKKdObTmpbFYZUxtMzfO2z5w5g8qVK8PZ2fmd61KgSSV2ZObMmaKJQUElJCQoW7LSuKWCdJujsxVU3te3b988vT50DFDw9erVK7Rr1w7jxo1TCdAZY6y0ePjkHg7tOQZJaDXopahOtJpc7jG69GyHWjUnqdxH+ioKT1fshWa0OQy1raCv++a2V0l+kFTShvPo3tDUeZMxyhgrtGfPPhEMefv4vnW/Gjaoj08GD0SXzp2gm6VxA2OMlcmgyMbGBrdu3YKDQ3oav2rVquLH6KRJkzBnzhxxdj8zyiRlrJuTw4cP48KFC2LsSLVq1cQyCq4aNGggBtTTj9z8rFdUKCC6FXoLpUVgYKB4b/KCxgG1aNFCdKN71xwT7wpmqFwuLCxMZIwoI0hZo/yi9C01WXB0dHznuk+ePBFB0JgxY0Q5JGUOw8PDMXv27AI+C8YY+/DOXTyJSyfuwfBVTRinvQmG4nXCoGXnj0+HjYClpepEq5H3PRCw/QKM4ABTDTfl3EKKVBki5T6w6VETNVt/lu2xnnh4YsvW7di3/wCSkpJy3ScTExP070tZoYGo5OJSmE+XMcZKf1BEmQQqXcsaKFEmh8rbsgZFeWkXTUFTRqCT0QiAtkO3ZQQ7eV2vqFCmprDlN1OUH1Rf/rYvu8wok0cXqiN9H5QZogzPpUuXRJawZ8+eIoCuV69evraTURufl/2nwImylBmZIRoMTC28GWOsNNizbzs8r0fCJIZaar/5rIzRC4CZWwy+HjY2W0vtwP1nEHHWD2YSF1hqvKnESJTHIFE7GOaDm6BWzdYq4wLo++bEyVPYtGUbrt+4+c6s0JBPBqFLp06QSFSzS4wxVlIUe1CUNSAiNBieflDnVKr12WefibEt9vb24kcyndHPXNrk7e2d4/1oGd2W3/Wyoh/JmbvmUOCWkdWgS15NqTcFhYkeOyoqCqampnke0Jaf/aXMz99//y2yNtSGOzOa74cyQjTmJzMKbHN6Xd42KWuGpUuXYuXKldi/fz+qV68ugle6UPaQyi0zoy9neixt7denNXOY6K9OnTqiLJLKNLO+Pnv37hXNHKiRhM7rcpCMfaasIZV15ue1Kolo/zPeD8b42Pi4pCgU2LJtLUI9dGAS7wxTWCtvizJ6Aqc6eviiz1BovC4/ps+BFJkcvuv/hdw7Baa6FVUmWo1ODgGsk1FpbF9o6EnEd0vGZ0dYeDh27tqN7Tt2IjQ07J1ZocGDBsAl03ctfwZ9PPh7hZWW4yOvv4uLPSjKiubAOXDggOgwlvVJ9OnTB1988YUooaOz+TNmzBDrHj9+XBlcZUwmmhU1T6DbMuR1vazoR3lOpVT0paFQKFBc6KCj/aYDsCi6fFCDBQpQunbtiv/9739ifBGVpVFAQU0MKLuWuW1rRrBCY4KyLqeMHAU4NAdRTuj9/O6778RrTZPCZtyf9oEuN27cgEum0gsKlCmQvXr1aq77T/s8YMAAcZk4cSLs7Ozg7+8vJnGlOY/o76z7SXMWeXp64pdffsl2W2lT1McHK7342Ci9pNJk7N27Awl+FWCU5A4TleYJD1CjUUUMbJI+x1vM6xN48vhEvNx8HJIYCxjq2AC6byZafZXkC52ahijfo434To2TJSM1OVGc/Lt3/wF279mLU6f/e+t3XY3q1TCwf1+0a9tGeZKptH9+spzxZwcrLcdH1pP5pSIooiYKNJ6DfvhS8JOZq6ur+AGegbIH9CRp/Aqdzc8YzE9lAZSJyIqyO7q6b0aL5nW9rKZPny7GO2WgLwv6gU0ZmuJuyU1fYvnJFOUHZe6odI0mbaWggsZ9UZkjlbKdOnUKTZo0yXYfygRRkJm1jI7K2CjTl1N53YMHD0TZHDXbmDx5ssptn3/+ORYvXiyCKZovKQO9jzTv0NvK9aipBpXhUWtvaslN+0Dlk5QBo7bflpaWKutT23GaF4laeWdt5lEaFfXxwUovPjZKn4SEOGzYsAZSPzsYSOvBKNNkq4mWD9GpZ0vUrqXaPIHmF/JdfQT6MhtYalYBXlexyVOliFb4wqZvfdRsPFzlPsnJydh/4BA2bdkKD0+vXPdHR1sbPbp3w2efDkHNGtUL/wmzEok/O9jHdnyUmKDo/Pnzol3ykCFDROYhq5xe0JYt02fKprP5GUFRxYoVcffu3WzrBgUFqbT0zut6WdGZr4yzX1n3r7jfdDr4inI/6DWjTn3vsz9+fn6iBG/8+PE57ic1VIiIiMhxe7Q+vddZ/9HdvHlTBErvet6UococWOeG5kOiUjvKfn0MAdGHOj5Y6cXHRukQERmGzRs2IC2Q2mrXg1amTnIyq8cY9OkAOFTsmr15wrYLMFZzgoVGFeW3fpIiDglagXD+siscHVTH0Ia8eIHNW7Zhx67diI6OznV/bGys8dnQIRg8sP97jyFlpRN/drCP6fgoEUERlUPRmXwaI0Qd4HIaZ5QTH5/0ieAyl8FRoLRz507xw7tcuXLKzmk0BxK1is7veiz/qCSNLpT1oQYJVBJJc1FVqFAB169fR69evUT5XWF49OiRyFjRNgsD7d8PP/wgMmDdunVTNl/IrdSPMcaKWlBIIHZs2Qb1YHfoKt50kkvSikaajRc+GzkM5cupdpJ7ceoKXh55DDMdF1hqvmmeEC+LgNw0Cq4T+0PHWHWCVCqRW7dhE44cPfbWErlmTZtgxLBPRYkcT1fAGPtYqKVRsV8xoh+1FKC0atVKDOTPbR4aKpuicSi0Hq3j5eUlJnmls1iPHz9WTrhKY1jc3NzEehRg0dMbOnQobt++LdotZ3Tdyet670LlczT5XExMTLGXz5WUmYNpfA5dMqOxQXl9TYsTHU9UTpcZHVuUZSrNStLxwUoWPjZKLr8AX+zauhs6L6tBJ+XNpOIJ2hHQtPfDyFGjYWKsmqEJ+Ockoi6FwEJXtZFQVHIQtJyASmP7QUP7TZMbmqPvxKnTWL9hk5hwNTf0Odivb28M/2wot9NmAn92sI/t+Cj2TBENgKcXjc7QZx48n9GFjjp/ESppo/bdvXv3FuVrNCaEsgM0GD8jICL0Nw3UHzZsmBhzRMEOtYemUqjMP8rzuh7LPxqr87a5pEoy6phEgTJjjBV3MCR5WR1GmSZcjZO8gL7TC4wfNQ56evoqgY3/1kNIuBcHM10HZUBE32uRyc9gVN8S1YcOVnmM+Ph47Nq9Bxs3bcHzwMBc98XZyRH9+/bBp0OHwNi4+E78McbYR58povI1mlgzJ1RulTVAoZQ+dXrLOjA+J9QMgErx3lXrnNf1csKZIlYalMYzNuzD4GOjZAZD2il6yuWxeoEwdYvC5yO+hFamqQcoGPJdvQcy71SYSGyVy1PTUvBK6oMKXd1h1V61CU5QULBonLBj19+Ii4vPdV9aNm+GUZ+PQIvmzcR3Ln92sKz4s4N9bMdHsWeKMsbz5BWVzuUlICLm5uaFuh5jjDH2oTJDMXrPUa5aPL7/bKxyjiGikErxdPluIEgXRjrW0Ht97jAlVY5IuQ/sBjdExQajVB7j8eMnWLV2PQ4dPiKCqdy6yPXu3ROjRo5AZTdXsawkzDHCGGNlIihijDHGyqJ3BUNTswRD8vgEeC3ZDc1XpjDSdlBtq53qC4fhrWFfrY1yfSoEuXzlKlauXoMLFy/nuh8WFuYY9ulQfDrkE/E3Y4yVRRwUMcYYYyU5GIqLh+eiv6ETUw4mWi7A6wo6aUoS4tT94Dy2Cxyd2qmUmR89dgKr1qzFw0ePc92PypXd8MXnI9GzR7ccp5pgjLGyhIMixhhj7AMIDQvBpvWboR1cI4/BUBw8F+6GTmw5mGq5ImNiIppjKFEnCK5f94auVQfl+tSA6O9/9mDtuo1vbZ7QulVLjBn9OZo2aZznKTAYY+xjx0ERY4wxVoQioyKwYe06qAdWgaGiUZ6CIY+FuyGJLa8SDCXKY5Bs+BJuX/eHjqmxcn1qhLBpyzZxob9zG49LGaExo0fBvUrhzBPHGGMfEw6KGGOMsSKQmJiANauXQ+HvDD3Zm8xQrG4ILKpGYerwcdmDoQV/QxJXAWY5BUPTB6pMuBoaFoa16zZg2187c+3iqqenhyGDB4rmCTY21vw+M8ZYLjgoYowxxgqRXCbDmrXLkOBtAwNp/YwhQIjXCYN+pWBM/mKCSmttaUwcvBZlBENuqsGQUSiqzBwALcM3wVBgYJAYL/T37j2QymQ57gM1TPh8xDAxv5CJ8ZusEmOMsZxxUMTyjCbYpQl016xZA2fnN7OlU7nGiBEjUL16dfzyyy/5fkWlUin27t2L//77Dy9fvhST6daoUQMjR44Uk6kWNn9/f+zcuRP3798XZ1dpotn27dujW7duXF/PGCuwFIUC6zetROQTMxgl1YbB6+WJ2pHQdPDFV2O+hIG+oUo3OY+FuyCJKZ8lGIpGslFYtmDIx8cXy1euxr8HDubaVtvR0UGUyPXr0xsSCTdPYIyxUjN5a2lXliZvpS/hSpUqoUOHDli9erVYJpPJxPXnz5/j2rVr+Z536uHDh+jbt6/ofDR69Gg4OjrCx8cHixcvRnR0NCIiIqCl9fqXQiFYsGABfvzxR/Tq1Qtdu3aFvr4+Tp48ibVr1+LLL7/E0qVL8TEqjZOosQ+Dj43CsfPvTfC7kQbjBAflsmTNWKRW9MDno0fDzNRCZZ4hr0U7oRlmCn3tN5OGUzAkNQ5F5W8HqgRDjx49xtIVK3Hs+EnRZjsnVd2rYMJX49C5U0doaGgU0rPi44PxscHKzncLZ4pYntEX7ZQpU/Dtt99i1qxZsLKywhdffCEyLleuXMl3QBQQEIDWrVujbdu22L59u0rwM2zYMHEpzIBoyZIlmDp1qshK9ezZU7mcAiTKEt25c6fQHosxVjacOHUIN08FwDTWHRlFalKNRMhsHuCzkZ/BukIvlRNLT5fuBAL1YKztrGytTWVyUuOX2YKh27fvYPGyFTh77nyuj1+vbh1MGP8l2rRqyZluxhh7D5wpek9lKVNEkpOTRTbn008/Fc/3559/xrFjx0Rgk1+UYaKsEGWLKGOT02NJJK+nan9P3t7eqFatGiZPnozffvstx3UK8/FKmtJ4xoZ9GHxsFMztu1dxbM9lGL+qBXWk/5tSqMuQUP4uBg8fAEd7Z5VgyGftXiieqsFYp4JyebIiHgm6Qag8aYBKN7lbt+9g0eKlOH/xUq6P36J5U0z46ks0atigSIMhPj4YHxusrHx2cKaI5QsFDd988w1++uknMRZo3bp1BQqIbt26hVOnTmHRokU5BkQZj1WYZXP0w2HSpEm5rvOxBkSMscKdeHXHpt0wCK0N07Q6YlkqUhFjfg9d+rdAnVrTVdb33bQfifeTYCqxBV4P8ZGlJCFW0w+Vp/SFpHxnlWBo4eIluHDxcq6P37F9O4z/ahxq16rJbytjjBUiDopYvtWuXVtkVajs7PPPPy/QK3jgwAHx/08++SRP6z948AA3btyAk5MT2rRpU6DHo8yUubn5O9elmn1q+uDn5yeea926dfP9eIyxj0t0TCTWrloDzcBqMMk08WqU8WM07OCA9m0nq6wf8M9JxFwKg5muPXRen2+Rp0oRDV9UmtAdThXfTLp689ZtLFqyNNdgiM6ydu/WFeO/HIsqld2K6ikyxliZxkFRMXn5+++QengW2vZo6K1CLke8lhbyUkihU6UyKsyYke/H8fX1xZAhQ1C+fHmcP38e8fHxMDDI6LGUd56enjA1Nc3TOCTK7pw9e1YEJ3/++afockfjgvKKShupq13lynmbsLBjx47iR4idnZ1oyjB27FgxhooxVjbba69esxRJ3vbQzzTXUIy+PxwbqOGrgRNU1g89fx0v9j2GhW4lERARRaocUSnecBrbAY6V2qkEQwsXL8XFS7kHQ3169cTE8V/CycmxyJ4jY4wxDoqKDQVEiTdvFvp25Sg6VBvapUsXuLu7i8YIbm5uoj33d999l+9tyeVyMalgXvTo0QMLFy5Utv+uUKGC6HZXsWLFPD8Wyevj0Zij+vXri7+PHj2KadOmcVDEWBm0a/dmPLuWBuPEOsgo8o3XCYWxeyimfj5eZeLVqIde8N94HubariIgIilpKYiUPYX98OZwqNlGpUxuwaIluQZD1NSGgiFqoODk+KabHWOMsaLDmaJiQpmawpSRKdLMR6YoP2j8EJXLkX///VcMnKN5hChYGT9+vGipnR+U7Tl48CBCQ0NF1knluaSlifbejRs3FtdbtWqlEuDQDwZ6/LyieY+oU97du3dz7YKnqakJGxsbcZ0Coq1btyI4OFg0kShI0McYK70uXTmLswfvwyy6hrKjXJJmLNQcPPHVuK9U5hpKCHqBp0sPwhQusNSpolwekfQU1v1ronazL5TLHjx8hHkLFuXaTY4+2/r27oUJ48fB0YGDIcYY+5A4KComBSldK84uHzR2yMPDQwQrGQEJteemTBEFEDTHUNZJXmmuIer4lhNq5b1s2TLxf7o/dfDLmFh1woQJYvxPRlCUOSD67LPPRMe7zCV7VNoWGBiIjRs35rr/1HWOLvRYtI2M4IsCs6+++gpeXl4q61NARJ3xwsLCRMDEGPv4BQQ+w/b1u2EYVgdmaTXEMoWaDAlWd/HZqKGwtX7TXlsaEwfP+btgkFwRlhruyuWRSf4wbWWFWr3fjLf0evoU8xcuwbHjJ3J8XA6GGGOs+PGvPfZONK5mz549OHPmDJyd37SZtbe3F40SaJwPZY0yJgyk8Tu0LjVjyA2N16Huc6NGjYKtrS2qVKkislHPnj3DoEGDxISumdFt/fv3R7169URwkxnNL0RB0bvGJdE2KOD64YcfROkdNVKgkrrp06dn64BHywhll1q0aIHBgweXmpaSjLH8SUxMwKoVy4CAKjBRNFAujzS9h079GqF+3Tcd5VJkcngu3AHNcDOYa1UGXs+TGpP8AjrVNVHj80+V6/r5+4sxQ/sPHMpx0lX6zOzXp7fIDDnYp48/YowxVjw4KGJvpVAoRPnawIEDc8z6zJs3T3SGowAoI7C4d++eaGrwrq5tVKZGE79SIBQUFCTK3CjoylqKl5iYKEr3GjVqJLJEWdE2KNh5Fwp0qBTu0aNHSEpKgoODA6ytrVXm+Hj16pV4/IxMFAVNlIXLbRZ5xljptnHzSoTdM4Zh8ptgKFr/Gao018NXvVRb+Pts3A/pQzmMdZyA1/NKJ8gikWIdi8rffqI8MRQSEiImXf179x4xR1FW9JnTu1cPfPv1BC6TY4yxEoKDIvb2A0RT863zEFH3uHbt3nRTIpcuXRLBR14nFKQ223TJDWWOqLECNXmgkryMZdRwgcYDUXc5KsPLC21tbdSpkz63SE6io6PFttu3by+eOzWUoPK6jB87jLGPw+n/juDasecwjauMjBFCCdqvYFAlCNNGT1BpovDi9FWEHXoKc10nSHTeTLyaaBCMKj8MhpZB+gmh8PAILFuxCtt37IBMlnPbmy6dO2LypG/gWim9GQNjjLGSgYMiVuhoYlcqcyssDRs2FEETjTfKQKVwxNDQULQGzxiT9L4oU0WNJHbs2CGyXwWdnJYxVnLHDW1bvxvGYXVhmpY+549MIwkymwcYPW40zEwtlOvGPPXDs1WnREc5CoiIIlWGKPig8nd9oGuVPvFqXFwcVq/bgLXrNogsdE7atG6FKd99g+q5jLNkjDFWvNTSuC7ovcTGxoof5JStMDIyQnEp6kYLrHTj44OV9WOD5htasXIxUnxcIVGkf1anIhUxFnfQe0gnVK2S3lhB2URh7g4Yyp2grZE+8yp9VUZIn6Li8CYwr+WuPDmz7a+dWLp8BSIjo3J83MaNGuL7yZNQv17pnAS6rBwfLP/42GAf2/HBmSLGGGMftX/2bYf3JTmME+tlDAVCtIEvarQ2Rfeu3yvXo/E/Xgv/guZLU5hruSubKEQmBcC0tRVq9xql/LLff/AQ5s1fhMCgoBwfs3atmpg65Ts0bdI4z6XEjDHGig8HRYwxxj5KDx/fwf6/zsIssrZyvqFErSjoVQ7AtDETVcYN+e88ivjrsTCROCqbKMTJIqDuJEXVcYPFuELKFp2/cBG//zEPTzw8cnxMNzdXTJvyHdq1bcPBEGOMlSIcFDHGGPuoxMbGYPWKldAKrAGz1NpiWYqaAvFWtzFyzGeoUP5Ny/9Xdx7j+dZrsJS4wkSS3nJBqkhAgkEQ3P83FJp66eVz9+4/wJy583D5ytUcH9PGxhpTJn0ruspxYxbGGCt9OChijDH20diybTVe3jaGQXJD5bIo48do2dMdzZu8mW9IGhUDj7m7YJLqIgIikpKqQGTqU1Sa2B0GFTuJZf4BAfjjz/k4fORYjo9nYmKCiePH4bOhQyHJaE3HGGOs1OGgiDHGWKl3594NHN11BabRNZA+yxgQLwlFuVrR+Gr4BJVxQ0+X7oR6kDEsaNzQ6/G/EUk+sB5QE7WbjhHXo6KjsXTZCmzeuh1yefb22hKJBKNGDse4MV/A2Lj4muwwxhgrHBwUMcYYK7XiE+OxcukyaD+vCdPU9A5ycvVkyOzuY9xXX8LI6E27/qDD5xB5KhhmuvZvxg1Jw6FVDaj1+QhxXSaTYeu2v7Bo6XLRVTQrKo0bNKA/vv1mAiqUL/+hniZjjLEixkERY4yxUunv3Vvw7Ko6jJIylcqZPECXQU1Qp9abUrkYbz88W0nzDbnBTLeiWCZNSUK8XgCq/u9TMW6ImigcO3ESv//xJ/z9A3J8vE4dO4gmCi4uzh/g2THGGPuQOChijDFWqnh4PsSebSdg9qoOMgrX4nXCUKFuNL767BvlegqpFI9/2wqDJHtY6lQRy1LTUvFK5gWX8R3h7NxB2UThl9/m4PqNm7m21/7fDzNK7VxDjDHG3o2DIpYnR44cgZ+f31vXqVWrFpo1a5bvVzQsLAxXrlxBREQErKysxHZsbGwKff8TExPRv39/leUvX77Enj170KBBA3EpiKdPn+LevXtiVnt7e3vUr19fTOjLGCv8CViXLVsEPHOHWUodsUyhJkOSzR2MnTAWJsZmynX9th9B0u0kmOtUVplvyKyjHWp3+UJcDwoKxh/zFmD/gYM5Pp6tjQ2mT52CHt27cnttxhj7yHFQxPLkwYMHCA4OVtbcr1u3Ds2bN0eNGm9mga9atWq+Xs1Xr17h66+/xt69e9GqVStYW1uLx7l79y5GjBghHqOwREVFYfjw4ahbty6cnJzEMgqSunfvLv7/6aef5nubT548wZgxY/D48WO0adMGhoaG+O2330Rw9/vvv2P8+PGFtv+MlXUHD/+DR//FwzixvnJZlJEH2vSuiiaNZyiXRXv4wG/NOVhK3KClk55HSpBHI80uFlUnpM83lJCQgOUrV2Ptug2QymTZHsvQ0AATvvoSI4cP445yjDFWRnBQxPJk+vQ39fkUtFDAMnXqVHTt2rVAr2BkZCRatmwJXV1dkWmxs7NT3vbXX39hyZIlhfrODBo0CD/++CPmzZuHVatWifEDQ4cOxfPnz3H9+vV8Z3YoM0SBUOfOnXH8+HHo6+srO1tNmzYNjx49KtT9Z6ysCg0LwfoVW2EUWhfGMBfLErUjYVQtBNNHfqmcgDWjVM6QSuUkbm9abOMp3GcMgI65KVJTU7H33/1i8tXQ0NBsj0UB09AhgzHp6wkwN09/LMYYY2UDB0Us3yggIFTmVlBjx44VGZWHDx/C0tJS5bYhQ4agTp300pjCoqmpiSlTpmDSpEmYNWsWFixYgGPHjuHcuXNwcHDI17aSk5MxcOBAkRnbtm0b1NXVVX5UUeDlkcts94yxvNuwcSVe3bOEiSy9tDVVLQVx5W/j8y8/Q/ly1sr1/HYcQeJN1VK5V0nPYNW/Kmo3S2+xfffefcya/Qvu3E3//Mqqfbs2mDltKjdRYIyxMoqDIlagoMjCwqLA435u376Nf/75B4sWLcoWEGWoUiV9UHRhGjlyJH7++WeR3aJs199//42GDd90rcqrjRs3iuzWli1bVAKiot5/xsqKh0/u4cC2szCNqon0HCwQo++POh3N0KnDNOV60Z6+8Ft9VmSGjDOXytnHo+bEYeJ6aFgY5v65ALv37M3xsdyrVMGsH2egaZPGH+CZMcYYK6k4KGIFCoreJ0tE5XFaWlr47LPP8jTuiBoYECpnoXE7BUWTLdLYofnz5+OXX37J1nQhr7Zv3y6yRI0aNcrT+jTxY3x8PExNTQv0eIyVpUYKy5cvQppvVZim1BTLZBpJSHV8iCkTJ0FLW/tNqdzvW2GYmHupnFQqxfqNm7F0+UoxhigrMzNTfD/5Owwe2F9keBljjJVtHBQVk4u7nyIiML4Qt5gGuVwBLS2aX0PtnWtb2Bmg+QDXAj0SNUMYNWoUCurmzZtwdHSEmdmbTlG5oVK0Xbt2ITw8XJS8UdldQdE4n7Vr14q/FQpFgbZBY5Eo00VjlN6FGlJQqR6NYVJTU0PFihVFdqpy5coFemzGPmanzx7B9SMhMInP1EjB+BG6fdIItWq+yQ4F/nsasecjYS7JXCrnB6u+VVC7xRjxb/TkqdOY/evvCAh4nmMp7fDPhuLbryfC2DijoTdjjLGyjoOiYkIBUYh3NEobassdHR39XpkimiWeWm/nxR9//CEu/fr1w/t48eKFKJujjnlU2rZs2TJMnjwZBgYG+dpOUlKSCHbysv/UrY8aOISEhIgs1TfffCPGNB09evQ9ngljH5fomEisWroG+iF1YZKWPilqolYUTGqE4IfRE5XrJb0Ih+e8fTDXqgxjSfq/v0R5NFJFqVx61vnZMz/8OGs2zl+8lONjtWzRHD/9byYqubh8kOfGGGOs9OCgqJhQpqZwZWSKNPOcKSquJgs0FsnLy+utJXOF2fmJSmeo9TZlpijrJNrxLl8uskYUpOSHnp4eTExMRNe6nFB3Kwr6qFSOsmHUiS4DBWT3799/7+fD2Mdi995teHZRA0bJ6WP70pCK6HK3MXzsJ7C1ftOR0nPJDmg8N4altru4npqWglcpXqgyrT8klmairT6Vya1Zt0GUq2bl4GCPn36cibZtWvN8Q4wxxnLEQVExKWjpWm7oxzi1uaYf/rkN/i8MFBRR1iO3EjDqJnf+/Hkxz1BGm+qsPvnkEzGeiCZNzZwBonbWNL+Ps7OzWCcvqByNAhUKenJ7XQYPHiwmaaXW25QZogs1XaByPJpLSPv1OAVy5swZEfDQ/ueG9m3Tpk3w9vZGpUqVlMtjY2MxevRo8Ryyjh+ijnVUCpjfIIyxj7bN9vJtMA6rC0Okf17F6gbDraUGxveaqlwv4uYDBG2/AwtdZ0ArfVl0chBMOlijdpf0Urkjx45j9i+/ISTkRbbHMTDQxzcTJ2Dk8M9U/p0zxhhjWXFQxPIdFFWrVi3XgckUEE2YMAG9e/fONSiiZgc3btwQ43IGDBiAmjVriuwKTeJKQcyJEyfyvD9z5swRpWy5BUVUsvbff//h4sWLKt3yvv/+e5Epog5yFMhkoBbb9PhvC4rmzp0rJm6ltuEU3FFGKCAgQARobm5u4nrWgIhej549e+ZpLBJjH7Nt29fhxU1jmEjTxw4p1ORIsruNCV9PgIF+eiMVRWKymHPIWO6cHhDRGL2UJCQYPof7z8Ogoa31zlK5Af36Ytr3k1GuXM4dLhljjLESGRRRloDGXpQvX/6dZ/RoPRq4/q5xHYW9HgPq16+vMtFqVv7+/nBxcXnna0ljeqhZA80VRJMo0vorVqxA27Zt81zeQmeJKatDcwblhDI5FGT9+++/qF27tspt9vb2oiU4dYXLuv8tWrR46+NSpokCLcoqUbBFWShXV1ecPHkyW1lhRukePa+ZM2fm6Xkx9jEKCHyGbWv2wjSibqY2235o0M0a7VrPUK7n//cxJF5LgLlOFbxOIiE8+Skcx7SEU5UO6aVyi5fkWipX1b0Kfv9lNurWLdy5zhhjjH3c1NLol2UxonIrOtt/4MABUfpFXca6deuGJUuWZJsHh+aWoSwD/QilH7vUzYvaI1PmoijXexsqmaLB9JTpMDIqvk5GH6p87l2oTfWwYcMwbty4Qtkevb70vL788ks0bdpUTOxKxwW19KZucvR4gYGBhdLumn5g0XtJ2S4K/t4XBUQdO3ZE9erVMXXqVGXnK1tbW5TV44OVPB/i2Fi/cTmi7lpBT57+71SuLoXc4R4mTPxWlOMqGyn8+S8stCsrT4zEyyKhUUWOSqP7iZMgR4+fyLVUztjICN9PmYShnwzmFtuFiD87GB8brKx8dhT7XlLwQ53B6Acu/bh99uwZfHx8spVD0Vw11D2sQYMGIrMQFhYm5orp0qWL6AhWVOux/GnWrBmGDx9eaC8blaS1atVKlKutW7dO/E0d8DLK0ijjVFjz/1CDh+nTpxdKQEToWA4KChLZMNpvunD5HCtLvH088MuMhZDecFcGRNGG3qg3VIIp309XBkReq3YjcP51WOpUEQFRSpoC4alP4PhjKxEQ+fn7Y+hnIzBm3PgcA6KBA/rh/H+nMOzToRwQMcYYK52Zon379okAiM78Z57cc+jQoaL8iUqxCI3/oGwBZXUsLCyUZW901n3z5s3KiUALe7134UwRKw1K4xkbVrqPjVWrFyPxkQMkCiPlJKxpzo/w9cTvoKGZXrkd89QPz1b+B0vJm8YzUcmBsOjqAKv2TcQErKvWrMOy5SshlcmyPUa1qu747eefuFSuCPFnB+Njg5WVz45i38s+ffqoBEQkI1NDXcUyXLhwAe7u7soAhlhbW4tOZTSuo6jWY4wxls/s0PRFSL1XQxkQRRl5oMUoM0yaNFUERDSG9PEfWxCx7qkyIJKnShEp8YL7n/1FQHT12nV07NID8xcuzhYQUancb7/8hCMH/+WAiDHG2MfVaCEDnRlcvHixKGWjICUDldZlHWNEaB26rajWy2n/6JI5U5QREdOluNBjU9KvOPeBlVx8fLAPcWzQ2KHY+3Ywk9cU16UaCdCq7IWpYyaKYIge49WNBwjZ+QDmuk7A6yaWr5KewWZoHdjXbSPOLP4250/8s3dfrl3lpk+dAnNzM+X+s6LDnx2Mjw1W2j878pqpKnFB0ZgxY0TZHA12z4zGj9CkmVnp6OiI24pqvayoKcTs2bOzLY+KioJCoUBxoYOOxknRAVha0pTsw+HjgxXlsREUHIBDf5+FWWQd6L5eFmX8GK17VYdbpeGIiY1FilyO4GX7YaqoBHPd9Lb1yYoExJsGw+rbbkhTV8fGzVuxeMkyRMfEZHsMJ0cH/DBjGurUTu/wSMETK3r82cH42GCl/bMjc1VYqQmKqEMXdX/btWuX6CqWmaGhYbb2yYSWZX6yhb1eVjQQP/MEnJQpohbVNNi/uLvP0QBl2o/iPvhYycPHByuqY2PLtjWIuFUOZvL0FtgyjUSou3pg6rivlWOHQk5eRvTxYJSTVMvUZtsLjl+2gZNLB3j7+GDGD7Nw/cbNHE9UfT3+S3wx+nOegLUY8GcH42ODlZXPjhITFP3++++YN2+eaHLQr1+/bLfTpJiHDx/OttzX1xdNmjQpsvVy+oKmS1b0hhf3m04HX0nYD1Yy8fHBCvPYCAoJxOaVO2EaUQ8Zoz+jDL3Q+ZNaqFt7inIS1ke/bIFpiitMJOnlyonyaKi5SVH7i1FITpaKMUPUTCGnOYdatmguxg452Nvzm1eM+LOD8bHBysJnR4nYS2qr/MMPP2DNmjW5dn2j9tk0Uee9e/eUy65duyZaadNtRbUeY4wxVdt3bsCOP66KgIjI1ZMhrXQT0+eMRt3ajcWykBMX4TXjICzS3KGhronUtFSEy56g4veNUemLfqKRQocu3bB0+cpsAVE5S0usXLYE27ds5ICIMcZY2WjJTe23aQJVao89fvx4ldtoMtWMDnS0m+3atROTuy5dulSk5b766is4OTnhyJEjyvsU9nrvwi25WWlQGltjspJ3bIRHhGHN0o0wDWugXBZt4IPWfV3RpHEr1exQqis01NKLEeJlr6BTTwuOn3RFbGwcfpszF3/t3JXjWcXPhn6C7yd/B2Pj4itHZm/wZwfLDR8b7GM7Poo9KKJA6PTp0znetmnTJjRunH7WkSQkJIgyu5MnT4ovz86dO2PatGnQ1c0Y2ls0670NB0WsNCiNH06sZB0bBw7vhsdpBQyTK4jrCnUZZA538c0330FLW1ssCz52AdEnXsJYYpW+7bRUvFJ4wn3GAOiYm+L4iVOY+eMshIaFZdu+e5Uq+OP3X5SNFFjJwJ8djI8NVlY+O4o9KCrtykpQRNtOTEx86zoGBgY5dvTLCW2Ltkkt0LPu76tXr0QHwJxapucVHda0fXpPss6DVRSoTTs16TA3N0dJVBo/nFjJODbo3+LihQuhH1gf6mnpPbRj9P3RuKc1Wrfo9CY79PMWmKZlzg5FQNJAAodBnREWFo4fZv2Eo8dOZNs+jdH87tuv8cWokdB83ZiBlRz82cH42GBl5bOjdOwlK3bDhw8XHQEzLtRxr1q1airLtm3bluftvXz5Eg4ODqJ8MrMbN26IbS9cuLBA+3n58mV06dJFlF26urqKQI3mvFq9enWht0yncRALFiwQ26fgy8XFRXQ17NGjB27ezN5Fi7HS5srVc1gwczsMnzcSAVGqWgribK/hm18GKgOioKPn4TXzECzgLgIiMXZI8QSOP7aB/cBO2Pn3brRu1zHHgKhJ40Y4feIIvhz7BQdEjDHGSkdQ9N9//8HHx6do94aVWAcPHkRQUJC4XLhwQSxbuXKlchldJkyYkOft0ditgQMHYu7cuSKrQwICAkRA0aFDB9GJML9obFjLli1Rv359BAcHi4xTaGioKIuk8WI5dbcqKOq936ZNG6xYsULsa1JSkpiril4bei2WLFlSaI/F2IeWolBg8eI/cX1bAkwSnMSyeEko7Dq/wrQfZkBPT19kh+5NW4OU86kw1kkvqYuTRSC1TiJqzx+DkJgoDPzkU0yZOkPMU5SZsZER5v85B3/v2AZHBwd+gxljjBW7PNcq+Pv7ix+x+/fvR9OmTYt2r1iJltGxr1at96v9p/FbNWvWFAFX69atRdc/W1tb7NixI9+p1mPHjuHrr7/GunXrMGrUKOVyKuebP38+3N3d8zVW7F1GjBghJhmm16JChfQfhKR27dpi4uETJ7KfFWesNPDyfox/1p+BaUx6ZzkSZXkLYyYOg6VleXH9xZlreHUoABYSd0Dt9dihFE+4/zgImkYGWL12PeYtWCTKSrPq0rkjfpk9C+XLlfugz4sxxhgrlDFFVFc+bNgwHDhwABs3bsQnn3ySbR1qZ01nyOmLkH6IlgVlZUxRZv/73//E+0vZEg2N9DEGBUWZIcrmUPDi4eGB69evw8oqfZB2XqWkpIhSOSq7O3fuHIraqVOnRDaLygWHDh2K0qA01vayD39sbNm6Bq9uV4Cu3FjclqQVA7M6LzByxJfieopMjke/boZxsjM01bWU2SHdhhI4DOwsJmH9bso03Ln7ZqqDDBQE/frzT+jcqQO/taUIf3YwPjZYWfnsyHOmSCKRYNeuXZg5c6b4IUiTnP7444/Ksif6kbxhwwaxHpcOfdwoO0Ljid43ICLTp08Xk+XSWJxLly7lOyAix48fx7NnzzBnzhx8CFQ2aGFhgQEDBnyQx2OsqEVGhmH1kg0wDa+PjHxqlPEj9B/VFm6VeovrETcfIGT7A5jrVhaF13Q+LULuAfeZA6BhbIgVq9Zg4aIlkMpk2bY/9JPBmD51CrfZZowxVmLlq9UPta2mFtZ0Vv6LL76Ap6enGBxL5U6WlpaYPXs2xo0bJwa3s7c7u3ktwgKeFd7LlAbIFXJoaWqJcpZ3KWfvhNbDvyhwUNSpU/og6/dFgVBGKV6NGjUKtI2M7BBlb94lOjoaf/zxh2jIQPNgUQlf9erV8/14bdu2hfbrNsRvQ8HaL7/8gqdPn4rHoUmKqUSQsZLi6In9eHQiCabJ9ZUTsaq5Psb08d9CQ1NTZGI9/twGvUgbmOnai3US5dHQqJaC2iPGwOvpU0wa+Tnu33+QbdsODvaY98fvaNyo4Qd/Xowxxlh+FKj/Kf14pR94FAwRGixP4zmotSrLGwqIgp48KnUvFzUTCAwMfO/xRGTPnj0iKKGyzC1btuDatWuii11+hYSEiPK7vLQDHz16tGjEQFklGvdDY5n8/PxEpiovqKECBVaOjo55Wp8eb+TIkeL/a9euFWWnGY0qGCvuZgoLF86Htl9tGKal/9uJ0fdDi75OaNZkirge7ekL/1UXYaHrDLxODIcne8J1cjfoVLDEshUrsWjJMshk8mwn0EaNHI7vJ08q1LF8jDHGWIkIimgAecaPSfpRTG2OKSDaunWraMJgb59+FpHlLVNTqAqQKSqIu3fviv+/b1BEAdBnn30mgqLffvsN9+/fF8cWjVnLL8pM0rxHdEY7p5I+KvOhH2lk+/btyuC9WbNm4himoCivWSq6L817ROOpcpP58ai0L2OeJBpzR9lUxoqbh+dD7N14HqaxDcT1VKQi3uYGvvnua9FZjngu2QHNQLP0gIjGlSrioagYjdoTR8PD0wvf9R6HBw+zn9hxcnLEwnlzUa9unQ/8rBhjjLEPEBTRj8lPP/1U/JA8cuSImAuG9OnTRwyWpzP81EWMzsKzdyto6VpxD2ij0jn6wZ9bEJGQkCCySTQ2KLcxRxSE9OzZUxw3v/76q1hGwdHgwYPx+PFjMe9PBplMJoIJGsND49Vy0q5dO5GFoQ503bp1U7mNslp0XFJLbpI5m0lNHWiblStXVi6jfaemIrmNbaLXlrJLFOzQeln3if6dUMBIY64IBURDhgzBnTt3ROBG/3YYK05btq1F+A1LmMrdxfVE7UiUrx+Jr4ZME8d3QtALPJ1/BJYSN+U3RESSDxy/agU9R1ssXrocS5atyNbinu77xejPxUSsurn8W2WMMcZKqjz/eqaJKS9evCguGQERobFEZ8+eFcFSq1at8O+//xbVvrISgIIiOhZyGze2adMm0QXuxYsXOd5OQQcdP7SNzZs3KzMq/fv3F8tovE9Ok7mePn06133q27evmIuI2mSvWbNGBFaUeaJtUfCW09gfaqdNQf7u3btVbv/2229FW+23oaYiVEJHj0md6Gj+rjNnzmDQoEH4/PPPxfPIbNasWVi/fr34NzJlSnpZEmMfWmxsDH77aQ7iLjspu8tFmTxE329roEvnPuK63/YjCFp0Kz0gopMSKcmIMfFF9YWf4UWaHD1698P8hYuzBUQuzs74d8/f+GH6VA6IGGOMfdyZoreN9aCz5fTjcurUqejXr5/oQjd8+PDC2kdWglDWhoLf3FBrchqfY2pqmmNZ2cSJE6GnpyfK5DJnWegsMzUhoACCWnSXL19euT1CTRFyQ/elbBCVwu3cuVOUdJqbm4uMEwXpWfeXgqbevXuL1vKNGzfOtv/vKgOl8XQUHFJwNHnyZJEdo/s0b95cZMGyZo+oMQldKNjS19cXAVVexj8xVlguXDyNS/8GwSQxveGBXF0KVHqI6RMmQU1dHWHBIbg/dS3M1atAXyv9XFlkUgCsP6sJ+1ptsHb9RsxbsDDb2CH6tzduzGh8+/VESCQ8ppQxxlgZmKcor+hMPf1gXLVqFcqCsjhP0dvQBKxUjrZgwYJC2R61gKfxR5SJKQx0bFLJJ80xlNMkxDQR66JFi0Qp3/uiCY8pY0WlghmNJag7IwWWGRmysnZ8sA/fTGH5ikVI86oKrdT0YD1WNwgNe5ZDm1bpHSRfnL2OVwf8YSKxTr9PmgLRWt6o9r8RCHr5At9+9z1u3LyVbdturpWwYN5c1KpZsK6RrHTgzw7GxwYrK58dBeo+9zZjxozBq1evCnuzrJQICgoSGZvCQvNhUQaysFAXOGqSkDHGKCOQb9iwoRh/ZGNjI0r5CkO5cuVEBnXs2LFiLJNCoRBjjj50QMTKpqCQQGxa9g/Mouoql0WXv4GvJn0BE2Mz0Zjkye9bYBhnrwyI4qThMGxjihrdRuOvHbvw829zxFi4nLJDk76ZyB1HGWOMfTQKPVNU1nCmqHTx8vISbbUze9sYqcIQERGB+Ph4MTaqMCa8LStnbFjBHTqyB09OymEgTS9DTdaMhVm9FxgxfJy4HuPtB7/l52Ch+2b8W7jsCdx/HIRIaRKmTJ2Bc+cv5Djv0JIF81CXO8uVGfzZwfjYYGXls6PQM0WMlWRubukDyD8k6pxHF8Y+RLnc4sXzoelbGwZp6a3gowy90HNEY1R37yWue6/bA3jpKQMiarWdZBeBGuNH4eDhI/jhx58QExubbdvDh32KGVOniDGBjDHG2MeGgyLGGPsIBAQ+w7YVB2Ea/WbuoQS7m5g65TtoaWtDGhOHJ7N3wFLbXfnJ/yrJFxXHNUeEZiWMG/81jh47nm27VlYVxLxDzZtlH4PHGGOMfSw4KGKMsVJu/8FdeHpGHabS9KYHiVpRsG0WiwkDp4vrL05fRdSRYFjqpM9NpEiVIdbAH9V+Gy7K5L6bMg0ROYwF7denN2bP+hHGxsXXRIYxxhj7EDgoYoyxUlwut3DhPOj41YV+WvrHeZSRB/qPbgW3SlXTmynM2QLDWHsY6bxuc5/8AmbdK6JSk0/wv9m/YMvW7dm2a25uhrm//4ZOHdt/8OfEGGOMFYcCj3w6duwYGjRoINpR07wsmS/UdpgxxljR8fXzxpyZK6H3rCE00jSRqpaCBPtrmPrraBEQxT8PwcNJW2AaXwma6ukTFIcrnsD11654Vd4QXbr3yjEg6tSxA86cOMYBEWOMsTJFs6Btl/v27Svme/n888+ztWWliSoZY4wVjT37tuPZOR2YyqqJ64nakbBvmYQBfWeI6/67jkF6UwEL3UrKZgpprgmo8fkorF67HvMXLoZcrjoRq4GBPn6d/RP69unFbeMZY4yVOQUKimgyzfr164s5VxhjjH3YcjmJXz3op6W3d48yfozBY9rD2akyUmRyPJy1EWapbtDXSr89MskfFcc2RryhLgYMHorrN25m227tWjWxfOki2FesyG8lY4yxMqlAQZGuri4qVKhQ+HvDGGMsR4FB/ti8/ADMohuK6ylqCkgdbmP6d1OgoamJyPseCNp4Gxa67oAakJKWgmjNp6g2bwQOHjuGmT/MQmxcnMo2NTU1MenrCRg4oB8sLS35lWeMMVZmFSgooizRxIkTERMTI8YUMcYYKzrHTvyLB0eTYSatriyXc2yVjH590rvLPV25GxrPjGCmay+uJ8giIWmsC4cOgzBx8vc4cPBQtm06OTli2eKFqF6tqphgjzHGGCvLChQUhYaGwsrKCnXr1sXAgQNhamqqcnuNGjXQoUOHwtpHVsKEhIRgy5YtuHLlCqKiomBjY4NGjRph1KhRMDQ0LLTHmTp1qhi/9tdff6ksp7LNJUuWiEuTJk3yvd1Hjx5h27ZtuH//PhITE+Hg4ID27dtj8ODB4sx5Yc/ovGfPHhw+fBjPnz8XjUhoAlkai0f/Thh7l6VL5yHNszoMUtNPQEUZemLgmNao5FIF8vgEPJq1HZZab+YeCk/ygtv33fEw+Dn6d+6KkJAX2bb56ZBP8OPMaWIiVjpGGWOMsbKuQL8AHz58CB8fH/H3hg0bst0+ZMgQDoo+Ujt37sQXX3whgojhw4ejXLlyuHXrFubMmSOCF/q7sHTp0gWtWrUS3QybNWsmll24cEEEFN9//32BAqIff/wRCxYsEPs+YcIE6Ovr4+TJkyKgu3z5MlavXl1o+//ixQv06NFDnIX/+uuvxX7T38uXL0etWrVw/fp1kXVlLCeRURFYuWATTCPqiutpSEWc7Q1M/X6ymIw14sZ9vNzhCUtJ+txD8lQpEkyDUP3X4Vi6fCUWL12eLeChVtsL/vwD7dq24RedMcYYy0QtLS0tLfMClj+xsbGihJBKCY2Mim+CQ/rxQz+4zczMoK5e4E7rb3XkyBHxI3/hwoXiR35mlAWZO3cuVqxYUaiP2bRpU5iYmIjH9vb2RuPGjUVAtmPHjnx3yPr111/xyy+/iHbybdqo/ii8ePEirl69KoKtwkAZqHr16olj4sSJEyplpvRPjgK9//3vf7C2tsbHcnywwnPl6jmc/ycARol24nqyZhwsGoZi2KdfiOuey3dCK8AcOhq64nqsNBTmPWyR4lYRE775LsdmCm3btMb8uXNgaWmhspyPDfY2fHwwPjZYWfns4KDoPZWVoCghIQHOzs4iKPn3339zXIda/GppaRXq41LZWffu3fHff/9hzJgxIjN15syZbG3g3+Xx48ciO/PTTz9h5syZRb7/U6ZMEQEiPa6jo2O22xUKRaGX6n1sH05l1br1yxF31wE6KXrieoy+HzoOdUfd2o1Vy+VeC5d6wP1/A/Hf9euYPHW6+CzKjP6t/O+H6fhs6JAcTyTwscHeho8PxscGKyufHZr5KQXy8vISY4noxz/9nRtah8ZNsI8HjSGisWRvy6QUdkBEunbtiurVq4tyTHt7e+zfvz/fARGhkjnav/Hjxxf5/lOgvGrVKvTv3z/HgIh8yICIlQ6JiQlY9OdSmLxsiIwjPLr8DXz9/Vcw0DdExM0HePnXE5VyuUSLYFSe+Blm//o7tm7fkW2bbq6VsGLZElR247njGGOMsbfJ8y8zKl8aPXq0GBdBg+rp79zQOuvXr8/rplkpcOjQIdjZ2YlM0bvs3r0bDx48EH9TYFCzZs0CPy6d2XZychLj2GgsjoWFaulPfva/U6dOeeqWGBcXJ5ojvHr1Cm3btkXt2rXz9Vhnz54VmTVqQpIXVHpIwR7p1q2beL6sbPHwfIh9G67AJC693bZMPQmSGt6YOXaauP50xd/Q8DeBicRGpVxOZtMY3Xr2gZfX0xybKfzvxxnQlUg+8LNhjDHGPuKg6JNPPhE/KmlgOp2pp79zQ+uwt4s+5AtZSEIhvkxpkMsViNAKplDinWtrW+vDpLtznrdO43lcXfN2tpkyLtRlbevWrahcufJ7BUWzZs0SY3JoXiwKtt523OUmOjoaERERedr/wMBAdOzYUQT+lBFt3bq1CMaGDh2ar9eK5OXxaCwTNXyg4IsyTD/88APOnz+f70CMlV7/7t8Jn/+0YCKrJK7H6oagUW8LtG7xDRSJyXj4vy2w1HQH0udiRbjUE1Vm9sWeEycwa+znkEqlKtszNjLCvD/noEunjsXxdBhjjLGPOyii1q10yXydFRwFRDI/1dr/wiBD0dWGamtr52nd3r17i8ulS5fe6zEpqKLGCNTxjrI233zzDWbPni0yVvmR0YErL/tPwdzp06eVDRCqVKmCzZs35ysoys/j0XO5ceOGcl2qv6VAiYOismHxorlQf1obemnpH8WRpvfxxbcDUb6cNV7deYyQrQ9Uy+XMg+E4dgAmTpuBo8dOZNteg/r1xNxDNjYfpoEHY4wx9rF4r4ENSUlJOHr0qGjPXalSJXFWneat4fIf5ClTU7jSM0VaWpp5zhTlR0YLaZlMlu3HPmVi6BigbmuFhUrQqE02dYyjMrTk5GT8/PPPYmzQ4sWL87UtGuRXsWJFEXzkxNPTEwYGBrC1tYWlpWW2sXT5PZ7ptSL0ePS4WZ06dUp00CM0RxKVz61duxbBwcGIj48X8yWxj1t0TCSWz9sA04j0luypSEGy4y3M+G4KNDQ14bVqNzSfGcNUYituj5WGwbSrNcKNq6JD527Z5h6iQaxfT/hKXHi8GmOMMfYBgyIKhuhHK53Zpgk7e/bsiRYtWogB8TSehDNJb5ef0rWS0OWDGizQ+0ulXosWLVK+v5RV+eqrr7Bp06Y8b4uySFRaRi28cwtS+vTpI7IzM2bMUGZwvv32WxEYUYlZ5rFFkydPhr+/vxgHlBvaztixY7F06VLxHGisEnWbo9be1CkuICAg230oY0MTxdLcSBmosxeVulHWKrfsUbt27dCwYUMx+Sw1HKFGERmT3tI8SdR5LiMoIrQvVJKakpIiyvfoMbIGZ+zjcfPOFZza7gXTxPT5h5I0Y2HdLBKfDJouyuXuTtugWi6X7Am3GX2wZucOLFqyLNvcQ1ZWFUR2qFHDBsXxdBhjjLGPQoF+PdP4DDp7Tz8u6QccTdxJ6IcqTbZJ5U7s40JjbKg9NpXE0fvs7u6O8uXLi4lcqbFG3brpP/Dy4s6dOyIDk5OwsDAxaWudOnWwZs0aldtobh/KUlFgk5mHhweePXv21sekdt4rV67EH3/8IeY9qlatmgg8li1bJuZd0tVNn+8lw7lz50QzEQr+M88lRPMP3b59W4z/yQ0FpdSYhF4zyp5RtoiCIwoEKdNGwVLWEjoKlqhckJ47ZcPYx2nbjvW4sDEcxon24nqMvj/ajLLGJ4NGIvK+Bzxm7EsPiKhte6oMMSa+sJ7RE8MmTsSCRUuyBUSdOnbAyWOHOSBijDHGiiNTRKVNDRo0wPTp07PdVrVqVdy9e/d994uVQJQFpHl3qMyLxvjY2NjA3Nw8X9ug+1E2ZPjw4TneTj/6qKECNWjI2iKbGh/cvHlTZHgyo+Nt2rT0Ll1vQ0EVZYv8/PxE6SeVruXUFIQaO1DrbgqIqCw0a0BHAdSAAQPe+lj0uvz111+iLI4ejx6HgiMNjden/1979OiRCNAyUJlgQVqOs5ItRaHAgvnzoOtfD5LXKaAoy1sYP3kUTIzN4Lv1INIeaMFUkj5eLk4aDpMuFRCoWwlDunRHRMQrle3paGtj1o8z8enQT/I9iTFjjDHGCikoorPduXWYox91eR2Qz0onCobokhuaaJUu1IWNStqoHI5K3ChDc/nyZdFEoE2bNjnel7rM0SU3Li4uKtcpQ0THHGWr8tPiOze0r1QK2qtXLzE3E6GMGGVFCe3/iBEj8twanP6dZA56sqKMFAVqdJKBgifKxL1vgwpWsrwIDcb6xf/ALCq93bZCTY40t/v44ZvvRcnk/ZlrYapwg7pmeuI+PNkLrtN6YvXOHVi8dDnS0tJUtudayUXMPVSlMs8FxxhjjBVrUEQ/aqm06P79+9naLVOJVcYPSFY20UBvGgNEwUOGjLPZNNbm4MGDhfZYFJxQQ4PCagNPWSAas5RZ5swNjaOjcVuFhTJSTZs2FW24qWSQxmZR8Mg+DleunsP53YEwS6ohridov4Jb+1T07P49EoND8fTPo7DQrSJ6o6SkKhBj8Aw2k3pi5DeTcPnK1WzbGzxoAH6e9WO2ck/GGGOMvR+1tKynIfOob9++YtzEkCFDxDgLKqmiMRp0pp3KmcpKtojGltCEoDS2isq7iktRN1pgpRsfHx/etu3rEHatPCQKA3E9yvAp+n/RHG6VqiLk5CXEHg+HgXZ6xjFRHg2dRjoIsjHEhK8nISw8XGVb1Njkj99/QZ9ePQt9P/nYYHx8MP7sYIWtNH63FLj7HHXlojPqNIcLPWkKgrp37y66kZWVgIgxxnIaP7Rw4XxIntVVjh+KLn8Dk6ZOgJ6ePp7M3wa9MGtlQBSZ5I+KXzXFlhPHsGBq9mYKbq6VsGblcri4FG7HSsYYY4wVQlBE5RvUJWv+/PmIi4sTZzJ5fgzGWFmff2jZnxth9qqBcvyQWpUHmDlxGuTxCbg7aS0staso+36Gpz6B1fc98OW0abhw8XK27Q3s3w+//jyLy+UYY4yxkhgU0UBwX19fDBs2TIwVyVw2lvk2xhgrKx48vI3Dm+/DLKGOuJ6oFQWXtjL07jVFtNsO2XQPlpIq4jZZShIUDlGQ1quNrn36ITQ0VGVbNCZvzq8/o3+/PsXyXBhjjLGypkBBEY0bunbtWo6BD912/fr1fAdFVIJHA/Cpkxh148oqOjpalOxlRfO/ZJ4IM8Pz589FZy8K2lq3bg1b2/SZ4Qu6HmOM5Wbf/h14dkYCY7mDuB6j74fuI2ujetU6ynbbJpL0z5ZYaSjMettjz0NfzPvkf6IDXWaVXJyxeuUyuLm68gvOGGOMfSCFPvLJx8cnz+2KM4IdmvOF2hb/+eef+Oabb3Jc7+XLl6KrHWWiKPDKuOQ0CejGjRvFPDcUZO3bt09MmklzxhR0PcYYy82SJfMQeMIcuvL0roFR5nfw5f96w71yTdFuW+uxMSSaBsp222bj62LKxtX4Y96CbAFR3z69cPjAPg6IGGOMsZKcKaI5Z6i5AnVao8kvs86nQl3oaGJOmqMmr+hHQb9+/bBt2zbMmTMHf/zxx1vXp0k6a9Wqlevt/v7+YpLOhQsX4quvvhLLaOwTtRCnTJC1tXW+1mOMsZwkJiZg0dxlMAlNHz+UihRInW9h+rdTIA19hYf/2/qm3XaaArH6vkjpUxPdh36KFy9eZmv7TmOHBg3oz5OxMsYYYyU9KHJ0dBQBzL1790QL7q5du6rcTmOLWrRogUaNGuV5m+bm5iJTVFgo06OlpSWCmwwU/MyYMQO7du3CpEmT8rUeY4xl5e3rib9Xn4NpXHpAJNWMR7km4Rj6yXS8OHMN0UdewEI3faLhRHkMtBtp4VaiNn4e8hnkcrnKtpycHLF6xTK4V6nMLzRjjDFWGoKiunXrisudO3cQFBSEHj164EOjlt+3bt2Cvb29CL4MDQ1VbqfbqBQvc1tw6oxHZXJ0W37XY4yxzI6fPIAHR6QwlaaP+YnVDUbLQfZo0rAHvJbvgnaAOQwztduuMLIeft64DvsPZJ+0uGeP7pj7+y8wMEgvr2OMMcZYKWq0UKdOHXHJEBUVJSYwLerJmSizc+LECVHaRq3A6XHXrFmDXr16KdehLk45jWmiZWFhYfleLyupVCoumSdvJTS3SNb5RT4kemyah7c494GVXHx8FI6165Yi+b4b9FPTT8ZEmjzEqG/6wsK0HO5OXQMLVIGahpq4LVzxBPpftMDgb7+D19OnKtvR1tbCrB9/wNBPBolyOf7sYCUVf3YwPjZYaf/syGt8UuB5iqhb3PTp00WpGQUG1EK2TZs2WLRokWhYUNgoWHn06JFy2zQWadSoURg0aBC8vb1hZ2cnltMbQD8yssr6wyOv62VF455mz56dbTkFaAqFAsWF9pnmi6LnVVpmDmYfDh8f7z8h64Z1G2Ac3Bha9PmBVMTaXMcXoz+H/FU0Hv9+CpZ67mJdRaoMMab+8HYxx/8GDEJ8QoLKtqwqVMD8P+egqnsV8blR3PjYYHx8MP7sYB/zd0teG8AVKCiiJ9ilSxdRQvfdd9/ByckJ4eHhomV2kyZN8OTJE5QrVw6F/YQyPykNDQ3R9GHz5s04efIkPv/8c7HczMwsxx8atIz2M0Ne18uKAsHM440oIKSAzNTUVGW+puI4+Cigo/0o7oOPlTx8fBRcVFQE1i7ZAbOoxuK6TD0JBnV8MW3kdISev4m4gyGw0EsfP5Qgi4KklQEOP47Aqilzsm2rRfNmWLpovvj8KSn42GB8fDD+7GCFrTR+txQoKLpy5Qr8/Pzw8OFDleCHWma3atVKdJKjYKmoUXaKyGQy5TLqTLdq1SrxZmS8CTSw2cvLS6XMLq/rZUVdouiSFW2juN90OvhKwn6wkomPj/x7+OQeDm24A7OE9I6XCdoRqNldFx3bT4TXqt3QemYCQ50344dMh9XCd/Pm4srVa9m29fXE8Zj09QRxQqek4WOD8fHB+LODlfXvlgLtpa+vL1q2bJktG6SpqYnevXuL2wsbBSuUocps3bp14gWnjncZBg4cKOY+2r9/v3LZ7t27RQvxzF3u8roeY6xsOnr8Xxxf7QPjhPQJWaP1n6H7l1XQrk0X3Ju+Bnr+FaCtoascPyQb7IreX47NFhAZGxlhy8Z1mDLpmxIZEDHGGGOsgJkiKv14+vRpjuNyaELV8uXL52t7GzZsEMHIjRs3xFih5cuXi+Xt2rUT3eDIgQMHRNBC45bo8S9fvizK5ubOnYuqVasqt1WjRg1R4jZixAjRJY8yQUuXLsWsWbPg5uaW7/UYY2XPuvXLkHDHBXqp6VnhSLO7mDB1BHQSU/BwEs0/5C7mH6LxQ4mWwbhXThc/fzo8W7ttGje0dvUK2FesWEzPhDHGGGN5oZaWNf2SBzRwysHBQcxTRIEFzV9EY4pofA81Ibh+/bpo3Z1XNCFrfHx8tuWffvopGjZsqBJwHT16VHSOq1ixIrp16yZac+fk7NmzImiioK1z585o3rz5e62XGxpTRJ33aELb4h5TRM0vKGAsLWlK9uHw8ZH3hgoL5v0JvYAGUIO6aKiQaH8D3035Hq+u3UPE3gAY6aRnyBPk0dBuqoOFF47j3/3Z220P6NcXv/06G7qvy3xLKj42GB8fjD87WGErjd8tBQqKyPnz5zFs2DAEBAQol9GcQQsXLhRd4coKDopYaVAaP5w+tOiYSCybuwlmkbXFdbm6FPp1fDB61AQ8XfMPNH2MleVykUkB0OrjjPG//wIvr+zttn/+aRaGDB6YY4fLkoaPDcbHB+PPDlbYSuN3S4FbctOYIg8PD1y9ehX+/v6oUKECGjRokOe2d4wxVlJ4eD7EvvXXYBafHhAlakeiahcNdGz/Je7PWAPTlMpQ10j/UA+XP0FERwdMHD8OcXGqGW4bG2usWbkctWrWKJbnwRhjjLEPGBSdO3dONFOgNtg0xocxxkqrE6cO4f6hJJjInMX1GH1/dP+8DlzL2+PhpM2Zxg/JkWAWiHO6Miz48qts22nZvBmWLVlYotptM8YYYyxvCpTPCg4OFuVzjDFWmm3ctBJP9qtDX/a6rbbpPYz9oQesk7Xg88spWOimTxadKI+GvG4yFj67hgWLlmTbztcTvsLWzRs4IGKMMcbKUqaoevXq+PXXX0WnOG4xyxgrjQ0VFi6YB4lffWi/PjcUZ3cNM6Z+j8C9pyC/mQZjiZVYHpUcCM0eFfHl77/A20d1ugFDQwMsXbQA7du1LZbnwRhjjLFiDIpsbW3FheYkGjt2LKysrFQGFJubm8POzq6QdpExxgpPfEIcFs9ZBdOI9M6WCnUZtGt4YtrYGXj8xxYYRFaErmb6R2O41BPh7Wzx9dfjs40fcnF2xoa1q+Ds7MRvD2OMMVYWg6J9+/bh9OnT4u9Dhw5lu53GGq1fv/79944xxgpRQOAzbFt6AqZx9cT1RK0ouHZMQbcOX+Hu5DWw1HQXRcWpaamI0nmKc+WTsHDCxGwTR3do1xZLFs0XHTcZY4wxVkaDor59+6JRo0a53s4DjRljJc2NW5fx33Y/mCanT84cqxeIzsPc4WpREY+m7IAlNVQAIEtJgtQxCkvv3cGJraeybee7b78WY4hKS4tRxhhjjBVRUGRqaioujDFWGhw49De8T2rDUG4trkcZP8bo7/pC7WkIArZchrlueglcnCwCisbamLhmI48fYowxxsqQfAVFcrkcy5cvx4ULF5CcnIyaNWvi+++/58wQY6zEWrNuKZLuVoJuqo64HlXuJibP+BpBO45DzUMXhtqWYvmrJD9ENDPChJ9/QGxcnMo2nJ2csHHdah4/xBhjjH2k8hUUDRgwAPv374ezszO0tbVx5swZ7N69G0+ePIFEIim6vWSMsQJ2mNP1qw8tqCMVqUh2uoUfvp+GBz+th0mSC9Q1NMS6YfInuOAgxYLvf8lx/NDihfNhZMTjhxhjjLGPVZ6L4h8/fozjx4+LLJGPj48IhJ4+fSp+QPz1119Fu5eMMZYPiYkJmDN7AfT8GkIN6pCrS6Fb3xPffDkBd79dC7NkN6iraSAlTYFXel5YGX8f85cszRYQTfpmItavXcUBEWOMMfaRy3OmyMPDA506dULz5s2VyxwcHDBmzBhxG2OMlQRBIYHYvPggTGPri+tJWtGiw1zrKt3hMXM/LHWriOXJinjEu0Thu3174fXUW2UbBgb6Yv6hDu3bFctzYIwxxlgJDYqio6PF/ENZWVhYiMwRY4wVt9t3r+LkVm+YJqUHPrG6QejwWSVYR6QhZMV9mOlWFMtjpC8RVQcYu2Ch+GzLOn6I5h9ycXEulufAGGOMsRI+pigiIgK3bt1SWRYQEJBtuaWlJezt7QtvLxlj7B0OHv4HT09owEhuK65HGXlg+Dc9kHTkOpKeGkNfO71jZkSSNx5WTsEPP81HSkqKyjbat2uDJQsXcLkcY4wxVsbkKyg6cOCAuOR2WwaevJUx9iGt37Ac8bed33SYs7yJSdPHw2feLpgkUkOF9OGTYSmPsUsSgB1z/8m2DZp7iOYg4vmHGGOMsbInz0ERjSc6duxYnta1s7N7n31ijLE8m/fnH5A8qyc6zKUhFUmONzFl/EQ8+WE7LLXdATUgJVWBSCNf/Hr/HG7cVM12U+fMRfPnonu3rvyqM8YYY2VUnoMiW1tbcWGMsZJALpPhz98WwiS0Qfp16jBX2xsju4yE54w9sNR1F8uTFQmIsg/D+F1bERwcorINa2srbFy7GtWqVS2W58AYY4yxUlg+xxhjJUFkVARWzv0LptHpAVGSVgxc2kvRzKoV/OdfhLmuk1geJw3H80oxGL9sIZKSklS2Ua9uHaxbvRKWlhbF8hwYY4wxVnJwUMQYK1W8fTywe9VlmCZUF9fjJC/RaogdKvgnIPrvYBjplBfLXyX54WK5l/jjz7XZtjFwQD/8/sts6Oikj0FijDHGWNnGQRFjrNS4cvUcLv79AibJ6ZmgaAMfDPqqNaT7rkMt1BoSTS2xPEz6BGsS7+HIulMq96cmCrN+nImRwz+DmppasTwHxhhjjJU8HBQxxkqF/Qd3weekBAaK9ExQlOl9jJsyFIF/7oMF3AF1IDUtFWHqjzHd4yg8PD1V7m9sZIRVK5aiRfNmxfQMGGOMMVZScVDEGCvxNmxcgbhbTsqW29Hlb+Db8aPxdPa/yoYK8pRkhBh5Y9y/mxAZGaVyfxdnZ2xcvwZOjg7Fsv+MMcYYK9k4KGKMlWgLF86F1tM60IKGaLmd7HwT43sOwrPfTsBS102skyiPhqfZM0zctAoKhULl/m1at8LyJYt4QlbGGGOM5YqDIsZYiZSiUGDu7/NgHNJQXFeoySCp/RR9HVvi5eqHMJWkz4cWnRyM05InmL9uR7ZtjBvzBaZ9/x00NDQ++P4zxhhjrPTgoIgxVuLExsZgyR/rYRaZHhBJNeNh2zoGtSOtkXQyAfrapmJ5eNJTrI6+hiPnz6rcX0dbG3/O/R19e/cqlv1njDHGWOnCQRFjrEQJDPLHliXHYRZXW1yP1wlHw36mMDsTBp2kilDXUBfLX8oeYKrHYXg99Va5fzlLS2xYtxq1a9Uslv1njDHGWOnDQRFjrMS4c+8GTmzxgmmSq7geoxeA7p9Vh2LrbZhpuwNqQEqqAiFajzD2/Da8ehWpcv+q7lWwacNaWFtZFdMzYIwxxlhpxEERY6xEOH7yAB4eUsBIbiOuRxk/wYiRHRCx8oqyw1yyIgG+hp4Y99cayGRylft37NAeyxYvgJ6eXrHsP2OMMcZKLw6KGGPFbttf6xBxxQp6KYbiepTlLXzRpxvCV92Fua6zWBYnC8cl7UeYvWlrtvt/NW4Mpk75TkzOyhhjjDGWXxwUMcaK1bLl85H2uAa009I/juIrXsOIei0Qtd0HxhJrsSwyKQBbEq7g79MnVe6rpaWFP+f8hv79+hTLvjPGGGPs48BBEWOs2Fpuz/vzTxg+b5R+XU0BtaoP0M+oGpJPJUJfK73DXFiiJ35+dhi3Hj1Wub+ZmSnWr1mFBvXrFcv+M8YYY+zjwUERY+yDS05OxvzflsA0PD0gkmkkwqLJC9QNKQfNQENoaKR/NAUn38OXV3cgNDxc5f5urpVEQ4WKdulzFTHGGGOMvQ8OihhjH1RkVARWzv0LptH1xfVErShU66IOqwupMEpzFB3mUtNS4Ke4hc+PbxYBVGatW7XEymWLYWiYPv6IMcYYY+x9cVDEGPtgAgKfYfuS0zCNry6ux0lC0G6wAzR2PYGFTnqHOXlKMu7JrmLCgewNFUaNHI4fZkyDpiZ/dDHGGGOs8PAvC8bYB3Hv/k0c2+wJkyQXcT3awBd9B9aCdLsHzHWriGWJ8hgcizmDeacPqX5QaWri19mzMHTIYH63GGOMMVboOChijBW502eP4e6/CTCSZcxB9Aif9miE+B3+MNd1FMtipaFY5bcX/967qXJfYyMjrF29Ak2bNOZ3ijHGGGNFgoMixliR+mffdgT+ZwQ9hZm4HmVxC0Mb1IN0XxiMdSqIZRGJfphxbzMePH+ucl9HRwds2bAOTk7pgRNjjDHGWFHgoIgxVmTWb1yOhFsu0EnVFtfjbK9hQDlXpF5MgZ6WsVj2Iv4RRpxdg+iEeJX7UmZo9cplMDUx4XeIMcYYY0WKgyLGWJFYvPhPaHjWhiY0kIpUKFxvo5vUGjq+FtDQ0BDrPIu7hqHH1iE1NVXlvkM/GYxfZv9PTM7KGGOMMVbUOChijBX+pKxz58EwsKG4rlCTQbeWF5o/M4GJmrNouZ2SpsD96HP48sRfKvdVU1PDrB9m4PORw8XfjDHGGGMfAgdFjLEimJQ1PSCSaiTAtmkYKt3Qh4XETSyTpSTh5MvD+PXiUZX76unpYcXSRWjfri2/I4wxxhgre0GRTCbDoUOH8M8//4i/9+3bl+N6VGKzdetWnDx5UpxF7ty5M4YMGZLtjHJhr8cYK8CkrNqRqN0iBeUu6sBM114sS5BHY5P3Lmx/cF3lvuXLl8eWDWtRrVpVfqkZY4wxVvaCopCQENSvXx+NGjWCXC4XAUpuhg8fjjNnzmD27NlISUnB5MmTcfHiRaxZs6ZI12OM5XdS1hdo1UQCo8uaMNK1Fsuik0Pw8+0NuBL4TOW+Vd2rYPPGdbCqkN6JjjHGGGOszAVFpqamuH//PiwsLPDTTz/lGhRdvnwZ27Ztw3///YfWrVuLZXZ2dujatSvGjBmDOnXqFMl6jLH8T8ratZop9G/oQlfHUCwLT/DBuHMrEBQXrXLf9u3aYPmSRdDX1+eXmTHGGGPFRh3FTFdXVwRE70IldVRikxHAkE6dOsHExESl3K6w12OM5e6/c8dxcoM/jJLeTMraw04C4ycm0NVMD4gCY++i39E/sgVEn48YjvVrVnFAxBhjjLFiV+yZorx6/PgxKleurLJMXV0drq6u4raiWi8rqVQqLhliY2OV45OythX+kOix09LSinUfWMlVFMfH3n//QuBZY+grzMX1KIvb6K5lAuOQiuLfEj2eR+QFjDy1WeV+dNvs//2AYZ8NVe4bKz782cH4+GD82cE+5u8W+t3xUQVF0dHRKFeuXLblRkZG4raiWi+rOXPmiDFIWUVFRUGhUKC40EEXFxcnDsC8vvms7Cjs4+OfPdshe1BZOSlrTIUr6BRrBnPtyuktt1PluBB8GNMvH8zWYW7u77+iebMmiIyMfO/9YO+PPzsYHx+MPzvYx/zdkpeKtFIVFGlqaopmCFnRsswTPBb2ellNnz4dkyZNUskU0VgkGhtFAVVxHnzUNY/2o7gPPlbyFObxsXTpfJVJWVMdbqLzCytY6rqK26UpifjHexeW37uocj8rqwrYtH4N3KtUea/HZ4WLPzsYHx+MPztYYSuN3y2lJiiytraGr69vtuUvX74U3euKar2sdHR0xCUresOL+02ng68k7Acrmd73+MhpUlYjl8eo97wiTHUrimXxskgsursOR/w8Ve5bvVpVbNqw9v/t3Qd4VUX6x/FfOiGdGukQqtI7qCCiICiKuqugKKgr/nUR1l7WAi6CCogivVhBERVFEFSkNxEEBAvSBJJQQ0ISEtLv/5nJ5ppLkI0YcpPc7+d5YnLOmRMm947nnPfOzDuKrFq1CP4SFDWuHaB9gGsHPP3eUjpqKdmU3Wauz6lTp1yGrO3atcseu1DlAOQuyjp6xDhnQGQWZa3VcJc6xtZzBkQJp2M0dMVLBQKinldfpU/mfUBABAAASqxSExQNGDDADmt75ZVXnPtGjRqlkJAQ9evX74KVAzydWZR17PBpijj+30VZ/RLUos5BNYttoBD/3HG6R07tVP/FI/VzwnGXcwf/425NnzrJziUCAAAoqUrE8Lnbb79diYmJtpfGLOB63XXX2f0PPfSQunfvbn82SRHmzZtnyy5evNiOVTx48KA++ugjO14xT1GXAzzZ2RZlvbxioqofbyxf39wkC/viv9OAr6cqRw7neT4+Pho54nndMeA2t9UdAACgVAVFAwcOVEZGRoH9jRo1ctnu1auXYmJitGnTJjtO0cz9MescnamoywGeqMCirEH7dLV/uiJPNbXjg3McOdp2ZKkeWDXX5bzg4CBNnfSGrujaxU01BwAAKIVBUY8ePQpd1gzD6dq1a7GXAzxtUdbN85MVmvHfRVlDd6hXVoCqOprblNtZORn6ct/HGrl5qct51atX09uzZqhJY9cPNAAAAEqyEhEUASg5Pp4/WweXhzoXZU0K36TrTldWpcAGdjst65Rm/fCm3tu91eW8Fi2a660Z01SlSmW31BsAAOB8ERQBcJr15iSd2hzlXJQ1K2KD+pyOUnhgbo9RckacRqydoLXHol1etV7X9NSE8WMZfgoAAEolgiIA1muvveKyKGtQxY3qfLqpgstVsMdPpB7QA0vH6cDpZJdX7P77BuupJx4tNesQAAAAnImgCPBwdlHWV15RyMGOzkVZq4dvU6uMtgrwz02lfSjxR9359QSdys50yTA3auQI3d6fFPYAAKB0IygCPFhmRoZeHjleEcdyA6J0n1RdErRTjbPby8fHz+7beWytBi2f5XJeSEiwpk+ZpMsvu9Qt9QYAAChKBEWAhzqZGK83XnpXFRJ+X5S1g2+06nq1tynqTcrtDQcX6ZENn7qcV6N6db3z1gw1atjQTTUHAAAoWgRFgAeKjtmvd1//UhWSm9vtUwGx6uY4pWoBbex2Zk665v80W+N/WutyXquWLfTmjGmqXLmSW+oNAABwIRAUAR5mx09btGjmDoWfzu3pSSm3Rz1y/FW5fFO7fTorWa9vnKTPon91Oe+6a3tp/LgxCixXzi31BgAAuFAIigAPsnrdN/ru45MKTa9ptzPK7VBvRSq8fDW7nZR+TE8uH6sticddzhvywP/p8UcfJsMcAAAokwiKAA+xbMUXilkVrqCs3KFv3uW+V2+fxgryC7fbx1P26b6vX9Wh9BTnOb6+vnpp1H/U75a/u63eAAAAFxpBEeAB3n1vuk5urKVyOblD38ICNqqzXxv5+wTa7YMJ23Tn0olKy8l2nhMWGqrpUyfp0s6d3FZvAACA4kBQBJRxb0wcK8dPzeXn8JVDOarh971alesoH6/c//23H1quwavfczmnVs2aevetmapfP8pNtQYAACg+BEVAGfbKS6MVtL+D/TlLGWrq+4saBXW22zmObC3b/bGe3fKlyzlt27TWrOlTVLFiRbfUGQAAoLgRFAFldFHWV158VeFHcwOiDO8UdfSOUc3gtrnb2WmavXWmpu/53uW8G/pcp3FjXla5cgFuqTcAAIA7EBQBZcyplGSNf3GGKsS3t9tZPid0hU+qM+V2amaiXlo7Xl8fPeBy3rChQ/ToQ8Pswq0AAACehKAIKEMOHYnRm+M+V4Xklnbb4ROtq/yDFBZQz24nph3Wo8vGaUfyCec5fn5+GvPSKP3t5hvdVm8AAAB3IigCyohfdu7Qp9M3KyK1sd32892lKwJqqLxfmN0+mrxb9yx9VXEZac5zwsPDNXPaZHXskNurBAAA4IkIioAyYP3G1Vrz/iGFpde226E+P+rSwCby98lNwb0vbpMGLZuqDEeO85w6dWrr3bdmqV7dOm6rNwAAQElAUASUcouWzNfOxV4Kzqxit6t571Cb4Bby9vKx25sPLtGQ9fNczunQvp3tIYqIiHBLnQEAAEoSgiKgFJv9/iwdXxepwOxAORwONfHZqUahre2xbEeWFv/0vl78cYXLOTff1FevjH5RAQFkmAMAADAIioBSasqU8crcfon8Hb7ycmSpjV+0agQ3t8fSs1M1Y+NUzT64w+WcRx4apn8NHUKGOQAAgHwIioBSaNyYlxSwt6185C0vpahzuVOqFNjQHjuVEa8XVr2q1SdineX9/f004rlndftt/QiIAAAAzkBQBJQi2VlZennUGIUdyl2U1V9xuqy8v0L8a9jt+NRoPfjNOO1NTXSeU6FChGZMnayoenXdVm8AAICSjKAIKEWLsr42apoiTuQGRMFesbosuIoCfMrb7ZiEHbr7mzeUlJ3pPCeqXj2989YM1apZU/Hx8W6rOwAAQElGUASUlkVZX12giKTcJAqVvfapQ0g9+Xj72e2fDq3UvavfVY4cznM6d+qo6VMnKTwsTDk5v6fiBgAAgCuCIqCE2/HzNi2auU0RqU1shrl6PnvVPLSJPZbjyNGKXR/r31uXuJxz6y1/0+iRL8jf399NtQYAACg9CIqAEmzF6i+16eMkhWbUkhw5au53UPWCcwOizJx0zdkyU1P3bHY558nHH9U/77+PhAoAAACFRFAElFDzPnlPMSvCFJRVST6ODLUNOKHI8g3ssdTMJI1d97oWH9nnLG/WHXr91TG67trebqw1AABA6UNQBJRA02ZMUNqWhgpw+CvAcUody2cpPKCWPXYy7bAeWzZOO5JPOMtXqlRRb86YptatWrqx1gAAAKUTQRFQAtcg8t/bVr7yVpDjhDqHBKm8b4Q9diTpV/3jm9cUl5HmLN+oUUO9PXO6atbMTcsNAACAP4egCCghMjMyNGbUOIUdyU25XdHrkDqERsrPO8Bu7z76re5ZOUMZjt8zyXW/spsmTRiv4OBgt9UbAACgtCMoAkqApKREvT56liok5AZENbwPqFVIPXl7eduMcxv2fa6HN33mcs59996jp598XD4+Pm6qNQAAQNlAUAS42YHofZo94WtVSG4phyNHF/tGq2FIfXssOydTn+54R2N/Wecs7+vrq9EvvqD+t97ixloDAACUHQRFgBtt2fadvnrnV4WfbmgzzLUOiFe18rkBUVpWiiZ/O0nzYn5xlg8PD9f0KRPtwqwAAAAoGgRFgJt8tXShti9MV2hGdZXTKXUon63wgJr2WFLaMT23ary+TTjiLF8/KkpvzZqmunXq8J4BAAAUIYIiwA1mvz9Lx9ZVVfnsCgrTCXUMDlE53yB77EjSLt2/7HUdTk91lu96+WWaPHGCwsJCeb8AAACKGEERUMwmTBgj/dJCAQ5fXeR1WG1CqsnHO/d/xZ2H12nw6jddMswNGniHhj/7bzuXCAAAAEWPpyygmGRnZemV0WMUGtvBZpSr7xujS0Lq2mM5jhyt2j1fT235wlneZJV7YfizGnjHAN4jAACAC4igCCiulNsvzVKF+A7ycmSqVUCcapXPDYgystM0e8tMTd/7vbN8aEiIpk5+Q10uv4z3BwAA4AIjKAIusL2/7dbcSStU4VRL+TtS1b58uioG1LLHTmXEa9Sa17T8eLSzfO3atfTOrBmqXz+K9wYAAKAYEBQBF9D6DSu1+sNDCk+rr2AlqGNIOQX5VrHH4k7t14PLX9VvqcnO8p06drAptyMiInhfAAAAiom3Soldu3apXLlyBb7uvvvuAmWPHj2qAQMGqEqVKqpataoGDRqkuLi48y4HnI+P58/WhjmJCkmLVGWvo+oSGq4g39zscfuOb9YtS0a6BEQD7xyg9997m4AIAACgmJWanqKcnBylp6dr48aNat68uctk9PyysrLUs2dP+2D53XffKTs7W3feeaeuvfZabdiwQd7e3n+qHHA+pkx9TRk/NFZAjp/q+MSqWUgteXt52wQL3+3/QsM2fuIsa7LKjXxhuAbc1o8XGwAAwA1KTVCUx9/f3/YQ/ZH58+frhx9+0J49e1Tnv4tcTp8+XU2bNtUXX3yhPn36/KlywJ/NMDduzBiVP9BOvg6HmvofVlRQbvvKysnQ/B/e0au/rneWr1ixgqZPmaQO7dvxQgMAALhJmesOWbp0qerXr6+oqN8nqV9yySWqXr26vv766z9dDiisUynJGj38VQUd6CB/R7o6ByYqKqi2PXY6M0kvrxnjEhBdcnETLf78MwIiAAAANyt1PUVmeFtKSopq166tG264QU888YSCgoKcx/fu3evs+cnP7Nu3b9+fLncmM4TPfOVJSkpyDu8zX+5i/m0zNMuddfBke/f9qnlTVyviVFuFOBLUwSZUqGqPJaTG6vEV47Uj+YSz/HXX9tLYl0erfPnyxfKe0T5A2wDXDnBfQXHJKUHPpYWdElNqgiLzBz3wwAMaPHiwqlWrpvXr1+uf//ynvvrqK/tz3twiEzBFRkYWON88fJpjeQpb7kyjR4/WiBEjCuxPSEiw85TcxTS65ORk2wCZD1W8Nm5arR+/zFB4egNFeh1Wm9CL5OvtZ4/tj9uqwSumKCk701l+yAP/p3vuGqi0tDT7VRxoH6BtgGsHuK+guOSUoOfSSpUqla2gqGHDhpo0aZJz2/QSBQQEqFevXlqyZImuu+46uz8wMPCsD5qnT59WcHCwc7uw5c701FNP6eGHH3bpKapZs6ZN2BAamptZzF2Nz8vLy9bD3Y3Pk8yeM0Nx31ZXUFaYGvkdUuPg3OFyOY4cfbtvoR7e9JmzrOnRfH38WPW4qnux15P2AdoGuHaA+wp47igDQdHZtGuXOzn9t99+c+6rW7euzR53poMHD9qhd3+23JlMIGa+zmQCEXcHIyYoKgn18BTjxr4k/z1tVN6Rpdbl4lQtMDcgysg+rfe3vqmpeza7LMj65oypatSwodvqS/sAbQNcO8B9BTx3nF2pfnrevn27/W56avJ0797drmkUHR3t3GcyzJlgxxz7s+WAM6Wmpmjksy+r3J72CnKkqEtwpqoFVrPHktKP65nlL7oERF27XK5FC+a7NSACAADAH/NymMF+pYCZx2MyxfXo0UPh4eG2l+eee+6x6bm///57Z+9NRkaGmjVrZjPLzZ492w4b6tevn44cOaKtW7faNWH+TLn/xQyfCwsLU2JiotuHz8XHx6tChQr0FF1AB6L36b0JXykiuZEq6pjah1SUv09uivjDiTv1wPI3dDg91Vl+6JAH9MhDwwqsp1XcaB+gbYBrB7ivgOeOMtBTdNddd2n16tVq2bKlnfMzaNAgO69o1apVLsPZzDpGeSm1L7roIpti2yRPMPOO8gc6hS0H5Fmzfpk+GPetwpMaqq53rDqHXeQMiH6IXqabl7ziDIiCg4M0c9oUPf7ow24PiAAAAFBGeoryM1U28yMKU874X2ULW+5s6CnyDHM+eFNH11VSYKa/WgQkqFb5GnZ/Vk6mFv44Wy//vNpZtn5UlGZOm6z69X9fA8vd6CkCbQNcO8B9BTx3/LFS2SVS2OClqMvB82RnZenVV8eq3L42inCkqH1QusL8cwOi1MxEjV8/UQsP73GW73VNT40f+/I5MxgCAACgZCmVQRFQHOIT4jR5zDuKiG+vKjqitmFV5OedO1TzaPIePbxiovamJtptk/HPDJX75/33EWQDAACUMgRFwFl8v3WDvnpvp8JTWqiRX6waB9dxHtses0z/XDdHmf8ddmkSf0yaMN5mmQMAAEDpQ1AEnOGDD9/SoTURqpRZRW0CE1S1XG5AlJmdpk+2v6fXfl3vLHvJxU00Y9pk1cqXFh4AAAClC0ERkG/+0Gvjx8p/XxtVdZxUuxB/BflG2mNJacc0cu0ErY6Ldb5et97yN40c8bwCAwN5DQEAAEoxgiIgb/7Q2LcVHtdOtXwOq0Vodfl45f7vcTD+Bz2wYoriMtPttlkba9R/RuiWv9/MawcAAFAGEBTB423Z9p2+fPcnVUhppmb+R1Q3qLZ9TXIc2Vq393M9tvlz52sUVa+epk2ZqMaNGnr86wYAAFBWEBTBo3047x1Frw7TRZkRaht0WhH+tez+tKxTmvnddM0+uMNZtu8N1+vlUf9RUFCQG2sMAACAokZQBI+dPzRu7BgFHmirejqmVmGR8vP2t8fiUg7oiZUT9FNyvN0O8PfXiOef1e239SPdNgAAQBlEUASPEx2zX29PXKCKCa11if8xRQXl9g4ZO2JW6MH1c5SWk223a9eupWmT3lDTppe4scYAAAC4kAiK4FEWf/mpdixJV4202i7D5dKzU/XRtnc0cfd3zrK9e/XU2JdfUmhoiBtrDAAAgAuNoAge47XXXpHXr83VQKlqFRbiHC53IuWgnl09UVsSj9ttPz8/PfP0k7p70J0MlwMAAPAABEUo8+Lij2nquHdVMa65mvqfUN1zDJerU6e2Jk14TS2aN3NjjQEAAFCcCIpQpn2z/AttWpig2qdrq21wpkL8/ni43N9vvkn/GfGcgoOD3VhjAAAAFDeCIpTZ7HITJoyT1+7maunt0CVhleXt5WOPHUvep2dWT9H25Di7HRISrNEj/6O+N/Rxc60BAADgDgRFKHMORO/Tu5M/10XxTdQq8JSqlqvjXIx10/4lemjjfOXIYfe1btVSEyeMV62aNd1cawAAALgLQRHKlI/nz9a+lf5qnFFFrUPLKcAnwu4/lXFCUzbO1CexO+22l5eXhjzwf3r4X0NtYgUAAAB4LoIilAmZGRl6dew4hRxops7+SaoT/nvPz77jmzV0zSzFZaTZ7Zo1aui1V8eoQ/t2bqwxAAAASgqCIpR6321ep6Uf/qh6yfXUOsRbQb65AVFGdpq++OkDvfzzamfZfrf+XcOf/TfJFAAAAOBEUIRSnUxh0uTxcvzSQJ19gtQgvJrz2NHkPXp+7XRt++/aQxUrVtAro19Uzx5Xu7HGAAAAKIkIilAq/br7J82b9Y3qnayt1kE+CvGrbfdn5WRozZ7P9dSWL5xle159lV4e/aIqVaroxhoDAACgpCIoQqkz681JSv6+ijqpohqGVZW3l7fdfyLloEavn6a1Jw7Z7eDgIA1/7hnd+ve/2cQKAAAAwNkQFKHUiDkUrbcnz1W9uFrqHFROIX6Rdn+2I0ubfvtSj22ar0xHbqrt7ld20+gXX1C1iy5yc60BAABQ0hEUoVR4863JSt4cri7e1VQv39yhhNOH9Nq3M/TV0f12Ozw8XC8Mf1Y33nA9vUMAAAAoFIIilPy5Q299pcbxkbo8uIICfYPs/qycTNs79MTmz5ThyLH7ru19jUaOGK7KlSu5udYAAAAoTQiKUGIzy02dPkH6sbqu9q2mGuHVnceOJe/VqA2z9G38YbtduVIljfzPcF3b6xo31hgAAAClFUERSpwt277Tkjkb1CqlspoEV5Sfd4Ddn5F9Wst2zteIHd84y97W/1Y99cRjiggPd2ONAQAAUJoRFKHEOJWSrMlvTFT1AzXVN7CuwkIjnMeiE3bombVv6deUBLvdpHFjvfTiC2rTprUbawwAAICygKAIJcKcD95U/Drpcu86qhlWw7k/Of2EPtkxV1P3bLbbQUFBevShYbpr0J3y9aX5AgAA4K/jqRJute2HTVo8Z40dKndpUHX5evs5F2HdcmCpntz8qVKzs52JFJ5/9t+k2QYAAECRIiiCWyQlJWrqhImKiq2hm4IaKTgk1HksOn6HXtz4nrYlHrfb9aOi9PyzT6vbFV15twAAAFDkCIpQ7FnlZsyaqKBtwbom8GJVCPs9fXZS+nF9uO0Dzfptq3PNoUceGqoBt/WXn19uDxIAAABQ1AiKUGzen/umUtakq61vNUWGXeTcn5aVog37lmjEti+VlpNtA6BBdw7QsKFDFB4WxjsEAACAC4qgCBfcl18v0N5F+9VClVU7uL68vLzs/sycDP0Uu1rPb/pURzNS7b6ePa7Wv596QvXq1uGdAQAAQLEgKMIF8+2mNdo2e4Oa5dRQn/It5e3lbffnOHK0L26zRm2cq59P5abYbte2jR5/9GF16tiBdwQAAADFiqAIRe6bFUv022c/qqmjhq4N7OjsGTJiE3/RG5s/0Mrj0Xa7RfNmeuyRh9S1y+Uu5QAAAIDiQlCEIrNg0TzFfRmjpj7V1Cuwo3O/w+FQbNLPenPrfC0+ss+5+Opjj/xLV1/VnWAIAAAAbkVQhL9s7tsz5PdduuoHVFOb4HbO/WaYXHTiT5r2/Uda/t+eoQb1o/Twv4bq2t695O2dO5wOAAAAcCeCIpyX+IQ4ffr6dNU6XkVty9dSudDyzmPZjmwdTNiu1zd/pG/jD9t9Hdq30/333asru11BMAQAAIAShaAIf8qqlV8p+pOtivKqpasDL5V3iLdLau09cd9r4tZFduFV0xN03bW9dN+9/1Crli14pQEAAFAiERThfzp0JEZfvfG2aiRUVa3y1RUVdKnL8RNph7Uldq1e3rJUp7IzFRgYqEED79A/7h6kOrVr8woDAACgRPP4oCgzM1M7duywk/2bNWsmX1+Pf0mcw+MWjZ+mKnERql6umq727yqF/t5wsnOyFHtqlz7+cZHmHfzF7mverKn633qLbri+j0JDQ9zUpAEAAIA/x6MjgJUrV6p///4KCwtTTk6OUlNT9eGHH+rSS117QjzFxvWrtGfuKkVmRyoyoKqu9O/iEggZ8WlH9OuJLXp905fan5assNBQ2yvU/5a/65JLLnZX1QEAAIDz5rFB0YkTJ3TjjTfqnnvu0dixY+2+IUOGqG/fvtq7d69CQ8+IBsqY5ORkrVu1XEeXbVLltEqq7F9VVQIqq3r5bgXKJmacUEzSLn3401J9ffg3+fj4qHOnjnrk7zfrmp49FFiunFv+BgAAAKAoeGxQNGfOHKWkpOi5555z7hs+fLimTJlie4vuvfdelSZmLaDMrCz7N2VlZ+t0aqri4xOUcPKk4k6cUPT2bSp/JFUVs0IV4VtJEf4V1NivgpoG9JQCCv6u+PSjOpzym+bvXK7F0XtsINSxQ3u9NORu9bqmhypWrOiuPxUAAAAoUh4bFK1fv15NmzZ16RGqVKmSGjZsaI+VlqAoJiZW/xn8T3WoWl/lfcor0LucAuxXoAJ9ghTqW16RPsFq59tNOsc0n5TMRMWlHVH0qb2auXWZdibFKyIiQt2u6KLJjz+orl0uV1hY2e49AwAAgGfy2KAoJiZGkZGRBfabfbGxsX94Xnp6uv3Kk5SUZL+bOUnmq7h5+3jr2pod1Tqi8POgTJKEkxkndDLjuI6cjtXiPRu1LPo3RUSEq03r1rpl6P/p0k4d1ahRQ5c1hdzx96FomPfO9ADyHoK2Aa4d4L4CT3ru8M73LHsuHhsUZWVlnTXTnNlnMtL9kdGjR2vEiBEF9ickJNjfWdxSU1KVnn26wP6snEydzk7R6awU+z05K1HH0o9qy7G9WvTLdoVUrKj6UfUUVa+urrxyoP7VrKlqVK9us/DlOXnyZDH/NbhQzEXJzCMzF6jCXhzgGWgboH2AawfK8r3FjAQrDI8NikzGOfNmncnsO1sPUp6nnnpKDz/8sEtPUc2aNe1QM3ckZwgICNDC2O91KCNO8RmpistM1aHTp5Xh66MKEREKjwhXRKUIVasWqRrVm2hQjdv1XK2aCg8LK/a6wr0XJxPwmnbq7osTShbaBmgf4NqBolYa7y0eGxQ1adJE8+bNc9lnotndu3erW7eCGdjyByHm60zmDXfHmx4SEqJ3lyyyjS8+Pl4VKlQoNY0PxctcnNzVTlGy0TZA+wDXDnj6vaV01PICMKm3Dx8+rHXr1jn3LVu2zAYW5hgAAAAAz+CxPUVXXHGFbr75Zg0YMMDOEzI9LU888YTd7tChg7urBwAAAKCYeGxQZMydO9euS2TWLDJdfE8//bQGDx7s7moBAAAAKEYeHRSZTHMPPvig/QIAAADgmTx2ThEAAAAAGARFAAAAADwaQREAAAAAj0ZQBAAAAMCjERQBAAAA8GgERQAAAAA8GkERAAAAAI9GUAQAAADAoxEUAQAAAPBovu6uQGnncDjs96SkJLfWIycnR8nJyfL19ZW3N7EuaB/g2gHuLeC5A+6RU8KeS0NCQuTl5XXOMgRFf5F5w42aNWv+1V8FAAAAoIglJiYqNDT0nGW8HHldHTjvSPjQoUOFikAvJNNTZQKz6Ojo//mmw/PQPkDbANcOcF+Bpz53hNBTdOGZLsEaNWqopDANryQ0PpRMtA/QNsC1A9xXwHNHQe4f5AcAAAAAbkRQBAAAAMCjERSVEQEBAXr++eftd4D2Aa4d4N4CnjvgLgGl8LmURAsAAAAAPBo9RQAAAAA8GkERAAAAAI9GUAQAAADAo/m6uwL4a7KysrRo0SLt3LlTkZGR6tu3r8LDw3lZPXAR4ZUrV+qHH35QcHCwLrvsMjVp0uSsZY8ePaoFCxYoISFBLVu2VM+ePYu9vnCfd999V/v27dNtt92mhg0bFji+efNm25b8/f3Vq1cvNWjQwC31RPGKiYnRkiVLlJycrK5du6pNmzYFymRkZOjzzz/X7t277aKM5n5jrjco23766SetXbvWto1GjRqpd+/e8vHxKVAuNjbWtg9Trl27durWrZtb6osL58cff9TChQvtQqhDhgz5w3Lr1q3T+vXrFRgYqOuuu0516tT5S+WKCz1FpVhqaqq96Dz66KP2Afftt9/WxRdfrF27drm7aihG27Ztsw+3gwYN0sGDB7V69Wq1atXKtoszbdiwwd7UzEUtLi5Od911l2666SZlZ2fznnmAFStW6N5779WIESPOep147rnn7DVl//792rJli5o3b26DKJRt06ZNsx+iLF++XMePH9ewYcP0wgsvuJRJTExUp06dbDYp8/OkSZPUrFkze81B2TVy5Ei1bt1aa9as0eHDhzV06FB7fzl58qRLuaVLl9p7y7Jly3TkyBHdcsst9p6EsmH37t1q3769+vXrp/fee08TJ078w7Lm+nHttdfaD1rMM4e5tnz66afnXa5YOVBqPf/8846IiAjH8ePH7XZOTo6jS5cujm7durm7aihGH330keOWW25xpKamOvfNmzfPYf73XrFihXNfdna2o0GDBo7+/fs79+3evdvh5+fnmDVrFu9ZGZeYmOioXbu24+mnn7ZtY+HChS7HN23aZPcvWLDAue+ll15yBAUFOY4dO+aGGqM4LF++3OHt7e1YunSpy/6tW7e6bA8bNsxRrVo1R1JSkt3OzMx0tGrVynHjjTfyRpVRsbGxDi8vL8fYsWOd+44ePeoIDg52PPPMM859aWlpjurVqzvuv/9+l/Zjzv3kk0+Kvd4oegcOHHBs3LjR/jxw4EBHo0aNzlrOXEfMfWTVqlXOfU8++aSjQoUKzmvHnylX3AiKSrGoqCjH4MGDXfbNmTPHNrTo6Gi31QvFKyYmxpGVleWyLyUlxbaD/DezDRs22H2rV692KdurVy/HFVdcUWz1hXsMGjTI0adPH8eOHTvOGhSZh17zYJNffHy8fWCeOnVqMdcWxcV8iNa7d+9zljEfuFWqVMnx+OOPu+yfNGmSw9fX15GQkHCBawl3MPcKc61Yt26dy34TDN96663O7SVLlthy27dvdynXqVMnR9++fYutvigeA88RFJljF198cYGAyrSPuXPn/ulyxY3hc6VUUlKS9u7dqxYtWrjsz9s2Q6rgGapXr15gfLeZW2TUrVvXuc8MhzLO1ma2bt1aLHWFe5hx/mZYwpQpU/6wTN5wufwiIiJUq1Yt2kcZlZaWZueKdO/eXZs2bdIrr7yimTNn2qEy+UVHR9vhtme7dph5rWaeAcoeMxy/fPnydmhTHjO8Mm8oVf5rh6+vry2fH/cWz7Nly5YC1wlzDzFz3fM/ZxS2XHEjKCqlzA3KqFChgsv+vG1z4YJnMpOhzVhdMxH6mmuucWkzJngKDQ0t0GbMHIHMzEw31BYXmrkWmHlEY8aMsQH0HzHt48zriWH2cT0pm8zcD/P/vQmYb731VjtnxCRbaNq0qZ1nlIf7jWeqWLGiPvroI02fPl133HGHHnnkEXXp0sXORX3wwQdd2kdYWFiBD+e4dnieuELeR0rq/Ybsc6WUGfpoeHl5ubsqKGHt4u6779aOHTv0zTff2E/58h+jvXie++67zz7kmsDoXGgfnpm10vj5559t4g3zEGyYZAr/+te/1KdPH1WrVo37jQczn9qbpE4BAQH2/mGyUppst8eOHXN+yMK1A3kK2xZKapuhp6iUqly5sv1+4sQJl/3x8fH2e6VKldxSL7iXyQw0b948ffzxx7r00ksLtBkz1MUMvTyzzZjeIz8/v2KuLS60Q4cO2V4A02s4fPhw+zV58mR77P3339eECRNc2seZ15O89sH1pGzfR6666ipnQGSYXiMztM4MqctfjvuN5w27feaZZzR37lw7rHLs2LH6/vvvbUA0ePBgZznTPkw2ujOzmHLt8DyVC3kfKan3G4KiUso8xEZFRTnnjuTJ2zYpM+FZnn76aU2dOtXewEyayzOZtKrG2dpM3jGULWYNGfOpf2HWfjBtYPv27S77TKp/k3KZ9lE2mbVGzrUOlbd37iOCCarNg8rZrh1mLolJzY2yx8z7MB+W5f+AzbzfZh08ExzlMdcH84Gb6XHMj3uL52ndunWB64S5h5igOf99pLDlip3bUjygSFJym/SFpOSGSZ1ssoSZ7IN/hJTcMP4o+9y5UnKbNLwom1588UV7H4mLi3Pue+655+z7fuTIkQLZCUnJ7TlMFjBzTVi7dq1zn0nF3qJFC5elP0xKbpOunZTcnmFgGU7J7WX+476QDH+FGefbo0cPHT161C7AuXHjRv366692NXqziBo8w+LFi23PkOkdvP76612Ode7c2baRPCaLUK9evXT55ZercePGmjNnjjp27Ggn055thXKUPSZTmPlk3yzga1YQP3Px1vHjx2vgwIFKSUnRBx98YCdZ33nnnW6rLy6s9PR02w727Nmjvn372kxz5ppi3vcBAwY4y5lkLGZhX1PezDVatWqVTcxgFos2WaNQNuec3XzzzXZ+qhlSabJRfvnll/aZwyzWmj97mNm+8cYbbXIf0x7MAp+9e/fWO++849a/AUWXwGnUqFH2588++8wuuDpkyBC7bRbpzT8awQzjN4t+m/0macL8+fPtcG3TPvIrbLniRFBUypkua/NwYyY+RkZG2sZkUhrCc2zevFmLFi0667EzgyLD3NDMRc0MjWrZsqV69uxZIic84sIw8wHMvKLbbrtNDRs2LHDczCMxH6yYYTPmoeZsZVD2Hn7Nw64ZPlm1alVdeeWVql279lkfjBYsWGADqBo1atj7jRmiibLNfJhmEi6YD0pMuzAfwgUFBRUoZx6UzTyk5ORktWvXzrYjlL2g6ExnBkXGunXr7FdgYKD90CX/8iDnU664EBQBAAAA8GgkWgAAAADg0QiKAAAAAHg0giIAAAAAHo2gCAAAAIBHIygCAAAA4NEIigAAAAB4NIIiAAAAAB6NoAgAAACAR/N1dwUAAO5lVhQfP378OctERETozjvv1Ouvv66PP/5Y7vbpp5/ql19+0dNPP22316xZUyLqVlLqcT6WL1+ur776Si+//LK7qwIAxY6gCAA8XO3atdWvXz/n9sKFC/Xuu+/q/fffl5+fn91Xrlw5HThwQJ988oncLSkpSffff7/ee+89576SUrcLXY+VK1dqypQp+vDDD4v8d3fo0EH9+/fXlVdeqZ49exb57weAkoygCAA8XI0aNfS3v/3Nub1//377/cYbb7TBUJ6DBw/qo48+kruZoKBy5cq6+uqrnfu6dOlSIup2oeth3psLFXQFBQXp3nvv1YgRIwiKAHgc5hQBAArdCzJ37lzn9tKlS3XHHXdoz549euGFF+zwuieffFIxMTE6ffq0JkyYYPcNGzZM27dvL/D70tLSNHPmTN19990aOHCg7Z3Kycn5n/WYOnWq/XcLU7fDhw9r5MiRGjRokB1qZ+r2v/yVv+t862ECnQcffLBAXW677TbbO5Q3NG/SpEn2NTJBrPl6/vnnC/16mp9NwPbAAw/onnvu0cSJE+3fk5+p64YNG/TDDz/8z9cJAMoSgiIAwHkNDdu7d68++OAD9ejRQwEBAbriiiv0xRdf6NJLL1W3bt20c+dOde/eXcePH1fHjh3t+fmHwHXq1Mn2SjRt2lTt2rXTs88+q7vuuuucdTC/0/SWmB6ZwtTNlPPy8rJ1++6779S2bVslJiae89/4K3/X+dbDzI9asmRJgbrMnz/f2XNnhjmaIW7m95jhjubLDHUr7OtpgrGhQ4cqKipKXbt2tUFf7969Xf69Ro0a6aKLLjprXQCgLGP4HADgvGVnZ+vtt992BikNGzbU5Zdfbnsxxo0bZ/cNGDBA1apVs/NgHn/8cbvP9MCY4MIEA3Xq1LH7rrrqKvtAb+YLmWDjbLZs2WK/m3KFqZvpOTEBgHHTTTepUqVKWrx4sZ07cyH+rqKuR361atWywZQJivIPdyzs67lgwQI99NBDeuSRR+xx09tlArszNWvWTJs2bSp0vQCgLKCnCABw3vz9/XXZZZc5t+vVq2e/mx6VPD4+PraXI/+QsUWLFtleirwHeKNx48Zq2bKlDRb+yLFjx2zyh+Dg4ELVzQQyeUJDQxUZGano6OgL9ncVdT0KqzCvp+k9mjZtmk1QcejQIbvPzM06U8WKFe3rDACehJ4iAMB5MwGKt/fvn6/l/Zw/QUPe/vzzW+Lj4/Xjjz8W6PGIjY3Vb7/9ds4Aw/S8mN+V/98tTN3OVo+i/ruKuh6FVZjXc8aMGTYoMnONzLwi08v11FNP2XlO+aWnp9vXGQA8CUERAKDYmR4N00uRPxW4YbZNNrxzDSEzwYTpyTC9LWVFYGCgTZSQX3Jysg1Q8jND58739TTzo8ycIvOVlZVls/iZOUdmSF7+4YhHjhxRgwYNivCvA4CSj+FzAIBiZ+a5bN261Q7vysukZr5MoJO3NtLZmGQHppelrM15ufjii+2Qth07djj3jR07tkC5KlWq2J4y0zP0Z19Pk7UvL/Dy9fVV586d7c+pqanO32OCpW3btrkM9wMAT0BPEQCg2JkeCtMj0aZNG9tLER4erl27dtkhXbNmzfrD8yIiImzGNTNPpk+fPiorrrnmGl1//fV2HpMJVsw8JZPc4cwA0SR+MNnjTJlLLrnEvnYm41xhXs99+/bZc00vkOk1+vbbb20wZeYa5Vm1apUNjMrSawsAheHlcDgchSoJAPAI5mHarL9jsqTlnwtjFm816aTz5q2Yh2xTrm/fvs4yZrjXwoUL7cO76dXIs2LFChvQmJ6M/Ewq6c2bN9vzTDrovIQG52J+v8mcZnpWzLCzwtbNMKmmzb9h/q0/8lf+rr9aD7M+kPm7TOBSv359ffrpp2rdurVN6JC/LubfMJnjTFKEvKx2hXk9TRpw06NkAh/TO2WCpvxuv/1224v0zjvvnOMdAICyh6AIAFDqmODE9GY89thj7q5KmbF7927b02SG8OUPwgDAEzB8DgBQ6pi00mbxURQdM1fJ9GAREAHwRPQUAQAAAPBoZJ8DAAAA4NEIigAAAAB4NIIiAAAAAB6NoAgAAACARyMoAgAAAODRCIoAAAAAeDSCIgAAAAAejaAIAAAAgEcjKAIAAADg0QiKAAAAAMiT/T/aVstuB8RkRQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from autoreduce import get_error_metric\n", + "from sympy import latex\n", + "\n", + "TOTAL_RNAP = 1000.0\n", + "TOTAL_RIBOSOME = 1000.0\n", + "TOTAL_RNAASE = 1000.0\n", + "\n", + "unlimited_resource_parameters = {\n", + " **default_parameters,\n", + " P_tot: TOTAL_RNAP,\n", + " R_tot: TOTAL_RIBOSOME,\n", + " E_tot: TOTAL_RNAASE,\n", + "}\n", + "\n", + "conserved_system.set_param_dict(unlimited_resource_parameters)\n", + "\n", + "unlimited_solution = solve_ode(conserved_system, timepoints)\n", + "unlimited_output = (conserved_system.C @ unlimited_solution.T)[0]\n", + "\n", + "fig, ax = plt.subplots(figsize=(8.5, 4.8))\n", + "ax.plot(\n", + " timepoints / 60,\n", + " unlimited_output,\n", + " color=\"#1b1f23\",\n", + " linewidth=2.8,\n", + " label=\"full model\",\n", + ")\n", + "\n", + "unlimited_resource_errors = []\n", + "unlimited_resource_labels = []\n", + "for reduced_model in all_reduced_models:\n", + " reduced_model.set_param_dict(unlimited_resource_parameters)\n", + " reduced_error = get_error_metric(\n", + " conserved_system,\n", + " reduced_model,\n", + " timepoints_ode=timepoints,\n", + " )\n", + " reduced_label = \", \".join(rf\"${latex(state)}$\" for state in reduced_model.x)\n", + " unlimited_resource_errors.append(reduced_error)\n", + " unlimited_resource_labels.append(reduced_label)\n", + " if reduced_error > 5000:\n", + " continue\n", + " reduced_solution = solve_ode(reduced_model, timepoints)\n", + " reduced_output = (reduced_model.C @ reduced_solution.T)[0]\n", + " ax.plot(\n", + " timepoints / 60,\n", + " reduced_output,\n", + " linewidth=1.8,\n", + " label=reduced_label,\n", + " )\n", + "\n", + "ax.set_xlabel(\"Time (in minutes)\")\n", + "ax.set_ylabel(\"Protein $X$\")\n", + "ax.set_title(\"Abundant resources\")\n", + "ax.legend(frameon=False)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "379642b5", + "metadata": {}, + "source": [ + "## Weak ribosome binding strength\n", + "\n", + "Under the condition that the ribosome binds very weakly to the mRNA, we have that $k_{b}$ is very small. In this case, we set $k_{b}=1$ instead of the original value of 100." + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "cdc89d53", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{kb__: 100.0,\n", + " ku_strong_: 0.5,\n", + " ktx_strong_: 3.926187672,\n", + " ktl__: 0.05,\n", + " kdil__: 0.001,\n", + " ku__: 10.0,\n", + " kdeg__rna_degradation_mm: 0.01,\n", + " G_tot: 0.01,\n", + " P_tot: 1000.0,\n", + " R_tot: 1000.0,\n", + " E_tot: 1000.0}" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "conserved_system.params_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "1e38e221", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The error is NaN, something wrong...continuing.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from autoreduce import get_error_metric\n", + "from sympy import latex\n", + "\n", + "TOTAL_RNAP = initial_conditions[\"protein_RNAP\"]\n", + "TOTAL_RIBOSOME = initial_conditions[\"protein_Ribo\"]\n", + "TOTAL_RNAASE = initial_conditions[\"protein_RNase\"]\n", + "\n", + "weak_binding_parameters = {\n", + " **default_parameters,\n", + " P_tot: TOTAL_RNAP,\n", + " R_tot: TOTAL_RIBOSOME,\n", + " E_tot: TOTAL_RNAASE,\n", + " kb: 1.0,\n", + "}\n", + "\n", + "conserved_system.set_param_dict(weak_binding_parameters)\n", + "\n", + "weak_binding_solution = solve_ode(conserved_system, timepoints)\n", + "weak_binding_output = (conserved_system.C @ weak_binding_solution.T)[0]\n", + "\n", + "fig, ax = plt.subplots(figsize=(8.5, 4.8))\n", + "ax.plot(\n", + " timepoints / 60,\n", + " weak_binding_output,\n", + " color=\"#1b1f23\",\n", + " linewidth=2.8,\n", + " label=\"full model\",\n", + ")\n", + "\n", + "weak_binding_errors = []\n", + "weak_binding_labels = []\n", + "for reduced_model in all_reduced_models:\n", + " reduced_model.set_param_dict(weak_binding_parameters)\n", + " reduced_error = get_error_metric(\n", + " conserved_system,\n", + " reduced_model,\n", + " timepoints_ode=timepoints,\n", + " )\n", + " reduced_label = \", \".join(rf\"${latex(state)}$\" for state in reduced_model.x)\n", + " weak_binding_errors.append(reduced_error)\n", + " weak_binding_labels.append(reduced_label)\n", + " if reduced_error > 5000:\n", + " continue\n", + " reduced_solution = solve_ode(reduced_model, timepoints)\n", + " reduced_output = (reduced_model.C @ reduced_solution.T)[0]\n", + " ax.plot(\n", + " timepoints / 60,\n", + " reduced_output,\n", + " linewidth=1.8,\n", + " label=reduced_label,\n", + " )\n", + "\n", + "ax.set_xlabel(\"Time (in minutes)\")\n", + "ax.set_ylabel(\"Protein $X$\")\n", + "ax.set_title(\"Weak binding, $k_b = 1$\")\n", + "ax.legend(frameon=False)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "b4c038dc", + "metadata": {}, + "source": [ + "## Accuracy of the reduced models\n", + "\n", + "Here, we compare the accuracy of the reduced models in representing the desired output: `protein_X`. This can be done in AutoReduce using the `get_error_metric` method. This metric is based on the difference between the output of the full model and the reduced model. " + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "f902be9c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from autoreduce import get_error_metric\n", + "from sympy import latex\n", + "\n", + "accuracy_conditions = [\n", + " (\"limited RNAP\", limited_rnap_parameters),\n", + " (\"abundant resources\", unlimited_resource_parameters),\n", + " (\"weak binding\", weak_binding_parameters),\n", + "]\n", + "accuracy_labels = [\n", + " \", \".join(rf\"${latex(state)}$\" for state in reduced_model.x)\n", + " for reduced_model in all_reduced_models\n", + "]\n", + "accuracy_values = []\n", + "\n", + "for condition_name, condition_parameters in accuracy_conditions:\n", + " condition_errors = []\n", + " conserved_system.set_param_dict(condition_parameters)\n", + " for reduced_model in all_reduced_models:\n", + " reduced_model.set_param_dict(condition_parameters)\n", + " error = get_error_metric(\n", + " conserved_system,\n", + " reduced_model,\n", + " timepoints_ode=timepoints,\n", + " )\n", + " condition_errors.append(error)\n", + " accuracy_values.append(condition_errors)\n", + "\n", + "accuracy_values = np.asarray(accuracy_values)\n", + "models_to_plot = np.all(accuracy_values <= 5000, axis=0)\n", + "accuracy_values = accuracy_values[:, models_to_plot]\n", + "accuracy_labels = [\n", + " label for label, keep_model in zip(accuracy_labels, models_to_plot)\n", + " if keep_model\n", + "]\n", + "model_positions = np.arange(len(accuracy_labels))\n", + "bar_width = 0.26\n", + "\n", + "fig, ax = plt.subplots(figsize=(9.5, 4.8))\n", + "colors = [\"#0072B2\", \"#E69F00\", \"#009E73\"]\n", + "for condition_index, (condition_name, _) in enumerate(accuracy_conditions):\n", + " ax.bar(\n", + " model_positions + bar_width * (condition_index - 1),\n", + " accuracy_values[condition_index],\n", + " width=bar_width,\n", + " color=colors[condition_index],\n", + " label=condition_name,\n", + " )\n", + "\n", + "ax.set_xticks(model_positions)\n", + "ax.set_xticklabels(accuracy_labels, rotation=45, ha=\"right\")\n", + "ax.set_ylabel(\"Output error\")\n", + "ax.set_title(\"Reduced-model accuracy across parameter regimes\")\n", + "ax.legend(frameon=False)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "b90fd1af", + "metadata": {}, + "source": [ + "## Robustness to parametric uncertainties among the possible models" + ] + }, + { + "cell_type": "markdown", + "id": "c0f3f6f3", + "metadata": {}, + "source": [ + "Among all possible models, is there a clear winner in terms of robustness to parametric uncertainties? With AutoReduce, we can compute a robustness metric associated with each reduced model using `get_robustness_metric`. This metric is based on the sensitivity of the output to the parameters. A lower sensitivity indicates that the model is more robust to parametric uncertainties. Let's compute this metric for all the reduced models and see which one is the most robust. " + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "054b3677", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\ayush\\Box\\Research\\autoReduce_HPC\\autoreduce\\solvers\\ode.py:64: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", + " sol = odeint(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SSM Progress: |################----------------------------------| 33.3% Complete\r" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\ayush\\Box\\Research\\autoReduce_HPC\\autoreduce\\solvers\\ssm.py:239: ODEintWarning: Excess work done on this call (perhaps wrong Dfun type). Run with full_output = 1 to get quantitative information.\n", + " sol = odeint(sens_func_ode, S0, timepoints, tfirst=True)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "SSM Progress: |##################################################| 100.0% Complete\n", + "Most robust reduced model: $C_{1}$, $X$\n", + "Sensitivity score: 3.216e+08\n", + "Robustness metric: 7.507e-08\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from autoreduce import get_robustness_metric\n", + "from sympy import latex\n", + "\n", + "robustness_timepoints_ode = np.linspace(0.0, 6000.0, 120)\n", + "robustness_timepoints_ssm = np.linspace(0.0, 6000.0, 8)\n", + "\n", + "conserved_system.set_param_dict(default_parameters)\n", + "\n", + "robustness_labels = []\n", + "sensitivity_scores = []\n", + "robustness_scores = []\n", + "\n", + "for reduced_model in all_reduced_models:\n", + " reduced_model.set_param_dict(default_parameters)\n", + " sensitivities, robustness = get_robustness_metric(\n", + " conserved_system,\n", + " reduced_model,\n", + " timepoints_ode=robustness_timepoints_ode,\n", + " timepoints_ssm=robustness_timepoints_ssm,\n", + " )\n", + " robustness_labels.append(\", \".join(rf\"${latex(state)}$\" for state in reduced_model.x))\n", + " sensitivity_scores.append(np.linalg.norm(sensitivities))\n", + " robustness_scores.append(robustness)\n", + "\n", + "models_to_plot = [\n", + " index for index, score in enumerate(sensitivity_scores)\n", + " if score <= 1e10\n", + "]\n", + "model_order = sorted(models_to_plot, key=lambda index: sensitivity_scores[index])\n", + "ordered_labels = [robustness_labels[index] for index in model_order]\n", + "ordered_sensitivity_scores = [sensitivity_scores[index] for index in model_order]\n", + "ordered_robustness_scores = [robustness_scores[index] for index in model_order]\n", + "\n", + "fig, ax = plt.subplots(figsize=(9.5, 4.8))\n", + "ax.bar(\n", + " np.arange(len(ordered_labels)),\n", + " ordered_sensitivity_scores,\n", + " color=\"#56B4E9\",\n", + ")\n", + "ax.set_xticks(np.arange(len(ordered_labels)))\n", + "ax.set_xticklabels(ordered_labels, rotation=45, ha=\"right\")\n", + "ax.set_ylabel(\"Sensitivity score\")\n", + "ax.set_title(\"Robustness ranking of QSS candidates\")\n", + "plt.tight_layout()\n", + "\n", + "print(f\"Most robust reduced model: {ordered_labels[0]}\")\n", + "print(f\"Sensitivity score: {ordered_sensitivity_scores[0]:.4g}\")\n", + "print(f\"Robustness metric: {ordered_robustness_scores[0]:.4g}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "bdf6735b", + "metadata": {}, + "outputs": [], + "source": [ + "# end" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "autoreduce", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/biological/Toggle switch.ipynb b/examples/biological/Toggle switch.ipynb new file mode 100644 index 0000000..713b209 --- /dev/null +++ b/examples/biological/Toggle switch.ipynb @@ -0,0 +1,1088 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "toggle-switch-00", + "metadata": {}, + "source": [ + "# Toggle Switch\n", + "\n", + "In this example notebook, we build a bistable toggle switch model with BioCRNpyler, export it to SBML, and load the SBML model into AutoReduce to obtain a reduced model that is suitable for design and analysis.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "toggle-switch-01", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import numpy as np\n", + "from autoreduce import load_sbml, solve_ode" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "toggle-switch-02", + "metadata": {}, + "outputs": [], + "source": [ + "from biocrnpyler import Species\n", + "from biocrnpyler.components import DNAassembly, RegulatedPromoter, DNABindingSite\n", + "from biocrnpyler.mechanisms.global_mechanisms import Dilution\n", + "from biocrnpyler.mixtures import SimpleTxTlExtract\n", + "\n", + "parameter_file = Path(\"models/design1_parameters.tsv\")\n", + "sbml_file = Path(\"models/design1_regulated_promoter.xml\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "toggle-switch-03", + "metadata": {}, + "source": [ + "## Build bistable toggle switch model using BioCRNpyler\n", + "\n", + "The design has two regulated promoters. Each promoter has one activating regulator and one repressing regulator, and the resulting CRN is exported as SBML for AutoReduce.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "toggle-switch-04", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Species(N = 12) = {\n", + " dna[D2] (@ 1.0), \n", + " dna[D1] (@ 1.0), \n", + " rna[m2] (@ 0), \n", + " rna[m1] (@ 0), \n", + " complex[dna[D2]:protein[R1]] (@ 0), \n", + " complex[dna[D2]:protein[A2]] (@ 0), \n", + " complex[dna[D1]:protein[R2]] (@ 0), \n", + " complex[dna[D1]:protein[A1]] (@ 0), \n", + " protein[R2] (@ 0), \n", + " protein[R1] (@ 0), \n", + " protein[A2] (@ 0), \n", + " protein[A1] (@ 0), \n", + "}\n", + "\n", + "Reactions (16) = [\n", + "0. dna[D1] --> dna[D1]+rna[m1]\n", + " Kf=k_forward * dna_D1\n", + " k_forward=0.25\n", + " found_key=(mech=transcription, partid=p1_leak, name=ktx).\n", + " search_key=(mech=simple_transcription, partid=['p1_leak', None], name=ktx).\n", + "\n", + "1. protein[A1]+dna[D1] <--> complex[dna[D1]:protein[A1]]\n", + " Kf=k_forward * protein_A1 * dna_D1\n", + " Kr=k_reverse * complex_dna_D1_protein_A1_\n", + " k_forward=1.0\n", + " found_key=(mech=one_step_cooperative_binding, partid=p1_A1, name=kb).\n", + " search_key=(mech=one_step_cooperative_binding, partid=['p1_A1', 'dna_protein', None], name=kb).\n", + " k_reverse=1.0\n", + " found_key=(mech=one_step_cooperative_binding, partid=p1_A1, name=ku).\n", + " search_key=(mech=one_step_cooperative_binding, partid=['p1_A1', 'dna_protein', None], name=ku).\n", + "\n", + "2. complex[dna[D1]:protein[A1]] --> complex[dna[D1]:protein[A1]]+rna[m1]\n", + " Kf=k_forward * complex_dna_D1_protein_A1_\n", + " k_forward=2.0\n", + " found_key=(mech=transcription, partid=p1_A1, name=ktx).\n", + " search_key=(mech=simple_transcription, partid=['p1_A1', None], name=ktx).\n", + "\n", + "3. rna[m1] --> rna[m1]+protein[A1]+protein[R1]\n", + " Kf=k_forward * rna_m1\n", + " k_forward=5.0\n", + " found_key=(mech=simple_translation, partid=utr1, name=ktl).\n", + " search_key=(mech=simple_translation, partid=['utr1', None], name=ktl).\n", + "\n", + "4. dna[D2] --> dna[D2]+rna[m2]\n", + " Kf=k_forward * dna_D2\n", + " k_forward=0.25\n", + " found_key=(mech=transcription, partid=p2_leak, name=ktx).\n", + " search_key=(mech=simple_transcription, partid=['p2_leak', None], name=ktx).\n", + "\n", + "5. protein[A2]+dna[D2] <--> complex[dna[D2]:protein[A2]]\n", + " Kf=k_forward * protein_A2 * dna_D2\n", + " Kr=k_reverse * complex_dna_D2_protein_A2_\n", + " k_forward=1.0\n", + " found_key=(mech=one_step_cooperative_binding, partid=p2_A2, name=kb).\n", + " search_key=(mech=one_step_cooperative_binding, partid=['p2_A2', 'dna_protein', None], name=kb).\n", + " k_reverse=1.0\n", + " found_key=(mech=one_step_cooperative_binding, partid=p2_A2, name=ku).\n", + " search_key=(mech=one_step_cooperative_binding, partid=['p2_A2', 'dna_protein', None], name=ku).\n", + "\n", + "6. complex[dna[D2]:protein[A2]] --> complex[dna[D2]:protein[A2]]+rna[m2]\n", + " Kf=k_forward * complex_dna_D2_protein_A2_\n", + " k_forward=2.0\n", + " found_key=(mech=transcription, partid=p2_A2, name=ktx).\n", + " search_key=(mech=simple_transcription, partid=['p2_A2', None], name=ktx).\n", + "\n", + "7. rna[m2] --> rna[m2]+protein[A2]+protein[R2]\n", + " Kf=k_forward * rna_m2\n", + " k_forward=5.0\n", + " found_key=(mech=simple_translation, partid=utr1, name=ktl).\n", + " search_key=(mech=simple_translation, partid=['utr1', None], name=ktl).\n", + "\n", + "8. protein[R2]+dna[D1] <--> complex[dna[D1]:protein[R2]]\n", + " Kf=k_forward * protein_R2 * dna_D1\n", + " Kr=k_reverse * complex_dna_D1_protein_R2_\n", + " k_forward=1.0\n", + " found_key=(mech=one_step_cooperative_binding, partid=R2, name=kb).\n", + " search_key=(mech=one_step_cooperative_binding, partid=['R2', 'dna_protein', None], name=kb).\n", + " k_reverse=1.0\n", + " found_key=(mech=one_step_cooperative_binding, partid=R2, name=ku).\n", + " search_key=(mech=one_step_cooperative_binding, partid=['R2', 'dna_protein', None], name=ku).\n", + "\n", + "9. protein[R1]+dna[D2] <--> complex[dna[D2]:protein[R1]]\n", + " Kf=k_forward * protein_R1 * dna_D2\n", + " Kr=k_reverse * complex_dna_D2_protein_R1_\n", + " k_forward=1.0\n", + " found_key=(mech=one_step_cooperative_binding, partid=R1, name=kb).\n", + " search_key=(mech=one_step_cooperative_binding, partid=['R1', 'dna_protein', None], name=kb).\n", + " k_reverse=1.0\n", + " found_key=(mech=one_step_cooperative_binding, partid=R1, name=ku).\n", + " search_key=(mech=one_step_cooperative_binding, partid=['R1', 'dna_protein', None], name=ku).\n", + "\n", + "10. protein[R2] --> \n", + " Kf=k_forward * protein_R2\n", + " k_forward=1.0\n", + " found_key=(mech=protein_degradation, partid=protein_R2, name=kdil).\n", + " search_key=(mech=protein_degradation, partid=['protein_R2', None], name=kdil).\n", + "\n", + "11. protein[A2] --> \n", + " Kf=k_forward * protein_A2\n", + " k_forward=1.0\n", + " found_key=(mech=protein_degradation, partid=protein_A2, name=kdil).\n", + " search_key=(mech=protein_degradation, partid=['protein_A2', None], name=kdil).\n", + "\n", + "12. protein[R1] --> \n", + " Kf=k_forward * protein_R1\n", + " k_forward=1.0\n", + " found_key=(mech=protein_degradation, partid=protein_R1, name=kdil).\n", + " search_key=(mech=protein_degradation, partid=['protein_R1', None], name=kdil).\n", + "\n", + "13. protein[A1] --> \n", + " Kf=k_forward * protein_A1\n", + " k_forward=1.0\n", + " found_key=(mech=protein_degradation, partid=protein_A1, name=kdil).\n", + " search_key=(mech=protein_degradation, partid=['protein_A1', None], name=kdil).\n", + "\n", + "14. rna[m1] --> \n", + " Kf=k_forward * rna_m1\n", + " k_forward=1.0\n", + " found_key=(mech=rna_degradation, partid=rna_m1, name=kdil).\n", + " search_key=(mech=rna_degradation, partid=['rna_m1', None], name=kdil).\n", + "\n", + "15. rna[m2] --> \n", + " Kf=k_forward * rna_m2\n", + " k_forward=1.0\n", + " found_key=(mech=rna_degradation, partid=rna_m2, name=kdil).\n", + " search_key=(mech=rna_degradation, partid=['rna_m2', None], name=kdil).\n", + "\n", + "]\n", + "SBML written to models\\design1_regulated_promoter.xml\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\ayush\\anaconda3\\envs\\autoreduce\\Lib\\site-packages\\biocrnpyler\\mechanisms\\global_mechanisms.py:204: UserWarning: species complex_dna_D1_protein_R2_ has multiple attributes (or material type) which conflict with global mechanism filter {repr(self)}. Using default value False.\n", + " warn(\n", + "c:\\Users\\ayush\\anaconda3\\envs\\autoreduce\\Lib\\site-packages\\biocrnpyler\\mechanisms\\global_mechanisms.py:204: UserWarning: species complex_dna_D2_protein_A2_ has multiple attributes (or material type) which conflict with global mechanism filter {repr(self)}. Using default value False.\n", + " warn(\n", + "c:\\Users\\ayush\\anaconda3\\envs\\autoreduce\\Lib\\site-packages\\biocrnpyler\\mechanisms\\global_mechanisms.py:204: UserWarning: species complex_dna_D1_protein_A1_ has multiple attributes (or material type) which conflict with global mechanism filter {repr(self)}. Using default value False.\n", + " warn(\n", + "c:\\Users\\ayush\\anaconda3\\envs\\autoreduce\\Lib\\site-packages\\biocrnpyler\\mechanisms\\global_mechanisms.py:204: UserWarning: species complex_dna_D2_protein_R1_ has multiple attributes (or material type) which conflict with global mechanism filter {repr(self)}. Using default value False.\n", + " warn(\n" + ] + } + ], + "source": [ + "A1 = Species(\"A1\", material_type=\"protein\")\n", + "A2 = Species(\"A2\", material_type=\"protein\")\n", + "R1 = Species(\"R1\", material_type=\"protein\")\n", + "R2 = Species(\"R2\", material_type=\"protein\")\n", + "\n", + "# Activator promoter only:\n", + "# gives D1 leak transcription and A1-bound transcription.\n", + "p1 = RegulatedPromoter(\n", + " name=\"p1\",\n", + " regulators=[A1],\n", + " leak=True,\n", + ")\n", + "\n", + "# gives D2 leak transcription and A2-bound transcription.\n", + "p2 = RegulatedPromoter(\n", + " name=\"p2\",\n", + " regulators=[A2],\n", + " leak=True,\n", + ")\n", + "\n", + "D1 = DNAassembly(\n", + " name=\"D1\",\n", + " promoter=p1,\n", + " rbs=\"utr1\",\n", + " transcript=\"m1\",\n", + " protein=[A1, R1],\n", + ")\n", + "\n", + "D2 = DNAassembly(\n", + " name=\"D2\",\n", + " promoter=p2,\n", + " rbs=\"utr1\",\n", + " transcript=\"m2\",\n", + " protein=[A2, R2],\n", + ")\n", + "\n", + "# Repressor binding only, no transcription.\n", + "# This gives R2 + D1 <--> D1:R2 and R1 + D2 <--> D2:R1.\n", + "R2_binds_D1 = DNABindingSite(\n", + " name=\"R2_binds_D1\",\n", + " binders=R2,\n", + ")\n", + "R2_binds_D1.dna_to_bind = D1.dna\n", + "\n", + "R1_binds_D2 = DNABindingSite(\n", + " name=\"R1_binds_D2\",\n", + " binders=R1,\n", + ")\n", + "R1_binds_D2.dna_to_bind = D2.dna\n", + "\n", + "protein_degradation = Dilution(\n", + " name=\"protein_degradation\",\n", + " filter_dict={\"protein\": True, \"complex\": False},\n", + " default_on=False,\n", + ")\n", + "\n", + "mixture = SimpleTxTlExtract(\n", + " name=\"Design1_RegulatedPromoter\",\n", + " components=[D1, D2, R2_binds_D1, R1_binds_D2],\n", + " parameter_file=str(parameter_file),\n", + " overwrite_parameters=True,\n", + " global_mechanisms={\n", + " \"protein_degradation\": protein_degradation,\n", + " },\n", + ")\n", + "\n", + "initial_conditions = {\n", + " D1.dna: 1.0,\n", + " D2.dna: 1.0,\n", + "}\n", + "\n", + "crn = mixture.compile_crn(initial_concentration_dict=initial_conditions)\n", + "\n", + "print(crn.pretty_print(show_rates=True, show_keys=True))\n", + "\n", + "crn.write_sbml_file(sbml_file)\n", + "print(f\"SBML written to {sbml_file}\")" + ] + }, + { + "cell_type": "markdown", + "id": "toggle-switch-05", + "metadata": {}, + "source": [ + "## Load the SBML model into AutoReduce\n", + "\n", + "Using `load_sbml`, we can load the SBML model into AutoReduce. The function returns a `System` object that contains the state variables, parameters, and equations of the system." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "toggle-switch-06", + "metadata": {}, + "outputs": [], + "source": [ + "sbml_file = \"models/design1_regulated_promoter.xml\"\n", + "\n", + "sys0 = load_sbml(\n", + " sbml_file,\n", + " outputs=[\"protein_A1\", \"protein_A2\"],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "toggle-switch-07", + "metadata": {}, + "source": [ + "## Inspect the imported SBML\n", + "\n", + "The state names come from the SBML species IDs generated by BioCRNpyler. Inspecting them makes it easier to choose outputs or reduction assumptions in later cells.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "toggle-switch-08", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Full model states:\n", + " dna_D1\n", + " rna_m1\n", + " protein_A1\n", + " protein_R1\n", + " complex_dna_D1_protein_A1_\n", + " dna_D2\n", + " rna_m2\n", + " protein_A2\n", + " protein_R2\n", + " complex_dna_D2_protein_A2_\n", + " complex_dna_D1_protein_R2_\n", + " complex_dna_D2_protein_R1_\n" + ] + } + ], + "source": [ + "print(\"Full model states:\")\n", + "for x in sys0.x:\n", + " print(\" \", x)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "885c2cd8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Full model parameters:\n", + " ktx_p1_leak_transcription: 0.25\n", + " kb_p1_A1_one_step_cooperative_binding: 1.0\n", + " ku_p1_A1_one_step_cooperative_binding: 1.0\n", + " ktx_p1_A1_transcription: 2.0\n", + " ktl_utr1_simple_translation: 5.0\n", + " ktx_p2_leak_transcription: 0.25\n", + " kb_p2_A2_one_step_cooperative_binding: 1.0\n", + " ku_p2_A2_one_step_cooperative_binding: 1.0\n", + " ktx_p2_A2_transcription: 2.0\n", + " kb_R2_one_step_cooperative_binding: 1.0\n", + " ku_R2_one_step_cooperative_binding: 1.0\n", + " kb_R1_one_step_cooperative_binding: 1.0\n", + " ku_R1_one_step_cooperative_binding: 1.0\n", + " kdil_protein_R2_protein_degradation: 1.0\n", + " kdil_protein_A2_protein_degradation: 1.0\n", + " kdil_protein_R1_protein_degradation: 1.0\n", + " kdil_protein_A1_protein_degradation: 1.0\n", + " kdil_rna_m1_rna_degradation: 1.0\n", + " kdil_rna_m2_rna_degradation: 1.0\n" + ] + } + ], + "source": [ + "print(\"\\nFull model parameters:\")\n", + "for p, v in zip(sys0.params, sys0.params_values):\n", + " print(f\" {p}: {v}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "887c3f3c", + "metadata": {}, + "source": [ + "### Rename species and parameters\n", + "For simpler names and to avoid long Sympy names, we rename the (long) BioCRNpyler-generated species and parameters to shorter names. We start by creating sympy symbols." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8ec5a233", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Renamed full system:\n", + "dD1/dt =\n", + "-A₁⋅D₁⋅kb₁ + C_A1_D1⋅ku₁ + C_R2_D1⋅ku_R2 - D₁⋅R₂⋅kb_R2\n", + "\n", + "dm1/dt =\n", + "C_A1_D1⋅ktx₁ + D₁⋅ktx₀ ₁ - kdilₘ₁⋅m₁\n", + "\n", + "dA1/dt =\n", + "-A₁⋅D₁⋅kb₁ - A₁⋅kdil_A1 + C_A1_D1⋅ku₁ + ktl₁⋅m₁\n", + "\n", + "dR1/dt =\n", + "C_R1_D2⋅ku_R1 - D₂⋅R₁⋅kb_R1 - R₁⋅kdil_R1 + ktl₁⋅m₁\n", + "\n", + "dC_A1_D1/dt =\n", + "A₁⋅D₁⋅kb₁ - C_A1_D1⋅ku₁\n", + "\n", + "dD2/dt =\n", + "-A₂⋅D₂⋅kb₂ + C_A2_D2⋅ku₂ + C_R1_D2⋅ku_R1 - D₂⋅R₁⋅kb_R1\n", + "\n", + "dm2/dt =\n", + "C_A2_D2⋅ktx₂ + D₂⋅ktx₀ ₂ - kdilₘ₂⋅m₂\n", + "\n", + "dA2/dt =\n", + "-A₂⋅D₂⋅kb₂ - A₂⋅kdil_A2 + C_A2_D2⋅ku₂ + ktl₁⋅m₂\n", + "\n", + "dR2/dt =\n", + "C_R2_D1⋅ku_R2 - D₁⋅R₂⋅kb_R2 - R₂⋅kdil_R2 + ktl₁⋅m₂\n", + "\n", + "dC_A2_D2/dt =\n", + "A₂⋅D₂⋅kb₂ - C_A2_D2⋅ku₂\n", + "\n", + "dC_R2_D1/dt =\n", + "-C_R2_D1⋅ku_R2 + D₁⋅R₂⋅kb_R2\n", + "\n", + "dC_R1_D2/dt =\n", + "-C_R1_D2⋅ku_R1 + D₂⋅R₁⋅kb_R1\n", + "\n" + ] + } + ], + "source": [ + "from sympy import symbols, Symbol, simplify, pprint\n", + "\n", + "D1, D2 = symbols(\"D1 D2\")\n", + "m1, m2 = symbols(\"m1 m2\")\n", + "A1, A2 = symbols(\"A1 A2\")\n", + "R1, R2 = symbols(\"R1 R2\")\n", + "C_A1_D1, C_R2_D1, C_A2_D2, C_R1_D2 = symbols(\n", + " \"C_A1_D1 C_R2_D1 C_A2_D2 C_R1_D2\"\n", + ")\n", + "\n", + "ktx0_1, kb_1, ku_1, ktx_1, ktl_1 = symbols(\n", + " \"ktx0_1 kb_1 ku_1 ktx_1 ktl_1\"\n", + ")\n", + "ktx0_2, kb_2, ku_2, ktx_2 = symbols(\n", + " \"ktx0_2 kb_2 ku_2 ktx_2\"\n", + ")\n", + "\n", + "kb_R1, ku_R1, kb_R2, ku_R2 = symbols(\n", + " \"kb_R1 ku_R1 kb_R2 ku_R2\"\n", + ")\n", + "\n", + "kdil_R1, kdil_A1, kdil_R2, kdil_A2 = symbols(\n", + " \"kdil_R1 kdil_A1 kdil_R2 kdil_A2\"\n", + ")\n", + "\n", + "kdil_m1, kdil_m2 = symbols(\"kdil_m1 kdil_m2\")\n", + "\n", + "\n", + "state_rename = {\n", + " Symbol(\"dna_D1\"): D1,\n", + " Symbol(\"dna_D2\"): D2,\n", + " Symbol(\"rna_m1\"): m1,\n", + " Symbol(\"rna_m2\"): m2,\n", + " Symbol(\"protein_A1\"): A1,\n", + " Symbol(\"protein_A2\"): A2,\n", + " Symbol(\"protein_R1\"): R1,\n", + " Symbol(\"protein_R2\"): R2,\n", + " Symbol(\"complex_dna_D1_protein_A1_\"): C_A1_D1,\n", + " Symbol(\"complex_dna_D1_protein_R2_\"): C_R2_D1,\n", + " Symbol(\"complex_dna_D2_protein_A2_\"): C_A2_D2,\n", + " Symbol(\"complex_dna_D2_protein_R1_\"): C_R1_D2,\n", + "}\n", + "\n", + "params_rename = {\n", + " Symbol(\"ktx_p1_leak_transcription\"): ktx0_1,\n", + " Symbol(\"kb_p1_A1_one_step_cooperative_binding\"): kb_1,\n", + " Symbol(\"ku_p1_A1_one_step_cooperative_binding\"): ku_1,\n", + " Symbol(\"ktx_p1_A1_transcription\"): ktx_1,\n", + " Symbol(\"ktl_utr1_simple_translation\"): ktl_1,\n", + " Symbol(\"ktx_p2_leak_transcription\"): ktx0_2,\n", + " Symbol(\"kb_p2_A2_one_step_cooperative_binding\"): kb_2,\n", + " Symbol(\"ku_p2_A2_one_step_cooperative_binding\"): ku_2,\n", + " Symbol(\"ktx_p2_A2_transcription\"): ktx_2,\n", + " Symbol(\"kb_R2_one_step_cooperative_binding\"): kb_R2,\n", + " Symbol(\"ku_R2_one_step_cooperative_binding\"): ku_R2,\n", + " Symbol(\"kb_R1_one_step_cooperative_binding\"): kb_R1,\n", + " Symbol(\"ku_R1_one_step_cooperative_binding\"): ku_R1,\n", + " Symbol(\"kdil_protein_R1_protein_degradation\"): kdil_R1,\n", + " Symbol(\"kdil_protein_A1_protein_degradation\"): kdil_A1,\n", + " Symbol(\"kdil_protein_R2_protein_degradation\"): kdil_R2,\n", + " Symbol(\"kdil_protein_A2_protein_degradation\"): kdil_A2,\n", + " Symbol(\"kdil_rna_m2_rna_degradation\"): kdil_m2,\n", + " Symbol(\"kdil_rna_m1_rna_degradation\"): kdil_m1\n", + "}\n", + "\n", + "sys0.x = [state_rename.get(x, x) for x in sys0.x]\n", + "sys0.params = [params_rename.get(p, p) for p in sys0.params]\n", + "sys0.f = [simplify(fi.xreplace(state_rename)) for fi in sys0.f]\n", + "sys0.f = [simplify(fi.xreplace(params_rename)) for fi in sys0.f]\n", + "\n", + "print(\"\\nRenamed full system:\")\n", + "for x, fi in zip(sys0.x, sys0.f):\n", + " print(f\"d{x}/dt =\")\n", + " pprint(simplify(fi))\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "id": "485ecb0c", + "metadata": {}, + "source": [ + "## Apply conservation laws\n", + "\n", + "The `solve_conservation_laws` function can be used to eliminate conserved species from the system. This AutoReduce method can find the conserved sets automatically by performing a combinatorial search over the stoichiometry matrix. The user can also specify the conserved sets manually, as we do here for the toggle switch model. The conserved species are the DNA species, which are not degraded in the system. The total amount of each DNA species is conserved. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bb425d66", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found conservation laws: [C_A1_D1 + C_R2_D1 + D1 - D1_tot, C_A2_D2 + C_R1_D2 + D2 - D2_tot]\n", + "States after DNA conservation laws:\n", + " m1\n", + " A1\n", + " R1\n", + " C_A1_D1\n", + " m2\n", + " A2\n", + " R2\n", + " C_A2_D2\n", + " C_R2_D1\n", + " C_R1_D2\n", + "\n", + "Dynamics after DNA conservation laws:\n", + "dm1/dt =\n", + "C_A1_D1⋅ktx₁ - kdilₘ₁⋅m₁ - ktx₀ ₁⋅(C_A1_D1 + C_R2_D1 - D₁ ₜₒₜ)\n", + "\n", + "dA1/dt =\n", + "A₁⋅kb₁⋅(C_A1_D1 + C_R2_D1 - D₁ ₜₒₜ) - A₁⋅kdil_A1 + C_A1_D1⋅ku₁ + ktl₁⋅m₁\n", + "\n", + "dR1/dt =\n", + "C_R1_D2⋅ku_R1 + R₁⋅kb_R1⋅(C_A2_D2 + C_R1_D2 - D₂ ₜₒₜ) - R₁⋅kdil_R1 + ktl₁⋅m₁\n", + "\n", + "dC_A1_D1/dt =\n", + "-A₁⋅kb₁⋅(C_A1_D1 + C_R2_D1 - D₁ ₜₒₜ) - C_A1_D1⋅ku₁\n", + "\n", + "dm2/dt =\n", + "C_A2_D2⋅ktx₂ - kdilₘ₂⋅m₂ - ktx₀ ₂⋅(C_A2_D2 + C_R1_D2 - D₂ ₜₒₜ)\n", + "\n", + "dA2/dt =\n", + "A₂⋅kb₂⋅(C_A2_D2 + C_R1_D2 - D₂ ₜₒₜ) - A₂⋅kdil_A2 + C_A2_D2⋅ku₂ + ktl₁⋅m₂\n", + "\n", + "dR2/dt =\n", + "C_R2_D1⋅ku_R2 + R₂⋅kb_R2⋅(C_A1_D1 + C_R2_D1 - D₁ ₜₒₜ) - R₂⋅kdil_R2 + ktl₁⋅m₂\n", + "\n", + "dC_A2_D2/dt =\n", + "-A₂⋅kb₂⋅(C_A2_D2 + C_R1_D2 - D₂ ₜₒₜ) - C_A2_D2⋅ku₂\n", + "\n", + "dC_R2_D1/dt =\n", + "-C_R2_D1⋅ku_R2 - R₂⋅kb_R2⋅(C_A1_D1 + C_R2_D1 - D₁ ₜₒₜ)\n", + "\n", + "dC_R1_D2/dt =\n", + "-C_R1_D2⋅ku_R1 - R₁⋅kb_R1⋅(C_A2_D2 + C_R1_D2 - D₂ ₜₒₜ)\n", + "\n" + ] + } + ], + "source": [ + "from autoreduce import solve_conservation_laws\n", + "\n", + "D1_tot, D2_tot = symbols(\"D1_tot D2_tot\")\n", + "\n", + "\n", + "sys_cons = solve_conservation_laws(\n", + " sys0,\n", + " total_quantities={\n", + " \"D1_tot\": 1.0,\n", + " \"D2_tot\": 1.0,\n", + " },\n", + " conserved_sets=[\n", + " [D1, C_A1_D1, C_R2_D1],\n", + " [D2, C_A2_D2, C_R1_D2],\n", + " ],\n", + " states_to_eliminate=[D1, D2],\n", + " debug=True,\n", + ")\n", + "\n", + "sys_cons.f = [simplify(fi) for fi in sys_cons.f]\n", + "\n", + "print(\"States after DNA conservation laws:\")\n", + "for x in sys_cons.x:\n", + " print(\" \", x)\n", + "\n", + "print(\"\\nDynamics after DNA conservation laws:\")\n", + "for x, fi in zip(sys_cons.x, sys_cons.f):\n", + " print(f\"d{x}/dt =\")\n", + " pprint(simplify(fi))\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "id": "c303f500", + "metadata": {}, + "source": [ + "## Apply quasi-steady state assumptions\n", + "\n", + "Some species, such as mRNA, degrade much faster than others, such as proteins. We can apply quasi-steady state assumptions to eliminate the fast species from the system. The `solve_timescale_separation` function can be used to eliminate fast species from the system. This AutoReduce method can find *all possible combinations* of fast species automatically by performing a combinatorial search over the system state-space and symbolically finding out whether a feasible solution is obtained. The user can also specify the fast species manually, as we do here for the toggle switch model. The fast species, as a first step, are the complex formations between the activator, repressor, and the DNA." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4ecf354a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Successful solution obtained with states: [m1, A1, R1, m2, A2, R2]!\n", + "Six-state reduced system after promoter-complex QSS:\n", + "dm1/dt =\n", + "A₁⋅D₁ ₜₒₜ⋅kb₁⋅ktx₁⋅ku_R2 - A₁⋅kb₁⋅kdilₘ₁⋅ku_R2⋅m₁ + D₁ ₜₒₜ⋅ktx₀ ₁⋅ku₁⋅ku_R2 - ↪\n", + "────────────────────────────────────────────────────────────────────────────── ↪\n", + " A₁⋅kb₁⋅ku_R2 + R₂⋅kb_R2⋅ku₁ + ku₁⋅ku_ ↪\n", + "\n", + "↪ R₂⋅kb_R2⋅kdilₘ₁⋅ku₁⋅m₁ - kdilₘ₁⋅ku₁⋅ku_R2⋅m₁\n", + "↪ ────────────────────────────────────────────\n", + "↪ R2 \n", + "\n", + "dA1/dt =\n", + "-A₁⋅kdil_A1 + ktl₁⋅m₁\n", + "\n", + "dR1/dt =\n", + "-R₁⋅kdil_R1 + ktl₁⋅m₁\n", + "\n", + "dm2/dt =\n", + "A₂⋅D₂ ₜₒₜ⋅kb₂⋅ktx₂⋅ku_R1 - A₂⋅kb₂⋅kdilₘ₂⋅ku_R1⋅m₂ + D₂ ₜₒₜ⋅ktx₀ ₂⋅ku₂⋅ku_R1 - ↪\n", + "────────────────────────────────────────────────────────────────────────────── ↪\n", + " A₂⋅kb₂⋅ku_R1 + R₁⋅kb_R1⋅ku₂ + ku₂⋅ku_ ↪\n", + "\n", + "↪ R₁⋅kb_R1⋅kdilₘ₂⋅ku₂⋅m₂ - kdilₘ₂⋅ku₂⋅ku_R1⋅m₂\n", + "↪ ────────────────────────────────────────────\n", + "↪ R1 \n", + "\n", + "dA2/dt =\n", + "-A₂⋅kdil_A2 + ktl₁⋅m₂\n", + "\n", + "dR2/dt =\n", + "-R₂⋅kdil_R2 + ktl₁⋅m₂\n", + "\n", + "Fast states collapsed:\n", + " C_A1_D1\n", + " C_R2_D1\n", + " C_A2_D2\n", + " C_R1_D2\n" + ] + } + ], + "source": [ + "from autoreduce import solve_timescale_separation\n", + "\n", + "slow_states_6 = [m1, A1, R1, m2, A2, R2]\n", + "fast_states_complexes = [C_A1_D1, C_R2_D1, C_A2_D2, C_R1_D2]\n", + "\n", + "sys_6, fast_subsystem = solve_timescale_separation(\n", + " sys_cons,\n", + " slow_states=slow_states_6,\n", + " fast_states=fast_states_complexes,\n", + " debug=False,\n", + ")\n", + "\n", + "sys_6.f = [simplify(fi) for fi in sys_6.f]\n", + "\n", + "print(\"Six-state reduced system after promoter-complex QSS:\")\n", + "for x, fi in zip(sys_6.x, sys_6.f):\n", + " print(f\"d{x}/dt =\")\n", + " pprint(simplify(fi))\n", + " print()\n", + "\n", + "print(\"Fast states collapsed:\")\n", + "for x in fast_states_complexes:\n", + " print(\" \", x)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7589605d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Six-state model after promoter-complex QSS:\n", + "dm1/dt =\n", + "-(-A₁⋅D₁ ₜₒₜ⋅kb₁⋅ktx₁⋅ku_R2 + A₁⋅kb₁⋅kdilₘ₁⋅ku_R2⋅m₁ - D₁ ₜₒₜ⋅ktx₀ ₁⋅ku₁⋅ku_R2 ↪\n", + "────────────────────────────────────────────────────────────────────────────── ↪\n", + " A₁⋅kb₁⋅ku_R2 + R₂⋅kb_R2⋅ku₁ + ku₁⋅ ↪\n", + "\n", + "↪ + R₂⋅kb_R2⋅kdilₘ₁⋅ku₁⋅m₁ + kdilₘ₁⋅ku₁⋅ku_R2⋅m₁) \n", + "↪ ─────────────────────────────────────────────────\n", + "↪ ku_R2 \n", + "\n", + "dA1/dt =\n", + "-A₁⋅kdil_A1 + ktl₁⋅m₁\n", + "\n", + "dR1/dt =\n", + "-R₁⋅kdil_R1 + ktl₁⋅m₁\n", + "\n", + "dm2/dt =\n", + "-(-A₂⋅D₂ ₜₒₜ⋅kb₂⋅ktx₂⋅ku_R1 + A₂⋅kb₂⋅kdilₘ₂⋅ku_R1⋅m₂ - D₂ ₜₒₜ⋅ktx₀ ₂⋅ku₂⋅ku_R1 ↪\n", + "────────────────────────────────────────────────────────────────────────────── ↪\n", + " A₂⋅kb₂⋅ku_R1 + R₁⋅kb_R1⋅ku₂ + ku₂⋅ ↪\n", + "\n", + "↪ + R₁⋅kb_R1⋅kdilₘ₂⋅ku₂⋅m₂ + kdilₘ₂⋅ku₂⋅ku_R1⋅m₂) \n", + "↪ ─────────────────────────────────────────────────\n", + "↪ ku_R1 \n", + "\n", + "dA2/dt =\n", + "-A₂⋅kdil_A2 + ktl₁⋅m₂\n", + "\n", + "dR2/dt =\n", + "-R₂⋅kdil_R2 + ktl₁⋅m₂\n", + "\n", + "Parameters currently in sys_6:\n", + " ktx0_1\n", + " kb_1\n", + " ku_1\n", + " ktx_1\n", + " ktl_1\n", + " ktx0_2\n", + " kb_2\n", + " ku_2\n", + " ktx_2\n", + " kb_R2\n", + " ku_R2\n", + " kb_R1\n", + " ku_R1\n", + " kdil_R2\n", + " kdil_A2\n", + " kdil_R1\n", + " kdil_A1\n", + " kdil_m1\n", + " kdil_m2\n", + " D1_tot\n", + " D2_tot\n" + ] + } + ], + "source": [ + "from sympy import cancel, factor, simplify, together, pprint, Eq, solve\n", + "from autoreduce import System\n", + "import numpy as np\n", + "\n", + "\n", + "\n", + "def clean(expr):\n", + " return factor(cancel(together(simplify(expr))))\n", + "\n", + "\n", + "sys_6.f = [clean(fi) for fi in sys_6.f]\n", + "\n", + "print(\"Six-state model after promoter-complex QSS:\")\n", + "for x, fi in zip(sys_6.x, sys_6.f):\n", + " print(f\"d{x}/dt =\")\n", + " pprint(clean(fi))\n", + " print()\n", + "\n", + "print(\"Parameters currently in sys_6:\")\n", + "for p in sys_6.params:\n", + " print(\" \", p)" + ] + }, + { + "cell_type": "markdown", + "id": "d9730b19", + "metadata": {}, + "source": [ + "### Symbolic simplification of the reduced model: assume same expression rates" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "cb267802", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Four-equation model:\n", + "dm1/dt =\n", + "-(-A₁⋅D₁ ₜₒₜ⋅kb₁⋅ktx₁⋅ku_R2 + A₁⋅kb₁⋅kdilₘ₁⋅ku_R2⋅m₁ + A₂⋅kb_R2⋅kdilₘ₁⋅ku₁⋅m₁ ↪\n", + "────────────────────────────────────────────────────────────────────────────── ↪\n", + " A₁⋅kb₁⋅ku_R2 + A₂⋅kb_R2⋅ku₁ + ku₁⋅ ↪\n", + "\n", + "↪ - D₁ ₜₒₜ⋅ktx₀ ₁⋅ku₁⋅ku_R2 + kdilₘ₁⋅ku₁⋅ku_R2⋅m₁) \n", + "↪ ─────────────────────────────────────────────────\n", + "↪ ku_R2 \n", + "\n", + "dA1/dt =\n", + "-A₁⋅kdil_A1 + ktl₁⋅m₁\n", + "\n", + "dm2/dt =\n", + "-(A₁⋅kb_R1⋅kdilₘ₂⋅ku₂⋅m₂ - A₂⋅D₂ ₜₒₜ⋅kb₂⋅ktx₂⋅ku_R1 + A₂⋅kb₂⋅kdilₘ₂⋅ku_R1⋅m₂ - ↪\n", + "────────────────────────────────────────────────────────────────────────────── ↪\n", + " A₁⋅kb_R1⋅ku₂ + A₂⋅kb₂⋅ku_R1 + ku₂⋅k ↪\n", + "\n", + "↪ D₂ ₜₒₜ⋅ktx₀ ₂⋅ku₂⋅ku_R1 + kdilₘ₂⋅ku₂⋅ku_R1⋅m₂) \n", + "↪ ────────────────────────────────────────────────\n", + "↪ u_R1 \n", + "\n", + "dA2/dt =\n", + "-A₂⋅kdil_A2 + ktl₁⋅m₂\n", + "\n" + ] + } + ], + "source": [ + "f6 = dict(zip(sys_6.x, sys_6.f))\n", + "\n", + "expected_states = [m1, A1, R1, m2, A2, R2]\n", + "missing_states = [x for x in expected_states if x not in f6]\n", + "\n", + "\n", + "coexpression_rate_subs = {\n", + " kdil_R1: kdil_A1,\n", + " kdil_R2: kdil_A2,\n", + "}\n", + "coexpression_state_subs = {\n", + " R1: A1,\n", + " R2: A2,\n", + "}\n", + "f6_equal_rates = {\n", + " x: clean(fi.subs(coexpression_rate_subs))\n", + " for x, fi in f6.items()\n", + "}\n", + "\n", + "D1_tot, D2_tot = symbols(\"D1_tot D2_tot\")\n", + "\n", + "\n", + "\n", + "x4 = [m1, A1, m2, A2]\n", + "\n", + "f4 = [\n", + " clean(f6_equal_rates[m1].subs(coexpression_state_subs)),\n", + " clean(f6_equal_rates[A1].subs(coexpression_state_subs)),\n", + " clean(f6_equal_rates[m2].subs(coexpression_state_subs)),\n", + " clean(f6_equal_rates[A2].subs(coexpression_state_subs)),\n", + "]\n", + "\n", + "params_4 = []\n", + "for p in sys_6.params:\n", + " p_new = coexpression_rate_subs.get(p, p)\n", + " if p_new not in params_4:\n", + " params_4.append(p_new)\n", + "\n", + "sys_4 = System(\n", + " x=x4,\n", + " f=f4,\n", + " params=params_4,\n", + " params_values=[sys_6.params_values[sys_6.params.index(p)] for p in params_4],\n", + " x_init=[0.0, 0.0, 0.0, 0.0],\n", + " C=np.array([[0, 1, 0, 0], [0, 0, 0, 1]]),\n", + ")\n", + "\n", + "for fi in sys_4.f:\n", + " if R1 in fi.free_symbols or R2 in fi.free_symbols:\n", + " raise ValueError(\"R1 or R2 still appears after co-expression reduction.\")\n", + "\n", + "print(\"Four-equation model:\")\n", + "for x, fi in zip(sys_4.x, sys_4.f):\n", + " print(f\"d{x}/dt =\")\n", + " pprint(clean(fi))\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "id": "41b273b3", + "metadata": {}, + "source": [ + "### QSS: Fast transcription relative to translation " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "383bf7ca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Successful solution obtained with states: [A1, A2]!\n", + "Two-state model after mRNA QSS:\n", + "dA1/dt =\n", + " ⎛ 2 ↪\n", + "-⎝A₁ ⋅kb₁⋅kdil_A1⋅kdilₘ₁⋅ku_R2 + A₁⋅A₂⋅kb_R2⋅kdil_A1⋅kdilₘ₁⋅ku₁ - A₁⋅D₁ ₜₒₜ⋅kb ↪\n", + "────────────────────────────────────────────────────────────────────────────── ↪\n", + " kdilₘ₁⋅(A₁⋅kb₁⋅ku_R2 + ↪\n", + "\n", + "↪ ↪\n", + "↪ ₁⋅ktl₁⋅ktx₁⋅ku_R2 + A₁⋅kdil_A1⋅kdilₘ₁⋅ku₁⋅ku_R2 - D₁ ₜₒₜ⋅ktl₁⋅ktx₀ ₁⋅ku₁⋅ku_ ↪\n", + "↪ ──────────────────────────────────────────────────────────────────────────── ↪\n", + "↪ A₂⋅kb_R2⋅ku₁ + ku₁⋅ku_R2) ↪\n", + "\n", + "↪ ⎞ \n", + "↪ R2⎠ \n", + "↪ ────\n", + "↪ \n", + "\n", + "dA2/dt =\n", + " ⎛ 2 ↪\n", + "-⎝A₁⋅A₂⋅kb_R1⋅kdil_A2⋅kdilₘ₂⋅ku₂ + A₂ ⋅kb₂⋅kdil_A2⋅kdilₘ₂⋅ku_R1 - A₂⋅D₂ ₜₒₜ⋅kb ↪\n", + "────────────────────────────────────────────────────────────────────────────── ↪\n", + " kdilₘ₂⋅(A₁⋅kb_R1⋅ku₂ + ↪\n", + "\n", + "↪ ↪\n", + "↪ ₂⋅ktl₁⋅ktx₂⋅ku_R1 + A₂⋅kdil_A2⋅kdilₘ₂⋅ku₂⋅ku_R1 - D₂ ₜₒₜ⋅ktl₁⋅ktx₀ ₂⋅ku₂⋅ku_ ↪\n", + "↪ ──────────────────────────────────────────────────────────────────────────── ↪\n", + "↪ A₂⋅kb₂⋅ku_R1 + ku₂⋅ku_R1) ↪\n", + "\n", + "↪ ⎞ \n", + "↪ R1⎠ \n", + "↪ ────\n", + "↪ \n", + "\n" + ] + } + ], + "source": [ + "\n", + "slow_states_2 = [A1, A2]\n", + "fast_states_mrna = [m1, m2]\n", + "\n", + "sys_2, mrna_fast_subsystem = solve_timescale_separation(\n", + " sys_4,\n", + " slow_states=slow_states_2,\n", + " fast_states=fast_states_mrna,\n", + " debug=False,\n", + ")\n", + "\n", + "sys_2.f = [clean(fi) for fi in sys_2.f]\n", + "\n", + "print(\"Two-state model after mRNA QSS:\")\n", + "for x, fi in zip(sys_2.x, sys_2.f):\n", + " print(f\"d{x}/dt =\")\n", + " pprint(clean(fi))\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "id": "2a5bec4a", + "metadata": {}, + "source": [ + "### Two-state reduced model" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "8e4078f0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dA1/dt =\n", + " ⎛ 2 ↪\n", + "-⎝A₁ ⋅kb₁⋅kdil_A1⋅kdilₘ₁⋅ku_R2 + A₁⋅A₂⋅kb_R2⋅kdil_A1⋅kdilₘ₁⋅ku₁ - A₁⋅D₁ ₜₒₜ⋅kb ↪\n", + "────────────────────────────────────────────────────────────────────────────── ↪\n", + " kdilₘ₁⋅(A₁⋅kb₁⋅ku_R2 + ↪\n", + "\n", + "↪ ↪\n", + "↪ ₁⋅ktl₁⋅ktx₁⋅ku_R2 + A₁⋅kdil_A1⋅kdilₘ₁⋅ku₁⋅ku_R2 - D₁ ₜₒₜ⋅ktl₁⋅ktx₀ ₁⋅ku₁⋅ku_ ↪\n", + "↪ ──────────────────────────────────────────────────────────────────────────── ↪\n", + "↪ A₂⋅kb_R2⋅ku₁ + ku₁⋅ku_R2) ↪\n", + "\n", + "↪ ⎞ \n", + "↪ R2⎠ \n", + "↪ ────\n", + "↪ \n", + "\n", + "dA2/dt =\n", + " ⎛ 2 ↪\n", + "-⎝A₁⋅A₂⋅kb_R1⋅kdil_A2⋅kdilₘ₂⋅ku₂ + A₂ ⋅kb₂⋅kdil_A2⋅kdilₘ₂⋅ku_R1 - A₂⋅D₂ ₜₒₜ⋅kb ↪\n", + "────────────────────────────────────────────────────────────────────────────── ↪\n", + " kdilₘ₂⋅(A₁⋅kb_R1⋅ku₂ + ↪\n", + "\n", + "↪ ↪\n", + "↪ ₂⋅ktl₁⋅ktx₂⋅ku_R1 + A₂⋅kdil_A2⋅kdilₘ₂⋅ku₂⋅ku_R1 - D₂ ₜₒₜ⋅ktl₁⋅ktx₀ ₂⋅ku₂⋅ku_ ↪\n", + "↪ ──────────────────────────────────────────────────────────────────────────── ↪\n", + "↪ A₂⋅kb₂⋅ku_R1 + ku₂⋅ku_R1) ↪\n", + "\n", + "↪ ⎞ \n", + "↪ R1⎠ \n", + "↪ ────\n", + "↪ \n", + "\n" + ] + } + ], + "source": [ + "for x, fi in zip(sys_2.x, sys_2.f):\n", + " print(f\"d{x}/dt =\")\n", + " pprint(clean(fi))\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "id": "3e86c133", + "metadata": {}, + "source": [ + "## So what? How can we use the reduced model?" + ] + }, + { + "cell_type": "markdown", + "id": "85c2627d", + "metadata": {}, + "source": [ + "The model derived above enables us to apply assume-guarantee contract based analysis to obtain guarantees on parameter regions that ensure bistability. This work (derivation of formal guarantees using the reduced models) was published in the IEEE Conference on Decision and Control (CDC) 2024 paper titled \"Guaranteeing System-level Properties in Genetic Circuits Subject to Context Effects\" by Inigo Incer; Ayush Pandey; Nicholas Nolan; Emma L. Peterman; Kate E. Galloway; Eduardo D. Sontag, Domitilla Del Vecchio." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "autoreduce", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/default_parameters.txt b/examples/biological/default_parameters.txt similarity index 94% rename from examples/default_parameters.txt rename to examples/biological/default_parameters.txt index 3d16e4b..e55546c 100644 --- a/examples/default_parameters.txt +++ b/examples/biological/default_parameters.txt @@ -6,17 +6,17 @@ mechanism_id part_id param_name param_val comments e coli extract protein_Ribo 24 1/5 th the Ribosome concentration of E. Coli e coli extract protein_RNAP 3 1/5 th the rnap concentration of E. Coli e coli extract protein_RNAase 6 1/5 th the rnaase concentration of E. Coli - e coli extract 2 protein_Ribo 12 - e coli extract 2 protein_RNAP 6 - e coli extract 2 protein_RNAase 3 + e coli extract 2 protein_Ribo 12 + e coli extract 2 protein_RNAP 6 + e coli extract 2 protein_RNAase 3 ktx 0.05 transcripts / second per polymerase assuming 50nt/s and transcript length of 1000 ktl 0.05 proteins / second per ribosome assuming 15aa/s and protein length of 300 cooperativity 2 Seems like a good default kb 100 assuming 10ms to diffuse across 1um (characteristic cell size) ku 10 """90% binding""" kdil 0.001 assuming half life of ~20 minutes for everything (e coli doubling time) -rna_degredation_mm kdeg 0.001 assuming a half life of ~10 minutes for mRNA -rna_degredation kdil 0.001 assuming a half life of ~10 minutes for mRNA +rna_degradation_mm kdeg 0.01 assuming a half life of ~10 minutes for mRNA +rna_degradation kdil 0.01 assuming a half life of ~10 minutes for mRNA simple_transcription ktx 0.1 Assuming ~10% of e coli rnap working at ktx above simple_translation ktl 0.25 Assuming ~5% of e coli ribosomes working at ktx above gene_expression kexpress 0.28125 The product of the above two rates @@ -57,4 +57,4 @@ simple_transcription strong ktx 0.4775625 Above rescaled by ktx for simple trans combinatorial_promoter_leak ktx 0.0005 1% of ktx default combinatorial_promoter_leak kexpress 0.0028125 1% of kexpress default regulated_promoter_leak ktx 0.0005 1% of ktx default - regulated_promoter_leak kexpress 0.0028125 1% of kexpress default \ No newline at end of file + regulated_promoter_leak kexpress 0.0028125 1% of kexpress default diff --git a/examples/models/biocrnpyler_gene_expression.xml b/examples/biological/models/biocrnpyler_gene_expression.xml similarity index 84% rename from examples/models/biocrnpyler_gene_expression.xml rename to examples/biological/models/biocrnpyler_gene_expression.xml index e54b640..89a7c7b 100644 --- a/examples/models/biocrnpyler_gene_expression.xml +++ b/examples/biological/models/biocrnpyler_gene_expression.xml @@ -1,6 +1,6 @@ - + @@ -12,13 +12,13 @@ - - - - - - - + + + + + + + diff --git a/examples/biological/models/design1_parameters.tsv b/examples/biological/models/design1_parameters.tsv new file mode 100644 index 0000000..7fa1e8f --- /dev/null +++ b/examples/biological/models/design1_parameters.tsv @@ -0,0 +1,24 @@ +mechanism_id part_id param_name param_val unit +one_step_cooperative_binding p1_A1 kb 1.0 per_hour +one_step_cooperative_binding p1_A1 ku 1.0 per_hour +one_step_cooperative_binding p1_A1 cooperativity 1.0 per_hour +one_step_cooperative_binding p2_A2 kb 1.0 per_hour +one_step_cooperative_binding p2_A2 ku 1.0 per_hour +one_step_cooperative_binding p2_A2 cooperativity 1.0 per_hour +one_step_cooperative_binding R2 kb 1.0 per_hour +one_step_cooperative_binding R2 ku 1.0 per_hour +one_step_cooperative_binding R2 cooperativity 1.0 per_hour +one_step_cooperative_binding R1 kb 1.0 per_hour +one_step_cooperative_binding R1 ku 1.0 per_hour +one_step_cooperative_binding R1 cooperativity 1.0 per_hour +transcription p1_leak ktx 0.25 per_hour +transcription p1_A1 ktx 2.0 per_hour +transcription p2_leak ktx 0.25 per_hour +transcription p2_A2 ktx 2.0 per_hour +simple_translation utr1 ktl 5.0 per_hour +rna_degradation rna_m1 kdil 1.0 per_hour +rna_degradation rna_m2 kdil 1.0 per_hour +protein_degradation protein_A1 kdil 1.0 per_hour +protein_degradation protein_A2 kdil 1.0 per_hour +protein_degradation protein_R1 kdil 1.0 per_hour +protein_degradation protein_R2 kdil 1.0 per_hour diff --git a/examples/biological/models/design1_regulated_promoter.xml b/examples/biological/models/design1_regulated_promoter.xml new file mode 100644 index 0000000..6ca671b --- /dev/null +++ b/examples/biological/models/design1_regulated_promoter.xml @@ -0,0 +1,409 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ktx_p1_leak_transcription + dna_D1 + + + + + + + + + + + + + + + + + kb_p1_A1_one_step_cooperative_binding + protein_A1 + dna_D1 + + + + + + + + + + + + + + + + + ku_p1_A1_one_step_cooperative_binding + complex_dna_D1_protein_A1_ + + + + + + + + + + + + + + + + + ktx_p1_A1_transcription + complex_dna_D1_protein_A1_ + + + + + + + + + + + + + + + + + + ktl_utr1_simple_translation + rna_m1 + + + + + + + + + + + + + + + + + ktx_p2_leak_transcription + dna_D2 + + + + + + + + + + + + + + + + + kb_p2_A2_one_step_cooperative_binding + protein_A2 + dna_D2 + + + + + + + + + + + + + + + + + ku_p2_A2_one_step_cooperative_binding + complex_dna_D2_protein_A2_ + + + + + + + + + + + + + + + + + ktx_p2_A2_transcription + complex_dna_D2_protein_A2_ + + + + + + + + + + + + + + + + + + ktl_utr1_simple_translation + rna_m2 + + + + + + + + + + + + + + + + + kb_R2_one_step_cooperative_binding + protein_R2 + dna_D1 + + + + + + + + + + + + + + + + + ku_R2_one_step_cooperative_binding + complex_dna_D1_protein_R2_ + + + + + + + + + + + + + + + + + kb_R1_one_step_cooperative_binding + protein_R1 + dna_D2 + + + + + + + + + + + + + + + + + ku_R1_one_step_cooperative_binding + complex_dna_D2_protein_R1_ + + + + + + + + + + + + + kdil_protein_R2_protein_degradation + protein_R2 + + + + + + + + + + + + + kdil_protein_A2_protein_degradation + protein_A2 + + + + + + + + + + + + + kdil_protein_R1_protein_degradation + protein_R1 + + + + + + + + + + + + + kdil_protein_A1_protein_degradation + protein_A1 + + + + + + + + + + + + + kdil_rna_m1_rna_degradation + rna_m1 + + + + + + + + + + + + + kdil_rna_m2_rna_degradation + rna_m2 + + + + + + + diff --git a/examples/models/example1.xml b/examples/biological/models/example1.xml similarity index 100% rename from examples/models/example1.xml rename to examples/biological/models/example1.xml diff --git a/examples/models/example_1.xml b/examples/biological/models/example_1.xml similarity index 88% rename from examples/models/example_1.xml rename to examples/biological/models/example_1.xml index 2a8cb33..56eae59 100644 --- a/examples/models/example_1.xml +++ b/examples/biological/models/example_1.xml @@ -1,6 +1,6 @@ - + @@ -12,7 +12,7 @@ - + diff --git a/examples/models/reduced_gene_expression.xml b/examples/biological/models/reduced_gene_expression.xml similarity index 100% rename from examples/models/reduced_gene_expression.xml rename to examples/biological/models/reduced_gene_expression.xml diff --git a/examples/canonical/Michaelis Menten.ipynb b/examples/canonical/Michaelis Menten.ipynb new file mode 100644 index 0000000..b2b715c --- /dev/null +++ b/examples/canonical/Michaelis Menten.ipynb @@ -0,0 +1,390 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "michaelis-menten-00", + "metadata": {}, + "source": [ + "# Enzymatic System: Michaelis Menten Model \n", + "\n", + "This notebook shows two reductions for an enzymatic reaction system with AutoReduce: first a conservation-law reduction, then a quasi-steady-state approximation (QSSA). The goal is to keep the substrate and product dynamics while eliminating intermediate enzyme-complex states.\n" + ] + }, + { + "cell_type": "markdown", + "id": "michaelis-menten-01", + "metadata": {}, + "source": [ + "## Model\n", + "\n", + "The reaction structure is\n", + "\n", + "$$\n", + "E + S \\rightleftharpoons_{k_2}^{k_1} C \\rightarrow^{k_3} E + P.\n", + "$$\n", + "\n", + "### Conservation law:\n", + "With total enzyme $E_T$, the conservation law is\n", + "\n", + "$$\n", + "E + C = E_T.\n", + "$$\n", + "\n", + "After substituting $E = E_T - C$, the system is\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\dot{S} &= -k_1(E_T-C)S + k_2C, \\\\\n", + "\\dot{C} &= k_1(E_T-C)S - (k_2+k_3)C, \\\\\n", + "\\dot{P} &= k_3C.\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "We will now show how AutoReduce can be used to solve for the reduced model by applying conservation laws automatically. That is, we will use AutoReduce to find the model above starting from the enzymatic system CRN. This \"trivial\" example is designed to demonstrate the most fundamental features of AutoReduce. For more interesting examples, see the other example notebooks.\n" + ] + }, + { + "cell_type": "markdown", + "id": "c0a51d67", + "metadata": {}, + "source": [ + "### Import libraries and define symbols" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "michaelis-menten-02", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from sympy import simplify, symbols\n", + "\n", + "from autoreduce import System, solve_conservation_laws, solve_timescale_separation\n", + "\n", + "# define all symbols using sympy.symbols (see note below on supported model imports)\n", + "S, E, C, P, k1, k2, k3, E_T = symbols(\"S,E,C,P,k1,k2,k3,E_T\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "6367e163", + "metadata": {}, + "source": [ + "## Create a system in AutoReduce \n", + "Here, we use the Sympy symbols to define the system. AutoReduce also accepts pre-defined models in standard control theory or system biology formats: `python-control`, `sbml`, and `pyDMD`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4487ccfc", + "metadata": {}, + "outputs": [], + "source": [ + "# define variables and parameters\n", + "x = [S, E, C, P]\n", + "params = [k1, k2, k3, E_T]\n", + "param_values = [1.0, 0.5, 0.25, 10.0]\n", + "x_init = [10.0, 0.0, 0.0, 0.0]\n", + "\n", + "# define output of choice / interest using the C matrix\n", + "# here, C is the matrix of the output equation: y = Cx.\n", + "# alternatively, y = g(x,u), a nonlinear function is also supported.\n", + "\n", + "f = [\n", + " -k1 * E * S + k2 * C,\n", + " (k2 + k3) * C - k1 * E * S,\n", + " k1 * E * S - (k2 + k3) * C,\n", + " k3 * C,\n", + "]\n", + "\n", + "system = System(\n", + " x,\n", + " f,\n", + " params=params,\n", + " params_values=param_values,\n", + " x_init=x_init,\n", + " C=np.array([[0, 0, 0, 1]]),\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "de25358c", + "metadata": {}, + "source": [ + "### View the system" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "dea00165", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AutoReduce System object with 4 state variables, 1 output.\n", + "system equations:\n", + "\\left[ C k_{2} - E S k_{1}, \\ C \\left(k_{2} + k_{3}\\right) - E S k_{1}, \\ - C \\left(k_{2} + k_{3}\\right) + E S k_{1}, \\ C k_{3}\\right]\n" + ] + } + ], + "source": [ + "system.pretty_print()" + ] + }, + { + "cell_type": "markdown", + "id": "5c964779", + "metadata": {}, + "source": [ + "## Solve conservation laws\n", + "\n", + "To solve (apply) conservation laws to a model, you can use the `solve_conservation_laws` function directly on the `System`. This will automatically find conserved sets and reduce the system accordingly.\n", + "\n", + "In this example, we expect that AutoReduce will find the conservation law $E + C = E_T$ and reduce the system to the form shown above. The search depth is set to 2 because this conservation law is detected by summing two ODE terms, $\\dot{E}+\\dot{C}=0$." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1cdc540f", + "metadata": {}, + "outputs": [], + "source": [ + "conserved_system = solve_conservation_laws(\n", + " system,\n", + " search_depth=2,\n", + " total_quantities={\"E_T\": param_values[-1]},\n", + " states_to_eliminate=[E],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "710b84cd", + "metadata": {}, + "source": [ + "### Check the reduced system after applying the conservation law" + ] + }, + { + "cell_type": "markdown", + "id": "e113f007", + "metadata": {}, + "source": [ + "Print the conserved system states:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "308e319d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[S, C, P]\n" + ] + } + ], + "source": [ + "print(conserved_system.x)" + ] + }, + { + "cell_type": "markdown", + "id": "4ed2d052", + "metadata": {}, + "source": [ + "Print the conserved system equations:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ad2ded24", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C⋅k₂ - S⋅k₁⋅(-C + E_T)\n", + "-C⋅(k₂ + k₃) + S⋅k₁⋅(-C + E_T)\n", + "C⋅k₃\n" + ] + } + ], + "source": [ + "from sympy import pprint\n", + "for i in range(len(conserved_system.f)):\n", + " pprint(conserved_system.f[i])" + ] + }, + { + "cell_type": "markdown", + "id": "michaelis-menten-03", + "metadata": {}, + "source": [ + "## Quasi-steady-state approximation\n", + "\n", + "For the standard Michaelis-Menten reduction, the enzyme complex $C$ is treated as the fast state (at quasi-steady-state). AutoReduce can solve the reduced dynamics automatically using the `solve_timescale_separation` function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "michaelis-menten-04", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Successful solution obtained with states: [S, P]!\n" + ] + } + ], + "source": [ + "reduced_system, collapsed_system = solve_timescale_separation(\n", + " conserved_system,\n", + " slow_states=[S, P],\n", + " fast_states=[C],\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "817817c6", + "metadata": {}, + "source": [ + "### Print the Michaelis-Menten reduced model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "63dce4f2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "### The reduced model is" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/latex": [ + "$\\displaystyle \\begin{aligned}\\frac{d S}{dt} = - \\frac{E_{T} S k_{1} k_{3}}{S k_{1} + k_{2} + k_{3}} \\\\ \\frac{d P}{dt} = \\frac{E_{T} S k_{1} k_{3}}{S k_{1} + k_{2} + k_{3}}\\end{aligned}$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import display, Markdown, Math\n", + "from sympy import latex\n", + "\n", + "display(Markdown(\"### The reduced model is\"))\n", + "\n", + "reduced_equations = [\n", + " rf\"\\frac{{d {latex(reduced_system.x[i])}}}{{dt}} = {latex(expr)}\"\n", + " for i, expr in enumerate(reduced_system.f)\n", + "]\n", + "\n", + "display(\n", + " Math(\n", + " r\"\\begin{aligned}\"\n", + " + r\" \\\\ \".join(reduced_equations)\n", + " + r\"\\end{aligned}\"\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "michaelis-menten-05", + "metadata": {}, + "source": [ + "## Reduced dynamics\n", + "\n", + "The reduced system has states `reduced_system.x`, which are $[S, P]$. The symbolic dynamics are `reduced_system.f`, shown above.\n", + "\n", + "\n", + "The collapsed system records the eliminated fast state and its algebraic condition. You can explore the collapsed system by printing `collapsed_system.x` and `collapsed_system.f`.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "michaelis-menten-06", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([C], [-C*(k2 + k3) - 10.0*k1*(C - E_T)])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "collapsed_system.x, collapsed_system.f\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e0f39577", + "metadata": {}, + "outputs": [], + "source": [ + "# end" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "autoreduce", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/canonical/Parameter sensitivity.ipynb b/examples/canonical/Parameter sensitivity.ipynb new file mode 100644 index 0000000..9c8ff64 --- /dev/null +++ b/examples/canonical/Parameter sensitivity.ipynb @@ -0,0 +1,246 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "parameter-sensitivity-00", + "metadata": {}, + "source": [ + "# Parameter Sensitivity\n", + "\n", + "This notebook uses the direct sensitivity solver in AutoReduce for a one-state decay model. Local sensitivity analysis is performed by solving the sensitivity equations alongside the original system, then comparing the result against an analytical expression.\n" + ] + }, + { + "cell_type": "markdown", + "id": "parameter-sensitivity-01", + "metadata": {}, + "source": [ + "## Model\n", + "\n", + "The model is\n", + "\n", + "$$\n", + "\\dot{x} = -kx,\n", + "$$\n", + "\n", + "with solution $x(t)=x_0e^{-kt}$. The sensitivity of the state with respect to $k$ is\n", + "\n", + "$$\n", + "\\frac{\\partial x}{\\partial k} = -t x_0 e^{-kt}.\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "parameter-sensitivity-02", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sympy import Symbol\n", + "\n", + "from autoreduce import System, solve_sensitivity\n", + "\n", + "x = Symbol(\"x\")\n", + "k = Symbol(\"k\")\n", + "\n", + "system = System(\n", + " [x],\n", + " [-k * x],\n", + " params=[k],\n", + " params_values=[0.4],\n", + " x_init=[5.0],\n", + " C=np.array([[1.0]]),\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "parameter-sensitivity-03", + "metadata": {}, + "source": [ + "## Compute local sensitivities\n", + "\n", + "`solve_sensitivity` returns an array indexed by time point, parameter, and state.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "parameter-sensitivity-04", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1024, 1, 1)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timepoints = np.linspace(0.0, 5.0, 1024)\n", + "sensitivities = solve_sensitivity(system, timepoints, normalize=False)\n", + "\n", + "sensitivities.shape\n" + ] + }, + { + "cell_type": "markdown", + "id": "parameter-sensitivity-05", + "metadata": {}, + "source": [ + "## Compare against analytical coefficients\n", + "\n", + "For this model, the analytical expression is available, so it provides a compact check on the numerical sensitivity calculation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "parameter-sensitivity-06", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0. , 0. , -0. ],\n", + " [ 0.00488759, -0.02439021, -0.0243902 ],\n", + " [ 0.00977517, -0.04868514, -0.04868512],\n", + " [ 0.01466276, -0.07288506, -0.07288505],\n", + " [ 0.01955034, -0.09699027, -0.09699026],\n", + " [ 0.02443793, -0.12100105, -0.12100103],\n", + " [ 0.02932551, -0.14491766, -0.14491764],\n", + " [ 0.0342131 , -0.16874038, -0.16874037]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x0 = system.x_init[0]\n", + "k_value = system.params_values[0]\n", + "analytical = -timepoints * x0 * np.exp(-k_value * timepoints)\n", + "numerical = sensitivities[:, 0, 0]\n", + "\n", + "comparison = np.column_stack([timepoints, numerical, analytical])\n", + "comparison[:8]\n" + ] + }, + { + "cell_type": "markdown", + "id": "parameter-sensitivity-07", + "metadata": {}, + "source": [ + "## Verify the sensitivity calculation\n", + "\n", + "The maximum absolute error gives a direct numerical check of the computed sensitivity against the analytical expression.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "parameter-sensitivity-08", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'max_absolute_error': 3.823501204536228e-08,\n", + " 'tolerance': 1e-06,\n", + " 'passes': True}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "absolute_error = np.abs(numerical - analytical)\n", + "max_absolute_error = float(np.max(absolute_error))\n", + "tolerance = 1e-6\n", + "\n", + "assert max_absolute_error < tolerance\n", + "{\n", + " \"max_absolute_error\": max_absolute_error,\n", + " \"tolerance\": tolerance,\n", + " \"passes\": max_absolute_error < tolerance,\n", + "}\n" + ] + }, + { + "cell_type": "markdown", + "id": "parameter-sensitivity-09", + "metadata": {}, + "source": [ + "## Plot a sensitivity heatmap\n", + "\n", + "The heatmap shows how the local sensitivity of $x$ to $k$ changes over time.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "parameter-sensitivity-10", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 2.2))\n", + "sns.heatmap(\n", + " numerical.reshape(1, -1),\n", + " cmap=\"vlag\",\n", + " center=0,\n", + " xticklabels=128,\n", + " yticklabels=[r\"$\\partial x / \\partial k$\"],\n", + " cbar_kws={\"label\": \"Sensitivity\"},\n", + " ax=ax,\n", + ")\n", + "ax.set_xlabel(\"Time index\")\n", + "ax.set_ylabel(\"State/parameter pair\")\n", + "ax.set_title(\"Sensitivity of x to k over time\")\n", + "plt.tight_layout()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "autoreduce", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/canonical/QSS with python-control.ipynb b/examples/canonical/QSS with python-control.ipynb new file mode 100644 index 0000000..b04a548 --- /dev/null +++ b/examples/canonical/QSS with python-control.ipynb @@ -0,0 +1,244 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "qss-control-00", + "metadata": {}, + "source": [ + "# QSS with `python-control` and AutoReduce\n", + "\n", + "This canonical example uses a simple singularly perturbed system to show how a quasi-steady-state approximation eliminates a fast state while keeping a constant or slowly varying control input. in this example, we demonstrate the compatibility of AutoReduce with the `python-control` package. Particularly, we create a NonlinearIOSystem from `python-control` and use AutoReduce to load this model as a `System` in AutoReduce. We then perform a quasi-steady-state reduction on the system and compare the output of the reduced system to the original system.\n" + ] + }, + { + "cell_type": "markdown", + "id": "qss-control-01", + "metadata": {}, + "source": [ + "## Model\n", + "\n", + "Consider\n", + "\n", + "$$\n", + "\\dot{x} = -x + z, \\qquad \\epsilon \\dot{z} = x - 2z + u, \\qquad 0 < \\epsilon \\ll 1,\n", + "$$\n", + "\n", + "where $u$ is a constant or slowly varying control input. This is the standard singularly perturbed form\n", + "\n", + "$$\n", + "\\dot{x}=f(x,z,u), \\qquad \\epsilon\\dot{z}=g(x,z,u).\n", + "$$\n" + ] + }, + { + "cell_type": "markdown", + "id": "d4e72425", + "metadata": {}, + "source": [ + "### Create the model using `python-control`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "qss-control-02", + "metadata": {}, + "outputs": [], + "source": [ + "import control as ct\n", + "from sympy import simplify, symbols\n", + "\n", + "from autoreduce import solve_timescale_separation\n", + "from autoreduce.system.control import from_nonlinear_io_system\n", + "\n", + "x, z, u, epsilon = symbols(\"x z u epsilon\")\n", + "\n", + "\n", + "def model_update(_t, state, inputs, params):\n", + " x_state, z_state = state\n", + " control_input = inputs[0]\n", + " epsilon_value = params[\"epsilon\"]\n", + " return [\n", + " -x_state + z_state,\n", + " (x_state - 2 * z_state + control_input) / epsilon_value,\n", + " ]\n", + "\n", + "\n", + "control_system = ct.NonlinearIOSystem(\n", + " model_update,\n", + " None,\n", + " states=[\"x\", \"z\"],\n", + " inputs=[\"u\"],\n", + " params={\"epsilon\": 0.01},\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "97bc1684", + "metadata": {}, + "source": [ + "## Load a NonlinearIOSystem into AutoReduce" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "759646f2", + "metadata": {}, + "outputs": [], + "source": [ + "system = from_nonlinear_io_system(\n", + " control_system,\n", + " state_symbols=[x, z],\n", + " params=[epsilon],\n", + " params_values=[0.01],\n", + " input_symbols=[u],\n", + " input_values=[1.0],\n", + " x_init=[0.0, 0.0],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "aab9f2f2", + "metadata": {}, + "source": [ + "### Explore the system" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "512b0fb5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[-x + z, (u + x - 2*z)/epsilon]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "system.f" + ] + }, + { + "cell_type": "markdown", + "id": "qss-control-03", + "metadata": {}, + "source": [ + "## Quasi-steady-state approximation\n", + "\n", + "Because $z$ evolves on the fast time scale, set $\\epsilon=0$ in the fast equation. This changes the differential equation into the algebraic constraint\n", + "\n", + "$$\n", + "0 = x - 2z + u.\n", + "$$\n", + "\n", + "Therefore, the quasi-steady value of $z$ is\n", + "\n", + "$$\n", + "z = h(x,u) = \\frac{x+u}{2}.\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "qss-control-04", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Successful solution obtained with states: [x]!\n" + ] + }, + { + "data": { + "text/plain": [ + "[u/2 - x/2]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reduced_system, collapsed_system = solve_timescale_separation(\n", + " system,\n", + " slow_states=[x],\n", + " fast_states=[z],\n", + ")\n", + "\n", + "[simplify(expr) for expr in reduced_system.f]\n" + ] + }, + { + "cell_type": "markdown", + "id": "qss-control-05", + "metadata": {}, + "source": [ + "## Reduced model\n", + "\n", + "Substituting the quasi-steady value of $z$ into the slow equation gives\n", + "\n", + "$$\n", + "\\dot{x} = -x + \\frac{x+u}{2} = -\\frac{1}{2}x + \\frac{1}{2}u.\n", + "$$\n", + "\n", + "The reduced AutoReduce system stores this one-state model in `reduced_system.x` and `reduced_system.f`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "qss-control-06", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([x], [u/2 - x/2], [z])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reduced_system.x, reduced_system.f, collapsed_system.x\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "autoreduce", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/cyber-physical/Motor control.ipynb b/examples/cyber-physical/Motor control.ipynb new file mode 100644 index 0000000..acee9f2 --- /dev/null +++ b/examples/cyber-physical/Motor control.ipynb @@ -0,0 +1,1314 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5d491864", + "metadata": {}, + "source": [ + "# Induction Motor Speed Control Using Reduced-Order Models\n", + "\n", + "This tutorial builds the fifth-order induction motor model used in induction motor speed control. The most commonly used model is one that assumes stator and rotor currents at quasi-steady-state. But other models are also possible. We show how AutoReduce can be used to explore these possible models and to find out what reduced model is most suitable for the given control application. This model is built on the work of Sabir and Ibrir (2018) who used a reduced-order model for induction motor speed control.\n", + "\n", + "> Reference: Sabir, A., and S. Ibrir. \"Induction motor speed control using reduced-order model.\" Automatika: časopis za automatiku, mjerenje, elektroniku, računarstvo i komunikacije 59.3-4 (2018): 274-285.\n" + ] + }, + { + "cell_type": "markdown", + "id": "081754f8", + "metadata": {}, + "source": [ + "## The fifth-order motor model\n", + "\n", + "The state vector contains the d-axis and q-axis stator currents, the d-axis and q-axis rotor fluxes, and the rotor mechanical speed:\n", + "\n", + "$$\n", + "x =\n", + "\\begin{bmatrix}\n", + "i_{sd} & i_{sq} & \\phi_{rd} & \\phi_{rq} & \\Omega\n", + "\\end{bmatrix}^{T}.\n", + "$$\n", + "\n", + "The model uses the d-axis and q-axis stator voltages and the load torque as prescribed values:\n", + "\n", + "$$\n", + "u =\n", + "\\begin{bmatrix}\n", + "v_{sd} & v_{sq} & T_L\n", + "\\end{bmatrix}^{T}.\n", + "$$\n", + "\n", + "The fifth-order nonlinear equations are\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\dot{i}_{sd} &= -\\gamma i_{sd}+\\omega_s i_{sq}+ba\\phi_{rd}+bp\\Omega\\phi_{rq}+m_1v_{sd}, \\\\\n", + "\\dot{i}_{sq} &= -\\omega_s i_{sd}-\\gamma i_{sq}-bp\\Omega\\phi_{rd}+ba\\phi_{rq}+m_1v_{sq}, \\\\\n", + "\\dot{\\phi}_{rd} &= aM_{sr}i_{sd}-a\\phi_{rd}+(\\omega_s-p\\Omega)\\phi_{rq}, \\\\\n", + "\\dot{\\phi}_{rq} &= aM_{sr}i_{sq}-(\\omega_s-p\\Omega)\\phi_{rd}-a\\phi_{rq}, \\\\\n", + "\\dot{\\Omega} &= m(\\phi_{rd}i_{sq}-\\phi_{rq}i_{sd})-c\\Omega-\\frac{T_L}{J}.\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "The output for model reduction is the rotor speed, $y=\\Omega$.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2bd5f24e", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import sympy as sp\n", + "from IPython.display import display, Math\n", + "from sympy import latex\n", + "\n", + "from autoreduce import System, load_ode_model, solve_ode, solve_timescale_separation\n" + ] + }, + { + "cell_type": "markdown", + "id": "0a5459ca", + "metadata": {}, + "source": [ + "## Set the motor parameters\n", + "\n", + "The numerical values below come from the induction motor example. The line-to-line RMS voltage is converted into the phase-peak d-axis voltage used by the dq model.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fdf7166c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Rs': np.float64(0.087),\n", + " 'Rr': np.float64(0.228),\n", + " 'Ls': np.float64(0.0355),\n", + " 'Lr': np.float64(0.0355),\n", + " 'Msr': np.float64(0.0347),\n", + " 'J': np.float64(1.662),\n", + " 'fv': np.float64(0.1),\n", + " 'p': np.float64(2.0),\n", + " 'omega_s': np.float64(377.0),\n", + " 'vsd': np.float64(375.588427226754),\n", + " 'vsq': np.float64(0.0),\n", + " 'Tl': np.float64(0.0)}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "line_voltage_rms = 460.0\n", + "phase_peak_voltage = np.sqrt(2.0) * line_voltage_rms / np.sqrt(3.0)\n", + "\n", + "motor_params_values = np.array([\n", + " 0.087, # Rs: stator resistance, ohms\n", + " 0.228, # Rr: rotor resistance, ohms\n", + " 0.0355, # Ls: stator inductance, H\n", + " 0.0355, # Lr: rotor inductance, H\n", + " 0.0347, # Msr: mutual inductance, H\n", + " 1.662, # J: rotor inertia, kg m^2\n", + " 0.1, # fv: viscous friction coefficient\n", + " 2.0, # p: pole pairs\n", + " 377.0, # omega_s: synchronous electrical speed, rad/s\n", + " phase_peak_voltage, # vsd: d-axis stator voltage\n", + " 0.0, # vsq: q-axis stator voltage\n", + " 0.0, # Tl: load torque, N m\n", + "])\n", + "\n", + "motor_parameter_names = [\n", + " \"Rs\", \"Rr\", \"Ls\", \"Lr\", \"Msr\", \"J\", \"fv\", \"p\", \"omega_s\", \"vsd\", \"vsq\", \"Tl\"\n", + "]\n", + "\n", + "motor_parameter_values = dict(zip(motor_parameter_names, motor_params_values))\n", + "motor_parameter_values" + ] + }, + { + "cell_type": "markdown", + "id": "96555caa", + "metadata": {}, + "source": [ + "## Build the AutoReduce system\n", + "\n", + "This cell maps the physical motor variables into AutoReduce's symbolic state and parameter containers. The auxiliary constants $a$, $b$, $c$, $\\gamma$, $m$, and $m_1$ remain symbolic expressions of the motor parameters.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ac9fa31c", + "metadata": {}, + "outputs": [], + "source": [ + "motor_states, motor_rhs, motor_params = load_ode_model(5, len(motor_params_values))\n", + "Rs, Rr, Ls, Lr, Msr, J, fv, p, omega_s, vsd, vsq, Tl = motor_params\n", + "i_sd, i_sq, phi_rd, phi_rq, Omega = motor_states\n", + "\n", + "sigma = 1 - Msr**2 / (Ls * Lr)\n", + "a = Rr / Lr\n", + "b = Msr / (sigma * Ls * Lr)\n", + "c = fv / J\n", + "gamma = (Lr**2 * Rs + Msr**2 * Rr) / (sigma * Ls * Lr**2)\n", + "m = p * Msr / (J * Lr)\n", + "m1 = 1 / (sigma * Ls)\n", + "slip = omega_s - p * Omega\n", + "\n", + "motor_rhs[0] = -gamma * i_sd + omega_s * i_sq + b * a * phi_rd + b * p * Omega * phi_rq + m1 * vsd\n", + "motor_rhs[1] = -omega_s * i_sd - gamma * i_sq - b * p * Omega * phi_rd + b * a * phi_rq + m1 * vsq\n", + "motor_rhs[2] = a * Msr * i_sd - a * phi_rd + slip * phi_rq\n", + "motor_rhs[3] = a * Msr * i_sq - slip * phi_rd - a * phi_rq\n", + "motor_rhs[4] = m * (phi_rd * i_sq - phi_rq * i_sd) - c * Omega - Tl / J\n", + "\n", + "motor_x_init = np.zeros(len(motor_states))\n", + "motor_C = np.zeros((1, len(motor_states)), dtype=int)\n", + "motor_C[0, 4] = 1\n", + "motor_params_dict = dict(zip(motor_params, motor_params_values))\n", + "\n", + "motor_system = System(\n", + " motor_states,\n", + " motor_rhs,\n", + " params_dict=motor_params_dict,\n", + " C=motor_C.tolist(),\n", + " x_init=motor_x_init,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "04ff364a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\dot{x} = \\left[ \\frac{P_{1} P_{4} x_{2}}{P_{2} P_{3}^{2} \\left(1 - \\frac{P_{4}^{2}}{P_{2} P_{3}}\\right)} + P_{8} x_{1} + \\frac{P_{9}}{P_{2} \\left(1 - \\frac{P_{4}^{2}}{P_{2} P_{3}}\\right)} + \\frac{P_{4} P_{7} x_{3} x_{4}}{P_{2} P_{3} \\left(1 - \\frac{P_{4}^{2}}{P_{2} P_{3}}\\right)} - \\frac{x_{0} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)}{P_{2} P_{3}^{2} \\left(1 - \\frac{P_{4}^{2}}{P_{2} P_{3}}\\right)}, \\ \\frac{P_{1} P_{4} x_{3}}{P_{2} P_{3}^{2} \\left(1 - \\frac{P_{4}^{2}}{P_{2} P_{3}}\\right)} + \\frac{P_{10}}{P_{2} \\left(1 - \\frac{P_{4}^{2}}{P_{2} P_{3}}\\right)} - P_{8} x_{0} - \\frac{P_{4} P_{7} x_{2} x_{4}}{P_{2} P_{3} \\left(1 - \\frac{P_{4}^{2}}{P_{2} P_{3}}\\right)} - \\frac{x_{1} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)}{P_{2} P_{3}^{2} \\left(1 - \\frac{P_{4}^{2}}{P_{2} P_{3}}\\right)}, \\ \\frac{P_{1} P_{4} x_{0}}{P_{3}} - \\frac{P_{1} x_{2}}{P_{3}} + x_{3} \\left(- P_{7} x_{4} + P_{8}\\right), \\ \\frac{P_{1} P_{4} x_{1}}{P_{3}} - \\frac{P_{1} x_{3}}{P_{3}} - x_{2} \\left(- P_{7} x_{4} + P_{8}\\right), \\ - \\frac{P_{11}}{P_{5}} - \\frac{P_{6} x_{4}}{P_{5}} + \\frac{P_{4} P_{7} \\left(- x_{0} x_{3} + x_{1} x_{2}\\right)}{P_{3} P_{5}}\\right]$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x0: d-axis stator current\n", + "x1: q-axis stator current\n", + "x2: d-axis rotor flux\n", + "x3: q-axis rotor flux\n", + "x4: rotor mechanical speed\n" + ] + } + ], + "source": [ + "display(Math(r\"\\dot{x} = \" + latex(motor_rhs)))\n", + "\n", + "for state, label in zip(\n", + " motor_states,\n", + " [\"d-axis stator current\", \"q-axis stator current\", \"d-axis rotor flux\", \"q-axis rotor flux\", \"rotor mechanical speed\"],\n", + "):\n", + " print(f\"{state}: {label}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "1a2c5a01", + "metadata": {}, + "source": [ + "## Simulate the full-order model\n", + "\n", + "The first simulation uses no applied load torque, so the motor accelerates from rest under the nominal voltage. This full fifth-order solution is the reference trajectory for the first reduction comparison.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ca7cf4fe", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "timepoints = np.linspace(0.0, 2.0, 201)\n", + "full_solution = solve_ode(motor_system, timepoints).T\n", + "rotor_speed = full_solution[4]\n", + "\n", + "fig, ax = plt.subplots(figsize=(7.5, 4))\n", + "ax.plot(timepoints, rotor_speed, linewidth=2.5, label=\"fifth-order model\")\n", + "ax.set_xlabel(\"Time (s)\")\n", + "ax.set_ylabel(r\"$\\Omega$ (rad/s)\")\n", + "ax.set_title(\"Rotor-speed response\")\n", + "ax.grid(alpha=0.3)\n", + "ax.legend()\n", + "fig.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "22c89b7f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "torque_gain = motor_system.params_dict[p] * motor_system.params_dict[Msr] / motor_system.params_dict[Lr]\n", + "electromagnetic_torque = torque_gain * (\n", + " full_solution[2] * full_solution[1]\n", + " - full_solution[3] * full_solution[0]\n", + ")\n", + "\n", + "fig, axes = plt.subplots(3, 1, figsize=(8, 8), sharex=True)\n", + "\n", + "axes[0].plot(timepoints, electromagnetic_torque, linewidth=2, label=r\"$T_e$\")\n", + "axes[0].set_ylabel(r\"$T_e$ (N m)\")\n", + "axes[0].set_title(\"Electromagnetic torque\")\n", + "axes[0].grid(alpha=0.3)\n", + "axes[0].legend()\n", + "\n", + "axes[1].plot(timepoints, full_solution[0], linewidth=2, label=r\"$i_{sd}$\")\n", + "axes[1].plot(timepoints, full_solution[1], linewidth=2, label=r\"$i_{sq}$\")\n", + "axes[1].set_ylabel(\"Current (A)\")\n", + "axes[1].set_title(\"Stator currents\")\n", + "axes[1].grid(alpha=0.3)\n", + "axes[1].legend()\n", + "\n", + "axes[2].plot(timepoints, full_solution[2], linewidth=2, label=r\"$\\phi_{rd}$\")\n", + "axes[2].plot(timepoints, full_solution[3], linewidth=2, label=r\"$\\phi_{rq}$\")\n", + "axes[2].set_xlabel(\"Time (s)\")\n", + "axes[2].set_ylabel(\"Flux\")\n", + "axes[2].set_title(\"Rotor fluxes\")\n", + "axes[2].grid(alpha=0.3)\n", + "axes[2].legend()\n", + "\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3f1e8f68", + "metadata": {}, + "source": [ + "## Choose reduced-order models\n", + "\n", + "Using AutoReduce, we explore various quasi-steady-state reductions by explicitly listing the states that remain dynamic. One candidate keeps only a stator current and speed. One candidate keeps the two rotor fluxes and speed, matching the third-order state choice discussed in the reference paper. The other candidates retain nearby current-flux-speed combinations.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "956b7746", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Successful solution obtained with states: [x0, x4]!\n", + "Successful solution obtained with states: [x2, x3, x4]!\n", + "Successful solution obtained with states: [x0, x3, x4]!\n", + "Successful solution obtained with states: [x0, x2, x3, x4]!\n" + ] + } + ], + "source": [ + "reduction_timepoints_ssm = np.linspace(0.05, 2.0, 5)\n", + "\n", + "reduced_current_speed, _ = solve_timescale_separation(\n", + " motor_system,\n", + " [i_sd, Omega],\n", + " timepoints_ode=timepoints,\n", + " timepoints_ssm=reduction_timepoints_ssm,\n", + ")\n", + "\n", + "reduced_paper_flux_speed, _ = solve_timescale_separation(\n", + " motor_system,\n", + " [phi_rd, phi_rq, Omega],\n", + " timepoints_ode=timepoints,\n", + " timepoints_ssm=reduction_timepoints_ssm,\n", + ")\n", + "\n", + "reduced_current_flux_speed, _ = solve_timescale_separation(\n", + " motor_system,\n", + " [i_sd, phi_rq, Omega],\n", + " timepoints_ode=timepoints,\n", + " timepoints_ssm=reduction_timepoints_ssm,\n", + ")\n", + "\n", + "reduced_four_state, _ = solve_timescale_separation(\n", + " motor_system,\n", + " [i_sd, phi_rd, phi_rq, Omega],\n", + " timepoints_ode=timepoints,\n", + " timepoints_ssm=reduction_timepoints_ssm,\n", + ")\n", + "\n", + "motor_reduced_models = [\n", + " (\"current-speed: i_sd, Omega\", reduced_current_speed),\n", + " (\"paper flux-speed: phi_rd, phi_rq, Omega\", reduced_paper_flux_speed),\n", + " (\"current-flux-speed: i_sd, phi_rq, Omega\", reduced_current_flux_speed),\n", + " (\"four-state: i_sd, phi_rd, phi_rq, Omega\", reduced_four_state),\n", + "]\n", + "\n", + "for _, reduced_model in motor_reduced_models:\n", + " reduced_model.C = [[1 if state == Omega else 0 for state in reduced_model.x]]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a33d7f34", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "current-speed: i_sd, Omega\n", + "retained states: [x0, x4]\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle \\text{reduced equations: } \\left[ \\frac{P_{3} \\left(- P_{0}^{2} P_{1}^{2} x_{0} - P_{0}^{2} P_{3}^{2} P_{7}^{2} x_{0} x_{4}^{2} + 2 P_{0}^{2} P_{3}^{2} P_{7} P_{8} x_{0} x_{4} - P_{0}^{2} P_{3}^{2} P_{8}^{2} x_{0} + P_{0} P_{1}^{2} P_{9} + 2 P_{0} P_{1} P_{4}^{2} P_{7} P_{8} x_{0} x_{4} - 2 P_{0} P_{1} P_{4}^{2} P_{8}^{2} x_{0} + P_{0} P_{3}^{2} P_{7}^{2} P_{9} x_{4}^{2} - 2 P_{0} P_{3}^{2} P_{7} P_{8} P_{9} x_{4} + P_{0} P_{3}^{2} P_{8}^{2} P_{9} + P_{1}^{2} P_{10} P_{2} P_{8} - P_{1}^{2} P_{2}^{2} P_{8}^{2} x_{0} - P_{1} P_{4}^{2} P_{7} P_{8} P_{9} x_{4} + P_{1} P_{4}^{2} P_{8}^{2} P_{9} + P_{10} P_{2} P_{3}^{2} P_{7}^{2} P_{8} x_{4}^{2} - 2 P_{10} P_{2} P_{3}^{2} P_{7} P_{8}^{2} x_{4} + P_{10} P_{2} P_{3}^{2} P_{8}^{3} - P_{10} P_{3} P_{4}^{2} P_{7}^{2} P_{8} x_{4}^{2} + 2 P_{10} P_{3} P_{4}^{2} P_{7} P_{8}^{2} x_{4} - P_{10} P_{3} P_{4}^{2} P_{8}^{3} - P_{2}^{2} P_{3}^{2} P_{7}^{2} P_{8}^{2} x_{0} x_{4}^{2} + 2 P_{2}^{2} P_{3}^{2} P_{7} P_{8}^{3} x_{0} x_{4} - P_{2}^{2} P_{3}^{2} P_{8}^{4} x_{0} + 2 P_{2} P_{3} P_{4}^{2} P_{7}^{2} P_{8}^{2} x_{0} x_{4}^{2} - 4 P_{2} P_{3} P_{4}^{2} P_{7} P_{8}^{3} x_{0} x_{4} + 2 P_{2} P_{3} P_{4}^{2} P_{8}^{4} x_{0} - P_{4}^{4} P_{7}^{2} P_{8}^{2} x_{0} x_{4}^{2} + 2 P_{4}^{4} P_{7} P_{8}^{3} x_{0} x_{4} - P_{4}^{4} P_{8}^{4} x_{0}\\right)}{P_{0} P_{1}^{2} P_{2} P_{3} - P_{0} P_{1}^{2} P_{4}^{2} + P_{0} P_{2} P_{3}^{3} P_{7}^{2} x_{4}^{2} - 2 P_{0} P_{2} P_{3}^{3} P_{7} P_{8} x_{4} + P_{0} P_{2} P_{3}^{3} P_{8}^{2} - P_{0} P_{3}^{2} P_{4}^{2} P_{7}^{2} x_{4}^{2} + 2 P_{0} P_{3}^{2} P_{4}^{2} P_{7} P_{8} x_{4} - P_{0} P_{3}^{2} P_{4}^{2} P_{8}^{2} - P_{1} P_{2} P_{3} P_{4}^{2} P_{7} P_{8} x_{4} + P_{1} P_{2} P_{3} P_{4}^{2} P_{8}^{2} + P_{1} P_{4}^{4} P_{7} P_{8} x_{4} - P_{1} P_{4}^{4} P_{8}^{2}}, \\ \\frac{P_{3} \\left(- P_{11} - P_{6} x_{4}\\right) \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{0} P_{1}^{2} + P_{0} P_{3}^{2} P_{7}^{2} x_{4}^{2} - 2 P_{0} P_{3}^{2} P_{7} P_{8} x_{4} + P_{0} P_{3}^{2} P_{8}^{2} - P_{1} P_{4}^{2} P_{7} P_{8} x_{4} + P_{1} P_{4}^{2} P_{8}^{2}\\right)^{2} - P_{4}^{2} P_{7} \\left(P_{1} x_{0} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{0} P_{3} P_{7} x_{0} x_{4} - P_{0} P_{3} P_{8} x_{0} + P_{1} P_{10} - P_{1} P_{2} P_{8} x_{0}\\right) \\left(P_{0} P_{1}^{2} + P_{0} P_{3}^{2} P_{7}^{2} x_{4}^{2} - 2 P_{0} P_{3}^{2} P_{7} P_{8} x_{4} + P_{0} P_{3}^{2} P_{8}^{2} - P_{1} P_{4}^{2} P_{7} P_{8} x_{4} + P_{1} P_{4}^{2} P_{8}^{2}\\right) - \\left(P_{1}^{2} P_{4}^{2} \\left(P_{0} P_{3} P_{7} x_{0} x_{4} - P_{0} P_{3} P_{8} x_{0} + P_{1} P_{10} - P_{1} P_{2} P_{8} x_{0}\\right) - P_{3} P_{4}^{2} P_{7} x_{4} \\left(- P_{3} P_{7} x_{4} \\left(P_{0} P_{3} P_{7} x_{0} x_{4} - P_{0} P_{3} P_{8} x_{0} + P_{1} P_{10} - P_{1} P_{2} P_{8} x_{0}\\right) + P_{3} P_{8} \\left(P_{0} P_{3} P_{7} x_{0} x_{4} - P_{0} P_{3} P_{8} x_{0} + P_{1} P_{10} - P_{1} P_{2} P_{8} x_{0}\\right) + x_{0} \\left(P_{0} P_{1}^{2} + P_{0} P_{3}^{2} P_{7}^{2} x_{4}^{2} - 2 P_{0} P_{3}^{2} P_{7} P_{8} x_{4} + P_{0} P_{3}^{2} P_{8}^{2} - P_{1} P_{4}^{2} P_{7} P_{8} x_{4} + P_{1} P_{4}^{2} P_{8}^{2}\\right)\\right) + P_{3} \\left(P_{10} P_{3} - P_{8} x_{0} \\left(P_{2} P_{3} - P_{4}^{2}\\right)\\right) \\left(P_{0} P_{1}^{2} + P_{0} P_{3}^{2} P_{7}^{2} x_{4}^{2} - 2 P_{0} P_{3}^{2} P_{7} P_{8} x_{4} + P_{0} P_{3}^{2} P_{8}^{2} - P_{1} P_{4}^{2} P_{7} P_{8} x_{4} + P_{1} P_{4}^{2} P_{8}^{2}\\right)\\right) \\left(- P_{3} P_{7} x_{4} \\left(P_{0} P_{3} P_{7} x_{0} x_{4} - P_{0} P_{3} P_{8} x_{0} + P_{1} P_{10} - P_{1} P_{2} P_{8} x_{0}\\right) + P_{3} P_{8} \\left(P_{0} P_{3} P_{7} x_{0} x_{4} - P_{0} P_{3} P_{8} x_{0} + P_{1} P_{10} - P_{1} P_{2} P_{8} x_{0}\\right) + x_{0} \\left(P_{0} P_{1}^{2} + P_{0} P_{3}^{2} P_{7}^{2} x_{4}^{2} - 2 P_{0} P_{3}^{2} P_{7} P_{8} x_{4} + P_{0} P_{3}^{2} P_{8}^{2} - P_{1} P_{4}^{2} P_{7} P_{8} x_{4} + P_{1} P_{4}^{2} P_{8}^{2}\\right)\\right)\\right)}{P_{3} P_{5} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{0} P_{1}^{2} + P_{0} P_{3}^{2} P_{7}^{2} x_{4}^{2} - 2 P_{0} P_{3}^{2} P_{7} P_{8} x_{4} + P_{0} P_{3}^{2} P_{8}^{2} - P_{1} P_{4}^{2} P_{7} P_{8} x_{4} + P_{1} P_{4}^{2} P_{8}^{2}\\right)^{2}}\\right]$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "paper flux-speed: phi_rd, phi_rq, Omega\n", + "retained states: [x2, x3, x4]\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle \\text{reduced equations: } \\left[ \\frac{P_{1} P_{4} \\left(- P_{3} P_{8} \\left(P_{2} P_{3} - P_{4}^{2}\\right) \\left(- P_{0} P_{1} P_{3}^{2} P_{4} x_{3} - P_{0} P_{10} P_{3}^{4} + P_{0} P_{3}^{3} P_{4} P_{7} x_{2} x_{4} - P_{1}^{2} P_{4}^{3} x_{3} - P_{1} P_{10} P_{3}^{2} P_{4}^{2} + P_{1} P_{3} P_{4}^{3} P_{7} x_{2} x_{4} + P_{1} P_{3} P_{4} P_{8} x_{2} \\left(P_{2} P_{3} - P_{4}^{2}\\right) + P_{3}^{3} P_{8} P_{9} \\left(P_{2} P_{3} - P_{4}^{2}\\right) + P_{3}^{2} P_{4} P_{7} P_{8} x_{3} x_{4} \\left(P_{2} P_{3} - P_{4}^{2}\\right)\\right) + \\left(P_{3}^{2} P_{8}^{2} \\left(P_{2} P_{3} - P_{4}^{2}\\right)^{2} + \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)^{2}\\right) \\left(P_{1} P_{4} x_{2} + P_{3}^{2} P_{9} + P_{3} P_{4} P_{7} x_{3} x_{4}\\right)\\right) - P_{1} x_{2} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{3}^{2} P_{8}^{2} \\left(P_{2} P_{3} - P_{4}^{2}\\right)^{2} + \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)^{2}\\right) - P_{3} x_{3} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{7} x_{4} - P_{8}\\right) \\left(P_{3}^{2} P_{8}^{2} \\left(P_{2} P_{3} - P_{4}^{2}\\right)^{2} + \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)^{2}\\right)}{P_{3} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{3}^{2} P_{8}^{2} \\left(P_{2} P_{3} - P_{4}^{2}\\right)^{2} + \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)^{2}\\right)}, \\ \\frac{- P_{1} P_{4} \\left(- P_{0} P_{1} P_{3}^{2} P_{4} x_{3} - P_{0} P_{10} P_{3}^{4} + P_{0} P_{3}^{3} P_{4} P_{7} x_{2} x_{4} - P_{1}^{2} P_{4}^{3} x_{3} - P_{1} P_{10} P_{3}^{2} P_{4}^{2} + P_{1} P_{3} P_{4}^{3} P_{7} x_{2} x_{4} + P_{1} P_{3} P_{4} P_{8} x_{2} \\left(P_{2} P_{3} - P_{4}^{2}\\right) + P_{3}^{3} P_{8} P_{9} \\left(P_{2} P_{3} - P_{4}^{2}\\right) + P_{3}^{2} P_{4} P_{7} P_{8} x_{3} x_{4} \\left(P_{2} P_{3} - P_{4}^{2}\\right)\\right) - P_{1} x_{3} \\left(P_{3}^{2} P_{8}^{2} \\left(P_{2} P_{3} - P_{4}^{2}\\right)^{2} + \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)^{2}\\right) + P_{3} x_{2} \\left(P_{7} x_{4} - P_{8}\\right) \\left(P_{3}^{2} P_{8}^{2} \\left(P_{2} P_{3} - P_{4}^{2}\\right)^{2} + \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)^{2}\\right)}{P_{3} \\left(P_{3}^{2} P_{8}^{2} \\left(P_{2} P_{3} - P_{4}^{2}\\right)^{2} + \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)^{2}\\right)}, \\ \\frac{P_{3} \\left(- P_{11} - P_{6} x_{4}\\right) \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{3}^{2} P_{8}^{2} \\left(P_{2} P_{3} - P_{4}^{2}\\right)^{2} + \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)^{2}\\right) - P_{4} P_{7} \\left(x_{2} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(- P_{0} P_{1} P_{3}^{2} P_{4} x_{3} - P_{0} P_{10} P_{3}^{4} + P_{0} P_{3}^{3} P_{4} P_{7} x_{2} x_{4} - P_{1}^{2} P_{4}^{3} x_{3} - P_{1} P_{10} P_{3}^{2} P_{4}^{2} + P_{1} P_{3} P_{4}^{3} P_{7} x_{2} x_{4} + P_{1} P_{3} P_{4} P_{8} x_{2} \\left(P_{2} P_{3} - P_{4}^{2}\\right) + P_{3}^{3} P_{8} P_{9} \\left(P_{2} P_{3} - P_{4}^{2}\\right) + P_{3}^{2} P_{4} P_{7} P_{8} x_{3} x_{4} \\left(P_{2} P_{3} - P_{4}^{2}\\right)\\right) + x_{3} \\left(- P_{3} P_{8} \\left(P_{2} P_{3} - P_{4}^{2}\\right) \\left(- P_{0} P_{1} P_{3}^{2} P_{4} x_{3} - P_{0} P_{10} P_{3}^{4} + P_{0} P_{3}^{3} P_{4} P_{7} x_{2} x_{4} - P_{1}^{2} P_{4}^{3} x_{3} - P_{1} P_{10} P_{3}^{2} P_{4}^{2} + P_{1} P_{3} P_{4}^{3} P_{7} x_{2} x_{4} + P_{1} P_{3} P_{4} P_{8} x_{2} \\left(P_{2} P_{3} - P_{4}^{2}\\right) + P_{3}^{3} P_{8} P_{9} \\left(P_{2} P_{3} - P_{4}^{2}\\right) + P_{3}^{2} P_{4} P_{7} P_{8} x_{3} x_{4} \\left(P_{2} P_{3} - P_{4}^{2}\\right)\\right) + \\left(P_{3}^{2} P_{8}^{2} \\left(P_{2} P_{3} - P_{4}^{2}\\right)^{2} + \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)^{2}\\right) \\left(P_{1} P_{4} x_{2} + P_{3}^{2} P_{9} + P_{3} P_{4} P_{7} x_{3} x_{4}\\right)\\right)\\right)}{P_{3} P_{5} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{3}^{2} P_{8}^{2} \\left(P_{2} P_{3} - P_{4}^{2}\\right)^{2} + \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)^{2}\\right)}\\right]$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "current-flux-speed: i_sd, phi_rq, Omega\n", + "retained states: [x0, x3, x4]\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle \\text{reduced equations: } \\left[ \\frac{P_{1} P_{3} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{3} P_{9} + P_{4} P_{7} x_{3} x_{4}\\right) + P_{1} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{4} \\left(P_{1} P_{4} x_{0} - P_{3} P_{7} x_{3} x_{4} + P_{3} P_{8} x_{3}\\right) - x_{0} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)\\right) + P_{3} P_{8} \\left(P_{1} \\left(P_{1} P_{4} x_{3} + P_{10} P_{3}^{2} - P_{3} P_{8} x_{0} \\left(P_{2} P_{3} - P_{4}^{2}\\right)\\right) - P_{3} P_{4} P_{7} x_{4} \\left(P_{1} P_{4} x_{0} - P_{3} P_{7} x_{3} x_{4} + P_{3} P_{8} x_{3}\\right)\\right) \\left(P_{2} P_{3} - P_{4}^{2}\\right)}{P_{1} P_{3} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{2} P_{3} - P_{4}^{2}\\right)}, \\ \\frac{- P_{1}^{2} x_{3} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) + P_{1} P_{4} \\left(P_{1} \\left(P_{1} P_{4} x_{3} + P_{10} P_{3}^{2} - P_{3} P_{8} x_{0} \\left(P_{2} P_{3} - P_{4}^{2}\\right)\\right) - P_{3} P_{4} P_{7} x_{4} \\left(P_{1} P_{4} x_{0} - P_{3} P_{7} x_{3} x_{4} + P_{3} P_{8} x_{3}\\right)\\right) + P_{3} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{7} x_{4} - P_{8}\\right) \\left(P_{1} P_{4} x_{0} - P_{3} P_{7} x_{3} x_{4} + P_{3} P_{8} x_{3}\\right)}{P_{1} P_{3} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)}, \\ \\frac{P_{1}^{2} P_{3} \\left(- P_{11} - P_{6} x_{4}\\right) \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) - P_{4} P_{7} \\left(P_{1}^{2} x_{0} x_{3} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) - \\left(P_{1} \\left(P_{1} P_{4} x_{3} + P_{10} P_{3}^{2} - P_{3} P_{8} x_{0} \\left(P_{2} P_{3} - P_{4}^{2}\\right)\\right) - P_{3} P_{4} P_{7} x_{4} \\left(P_{1} P_{4} x_{0} - P_{3} P_{7} x_{3} x_{4} + P_{3} P_{8} x_{3}\\right)\\right) \\left(P_{1} P_{4} x_{0} - P_{3} P_{7} x_{3} x_{4} + P_{3} P_{8} x_{3}\\right)\\right)}{P_{1}^{2} P_{3} P_{5} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)}\\right]$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "four-state: i_sd, phi_rd, phi_rq, Omega\n", + "retained states: [x0, x2, x3, x4]\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle \\text{reduced equations: } \\left[ \\frac{P_{3} P_{8} \\left(P_{2} P_{3} - P_{4}^{2}\\right) \\left(P_{1} P_{4} x_{3} + P_{10} P_{3}^{2} - P_{3} P_{4} P_{7} x_{2} x_{4} - P_{3} P_{8} x_{0} \\left(P_{2} P_{3} - P_{4}^{2}\\right)\\right) + P_{3} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{3} P_{9} + P_{4} P_{7} x_{3} x_{4}\\right) + \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{1} P_{4} x_{2} - x_{0} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)\\right)}{P_{3} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) \\left(P_{2} P_{3} - P_{4}^{2}\\right)}, \\ \\frac{P_{1} P_{4} x_{0} - P_{1} x_{2} - P_{3} x_{3} \\left(P_{7} x_{4} - P_{8}\\right)}{P_{3}}, \\ \\frac{- P_{0} P_{1} P_{3} x_{3} + P_{0} P_{3}^{2} P_{7} x_{2} x_{4} - P_{0} P_{3}^{2} P_{8} x_{2} + P_{1} P_{10} P_{3} P_{4} - P_{1} P_{2} P_{3} P_{4} P_{8} x_{0} + P_{1} P_{4}^{3} P_{8} x_{0} - P_{1} P_{4}^{2} P_{8} x_{2}}{P_{0} P_{3}^{2} + P_{1} P_{4}^{2}}, \\ \\frac{P_{3} \\left(- P_{11} - P_{6} x_{4}\\right) \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) - P_{4} P_{7} \\left(x_{0} x_{3} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right) - x_{2} \\left(P_{1} P_{4} x_{3} + P_{10} P_{3}^{2} - P_{3} P_{4} P_{7} x_{2} x_{4} - P_{3} P_{8} x_{0} \\left(P_{2} P_{3} - P_{4}^{2}\\right)\\right)\\right)}{P_{3} P_{5} \\left(P_{0} P_{3}^{2} + P_{1} P_{4}^{2}\\right)}\\right]$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "for model_name, reduced_model in motor_reduced_models:\n", + " print(model_name)\n", + " print(\"retained states:\", reduced_model.x)\n", + " display(Math(r\"\\text{reduced equations: } \" + latex(reduced_model.f)))\n", + " print()\n" + ] + }, + { + "cell_type": "markdown", + "id": "3fc962e5", + "metadata": {}, + "source": [ + "## Compare rotor-speed outputs\n", + "\n", + "The comparison uses rotor speed because that is the selected output, $y=\\Omega$. The errors are small near the final speed, but the mean absolute error still shows which state choices follow the full transient more closely.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1ee25ef2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "[{'model': 'current-speed: i_sd, Omega',\n", + " 'MAE': 2.603328658858775,\n", + " 'RMSE': 4.55861453273446,\n", + " 'final speed error': 1.332148315213999e-05},\n", + " {'model': 'paper flux-speed: phi_rd, phi_rq, Omega',\n", + " 'MAE': 2.583378656655576,\n", + " 'RMSE': 4.475722796613856,\n", + " 'final speed error': 3.6656476822827244e-06},\n", + " {'model': 'current-flux-speed: i_sd, phi_rq, Omega',\n", + " 'MAE': 2.3547724655388906,\n", + " 'RMSE': 4.15137199393485,\n", + " 'final speed error': 1.538109307830382e-05},\n", + " {'model': 'four-state: i_sd, phi_rd, phi_rq, Omega',\n", + " 'MAE': 2.4685029770172715,\n", + " 'RMSE': 4.267054728331146,\n", + " 'final speed error': 4.355007803269473e-06}]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "full_speed = full_solution[4]\n", + "motor_reduction_summary = []\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 4.5))\n", + "ax.plot(\n", + " timepoints,\n", + " full_speed,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full fifth-order model\",\n", + ")\n", + "\n", + "for model_name, reduced_model in motor_reduced_models:\n", + " reduced_solution = solve_ode(reduced_model, timepoints).T\n", + " reduced_speed = np.ravel(np.asarray(reduced_model.C, dtype=float) @ reduced_solution)\n", + " speed_error = full_speed - reduced_speed\n", + "\n", + " motor_reduction_summary.append({\n", + " \"model\": model_name,\n", + " \"MAE\": float(np.mean(np.abs(speed_error))),\n", + " \"RMSE\": float(np.sqrt(np.mean(speed_error**2))),\n", + " \"final speed error\": float(abs(full_speed[-1] - reduced_speed[-1])),\n", + " })\n", + "\n", + " ax.plot(\n", + " timepoints,\n", + " reduced_speed,\n", + " linewidth=2,\n", + " label=model_name,\n", + " )\n", + "\n", + "ax.set_xlabel(\"Time (s)\")\n", + "ax.set_ylabel(r\"$\\Omega$ (rad/s)\")\n", + "ax.set_title(\"Full and reduced rotor-speed trajectories\")\n", + "ax.grid(alpha=0.3)\n", + "ax.legend(fontsize=8)\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "motor_reduction_summary\n" + ] + }, + { + "cell_type": "markdown", + "id": "3986970e", + "metadata": {}, + "source": [ + "## Change operating conditions\n", + "\n", + "A reduced model that works for one operating point may not be the best choice after the load, supply voltage, or rotor resistance changes. The following cells keep the same reduced-state choices and evaluate them under four constant conditions: no load, a larger load torque, a voltage sag, and increased rotor resistance.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "013a5db2", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "default_motor_params_dict = motor_system.params_dict.copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "cb70fac5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\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", + "
modelspeed MAEfinal speed errorx3 MAEfinal x3 error
0current-speed: i_sd, Omega2.6033290.000013NaNNaN
1paper flux-speed: phi_rd, phi_rq, Omega2.5833790.0000040.0472984.391621e-09
2current-flux-speed: i_sd, phi_rq, Omega2.3547720.0000150.0501382.235849e-08
3four-state: i_sd, phi_rd, phi_rq, Omega2.4685030.0000040.0455361.116816e-08
\n", + "
" + ], + "text/plain": [ + " model speed MAE final speed error \\\n", + "0 current-speed: i_sd, Omega 2.603329 0.000013 \n", + "1 paper flux-speed: phi_rd, phi_rq, Omega 2.583379 0.000004 \n", + "2 current-flux-speed: i_sd, phi_rq, Omega 2.354772 0.000015 \n", + "3 four-state: i_sd, phi_rd, phi_rq, Omega 2.468503 0.000004 \n", + "\n", + " x3 MAE final x3 error \n", + "0 NaN NaN \n", + "1 0.047298 4.391621e-09 \n", + "2 0.050138 2.235849e-08 \n", + "3 0.045536 1.116816e-08 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "condition_name = \"nominal no load\"\n", + "condition_params_dict = default_motor_params_dict.copy()\n", + "motor_system.set_param_dict(condition_params_dict)\n", + "\n", + "condition_solution = solve_ode(motor_system, timepoints).T\n", + "condition_speed = condition_solution[4]\n", + "condition_x3 = condition_solution[3]\n", + "\n", + "nominal_no_load_summary = []\n", + "fig, axes = plt.subplots(2, 1, figsize=(8, 6.5), sharex=True)\n", + "\n", + "axes[0].plot(\n", + " timepoints,\n", + " condition_speed,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full model\",\n", + ")\n", + "axes[1].plot(\n", + " timepoints,\n", + " condition_x3,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full model\",\n", + ")\n", + "\n", + "for model_name, reduced_model in motor_reduced_models:\n", + " reduced_model.set_param_dict(condition_params_dict)\n", + " reduced_solution = solve_ode(reduced_model, timepoints).T\n", + " reduced_speed = np.ravel(np.asarray(reduced_model.C, dtype=float) @ reduced_solution)\n", + " speed_error = condition_speed - reduced_speed\n", + "\n", + " summary_row = {\n", + " \"model\": model_name,\n", + " \"speed MAE\": float(np.mean(np.abs(speed_error))),\n", + " \"final speed error\": float(abs(condition_speed[-1] - reduced_speed[-1])),\n", + " \"x3 MAE\": np.nan,\n", + " \"final x3 error\": np.nan,\n", + " }\n", + "\n", + " axes[0].plot(timepoints, reduced_speed, linewidth=2, label=model_name)\n", + "\n", + " if phi_rq in reduced_model.x:\n", + " reduced_x3 = reduced_solution[reduced_model.x.index(phi_rq)]\n", + " x3_error = condition_x3 - reduced_x3\n", + " summary_row[\"x3 MAE\"] = float(np.mean(np.abs(x3_error)))\n", + " summary_row[\"final x3 error\"] = float(abs(condition_x3[-1] - reduced_x3[-1]))\n", + " axes[1].plot(timepoints, reduced_x3, linewidth=2, label=model_name)\n", + "\n", + " nominal_no_load_summary.append(summary_row)\n", + "\n", + "axes[0].set_title(condition_name)\n", + "axes[0].set_ylabel(r\"$\\Omega$ (rad/s)\")\n", + "axes[0].grid(alpha=0.3)\n", + "axes[0].legend(fontsize=7)\n", + "axes[1].set_xlabel(\"Time (s)\")\n", + "axes[1].set_ylabel(r\"$x_3$, q-axis rotor flux\")\n", + "axes[1].grid(alpha=0.3)\n", + "axes[1].legend(fontsize=7)\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "display(pd.DataFrame(nominal_no_load_summary))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c69bd04c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\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", + "
modelspeed MAEfinal speed errorx3 MAEfinal x3 error
0current-speed: i_sd, Omega4.9281970.005382NaNNaN
1paper flux-speed: phi_rd, phi_rq, Omega4.9213550.0070070.0758410.000044
2current-flux-speed: i_sd, phi_rq, Omega4.5258780.0034530.0782660.000030
3four-state: i_sd, phi_rd, phi_rq, Omega4.6638980.0076060.0725970.000051
\n", + "
" + ], + "text/plain": [ + " model speed MAE final speed error \\\n", + "0 current-speed: i_sd, Omega 4.928197 0.005382 \n", + "1 paper flux-speed: phi_rd, phi_rq, Omega 4.921355 0.007007 \n", + "2 current-flux-speed: i_sd, phi_rq, Omega 4.525878 0.003453 \n", + "3 four-state: i_sd, phi_rd, phi_rq, Omega 4.663898 0.007606 \n", + "\n", + " x3 MAE final x3 error \n", + "0 NaN NaN \n", + "1 0.075841 0.000044 \n", + "2 0.078266 0.000030 \n", + "3 0.072597 0.000051 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "condition_name = \"200 N m load\"\n", + "condition_params_dict = default_motor_params_dict.copy()\n", + "condition_params_dict[Tl] = 200.0\n", + "motor_system.set_param_dict(condition_params_dict)\n", + "\n", + "condition_solution = solve_ode(motor_system, timepoints).T\n", + "condition_speed = condition_solution[4]\n", + "condition_x3 = condition_solution[3]\n", + "\n", + "load_summary = []\n", + "fig, axes = plt.subplots(2, 1, figsize=(8, 6.5), sharex=True)\n", + "\n", + "axes[0].plot(\n", + " timepoints,\n", + " condition_speed,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full model\",\n", + ")\n", + "axes[1].plot(\n", + " timepoints,\n", + " condition_x3,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full model\",\n", + ")\n", + "\n", + "for model_name, reduced_model in motor_reduced_models:\n", + " reduced_model.set_param_dict(condition_params_dict)\n", + " reduced_solution = solve_ode(reduced_model, timepoints).T\n", + " reduced_speed = np.ravel(np.asarray(reduced_model.C, dtype=float) @ reduced_solution)\n", + " speed_error = condition_speed - reduced_speed\n", + "\n", + " summary_row = {\n", + " \"model\": model_name,\n", + " \"speed MAE\": float(np.mean(np.abs(speed_error))),\n", + " \"final speed error\": float(abs(condition_speed[-1] - reduced_speed[-1])),\n", + " \"x3 MAE\": np.nan,\n", + " \"final x3 error\": np.nan,\n", + " }\n", + "\n", + " axes[0].plot(timepoints, reduced_speed, linewidth=2, label=model_name)\n", + "\n", + " if phi_rq in reduced_model.x:\n", + " reduced_x3 = reduced_solution[reduced_model.x.index(phi_rq)]\n", + " x3_error = condition_x3 - reduced_x3\n", + " summary_row[\"x3 MAE\"] = float(np.mean(np.abs(x3_error)))\n", + " summary_row[\"final x3 error\"] = float(abs(condition_x3[-1] - reduced_x3[-1]))\n", + " axes[1].plot(timepoints, reduced_x3, linewidth=2, label=model_name)\n", + "\n", + " load_summary.append(summary_row)\n", + "\n", + "axes[0].set_title(condition_name)\n", + "axes[0].set_ylabel(r\"$\\Omega$ (rad/s)\")\n", + "axes[0].grid(alpha=0.3)\n", + "axes[0].legend(fontsize=7)\n", + "axes[1].set_xlabel(\"Time (s)\")\n", + "axes[1].set_ylabel(r\"$x_3$, q-axis rotor flux\")\n", + "axes[1].grid(alpha=0.3)\n", + "axes[1].legend(fontsize=7)\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "display(pd.DataFrame(load_summary))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b3b3e54a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\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", + "
modelspeed MAEfinal speed errorx3 MAEfinal x3 error
0current-speed: i_sd, Omega2.6742390.000282NaNNaN
1paper flux-speed: phi_rd, phi_rq, Omega2.6555660.0002300.0468223.023468e-07
2current-flux-speed: i_sd, phi_rq, Omega2.4245680.0003580.0496822.879184e-07
3four-state: i_sd, phi_rd, phi_rq, Omega2.5398470.0002440.0450895.677020e-07
\n", + "
" + ], + "text/plain": [ + " model speed MAE final speed error \\\n", + "0 current-speed: i_sd, Omega 2.674239 0.000282 \n", + "1 paper flux-speed: phi_rd, phi_rq, Omega 2.655566 0.000230 \n", + "2 current-flux-speed: i_sd, phi_rq, Omega 2.424568 0.000358 \n", + "3 four-state: i_sd, phi_rd, phi_rq, Omega 2.539847 0.000244 \n", + "\n", + " x3 MAE final x3 error \n", + "0 NaN NaN \n", + "1 0.046822 3.023468e-07 \n", + "2 0.049682 2.879184e-07 \n", + "3 0.045089 5.677020e-07 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "condition_name = \"10 percent voltage sag\"\n", + "condition_params_dict = default_motor_params_dict.copy()\n", + "condition_params_dict[vsd] = np.sqrt(2.0) * (0.90 * line_voltage_rms) / np.sqrt(3.0)\n", + "motor_system.set_param_dict(condition_params_dict)\n", + "\n", + "condition_solution = solve_ode(motor_system, timepoints).T\n", + "condition_speed = condition_solution[4]\n", + "condition_x3 = condition_solution[3]\n", + "\n", + "voltage_sag_summary = []\n", + "fig, axes = plt.subplots(2, 1, figsize=(8, 6.5), sharex=True)\n", + "\n", + "axes[0].plot(\n", + " timepoints,\n", + " condition_speed,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full model\",\n", + ")\n", + "axes[1].plot(\n", + " timepoints,\n", + " condition_x3,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full model\",\n", + ")\n", + "\n", + "for model_name, reduced_model in motor_reduced_models:\n", + " reduced_model.set_param_dict(condition_params_dict)\n", + " reduced_solution = solve_ode(reduced_model, timepoints).T\n", + " reduced_speed = np.ravel(np.asarray(reduced_model.C, dtype=float) @ reduced_solution)\n", + " speed_error = condition_speed - reduced_speed\n", + "\n", + " summary_row = {\n", + " \"model\": model_name,\n", + " \"speed MAE\": float(np.mean(np.abs(speed_error))),\n", + " \"final speed error\": float(abs(condition_speed[-1] - reduced_speed[-1])),\n", + " \"x3 MAE\": np.nan,\n", + " \"final x3 error\": np.nan,\n", + " }\n", + "\n", + " axes[0].plot(timepoints, reduced_speed, linewidth=2, label=model_name)\n", + "\n", + " if phi_rq in reduced_model.x:\n", + " reduced_x3 = reduced_solution[reduced_model.x.index(phi_rq)]\n", + " x3_error = condition_x3 - reduced_x3\n", + " summary_row[\"x3 MAE\"] = float(np.mean(np.abs(x3_error)))\n", + " summary_row[\"final x3 error\"] = float(abs(condition_x3[-1] - reduced_x3[-1]))\n", + " axes[1].plot(timepoints, reduced_x3, linewidth=2, label=model_name)\n", + "\n", + " voltage_sag_summary.append(summary_row)\n", + "\n", + "axes[0].set_title(condition_name)\n", + "axes[0].set_ylabel(r\"$\\Omega$ (rad/s)\")\n", + "axes[0].grid(alpha=0.3)\n", + "axes[0].legend(fontsize=7)\n", + "axes[1].set_xlabel(\"Time (s)\")\n", + "axes[1].set_ylabel(r\"$x_3$, q-axis rotor flux\")\n", + "axes[1].grid(alpha=0.3)\n", + "axes[1].legend(fontsize=7)\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "display(pd.DataFrame(voltage_sag_summary))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "375e5db9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAKACAYAAAAB9u5NAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQV4FFcXhk8EggZ3d9cWh6KFUtxaKMVKkQItVkqhpXhxd4o7xX+8uLu7uzvBkpDs/3w3zDK72Q0bXcn39tmyO3tn5s6dO5tz7jE3g8FgEEIIIYQQQggJB+7h2ZkQQgghhBBCqFgQQgghhBBCIgRaLAghhBBCCCHhhooFIYQQQgghJNxQsSCEEEIIIYSEGyoWhBBCCCGEkHBDxYIQQgghhBASbqhYEEIIIYQQQsINFQtCCCGEEEJIuKFiQQghJFoQK1Ys+fXXXyW6w3EghEQWVCwIIRHGrl27pFmzZpI1a1aJEyeO5MyZU7p27SpPnjwJ1vbHH38UNze3YC9PT0/ekQ/s379fjcnKlSujbEw6dOgg8eLF4z3QgXvw+++/c0wIIeQT8C84ISRCuH37tnzxxRdSq1Yt+ffff5VScejQIWnZsqUsX75cjh07JgkTJjTZJ0GCBPL8+XPeARIlvHv3jiPNcSCERCK0WBBCIubHxN1dhg8frlbXCxcurCwWZcuWlSlTpsj169dl2rRpHGlCCCHEhaFiQQiJEFKnTq3cnsyBWxS4du1ahI502rRp5fvvv5eDBw9KiRIlJHbs2JIxY0YZOnSoGAyGYO2XLl0qpUqVUm4+mtKzY8cOi8c8evSo+h7tNJ/8169fyx9//CE5cuRQPuqZMmWSTp06ydOnT437o02PHj3UNceMGVNSpEihLDaPHj0yttm+fbtyrdmwYYNMnTpVMmfOrI5XrFgxOXDggLHdokWL1HWBOnXqGF3FBg8ebHVM9MceP368ZMmSRTw8POT48ePq+02bNkm5cuWMY4Dj692sqlevLhMmTFDXoXdPgzVK41PH0NzckiZNKs+ePZOmTZtK4sSJJV++fFb7Xb9+fTVmDx48kG+++UZZtkqXLq2+w72cNGmSFCpUSN1jWLnQz9OnT5scY+7cufL555+Lt7e3JEuWTCpXrhzs/lqKLQhpPyjEuH4wZMgQ43jUrl3buD/mnN6NL126dNKmTRsT9z9YSvB9nz59ZOvWrUrxRl+yZ88uCxYsCDYeuObJkydLkSJFJG7cuGoeffvtt3Lp0iWTNraMiyXMxyGi+6c/3saNG+Wzzz4TLy8vtQ94+PChtGvXTo0VnhP8i/68ffvWeI7du3ebzEHMNVwrrlnPy5cv1XOI5xHjgHnUvn17uX//vkk7W85JCIkADIQQEomMHz8eUr5hzJgxJttbtmxpcHd3NyRNmtQQI0YMQ9q0adW2W7du2XTcNGnSGMqXL2/4+uuvDadPnzY8ffpUncvT09PQs2dPk7aDBw9W5xo4cKDhzp07hgcPHqg2aLt161aLxzx58qTh7t27hmXLlhlev35tKFy4sCF16tTqM851/fp1dU1jx45V+75588ZQpEgRQ4YMGQzr1q0zvHz5Uh2jWLFihty5c6tjgG3btqnxaNiwoaFv376G+/fvG65evWooWbKkIWXKlOo4Gvv27VNtV6xYYdOYaMeuW7euoVevXoZ79+6pbefOnVPHwBj88MMPhhs3bqhr69q1q2o/bdo04zHat29viBs3rsXj23oM3MfEiRMbGjRoYFi7dq0arxkzZljtd7169dS41axZ07B582bDkydPDLNnz1bf/fjjj6o/U6dONTx+/Nhw8+ZNQ5MmTQzx48c3XLhwQbVZs2aN6sOECRMMz549Mzx//tywZcsWQ/Xq1U3O4+XlpfqrYet+aNO9e/dPjj/u8fbt2w05cuQwVKpUyRAYGKi2v337Vh2jdu3aqu9XrlwxPHr0yNCqVSuDm5ub4cyZMybHad68uSF27NiG0aNHG27fvq3aLlmyxPDLL78Y29gyLtYwH4eI7p92vBo1ahi+/fZbw6VLlwyXL182bNy4UT17uNcFCxY07Nmzx+Dj42PYvXu3IWvWrCZjZs7Dhw8N48aNU8/szJkzjdvxHOF4+/fvV+fFczl58mRDnz59jG3Cek5CSOihYkEIiTQgfCZJksSQIkUKJbTp6devn2HWrFlKIILguWrVKkPGjBlVW+z3KaAEQECC8Kynbdu2SlGBMAGgqOAzBGZzypUrpwR//TFjxoypBGZzxQSC0o4dO6z2Z8SIEaoNlAE9EHQgDEEoMhf+9UDgwfbFixeHW7GoWrVqsO8yZ85syJMnTzAhqmzZsuoevXv37pOKha3HgGKBfsyfP9+mfkOxQHsoIZbGZNSoUSbb/fz8VF8aN26sPv/6668Gb2/vT57HXKC2dT9bFQuNlStXqn0gTOsFbQi36LsGBNw4ceIYOnfubNwGxQRthw4davX4to5LaBWLiOqfdjwoytqc0Pjpp5+UUoLnXo923PXr14fY9/r16xuKFy9u/Ixz4JghEd5zEkJsh65QhJBI4cWLF1KzZk3lqjB//nzlqqGnV69eKoMUXBISJUqk2q5YsUK5LPTr18+mcxQtWlRSpkxpsg1uKv7+/ipDFYArBj43aNAg2P6VKlVSAeZ6dwi4d6RKlcqk3bp165SbFILTrbF69WrVpnjx4ibbM2TIoNwzzN1yqlWrZvI5b9686t+rV69KeMFY6oFLD46ruVSZuyHBbUdzl7JGWI6h7wdibMwzgD1+/Nj4fYwYMeSrr74KNqbA/N6hLe6FNqYFChRQ8wzzae/evep+20JY99MDVzxcZ/LkyZXbmd5V6vLlyyZt4WaFvmvAnQzzQ3/PMdfAd999Z/Wcto5LaImo/mlUqVJFuUCZ9x1uf3ju9ZQpU0a11foOfQ5ueXBTQz+0OQOXRv244h7i92XUqFFWnx1bz0kICT9ULAghEc6rV6+katWqcubMGRUrULFiRZv2K1iwoPJZh3+1LcC329o2TWjVfK3RB/jAQ/hDoDlef/75pwQGBqpYAI00adIEOyaUHUvb9eA8iEXAOfTngTB0/vz5YCl3zZUX+PiDiMiSZd5X7dzmSph+m17It0Roj4HrCU3aWowHxkuPdu8g3Jrfu1mzZhn71LhxYxk9erSKUUEcDWI0oLh9SmAM634auK+IxUHftm3bpuY9BOLNmzer780VFfN7ro2T/p5jrmHOWGob2nEJLRHVPw1Lzwz6jvE1f07wr6+vr7HvAwcOlF9++UWaN28uFy9elPfv36uxxWf9uM6ePVvq1aunFiMQU5Q+fXr5+eefTWIsbD0nIST8ULEghEQoWP1HECksAQj8rFu3bqSNMIJ9rW1LkiSJ+hdBxADCI4STgIAApUzg9cEdVAWea+hXbDUQ1Hvnzp0Q+4LzIMUuzqE/j3YOBMXqMV/1j0jMrwHB058aL22crBHaY5j3AQHd2lhor5Daa8fTLBuW7t2bN29UO7Tp2LGjEvTv3r0r06dPVwIwlMmQLDFh3U8DaZURqPzPP/9Injx5VPBwSIkKbLnnmGu4tnv37lltY+u4hJaI6t+n7imUN2vPCRIagDlz5iiLB+qq4PmEEmBpbLGQMGPGDDUWJ06cUIHb2Fdv/bL1nISQ8EPFghASYWD1D24gsDjMmzfPovtRSJw8eVK53GD12BagvJgLuqtWrVICDdwcAAQMrFIuXrxYwgoUJVgjdu7cabVNjRo15MKFC0q4iSiQcUcb1/CAjDl4IXuTecasZcuWKaUB1iLtnH5+fuE6RkSBMcW5IMDbClbSGzZsqIR9CJBwcQrvfshIZO0eQBg3d/eBYBueuQYsZWMKz7hEFLb0LyTQdzxH5lmbLGE+rlAq9uzZY7EtFI/8+fNL9+7dpVWrVuo5hJtbaM9JCAkfVCwIIRECVgKRKnTLli3K5xnpJ61x8+ZN5ZcOlxEoBojHWLNmjfLfx4oo4i9sAfEMWAk/e/ascmdCKkr48nfp0sXoEgV3EbhVjBw5UqW/hHACqwpWqZGSFf71nwKrpkjB2ahRIxUHgnPhGsaNG6deAO4XiPmAYoWCgFhBhQsJqmdrq6ihBYI8hNr//vtPpYAND8OGDVOpSJEK9datW0rI+u2335QLD1LYakIcYj3garJ+/XolYIflGBEF4gUgJCKNMcYZyh3G4dSpU+qeQogEuN+DBg1SfcO9xWo66qdAodTS1lrC1v0wJlCW9WmDAVbB4VLTuXNn5U6DOYF7bclFLzTXDHef3r17y9ixY5UlBcdGbAGsK6EZl8jAlv6FBFyWYE2EqyR+K/DsY1yRKhmuaZobGn4f1q5dq543XBssjojr0LtVYn7iPi1ZskTNRyh/KMSJ/fC8au6Ftp6TEBIBhCLQmxBCrHLs2DGVYcXaC5l/9CATC9J6IqsLsjYhI1SbNm1ClW4W2W+QOalo0aIq00369OkNgwYNspg+EqlFkVoyYcKEhlixYqkUsB07dlSpXs2PaQlkyEFmoCxZsqjMUZkyZTJ06tRJpUbVZ8NBtitkTsI5kHIVaWQnTZpkTCOrZW6ylInGUvahefPmGbJly6YyS+F7XJ81Qjo22LBhg6FMmTIq0w+y5CAj1tKlS03a+Pv7G1q0aKGyPCHVKI6nvye2HANZobC/rWBuYFytgfSiJUqUMMSLF0+9ChQoYOjdu7cx8xcygyG9br58+VSfkFmsWrVqhp07d4aYDcnW/Q4ePGj4/PPP1T3FeNSqVcv4HdKs5s2bV32HjEzI1LRr1y7VbvXq1SZZktBnczB+yKqlB/MXqZORHhXHRb+QtvXixYuhGpfQZoWKqP6FdDyA9LhdunRR6V7xLGH/ihUrGhYuXKjmH8DzgucLKZ5xb0qXLm04cOCA+o1IkCCBSYYspJzFs6/dAzzX5mNgyzkJIeHHDf+LCAWFEEKiEmRgQqE2uFwRQgghxP7QFYoQQgghhBASbqhYEEIIIYQQQsINFQtCCCGEEEJIuGGMBSGEEEIIISTc0GJBCCGEEEIICTdULAghhBBCCCHhxjP8h3B9AgMDVRGg+PHjqyqrhBBCCCGERAcMBoP4+PhI6tSpVVHQkKBiYQNQKtKlSxdR94cQQgghhBCnAhXuUUMqJKhY2AAsFdqAent7iz0sJo8ePZJkyZJ9UlMkHD/OP8eDzzDHj/PPeeHzyzGM7nPw5cuXaoFdk4dDgoqFDWjuT1Aq7KVYvHv3Tp2bigXHj/PP+eAzzPHj/HNe+PxyDO1NoIPIgbaEA3D5mxBCCCGEEBJuqFgQQgghhBBCwg0VC0IIIYQQQki4oWJBCCGEEEIICTdULAghhBBCCCHhhooFIYQQQgghJNxQsSCEEEIIIYSEG9axIIQQQiKI9+/fy9u3b8Xf318CAgLUNhS1ssTr16/l+vXrKkc9XshPny9fPottX7x4IQcPHlTHRFvkk69atarVtqtXrxaDwaBeaF+lShWLbV+9eiULFixQ7QD+bdmypcSIESNYW1zX5MmTje3watu2rcSNGzdYW1z/sGHDjO3w6tChgyRKlMhiP/766y/VTw20TZkypcW2ffv2FV9fX+Nn9CF9+vQW2w4cOFB8fHyMn3/88UfJmjWrxbZDhgyRJ0+eGD83a9ZM8uTJY7HtiBEj5N69e8bPjRs3lkKFCllsO3bsWHWfNb799lspVqyYxbYTJ06UixcvGj/XrVtXvvjiC4ttp06dKqdPnzZ+rl69ulSuXNli25kzZ8qRI0eMnzEfatSoYbHt/PnzZd++fcbP5cuXl3r16llsu2TJEtmxY4fxc6lSpaRRo0YW227YsEEOHTpkrIVQpEgRNcbW2mIOaxQoUEBat25tse2WLVtk+fLlxs+5cuVS88cSu3fvloULFxo/Z86cWbp27WqxLZ632bNnGz+jQNzvv/9use3x48fln3/+MX5Onjy59O7d22Lbs2fPyoQJE4yfEyZMqOapJa5cuSIjR46UBAkSyC+//CLOgJtB+zUhIVYcxE3Fj7W9CuQ9fPhQTVQWyOP4cf45H3yGI2b8IKDjvSWhV/sjfOLECVVICoInfjO//vprSPti8H0rBt836t9A33eyf89OWQ/BJdBPDAHvJUXyJPJVxQri5/tW3vu+Fn8/Xwnw95P37/2VAHnp0nn8wRR3g0Fix44lObJlFUNAQNArMACdVP++efVKHj96pNwB3A0iMTw9JAmEafypheCsXgb1OcDfX3zfvlN9h6gFeSuWV6ygth/+MuOc2higvcIQ5G7g6RkjqK1q9+ELQ9A+AQGBQcf8cBwPN3eT42nb1Xk0gR77qr7gvw/fmaMXGdDezU01cwuhjYa+jZvuK2NfzND6YHAza2PlmCb7Wux70A5Wry2kvjiQpORIfYlqPl2eLZKx89g/bV5dqncY5tByMC0WhBBCogQlhL96IRcO75MrJ4/JuycPxe/FM0mcILakSpxAfF+/EN+3b8T/3Rt57/tODH5+8ubFC/F//VYJ9J6BBonp5i4x3NzF3T9Q3AMM4v7eIB4BBvF4L+IRIJIe2wJFvTwC3eR8118t9gU2hKb6DWfviWw/LTFF1EtPcqyYmmzxFzlxzMarhtD+MBSj9CYUbf1C0TbIehLx0lM0lnIJiWIe+r51+DGnYkEIIeSTKJeaF08l4NFteXf/jry+f1d8Ht6W108fyLvnT+TFvXvi/8pHPP3eSwz/QIkZIEHCvr9BPP1FYvgbJKb/x/XGLBbOAYE+vk0CcoAjr2m6PIFWhtvEqGDhNui3GSLgGCbbw7pfKLZba2sP7K7O2XEsovO1x4gdRxwdKhaEEBJNCXz5XN7fuiSvb1yW5zevyfO71+Xd4wfy/sUzMfi8Fnn1TmK8DRSvdwaJ6RtkATAn1odXQjv9NUaX/DyDXv6eIgHuIu89gv4NdP/wrwfeu33Y5vbhs0iAW9D+2nb3mDHE4O4ugR5uIh7uIm7u4ubuLu8DAuTVmzcS6OamvJjcPDwkSbKkIu7uIu4eqo14eKj3b9+9kxu3bkmAQdTLw9NTChT+TNw9PEXcPcXdw0Pt7+YRQ56/eClbtm2XwECDEpZieMaQpk2aiZuHu7ipc3sEub+6u8vTp89kwYKFYlC+PG7q+1+7/aa+RzscU71385Rnz5/JmDHjPghgbkoN69nzT0mWNJl4eMZQx/f40JeXL19J5y5dVEscG15Mc+bMlfjeCVTf3d08xN3NTdzFTcWEID7gg4u8coOaO2eOJE2S1Oim+8GJSsWaNGjQwNgOr/Hjx0vq1Kkt3sfvvvvOGOcBBg8eLBkyZLDYFjEgcHfT6NOnj2TLls1iW/jaw31DAz7y1uImfv31V3n06JHxc8eOHaVw4cIWXRl79eolt2/fNrZt06aNFC9e3OJx4T9/9epV42fEFViLm0Dsxvnz542fGzZsKBUrVrTYFn76J0+eNH6uXbu21bib6dOny+HDh42f0a5mzZoW286dO1f27t1r/Izz169f32Lbf//9V7Zv3278XLp0aXUvzcEYIl4BcQv6GIsWLVpYPO769etNYiwKFiwYYozFsmXLTGIsfv75Z4ttd+3aZRJjkSVLlhBjLGbNmmUSY9GjRw+7xlgkTw77qWPDGAsbYIyFc0P/do5fdJyDUBp8L5+UZ+fPyIsr5+XlvRvy/vEjCXzuIzFf+YvXa4N4+Ubu0pufh8i7mB9eMYL+9YvhJv4xNEXATfw88dld3OPGlsCYMcUtRkxxixlT3GPGEnev2PLU57WcvXxV3gUY5I1/gMROkFSatGglXvETSuz4iSVuvMQS3yuOxPeKJbu37ZTePf4UrxheKlYBAsacOXOs/nGfN2+exIwZU8VspEiRQgX2WuL+/fsqmBXtPD09JV68eEqAsgQEXginHh4eqi3+TZIkicW2miCtCVqRBX8DOX72hnPQucePMRaEEBINeP/orjw7uleenTwqPlfPid/9e+L29JXEevFevN6ZCqvBw+1sE2Z9PUVexBV5FVvktZebvPMS8Y3lLn5eHuIfy1Pex/aSwNhxxMcgcvXBY3niFyiP37yXWInTyJ89+klK78SSLm4CSRjLW2J5xhJ3N3dZtWqVDO7VS63C4YVMSIMGDbJ4/jt37qjMN35+fpI2bVpJnDix1ZXsRrW/US9byJ07t/z99982tUV2ojp16tjUNlasWGpl0xYiW6EghJCohq5QhBDi4AHPby+ekIe7t8jLU0fk7c3r4vbUR7xeBEhMncUBnrcfvW9DFlj9PUSexhd5El/keTw3eRPHXXzjxJD38WJLYHxvcUuYWGImSys3n/vK7AUrxO+Rj/g/fSU5M+SUU8dOWTzm0aNHZdGiRVIgaVJJmjSpSuNYLnsJi21r1aqlXraQJk0aSZUqFTPjEUKIE0DFghBCHIQAnxfyaPtaebpnq7y+dF7k0XOJ9fS9eL4PUhSQZDWGDcoDFIYHCUUee7vJq/ge4hs/lgQkTChuyVLKI0NMWbBqi7y590L8L72WdInTyZVLVywe58yZMxL/QXzlF4+XNUsBgC86XoQQQqIvVCwIIcQOGN69k4db/yePd26WVxdPi8e95xL7eaC4G4LCX+OFoEAgK88Tb5H7idzkYSI3eeHtKfc9DXLzvciF537i/8pDNs5fJWnip5HYnrGDWRZ2zzkumfJ8LpmqZ5Ls2bNb7SOCXAcMGBDBV04IIcRVoWJBCCFRgP+zx3JpzQJ5sXebGK7fkLgP/MQjANl29PEPbsErICQUuZXMTe4mcZPXyb0lIH0GSZK7iBTM/LmUTppNUsZNKRcvXFSByhoILk4bO62KaTAHVgV9BV5CCCEkoqBiQQghkcC758/l+tJZ8nrHepGrtyX2kwCVijO+FSXivTsUCJGrKd3kYQov8UmZTNafui53zj+Ud7tfy/vn7+Xp06eSCFWczUCqzaFDh0r+/PlVUDLiEuyROYQQQkj0hooFIYREUJD1jc1r5fH/Fsr782ck3v0gi4S1gOqHCUTOp3WTW2liyvuM6STN5xWkePbS8kXiXBIvZjyVBWmSt7f4+vqq9khbipgHS2lO8V23bt14HwkhhNgVh1Ys8Id1+fLlqlhM8+bNJWPGjCbfI1Ug2lgy9WuFX9asWWNSFAYgD3C7du0iufeEEFfnjc9ruTh/qvhuWSmxrjyQmG/cJK4FRQIuTTdSiFxI4ybXErvLsdd+cvLMQ3m7/Y3s2bBHFYoyB/UVULgJFopixYrJZ599JnHiOH7VVUIIIdEXh1Us5s+fL927d1f5zTds2CDlypULpliY8/jxY1XNcNSoUcZtUCx27twp33xjW25zQggJiZePH8vF6WPFf/dGiXvjhXj5uYmXBYvEI2+RE5nd5E5mb4lTrLTkzVhSWuSoICUKlZDz5y8Z26FqrSXFAlirxkoIIYQ4Ig6rWKDMOrKXwCJhrdhQz549TT6PGDFCvLy8pEmTJibb4XPcp0+fSO0vIcR1eeHzWs5NHyOyaaXEu/FS4n5I/6pXJlBl+lQmNzmV3k18c2SVqjXaSJPUJSVhrITGqqneMb2lWrVqygobO3ZsqVixovp9IoQQQlwBh1Usihcvrv69ffu2zftMnz5d6tatK0mSJDHZfvPmTRXYiAqvpUqVkrx580Z4fwkhroX/+wA5tvxfebd0qnhfuicJ3gZXJl57iRzN4ian0rrLf/efya0jz+TturfyU9uyUqXj1xaP++OPP0qFChWkfPnySrkghBBCXAWHVSxCy759++TcuXPKFcqcgIAAuX//vkqx+Msvv6ggx5BysyNYUguYBC9fvlT/YtURr6gG5zQYDHY5tyvA8eP4hYar5y/J/fF9JPaxExL/meFDFqePysTL2CIHcrrJndzJJM/X30mN7DXl9rBJcnFcf2ObZcuWyejRo8XT0zPYHETdCK12BJ9pPsNRAX8DOX72hnPQuccvNOd1GcVi2rRpkjVrVhWLoadTp06SM2dO4+fVq1erwO4qVapImTJlLB5r0KBB0rdv32DbHz16JO/evRN73NAXL16oScUUkhw/zr+I551/oJxct0a8186UJFefSRKjq1MQ/h4iR7K6yfkCCSVNhTpSLkMVSR47edCXr0Vq1KihFivwjIL48ePLiRMnjG6cfIbDB8eP42dPOP84htF9Dvr4+EQvxeLVq1fy77//yp9//ilubqYCgV6pABAAUqdOrQImrSkWPXr0kC5duphYLCAgJEuWTLy9P5ayisoJhevC+alYcPw4/yKOu4+eybkx/ST+ni2S7UHAh60ff0POpxE5lDuGbPfxlecXPeTkXzstPoPINPfdd99JypQp1b8FChQw+S3iMxw+OH4cP3vC+ccxjO5zMFas4MVWXVqxWLx4sbIkICWtLUDje/PmjdXvEQCOlzm4mfYS7DGh7Hl+Z4fjx/HTc/zMZXk86ndJevS0pH1juhjxJqbIrrzucrdUdpkzd588mPBAJMgQIf/99598/bXl2Il58+ZxDkYifIY5fvaE849jGJ3noHsozukSUiqCtuHelCJFimCxFceOHTPZBleoe/fuqcBJQkj0ITDQIFt2HZV1jauKW+Pqkmb3GfHSKRW3k4gs/SqOnJ7cRppM3ylD2i2XpK+SGpUKLfMcIYQQQpzMYnH8+HFZuXKlMXB61qxZyn0JMRT6OAoEbCNwe/369RYtE+3bt5eECRNKnjx5VHaoVatWqaJTlStXjtLrIYTYT6HYuX2v+E3uJSnO35WYflAmPioUh7K5yaUyaaTiN7/LHxnKi7vbx/UWuES2bNnSxM/09evXEjfuxzJ4hBBCCHFwxUIDMQ29e/e2+v3z58+lf//+FhUFZGTZu3evbN26VVkucuXKpYKyzeMuCCGuqVBs231EZNyvkvzcffF8/1GhCHQT2ZPbTe59lV+yZ6kl/Ss0sniMxo0bq9itokWLqgWJ0qVLB4vjIoQQQoiDKxYFCxZUr09RokQJ9QoJ5IzHixDi+sBSuenIJXkztqtkOnFJYvp+VCjeu4vszucu7+tVkPvXvGVc13ESL95OqX2ltsWaEoi1unDhgsryRAghhBAnVSwIISS0nLzxWM4O7SZZD+6TdD4fFQpUxd5W0F08Gn4t5XI3lZqVasr169eN7k2TJk0yyQSnh0oFIYQQYhtULAghTs+9F29l+6i/JcvmpVLgMbZ8dFfalddN3nxfRRpX7inJ4iRTafuQ6EFTLMDgwYOldevWEi9ePPtcACGEEOICULEghDgtb/zey7/LNkjmOX9KwWu+Jt+dyuAm978rId/UHygp46Y0SZs3duxYKVasmPqMmAnEaCEom4oFIYQQEnaoWBBCnDKOYv2xG/JyzM9S8Pgl8VJxFEHcSCZyvGZm+bbVeMmUMJPF/RGMjbo3V65cUUqGLfFchBBCCAkZKhaEEKfi7vO3smLcaCm8aY5keogtQUrFq1giGyrFl/Idhsn3nlmk32/9ZOTIkVatEBMnTlTVRJnliRBCCIkYqFgQQpyCgECDLN24TxJP7Szlzr8Qd8NHKwUyPcX/pbV0L/mTzJ4xW6r9WlPVwEGmpzFjxlg8nqUsUIQQQggJO1QsCCEOz4X7PrJlVD8ptm21xHn5MdvTncQiF74vLI1+GCeJYyWW3377TYYNG2bcb9y4cfLNN99IqVKl7Nh7QgghJHrwscQsIYQ4GO8DAmXi6oNyuf2XUvZ/mlIh4ucpsq58bEmwYKq0bzdfKRWgVatWyr1JH4uBAneEEEIIiXyoWBBCHJIbT17LyL79pdDgppL5zEfXpwtpRPb2ry7txu2RIhnLmOyTLVs26d+/v/EzArSXL18e5X0nhBBCoiN0hSKEOBSwMqw4cEncx7aWqifui2fAx6rZW8rHk0q9pkntlAWs7t+5c2fZv3+/sl5UqVIlCntOCCGERG+oWBBCHIYXb/xlyvQF8sXywZLgHrYEKRW3k4rc/7matK8/SNwMbrJ582apVKmSxWN4eHjI0qVLo7bjhBBCCKErFCHEMdh/9YnM/v0nqThz0AelQiRQRLYV95KUC+dIk2+Hy70796RChQqqoB2UC0IIIYQ4DrRYEELsSmCgQaZuOS0pZ7SWisefGWMpnsQXOdy8oPzY6h+JFzOebNq0SRo2bChPnz5V3zdp0kROnjwpyZIl4x0khBBCHAAGbxNC7IbPO3/pN2mh5Br2reQ49tyoVJzO6CYvJ/wundovVEoF2Lp1q1GpAPfv31dxFIQQQghxDGixIITYhUsPfGT18F7y9Y4NEv9DGlm4Pu0q5y1VBy2SDIkymbQfMGCAHDt2TDZu3Kg+Z8yYUX7//Xe79J0QQgghwaFiQQiJctafvC2vRv0gXx68acz65BNL5HSr4tKy7VSJ4RHDYlD2ggULpGjRopI/f36ZMWOGJEyYkHePEEIIcRCoWBBCorTg3Zi1hyXvnDaS9/Q7Y9anK6ncxKN/F/mh9I8h7p84cWLZvXu3JE+eXNzd6clJCCGEOBL8y0wIibJ4ih6Tl8lnE5tJeqVUBLH7s5iSef4CqfpBqVixYoX4+flZPU7KlCmpVBBCCCEOCBULQkikc+/FWxk8ZKTUWtRLUlwP2hboJrKlZkqpP3275E5dUAIDA+W3336TunXrqqBsFMojhBBCiPNAVyhCSKRy5u4L2Tism9TeuVPivQ5yfXoTU+RU25LStu0U8XT3lHfv3knz5s1l8eLF6vs5c+ZIhgwZpF+/frw7hBBCiJNAiwUhJNLYdu6+nOz9rVTc9FGpeJhA5PHwdtK83XSlVIDLly/L6tWrTfbt37+/ygJFCCGEEOfAYRWLFy9eyPjx4yVv3rzi6ekpO3bsCNamffv26jv9q2DBgsHajRs3TrJkySLx4sWTEiVKyL59+6LoKgiJvszbe1le/l1H8u+6ITHfBykVl9K6SZyZY6RK5Z9N2uI5h7VCC8jGszxr1iwpVKiQXfpOCCGEEBdSLIYNGybnzp2T4cOHS0BAgEV/a2yvVauWcqPQXkeOHDFpM3PmTOnevbuMGDFCrly5IiVLlpTKlSvLrVu3ovBqCIlelbSH/e+wJB1dX7Ifem78kTmUL6bkWbBCiuSubHG/6tWry8SJEyV+/Piybt06adasWZT2mxBCCCEuqligGNaECRPUSmZIuLm5mVgskOveXEH54YcfpHbt2pIiRQqlqHh7e8ukSZMi+QoIiZ7pZPsu2C4FZzSTDCd9jdt3lfGWqrM3S5bkOULcv02bNnLx4kX58ssvo6C3hBBCCIkWioWtoAovFIV06dLJd999Jzdv3jR+9+zZM2X1KF++vIkigs979+61U48JcU183wdIn+mrpOyCdpL2PGpoB7GnRhr5fuI2SRYnmfoMy2JIIJ0sIYQQQpwPp84KlSlTJpU9pmzZsnLnzh3p3LmzlClTRk6dOqWUjXv37ql2KKalJ1myZHL48GGrx/X19VUvjZcvX6p/kQ4Tr6gG54QrmD3O7Qpw/CJ//N74vZchk+dK5dXDJNmdoHgKFNQ+2jS/NOs2TzzcPdT+CxculJ49e8qWLVskc+bMEl3gHOT4cf45L3x+OYbRfQ4GhuK8Tq1YIHZCX5F3yZIlkipVKlm0aJG0bt3a6n4IEA0pR/6gQYOkb9++wbY/evTok6utkXVDEcyOPrPaMMfP0ebfy3fvZe78RfLVhn8k8aOg7309RU62LiNfNugrTx4/UdvmzZun6lTgOBUqVJBVq1ap5zU6wGeY48f557zw+eUYRvc56OPjEz0UC3MSJUok6dOnl0uXLpm4VEAh0PPw4UMVb2GNHj16SJcuXUwsFnC1gqUDlhB7TCi4cOH8VCw4fo40/x75+Mq8qWOk6sZZkuhJ0HevYonc6vGNfN+gt7EdLBXdunUzfkbyBLgu7tmzRxImTCiuDp9hjh/nn/PC55djGN3nYKxYsaKnYgEFAAKLtgoKK0b27NlVqlpU8wXQ9rZv3y6NGze2ehwvLy/1Mgc3016CPSaUPc/v7HD8In787jx/K5NHDpWvNi+URE+D3J+exhN5PvAnqVvlF5P9q1WrplJBHz9+3LitSpUqSqmILnOac5Djx/nnvPD55RhG5znoHopzOu1fdMRANGjQQI4eParew0rRsGFDiRs3ronS0LVrV5k+fboK8oYZ6c8//5SnT59K27Zt7dp/QpwZKBVThg+QrzYtlMQflIon8UXejfpdqpkpFQAKBJ7BHDmCskL16tVLRo0aFW2UCkIIISQ64LB/1RGUjfSxGTNmVJ8rVqyoPvfr1099hkXh+++/lw4dOigXKARwI//9gQMHTNycEGvx119/SYsWLSRJkiSydu1alSNfOy4hJHTcff5WZg7rLV9tWiaJnwUpFY+9RdzG9ZOKZazXnkAShc2bN6tUz3iOsfpCCCGEENfBzRBSFLMdQbdQAM8ce5iB4GKVIEECZfGwV4wF4kIgmHGFl+Nnz/n3wMdX5gz5Q77YvE4SvgxSDB4mFIk7cZh8Xrh6lPfNWeAzzPHj/HNe+PxyDKP7HHwZCjnYYS0W5oXvtBcFa0Lsw/0X72TB4N+l7KaPSsX9RG6S4J+xJkrFiRMneIsIIYSQaIjDKhaEEMfh4Ss/mTe8l5TevFES+AQpFfcSu0miqWOlYL6PVbL79+8vhQoVkpkzZ9qxt4QQQgixB1QsCCEh8uDlO1k1c4KU2bxWvD8oFXeSuEmiaeOkYL5KxnYDBw5U8UxwY2zZsqVKmkAIIYSQ6AMVC0KIVR6/8pXJo4dI+W2rJOELzf1JlKWiUO6Kxnbbtm1TGdc0oFy0atVKzp8/z9ElhBBCoglULAghFnnx1l/GjxkpFTcvliQfUso+SiDiPXmUfJbno6UClCtXTn7//XeTbePHj5ecOXNydAkhhJBoAhULQkgw3vi9lzHjx0v5/2ZJsscfit/FF4kzYYh8VuAri8kW/v77b+nZs6f6PG7cOGnXrh1HlhBCCIlGuFTlbUJI+PF9HyCjJv0jZddNluQPgtYeXsQR8RzbXz7/vKbV/aBcDBgwQKpXry4lSpTgrSCEEEKiGbRYEEKMvA8IlNHTFkjp1aMl+b2gnwefWCJP+7SXIsXqfnKkoFxQqSCEEEKiJ1QsCCHGgOtRC1ZLsVUDJPntoJ+GN14iL/7uIIWL1jeO0oULF8Tf35+jRgghhBATqFgQQpRSMWb5dim8rLukuBb0s/Auhsi9v5pJxa9+Mo7Q6dOnpWTJklKvXj159+4dR44QQgghRqhYEEJk+qYjkmtJO0l9PihQ+727yNUuNaR6vY+Znq5duyaVK1eWp0+fyurVq6Vq1ari4+PD0SOEEEKIgooFIdGc5fsvSJr5LST98Y/bzv5YSuq1GGr8HBAQIHXq1JF79+4Zt23fvl369OkT1d0lhBBCiINCxYKQaMyOs7ck5rRGkv7Ae+O249/kkW86/2PSzsPDQ0aNGiXe3t7GbXCJ6tevX5T2lxBCCCGOCxULQqIpJ28+kWfjG0qGvW+NPwTHK6eTb/v+q7I7mVO+fHnZuXOnpEqVSvLlyydr166VuHHjRnm/CSGEEOKYsI4FIdGQG49fybmRjSXHrqfiGRi07UTRRFJ35Gpxd7O+3lCgQAHZu3evxIgRQxImTBh1HSaEEEKIw0PFgpBoxuNXvrJ5RHvJv+O6ePkHWSbO5IotX09eK16eXp/cP2PGjFHQS0IIIYQ4G3SFIiQa8cbvvcwf3Vtybjsg8d4GKRWXMnhKmRmrxDtOImO7t2/f2rGXhBBCCHFGqFgQEo2qak+aMkkKbF4hiZ8HKRV3krpJnunzJUWidMZ2K1eulOzZs8vx47o0UYQQQgghn4CKBSHRpADelEUrpMC68ZLiftBj/yyeSNJJYyVL2vzGdgcPHpTvvvtObt++LV988YVs3brVjr0mhBBCiDNBxYKQaMDiLfsk+4qekuZDVe23MUUCh/wuBfNVMra5ceOG1KxZ0+gGheJ3X331lZw6dcpu/SaEEEKI80DFghAXZ+uxC5JkdktJezrocQ9wE3nQvZGUrtjMpF2cOHEkc+bMJtuaNm0qefPmjdL+EkIIIcQ5ceisUO/fv5c1a9bI+fPnlXtG+vTpg7U5ffq07Nu3Tzw9PVXBrhw5cph8v3HjRjl27JjJtmTJkknLli0jvf+E2JtTNx7I+0kNJc2hj9vOtSghDRr/Fawtngu4PjVv3lwWL14slSpVkkmTJlmsaUEIIYQQ4jQWi3///VeyZMkiY8eOlR49esjVq1eD+YxXrVpVKRyHDh2SLVu2SKFChaRv374m7VasWCGzZs2S58+fG19w8SDE1bn99LVcHtlIUu55Z3zQj32VQep1m2Z1n1ixYsmCBQtUle2lS5eqehWEEEIIIU5tsUB13z179qj36dJ9zFijVyw6duyofMA1li1bJvXr15eGDRuaWC7gyjF48OAo6jkh9uflO3/ZPKKd5Nl1V2LA9wkF8Ap7S93hK0MsgAfc3d2lU6dOUdRTQgghhLgKDmuxKFOmjKRNmzZE4UevVIDSpUurf82tG3fu3FGWj9mzZ8vFixcjqceEOAb+AYEyd8JAybL9gMR786FWRcYYUnnKaonlGcve3SOEEEKIi+KwFouwoLluwCVKD1yfEKcBBaN169bSq1cv+fPPP60ex9fXV700Xr58qf4NDAxUr6gG54SFxh7ndgWi2/hNn7dAcmxcKEmfBK0b3E/sJnmnzJOEcZMax2D//v1y+PBh6dChwyePF93GLzLgGHL8OP+cFz6/HMPoPgcDQ3Fel1Esjh49Kt27d1cKQ8qUKY3b27dvbxKACnepBg0aSIUKFVSwtyUGDRoULFYDPHr0SN69eyf2uKEvXrxQkwqWGsLxs8bGA8cl0//6SZqbHurzKxgo+v0hcbySy8OHD03Syj558kROnDih5jqSH3D+8Rl2VPgbyPHj/HNu+Aw79/iFJjbZJRSLM2fOKLeoxo0bK2uEnnz58pl8rlevnqRIkUJlv7GmWCBYvEuXLiYWC8R5IGuOt7e32GNCQTHC+alYcPysse/sNUm5vLOkPxOkVLx3F3n5V2spX6GRsc2zZ89U1icoFWDGjBly//59WbRokcSNG5fzj8+wQ8LfQI4f559zw2fYuccPiV2ijWJx9uxZZX2oVauWTJ482abUmB4eHvLq1Sur33t5eamXObiZ9hLscV32PL+z4+rjd/X+M3k+qaFkPPhx2+WWZaVO3c4m7TZs2KDcAvUEBARI7NixQxwbVx+/qIBjyPHj/HNe+PxyDKPzHHQPxTmdWko4d+6cUirg1jF16tRgSgUEJlgzzOtaINaibNmyUdxbQiKHF6/95NiIxpJ61ytxNwRtO1kpvdTuMilYW1j15s+fLzFjxjRa9JDaOSRXKEIIIYQQW3BYaeLUqVOydu1aY+A0cusj4BSZn/B68+aNVKxYUfmboVrwkCFDjPt+/fXXkj9/fvVds2bNVGG9PHnyyM2bN1XhL8RdoAYGIc7O+4BAWTO2i2TecVVi+QUp1udyx5WaI1dYtd5pxSZ/+uknVYDSHu59hBBCCHE9HFax8PPzU8XsAIKyAT7rg6ebNm2q/kVAix4toxNWYQ8ePKjcP1B9u1ixYtK1a1eldBDiCiyZNUHSbtwkCV8GGR9vpvSQ0v8sl9gx44S4H5RzBG7TtYkQQgghLq9YfPbZZ+pljThx4thU9A6CEywYeBHiSqzbuF5Srhgnye8HBWs/jS+SfspUSZ4kvU37U6kghBBCSETi1DEWhERXDp0+J7FndZSUl4OUincxRN4P7i65cpQ0yQAVUpICQgghhJCIhIoFIU7G9QdP5fm4RpLyWJBSgbI11zrWkLIVmxvb+Pv7S/369aVUqVKqbgUhhBBCSGRDxYIQJ+Ll26AMUMn2fqwMf6x2DqnT8mPyAtCpUydVq+XkyZNSpEgR2bNnjx16SwghhJDoBBULQpyEgECDrBz7m6TYcU28/IO2nS7gLQ0GLDbJAIXUyxMnTjSpGP/999+rhAiEEEIIIZEFFQtCnITFC2ZL6k3rJdGLICXiVkoPqTBlpXh5mhZzRG2XnDlzGj+j2CPSLGu1KwghhBBCHFqxePLkiYwYMUIqVaokSZMmVdWtEydOLF988YX8/fffcu/evYg6FSHRjs17D0rilX9LmttBj+yLuCIZJ0+VJAlTBWubNWtWVfOlSpUq6vOMGTOkaNGiUd5nQgghhEQvwq1YIOtMjx49JG3atDJv3jzJmzevDBgwQL1HOljUjli1apVkyJBBOnTooDLVEEJs59yNu+I3vYVkOB0UrP3eXSRwQFfJnvNjBihzEiRIoIrfocgkCuIRQgghhDh8HYtp06Ypa8Thw4dVdWtrXLlyRUaPHi3Dhw+XgQMHhve0hEQLnr56J5dGN5CM+5H7KYjrP5STGlV//OS+KBDJ+i2EEEIIcRrF4ueff1ZuT58iS5YsMm7cOAkICAjvKQmJFvgHBMp/I9tKph1PJEZAUFzFmTKppV7Xj4HZhBBCCCEu4wr1KaUCisTz589tbk8ICWLZzDGSYss+8X4TpFRczeglX49dYZIBatGiRcrVkBBCCCHE5bJC9evXTw4cOGB0f0qfPr0kSpRIGjVqJAaDIaJPR4hL8t/WLZLof5Mk5YOgR/RxAjcpOG2RxIntbWwD98PmzZtL7dq1pX///hIY+NFdihBCCCHEqRULFOPC6ikCtgGCt0uWLCk7d+5UysZ///0XkacjxCU5demqBM5qJ+kvBln33sUQiTuiv6RJ+zGF7P3795VC4esbVCjvr7/+kgYNGsj79+/t1m9CCCGERG8iVLFAikt9WsuNGzfKH3/8IWXKlJHGjRvLoUOHIvJ0hLgcD5/7yM0xDSTdoY+P5oNO9aRw6Xom7WbNmiV37twx2ZY6dWoVsE0IIYQQ4vSKRezYsY31Kk6fPi1v3ryRAgUKqM/v3r2TWLFiReTpCHEp/N4Hyu7hTSTlrjfi/sFr8MzX2eWrlgOCte3evbuMHDlS3N2DHuFy5cqpz4QQQgghLqFYfPnll7Jp0yZp0qSJiqlo2LChMdB069atqngeIcQyq6b0kWRbz0ucIO8muZArntQc8q/FtniuOnfuLBs2bJDChQvLkiVLJEaMGBxaQgghhLiGYpEyZUrZvHmzskzUqlVLxViAEydOKKWjYMGCEXk6QlyGjWuXSYLViyTp0yBF/G4ydyn1z3KJGcMrxP3wXCGIG9XuCSGEEELsSYQ4ZCMwGxW4v/jiCylRooR66YE7lOYSRQgx5cSZ02KY20PSXw8K1n4VSyT1hPGSLGk6m4ZKn36WEEIIIcSpLRYPHjyQZs2aqVVTZKaZPXu2PHr0KCIOTYhLc+/xE7k3tqFkOB6kVAS6ibz+s7Xkyl/e2AaxSv7+/nbsJSGEEEJIFCkWNWvWlNu3b8v27dslf/78MnHiRJWhBpaLgQMHKlcoQogp7/zey5FhDSTlno/V6C82LCLl6nc2fkbtF9SqqFy5MpV1QgghhESfGItChQpJr169lGsUUmG2bt1ajh49qtLNolDeTz/9JGvXrpW3b99G5GkJcTqgMGwY21ESb70rXh9KT5z9LInU7DXTpN2gQYNUYDaU9iJFisjx48ft02FCCCGEkKiuvK2RPHlyadGihSxbtkweP34s06dPl5gxY0rHjh1VMS9CojMbl86Q+Os2SyKfoPiIG2liSOXJq8TDPcglCqxevVr+/PNP4+cbN25I9erVjUXxCCGEEEKihWKhBwoFsteMGTNGLl++LL179/7kPj4+PjJ58mSVSQpZplC92xJwu8qRI4ckTJhQWUYOHjwYpjaERBXHjhwQt4VDJPXdoMfvWTyRHFNnSfz4SYJlWYNLoQZqVkybNk28vELOFEUIIYQQ4pRZoZBHf9GiRTa1rVq1qnz77bcSL168T7aFC8iTJ09kwIABUqNGDQkMDAzWZs6cOdKlSxeZN2+eiucYOnSoUmDOnj0radKksbkNIVHF7Xv35OGE5pL+bJBlwt9DxH3Q75IpS+FgbeH6hFSydevWlX379qn0zV999RVvFiGEEEKih8UCAtDcuXPlypUrymXj5s2bsmDBAtm2bVuojvP333/LlClTQqx9MWTIEGnZsqXUr19fKQmjRo2SuHHjKgtFaNoQEhW8eecrp4bWkdT7P2670bqyFP+ymdV9YLXAswNLxa+//sobRQghhBDXtVhgBVVbRb1165aUKlVKjh07prJDaVy7dk1V3c6VK5dEFM+ePVNWh759+5q4ipQvX1727NljcxtCoipYe8uIFpJi+wvx/GB8O10undT/ZfQn94XrE5RjQgghhBCXL5CngTgIuBnplQqQKVMm5QKFqtzm34WVe/fuGYPE9eDzkSNHbG5jCVha9AGyL1++VP/CHcuSS1Zkg3NCMLXHuV0BRxi/zfNGSPwNRyX+26Bg7cuZY8nXI5eqfuHlyDjC+Dk7HEOOH+ef88Lnl2MY3edgYCjOG6GKBapvX7161eJ3sFogCDuigQXC/LO5oGZLG/P4Dr2VQwNF/969eyf2uKEvXrxQfTa/FuL443fu+F6Rf/+RFI+C4ioeJnSTjEMmis/LN+oFTp48Ka9fvw5Wtd4RsPf4uQIcQ44f55/zwueXYxjd56CPj499FAukwoQfOAp6tWnTRmW0gTCOwOnly5crF6mIIkWKFOpf8wrfDx8+NH5nSxtL9OjRQwV86y0W6dKlk2TJkom3t7fYY0K5ubmp81Owc67xu3njqvjN/13SXw5SKt7GFEkwarDkyVPMpHL9jz/+qCxso0ePlrZt26r+OgqcfxxDe8M5yPHj/HNu+Aw79/iFxjAQoYoFgqPh7oRaFSVLljRuz5cvn6xfv15y584dYedKkiSJZMuWTXbs2CF16tRR26DJ4XOjRo1sbmPNp91SSk/cTHsJ9phQ9jy/s2OP8Xv1+rVcHFFf0h76WJviUddGUqVETeNnuNw1aNBAxSeBDh06qEr148ePV2maHQXOP46hveEc5Phx/jk3fIadd/xCc84I712xYsVk//79ykqAKsH3799Xbh4VKlSI6FNJ586dVeG9LVu2KDeSPn36qGJ8sJaEpg0hEU1gQKDsGfyNJN3pa3zITtfKLVWamRaHRLYn80QCFy5c4A0hhBBCiNMRoRYLPUmTJlWvsIKUta1atTJ+rly5stKYUIlYq0b8008/qcxPsD6g5gWyTq1Zs0YyZ85s3M+WNoRENFum9ZS4m65IbL8gl6Zzeb2l1t8Lg7XD/Lx7965KrwzSp08vS5YscShrBSGEEEKILbgZIjglDfzFUYQO1oqnT5+aBEk3a9ZMWRBsISAgQPz9/YNt9/T0VC9L/mefMtXY0sYSiLFIkCCBCpyxV4wF4kKQzYquUI4/foc2LZHnw/6UtDeDznU7uYcUXrlRkiS2XpARRSZ//vln2bRpU4i1W+wB5x/H0N5wDnL8OP+cGz7Dzj1+oZGDI9Ri8fbtW1XHInv27CpGAZ34/PPP5d9//1UKRuHCwasLW8PDw0O9bMWWgaZQTiKb6xdPybN/ekq6m0GPlk9skXSTJoaoVICGDRuq5Ae2VKUnhBBCCHFEIlTtwWorAqbXrVunYiqgVAwfPlwVqUO1a0fP109IeHjx/KlcGt5Q0p0MUioC3ETe9mkvOfN8YdP+VCoIIYQQ4sxEqGKBWhUI3gaxY8c25r2FwITMN8jGRIgrAte9g4NqS/K9H4vIXGhcXMrW6mD8bK8Ci4QQQgghTqdYICZCCzpFEOrRo0eN392+fdtibAQhrsCOcT9J/C0PJeb7oM+niiWT2j2nmbTp3bu31K1bN1SFZgghhBBCnIVIk/S//PJLVeirbNmykjBhQuUedeTIkcg6HSF24+CqKSKrdkiCV0F6+tV0MaTqxFXi4f4xRghxRgMGDFDvUV37f//7HzOTEUIIIcSliFDFol27dsolRKvSt3fvXpk4caKKJt+2bZvkz58/Ik9HiN25fHKfPJ85XNLdC3qUnsR3k7xT50r8uImMbVBxHtXoNc6cOaMKSF6+fJlxFYQQQghxGSJUsTh06JBy80B2G5AhQwYZMmRIRJ6CEIfh2aO7cn1kc0l3Pugx8vMU8Rzyh2TIVMCkHRRrxBwha5rGX3/9RaWCEEIIIS5FhMZYnDp1Sv7777+IPCQhDsl7P1859nctSXng4yN0vW1VKV6hcbC2cAc8ePCg5MmTR31u3bq1KoxHCCGEEOJKRKhiUbRoUdm1a5fRHYoQV2XP8O/Fe9sr8fiQQflExYxSs/0Iq+2zZMki+/btU1Xjx40bJ25uQRW5CSGEEEJchQh1hUKQNoraoYYFCn4lS5bM5PscOXJIvnz5IvKUhEQ5B+b/LW5rT0ncd0HKwYVssaXWyKWfVBbix48v/fv3j6JeEkIIIYQ4sWIBNygEpIITJ04E+/7nn3+mYkGcmosHNsirebMk9ZOgjE/3ErtLsX/+ldhece3dNUIIIYQQ11EsOnTooF6EuCKP71ySW6N/kdTXgpSK114iScYNl1QpsxrbXL16VZ4/fy6FCxe2Y08JIYQQQpw8xoIQV8XvjY+cHlBXUh8LUioC3UQedW8iBT6ramyDjGg1a9aU0qVLy+LFi+3YW0IIIYQQJ1QsNm3apNLM2sLp06dl5cqV4T0lIVFLYKAc+ruOJNz9oaw2XP3q5peq3/XUNQmUJk2aqBoVSCuLGCMEamM7IYQQQkh0INyKRZw4caRu3bpSsWJFmT17tly7ds3k+5s3b8q8efOkatWqqk2MGDHCe0pCopTDUzuL+8bb4uUf9PlEoYRSv99ckzbTp0+XVatWmWyDEv3mzZuo7CohhBBCiPMqFqVKlZLz58/LV199JX369JHMmTNLzJgxJWnSpOLl5aWK5HXv3l2KFy+u2lWrVi1iek5IFHBx8xx5tXiDJPQJyvh0LbWnVJ68QmJ6xDRp16xZM1WfQiNx4sTyv//9j0XwCCGEEBJtiJDg7bhx40q3bt3UC8oDCuU9e/ZMvL29VVGwvHnzMm8/cToeXjokd8b3l5T3gh6Tp/FEMk+aKokTpAzWFsr05MmTpUCBAtK1a1dZsmSJUrIJIYQQQqILEZoVCuTMmVO9CHFm3j1/IBcGfi8pzwc9In4eIu8GdJacOUpY3Qd1LNq1a6dcA1OmDK58EEIIIYS4MswKRYgZhve+crxfDUl04OPjceaHslLxq4+uTiFBpYIQQggh0REqFoToMRjk+KimEmPrS/EwBG06UDaVNOwyUdfEoF6EEEIIIeQjVCwI0XFu6WB5vfKExHkXFKx9JquX1Bu9QtzdPj4qEydOlB9//FF8fX05doQQQgghkRVjEZWMHTtW/Pz8gm3Pnz+/VK5cWb3fvHmzHD9+3OR7ZKxq3rx5lPWTOAd3jqyT+zNmSMonQY/F3cRu8vnUBRI/dgJjm23btknHjh0lICBAJSpYtmwZXZ8IIYQQQiJDsXjw4IHs3btXXr9+rVLNlihRQjw9PWXPnj2qMjHS0kbkufSrxshENWPGDBk6dKhRsVi6dKkSBmvUqGESZEuIHp+7F+XS8I6S8lrQI/HaSyTOyAGSMXVuYxvUaGnQoIFSKgDmedGiRVUWtAQJPiofhBBCCCHRkQhTLN6/fy+//fabjBs3Tr3XSJ06tUrDeeHCBbl//36EKhYDBw40+TxmzBhVgA81BfTky5dPhg8fHmHnJa5FwNsXcmJAHUlxLOhxCHQTudn1W6lbvK5Ju4sXL6qq2nqaNm1KpYIQQgghJCJjLDp16iTz58+XCRMmyOXLl+Xx48fKSlGlShWpU6eOchmJbGCtqFWrliRPntxk+927d5VfPPp35cqVSO8HcSICA+Xw37Ul3q5A46bDdfJInSa9gzXFXIaVApY4gLnWr1+/KO0uIYQQQohLWyzgIjJz5kw5cOCAKoanUbJkSfWqWrWqNGzYUFXpjiwOHTokJ0+elGHDhgX7Di5SiLO4c+eO/PDDD6pCeI8ePaweC+5Veherly9fqn8DAwPVK6rBOZGFyB7ndgVCGr8TU9tL4IZ74uUf5B53rGBC+bbvPKuZn2D9wjz/448/ZMSIEcbjuzKcfxxDe8M5yPHj/HNu+Aw79/iF5rwRoljs2LFDKlasaKJU6IFfOoT7JEmSSGQxffp0yZgxo1SqVMlk+08//SSTJk0yxlUsXrxYGjVqJOXLl5fixYtbPNagQYOkb9++wbY/evRI3r17J/a4oS9evFCTyt2dibwiavwe7Fkkz//dKil9grZdTe0pnw34R54/ef7JYw4YMEC5RZm7RrkinH8cQ3vDOcjx4/xzbvgMO/f4IUY6ShULrOinSpUqxDatW9tWXCwsvHnzRhYuXCjdunULNuAFChQw+fztt98qt60tW7ZYVSxgzejSpYvJ9aVLl06SJUsm3t7eYo8JBcUI56diETHj9+jCfnk4b4KkvRv0CDyNJ5J18j+SLfPHYG3C+RdR8Bnm+NkTzj+On73hHHTu8YsVK1bUKhbwOZ89e7bV7/39/eWLL75QryFDhkhEg8xPyELVokULm9ojS5Xm3mQJLy8v9TIHN9Negj0mlD3P7+zox+/t07tyZkhzSXsuaPr7eYgE/v2b5Mj+UdG8ceOG0tCtWeGiG5x/HEN7wznI8eP8c274DDvv+IXmnBHSO7gf3bp1y2J8AwR4uELt37/fmKYzMtygvv76a0mTJo3Jdq3WgB7Utbh9+7ZSckj0w+D/Tg73rS4pDngYt11qXUXKVP6olMLcWK1aNRUftHHjRjv1lBBCCCHEuYgQi0XcuHFVRqZ69erJypUrVbxFwoQJVYrZf//9V5lufvnlF4kMLl26JDt37pT//e9/wb6DL9p3330nWbNmlTx58sjNmzdlwYIF0qZNGyU4kmiGwSAHh3wrcbe9FfcPcdmHv8wk3/8yytgEqZLhLnfmzBn1GfNk/Pjx0rZtW3v1mhBCCCHEKYgwe0r16tVVellUtUZFbNS02LRpkxLijxw5omIUIgPUxujevbuyWFhyeTp8+LB8//33xngL9BF1NUj048y8XhLwvwsS+0Ox9tO54kqDkctMCiaOHj3axEoBqxfmsz2C9gkhhBBCom3l7c8//1xWrVplNXg7MlyhypQpo14h+YXVrFlTvUj05cmR1fJk9jJJ8TJIl76ZwkPKTV8hsWLENmnXvn17pYwiexiAtW3t2rWhClwihBBCCImORFkECLIpJUqUKKpOR4iR51ePyMOpQyXF3aDp/iyuSLpJkyRZ4uBWtNixYyt3OdSpgDIBF7tMmTJxNAkhhBBCPgFTDBGXxv/FPTnd73tJeeFDBihPkTf9Oknu3CFbuVCnAjFC1lISE0IIIYQQU6hYEJfF4PdGjvSqJkkOfpzmp36sKJWqtbFp//Tp00di7wghhBBCXAsqFsQ1MRjk2JD64oUMUB827f0yvTTuOC5MJeoJIYQQQkjIULEgLsm5mV3Fd/VVieUf9PlY7jjy7bClxgxQSEXcsmVL+fXXXyOtvgohhBBCSHQiQrNCEeII3NwyUx7MXWvMAHUtpYcUGPSPxIkZ19imf//+MmvWLPX+7NmzsnDhQkmQIIHd+kwIIYQQ4uzQYkFciqcX9sqlMYMkxb2gqf00nkiGSZMlSYLUJrUqevfubfy8fv16VT2erlGEEEIIIWGHigVxGd49uSHHBzaX1Bc91GdfTxG/gb9JrhwlTdrly5dP4sSJY7KtZ8+eKhsUIYQQQggJG5SkiEtg8PWRg32qS4qDQUoFuNSumpSv0iJY24oVK8p///2naquACRMmSJ06daK0v4QQQgghrgZjLIjzExgoB/+uLfG3vzdqyoe+zi5NfhpmdZdSpUrJ1q1bZd++fdKuXbso6yohhBBCiKtCxYI4PSemtJXAtXckln9QxqeT+RJIw2FLjBmgrPHZZ5+pFyGEEEIICT90hSJOzdW14+TZwp2S8FWQEnEtdQz5avr/JKZHTHt3jRBCCCEkWkHFgjgtD47/J1fHj5MUD4OUisfebpJn+lxJ4J3cWKti0qRJcu/ePTv3lBBCCCHE9aFiQZySN/cuyOmBHSTNtaBg7TdeIrFGD5IMmQqoz0gd27FjRxU/UaRIETl06JCde0wIIYQQ4tpQsSBOR4DPIzn0R21JfSpIqQhwE7n7WzMpUrKW+vz+/Xtp1qyZjBs3Tn2GxaJu3brKekEIIYQQQiIHKhbEufB/K4f+qipJ933cdOy74lKj8e/Gzwja9vf3N9ktICBAvLy8orKnhBBCCCHRCioWxHkIDJSTg+uI1+bX4m4I2nSgbGpp/Od0k2YeHh4yZ84cqVq1qvocI0YMZa344Ycf7NFrQgghhJBoARUL4jRcmd5e3q66LrE+GCNO5Ioj34z7n7i7BZ/GMWPGlKVLl0rlypVl5cqVUqtWkJsUIYQQQgiJHFjHgjgFd9eOlDtztkqyV0FKxNVUHlJx+iqJEzOu1X3ixIkjGzZsUNmhHj58GIW9JYQQYgtwUzV3XXU0kAwEfXz37p24u3M9lmPo2nMwRowYyvMjrFCxIA7Ps2Or5ML4yZLyUdBEf+QtkmnKNEmWOO0n90W8BRQLQgghjsWrV6/k9u3bDv8bjf5BsPPx8flk4VXCMXT2OYjjp02bVuLFixem/alYEIfm7c0jcuzvrpLqWgxjWlnD0N6SO3tx9fnWrVsybNgwGTFihNKyCSGEOIelAkoFLMvJkiVzaIEdQh2yDXp6ejp0Px0ZjqFzjB/O8+jRI/VsZsuWLUyWC6dWLLp06SIzZsww2ZY7d27Zu3evyTa0GTNmjDx48EDy5csnQ4cOlUKFCkVxb0loCXh2Uw71aSSpTsUwppW98WtjqVuuofp85swZqVKlity5c0devnwpM2fO5I8+IYQ4AXDrgBADpSJ27NjiyFAo5hhGpzmYLFkyuX79unpGw6JYOLWz4Js3b6Rs2bJqALTXxo0bTdosXLhQfvrpJ+nWrZvs2bNHsmTJIhUqVGA1Zkfn3Qs52Le6JN73cVIfaVxc6jb5M+j9kSNSunRppVSA2bNnyx9//GG37hJCCAk9tAAQ4lrPpFMrFgDuLwkTJjS+4sePb/L9oEGDpEWLFvL9998rpWLChAmqngGLpTkwAf5ybFB18drqLx4fXG8Plk0nTf74mFYWlbSfP39ushuyP8FnlxBCCLGFjh07SqZMmYItSuqZOHGisohr76dPN01xHhmUKVNGfH19Q+xTVPSDkGinWGzZskVSp04tuXLlktatWyt3Jw0InqdOnZKKFSsat8GsA4vF7t277dRjEiIGg5yf1ETerXsksf2CNp3KFV8ajjdNK9u2bVtZsmSJsehdiRIl1D0Na7ARIYSQ6AXkg/3798u2bduU94M14GqLoFnz95HJvXv3Qgxqj6p+EBKtYizSpEkjY8eOVT8IcImBu1OpUqXkxIkTEjduXLl7965qlyJFCpP9kidPLkePHrV6XKwS6FcK8AADROTjFdXgnFpGAFfn5tI/5d6/xyWlT5Ap7lpqT6k0fZXE8IgZ7Prr1q0rmzdvVnMAcTQIArQ0RtFp/CIDjh/H0N5wDrre+Gl90l4AQaN6EiVKpHzKLWHeFh4LoU3gAffpAgUKSIYMGdTnkAR57TvzPkcmIZ0nKvsRUejHkDju+GnzSi/zhua3w6kVi169ehnfp0+fXlasWKFSZC1atEhatmxp/M485y9+qEK6MXCf6tu3r8UfMuQQjmpwQ1+8eKH67Mo5tN8cWSxXpy2TNA+DrvGRt5ukGDJG/PzcrNahyJo1q1Is4AJlzQ0quoxfZMHx4xjaG85B1xs/BIaiXwhIxcvSIuCxY8ckT548FveH+xLiLDWQtOXzzz+3+fwXLlxQbtL4m75u3Tq1IDl69GiV2KVGjRpGdyQsXmlKkNZnrd96sO+zZ89U/B8WOpGtEO/nzJkjBQsWVG5LsWLFUm26d++u+psuXToZOHCgFC5cWB4/fqzcspCU5JtvvlHHxDngefHXX38p7wwoT3gPLwxr/XBUMH7IBAYYV+PY44c5hbn15MkTo7IeGuuYUysWliLZsfKAHwzNMgHwwOqBkKp9Z4kePXqojFN6iwV+AHB8b29viWpwgzGRcH5H+aMQ0by+sE1O/zNe0twMmpKvvUTijhkqhT4rF+5jR4fxi0w4fhxDe8M56HrjB4EewgoW+qxZJUL6zhy4OdvaFuTIkUMGDx4sO3bskL///ltZR/C3Ht4K2nHu37+vjosxw/hByMJ7vMzPhYUtCP+TJ0+WGzduKOWgd+/esmbNGiVPYOGzSZMmKskIjrVq1SrlhlW/fn25evWq2p44cWJZvny5/Pfff2obztGzZ091XsQQwj0KLt+IMbTWD0eHaeEdf/wwpzC3kiRJopRhoP1r0/7iQrx+/Vrl3tWUhqRJk0rmzJll165dUrt2bWO7nTt3qofZGvDb13z39WgPsj3AD5E9zx+Z+N8/J4cHtJE054MeGH8Pkae9f5bKJaqrP4iwTOHHVDNXhwVXHr+ogOPHMbQ3nIOuNX6asK69LBHSd+FpqwlokBHgNo2FQ/M+aavE2nv9v5bOhc9QHGDxwCtmzJjy66+/qu+QFh2yCdocPHhQKQ9IJpMzZ05VgwkWjsOHDyslBN4XUHqg7KA95BfEjv7777/qWFhFvnz58ifHztGwNJbEMcdPm1f634vQ/G44xi9MGMCqAsyYFy9eVAMOTb5p06bqYW7UqJGxHUyL06ZNU6lm/fz8lJsTViHatGlj1/6TIAw+D+TAX3Uk5ZGPWvi5Nl9L5brtlNm5VatW6gf2iy++UCs4hBBCSGQAi8Hp06fV++PHjxvjNG1Fbz3QryxDSNN81OHCtX79evX+3LlzSnaBCxi2b9iwQW2HkqHFkKBI2W+//aasG3hdunRJ8ubNGwFXS0jk4LQWC1gUKlWqpCwPeNDwEMMfEgoEgro1fv75Z+UK9fXXXyuLRsaMGZVJEQ8rsTN+b+Rwn68lwe6P2veBWnml+S8jlFm5Xr16yiQMbt68qZSLrVu3Svbs2e3YaUIIIZGBeSwd3JNCCrzWg/iD8IK09Pg7M2XKFClXrlyILtNhBYubSDyCWAksiqJ4LwoEYgGtWrVqyhW7ZMmSKtslgEUDi6X9+vVT1hUA6wchjoqbwQXC82GJgKUiJHCZ8OkMS4VP+F0mSJBABb/ZK8ZCiwtxFDN2uAkMkNMDq4r/klsS60Na2YPFkkvjGVvE08NTWSuqV69uVCy01SD4pUJJlOg+flEIx49jaG84B11v/PD3+Nq1a2qlPjT+2xHdB7z0SglkBSxsoSYWvBtSpkypZAAEzqIdvoMFwjy1OdogHkMT/mGJSJUqlXqPRU3cA32dLQRxQ64wvx+IO9GfWwPHwD4ASWrQzlI/HBVWL3ee8bP0bIZGDnZai4WeTykVADciLEoFiRwuTW0tr1feFG+/oAfkZPY40mDqWqVUAFig4FMKKxRyjWNyI9tXaJUKQgghxBL4u2Ku1EBW0BQATbDHZy37knkRXg1zYUtTKoCmbNhijTE/t/4Y+uNY6wch9sYxli5ItOLWioFyf+4e8X4dpFRcSe0hFWaukjhepisv0I7Xrl2rUvWhgFGtWrXs1GNCCCGEEPIpXMJiQZyHR/sXy6UJcyTVkyCd9kFCN8n+zxxJliStxfbI1oFihswiQQghhBDi2NBiQaIMn8v75fjfvSTV7aBp9zK2SJwxQyV7lsIhFiykUkEIIYQQ4vhQsSBRgu+jq7Lvz2aS9qKH+uznKfK8byfJlbusKgykpdkjhBBCCCHOCV2hSKQT+PqZ7Pq9hqQ7HqTHIpv3xfZ15PVTL5X2F8V/kE1j2LBh0qlTJ1ooCCGEEEKcEFosSKRi8H8n23pWllR7gooDgaPfFhW3ZIVVgUMoFQCp/Lp06SKNGzeWN2/e8K4QQgghUQCKAo4ePTrENj/99JNKQxqec4wdOzbM+xPngYoFiTwCA2R33+qSbPMr40Q7VD6DfN9nlip+N3nyZJMUwLBaoCiQLemDCSGEEGemdevWqmaTvUERYVT7Dgn8zdZXEw/LOY4cOfLJdlu2bFGFjX/44Qf5559/1KIjcS6oWJDIwWCQwyMbSuw1dyTGh9+FE/kTSqPxq5WrE15t2rRRP2Z58uRR9SlQr2L48OGqAAwhhBDiyqAArLMIzpUqVVKLf5HJuHHjlEKRNWtWVcNqwYIFTDPvhFCCI5HC2Rk/i9/iU5LoXVCtiguZvKTGrA0Sw8N0xSN37tyyb98+FvshhBASpSAb4fz582Xz5s3y/Plzadq0qdStW1emT58uOXLkkNKlSxstC2PGjJGlS5eKl5eXHD9+XFnbIWgXLlxY1q1bJ4UKFZKvvvpKtUPV4iJFikj79u3VKv+PP/4orVq1kmnTpkmyZMmkZ8+esmLFClUN/ZtvvlEV0fGdOQsXLpQ1a9aoqtsVKlSQX375RR0LbsQzZ85URfi6d++uqm8/evTI4rmtbb9y5YqMGDFCeQgULVrUeE64K+Haq1SpEswVatSoUVarpFvqq/4cOHdIwM3qzz//lIMHD6rzgyZNmkjevHll06ZN8uWXX6prx7Z58+ap6uPdunVTsZmXL19W/StZsqTaz9o1X7p0SUaOHKnuIRYzz549q+I6f/31V3UMFC1s2LBhsGsnoYOKBYlwrq0aLA9nbZYUPkFKxc0UHlJyzv8kbpwEFtuzgighhERvaozbLY98fCP8uMnie8nqn4MUBHMGDx4sy5cvlw4dOqiCrLCeA1jP9VWuIdjCsnD+/Hm1ig5BtECBAsrCDgWhXbt2kj9/fiX81q5dW2rWrCkrV66UJ0+eSP/+/VXWQwjO1apVk0WLFqn9oFBAIYCgbF61G0AI7tWrl/Tt21f1JX369Go7juXj46NW8iHIQ9ieO3euxXP/9ddfFrdDgIcFAufOkiWLErZz5sypjg9lKnHixMH6gzHQqo/b0ldfX1+Tc0ApyZ49u9X7hGMkTZrUqFQAeC9UrFhRKXK4Dv04Tpw4UVatWiXNmjVTygPG89atW6qPIV0zlLLMmTOr/iJ5DKhRo4Y8e/ZMKZe4txkzZjTpBwkdVCxIhPJg/2K5PH6mpH0U5GX3KIGbHK74tfxVvYHs3r07XD6ahBBCXBMoFfdfhj04OCwsW7ZMZs+ebVQobAGCPNx4NSCwQtA9ceKE3Lx5UwnBeL19+1Y2btyoFAsAQRgKRKZMmZRi0adPH4kTJ44SamEFOHDggAwaNEi1hRUiX758kjJlShVzUKJECSlfvrzxnBMmTFBCOITpNGnSqJV3S+euX7++xe116tSRDBkySL9+/dTx0C+MBYAFJrTAcmLe1zNnzpicAwuIsPhYA9+/fPky2PYXL16YKF7aOELR27lzp3Ts2FFtnzp1qlIg7ty5Y/WaMfYYd+2atf6gDZQ07A/FZO/evVQswgEVCxJhvLi4V47+3Usy3gryw/SJJTIssbes6T1MfYbpFiZlQgghxNyyENXHhesLVsrNFQtYEhBsDCBswmVJA5YNPdpn/AtFASv0WiyCXiDGd9oqvLbyj/dajAVW+Zs3b67eQyBHH7AYh/5t27ZNrcLDTQjcuHFDKRb37t1TSom1c4e0/e7du6of6ANchsKDpb7CNSo058A1wyVs0qRJyq0JQDmBm5mmDJiPo/ZeP67WrhkvfX8whuD27dtKUezdu7eaD3CDgzsXCTtULEiE4Pvomuz5q4Vk0hXAm5ortaxZtNXYBisXeNj1maAIIYQQa+5KkQmEScRUwB8fAqkWY1G9enXlg49VbD8/PxMB1hpwn/nuu+/k999/V25FEGohYCPewBqwSsA9B4oNYizgvqNPzwprCLh+/brJCjqKyiI+BCvysIiEdG5r2xFXkStXLkmXLp0StjVXK2sxFiFhqa9wfzI/B+IirJ0DCV0QOwErC7JBQRHAceFChWBuWwlpLD777DPVH1wrXKrQB1hKoNzh3OgjrBckfLgZMDtJiMA8hx8dc5NcVBEYGKhWTKDNu7s7XiKvgJcP5L9O5SXj3qCpFOgmcqFTA1m+66oKjNMDf0f4hkYljj5+jg7Hj2NobzgHXW/8INhhFRvuKdYCgqMC+NUfPXpU/Z2HgK/53WNFG/2DcLxr1y4pV66cXL16VS2MQXgFhw4dUgK0PiYB+yAWAzEGaFewYEHlilO5cmUlPON8Fy5ckGLFiqkxgNsNUs6aC/KwmMAKgPuFNOwQirE/hHPsjz6nSJHCJG7B0rmtbYfoBwsIAqtxTLgP4Rw4Lq5Hu0YNBLjDxclSZihrfdWfAy5b2ngibgKuS5YUBvQRMS6wGiCOJWHChMbv9OMIl6enT58q5QzAUoLgbQRmh3TNcDlDm7Vr16p2UIhwHKTCxVhCkYRFA/PSkTAYDEZrC64/qp/N0MjBVCxsgIqFdQyvn8jWLmUl9Y6PKfOOf1dKGv01TT0ICObCCz8OUCrKli0rUY0j/lF1Jjh+HEN7wznoeuPnKIqFowl1nwJKAKwC9krLjhgTzU1MA8L5559/bvMYQiHTZ6KKKmAJgUKB/kORgpKB+BBnwOBEigVdoUjYeftcdnevICl3flQqjnyZVRr3+ke9x+SHbyRWdGAKtYdSQQghhLgKiAGI7HoSIdGgQYNg7kL4+x4a7KFUAFiJkO4XC51QhBAbQiIeKhYkbPi/lQM9K0nCrX7i/sGZ7nDJVPLdmJXBtGnEVRBCCCEkfNi7xoK9zx8ekBIYLxK5OIZNlDgXgYFyeGBtif3fa/EMDNp0oFBC+fafDeLhbr+VFEIIIYQQYj+oWJBQc3RKWzGsuikxPnhA7cnqKaMuvJK3r5hNgRBCCCEkukLFgoSKkyuHyas5OyXeBx3idFp3ab/trJw8dlrq1aunMioQQgghhJDoh9PHWCByff/+/SpSHoE5Wi5mje3bt6tcyHqSJEkijRo1iuKeOj+Xds6XOxOmS8ZnQTEUdxK7SZtjV8XvTZA/FKpudurUSVXGJIQQQoh1kB3pv//+U+lmkZK1Z8+eTjVcqEfRrl27UGeoglyGwGnzTFJIWYtjFS9ePNR9QcYkyB6//PJLqPf9999/1TnN5cfly5erNLWZM2cO9TGjM05rsUDqLWQnQE7j1atXq3oJKHYyfPhwk3aLFi2S0aNHq3zG2iu8VSajI3d3z5PLA/tJxltBSsVL1Av64y9JmyYo5zdAQaHffvvNjr0khBBCHJ9Hjx5JnTp1jBmWzGUXZ1EstCrioVUsDh8+HKF9QT/Qn7AAxQLpZ+3B3bt3ZebMmUpORU0TV8DTmRWLb7/9Vk0ILQvRggUL5Pvvv1cPK1KcakDjHD9+vB1769w82zNfzvbtLxlvBemhvjFEvIb2l2KV6svBirWVMlG6dGml6Nk7xzchhBDi6Jw4cUJVhB4wYID6PHnyZInuQI5wJFCFPTLZunWrkmOrVq2qPGnGjRun3ju7vOq0igWK/KD0u55KlSophQNVKfWKxYMHD2TGjBmquAfyJ4c253J0xufQEjn5V19Jcyco29PbmCJvBv4mpSsFjT2Kp4wZM4YKBSGEEKcCK+dx4sRRBecgJ3zzzTeqmjVW09esWaPckwoXLmxMsYr2cePGDdYeHD9+XFV/Ro0ECIs4rtb+1q1bKv6wYcOGqi2KFU6bNk0uX76saj39/vvvxj5t2LBBFcHLmzev+oyV7A4dOqiFU7gO5c6dW+7fvy+LFy+Wjh07BrsmFDDDguu9e/dUYcS//vpLdu7cafE6rfU7pO2bNm2SM2fOyFdffWU8J1b70e/WrVtbHV/0GYI6KnADyGrLli1TY4NxSZky5SddoczHE/1asmSJsv7AY+JTYFxQqRvu87BwNG7c2HhdsBzNnj1b/du0aVO1/VOuUDgeqoOj0B6uC5W/FyxYoL4rU6aMqmKu3XNrxQYhm9aoUUN97tevn+ofFmlR9wsKRvXq1WX9+vWSNGlSqV27tqxbt0553iCmVauOjvv8v//9Ty5duqT6C4VVuyZ482DBV9+fWbNmqXuCe1utWjVjtXmJ7oqFJTCwKByDG60Hpd8xIfEvJtLff/8tXbp0sXoclIDHSwMVB7Wbh1dUg3PiIYzqc/vePCZHe/0hyT8oFW9iitzv3UGqVmsWrC/on6Nir/FzFTh+HEN7wznoeuOn9Ul7ydRyIq8eRvyJ4iUXab3d4lcQnBcuXCgVKlRQQtjIkSPl5MmTxj69fv1a+vbtqwQ5xBJAjrDUHtWcoSDUrFlTjh07JlOnTlVCMo4P4RNCIgQ77e+k/u+l8fo/vIcQCcE6T548RsWiTZs2SmBEbCgEeAiHPXr0sPh3F0Jx7NixJXv27EqgRBtr12mt3xDWLW1H5ephw4YpBQHxlKhgrb+H5v2xdN5Tp06pdlidx7i8evVKCdew4OzatUstViJe1tr90o/nzz//rIT6cuXKGZWakGQR7Dt48GC1P4TwuXPnqnuqVQ8vVaqUnD17ViliEMihWMSPH19VoLZ2PIwH+oIK3hDSvby8JFeuXDJp0iSlIEL5sQTk0WfPninFQesz4k6gPGAcvvjiC6VYoA9QKDEP4DIFywbuL8YU14BFdiiKGF8oJb169VJj2bVrV6X84Zg5c+ZU9xB9RH+0e3Xjxg2lhGBcNSVFPyf1Mm9ofjtcRrGABo2B7Natm1Ej1jTCCRMmGCtVzpkzR1q0aKEmQpEiRSwea9CgQerHxBxoxSh1HtXghmIVAjcakygqMLx6JKf/aCxpr39QKrxE1n1TVlqVqqdWW5wJe4yfK8Hx4xjaG85B1xs/BCyjX1g5xsvz1QNx87kX4ecxiMFqHADODyG5f//+RqF848aNKnYTng+Ix4SXw8qVK5Vwb609hGS48UCozJAhgxJMz507p9pDUMRKNND6kThxYuVxgcBtCLQa+B73KCAgwKTPeA9hFcHdsFjA/bhixYpqO2Iz3rx5o7w0sHAKzwwIw4UKFVLCqSYchqbf1rZDsIWigGNDkIX3B/qQOnVq+eGHH4KNs/68uC6cF4oRtmNVXrt2XBOEbK2vId0v/XjCYgPhGsLzxYsXpVatWiHGfGD/zp07G60In332mbrP2A75EW70WFSGgI7jYLv5vTA/HvoAYR0WACgLp06dUgrdihUrZN68eVb3xfxHO0tjhrHS5gKUC1gUMOZQdlB5HftB+dLiQuBS1b59e/UeVhOcF0ohrFObN29W21etWqXkXxwX8i8UOpA1a1alzLZq1cpkvqEfT548kRgxYqhtPj4+Eq0UC5gT8UOAgRw4cKDJd+ZZBzCx8VDCnGdNscBKgN6iAYsFHiCUgvf29paoBjcYEwnnj4o/Cgb/t7Kh71eS+URQvESAm0j/1CKFA1JL8uTJxdmI6vFzNTh+HEN7wznoeuOHRToIK3B9UVmF4qUQg0RCjF685FazFmEssOiofY/PeA8hDX/3NavB8+fPVTtr7SEA4l9tbJs1a6YEfHxGpiFL58dxcE/03+E9Vuzh5oP3+Bfn1sYIwj1kEbgV6fug7xfcXGBdOHjwoHKDglIU2n5b2w4gaOI7TeA03j8bxhfXi/2wHa5P2na4N0GA164lpOOZj6fWH21bSBmqtGPrx0HrD1bzte8g9GvXr++/peNB8cL32vyI8WFctM/W9oWFAPIkhHrNFQrCPjxvcA+xH8ZL6xeUJ8hf2vHhqgUFAO562rkAlErcL21/7fxaGzx35cuXV/IyFFyARQfzeYi2sI5gPgLt32ihWFy5ckWZwfDCzbDlRxM3Ag+rNaCl42WONuntASZIlJz/va+s6fOVZNjx0RVsWlZ3WbXmrDx8sUH9UDkjUTZ+LgrHj2NobzgHXWv80A/0SXtJmx1R3gecd+nSpWq1HKv+yMqDIGqs7EKAg4CtZZHUEpNYao9VbrgOwRUGAiCAAmByfRbObf4d3sNSgJSpWIGHW46mFGLFGeeDnzxcXxAP0Lx5c+nevbvJcWFtePr0qeqf1k9r12mt31iFt7QdVgmcG1YIbWUeL8Q8WIqxMD8vYhumTJmi4jcsXXtI42VpzOAaBssN5D8cU2uDGJnbt28r64Y5sPDge1g6INhr8biW+mNpu7U+IQ4DSkD16tWVdQlWHlhy8B3iIhDPAGuCHriW4RoQHwIhHkoF9sf1mB/f/Jzav1Bs4NqFa4JVA0oB7hX6A0VE3x9s1ywwmN9QnmHVsHYv9L8XofndcGrF4urVq+oGYFDxQ6C5O2lgAGGe0gdyY3DxEDha9gGHwO+1bOtVSdKuey6eH9zpduSOK2NWHFHvnVWpIIQQQiwBIRqBsbACDBkyRK34wucfbicQvuAChVXlkNrDFQbB1qjlBKFeA/KJJpibA793/Srxr7/+qv7FSjLOCxcduKcgnT6EOsg7SJ+PfSDvoGYDVta1FWxzIFRiX7j1IEg6NP22th1jAYEVtcHgUg5Xrk/VsNDOi2ByZMDCec3HpW3btmoFHnJZSMcz3w+JY6C4wD0bAe5wPwK4bpzTEoixhcsSyhMgiygEaChL+hoWmscKFKiQaliY74eYlfkfgqUh0CMuAsB9SXNV0oP4BsRDwC0NVgPEfOiVD1yTZilAzAyOqQElT7M4ICYG58Z90bvrY94imBz9gTsVQgag4OB8eMENCopNWFIGh4SbwZGjbkMA/n14MDGI8DvUKxUIaoHPHgYLGR0Q9ASTJvzRYNWAbx98BW1NjQqtDmZA3Hh7uULhwcEPRaStNr19Jgf++FJib3wtMQKCNl3KFk++XrZbNvy3SX3WT2pnIkrGz4Xh+HEM7Q3noOuNH/52wxqAwNjQuFlEJFiVh0sOBNuQ0HzeIRhjVfpT7R0NW68zMs+rjaHmohMSCKjWgqo1IO+FlGFJDzJmIYbFfLEZ2xB0HtqFZQRpw3qkB/ErkDWtcfjwYTVf4IoGZQPxL+EhNOOngfgKuMVBOcSYINOZtRCATz2boZGDPZ35h1LzS4NJSw8CcgBuAMyGiKpHZgOYjDDQJUqUsEufHRa/13Kse0WJu+mteHxQM8/kiCc1F20Xz5heTqtQEEIIIdYIyaJgrT1W3F39Op39vNYyMZlbGCKT1KlTGxWh8CoV4QUKAgK8tZihyMZpLRZRiUtbLAIDZE/nkpJg00vx+OD+dCRvPKk7b6vEieV8P6DOslrnTHD8OIb2hnPQ9cbPESwWkblaTDiGzjoHw2uxcIxfGGI3Nv3xtcTZ+lGp2FMwntScu9lllApCCCGEEBI1ULGIxizv9514/3dDYvkHfT6U2UPy/j5WvGMHpZUjhBBCCCHEVqhYRFPOrBwhSTYcFe/XQSa1S6ncpN3eS7Ju+cfsF4QQQgghhNgKFYtoyNX1Y+TByH8k+dMgpeJ+IpGW525IqxbtLFYcJ4QQQkjUgxSiSCWKjD7mmYkcHVRu1upLWGPbtm2qNEBknsMaSKdrKcw4vH2K7lCxiGbc2TRBrg6dJKkeBikVT+OJDI3rLc2+/0lGjhzJwDRCCCEkCkCmHgTWWwP1CZCVcdKkSaqO1NSpU53qvqCIHgrShcTChQtVPY7IPIc1UKHakgIR3j7ZAgoGHjhwQKWl1deecAWcNt0sCT2Ptk6WM0PGSrp7QfrkyzgicSeMkeX5y6jIf2a7IIQQQqIGFDk7f/681axYqMSMYn2ol4DieKhc7Wo4orIU2X3auHGjqpqO1LdQbFD9GoXsypQpI64ALRYuDqp3/vzzz9KvZi4503+UpLsddMtfe4kEDh8oBYtVltixY1OpIIQQEu3w8fFRRcTganTlyhW1DS5Hd+/eDWZZuHjxoiq0e+PGDTly5Ih6ofgY2kNBAEjTCVcapPfVu9xgBRwr1FrdLbRHoV9UR8b35uCY+Pt98uRJdR49qMel8fjxY+UKhDSg+qJyOA8qLVu7ZvQR14zKz1offX19lfKCKt96LF1TSNtRPwwuXHpwHoxdaN2OLPXV2jmsEdK1IYWr/r7Y0iccz8/PTw4ePKiUAtzbvXv3qvG4fv26cR5Z4tmzZ9KkSROZN2+e0WIxduxY+e6775QVA/3BfcT7Xbt2GccW9xL9N3fdwvYdO3aodLAa1vqDuQa3OpwzMitN0GLhwuCHsVSpUvJ9Rn/5MmZKSfg0SKl4E1PE5++eUr5CXXt3kRBCCJFv13wrj98+jvCRSBo7qSyuvtjidxDUateuLdmyZVM5+rGKnCVLFrViXbx4cWOBs5YtWyqXG6wqQ8mAkAoXJQj98PGH0gHrw6xZs1SVZhzj3LlzMnPmTPnyyy+Vy02hQoWUsAjh+J9//lGCIIRmvEd9kYoVK5r0bc+ePUqBWbZsmXKVyZgxo/G777//Xu7fv6/eQ6nAeefOnSvjxo1TwiTOWbduXSWMWxJs8+fPL1mzZpW4ceNKpUqVpECBAqqPefPmVQIzrnXw4MHqun///XeL12RtO8YQgm7atGlVzZR06dIZhXWcM3PmzCb9adWqlboGS4X0rPXV2jmsYe3aQIMGDUzuS506dULsk3Y89AMCPFzUunXrJq9evVKWJy+voKLCGB9LQODPnTu3yf3GORHfinPiu0aNGilrRpw4cdTYNm3a1KhkYL6OGDFCzTncYygNmD+XL19WCifmCeQ+zBn0J2bMmMb+4PowBpANURF93bp1EhlQsXBh/vjjD/k2tZ80cUslcT4oFc/jiDzt102qVWti7+4RQgghCigVD9+YrnxHNhAKJ0yYIPXq1bN5Hwh+U6ZMUe/r16+vhDt4Bdy6dUu6d+8ukydPVkXMYN0YNmyYErbBgAEDlDCKFWO4NUER6N27tyxfvlwJgFj5PnTokGr7+eefK+F21apV0qdPH/UZ+4QEXJlnz56tql2PHj1aKRkZMmQIdlwInFCiBg4cKIULFzZxw4JwW6xYMaWclC9fXipXrqyUFvNrypkzp8XtUDJg/YGlBQIttmlWhk6dOqnV+NAAK4x5X2FxsHaOkDC/Nk2xML8vEPJtAfelSJEiyl0tUaJEsm/fPqPS8alrSpgwYbDtWvE5AEUH7lJo17ZtW2U9gULy6NEjdQ1QLPA9LECDBg1S+2zatEnF4pQtW1aSJUumrgdo1wnmzJkjx44dU0ot5ENYzXAvIxoqFi4KzLN396+W/ok+KhUPEojc7/urNPzqB3t3jxBCCDGxLET1cWFtyJUrV7DtEJb1rjBwWdKA5UGP9hkuSRCcp02bZvwue/bsxvd58uRR/6ZIkUJZKoA+rhECLwR10KNHD7WibAsQQjWwwo3VawjdsMJYOi5Ws6dPn64Uml69eknp0qWN2SBhGQBYLcdxrV2Tte3Pnz9X1gMI/AB9sEXotwZW3837WqtWrTCdw/zaQrovtqDdd1wzFCqNbB/G3RqwwHTu3FmdK378oELEGE9Yv2BVAalSpTIqH0mTJjVaq6DAaHMR+8Cio91bAKUC/dFbhbT3sGh88cUXqn84L6wfUDqpWBCbieP2Vn7LmlTiXwr64bqTWOS/76vL0K8+aq+EEEKII2DNXSkyweo0XJhgccCKMZQMCImwSmD1F24tO3fuNK4khwQEVAi8cKHKly+feHh4KCE2JJIkSaKCs3PkyKFcYyy5LlkCwiKsLRAKx48fbxQeoThgZR+uOd98842KBUB/9MeFMoWVbwQKQ3mB25emWPzyyy/K1QbtYfmwdk04r6XtUC6gyMAKgD7BcqIpVxD+IdCau0KFhKW+4hpDOgeEb0vjbn5tEQWEeYw35g6UnRkzZkjr1q3Vd7CsYAzRJw0oD1WrVlUB+e3atVMuTWPGjFGWBYwpFANbwHzBGFSpUkVZpuAShnNBWdX6g/mr9QcuVVBQ2rdvr5QSjFVkxVkweNsF8fd9K//7raqk/qBUIKbiv7rlZGi7YfbuGiGEEOIQ9OzZU3788UflNoKVX7iJAATXQmBbuXKlfP311yqwFsIzBFgIcRpwLUqcOLF6D6ES7imIv4DLCY6HOACA2AAIfgAr0XChAXBpgfAJtyhLFC1a1LhynSZNGuPqOuIZbt++rWJE4E6F1XMIjliJ79evn3L1gcK0dOnSYMeEfz36BiEdlg3ESWhAAIXgjRVzWCOsXZO17XBV+u+//1RsCGJEoLBoK/uIsbBUhwMCNixElrDU15DOgfdY+beE+bWFdF9C6pP5fpgPGGfcC1gF2rRpY3JOeI+Yg/sHZRZKK1ycYI3RUubGiBFD3T8NKHF6RUlzrUudOrWsXr1auYZBecA4IX4EygPSFKM/CEiHMgUrVrVq1VSsBWJ2EGcBRQuKbWTgZojM0HAXAf5omv+bt7d3lJ8fGi3MVpgc2mQ2Bz8qCB4qlD2dzBpUQ4r975V4fkiPfaBVRWnedbxEV2wZP8Lx4xx0XPgMu974wdcfK8+ZMmWymm7VUYCYBNcfCJuumpYdgdDIIBSSQB2ZYwjrit7lTFOsMGdtBXEDiMeIqGsLS5/Gjx+vZDHERiBYGtaDqJ6DiPeAtQfP199//62yT33KevapZzM0cjBjLFwAaKAwe45sWV6e+9yU4sc9xOODunihfPZorVQQQgghJGT0q/D2AFYbuOjoQdxDaBQLS0pFeK4tLH3KlCmTUkZgAYkopSK0IKAcqXgRxA1rSmiUioiAFgsnt1jADFawYEEZXUSk4NuUEvuph/G7e9mSSPkV28UtklYgnAVHXK1zJjh+HEN7wznoeuNHi0X0IjpYfVxl/N6F02LhGL8wJEwghzJ8P5tkfC9FH6cyKhXv3UWOVM0j5Zdvi/ZKBSGEEEIIiRqoWDgxCPp6eumI/JAgrXj4Bt3KG8lElnb5ShqPXCJuMWLYu4uEEEIIISSaEL19ZJyccl+UkUmVckmcE/7q88MEIqvafy0Tvx1OUyMhhBBCCIlSaLFwYhb0aSCpPygVcH9aUbcglQpCCCEkFCCDDlKnulJMDa4pPLx+/TpYRiRbQGFBSylWw9sn+PbD/Tu04L4iPsAcpFy1pT4JCT1ULJwR/3eyeGAtybrmvHHT7krpZORv82mpIIQQQmwUglGJGgXqUGchsrFVuA6vEI59v/32WwkPo0aNktmzZ4d6v1u3bqnaH5b61Lhx4zD3B/UhkDY1tGzatEm6dOkSbDuOhfS0UcGrV68kOkHFwtm4dUh2//K55FxwUbw/LCZcyxJLWo9aJ+5uvJ2EEEKILRw6dEilBUVK0a+++irSBw0F31B4L6LaWQNpRjdv3iyOBPq0YcMGcRRQzRs1JyKTadOmqUJ2KMqHYnRIhwul0dWJFpLoggULpFixYqoiYY0aNVR+X2cD2v7xeX/J8Y7fSJJtARIzIGj77bReUmnOJvHwYLgMIYQQYgtI3YlqzhD47t+/r9J56leY9Z99fHxUCk6NR48eGdtp7kLW3GrgFoTjox3a4Lz4rLXH+wcPHijriYaldgBtUF1bD5QitA2LxUPfNw1b3Z/0Lk/mfdLQb/9Un/THg+uSNv7Wjh2Sy5O1feDeZasrlP54+nbasXEtIdWXXr9+vfTv31/9i/lz5MgRVVNiypQpxr7gWDiGvl9oa+m4aKufI9b6g/uHe2rJHS2qcHnFAjeyefPm0qpVK1m7dq0kTZpUypUrp3J6Owv4ERvWtqYY5i0Ur7MfK5Qe+DyJlF2zV2ImSWrX/hFCCCHh4Vq9+nKpbLkIf+G4lrhy5Yp06tRJyQioBQWB7tKlS1KgQAG1ygxZYdGiRaptr169ZNWqVcZ9ixQpohSN4cOHK9kiQ4YM0qFDB5Pj41hYzMyWLZs6/ooVK6R79+5y5swZ9RnvIbziPc4Jy8mQIUPUvubtwG+//SaJEiVSq9+VK1c2CqNYLMW16IF8U7FiRatjbalvEPyRvh6KVubMmeXEiROfdHkqW7asVKhQQVKmTKmu4fbt2+o79A0WIPQ1b9688vz5c9WnkKww2vFwbejXjRs35IsvvlC1Vz777DOlfH3K5al+/frqfLCO4DiakoR+4TpR3K5q1apKAN+5c6e0b98+xOM1aNBA7QfrBsYMLnO4pmrVqknx4sVDVExmzJihXK0wLgDjPXjwYJk5c6b6PG7cOOUahloRmGsjRoxQ448q4Rj/e/fuGa1XGJc0adKosRg2bJjaDqU4e/bswfqD4njoM75DYTxY5aIal1csBgwYIM2aNZMff/xR8uTJo0qso0DQpEmTxBnAw9ihbnn5wdNT4tyMaQzUXlI9kzSevU1ixopj7y4SQggh4eI9Vt4fPIj4l1nlZA0IiRDymjZtqlZ4UfQLQjzkBaxU79ixQ37++WcTS4UlsDJ88eJFmThxojoOXhDSsT+Ee/wNxzYIjZMnT1aCJj7jvZeXl3oPxeDYsWOqPxDCzdvBhWjfvn1K2D9//rxkzZpVpk6dqs6P7biW0GCpbxBI79y5oywgOM/Nmzc/eRwU6J0wYYIar7p16xorX0MpgOAMQRdK2MqVK23qF443duxYpUTMmzdPCcc4NvoGQfpTXL58WcXK4LxQkCDcg+vXr8vWrVvl2bNnanxhPbAFHA8uZSdPnlTKZevWrdWx+/Xrp64xJO7evauUBj34jDHWW01wXVBaevTooeYijl+7dm1ZvHixatOzZ0/58ssv5dy5c7J//341R3CMv/76S3766SfV/u+//zbeL8TWQCnBnMRY9u3bV6Ial/afwYTEA4Ibo4GqhXigoK06A9PGDpCf3A2S7F6QDvguhsiQMgnln36LJYYH61QQQghxfjyTJrX7cSHgwwoBsPKNlXgIaah0rHdP0bseYbUYCgKsDVAuwKlTp5SwjurFlSpVkvjx4ysBDyvperCSXr16dXXeuHHjKqEXK/ewTOiBMnH8+HEpUaKEcRs8McKKpb5BqIdsFCdO0GIlLBGfIkuWLJIrVy6j5QTCMcA2WB0AFCRbA9Fz584tOXPmVO/RH4wNFoKxWg+rxafAqr02xrBMQP6DNQkB+okTJ1bbscCM/nh4BBUUDglYTGBN0PoDhQKgL+jTp8bm6NGjSinQgPIIpVAD44+5AysF+qfF+aCPmuKCew9vG308COYI7h9crbQx1voDhQSWGMxXyLta/6MSl1YsNM0Q5i89+IyH1BowT+pTz2l+dliFiMrAm7s3LkipzZsk+fOgzz6xRQbkSiCjus6TuLHiRosgoIgA44SHjOPF8eMcdE74DLve+Gl90l4Zly6JtHNZ84XXn18TGIcOHSrdunVTlgBYIyD0pUuXTvnKly5dWq18Q9nQ9oPgi3+xoo2XBtyB4B7Vrl07tXI+evRo9YJrM1bQ4fq0ceNG5SIDVyTIK40aNVJKC5QMfTsIzBC6YQVAf6DoJEiQQJ0XFga0gRBpfr3Wrhtjb963H374Qa2AQ5iHLz9cxJBNKaRzYBUdgizGbcyYMepfbNcrYpbmnaV+YRuEff29QDwCrhtCNhaD4Q6G72FlgdJnvj/cl7Zv365chqZPn64ySZmPhdYf3LdPzQ3t3mr9gbsS+oC+wEKA75ACV7OQ6OnUqZNSHNBPKDZQNjGeuCb9nNOf37yP+LdkyZJqf1xLrFixJEaMGOqYhQoVkpEjR6q5imLJGCO0x3XDcgS3MygkmDMhxYJYu3atD9q9C81vh0srFtpg6h8G7bOlIBiNQYMGWTQf4UH/lFk0IvH0ii8Ps8aT5IdfydP4In8njiV9Oo9TPzrOFCNib/BA4MHXfigIx49z0LngM+x64weBDP2CIG0efBxVQEjDir12friUdO3aVfnnYwVYi7Fo0qSJcrHBijLeQ6iDDIHVfaw4W+o/BEj4w0PegEsP3seLF09ZOOAzD8EPK+DLli1T54Mff9GiRZVQbt4O7kZwy/rll1/UajXODSH3m2++UZYCZB/Su0PhPkPQtTaulvqWP39+dW1QbuDjD3cc7do+//xzJbTrXXuwHb78e/bskT///FMlyPn111+V1QWr79q5Y8eOrd7jXqNPuO+4RnPQZ/1+LVq0kLNnz6rrg2JVq1YtpXhA2YM1BG5NejAm5cuXV2OFheOaNWtKvXr11H2Dm5t2XLzHdeOl325pbui/79Onj1LGYAmpU6eOsqzgOyigUDZ27dplsn++fPmUwgh5EvcZ8Q7oG+4n9jOfO7C0aO+xHXIePvfu3VudG9ePa8fYwUUL2zAntP7g3mCsO3furFz6YD2DVQsWi9A+X9r9gmUH4wAQg2QrbobQqjJOBBQBaK7w78NN0YAPJUyP0PJstVhgxQITGRMtKoEP3rL2X0r2uq0kTaEg7ZeEDjwgmAt4cB3lj6ozwfHjGNobzkHXGz8s0mFFHgIRVmIdHQjEmpDlLEDY1jJYmXttWBLuLQF3LayAm8el4t5BCYFgHZoxxPwLT58Q84DA9o4dO5psX7NmjZL1oGSFBsh65koKFBhztzVzoDhAmUAsCBSd8KQHDssc1O4ttiGxwMKFC5WSF1HPJlytYE3Tnk3IwXDRwwLFp+Rgl7ZYYGJgYKBA6BULTAZo49aAtoiXOXggovpHGTe10T87lIUCSpKj/FFwNvCDZY/75ypw/DiG9oZz0LXGD/1An7SXI6O59wBH76seuGwheNocBPbaukiKRVUEkJuDFX9YIGwdD20MEdQMy0xY+4SYBX3cggZW6+GuFdr7A/nw+++/N9mGrGCIjwgJWAKggMBqYI85eP36deWaB0UD7mJwaYuouak9k/rfi9D8bri0YgFgukJmqIYNGyqzHfwAoYEjup8QQgghxBWBUoB4hMg6Nnz4HaVPiGfAKyz7haU/iOWwJ1mzZo20exteXF6xQLAMUpchuh/mYFgxEJSkZR4ghBBCCCGEhB/HsIlGIjDnIMsD/MJggkPkPIJ6CCGEEGJfXDjMk5Bo+Uy6vMVC7w9onhuaEEIIIVEPfMOx8KcFlTty7AIELWTKgRzhyP10ZDiGzjF+OA+eSZwjrMkKoo1iQQghhBDHAIGvqMmAmEcEojoy+toHVCw4hq4+B93c3NSzaUsRQUtQsSCEEEJIlIN6DUjViZSZjoyW0x9ZkBwlq5azwTF0nvGDpSKsSgWgYkEIIYQQuwABJjxCTFQJdRC2kP6digXHkHMwZKh6E0IIIYQQQsINLRahiJBH5UF7rZagnDpXSzh+nH/OCZ9hjh/nn/PC55djGN3n4MsP8q8tGaOoWNgAbqZW2IUQQgghhJDoKA8nSJAgxDZuBiaRtklTRA2M+PHj2yUjBDRFKDW3bt2yqeQ94fhx/jkWfIY5fpx/zgufX45hdJ+DBoNBKRWpU6f+pMWEFgsbwCAi9Za9wWSiYsHx4/xzXvgMc/w4/5wXPr8cw+g8BxN8wlKhweBtQgghhBBCSLihYkEIIYQQQggJN1QsnAAvLy/p3bu3+pdw/Dj/nA8+wxw/zj/nhc8vx9DeeDmRHMjgbUIIIYQQQki4ocWCEEIIIYQQEm6oWBBCCCGEEELCDRULQgghhBBCSLihYkEIIYQQQggJN1QsCCGEEEIIIVQsCCGEEEIIIfaHFgtCCCGEEEJIuKFiQQghhBBCCAk3VCwIIYQQQggh4YaKBSGEEEIIISTcULEghBBCCCGEhBsqFoQQQgghhJBw4xn+Q7g+gYGBcvfuXYkfP764ubnZuzuEEEIIIYRECQaDQXx8fCR16tTi7h6yTYKKhQ1AqUiXLl1E3R9CCCGEEEKcilu3bknatGlDbEPFwgZgqdAG1NvbW+xhMXn06JEkS5bsk5oi4fhx/jkefIY5fpx/zgufX45hdJ+DL1++VAvsmjwcElQsbEBzf4JSYS/F4t27d+rcVCw4fpx/zgefYY4f55/zwueXY2hvAh1EDrQlHIDL34QQQgghhJBwQ4sFIYQQQuxCQECA+Pv7O/xqMfqIFWN6DXAMXX0OxogRQzw8PMK8PxULQgghhEQ5r169ktu3b6uMM44M+gfBDllxmBmSY+jqc9DNzU0FaMeLFy9M+1OxIIQQQkiUWyqgVMSJE0cFpDqywA6h7v379+Lp6enQ/XRkOIbOMX44D4LE8Wxmy5YtTJYLKhaEEEIIiVLg1gEhBkpF7NixHXr0KRRzDKPTHEyWLJlcv35dPaNhUSwYvE0IIYQQu2BvC8Dly5dl+vTpSpCyxvHjx+XUqVPB3kcmCxcuVFYdW/pEiCM9k1QsCCGEEBLteP78uZQrV0727dsnL168sNpuw4YNsm3bNuP7LVu2RHrfevXqFWJQe1T1g5DQQlcoQgghhNgd+HbrSZQokXL9sKVtwoQJVTab0HDkyBGpUKGCTJs2LQy9JYRYghYLQgghhNid5MmTm7wuXLhgtW3GjBlN2sI1KDQ8e/ZMli5dqlygJk+eLH5+frJ37165cuWKsc38+fNDdEfSc/jwYTl79qzs3r1bFi9erNKCPnz4UObOnRusbxcvXpR58+bJjh07TLafOHFCFi1aJPfu3TPZfvPmTeUatX79epv7Q4i9cDrFAsErMEni4Ttz5kyo9r1165bMmjVLDh48GGn9I4QQQohj8/btW7l27Zo8efJECf4Q2P/99185dOiQsc0ff/xhc42NNWvWSL169WT06NEyduxY9b5+/fqyefNm+fLLL+XYsWOq3fLly6VMmTKyceNG6dChg7Rs2VJthzJSpUoVWbdunTRq1EgpPgDtvvjiC+X6NGrUKKlevXqkjAch0dIV6unTp+oBxb958+ZV2v4PP/ygHuRPgR8HPOgnT56Utm3bStGiRcXVOX36tPoRgykZrxQpUkizZs3s3S1CCCHErqROnVrJAhDYYbGICOrWrSsDBw5U1g9vb2+VsjNp0qQyaNAgtSBaqFAhpRxAgSlbtqyyasDyAuVm3LhxsmLFCilRooSK90D/wODBg5WCkjVrVvV5yJAhKuCcEEfFqRSLnj17qlUGZEJA4Y4DBw6oh7Bq1apK0w+JHj16SJ48edQDH12AEtW7d2/j53z58lGxIIQQQiyAGA1NRtCKkYWGdOnSqX9jxoypYj6gVID48eOrQHEAZQKxI8DLy0vV8fD19VXbsQ+IGzeu+g68efNGKSgoJggg64SnKjIhkY2nM+XwhfvTn3/+aawGWKxYMfVasGBBiIoFViRWrVolR48eVSbI6ALcxvRYC4IjhBBC7A1iEvRoArglzNPDakJ5ePjss89kwIAByisCLtMQ9iOab775Rpo0aaIW+fbv368sE3g1aNBAvv/+e/XCdk3BgVfGzJkzldVCk30yZcoU4f0iJKJwGkkT8REwD8LqoAcuUVAYrIEgKDyYcAnCqoEtYPUAL42XL18aVzDwimpwTq2ce2gwt85AsbBH/+1NWMePcPw4Bx0DPsOuN35an7QX0Fb49WjfmROattaAGxIWG7X9IPTDQoCg8S5duqjvYR2AC5OW279gwYLKsmF+LiglCRIkMG5v2rSp8T3kFnhb4POvv/6qFAMEihcvXlxatWqltnfr1k1SpUqlXJg7duwo2bNnV+du3bq1qoC8adMmuXTpkvE6rfXDkdH66kx9jo7jZ/jwTOpl3tD8drgZnOQOw/0pf/786mGE+5NG9+7dZdmyZRZ9DjEQiMlA4JPmEoSHEXmrQ4rL6NOnj/Tt2zfYdmRysFU5iUhwHVCq8KPl7m57vP2cOXPU+OgxzzYRHQjr+BGOH+egY8Bn2PXGD3GP6FOGDBkkVqxY4shATEJwNwR9exf0c1Y4hs4zfrDU3bhxQ/1eaCmc4RYIZRfPLOKHXMJiETt2bPXv69evTbbjYrXvzEF6NuSp/u6771Q2KAATJ1LC4TNMkZZuEOIxsFqht1jAdxJlzj81oJH1RwH9xPlD80fB3O0LfptIyxfdCOv4EY4f56BjwGfY9cYPwgv+fmvJRZyB0NbJIBxDZ5yDeB7xO5EkSRKj0h8a5d85nmYRSZ8+vRpQc79KfM6SJYvFfVKmTCm1a9eWXbt2GbchAAqBUNu3b1emSkuKBYKmtMApPRhoe/0oo5+hPb/5BIS26yh/VJxh/AjHj3PQceAz7Frjh36gT9rL0VeLtT46el8dFY6h84yf9kzqfy9C87vhNIoFsizArQm5nn/88Ue17cGDB7J161YZP368sR1cpVCRs1atWlKxYkX10mOLK5SrYL4KZB7MTQghhBBCSEThNIqFlr+5VKlSKsAKQU/IlABFQV+bYcaMGSqjAhSL6A7qVsClCz55zmRuJoQQQgghzodTSZrIAIWS91AekLWhTZs2ynqhd/mB4gEXKGvUrFlTcubMKdEBZJgYMWKEvbtBCCGEEEKiAU6lWACkf+vXr5/V71u0aBHi/iHtSwghhBASVQHsWCRFhiwtra0zgdS4SKUbWp//u3fvqgVhJBPQc//+feXLH5YkM4hBOHPmjFqADi1Xr15V59TqhGhcu3ZNpTW2RzZQZ8bpFAtiO7t371ZFfjQ3qBw5cgSLOSGEEEJI1II6U1AkkCgGf59RowKpPJ0JJMeBchHadMFTp05VniVt27Y12b5x40YVT9uoUaNQ9wW1x9AfS6UHPsVvv/0mnTp1ktKlS5tsh7t99erVpWjRohKZPHr0SN37zJkzO0xyhfBAxcKFWbdunQwaNMj4uXHjxlQsCCGEEDuDRT+sri9ZskR9DsmFO7qgj5d1BCLbw+XOnTuq0jqUM1SOR2mDKVOmKAXJmXF+1YhYBeZVPQzeJoQQQj665GC1GAId3F40sO3w4cNy8uRJk9pZ1tprWRdhdXj48GGw9khzD3cbvQsUFAvUF8F5kApe49atW/Ls2TOT4sBw84HwiargAO2PHj1q9TaiEC6+x7HD0u+QtqMPsAroayvj+s6dOxesHyGdF6COid7CAFco8/NZOp5+PDFWKOZmC9gH++IcOJY5ODbGXwN9Rh8/dbwnT54oJUG7hvv376txunLlSoj9get+4cKFVYZTjPXKlSvlhx9+MF4bXLtwr9EnnAOgP3CfM6+Erd0DbY7o54J5f7A/5gbGPjQVtW2FFgsXxjy9LBULQgghjkiNcbvlkY9vhB83WXwvWf2zqYuL3iUHAj4ELSgQSP6ybNkyVfvq77//Vn9DIZQhzX3JkiVV+0OHDgVrj6K7yEQJNx4IgBAY4S2A9hDgzp8/LzVq1JBRo0ap80IInThxohK4IRSjrpYGEq4g62XDhg2DxqVGDbU/FIU///xTVqxYoVx3UPAWQqk5vXr1kn/++UfSpEmjYh8OHDhg9Tqt9dvadmTcRH8QG4HX27dv1TkhsKLfc+bMCXF8S5QoIcuXL1ffrV27Vu0Dgfirr75SbkcoXAy3KrglWbtf+vEsVqyYSuKDa82VK9cn5wLGDS5TFy9eVMrFzz//bLRKjBw5Ul03hPw//vhDfv31VzWWzZs3l0qVKlk9HuYI+tOhQwc1VqNGjVLWJ7ieY/yhLFgCrk+YZ2vWrDG6P2F8YK3Atl9++UXq1asnWbNmVQoO5syAAQNk7NixSjGFG92qVavUfpMnT5a//vpLZQJFH1AcumzZsmob2pv3B9eK4tGYf4gfQT/ixIkjEQUVCxcGRQX1TJ8+XYYPH65MboQQQoijAKXi/st3UX5eb29vtXILAbF8+fJKyK9bt656j5XiY8eOqb+bmkBsqT2ESWSoRAwjtn/33XdKaAUQ3LAarQ9wRlFfHHPDhg1KKLQFFPRFX6pUqSKxY8c2CqzIlAnvhAQJEki2bNlUbCWUlmrVqpkU+g1Nv3v06GFxe58+fWTChAkq5T+Ecy1QukCBAsGUCvPzoo/aeUHixInVuEBIRmwBBH5b0I8nZBzULkMAOYRxawqJniJFisjq1avl+fPnki9fPqUQAChzuMcooAxFAoqFLXz++efqXkCgx3hcuXJFVawePHiwUsSsAesIZDEob3qgHOA7DYw77jnu6bRp05QFC4vEuNdoh/179+4tixYtUmMNqwUUClwLFExYPzDWmG+YGwDuVjdv3pTHjx8r5Q7KKlzlIwoqFi4MTGqoY6EHqwNULAghhDgSsCzY47gQDCGkIksR6mLBQoEVXazQp06d2liBOKT2ENKwqqzFS0CQ09yZvvjii1BlTcK59O4peoFbEzAhMGrH7Nq1qxKSYVHB6jRW/dEGq/uwauBzaPttbTv20QKZs2fPrrZ/Cv15oYDgGNrqPICFAhmZQnI50qONJ1yxIM9AqdAUA1vQ+g85CAqe5nqF8QNp06ZVx7UVWAYAhPwMGTIopULrT0iKBTKcwmIApQtWCQ0I/z/99JPxM6wyIF26dOq+QZHA9WNuwuoBVylYg2A90YAFB9eF/mj3CPcBx0Z7KHi4x/gOygXuS0RCxcKFseT6xOrbhBBCHA1r7kqRDSz5uXPnVj7oWLnFSjWCiLHqC1cjrISvX78+xPZw5YHAjP20lKUQeCGYhzYVK4TM+fPnq9X4rVu3KsEPYCUcwuPx48dV1iS4wmDFffPmzSb7Q0Bv0KCBsljAnUaLxQhNv61th1D/+++/S/v27dV5Nb9/COKw7lhyR9LOC+EXrjvdunVTrlFhRRtP/AtBG/3BtWoKlCbk43wQ3s0ZOnSosuTA6oHVfKz8hwetP7C6IJ5h4sSJ6noHDhyoFDsAIR7nhDVCL5/17NlTuXT17dtXKSS471AWcP9sBcoRzt2yZUs1J3BcKAxQkBBHovUHFhRYuqBwYC7Nnj1bKWdwr4roOAsqFi4M8mKbQ8WCEEIICQJCOtxIIEjDRQTC6JAhQ5Swt2nTJuUiAsEwpPbw0x89erSKy3j69Klqh1gArCqjDoIlEiVKpFaUNSAkA8QzIGgXbkcQ7KtWraq29+/fXwnpEN4hgOLz3LlzTQoEA8QFQMiHQgCXpTJlysi2bdtC1W9r2/EZ8QfoG2JAkIoVFhZrMRbm4wU3KpzXfFygtOA6UNTX3DVIj/l+uH64bUGIR+para/YDqEa7j/mYEzGjRunZCG4MEHgh3Cur1WhreBDYId7kTX0+6HfUJz69Omj5g3GBy5XANuglCFeQw/GMlOmTGp8oFDAOgGrgnZP4VqlLRDDwqKfLyj0DGsPvsd5YGHDvIBrGSxbGBP0R5vHcO9CLAjGGMod5g+UWLj9RbQXi5tBH9pPLAJzFfwXceNDmmSRBbRJaJkwF4YmxzFMXlhZwMSDkoF/od2bF6VxdcI6foTjxznoGPAZdr3xgwAEdxsIVqGtgxBRQOCzVE/BHIhJEESxugvB7FPtHQ1brzMyz6uNIeSQT1lxoBSYZ22CIgZB3hZgCejcuXMwWad+/foW61V8Clg2NKVFr+TgZY3Dhw+r+QLlBa5NUGbCk0AnNOOngYBvWFHQd1jgYMFCvExYns3QyMG0WLgwUCZsDQwjhBBCohMhWRSstXfGhbnQXqe9zwv3M8SI6ClXrpxFC4QlYFmxhLllwlZg4dmyZYvJNrge6WMhzIkbN64xdmLSpEliD+DyBhcxKASw1GiZxiIbWixc2GJBOH6cf44Bn2GOH+ef41ksInO1mHAMnXUO0mJBQqy8Dd9QTES8kBVASw9HCCGEEEJIREJXKBcG2QBQhEYDWQGoWBBCCCGEkMiAfjUuDCtvE0IIIYSQqIKKhQtDxYIQQghxbpDhEX/PI7reQFTEBXyqz7i2yD5HaM8d3j5Fd6hYuDDmbk/IaxyewjSEEEIIiRg+JcCiGB4qLqPWAl5dunRxqqHfsWOHNG3aNMQ2qGGBYnaReQ5roC6Epdpe4e1TdIeKhQuDAjfIua2vRqkv9EMIIYQQ+4D0p8jAYw2ki0fhMwi/KH7miqBom1ahOrr06c6dO6qmBipkIx0vijAi86erQMXCxTEvyEITHyGEEGIKhHetXjBca/S1g7W/m/rt5i44IdUatvR3V9sX31n7HkXismXLFszVR99e64el/nzKRUjvXhXZsoH5mGrYet7wuIKF9to+1d58/PUYDIYQ5wKu4+uvv1Y1LlCxHEoMiv/Vq1fPuF9E3gt9f6zNtYiGikU0KJKnx5LZjxBCCIluYJW4du3aqmgaamkMGzZMbYfL0eLFi43tIATCstCvXz9VFC137txSp04dVXSsW7duyqXmzz//VFkYc+bMqY6F6s7Xr19X++N77IsV6uzZs8vZs2elV69ecuPGDVUjy1JFaRwXheJKlSoljRo1MvkuTZo0xvco3AZXINTb+uyzz+TYsWPi7++vCspt2rQp2HHxHYRY9BGvVq1aGfuIPkHIzZUrl6ocDaxdk7XtKMiGIoJw4frf//5nPC/OM3369GD9yZEjh7x69cri/bHWV2vnsIa1a9OK6envy6f6pB0PVcVhbVi9erX88ccf6j7i2G3atJEhQ4ZY3XfPnj1KuEeWTvQHxxgzZoyaCydPnpTnz5+r86NCdrx48aRy5cqyceNGSZ8+vbrmf//91yTzJ8YgTpw4aj5qfe7Ro4equWbeH/QRLnU458iRIyWyYLpZFwcP5ePHj5XlAkoGJiEhhBDiUEwpK/IqEtxB4iUXabPD4le//vqrUhrgZmSr6wtWmHft2iVJkiRR7ixPnz6Vc+fOiZ+fn6oVtXTpUiXQLVy4UAl4+BekTJlSHjx4IGPHjlUvuDnhvDgehGasKmuryfhbPWLECBUTCQEWx120aFGI/YLQiHM1aNBAChQoINWqVZMqVaoEO+6lS5fUC/2GQKoHRXjRR1Rsbtu2rWzevFk6duwY7JpQSdrS9nHjxsnvv/+ulB0oS61btzYWc4NSEdqFTUt9hTxj7RwhYX5tmnJh6b7YAoT8+/fvq+OsXLlSzpw5o4T2WrVqSebMma3uB3d0KA56cF9gmcJ3UFrw74wZM9QLiu+ECRPk1KlTSvHB9X777bdKgcSYYi7i2qC4QkEpX768UnYwr9Af7K/1R1M8YAmrXr26Ulj17vIRBRULF2f48OGRclwtViNGjBjqhR81/EsIIYSEGigVPnejdOCwQgzh2FypMBdU9S44UCagVGg0adJECb0Q+q5evaqUAA0I+BrNmzdXfyPLli0ru3fvDtYXCIN169ZV77Eqrb3/FPq+wYJQvHhxZU2AUGrtuLC0VK1aVa1q//LLL/Lll1+q75s1ayYxY8ZUgmv79u3l8uXLFq/J2nZsy58/v3oBrLprilVYgGXIvK+QNcJyDvNrs/W+WKNly5ZqwRb3HQpc2rRp1fZatWqF6AoFxQGKKNpo8wwK18WLFyVjxozqM/794osv1HuMMawVuO4iRYooxQqcOHFCKRdQjDUwFlAUYOVInTq12lajRg01R168eKFiObZu3aqUYGyDK1ZkKBZ0hSJhAuZZPCCYvNDcsXpACCGEhNmyED91xL9wXCsUKlRIrVI/efLEJMYCq9jbt29XK7xwtUGwrbW4Re0zBDy40+zfv19lFILr1KFDh4zt3N0/ilvaeaCQ3L59W1kUatasqfqA16eUCgjZcKnBSv6cOXOM27FyDpcaCM6wKADz4+Lc2op/9+7d1eq9xrRp08THx0fmzp2rrAHWrimk7VhZxyo++objfCrGIiQs9TWs5zC/tpDuiy1o9x3ZN9evX6+UKtzL5cuXG9tYimeA7KRl+Lp3756aW3Cvw3Xly5cvWJ8sfQYFCxZUigaUlDdv3qh7MHv2bJXRSusPjg0LDcAYvn37Vq5du6aUGChtkeUaT4uFC4OVGEwkPAB4wQ8yorRTPEB69D+8hBBCSKiw4q4UmQwdOlQJdXBDQYwC/O1/++03adGihfJZx8oxVrrxL1aXIeDphTy4sGirzgkTJlQuKzgeVrF9fX3VqvaUKVPU31+tHf7VYh/xfdGiRZWioMUo6NEfH+fV9kM/4fIEH3yswMODAAIm3GHgvoSYAaxeQ5j+8ccfTY65c+dOqVixojoeFgYRe6ABARUCLuQExDGEdE3WtsOFC2MH6wCsDXC7AYiPgCCsV2SAfmzMsdRXXJu1cyDWpFKlSsoKYY75tZmfW39fQuqT+fe4fxhrWIrQx5IlSxrbIeYF90Bv2cE51q1bJ127dpXChQura/vqq69k2bJlxn7olVe018857TsoFu3atVOKI5QFKAmIm4BVB3NC6w+UZ8wvxNwgUygUwhIlShjndGTgZgitCmln4Df2zz//KJ84aHfQzPFwWQMTHr6Je/fuNQrXGHRLGqA18IMDMxRMSbhBUQ20cASZwY8uNP3WfPU0MJlhUowIzCckzH9YLXFEwjp+hOPHOegY8Bl2vfHDCisEokyZMqkYA0cGYhIEt08JnM4MXHmg3JhbZKJqDLG6by6O6hUrW4ASgoD32LFjR8i1haVP48ePV5YuKFBwPYJbWlTPQa3feL7gugeZGQpQeJ7N0MjBjvELYyNHjx5VGiDMX2XKlFEr8vgXyoO1H1OYe2DSxH5YlUCmBc0c6Oogo4KeyPrBANFhPAkhhBBXxN5KE9yTtOxP2gsuPaEB7j7mSkV4ri0sfXL/YNWCtSeilIrQghgLjAPiRmDZCo1SEe1coZB1AOacmTNnqs/QxJDlCJ/NzWsAEwmmNH1qtmLFiilT1ZEjR0zMU66Iuf9cRCoWmLj//fefxSA1QgghhDgPllyxXOX8YT12WPZr166d2Bt7x7w6jcUCVglEs0OZ0EBmBpi+4OJjCSgWeqUCaJH7z549E1dHy5qgMWDAAOUSFlpgQkfQkx4EbCP3N/wdEegGExkhhBBCCIm+OI3FArECWIFH2i09+Lxjh+1BX8izDBMVLBchKTF69yr4lmmuVWGt/BgeLFXVtAVYFBDItG3bNvUZihliIRDUYys///yzKsICJWLBggWqYiTQZ6LQ99MRCev4EY4f56BjwGfY9cZP69OnKhU7CvqK24Rj6Mpz0PDhmdTLvKH57XAaxUIT9M0LuiBwG4EmtoAczsgmgJzHIQWfDBo0SPr27Rts+6NHj2w+V0Si5SDGjQ5t4J15ujNYamCBsAXkqoZSAWCx6Ny5s1O6j4Vn/AjHj3PQ/vAZdr3xQwwg+qWlQnVk9EXmXDV4O7LhGDrP+OF5xLOJNMxafTJzrxWXUCw0VxtzFyZcOCwQn2LVqlWqkA1SpCE92adiOZBjWG+xQCwH3H/slRUKEwnnD+0fBfNAJnxGZhCAqH8UW0Fgu6Xjwrpjrmho+zoT4Rk/wvHjHLQ/fIZdb/ywSAdhRUuH7gywCCzHMDrMQU9PT/U7gXADLStUaDK3OcfT/CE2IlGiRKpSpuaOA/DZPJbAHFSeRIrZUaNGWQzyNgfFS/AyxzyHdVRiKYe2LaB6I5QhpEjDZEHxFBwDKXiR8xmrRsihjDgVcy3YPCAbyp2j/FGKqvEjHD/OQceAz7BrjR/6gT5pL3vRv39/VQQPNS3Kly9vsY2+SrIzWCyw4Iog4sWLF4f5GKi/gEVbfVyrLaCmBIrambtLYxETdS/gORKWMcQxGzZsqOo3hIZdu3Ypd/C//vrLZPuBAwfUfR84cKA4A4YonIPaM6n/vQjN74bTKBa4SOQEnj59ulIOMOERW4Fqj4MHDza2mzx5sqoqiEIhAOm+kG4Lnx0hWj+q6dmzp8XtGEMtHe2GDRvUWCLjlp6kSZOqh1iLOYHVRlv9glsYFBVoz/gXlhBn+MElhBBCtLpYSFsPuQLp6CMbuCHDpXj+/PkR0s4aWAREsbzwcP/+/TC5qPn5+SkZzFKfevfuHeb+IEMT6kOEFrgA6ut5aWCRNaIKBlvjwoULMmTIEDUeiAfu1KlTlKd+tQdOo1gAaJaoZZErVy71gsYJwblChQrGNijzjjLzmgtTvXr11Io9Apfx0oDmjIxS0RU8bHpOnz4dTLHAuB47dsziaggyQelBwUJndJMihBASPbly5YpK5BJVsYMQuiFsRlQ7a2CxL0eOHOJIOFqfEJ8bUnHl8HLp0iVV2gCV3FGV/NSpU1KtWjVZvny5qr/myjiVYgEFYffu3cpKAUE2b968qjKgHigMcHvSfMLmzZtntfCJKwNrxIoVK4z+q7AsQHHQYi6grZ85c8bEOmErllYx8BBRsSCEEOIsSkWHDh1UnMfBgweVywzcPbDSv2fPHmWh79OnjxKGhw0bpv5mam7Y+HflypUyY8YMZcHHYiZSr48ePdp4fKyu//rrr2oxFIoCVuuXLVsmZ8+eVZ4AcEHGubCCDWt/6tSppXv37sp9GW4/+nbwykCWR8Q9YsEU2R21ONCaNWsqN2+9TPMpVyhLfatTp47Mnj1bZs2aJZkzZ1b+9SHJBZrLE8YFrtTINqm3ksBLBLGtRYoUUW5mKGysuUKFdDy4YEN2gZsSPFDgUQEB3TwRjTm4f2iLazt+/LjJGEEewvViMRqLzbAcfMoVCsfbuHGjigXCvViyZIlayMaxcQzUSEMNNWTMtMTQoUPV/MI9BaVKlZKYMWMq1zvcS+wL9zAoHLCoYDvmJFzQINuOGTNGueSj78OHD1d9iRs3rooBLl26tLpO9OfEiRMm/dHcvnAujOXff/+tYquiEqdSLAAewJBMSQhE1sDAhtY/0FV48+aNUcHSuHXrlrGOh3lQ99u3b8Nc0Rsgi5a+YB4hhBBiK9+u+VYev30c4QOWNHZSWVw9uICNGle//PKLqu30xx9/qIyTEETv3Lmj3FegLECBwKIZtkHw14CgCYUC7kIQlCHYZ8+e3eT4yD4JAR8JY7CwB1cYLL7BCwDCO2JGsR3vAYTLNm3aKMEVAri+HTwK4BoFYRVu4BCG8bcciWjQV/N6XfgbHZLFw1Lf4O0BgXTSpElq8RBCsTVXagCFBLGa6BOEV7wgAMNlHdeAZDnIsNmtWzcV5wq5zZKLlPnxYD0aO3asUtygmOD4SDQzfvx46dixY4heGMhiiReUCowXlC3El0LxwbXifsJ6UKNGDaVQ3rhxw6bjNW/eXClft2/fVtcJ13H0LSRl59y5c8oNXw+UCy3WA4vjc+fOVXMH8wiKXYsWLZQSC4UWY9GsWTN1r5E4B/+iHfqPxXW0uXfvnhpjLLhr/YHSgXmDewhFC8oaXP2iEqdTLEjYrQr6zBuYlFj5gIKBV758+cJ1bOb2JoQQElagVDx8Y1sq9IgAHg3weIAArgUEQ2BEzEXWrFmVEIgVYEv++XpatWolVapUUQIiVvy1ysdwtYYAj8K0sEKgXYYMGdTfW+18mjANCwlWoKHAQIg2bwdBG4oAFCDw/PlztQ8UC7iFhxZLfYNw+sMPPxitMrYU04U1B6v/2uLin3/+qRSL3LlzS/v27dV2rKZjJd6W2AJcC5Q9AIEebkRly5ZVL9yXTwHrTqNGjdR7KBawOsBTo2rVqsZsoAjQR39sCUbGfggYBxgf3F9cM+bG1KlTQ9w3WbJkSvDXg896zw4oDpUrV1bvodRCSYCcpo0ZwIItrD0YT8hZUEjgbYL7jwB59AcWHSiEAN9DGYMyAmuLPZI1ULGIpooFfP1sARNZyzOOVRCY/fCjhwcek1cDqwKEEEJIWC0L9j4urBL79u1TigUs/BAEISDCSoDgYQCBTy8watZ/eAhoWaUQqAxXIsR1QiiECxNW7uHuoi++C6UCrjBwdYLlAEIxhEG4VenbwToBYR11uLQkKaFxXzYHrk7mfUNM5ebNm41F0bAqnjFjxhCPA6ULY4EgaLgWaVYdeItoQLC1NQhc70mhHRNCNqwLetdtayBLKLwvcBy4t+E+WuoPrs8Wgdu8P7BiQZCH8gcBPiS++eYb5RoGJQ73D6USYK3Qe5Lo+6VPu6z1EWBfuLtBecU4og0SDWjjg/7A8gJrBujatauah1CsYG0LbxB/WKBi4aLgxwc/RDDZasBkih8PaOG2gIlqnjUBPoH4wcQPCCY/fgzxcJi7VhFCCCG2YsldKaqB4A83GvyLzEwQyuDXDmEQK/uI2YSwDfckc/A3Ue8uBV95uO9AQET8AAR4KClwV8HKPM6D1X2sVMO9BRYUzV/fvB3cb9asWaOES/xNxt939E0TOs1jLD6Fpb7VrVtXrcLjmPh7rs+SBdch+PxDIdGDJC7oH4RmKEJQTCIKuGLB2oDYBrippUiRwmjlQcC9pcQyUMhg5dGUM1gAYLWICOAKBYsIXJLQF60/kLHwHfqpp1GjRsoahnuIcYICBpcqfY00W8A11K5dW/755x8VbI57D6UJSgpkOVid0Bet5gSsO5gviP+BDGgXDOSTvHjxAvXT1b/2ICAgwHDv3j31b2hp166d6rv2wmdb2bJli8m+eN2/f199FxgYaHAWwjN+hOPHOWh/+Ay73vi9ffvWcPbsWfWvvXj+/Lnh1q1bJtv8/PwMFy9eNPl7j793z549M1y9elV9PnPmjNqGMX38+LHFY+Nv5bFjxwynTp0yvHz50rjd19dXXff169fVZx8fH8Ply5fVvcHx37x5Y7EdePr0qeHkyZPquE+ePFHbLI2hv7+/4fz581av21rfcE3Xrl1TfUAbXBvOWbJkyWBzB+2KFSumtl+5ckX1V+s3xk/j4cOH6oVxxfmsyQ7m+4H379+rY+N6MA6vXr0y7N2719C8efNg+69evdrQsmVLdR7so/UX9/HmzZvGdniPa8a437hxw+oYme8H3r17p+4RriFPnjxqTkydOtUwfPhwq8fx/XBd2n3VePDggRoXjdOnTxvf495ibmngfLj+gwcPGo4ePWocQ60/2DdbtmzG9nfu3DE+7+fOnTNExLMZGjmYFgsXx9xFCaY0aPwwlenrUEC71a+2AEs5tLXAbdasIIQQ4szAZQkvPfibaKmmBSwXWlttJdg87boe/aq2Hlj49XER+rSn+iyX5u0ALCXm1hJLMRZaaldYI/QFhTWwim+p0Bz+rmvuT5oXwuvXr1VgsDXXIWzXWzLQb/34aRmJ4Fat9cmSKzb6ZD7ukF+0Y8MFGyBIHhYWa+D+6fuDbKJ4aWj1uADGHef9+eefTY6B+4YsTPr9ALI0mWcixfhaus/WxkPDPIsmsmtpwNpifl8QYA8ZDfcWn+GaB0sGZDLE5sAKpaGX5XLmzClRDRULF0cfV6FXLMwDs7DNHM3H71MZoQghhBDiWCAOQ8s6pQeuRbYChQovcyC8IqtRVPcJLj+WgKsa0quGFuxj3h997IM1kDoYrmuIv7EHqVKlUv2GIgVlJzT3NLKhYuHiYGUFfnhaYFChQoU+GdhtDaTu1Wv7hBBCCHFMICBbskxE1LHDUq08svpkbpkIzX5h6Y+9i/15eXlF2r0NL1QsXJwff/xRvfQ8evQoWDukjDNP5wbzHn44EJSFYCikpIUCAsUE2zRlhRmhCCGEhAWmKifEtZ7JUCsWKNSCFF6IPjcHuZVRZKVSpUrh6hSJXGDWhB+llj5Pu3fmIAUeXuagsqOWexmgOA8KxxBCCCG2ABcO+IpjoQt++I4ct6elXdf82wnH0FXnoMFgUM8kzoFnNEoUCwS0IPXaggULTPzZUFimadOmqtoiFQv7g/zUyMetBWjDbIaiLgC+eChCE9q0Z9biLBA4hPzR+fPnj5C+E0IIcW1g6UZqUyxK6Re5HBEIW1rtAyoWHENXn4Nubm7q2QyrN0qoFQuUnEehEuQRRq5cVANEFWeUcoc7jVaunNgX5FauXr268TMCjJBrWsM80AdFZWzFUowGLBhagRZCCCHkUyArD9xtHT0pCAQ6VL5G4LA9Khm7AhxD5xk/LEaHx8XdMyw/BEhNioDg1q1bq+IcEFJhyUDxNeIYmAv/5iYtZFCYMmWKSimHV0hp88yx9EfA0f8wEEIIcTwgwDh6nB6EOvwNhQs4FQuOIedgJAVvv3jxQqUo1QRTLQ8zcQzMBX3zrE/IfW0p/3VIaOlnoVQuXLhQVZYMKV0tIYQQQgiJPriHxXe/Xr160rlzZ1USHv6RKHNeunRpZb1AGXpif5DSTSsoA1BOfuTIkfLvv/+G6jgoRoP4DKzSYFVp06ZNykKFAH69Px5XcQghhBBCojehVizgBgVl4vjx49KiRQtlGkQVRFRmhKLRv3//yOkpCRVly5ZVAXFjx441buvatatMnjzZ5mMg+9OlS5eUNUJLP6ZZQlAPA3EZcLmCJQMWLEIIIYQQEn0JtWJRq1Yt2bNnj2TJksVkO9xjTp06JUWKFInI/pFIqLyN4Psvv/xSlaLH/UQmL0v88MMPwbZpigWsF1Aqw+obiwxVKFuP6p2oGrly5cowHYcQQgghhDhpjEVIlRaRi7patWrh7RMJA1N2XJFVx+9Kr+q5pUSWJFYVC7iqwZ1t8+bNxm0Q8C2BIniRFaSNuhn6LFWM0SCEEEIIiWaKxZo1a2TevHlWv69Ro4Y0btw4vP0iocD3fYCM+O+i+AUEypSdV0wUC1gEkAFKq5KdO3fuTwZ2a6Dath64UcEyFRGYHxtxHIQQQgghJBopFggKNs8A9fr1a1UgD98hsJtELW98A5RSAV68NVUaYEEytyIhNbCehw8fSp48eWT//v0SP3584/ZUqVIpdycoAbBeIK4C3yOmAgHb4SnSYq5YWKrkTgghhBBCXFixQCE0vMzx8fGRkiVLqhVxErW89f+Yieudf5CCERI5cuSQHj16yKBBg0wK6r1588ZEsUAshiWGDRsmv//+u4qvQG5vKC5Lly4NVZ9Xr14tr169UgoLlAwoLQBB4ii4iEQAyDw1f/58kwxUhBBCCCHExepYmAOBtHbt2vLff/+p1W9iH8XC98P7O3fuqIxOmgsUKm/nzJlTfZcxY0bp2bOniWIRmurbmisV4jXwunDhgpw/f14yZ86srFa2ULhwYYvbT548Kf369VPvDx48qJSMkFzvCCGEEEKIiykW4ObNm6rGAYl8Dhw4oKwFEORvvvxopfB9H/Qe6X/bt29v3I44C7irheR6ZKtiYV7V+/Tp06rY3uXLl4NlC7PGzJkzVQA5grbxQoaqNm3aqFooemCxoGJBCCGEEOKCisXevXuVVUIPVq2Ranb9+vVy6NChiOwfsQDchUqUKGGsLeGVJqek/H64ev/ug8XCXPg3D9DGZxTMg4KhVU9HoLctWMsMFZrMTrBGLFiwwPg5bdq06l/0gxBCCCGERAPFAlYJfapSdRBPT0mfPr1s3bpV8ufPL5HJxIkTZcyYMfLgwQPJly+fjBgxQooWLRrh+zgyUOQ0pQK4eX7MqGSrYgFQPT0sdOrUSWX+Mnd5C00qWvMsUJpS8tNPP0nSpElV7AW2ocYFIYQQQghxQcWiYcOG6mUP5syZI126dFGuMVixHzp0qCr0hsDjNGnSRNg+jo65ZcAthk6x+OAKBcEdAvrjx4/VZ1iZpkyZoiwUzZo1s/lczZs3l//9739KaYCy8tdff6nAb9QswTn0tS5Co1iYx2Jox8E9wosQQgghhLh45W17MmTIEGnZsqXUr19fKQWjRo2SuHHjKotERO7j6ECAxzVYslgEBBrkfUCgiq949OiRidta27ZtlVJgC8jYtG3bNtm0aZMqZIfPWtpZDQSIv3jxQmWTQp+sBWRbonz58iqzFBSVgQMHSoMGDWzelxBCCCGEOKnFYtGiRSr9py00atTIJGg4ooBwCytD3759jdvc3d2VgLpnz54I28fRGDS/hVx/fUl8A9/K2KZbxTtOAkmQIIG8fPlS1RNBwHWQxSJA3GI8E4N/UmW1iOfhbtEFClYHFDmcNm2aCv7GK2/evCpLlJ4rV65IhQoVgvVHb5VIkuRjIb7QcPXqVWU1gfUEVg/827Vr1zAdixBCCCGEOJFigfiJSpUq2XTAbNmySWRw79499W/y5MlNtuPzkSNHImwfgFV5/co8hHiAwnB4RRVPnjyRcy9PyrE4Qa5PGzatlPo1mhi/Ryamo0ePiptnTImdfpp4xr0mvg+/kje+FSRODHejImWuWCANLbJGaVSsWFFZD/TACmHNDSu8YwDrB6wpeqAARdbY4riISYnKe+dKcPw4hvaGc5Djx/nn3PAZdu7xC815bY6xQPE7FMZ7+vSpCh6Gj709MBeU8VkfyBwR+6C+g97KoQFh2LxidGSycuVK8Xv9XuRDBt8ZsyfKF8WqGL9HPQooFh5xY4hn3Ctqm0e883L3/iMJ9I5pVCQKFCigitnhhXojsOSYTxhU39Zz//79YP1B1q8UKVIEaxtaNIVPA1YLc0UjIsH1wWUL99x8LhCOX1TAOcjxsyecfxw/e8M56NzjhyLYEapY7N+/X/nTQ7GYMWOGEjqHDw9KbxpVQKAF5gIohFztu4jYByAOAQHfeotFunTplDLl7e0tUQWCrwODYq8Vcb09TKwviGlAbYrU2dKLQYIUCzc3f4mXIKEkTxZPfUb7rfu2SvwY8cXD3UNtGzx4sMl5EEtRq1YtadeunTRpEmQRSZw4sbpeLa4Cbk+WKq6HBfNaJ3CF0q4L55o7d66xIjdcvTp27GhSETwsD6Sbm5u6HioWHD97wDnI8bMnnH8cP3vDOejc42ep9lm4FAsEPS9ZskQVQIPWAjcZSyvaAEHF4RECrQHBFm5WEKTr1KmjtkFzw2fEdUTUPtoKunk6VICbGZU3FDfS781H81PsuKbWl+7du8sff/wh3f+3QdY92/ahk/7iG/BRo91xa4d02tZJMiXMJEuqL1HKRdmyZaV///7Sq1cvk7oSNWvWNO6HNnrLBMYNkxpA+Vi2bJkxRqNbt26qL7aClL9ITQzFAS+9Bj5r1iyl4JhnpkJcSXhA36P6/rkSHD+Oob3hHOT4cf45N3yGnXf8QnNOmxQLCJyjR482iZ+YNGmSxbYIwo0sawbqLvz2229So0YNKV68uEodi3SqqNisgToIEJK1GApb9nFUlGKhK4btnTB4kTvwyv+jiQoWi3f+gXLt2jV1nYvvLZb3hvdy6dklufz8suRInENKlSqlXqiYvXjxYpsqb2tKBYBiibZa+xs3bsitW7ckUaJEKqD8UyRMmFAF0Fti165dYa4ITgghhBBC7IdNigWqIaPi9t27d1W6VgQVW8viA/edyAJKA+IDYG1AHxC8jAxHmTNnNslapA+8tmUfRwUB8xff15FJD1aoz+nSB43t69evleIAawHqQTx99eTjTrBYvA+QocOHyuTJkyVd+3SSoEjQav8r/1cmxzevcm2rAG9efA9KJl6zZ8+Wpk2b2nSM/7d3HvBNVW0Yf5J0D/YG2XsKIkuQJSAyZcgQRJagMlREP0GGCg5EpoooylCQKSpTBAFFtoBskL1naWlLZ5Lv95z0pjdpumhpSfv++V3a3Jx7c+/JSXqe8y7GhrCuhlYIj65QFK+uAoQyMq5FEARBEARBuD9SHLzNFWu6RPXt21dNQJmiNDNgWlRunIC6Ms1wMu08OU3umIeZfLkKA9dtv0fF2rJT7d27F02aNLG3KTm8NwJq2n43GKIRFWOxp4U1esXfb3hMuMO5WTuicuXKSmDQOpLSqumJFcJzLtyXFLRyfP311/bHZcuWVcJCLwo19DU7BEEQBEEQhCxSebtKlSp4GEhMIDjXbUjJMQ8zBfMWs/8eaw5zOYE36WNqjDGIiI61WxUMXoZEhcUzzzyjttQyffp0jB8/XmUKY4aw+6m87RzDot1Tq1atVHASH1NkdOvWTYkOQRAEQRAEIYsJCyFjyRFY2P57DCJcCgujd3zqXIPBinsxUUpg0RJh8vG0P7fpr024vvU6nn/+eeVGlRK++OILlUWKQoXCgRP/hQsX2gO8GYR9PxYLunDp0Y5ldXBBEARBEATB/RBh8ZAT4B2fDSnWEA2zxZogxsFsdHQfCo2+pyprc2uw4GmEWi+r/QtWLMXNXz9TGbKSy7J06dIlFVPD2Br+rsE8yho//vijslho2aGc08gmRYkSJTB06FAlMLgxoFsQBEEQBEFwX0RYPOQEeMZnWTIbY3A7LFLVnGC8CCf1zH7V649JDsfcDg22/x5tiQLivKE8ctnSAH/55Zc4cuSIEgO0bNAK0aVLF4dzfPvtt8rdyRm9u5NzRfOUMnPmTJUEgHEd3BikzsxdgiAIgiAIQjYSFpyUXr9+3WVlaiF9oWXi4umL9sf3TMC1G9dRIEdJFUxPUfDoo4/CuM3RgnHpus1CQcyId08y+dncn1jH47fffrPvZ5pYZ2HhKohau6a0woKFzGqlITEUgiAIgiAI7k+qo5np7sKaBcKDJzg4GHVr1rU/DjcYceW8rcK2Pgja6BUfQE2u3oovXmhBvEDIUSAXateu7RBwTVzFWzineC1evDi2bNmiArfTivO5U1PRURAEQRAEQcgiFovWrVtj4sSJOHbsmKoJITw4VOYkK+AZa0WMhwGhRiPCg64maGf0dLQiePrbAqNZ0dqis1hUqFYBP703W6WZ1fPhhx9i586dKFSokD0wmxm0OOGn5YLnYfYoBmunB87WEGdhQQFz7tw5e2VuZp+qU6dOury2IAiCIAiC8JAICwbzcsWbNQ9q1aqlUoPq6dSpE/r165ee15ht0TIneUTbhEW40YDokBsJ2hlMjhP1HPlsgdAxlhjAEJ8x6l6sLd0sg7fpfvTTTz/h5MmTah+zO5UsWdLeltXTuVFU0P1JXxvk8ccfVxN/LUaD9SiefvrpFN8Xq54zrkITDmXKlLE/9/7772PcuHEJhI8IC0EQBEEQhCwmLJi9p3379ok+/yArb2c3OHFnLIUh2gr4QVksLKG6KttxVgkYHStmR8ZG4syZM7gd7tg2Ivae+tmzZ0/1s3nz5mjRokWSlbf5+s6uUqxgfuvWLfvjoKAgtbFdYKAtQDwpWJSPW2KB3c6ktCK4IAiCIAiC4EbComnTpmoTHjx0R6J1qMeyNjgScRERRiO8LXfVJJ5pX2nRsBpMgCkygbB44YUXsOvoLlScWtG+P8piExYarHNxPxN45wBu1sUgAwcOdKimnRS0VIwePVq5RWnF8JgpylXQuHNMhiAIgiAIgpCF0s1yxfrPP/9UNQ4KFy6MJ554AkWKFEnfqxOUxSCnTw7E1caDNeoGZsyYYc/KZQoIQKXP412YSJQ5Uk3+jV6OsfnRTsKCtSTGjBmjBAaD8gMC4lPbJkViFbZTU3mbrlVTpkxx2Mf0ts5F9pixSu8qJQiCIAiCIGQhYTFv3jwMHz5crXAXLFhQpQ/l6vqECRPwxhtvpP9VZnMCfHLbf7fEBjlMvj1yOFodHISFt6OwMGvqJI5ixYqpmIbUsnLlSvXejxw5UtXRSI/K2+q6o6KU9YMWCs2SQRGlj/0QBEEQBEEQsoiwoO8+g28//fRTDB48WE0Q6a6zaNEi5QrTsGFDCbRNZwJ844WF0RqCKN0E3hTonaA9i+LRImD0c5y8M/Xs0qVLVWxF3rx5U/Ta27Ztw4ABA5RQoUWCwfp79+5Vz7Vp08ZBWKTGYmEymZQ1RsWIaNcdHa0K8wmCIAiCIAjZQFhs3LgR7dq1w7Bhwxwmib1791YpS1l4TTL4PDiLhZcxDKE6w4ApMOHK/53QIOzbtw/rT23FyL+HxD9hsKLHCz3w95a/kxUWzBZFMXH06FGcOHHCZbzD0KFD0atXLyUuGbjt7++f4nuiqKBgoaWLaXV5jpSKHUEQBEEQBCELCAtaJ1R9BRdwf3pUZhYcCfCMj33wMN7DK2+OwrSP31cr/D8c3IjZZx2roN+LClU/70Y7xlQQo68RY8eORalSpezpYhnozdTBerp164YDBw4kOF7//jIDmHMWMFo4KC61uA3GR1CI6unQoYOqvM36FdyYXpZWFEEQBEEQBCEbCQsWSWMcxc8//4yOHTva97MOwpw5c/Drr7+m9zVmaxgcHx5kqz+hMEUhKDQCfsXzqIm72TO+voSG1WCrrB0alVBYmAJ98Pvvvzvsq1+/fgJh4So7U0rcnf7++28Va6PBwnrOwoIWEL0VhBXGBUEQBEEQhGwmLFh/gBmJnnvuObVaXbRoUVy/fh2XL19WgqNJkyYP5kqzKZyUnws4h2IDiqnHYUYjom9fA1BUPb4bbbNO6LEabVaFUBcWi1JVKuH4xT0O+5zrVLhK8dq/f39V/DAxa1ViKWudU9q6Ondy5xQEQRAEQRCyaFaot956C507d8b69evt6WabNWuGqlWrpv8VZnMYe2CJiLdKhBkN8A66an/sSlgYPW0B0WHRCetSjP/0I4w6+ZIKwtegK9SCBQuUKPjss8/U+0iXNz0Uki1btkz2eu9HWNAdSg/HFON1tMrcLLpH1yxBEARBEAQhCwmLQ4cOqckjA7RfffXVRJ8T0geu5ptvxU/yabEw3L1hfxzqSlh42IRIeLTOhSqO2/fu4sUXX1QpgunW9NVXXyE8PBy//PKLev7GDdu5z58/rzJL0SWKG92uyL1791ChQgUVm8GN1g66VtFyRapVq6ZECMcBNz525ptvvkFoaKg6L4VDpUqV1P6rV6+q62E6W44lvZVMhIUgCIIgCEIWExYMzL127ZpL8cDn6BYlwiKdLRaReouFEf6h1+2Pw2PDEhxjQbQKjr4ZEuRSWLAonsbatWtx4cIFlxYHZmyixUFvdaAYoUXB4fUsFhVIzsBuZonipof7mQWK2cOIc8yFBs/rqq6GVN4WBEEQBEHIwpW3XcE4C9Y5ENKPNWvW4ELoBXRa08kuLPKH3lAWB1oLwqJCEhxjMUSjRo1HkatPReSs7fhcSGRokq5KtEgkhavg7eLFi9stC0eOHLGLzL/++gvbt2/H7t27sXr16gTxN19//bVyydKK4bESuCtEWAiCIAiCIGQhYfHDDz9g2rRpyiLByeWWLVscnqc7zX///YcdO3Y8iOvM1q5QuWJz2R+HGQywhFxGgQIF1OMy79eDr21eb8dgjEEsDAkqb5OQaEcLB4saBgUF2S0T1atXT/J6kkonrBcd7777rr2QHqHAcBYWjOtgFikNV+5O9erVs9+rIAiCIAiCkAWERfny5dGlSxe1Ck3/eKYR1ZMjRw40atTIpU+9kDb8PeMLz9FikccUQfUAWC0wesdXrrZavGAwRgOGGJhhhNErobAIdRIWI0aMSNW15MqVC+vWrVMCgymH9ZWy9cKCKWydhYUrNy89DNLu2rWrPa4jZ86cWLJkSaquTxAEQRAEQXjIhQXjJri1adMm0wO0aRmh5aRixYoJCrS5gpNUVpBmsDEFkrulN/U2ecPDYEKs1ayERT7DXZj8csIcfgdGb4tdVBitPrAiWokLC4wweBkSnOta0DUVy1CsmC19bXKEhISojF8UEhQO3CgS6PJGVyy9sKA7k0aDBg0wc+ZM+2NasqxWq4q1sN+X0/vAoPA333wzlb0jCIIgCIIguGWMhWaRYMDvxo0b7elm6eZSrlw5PEjo/0+rCd1nSpcujePHj+ODDz5IdDLKiSyrTNOXn1mLePydO3cwa9YsVZPBXeBk3M/DH3dj7qp0s3kpLALy2ISFly1jlNXsA6vVA2B8tCEGh4+dxKubh+K6+aDDuS5dv6jeN2aGSgyKh3PnzqmJf3hEOE57nUZ0cDQizkQ4FM+jVWL//v1KYND6oE8bS2FBCxbb8Hf+1IsKQsFCYchj+Vo1atRIc18dPHgQI0eOxN27d9XG8+otJ4IgCIIgCMJDFLw9Y8YMvP3228onXyuQxwn7O++84zKrT3oxbtw4FRxMiwX97pnRiBYUTly5uRIWnFiyPV21yEcffYTnn38ep0+fRpEiReAu+NuFhVEJi0U/r0PdYn5os7EjaLOwWnwQGx0NDy9bjIXFaEIM4i0IGnSdYppgTsApCGjFee211xyC7hmET8sOyduiAB4Z/AisscCJN48jNthmuSDs00cffdTh/F988QXCwsLU2Ojdu7eqfaEPyma2KtZAoQjhxveHgd1axqi0wkDvDRs2JFlHQxAEQRAEQXgIhMWJEydUgTxaAZhWlClJyapVq9C9e3e0aNFCrVQ/CObPn4+hQ4fag3kZ58GJ7bx581wKC14bg4j19OvXD6NGjcKBAwfcQlgwnoWizcNie6uUKxRCYDb5oGCRgrAYbNYDmH1hibEJCQqL0IhIxFrintNh9LIqy83UqVMRWCsQPsV80O12NwdhoVkkSM56pfmqMHgAAVWLIHjbBZeZoTSmTJniUHyP9TH0woJWBFo57NdjNNrHUHqgCUgNuu0ldb2CIAiCIAhCJgmLzZs3o2PHjqpasx7WJmCGoU2bNj0QYcFVdKZYrVWrlsN+PqZISCms6EySctvSgof1k2GtXgO3jIQWoMmTJ6PU/0rBv6I/YulOZIxF2N0ghEYF2NvRYmGNiU89e/tuMGKstnuwmr0AoxkGg9nuOuWZxxPFXykOg4cBn538DN+V+87uqqSvZeGZP959qeULXfHca/VRsGDBRPvBOV0tLRL6ts6VuWm1oGWJW3oQEBDfJ/o4kVu3bimXPWcRNHz48HR53awM3z++Pxk99rMS0ofSfzL+3Bf5/EofZvcxaEnF66ZaWHDymdgkkC+cmtVnBlRfuXIlyTZPPPGEcmfhqj3JkyePw/N58+a1P5ccLOw3ZMgQZWlJSljQXeq9995LsJ/CJqNrKmir7eZ7uurbBgNCrp3HuavxbzRjLLyN8cHQV27fRKwlEmDyKKsXjBwUpnswetmO8S7qrUQF2XdnH5r+71lE3qyOZqUC0KRunHuTAfAIiBcKMYFm9X5oVbVTIizYX1o1b626trPw0D+v7sVqVQJWE3jcWrVqpTJSJQeDzOkyR4HBLFP8yVTIFKbO0HLi/NqC6881xRnfl/S0LmUnpA+l/2T8uS/y+ZU+zO5jMDTUsQZaugoLBtxylZfuR/Shp288b3TlypWYM2eOCgxOTfE3FlJLCtY6oLDQUpM6T2g5kXVOW+oK1mp4+umnUapUKcyePTvJtowVeeONNxwsFo888ohyF3J2tXnQ5M6dW/10rr5d8846eN1rGt/Q4ovSxcvgTIStKrd/7kBYLsa5AFm8YDIZYMY9WA2RGDBwIK7mu4LzOG8/PKjSJYT7dMFvt+9hYosWql9P3jyNXpt72NvcibmBixcvqvedsRnGRkZ4lPDAkpeWoEyuMnb3NA5+Cgq+V2XKlHGoQ1G3bl3MnTtXPc8sUhw/2vPMNsXAfL6f+v4nW7duVeOO/a9tFBCu3g8G7Dt/IBln44z+tYXEYf9xQYHjX4TF/SF9mDak/6T/MhMZf9KH2X0M+uiS86S7sOBK//Tp09XKP+MdChUqpFbyOYnkhM5VrENiMHsPt5TAiT07k1mo9PBxyZIlkzyWFo2nnnpKrV4z4NvPzy/J9lxFd5WSNr3jAVLzZjpYLIxGNLn1I3at/gkoXFDta4T/YInOCy264drtG7Agzp3L6gUvoycicBsGYxQmT/sC35+YjdkH4wWWwRQD3yJLERLZV90jxdzxUEfrQkjsdbX6zzgbr/xeKF+vPGIQgyl7Z2FWyylKYC5atChB9ic9jGtJLCPVH3/8ocSCK5ggQB+UTcaPH5/g/aBFhVYwWrK4jRkzRo1JBpQ7Q8EoE+WUwfc0M8Z/VkL6UPpPxp/7Ip9f6cPsPAaNqXjN+8oKNWjQILRv315NBLV0s40bN3YI0k1vONFl7AaLsmnxHTTNMKZjwoQJ9nbHjh1TK+as2KwXFRQTLOzmygf/YYbijbErMw/MxPKLy9U+ppwlobo3up71FK7eOYfdOQLVY/91A2GtYfsdsQZ4evuCth6DMRY3w8Jw/Z7NskGsZm8YTFEw+Z2HKf9uXLrTGo/k8cPBaycdriXGcAtR0Tax4lcpPl5hy3/b4dnGU7khsb81lyU+ZtYuvh+cxPMnLQ9ly5ZVz//555/qMS0X3H788cdE+8GVy9K///6rxoReyDBNLoUFfxJmvCKsefLKK6/YhQ8tHX369En5GyEIgiAIgiCkr7BYvHgxbt++rVKWMm1rRvLhhx+iadOmeP3111VdBKY2ZbrbAQMG2Nt89tlnKkD78OHDarJK33yKH7o/7dq1y96ucuXKbpEVioKIVoucPjnt+/5n7o26d24hNmgdYDNYINBixR1d7EvVAox1sAmLOsZzQJQ/9sYZYW7cuYIrYfHWiIgr3eFbbAEMBiu8cu3Gsat3lbA4FXzW8WIMZly5d9t2XWXpQmRzSzP5h8NisgCxjtW36S61ZcsWh8J5wcHB9t8ZR0GrQ1JUrVpV3b/+HBoUs4ybYTA5ocWEQdp6tAKKjM1hwT6OGUEQBEEQBOEhEBZceT506BAyA7q00Af/yy+/VKlnKS5YHM/f399BMGgr2PTj58o0i/p9/vnnDucaMWKEWwgLfR0LjUvGHDhtqYWIk2tQ+DHbvlUenVA2zxXAbLMyBOvqQvhZLfBnxihv2zkeWd4E1woXUcX0jBYTagVURqhfBVyOOA6j9y3su3QJLasUwtV78TEYGjH5/bFixQpMu7Ucd2AbB+xu3zJ5EH70VgIBkDNnTuUqp0GrhYYrd7PWrVvbA7Zp7WC8i7rnS5fUuf/3v/85tKeFShMWdNNyfn26QwmCIAiCIAgPobBo3ry5Sn9KlxctsDgjqV27Nr777rtEn9cH/VJUpCaY3F2EhcEYCaNvIEx+8eLhimcVFC1cBrhkExb/O1cOKGDLlmUxe8DfGp/NKtxgxU1DLL3mUDw2EkuDn8fHAWWxyNP2/IFr/7CncTf2isoqpWf6D7PxZfe3EXnXMROXf5UiSlg414zge6AXFlrqXuIcdM8aKIyBcUWxYsVUUUa6S9EFSi8sWPVdEyrbtm1TVgta1fiTMUCCIAiCIAjCQygsuHLMCRwrMzMDkL6wGuEkr23btul5jQIn7p46YWGKgsFogilHfFXpqLBYnDt5FoiLSy9euw7OwZZxa2tkNVgvnYNHTZu4OGjMi4i4+IxC5lgYYEHtoItYVND2XtYO/gS3vlsFs8kmAqxWIwwGW1aqUK9I3Lx9ExG45vC+PN62Pj4Zt0hZgSJiIrH0yEY0LF5DBWNrliNaL/R1SDiGWBOF44kig5al5GCshCYseIw+1TAriTN4m/UpGOhNEcOsYiyK2LNnTxlHgiAIgiAID5Ow4Cow4xq4MVMPN+eJn5D++Hn4OVgsSIsOz2Bf6F/q9yvnruHklY0o+KxNMIREBQNxusMDXrgdYoZWAWTE+aLIVdhmRQiNKQRrvjyoceeU/fxHvE24em0XUNS22l8tMhqHfW1DxS+fARcjbwHK4hHPLetlJR5mzJiB1b6HcTvgH3z2T05s77UBAd7x105rE1MVM26C25NPPqnc2VITzM7YnkqVKqnUwUwZ68yRI0cc0hhfuHAhxecXBEEQBEEQMkhYdO7cWW1CxsDMSlx5j76rix2IExZRpvgUtIYYEyyRnOzb3IuiEG5/zmT1gDmcx9tiT7wKxvs37Q0qBcO471Hg7hXk/KkTQgzhOOztjVNecX5RAJpGhOGwry3TU80Cl1Dg2reAU+hCuPUSjh4/ipFvv4XKs2srDyqrRwi+3bcGw+t3tbc7ffo0/vrLJoZIarN00SKRHCyMp0fvfiUIgiAIgiA8GCQp/UMOMycxAPnZts86uEKRkKj4SoimWA9YIuPjG6KdhIUxKr7Anlf++N/Nt+NiL3IUQeFAWyR4pNGAD0yV7G1KRMaiQKzNQnHF04R7hng3KG9LXCYqQyyO3zmPnHXLw+gZX8Tw19NrHO7HuXJ5aoqupBTnonkUFm+99ZbKMMXAfm58XbrsuarILQiCIAiCIKSe+6pjIWQcWoCzvkCe5goVFm0TFlarCXly5EKOYiUQBVu6VbMpfnLPitxvt+2M9/e8rR6b/OJTvoafv6EC3lng8Gb+W4CtgDaic9+Ms28A0y8+AxS4COAqgkwmHPSOD7pufu8e1gbY4j+KXvwYz7b1x17d9d+IPYCb4XeQ3z+3S2HhKjMUYRE+xvPwungMCzPWqFEjRX3GFMP6Ct0soEhhwUBvDWadYuV31sdgemJW/WZqWm58nTp16qTotQRBEARBEAQbIizcRFhYIi0JhEWk2WaVsJp98HTzZmhYrTZe//Ml2z5TvMXC1+SD/AHx7kEGY7xlo6RfTkydOtXWrnxulBlV1NbGYLWLlomvjcaoPZ8BsbbaF1t9aRGIhdEKtAyLFxbnPM24lYPn9nSofTF7zzK82+QlWCxWxNR5FK3LjEdj5IAlKhKPPvqovemyZctUBine80svvaTqUujp2rWrXSzQ2tCsWbNE3aX0LlMWi0UVU3QF09/+/vvvqs6JxssvvyzCQhAEQRAEIZWIsHjIsa/oWwBzpBkmHxNgsgmLaGu4LWzC4gMfTxMCveKDpK3GcLvFwdfTB7mVGEjI3ImfouriVer3iNN3YDWXgMGkC8yOyYdHy5VC0WNFcSnO0GE12p6PiciFafuLA61twdG/+/nhiqdtSNF16oaH7fcTJ6YCIQfxSUxe7MBPKj5jr3dXLOs+1uFaWNxQX8TQGQoPDaaRdRYW/fv3V5XYaXWg+xizQXXr1k09l5Sw0KfD1RfVEwRBEARBEFKOCIuHHMYFXLx4UU2AhxwegluRt2AwMsbCCktc5Wur2Rc+nkbk9NFljopLD0s2rv0dI5u0SnBug9UbRXKzgnYcZiAmOCe88tqqaxN/Q2EVk1AmdwnsivegUsTc8cbqJetQ+am6MHqG2UUFef5uBH4O8MFZL08c8PHAn8eXYWWBfEBcmtvjkcvx3d+1ELL7P1XUjq5JSYkKZ2i1YJ/QvenevXtKZDD70/nz59VGWrZs6VC1na/DrFKs/t2pUydVE6VChQqJVusWBEEQBEEQHrCwYNVrTngfe+wx5aPOSdrx48eVC8kHH3xwP6cUEoFuQawN4eHhgUCvwDhhEQkYo6kMVBurxQe+ymLhOhDaGGtwqIOh4W/Mq6qW9+3bF76+vmrbgZu4i3hhUcDnEfWzaoFSwFnH46Ou0XJhRWxwILzyhzk8V6n9SuzeOh1nwWJ7wLCC+WGOq4iuMFix6Ng7qPrzKSz+JwrXwx3dnjRKlCihrovjSw/HGjctxTEFRlICgWltCxQogF69eiV4jXbt2qk4DB7PjWlsBUEQBEEQhAcsLJgu9NNPP8WBAwfU448//hhGo1HtY2VkFs2rX79+ak8rpIAAr4D4Anm6GArGWPh6meDrGV8wT48h1ooAz4RpXfP6FlDCRV/J/NO/VmDBmX32x6VyllQ/HytaLsHxjSrUwyJsReRVK7x0dRI9zAVRv0xNXA57DX8f6K32aaKiQlQ0fKxW/OvjjeueQO3nCmPuM/ewzCMfjvjmQuT5YvDeehax0TGqwrvm7vT1118ryw0zPLH4nV5onDp1SlX8ZrVth/vL65QTNxH0dTTMZrMSy5lVWV4QBEEQBCHbCIs///wTDRo0UCvohJl15s6dq/Zx1ZjPi7B4MOitDkaP+NoM1rgYCx+Ta4tFZEg4zpw4k2B/8RxFEux7qnQdLNA1rVqgrHIj+mPzH7D28ITBFB/4/Uq7njjyzXpcOXMXOarHH1Mxp01YdqhaHeN3FIfB1xaDYY31w+GFXvjujfYYHrQckUZgTYC/2myEAJVDULN8IcxoNxPeBeKLLTKYW4OuTPpJP2t9UPAuXbpUFWykwKDlISWVvO338sorWL16Na5cuaLEBQPaX3vttRQfLwiCIAiCkN1JdR0LZurRAmHpy86JmJaa09PTU03KhAdDoGd8ZifP3NvjnzD74frli/hpyU8uj6tctjxqVK8BS4xjlery+YolaFujcDFYo+NX+h8vUgGHDx/Gpo2bYA6Pj+GA1YDHipTHV199hfF9HSfgXSraYhs8TUZU8bP9brUaUTKsM6a9MxENOoxDCY94oeDMdo9r6L+yPc7Pbw3L0V8Bs2OV71y5cqngbcLK2+XLl1dio169eujQoYMK2N67dy8GDRqkskMxfSytEEnB42kR0cav1LcQBEEQBEF4wBaLxo0bqwDY9957T1VQbt++vd16sW3bNkyYMCG1pxTuw2LhmfOg+mm1GhATWgU7tm3Fj5NHocq3NWDQVeQmRfMXtrWNMQKe8c8d23EYy84sU2lcNYxGA8xXKsNUYhtigqugVqmS9ol9TIgHPOKSS3khP3w8fNRk/nHL45g1/zOAQeWxfri79zSWH7uOKlWqYFqHl9Dvx5zI75cHswY/g2GvDMKMGTNgCMiD6NpPwRh4CqboouidLz8Khm3HF17XEGk0KleptrgE713voPD2d1DcsxT+1/ITPFK4inr9xYsXI3/+/Chbtqw9Ja+9bzw9HTJIEQZ6J0WxYo4iizU0BEEQBEEQhAcoLMqUKaN88rlSXbBgQZUilDDmgsGxjRo1Su0phWQsRIwfYOYjT4uuPkQcUdeehSWiBHw9j9raWzwSCAtfo+04S5QRJp3RYdHsRTie57iDsCB+f1/HpaPtEH54u4O1IOZ2LHxtsdzI51Xcvt9kNKFr6cFYdnwerq0OQb/VfdX+sWPHKgG6bvCL9rZ0lWNMBPH4oxhGfPg53ujXCgUCbW5cYb+vwPfnP8Q9z2jb/RmNOGcEzuE8/ln/HPqZSqJ/s/eUwE0MCg1W1tYX4wsLcwwud6ZoUVv9Do2rV201OwRBEARBEIQHmBWKriZafQANFjpzXiUW0gdOkkn+DvlR8NmC9v2R159BTLDNDY3B28Rq9gA8mY42Hn+7sHA8b0xQDDwLJhQrlptncOP3eLcqZlKqVasW9nqfwkH8qfZVLVDB4ZixjQdg16SVOLz2b/s+ZnNyRj/Zj719CU2Ke9tFBRnSojN8d5TFtN3fIYfHCfh6XUOQZyxiDAaEG42Yab2ADWufR3tjfjxddygKVOlqT2HrnI5W/1pMKtCwYUMVi0HRwJgKWjGYcWvSpEmq4B4zQ1Fg0HpBkSwIgiAIgiCks7Dgajmz8TA1KX3a+XtisE1gYHwsgJA2WEOCrj20WkRejJ8oR91qhpigJ+2PC+XPq4KVzdaEb+mgF/vh4zdfR5+1/bHv5m5HYeHpiTlz5uDEiROIiIhQm5bxS5+O9bnnnsP5u+fR4ee/Ybaa8UKN1gleh8fq8fPTmUfi0E/2HQoA6uhfvwY6VBiPA4ePI+xeBG7dPI6tIYtxIPCOev6Etxc+RQgm//MBqu6cgF4lO6B1k3dh8IwXKP/73/9UUDcFxvr16/Hzzz8rVz2NL7/80v472zE1LbecOXPa4zcEQRAEQRCEdBYWnISNHDkSI0aMUJMu/p4YbMM0oUL6QdceCovQ/aG49M0ltBswHn/eLOPQpsdznfHuq31QZ94ziGB2pTisVhNyxFk88uiqbxtiDGjRuIWqRbJo0SJs3rzZ/ty7776LAQMGqKJ13B55xOb/VCJHCbS+0hpbt23F6/NfV7E1FBxsS1jbhO0pMChGGQPhDOucUJiyHUWGVjOCxetYH4VCg/e7detW5W4Xf8FGNH97GCJK7sJdH1vyAKvBgENewNtXfsGPc3/C6yU6oFbj/wE+OfH666/bD2U6ZAqLxGAGKI1WrVqhSZMmKXtjBEEQBEEQhNQJCxZQe/rpp9WKLle4+XtiSNXi9IcT7fDwcNaiQ/DfwSg5qCr+hOPKPwvkEZPBMZAZFk/4eXkkCP4una80fl5vm2y3adMmgdWJhelccenIJexYs8P+mC5SGgzKTo7Bgwe73M8YCH1K2QRYLdj08TR45CyI4s88hdqNrLjjcQhXvWyF9Q54m9Dn2mo0/HY5ipzxQa4i3TF0xGj1nJbFLCXI+BUEQRAEQXiAwoKFxvTFxpIqPGaxWO7zUoTE2LVrl0qHWrhwYRW38Nf5e1hwxJYVyllYeBi8lQDRsFo88UKvHli2dKm9wB4p5B/v7kN3IT1JpWal25CeTz75BEuWLFEWFW5DhgzBmDFjHNqMHj0a+/btUzENtFYwqJuWDsJEALRuMHVxSogNuY4cx45gyaL9uHA7HDNXf4K90b/ilpctYH1bgA9QHSgd9QOK/HoOHZt/jNatW9tdrg4dOoTZs2crgcP7ZnxFcsKC90wXQLqlCYIgCIIgCOkUvP39998rYcFgWFfPnTt3LsHEUkgbzMTFyT4DiseNG4dpi9cjb+fxDm1YII94Gr0Bs6OwsMTVZtBbLAr6F3SwOrCGQ+XKlVWKWAY5JwbFgzN8z5NK60phtGnTJvtjfY0IFqFLyqLAseZcUVsTQou+mYkpoyfCmKsAqvWtDZ+KFxEal073jLcHxt/ZiR8WNcSQQs3Quc0wFCheTrlF6V2sKlSooDJVsaAeN9bE0EMXqoEDByq3renTp6Nfv36JXqsgCIIgCEJ2JtXCgsGtHTt2VG4rn376qVpBv3PnjloBXrVqFX788ccHc6WCQsU93A1K0BveHrbMSF5OwgJmk73OiF5YFPKLt1gwZiapuBk9fN+bN2+uBAZX8mlxOHLkSJLCw9kiog/+d65BQShuGHPBwnx8fufOnaoqNo/jVq5cOdWOGZ1oIbMEXcP+z1bDs0BxVO1WGwUrn8clX1sKrFNeHngt6E/U/m0ThpbsiFrNxgGe8dmqKBScxQKL5LGCN6+B90vBQSiOXnzxRSVOBEEQBEEQhDQKCxbEY2G8559/XgX8vvnmm8q1hYG6dHepWLFiak8ppAJOdi0Rjlm5fDyNqrAd8TLGZ0YiVrNJHXPmzBnEhsS7MRULTFh1OzF++eUXzJ07VwkJCofatWtj4sSJ6jmmb9ULC76WKzGaUmHx22+/oWVLW7VuDRbh4+YMs2DpiblxAX3LvYmrwRYUttzDZdMKXPGxCYy9Pp7oc20NWs75FcNqvIwS9V4BjI6VyKdMmaICuZmOluKCAubmzZtKPNPFi9YN1hURBEEQBEEQ0qmORd26dbF7925Ur15drfayWNmGDRtcrj4LD0JYhCaIrwgKClLpVMND7gE6beHjFYgnnmig3KmMPkY88vIj8Pf1R4vnW7g8PyfOdPthTIK2Mk/xQHHhikGDBqkYBgb1c3OuYE26dOmi3KxoueBGi4RG/fr11bVz7HDLkydPivuCIpbXyGsuXbq0ykrVqVMnVYti3bp1+GrhKeQrYYa55L+442UTVRv8TNh8cjY6HZyDVxuOQe4qnZnTVz1H4aSvuP3ff/+pn8xyRescx3v//v0TvR6KkNy5c9stRIIgCIIgCNmJ+5oBccLVs2dPFcz61ltvKd/zl19+Wf0MCIgPEH4Q0EWF6VH5kyvWLNSX0okcxRCPpRB69tln4Y6MGjVKpXftvuIqos3xwuLYsWPo0KEDir/WGDkejW/vZfK1xw1YIi04P9UWJD2n8BzVbzVq1FCTe32MBCfHhM+zON+rr77qcA16dydOtrlxH9PFXrt2TVkwuMrPfuZPZp3ixgDtoUOHqnNyo3hZvnz5fQdF89z79+9XoomZrPRQDP268DvbfeQthAavNkRUiRMIN1lVsb0lvhas3T0OvXZ8hn6tpsKneD2XokhP06ZNXe6nIGH1csZjMDUv62ZQSAmCIAiCIGQnUu0sTj/zmjVrqirFBw8eVFmBOGFngC6rb9Md6kFBQUMxwYkbV8cZyMzUt3RbSQ7GgfTo0UNNflkjwd3gqjytFbly5VIr/vmY/UgXuK1lPbJEO7rqeBq8VUYjZzjBpxh0rpbOGA79hJlpYJ0n7c6ZoQgDsBnkTBc5Wg1oxWCf62EQNuNw+JoM9Od7kdZMSxQ1ztfnHNcRe/sagn46jilN1qBiVG14xSUuCzUZMcsrDG1/74slizqheL6ElcIZQ9K7d28lOhITFmyj1clgEDzHpSAIgiAIQnYj1RaLU6dOqXoF+oBXTu727t2rrBeLFy92qG2Qnrz99tvK/YVuLnSB4US2bNmyygrByV9S0IWFgbcrVqyAu8EMXIw90Jg2bRpy+dXClZBIu7CgBYBYoh3T/XqZvJO06FCgJSYsNJ588klV2E5zd9IK5iVVdVuzKCRVdVu75geBc8A4A8EnDBmEHDlzolzpjrhT4B9cy3kBFoMB1z08MCHmP5Q7PwoLvu6Byo++hqKPFFdZuDjOWMeFws5VfAX3sco3YZwRrUZ0DxMEQRAEQchupFpYJDZp4iSRgsN5lTq9oKvN2rVr1aRa8/0vXry4qpLM1eKkhMUXX3yh0rXSjcgdhYVzFiJaLvLkjo9n8fUyqVV7xhl4+tAVLdj+HIO5mcWJBfYoMF544QVVd0JDEx0MWF66dKnLWAq6StGtKSlSIiycRUtywoLuXbxuChKen1XCUxqDUalSJVU/gwKDgpRQkGrXFREZhXyNn8CjnSy4lsOWIvc/Lw9MwiE03z8Q7wS8D2OhDvbz0bKit67QQsMMaBTV2phnjMWcOXOUxUYQBEEQBCG7kaYoU04UWbhNv5Lryi0lPbhw4YJ6PfrT6+Hjv//+O9Hj6K71/vvvq5SlrlyCEk3pqpsEa1mMVGrTTCgA6BwUz4l2Ll9Ph6xQrJRNV7Hxm+di5aVp8ceafJQw0SbxnAjTJYnuTNx4HO+JsRGsKaFny5YtSniw37T7pvsUYyW4n9YLHtOoUSN7UD+L3VEE8Br5vL6/KAQnTJignuPGa9KeZy2M7du3q3ulWxcFROfOndVkXYOWMGYlo0sbLVVJwYxOfN85Niko9e5ytLicPHkSt7b8hU3bfVHuuadQouFlXPWxZbTa5G3Bzp2jMGD3l3ih/Rx45CxqP/bKlStKQH/99dcqHoXX4+fnp+6bsD+feuqpLFUokvfCfsxK95TRSB9K/8n4c1/k8yt9mN3HoCUVr3tfwoJuOW+88YZaUXZ2DxkxYgQmT56covPQhYnxGUnx7rvvqmrI2sQtMDDQ4XmuSGvPOcPVbgZ383pKlSqFlPLRRx/hvffeS7Cfk1xnd57MeEO5Qu5jjI9zMFhi46tlO2V7NVlMDpW0XdVt4PMM2KYA0b8WBQLjZvSTe8annDhxwv6YMS5Mw8qgfS3OQEN/nCY6nbMqaddGaxTjPjQY/OzspsX4HW5ahikNxtxwnPAeKEhorRg/3lZAkGPDOQanYMGCSlgQa3QETv6wCmfWF0PjlxshvOQhhJmAcKMR03EF65a3xPCiz6J8zSGAwaiEBAPGNWjp4WNawhYsWKBcoZwL+rk7HBMUUfysSw0P6UMZg+6HfIal/zIbGYPu3X9JFTJOs7Bg1eTnnntOrQZzlZmT3F69eqkAVta3GDZsWIrPRcHAIPCk0CaXmqCghUQPX99ZbGgsXLhQTfz++ecftWnXz8kxV9pZt8DVG/TOO+8o4aS3WHCVmz70zr77GQGv8/XXX0ehQoXUKj8n0N/uvs6pu3o+l7+figcg+XPlAeJ1BA7sOYDvLnxnjwNIClp/tBSrhH3nXFPCmT/++AMzZ85UrmrcGNjvHBDOVX4KTn4oODjZnxQItITwvTh79qwK5nYWIa6K7WmWD+1+Cc/J91Wr6M1K2l9++aX6nZanefPmqWvgB5LB6DyWxfX0LmGxty7B90AYBndcgu93vIUzAbbsWSe9PPDqzVVov3YjRj79lXof6E6msWfPHiWO6G7FGCNagZwFUVb4QqMbGMe/CAvpQxmD7od8hqX/MhsZg+7df6mJiU21sOBEkNlxhg8fjs8++0zdKF0/uHESyloKTEWbEtg+uYmrfjLJVfHjx4+rVXINPk4stSddc7SVaw262lAcUNAklpGIrjhaliU9fDMz4w1l7ATvnRNi9hcn5b7Vn4ZnveftMRbadQV4+TkcGx0epSboKbluVlTnJJn9ya1OnToJjnOe7NMioC+QR2uA8zH8QDB+w/k4Fs5j/IuruBf2Pwcy3yNnqxgzY+lfw5WY1Z5nPAXjb3hfWjC2Bl2qaGVhZW1aV6pVrYoutSqjvM9kLDyyG/vuTMc1b5sJ6FePCOxY3wv/K9AEpUsUw5nzl9S10UKhvx69ux1jMCiE6dKlF0LuCO81s8Z/VkH6UPpPxp/7Ip9f6cPsPAaNqXjNVAsLrmJrcQ6coB86dMj+XMOGDXH06FE8qJviBI2rz4MHD1aTTsZPML7ip59+srfjKjQtKVxBZo0Gbnp4PFfVneMJ3AWu+tNKE3XjMvLH7aOw0PD3cgyYtkSZU1znY9KkScm2YUA0C9pRYHB1nq5hq1evtj/vysrgXHlbuw/ud1VUkXEKhQsXVpYHWhwYl0Erh7blzZvXof1XX32lxoTe4pQSKAq4OTN4QD/s2LEDRas+jho9q+BmocOIMBpw08OEEUF/od3IHMh58lk8/+rH9hohetgvBw4cUC5n7B+6eDVr1kyloX3iiSdSdG2CIAiCIAjuRqqFBVePtZV++rLTJYoTXQawssbFg8yI8/HHH6vsRI8//rgSB/TLpxuWfnL4+++/q0BtLRNQVoMZoYglwhZQ7iwsAr0dLRaWSFt8AQsKcsLLeAP+pBUkpVAsTpw4UR1H4UA3Jc11iXEyrq5Pj6uiiVpAvLNlyDlGhwKSwiIp+vTpoywPjLVg5ijngn6pgVYGigpy+fAeXB79D96Y/R1Oxs7GOT+bj+GmACPyVj+OusemoHyZmYDJ0+569+2336qaLvq4H/Y5xyVFmSAIgiAIQlYl1cKCLh2auwctFCzWxtVlrjzTJYQT/QcFYwy4Esy0oZwov/TSS+oa9HTv3l2loE2MkSNHJlth+WFGm7hHXjyCmKDL8M9XBE9XKaT2cYX/2PUzDu2f69gFtfOVV32nh5NdV6YtvXDUoKuQXkBolbkJV+A5GWdcAceA/jkNjhe6pNEtiVYuWiqKFrVlWqLAqV27tj0bVGoEj158UGTSusFzaNfPbFBnzpxR1hEGVNMik9TYIAnidawWvN+zC+5Ed8WY5e/jmGkNwk3AbQ8T3g7+G799VxfjWs9GnmKPq2xZmzdvdnlexnRoY5V9n9IMZYIgCIIgCO6Cweqq6lcq4Co2g7a5As3Yi8wIbn7Q8N44GeYENTPujzEKWowA3b8YrEyBERkVhYpVqqNMCZtQ4vN3vYFyEwraj325/Kd4Km9plbnJ2X2IViYKA/1knq5izNykxTgwzmLs2LEOLjycfGsWB71Vg25xFA/cKDarVq3q0IZuaqyTwfNyYwwMrQ0PCqbW1bvq0cqSnPBlJjGKHr7XWhyGJqr4UVm4ex+W/PMazvnHJxHIazZjXLH2MHq1QpOmzVyely5Tbdu2xcaNG1GvXj3MmjVLZR6jGxnjkz788MOHVmzox5/EWEgfyhh0P+QzLP2X2cgYdO/+S808OE11LAiz7HAC5+z3LjwYGDPCFW9XcRMUA5YIx5RgObz9XbbVYhI42dYLC676cwAz1Sw3ihjnLEeu4igoGGgh0OAketWqVQ5tmJaV1g0NnvtBCgtn64OzGHIF3bxo+Zk6daoKRNe71NES0qvuY3iq4gaMXvIejnmsRqjJgNsmE4ZdXYPOMVtQMr8Xzt20WZUo5ugeNWTIEOWex+xe2n1/8sknyo2QMBifXxZ0AxMEQRAEQXBX0iwsWGmYxdVSWrtCSD0syEb/fC2la5s2bRwCpjVoBTDfvuWwjzEXSa2EO4sG5+rYVMZ042G6Wrbl5ipjlnPlbeeq28S5Bkhq0pfdD86qWou9oNWCFhsqb2375ptvHIoIzp07N9HzFsrpizkDP8K3f3XAqiOv44xfuNq/wjMc1SeWxqe0XLSx1V8hs2fPdkgiwPS6ehFGpk+frhIKPKxWC0EQBEEQhAcuLIQHDy0I+mBgVwHShAIgKsrxuZw+fiqmhCY0Wi4YE8PMXhrO1gx9MT3CAoZ0DWLRwKR4EMKCcRGM79AqedMqxoraKYX1VhjQrYdZxLp27ZoguL9+/foYNGhQiif2tF4MeLI+nqq8EWOXvYnDPtsQYzTgjJcHPrJsRPCmS+jX6QcYPX2USxhzTzsXDNQzf/58ERWCIAiCILg1IizcAGcLQWLCgjVGSNW5tWAw2tyVcvn6qwkrJ7aEwcsMMtbSxbJStZ5nnnlGZYDS0Nx1tBiDZ599VokRbaNLD4UHz8/aF5oLlSvXuNatW6v9FAncGjVq5FBojoJHC+JmnRGu4nPTw+xPrlLEuqJv377Yu3evvVie5h7lyj+Q1oyXX34ZqaVkvgDMHTQLk9evxqZLY3HVOxbRRgOmR57Ajvn18GmbuchTuKaqvcI0yIynaN68ucqoRssIi/rxtRmfJAiCIAiCkK2FBVO/pqbUt5B6knNXcsZgZW2IOGHh4+/wnHN6WGcaNGigUqYyFoLZmlhpWoNChLEUesaMGaN+suo0t/upG0GmTZvmcG10vXJl9WDMQkqFhau4CooKV65cJLGCiclhMhrw9jPt0Ozs4/hszQAcCbRV7d7taUbXtc/jo0oDlUXC+fyXLl1SxQVpaRIEQRAEQUB2FxasKyE8WNq1a6fcmRhMTPehBClRnbCYTTDGefQ0ql0Ps2ZMVcHUKYWF3bg54ypo+8KFCyoAm1YUPk+3LX0lbo1ly5apCtuc6DOmgQXjPvjgA5UO9p9//kkgePRpY/WkNisX74PZp65cuaKuLbHxyqDttPJ4qUL4esBKjFn0KfZZFyHYw4AbHia8dPJbDD63BYO6LIbBqYAhXdMEQRAEQRCypbBgnn7nVevE4OSxffv293Ndgg4Kilq1aqk6IXQRoruQtrGmBytV67GabW+r1WLCpXNnEnWdSi20WDhD9ygWhNPDCbxzOjSmo2W6Wf09ERaO01fN1uC9ucpmlVphQRcjignnNG1MkUzLDGM4uGnV5NNKDh9PTOv7Dub91QQrjw7DWd8omA0GfBFzBv/Ob4BPOv6IHPkrujyWLmobNmxQ10axxfebgfss+icIgiAIgpDlhAVXnJlGlCvNDErlSjqL1bFwHV066D6jERQUlN7Xm62hQGBfJ4c5pBhMvkGIDSsNWP91OUG/HzjZZ/yFFp/Bn1rmIz3c7+xu5CwIEqu8TXhOtmcwNQv7MYCc7bnpsyulBRarcy6umF7Q0tL3yQaoV3YDPlg5AIcC/lP7t3nFouuvnfFp7VGoXuN5l1YdFnDU06pVK5VFKjkrlSAIgiAIQmaT6hknC6Zx4shVVf3EjIXI6LLz8ccfo2JF1yuyQtpwZXngZN+ZiM2+iKk3BCG7/lWPGbzNeiOsf0FBwI1B1CkVHAy0HjZsmF1McPv888+VAOAqu6vrdBYMLKyiRytA53z91apVU0UANV544QW1uSOViuTBtwOXYdTiSdgZuxBhJgOueBjx4v6P8OaF7ejZ9nOqEHt7fTA7YUA8XcREVAiCIAiCkCWFBTMP0cXJebWXE8Lu3bvjt99+E2GRScLi9OnTKsvQoEalcP3OWZRqWQ6VX1uPmjVrJpicMg6CWZxSAl2bWOdBD9PPUlhwYy0TBpjzWvjTVRpZXgNrN1Bg0BpBSxehwGGGJM21KzXpZJPjxIkTqtAdRQzdnQICArBy5UpkJL5eJkzp/T98u7kufvnvDZzzMSPGYMBHQX/i+ILmGNPtZ3j62Kw5dHdjNXSmFqbbFgvnMeOWIAiCIAhClhQWwcHBqiCeK7j/QRc9y87kzp0bGzduVAJDC5bWCwamftULgKFDh9qzOjG2gAJBg1mfONln+tPk4hacs1LpA7kZ9Ny/f38lKGnRYCYnpnil1YrXq8HXYozFqVOn1BihK12pUqWUqw/jLx4ErIPB4nQambXyr2peNGuGR0utx/Q1PXEg0FbPYiVu4uz3jTCt3QLkLVRD9TPT+dLlq0WLFkoICYIgCIIgZFlhwXz8nKyySjB94BlXwcJfP/zwg0oFSn944cFA9yLWQEgMZ1GnT0tLdyi9sJgwYYL6yUl9csLClcuUc4YojgW9WxTjcJwzUVFYsJaD3vXnQWZFcr4vpkV2FVieUdQuVQhTX1yHMd8PxU7f7Yg1GHDAy4Lua3piap2xqFqtm/ocCYIgCIIgZAthwaxEq1evVqvh+uJlXH1evny5WpkW0hfGr9CyQIuA5g4VHh6eoJ1zXIO+0jXFgat0sSmJs+CK+/Dhw5U44ao6j3EugJeSytvO9TcetHXLVRVtZodiQHhmkS/AGzNf+goTl3+FjWFfqpS01zyM6Lv3fYy+fhgdn/ogyeP5HtLlcMiQIVJUTxAEQRCEh4r7ShfEVfPDhw8rdxb69HOixnSd6ZV9SEg4sWeMgHOaV+c6D1yhp/sRBQYn7fqq2sePH1dCo0KFCsm6OSVWwC4pUiIs9EKHJFaoTj+JphDguXksH6dGuDJeg2NTc91jXIdWgTwz8TAZMa7bK6i4ozp+OPgqzvlYEGk0Yszln3F8yTG81XUJjFohEic+/fRT/PTTTypWhBm6WEjwfgv7CYIgCIIgpCf3rQToTlK2bFm1CQ8WV5mfaL1wFgWsgq1VwnamePHiKjMUayLo08WmxmrAtKejR4+2Wy0oHpgdirCWBmMDKAIYfMwgZGdefvll5Y5EkUDrhb7i9B9//GG/VwoOxmjs378/QUE73kNKi9nxGufOnausa3SB+vLLL11aMTKLbvUbolzhdZi6pisOBNjS7y6MPIFL85/E5O6r4eMbH6OiBdy/9957dmHJYPiTJ0+qexQEQRAEQchsxMTgBrha2adLVEqtDRoMBmZg9f3CWBoGfWtQPGjCgu5aycEV9sTo0qUL7ty5Y3/8559/JrCCEAqS1FTJZkwQs0NpBfIeNmqVLILJz/+O9394AdsCjsNiMGCr8S5eWNgUX3ZYjHy6YnpfffVVgsxgDPYWBEEQBEF4GMicKFYhVbBK9dKlS7FlyxZV5Zor+YlZGrgyT5cfxsLQmsSVf7qspQfOMRqa6xuDtBmIXa9ePWUR0dehSA5aN9auXesgKjTLRfXq1dNcedsdKJjLD58NWoLWsc/ANy7A/pinGT1/7YITpzbY2zGmiWl+teDzsWPHSmV7QRAEQRAeGsRi4QZQRHDizgxOPXr0sNd8oIBYs2aNQ1u6ODHuRY8+G1Ra4Ln1aBaT7du3OwgDrfhdSqAloU2bNi6tNIULF8bAgQPtKXSZySqrxvH4eJrwUf9PMO2nsvgleDpuexhx1cOAF/96HR/eeQ1NHx+oBAVjKljvgtmjxo0bl9mXLQiCIAiCYCdrztKyKIxh0FsfGK+Q3OSfpNdk/JFHHsE777xjj8/QArSdXbJcFfJLTfyI3v2LdSgoLiiuWIQxK8Mg7Nc7v4QSf5fD3CPDcM4bCDMa8fqR6Rhx5xx6t7S5krVs2VJtgiAIgiAIWVJY0P+eK9USzP3gcHZFSiyo25WwYLAvnzObzeonJ+6pidGgC86VK1fUNXBjIHbt2rXVc87ncZXWNjXxI1evXrWnhOVk+/HHH0d2otMTTVEs/0+YtqkbDvnFwGwwYNLVX3F5xUW83Wl+slmg1q1bp2JROnbsmGHXLAiCIAiCkG7CYv78+Rg5cqQKwmVKTPr4C+mLsyXAWVjQonHs2DHlIsM6FxQTDRo0UDUnGGvBDEIarDnSuXPnFL/2999/r86twYrZmrD44IMPVKYnCgxeU2osCxQWtIRo2aASs2BkN+qUL4eJOX/HpGUdsC3Q5lq2MGw/bv7wDD7p+Ss8TJ6Jupb16dNHCf0XX3wRM2bMyLSK44IgCIIgZC/STVh069ZNBdv+9ddf2LBhA1566aX0OrUQx5NPPolffvlFCQxuzhPGv//+G88884z9MWMwJk+e7NIdiudhIHSLFi1S1L/OVgm9ZaRdu3Yq2xSzRNE9ypWLVlKZqi5cuCDvsQtKFcyLj/puwsS5XbA+0FaxfIPlEoLmN8aXPdfB1yenQ3sKSbqNUVSQefPmqXozTOUr4kIQBEEQBLcRFlx15ia+3w+OokWLqj5ODOdMUfpK1871G2iBWLZsmcuUrq5Iyt1p3759aN26tf0xg67pNiWknVz+3vhg0M/w+24AVnnvQYzBgL2mUPRe2BRfP7cKeQKL2tv+/vvv+PXXXx2OZyA/XctEWAiCIAiC4HbpZumO8yDhSjsrf1etWlVlSDp16lSyx9y+fRtvvfWWct3hqj8z6rgbtCywyB1rMeTKlUtZJ5KLV9BXunYVwJ2aoG7WS6AV6tVXX8Vrr72GSpUqOaSM1eOqOJ6QtoxR4wZ+h56mjvCPy/B1wiMGPZc+gws3jjqMERbL00QE452Ysat8+fLS/YIgCIIgPPwWizfeeEOtfPft21dNbCdNmqQmwFu3bkWePHmQnqxevdoew1G/fn1MnTpVpWFlReLEXouiom7duihdurRqrxV1YwxIw4YN4S5cv37d7uJCXFkaaLGgZYE/+V7oaz4wpoIuMXSV0UhN8DYrbieG87Vo2aKE9MNoNODN3hOQ99cimH/zc9z2MOGyhwW9VnfDzGazUKNkQxXUzbgK1hOh+GPcE2ugCIIgCIIgPPTCYs+ePVi5cqWKq2Aa0rNnz6qJ/IABA9Sk5vXXX0+/KwUwfvx49OrVS02ayIIFC5TbzaxZsxKd+I4ZM0ZlQqKLiOYqxFVd7nMnUpLSlfUNEkv1SmFFYcIgbroxMUYiZ05HH/3kYDVsulDxWmjt4Ir4sGHD1GO6adFyQZGRWosFYzIOHDhgD+DmpreICPH0bf8K8mzKh6/PjMcFLxPumICXNg/Gp/U+wpOV2qk2fI/Xr18v3SYIgiAIgvsICwbdMhUoV/+feuopVRmaE06umB46dCj9rjJu8klf/jfffNO+jxNR7XVdCQsGsy5ZsgSvvPJKgvgD55iDhx3nbEmpqRWhQcuNPrNTauGxc+bMsT9+4oknlLCgFYmbvt9TAy1OdFHT8Pf3R1hY2H1fZ1anQ/PnkDsgLz4/MBTHfEy4ZzTg9Z3vYFz4HbSv/UKyx1NU//PPP6hTp06GXK8gCIIgCNmDNAkLuiGNHTtWrVLTNUkLLD5+/Dhq1KiB9OTSpUtqwqrVN9Dg44MHD7o85tatWwgKClLXRRcRTqaKFCmi0nH27Nkz0ddi0LM+8FmLG2EF6/SqYp0a+Jp0MaMlQEvJyhV9V9fC6tydOnVSAo8bBdXOnTvT5TqcxQwtFbyG9957D7t27bLXuGAsRlL968oSooepctOzn3kujp3MeO8eFA0fb4ocAQsw9c8+2OdnRLTRgLGHJyE4PAi9Gg1L1vLHuiSLFi1yEITZqf8yGulD6T8Zf+6LfH6lD7P7GLSk4nXTJCwYSMx4BU5mH3vsMVSuXFm52/Dm+/fvn+zxb7/9NlasWJFkG8YFMGZDuylnlyBOshNza9ImwqyvwYkU40E4Ae7Xr58q5scib65gW06WneG96QOiMwreO4PVFy9erGIltHoRDGIfPnx4AgH233//2R9TWLC2QXpw586dBNfFc+/YsUNlJNJg7EpqXpPjwJn0umbtOvl+c1wajemeryDTKJS3GIbU/Q5zdg7Adn+oQnqTz87B9TtX0bueazfETZs2YcKECer3559/Xgno5FIOZ9X+y0ikD6X/ZPy5L/L5lT7M7mMwNBVlBFItLBhPwXoVmn9+06ZNHZ7Pnz8/pk+fnqJzjRgxwiGY2BWMoSD58uVTPxnD4WyV0J5zhoXh+AYwoxHdoQivnZaLb775JlFhwXgRihC9xYJWD96bPiA6IwcUA3M5qCjiNCg2KO70OF8frRbObe4XCoahQ4eq+Axu9OXnuem6pIdWlbS+Znpds77/+P5ltYkx+6lYkfX4ZHlbbAqMhdVgwIKQtYjYeQ+j201zqNLNtLN8/zT4HjIeijVIqlSpki37L6OQPpT+k/HnvsjnV/owu49BH6dwgnQVFvv378eQIUOwbt065Vakh0qKcRclSpRI8aQopRNIZrfh5J6r4+3bt7fvZ9rVp59+OtGOoJBgelY9fEx3m8TQAoid4ZuZWRMrDih97QjCa3S+HmdzFYWFcxu+T6lVvcz8RUFGawmvhX2uvQ/OfcUJa2rOzaBzxs9oMLg+vfuZ15yZ79+DpHChonjvhc3wXdAKqwNtqX+XhWxByPK+mPzcfLu44Oe1e/fuKtmBBsU1BapegGS3/ssopA+l/2T8uS/y+ZU+zM5j0JiK10z11XEiwsk6YyoYS6Gxdu1a1KxZEzNnzsSDYvDgwSp4WHvdr7/+GmfOnHGweowaNcqh+jRFEF2ItHoXzFzFOhZt27aFu+Ec4+Ac0K0FpY8bN04FubO/tMrbrIxOAcDnOUDo7pUaVq1ahU8++QRTpkzBjBkzsG3bNvtzjPhMeD8AADgVSURBVKdgCuBp06bhyy+/VJW4UwMVOGNl6PJWrlw5VY1bSB05c+TCuAFb8FxYbvu+DZH7MXhhJ8RaYu1fSnRdZGpo7bPCFMzJiQpBEARBEIQHYrHgijXTvHJSwqxADCqeN2+eChBmUDSzBD0o6IvPGAIGhtP9hpNkioRq1ao5+ObTaqLBWA8+5qo4J6yME+jduzcmTpwId4MCqlmzZkpgcGNMizN0TdMHntPNhTAORS9M6GtPAUCRmNbK23oL0v0gqVHTBx8fX4wa9Ad8v2mH730vwmIwYLv5FPosaINve/0CHw8fJSrpBsj3ni6CgiAIgiAI6cV9BW9zhZOBn0uXLlU+2swOdeLECVUr4UFCIcEVca6OM9sT4y+cq0dzJd45wJqB2BRCDL7mynhqKk4/TLByeHIpQmmV0AsLrS+c0+tu3rxZxZ3oLQ/3KyyEhweThwdGDFoD/++64WuPY4g1GHDQcAU9F7TCvJ6rkcMnUI0FERWCIAiCIKQ3qXaFoitRjx49lNWAKU+ZupK+9yxwllHQWsF4C1cCgW41Wtpb5wl3sWLF3FZUvP/++8pCQfHG+6BbUkoCbDSR4eq+U9MXrIFBMcm0vbSc0FolPJwYjEa83H8pXjPUhW9czM1/piD0WNgSN8OCkj2ehQ4p3t2tiKQgCIIgCJlLqmfZTA9Ld6StW7eqLEGEwZ90L7p8+bJD1hkh/aCLF61CiaV+1QsoWpS0AHQtmPuDDz5QQoJubIlZIZKCfvmab77gBhgM6NPnWwQsfh2f3duAUJMRFzzC8PySVvim088okbuoy8NYk6ZDhw7YuHGjWiyYP3++BGwLgiAIgvBghAVdn/TVr0nnzp1V1ib62jOgeNCgQak9rZAMzoHaencnPQxmp6uLc0AuLR0UgnSBohsTMzc5Z8tKSWao7du3K4FCUcIA/tQGaruCgvT69evqHimGeF20PAlpp3P3qQj4eRw+ur0Mtz1MuOoRiRd/aocv2ixF5UJlHdrSbY4uUhQVhAX0OFb0YlQQBEEQBCHdXKESm4xy0kp//cQmvELacLYuOGeI0uCkP7EsP3RhYiA76xkw3oRCITVwwsnMT8w0xVgWfVG8tDB79mxVYJFB+OXLl8err76aLucVbLTq+B4mFhuAwjG27FC3PGIwaE1n7Drn6L7477//YsuWLQmqonO8CIIgCIIgJEe6BhwwBsBVpiIh7TClK1PkMoaCq/pMzZpYWtixY8farQp8P5iiNz2glUNPesWr6CuFEy01sJB+PNHqDXzyZw6MPTEZ57w8EexhwfA/XsD7DWahZcUn7HE0v/zyCzp27KisFyyC+dtvv6m6NOlZCV0QBEEQhKyJe0YyZ0MYLM90u5yE02WI28iRI9GiRYsElcj1gfTpGYDrnAkqvYQF64w4F2EU0p+aTw7AZ745MHr/WBz39kS4yYrROwbjbsQkdKnZWrVp1aoV1qxZowrpMZ6K48656KIgCIIgCIIrRFi4EQcPHnQQDS+88EKGTf5JkyZNlKDRYjRYEDE9YB0UZpvS+Oqrr9LlvEJCyj/+HKb4BGLU9tdwwMcLkUbgwwNvIfjeXQx4optqw1opzP7G7GuCIAiCIAgpRYRFFqu8/aDclXbv3q2CrIsUKaJeg8HgTDucHrAq+K5du5TbDQv8McOY8OB4pFprTPUJwKiNA7HDzxMxRuDz/yYgODIEbzZ/SbVJTlQwJa2fn5+8TYIgCIIg2BFhkcWEBa0ILAgYFhaG8PBwlQpYSzc7depUJQq4cTI/d+7cFL82J/6M3dCgAGCGsPSAcSMsfChkHPnKNcIUnx8xelUP/OHvCbMBWHBxBkJWh+CDtiOTPJYB3hw/DP5/8sknM+yaBUEQBEF4uBFh4UZMnDgRISEhSmBwYxYlZ2bMmOEQszB69Gj1k9m69LUv/vrrL1y8eNFlMUFXSOXtrEfAIzUxqfPPGLe8E9YEmGA1GPDz7QUIWR6C6Z0/cJldbN++fSqtdGhoqIrHWLJkiXosCIIgCIIgwsKN6NKlS7LFypgxSg+z+7hyiTp9+jQmTZqEmTNnpui1nY93juUQ3BPvghUxscc6+P/YBksDbEJic/gv6LcoBHO6T4fJFD/eGHfx9NNPK1Ghja1OnTqpYplSiV0QBEEQhFTXsRAyB8Yf1KlTB9WrV0eFChXUhC4xtyI9Wl0RV7EWqam8XapUKZWGtGvXrir1LSeYQtbAlKcERvf+Hf3D4r8O9sZuQY8f+iNaF7NTuHDhBAKCVbqZplYQBEEQBEEsFm4CXaD++ecf++OAgIBkLRYUE1ar1Z5B6rvvvlOrzvrnU0rz5s3VJmRNjDkK47W+m+E/rxVm+NusXMewF50WdMcP3efbRSvjKgYNGqTGEscDq3OnZ+YxQRAEQRDcF5kRuAnOgdqJVd7++OOPVVVsCgyTyWTfz4J6LVu2VBNDLV2ss3UjORhgfeXKFTWR5MaCfY8++uh93pHw0OGXBwP7bYL/vKcxyecuzAYDzptOoMuizpjadCYKoIB631lwkfUt+vbtm8D1ThAEQRCE7IsICzfB2W1Jc3FyxtfXN9FzsD5EWmpEsN7Enj177I+LFi0qwiKr4ZMDPfttROD8tnjP4zqijEZc97yMV/4YgG86LELFAkVVUPewYcMy+0oFQRAEQXjIkBgLN4ErxHQ/+fHHH1VF5FmzZmX4NTyoGhnCQ4aXH9r1XYepKIUccZXbg72C0PfXzvjr7PFkD2el7smTJ6uUx4IgCIIgZB9EWLgJ+fLlUxaDb7/9Vm2ff/45bty4kaHX4JwJKjXB34Kb4eGNRi/8jFk+NVAwTlCGeYZjxB89sfjA9kQPY0zP8OHDMXLkSLRo0QJBQUEZeNGCIAiCIGQmsuTsJtD16c8//3TY98UXX2ToNbRp00YV3KPlgiKjWLFiGfr6QgZj8kD17gvx9cpX8EbQZpz28kKERww+3f8yLga/j5FNOiQ45P3331eil+zcuVNlkVq7dq3KKiYIgiAIQtZGLBZugqu6Ea4qbz8oGLRdsGBBVdmbAdv169dHw4YNM+z1hUzCaETJjl9gWoFn8WikLa4n2mjBD+fexZCfZ9qzjpGbN28mqIty7tw5XL9+PcMvWxAEQRCEjEeEhZvgKgtUaoTF8uXLlYWBtQjy58+PZs2aper1z58/jzfeeANvv/023n33XVUFXMgmGAzwqfsavqz5NhqHR6hdFgOwNeRrdP7hLUTG2FylOK5Y0V1vyVqwYAHq1auXaZcuCIIgCELGIa5QbkKOHDmUiwktFxQZ3JLKAOUMqyRfvnzZ/vjvv/9WtTFy5syZouOl8rbgX7svpuUsik82vIrFOfxUh/xnWY/WCy5jUdfZKJwjEJUqVVJji25zvXv3VgUVBUEQBEHIHoiwcBNYEO/ll1+G0Xh/RiZnYUBhsnLlSrz44ospOt45UNs5Q5SQPfCo8DRGByxFsRU9MCWHFywGA255HMKzSzpjestvULdECVUzZdeuXakSvoIgCIIguD8iLLIJ+mJ595PVKVeuXCrLD4/RNvrXs6aBkM0o+hj6PL8ORRZ1xOgACyKMRoR7XcWQ37thSI0Z6PN4Hfj52SwaifHvv/+iRIkSalwJgiAIgpA1cEthERoaitu3b6sCbSmdHN+9exd37txRMQYZGfT8sNCoUaME+1JTh6JkyZLYsGFDOl+V4LbkLYMWff9AgUWd8YbpJm54eCDSMxwzDr2Ef6/+D5PbdoPR6Fp0nj59Gk899ZQSFT///DOqVKmS4ZcvCIIgCEI2D96m+82gQYNUTYc6deqoLEULFy5M8hhOYpi9iILiySefVDEFPEd2c+UpVKiQyuZEUaVZGVJbh+Kjjz5S26effopp06ZJtp/sTkB+1Oi7Ad8HPo4KUbbkAtEmMzYGTUT7BWMQGpkwkxnrWjD+4tatWzh16hTq1q2rEgsIgiAIguD+uJXF4uOPP1ZxAYcOHUL58uVVJeo+ffqgWrVqqF69ustjBg4cqNyAmPKScQqHDx9WWWpYj2Ho0KHITuzfv9+hOnJqGTt2rIMga9y4sRJ3QjbG0wdFus7HvK2fYNTRb7DZ3w9WA3Aev6DVgv/wdbsZqFo4fowMHjwYJ06csD8ODw9Xn+kuXbpk0g0IgiAIgpAtLRazZ8/GgAEDlKgg/fr1Q9myZfHNN98kmSa1SZMmSlQQCorSpUur/dkZBoGnJhCc8RTOVh6pvC0oDAYENPkfpjWZgleDw2GIq20R6n0UfVZ3xTc7dto76rPPPkPt2rXtj2vUqJHk51cQBEEQBPfBbYTFtWvXcOnSpQQ58Vmo7Z9//kn0uLfeegtz587FL7/8ggMHDmDSpEm4ceOGEihCyjGbzQn2ibAQ9Bgrd8Dg51Zi+l0zAs02i1i01x18eWww+i6ei4hoMx555BFV64LZyPLkyaOsFckFeguCIAiC4B5kqivU1atXVS2FpChTpoyawDJYmzC+Qg8fM29+YvTo0QN//PEHunfvrgp40beb4qJixYqJHhMVFaU2feC35j50Py5EaYWvSYtBZry2Bq0VHTt2VD9ZS4M/OSHMzGtyp/5zZ1LVfwWroXGfTfhhaU+MMF/FKS8vxJrM2Bs1BS2/24/Z7cejYqFcmDNnjloooNDIDu+LjEHpPxl/7ot8fqUPs/sYtKTidTNVWMyYMUOtWCYFMxExL76WLtW5AjUFQFLZjdq2bQsfHx9lpQgMDMSRI0dUhiROjF977TWXxzBA+b333kuw/+bNm6rQXGa8oRRgHFT3W8ciPZg1a1aCfezXh52Hpf/cldT3nxF+zyzA1zs/wUfX1+N3f5tFIth3M3qvOornS72DntWrwNvbO9HxExERoaq78zPqvJjgjsgYlP6T8ee+yOdX+jC7j8HQ0NAUtzVYeZVuAG+KGZ2YBYpWCI3nnnsOwcHBLlOhXrlyRaWkXb16tcpEow/oPnjwoCrilVKLBVdWma6WFbAzY0BR1NDicr8DivdLqw0FFTdmhzp+/DiyA+nRf9mZtPSf9egvmP/Hm5iZwxexcdnITGYPVPDuj1kdBiCXn+vUz0OGDFFCltnc5s2bp9LTujMyBqX/ZPy5L/L5lT7M7mPw7t27yJ07txI3yc2D3SYrFK0Njz32GNavX28XFrRebNy4EW+++aZDLAZXO0uVKqWECFOram5UGnSHSqowF1dSuaU14Dk94X2k5fUZI6HPxkM0gZEdSGv/ZXfuu/+qPot+hauj9rLn8Y5HMC54esJsisXR2NlosWAX3n/yPbSpWtrhEMZDadYxuks+/fTTmDlzJl599VW4MzIGpf9k/Lkv8vmVPszOY9CYitd0q1kW3ZNosWBmme3bt6Nnz57KzYkpLDXeffddtGvXTv3u7++vVulHjRqlcuXv27dPpazlxKV///7I7pW3s4vFQshk8pZB9f6bsTR/U7QPDbPvjvY/gHd3PI/+i1cgJCLGviozevRoh8P5GW/WrFmGX7YgCIIgCKnDrYTFM888oyr1/vbbb3j55ZfVhGPbtm0qu4wGXSeYTlaDtS6GDx+Or776SomJnTt3YtWqVcqFKjvhSm2mpvK2IKQJT1/4d5iFiQ0/xMe3QxEQFwgW6xWGPZHj0ezbN7Dh6CU1Tjdt2qSsFBrTp09HpUqV5A0QBEEQhIcct4mxyEzoW0a3qpT4lj0IuIrLINcCBQrctwmMvnk8Xs/JkydRrlw5ZHXSo/+yM+nef0FncXFlf7wTewn/+sS7HHpG5UStHMPxabsOyOnroQQFU0l///339mrx7oqMQek/GX/ui3x+pQ+z+xi8m4p5sMyysgmuagVIHQohU8hTCo+8uAHzKvbHsDt34Rm3thHjHYJdke+j2Xcv44fdJzB8+GtJigquiVB8JJeyWhAEQRCEjEGERTaB8SZUvKxBweB2qk+m8RWETMHkAY/Gb2Ng99VYEpUD1SLjsrAZgNgcuzHtSG+0mjMdhy8nLhooOpiOlm5SP/zwQ7aohyEIgiAIDzMiLLIRXPllXAVjU5hlS9yChEynUDWUG7AVCyoNxJt37sI3ThzEeEThmve3eGFVd7y05GfcuOtYPyYoKAgjRoywZ47q3bt3tkvIIAiCIAgPGyIsBEHIXEye8HhyJPr02oRfjSXRPPye/alYv8vYETEGLecPwsT1uxAaacsexcxRTButp1evXhl+6YIgCIIgxCPCQhCEh4N8ZVHohdWY9uQkfB4SgxIxMXb3KHOOfVh29SU8+fUIfLH1EIa/PgKtW7e2H9qxY0c0b948865dEARBEAQRFoIgPEQwULtqZzQetAcrS3bHm3fiU9OajRbE5tyMb0/3Qc913+DpkZOwdOUqVK1aFZMnT070lFeuXFGbIAiCIAgPFrFYCILw8OEdCM+nxqNPn61Y4/8oeoXchYeWPcoUg5hcazHv7AuYcHYzun0yHzkLFkv0VCyaydo2rNx9+vTpDLwJQRAEQcheiLAQBOHhJXcJ5HluId7u8jNWG0uhXWg4i+/YBYYlzwasuNYfzb55DSNX/omLQfHxGeTMmTNYsGABoqKi8OWXX6q6LT/99FMm3YwgCIIgZG1EWAiC8PBTpCaKvrAKH7ZdgJ9RVAkMY5zAiDXFwppnGzaEvIp2P/RFl7kLsf7wVcSYLfjoo49gNpsd0i43a9YsE29EEARBELIuIiwEQXAfSjZE6Rd/w4ftFmKVqRQ6hYbZC+xZGOSd8yhOGD/G2O2dUW/muziTqxx88ha1Hz5w4EDkypXL5alZ44VF9wRBEARBuD9EWAiC4H6UqI/ivVfhvc6/YENgHbwUHIqcOstEhHcoonOvwq3KP6DKuDp4bPwHKFC3LfoNHpLoKekqxWJ77733Ho4cOZJBNyIIgiAIWQcRFoIguC+FqyNf5+8wtN9ObCzRHR+GWvBYRHwxPYvRiqgc/yGq5BIUH3gFfda+hy5zv8eSPecQci8unS2gLBXffPMNTpw4gfHjx6tMU5988kkm3ZQgCIIguCcemX0BgiAIaSawEHyaj0W7pqPR7vRmnPnna6y4sQerAnxxx2RSTSI9ooHc+3AC+zD54FRM2V4BRQJboVPlJxEYejmBlUJiMQRBEAQhdYiwEAQh62A0AeWeQulyT2Fk+G0MP7AImw7Px1rzHfzt54sY1slQIiMGyHUYp3AY045Ohe+9wqgwdhCCDkci7OAxFLCGoHbt2i5fIjIyEu3atUPjxo3RokUL1c4UJ14EQRAEITsjwkIQhKyJf154PTEUrRsMQesbxxB29CdsObUKm2Ju4S9fH0QZbZ6g0SYLogMvwzPwMgqWBkq39oRneEW0/vozPFbkcTQsWR6PlcyNAoE+qv3ff/+NjRs3qm3MmDEoXLgwLl++DEOcaBEEQRCE7IoIC0EQsjac8BesjICCldG26btoe+cc7h39GX+dWImNERex09cHwTqLQ7gnrRmnEYzTuBw0HxtvmOC/NS9M1goolLs+Qo9eh3fRioi+eR7W6AiUL18+UVFx8uRJ/Pfff6hSpQq8vb0z8KYFQRAEIeMRYSEIQvYid0n4PfEaWnELvw3L2a04cWottl/bi10Iwz5vb7s1g9zzMONe4A0AN3DN/BcM5YE64/zgHdUAUXdzwWwthXHrtqBO0bKoVDgXHsnjB0+T7filS5cqqwYJDAzECy+8gM8//zzTbl0QBEEQHiQiLARByL7454WxaidU4gag/90riDz9B/afXou9t4/giCUcB729ERonFIjVANzxiga8rgOB1wGcwE831mPVNSB3tA+8YnLABwXh71MaZ+6GI+cTrRB16SoiQm7CnEQivvnz52PHjh145JFH1MbYjcqVK2dQRwiCIAhC2hFhIQiCoJGjCHxq9kJ9bnwcEQzLlX04f24L/r26B/+GnscRkxlnPD0crBokxgjc8IkEuIEWjkNAFeCRKoC3BcgRWxAXYvag8+ct4WvMiwDvIsgVUBL58pRHkdzFsHjLPmxatRbm8GBYIkMxatQoTJw40eV7s2jRIpw7dw4FChRQW7Vq1VCqVCl5HwVBEIRMRYSFIAhCYvjmgrFMM5TiBqAj94XdgPn6EVy4vAsnb/6LE8FncTo6GKc9gYseHrC4iLeIMgI3vWIBrzCeAMBVAIcBapArts3Y2IraDXPBz5wXPmZPHDP/id6z2sDXmAP+Xnnh650P/r754R9QCCv+2IR9O/YjNiQclntheOeNYRj7zkh46CwrGu+//z7+/fdfVXE8Z86caN++PZo0aeLydi9cuIDo6Gj4+/vbN8l4JQiCIKQUERaCIAipIaAATAEFUKpMUyU2WnGf1QqEXUfMzRO4cuMgzt86hjMh53D+3k1csYThitGKax4mRDpZOfRQkIR6WBHqEQuAWwSA4PgGMXHbXQCNgNKNuNMLPpbc2Gr5Hm2/WwhvixEeVhM8rZ7wgCc8DN6I9IuG5VELbsVcx40oYNE/l/H3tfXw8QiAn1cAfL0D4OXlDx8vf8ybtxD/7DmAiHuxiLgXgyGDh+CNIUPh7WmCt4dRbZp4+d///qcyZDEonVufPn3w3HPPuby3X3/9FUePHoWHh4fa6tWrpzZX7Nu3T2XZYjuKGlpiypQp47LtjRs3EBoaCqPRqALoc+TIgTx58rhse+/ePSWatLZeXl4SUC8IgpDOGKwsOSskyd27d9VKX0hIiPrDldFYLBb1B5QuD/yjKEj/yfhzL+jadOvsYXgYg3Ej+DQuB5/BxeDLuBJxE3diQhFiiUAIYnDHw4jbRhOijQ9X6lpPqxWeVsDDCvtPtVkAk9UAoxUwGowwGYwwwgADbD+Ncf9iomJhjjHDYLVpMF9vX/j7+NvbGw2muN+NuHM7CGF3w1Qwi9UC5MmdBwULFoTZbIGnhycMBpN6Lf48f/48rl27rtpxK1q0KMqXr2BvYzSabFdhNOHgwUP47+RJgG2tFpQpXQYNn2gYdy7ba1Nw8PGe3XuwZ88eW0ANoM7Z+pnW6lxsy0xjfIbGqd2792Lbtm1Qf0gtQLnyZdGpUxf1pFFZrwy2YwB1zt/W/WZrazCgVOnS6PdiX9XGaGQ7W3sYjNi7ew+WLV+ujuPekiVKYviwYbbzsa3aa3uOYuz7Bd+r8/IURYsWw9tvjYx71taKf79y5cqJI4eOYM6cOXG7DciXLz/GjrUlGIjHdtzJEycw66tZ6neem3//PvjgA/Xa2utrbU+fOY2pU6bGtQR8/fww+dPJCc9qAC5euoyPPvrIvp/3PjORpAa3bt7C2LHjHPZ98cXn8PDwTNA2OCQEb731lsO+6VOnws/f3/Y6ce8DCb93D8OHsj/j+XTKZOTOmdvWido1G4CYmBj0799fiV2Njz76GIUKFk54wQZgQP9+MJu5OGDj/ffeR/GSJV3e3yuvvIyIe/fsj0eNHo1y5cq7OK0Br7/2GoKD79j3vTniTVSpVs3lef/39tu4cYMxYDaGDhuGmjUfc9l23NgxuHjxgv3xSwMHoV6DBnH37/hdNHHCBJz+7z/74z79+qJxY9cW0M8+/RRHdYVH27Rth86dnuUbnqDtzBkzsH/fPvvjTp07o227di7PO/ur2di1c4f98TNt2qJL1y4u286bOxd/bt1qf9yiZUv06NnTZdsfFy3C7xs22B8/2bgxXuzLz2dCVixfgTWrV9kf16lbD4NfHuyy7ZrVq7Ei7rNMataqpd4PV2z4bQMW/7jI/rhylap4c+SbnAji9u0glClVAf5+gXiY58EiLNK5Qx8EIiyk/zITGX8Z1IeccUeHwXovCPdCryDo7kXcDL2MqyFXcCP8Ju5GhiAsJhThseEIighFhNGCCJMV94xAhMmAUKMBEbLwIAiCkGUZmb8nXnjmnYd6Hux2rlBmsxnr1q3D8ePH0a1bN5U9JTloAl+zZg2uX7+ughxZMVcQBOGhgiuD3oEweAfCP3cJ+KM+kv9202GORWxkMCIjbiPiXhAiIoMQGh6ELds2IST8Nu7FRiLKHIlCxYvA6G1EhDkSEeYoRFtiEGONQaw1FsGhITAbLLAYrbBwYd7TBLMBiDVYEGOI88YyxG/RBoO9mrkgCIIguJWwWL58OUaOHKnExF9//aXSMSYnLK5evYonn3xSBSHWrFlTBTK2bNkSP/zwQ4ZdtyAIwgPH5AEP/3wI4KbbXaVm7xSfgp6xUVFRCA8PVxvjFQIC9GeLZ9WqVbh06RKiIiMRFRWB5s2eRJXK5WE2RyE2NhLRMdyiEB0bhe+/n4+z587ACjNgsKBOvcdRsUoVxJqjEUNBZIlFjDkasRazSrl7+dolWJVLjQVly5VVLkNRUffg6ekJKyywWMywWC04ceI4bt68YXPXMAKFChVE0WJF1HP0jeI/3hNdn67fuK5cZWw+TEBgjkDkzptHee5Y1KvF/bNaERIagrCwMLsnka+vL3LkzGGzKtmdfax2l5p798Lt/cLYjcBArc9sd6H9ZN9GRNjcXnhqk6cn/P387K20lnQZi46NRlRkVJzbFGA0mdR18Br0/sv01oqNjVXn1k5M1ysfX1uleK2t8no2cHHOgqjoqHhHJoMBPj62tq4W8hiXAl1bb11bg+5KzBYLoqP0beHyvOpdZVv9eYFE41143dHRtnvTXs3H2yfZthraeRP6fFsdrkF77+JdvOKP4v/ObTkWEyuM6dzWIxVtkzxvTIx9DNrO6+Hg3uWqbZw3HzxMHolaS+nqpR9VWltXfvKxsTGw6K/BZFKuhq7guFSfxTgYM2VKrK05Vo2L+2prNCWaZMK5La/VI9G2ZvXdEt+WMWUeiX42zCltazGr9vfV1mC0u+DxPcqboygedtxKWOTPnx9btmxRAygllgry9ttvq8JU/GPFL5jDhw+jRo0a6NKlCzp2VDleBEEQBN0kk1vevHmT7JN2ifg/u2Lc2CdS3LaHioZPmSsZJy7cOKFkG/4BTmyCShM+xQLbceNiU758+RJdkOLraefNnTt3oul8mfb37Nmztok7oM5ZvXr1RNvS2k7Ynn1cp06dRNsePHjQfl6KvEaNVMR+AhhrwvgNrS1dFriA5qr/GBjPhTmb4LKqv48dOnRwed4rV65gg87nnMKGngKuoEfA2rVrHSbpzz//vMu2t2/fxi+//OIw7vom4svO923FihUO+1588UWXk2SK4cWLFzvs69Wrl8sxQSH2/fffO+zr0aOHGhfOcIxNnz5d9ZX2ul27dlX97ArGsOjDVzt16pTo52nevHkO4oJZ2woVKuSyLa+XHhgabdq0QbFixVy2/fHHH5X7igbHQ2JjeNmyZeo90WjevDnKlSvnsu3KlStx7do1+2N6gCRWb0dbfNDGYMXyFdG0aVOX7x09Ufg50qhbpy4ee8x1TMjvv/+O/3RxHrVq1Uo0GQTnjEwcocHPZsOGDV22ZawUP3MalSpVUtfrip07d6rYJg32V4sWLVy2/eeff7Br1y77Y74PrVu3dtmWGfyYFEOD7y/HhP4z/LDjljEWHKgUFps3b040bSKh6uMHn7nghw8f7vBBYJAfc8GnBImxcG8kRkD6L7ORMSj9J+PPfZHPr/Rhdh+Dd7NyjEVquHjxolrBqFChgsP+ihUrYvfu3Ykex5UMu1k5rkOJttKV0fA1tZUzQfpPxp/7IZ9h6T8Zf+6LfH6lD7P7GLSk4nUzVVisX79euSYlxYABA1Rhp/uB+c2J8/F8rD3nCqbBe++99xLsv3nzJiIjWdEq499QqkQOKkk3K/0n48/9kM+w9J+MP/dFPr/Sh9l9DIYmMWd+qIQFO0nvq+cKfRBLavHz81M/9X6G2uu68qPUeOedd/DGG2/YH/N4ul4xxiOz0s3SB5WvL8JC+k/Gn/shn2HpPxl/7ot8fqUPs/sY9EkkwcNDJywYBJZYIFh6UKJECRW0dfr0aYf9fJxYYBLRKsk6wzczsyb2qnBTJr6+uyP9J/2X2cgYlP6T8ee+yOdX+jA7j0FjKl4zy81SmcGCWRYIM4Qwa8LChQvt/mHMtLF161Y8++yzmXylgiAIgiAIgpB1cKvg7SNHjqiUZHRlIkuWLMHevXvRoEEDtZGlS5eqNGBMR0cmTZqknmOqNab1Yyo6pg/r3r17pt6LIAiCIAiCIGQl3EpYRERE2GMyRowYoX7ysSpkFEerVq1U7mGNMmXKqABx5nRmnu0PP/xQ5Z9OrJiKIAiCIAiCIAjZpI5FRkMLCTNJMX1tZgVvMyOVBG9L/2UGMv6kDzMbGYPSfzL+3Bv5DLt3/2lJjIKDgxMtDOmWFovMQkuzldJq34IgCIIgCIKQ1ebDyQkLsVikUCleuXIFgYGBKio/s5RiZllM3B3pP+m/zEbGoPSfjD/3RT6/0ofZfQxarVYlKooUKZKsxUQsFimAnVisWDFkNhxMIiyk/2T8uS/yGZb+k/HnvsjnV/owO4/BnMlYKrJsullBEARBEARBEDIeERaCIAiCIAiCIKQZERZuAKuAjxs3zmU1cEH6T8bfw498hqX/ZPy5L/L5lT7MbLzdaB4owduCIAiCIAiCIKQZsVgIgiAIgiAIgpBmRFgIgiAIgiAIgpBmRFgIgiAIgiAIgpBmpI5FJhU6OXnyJAoUKIDixYun2zH3c153JDY2FkeOHIGHhwcqV66coqKFLOxy6tQpVdylYMGCCZ7/+++/VQEYPaVLl1btsyLsi5CQENV/vr6+SbZlX9+5c8dhX548edSxaTmvO3Pjxg2cP38eJUuWRP78+ZNse+DAAYSFhbnMCV6tWjX1++XLl3H27NkE9XMaNGiArPoZ/ueff1QfVKxYMUXH3Lt3D8eOHUOuXLlQpkyZ+26TVTh8+LAaV/Xq1UtR+/DwcPz333/q74Or77Xdu3cjOjraYR//jmTVvyWXLl3CuXPn8OijjyIgICDJtvy7ys+8HtYSqF69eoK2POetW7fUuE7uvO4Mx96///6rxgcLt6X2bwjx8/NDrVq11O83b97EiRMnErSpX78+TCYTshpBQUHqb0iJEiXU39OUEBUVpfrS398fFSpUuO82DxyrkKF88cUXVl9fX2vFihWtfn5+1g4dOljv3buX5mPu57zuyK5du6zFihWzPvLII9aCBQtay5cvbz127Fii7U+fPm3t3LmzNVeuXNZHH33UGhgYaH366aetN2/edGhnMpmsVapUsT7xxBP2benSpdasxu3bt60NGza05siRw1quXDlrzpw5rcuWLUvymFatWlmLFi3q0DdvvfVWms/rjlgsFuvQoUOt3t7e1sqVK6ufI0aMSPKYF1980aHvuBmNRmvXrl3tbT799FOrv7+/Q5tmzZpZsxrh4eHWcePGWYsXL64+i/xspoTFixfbxxaPa9y4sTUoKCjVbbIC8+fPt9aqVcuaO3du9TlLjsuXL1t79+6t2vI7kN+FjRo1sp4/f96hnfZ9qh+DX3/9tTWrsX37dmv79u2t+fLl40qSdc+ePcke8/zzz1sLFCjg0DcvvfSSQ5uwsDBr69at1ee4QoUK6u/wnDlzrFkNjqdXX33VWrhwYauXl5f1gw8+SPYYfkc6fwfyu5PjUOP777+3enp6JmgXGhpqzUocOHDA2rJlS2uePHnU55HjpHv37uq7MSnWrl1rzZs3r7V06dLqs//YY49Zr1y5kuo2GYEIiwyEX2AGg8H6008/qcdXr15Vk+SRI0em6Zj7Oa87EhkZqe5L+0I3m83qD0T16tUTPWbDhg3W5cuXqwmhNgGuVq2aw6ROExbr1q2zZnX4BVajRg37l/XUqVPVF7zzJMNZWCQ3eb6f87ojnCgEBARYDx48aP/s8T4XLlyY4nPs3r1bTWjWrFnjICzYf1mdCxcuKGFx8eJFtfiREmFx5swZNYH58ssv1eOQkBAl6jhZTk2brMKoUaOse/futc6cOTNFwoITaU7aYmNj1eO7d++qCVvTpk0TCAu2y+rMnj3bunLlSuvhw4dTJSz69OmTZJshQ4aoCZ22aMW+5ALCoUOHrFmJP//80zpjxgxrcHCwtUSJEikSFs6cO3dO9c23335r38f+4hjM6ixbtkzNSzT4XciFu9dffz3RYzimuFjy/vvvq8cRERHWevXqKSGbmjYZhQiLDOSVV16xVq1a1WHf+PHj1cqJNvG9n2Pu57zuyK+//qr+EPCDqLFz584U/3HQmDBhglptcRYW3333nTrPrVu3rFkRTra4IjRv3jz7vpiYGLVy8tFHHyUpLAYNGqT6hkLBeUzd73ndkQYNGlh79erlsK9jx47W5s2bp/gc7Eta3CiM9cKCn+F///1XWeCio6OtWZ2UCgv+oeRqsb6/vvrqKyXouEqc0jZZjZQKC1dofaP/LHNSN2XKFPU5v379ujWrw89ZaoTFc889pwQdRax+nGnfd7SWTZ482WF/qVKlkl2UcWfuV1hwcYGTYP1nk8KCn2EKPm5cSMwuDB482Pr4448n+jwXTGjZ0Fs1uGDKBWXNIpGSNhmFBG9nIPv378djjz3msK9OnTrKH5P+nvd7zP2c1x3hfTI+olixYvZ9tWvXVjEWfC6l7NmzB2XLlk2w/80330T//v1RtGhRtG/fPoFPbVbwyY6JiXEYK4xToY9xcv03b948DBgwADVq1ECVKlWwa9eudDmvu5HYZy2l98kYgB9//BH9+vVTMRR66BfbvXt3tGjRQvnBf/fdd+l67e4K+7ZmzZoO/cU+py/x0aNHU9xGcPwOZAyZc3za+PHj1ee8VKlSaNasmfIBF2ysXLlSfW4ff/xx9ffjjz/+sHfNmTNnVIyj83cD22a178C0YrFYMHfuXPTs2VPFAejh39xnn30W7dq1U3EHkydPRlbHarWqeDNXcxINjqFKlSqpmBT99xuPZQxfSttkFCIsMjhYJ2/evA77tMd87n6PuZ/zuiOu7pNBXQzUTOl9Ll68GL/++iveffddh/2zZs1SwWMMRmMA8unTp9G3b19kJbQ+cjVWkuq/Pn36qL7hl9PVq1dVsF3Hjh3twXj3e153IzIyEhERES7vk33hHPzviuXLl6ugR05Q9FCEMbCWk+CLFy/iww8/VBO8P//8E9kd+Q5MX3777Tc1sRszZozDfo6527dvq885A5Apgil0UzKuszr8vrt27Zr6+8DvwGeeeUZNgLWFu+zyHZgebNy4ERcuXMDAgQMd9jPZwsGDB1WgPIXaggUL8NZbb2HZsmXIynz22WdqXPFes8p3oAiLDMTT01NNTvRwokK8vLzu+5j7Oa874uo+Cfel5D43bNiAF198UX2QW7Zs6fAcv+S01U5aRPhHd+3atWoVKiv1H3E1VpLqvx49eiAwMFD97uPjg2nTpqk/slu2bEnTed2NpO6TFpqUZCf79ttv0apVqwSZdp566imHLEYvv/yyyjizZMkSZHfkOzD92LlzJ7p27Yp33nlHfa71UOxyHBNmOpswYYJqT5GR3enSpYs9cw/HI/+G8Htg3bp19n3Z4TswPeB3IK2LztYdZn/SsuSRzp07q7/TXAzMqnz//fcYNWoU5s+frxaXssp3oAiLDIRpxZhWUg8fc0KSWLq2lBxzP+d1R3if169fh9lstu+jEueHJ7mUiL///rtadeIfy9dffz3Z19JS0l65cgVZqf+Iq7GSmpSS/APLLzHtPOl13ocdWsfoJufqPrU+SApaJGiBcF6pS2oMOr9WdiSx7zeija+UtMnu0H2RovaVV15R34Mp/Q6UMZgQb29vZSnPbt+BaYUWsV9++UW+AwEsXLhQuV7TekjLYFb6DhRhkYHQd5p+mcwnrsEPGfOQa/mug4ODsW3bNrvSTMkxKWmTFeCqLu9x06ZNDvfJSW7jxo3t+9h/ekHA9h06dFD+w4yjcEbfb3rrBv0/Wacgq8Cc1hSadAXToA81XR84hvQxE5pfOn3UWXNAz+bNm1VMRdWqVVN13qwA72fVqlV29xD6C/Ox/j7pHrF9+3aXK3WFChVS/sPJjUG6Vu3du9fex9kJ9gU/w6yHQti37Au6oOg/94wD0Kw8KWmT3UQE3U30MRUUFYMHD8bHH3+c4u9AWjBSWmckK8F6CnTLIfz+4/egHrquMB5A+3zmy5dPrTjrvwP5GeZCQlb7DkwJ7Bt+hvWLgNoKPRdoGF+R3Bjk6vtff/2VJb8Df4yLs2Mc3fPPP5/gedaTYf9RiBGOIbpn6+PF+P3GRT6tDkhK2mQYGRoqns1hBgTmWGcGmZ9//tn6zjvvWD08PKx//PGHvQ1TnvJt0WozpOSYlLTJKvTt21elnP3hhx9U6k/mZGf6RT3sP6Y7JTt27FCZEph95q+//nLYNJjNiBlqFixYoPqfWTyY5WjatGnWrAb7jWNj0qRJ1hUrVqh8+ExJp89ywnHUpk0b9fvZs2etNWvWVHVSfvvtN9UnzDbGNL+pPW9W4OTJkyr7C2tTMEtZz549Vb5wpk/UYCYsZtxxzhrDTGT/+9//XJ6X6T+Z2YgpaNmXzG9esmTJLJmdh+lP+fljDvsmTZqo35ndTWP//v3qM7x582b1mGlSmTGFG1Nqs3851pYsWWI/JiVtsgpHjx5Vfcb0lEx9rH2f6TPsMJf96NGj1e/MsMPvyaeeeirBdyDHJVm9erV6npnx1q9fbx0zZozVx8dH/cxqMEMO750pojnO+HeEjy9dumRv061bN2vdunXV70yryoxt/O5j38yaNUulB+X41fpPqyHA7ILMeMS/w3yeKY+Z9jMrwfvRxk+hQoWsAwcOVL/r0+rOnTtX9e2dO3ccjmWqd353uqJdu3Zq7sLvVdaQYv/lz5/feurUKWtW4pdfflHj5OWXX3b4LDINuQYzX7L/9LWgWPuC44n7pk+frv7GaOm1U9MmIzDwv4yVMtkbKnmuGHHFg5lfaJZu1KiRw0rTiBEjsGjRIrv5KrljUtomK8DVo88//xzr169Xq2l0b6I5Ue/f3rBhQwwfPlz5EtPcyMBsV3BFQB9QxrZc8eQqJ2Mx6tati6zI6tWrlfmVK8L0ax05cqSqIqtBVzH6ZH7yySd2F54vv/xSrYTQPeLpp59W/tnOMQXJnTerwH6gjzUrZXM1nPdZvnx5+/McR1yJ0lvW9u3bh2HDhilfWlcr6OyzL774Qlk6WLGc2c6GDBmSIGtKVoB+0wwM1kO3Eo4fwuQJ/PzNnDlT+WJr/TNp0iT1/ci2/My3bt3a4RwpaZMVoE+2q6B+Zm7TMsu0bdtWWWnpdsd+dWWlIGvWrFHVzwnHHj+/tHTwbw9XlZs2bYqsxk8//YQpU6Yk2M/Pm+aSQus2/xbMnj1bPWZCBY5HWjEYEMuMWRyjzhWhac396quv1Eozx+7bb7+trBlZCbrXdOvWLcF+ZsCaOnWq+p2xJxMnTlR/pzWvCcbq9OrVS7VhW2fopcG+27p1q/rbwgyE/M5MaVVqd2Hq1KlYsWJFgv2ct3FsEiZLYXIAuiw2adJE7eN3JsctP/vM/ERLB+c4elLSJiMQYSEIgiAIgiAIQpqRGAtBEARBEARBENKMCAtBEARBEARBENKMCAtBEARBEARBENKMCAtBEARBEARBENKMCAtBEARBEARBENKMCAtBEARBEARBENKMCAtBEARBEARBENKMCAtBEAThgbB37178/fffmdq7f/zxhyr6lhwsmMnifIIgCML945GGYwVBEIRsCCsQswJ5UrDy85w5c3Dr1i088cQTyAyOHDmiKkifOHEiRRWFWXWelbuNRllzEwRBuB9EWAiCIAipnrD/8ssv9sf8vVy5cqhcubJ9X8uWLfH4448jNDQ003p39OjRGDRoEHLmzJls2+eeew6jRo3CihUr0LVr1wy5PkEQhKyGwWq1WjP7IgRBEAT3pVChQhgyZAjefffdBK5QUVFRdovFzp07YTAYUKVKFezfvx93795F48aNERAQoH6n25S3tzcaNGgAHx8fl5aSM2fO4JFHHkHNmjWTtCzQ/alUqVLKvYk/Nc6dO4fDhw8jf/78qFWrFjw9Pe3PjRs3Dlu3bsWWLVvSqWcEQRCyF2KxEARBEB4Izq5Qn3/+OQ4dOoTg4GAlLjjpDwsLw0cffYTx48cri8exY8eUhWHHjh12cUHR0aVLFxw/fhyPPvqo+pk7d26sWrUKBQoUcPnaa9euRfHixR1EBV9jypQpaNSokTonX/unn36yt2nWrBkmTpyIkJCQFFk5BEEQBEdEWAiCIAgZxunTp/Hvv/+iTJkyyprBn8OHD1f7SpQogfDwcPVz6dKleOGFF9QxjH2gyOCxtDCYzWZ07twZb731FubNm+fydfbt2+fgmsXXomjYsGEDmjZtqvYx9iIiIsLeplq1aurcPFZrIwiCIKQcERaCIAhChtG8eXMlJgjdnujS5Ofnp8QE8ff3VxP8kydPqsfR0dFYtGiREh+M5aD3LrdixYopi0Vi0FJCq4YG3aa8vLyUxYTuV3xcoUIFh2Ny5cplP1YQBEFIPSIsBEEQhAxDP9nXxIWrfZGRker3a9euqd8Zk8H4CD0UCInBuA194DgtHT/88ANGjBiBCRMmqGN79OiBTp062dvcu3dP/QwMDEzjXQqCIGRPRFgIgiAIDy3aJJ/ZnfQiIDnKly+P5cuXO+x79tln1UZrCGMw+vbti0uXLmHYsGHq+bNnz6qfzpYMQRAEIWVIsm5BEAThoYXWjLp162L27NnKBcq59kRSLlfM/sRAbM0awaBxTXS89tpraNu2rcpUpcGsVKVLl3YI+BYEQRBSjlgsBEEQhIear776Ck899ZTamB2KAde///47KlasiKlTp7o8pn79+qhUqRKWLVuGAQMGKIHBbFAs3Fe1alWVjvbnn3/G999/bz9myZIlqq0gCIJwf4iwEARBENJEx44dVfpYZ5wL5HGy71x7omHDhgliGpo0aaJqVWgwxSyL8jEDFCtjswYFM0WxCF9SjBkzRmWC6t+/PwoXLow9e/Zg7ty52LZtG/LkyYNNmzahXr169hoZfA2mnxUEQRDuDymQJwiCIGRZ3njjDSUsXAkfPV9//bUSG7SICIIgCPeHCAtBEARBEARBENKMBG8LgiAIgiAIgpBmRFgIgiAIgiAIgpBmRFgIgiAIgiAIgpBmRFgIgiAIgiAIgpBmRFgIgiAIgiAIgpBmRFgIgiAIgiAIgpBmRFgIgiAIgiAIgpBmRFgIgiAIgiAIgpBmRFgIgiAIgiAIgpBmRFgIgiAIgiAIgpBmRFgIgiAIgiAIgoC08n/RionZ9vB1OwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\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", + "
modelspeed MAEfinal speed errorx3 MAEfinal x3 error
0current-speed: i_sd, Omega2.3735990.000073NaNNaN
1paper flux-speed: phi_rd, phi_rq, Omega2.3577640.0000600.0464995.696386e-08
2current-flux-speed: i_sd, phi_rq, Omega2.1544080.0000890.0497575.200329e-08
3four-state: i_sd, phi_rd, phi_rq, Omega2.2533760.0000640.0444161.235121e-07
\n", + "
" + ], + "text/plain": [ + " model speed MAE final speed error \\\n", + "0 current-speed: i_sd, Omega 2.373599 0.000073 \n", + "1 paper flux-speed: phi_rd, phi_rq, Omega 2.357764 0.000060 \n", + "2 current-flux-speed: i_sd, phi_rq, Omega 2.154408 0.000089 \n", + "3 four-state: i_sd, phi_rd, phi_rq, Omega 2.253376 0.000064 \n", + "\n", + " x3 MAE final x3 error \n", + "0 NaN NaN \n", + "1 0.046499 5.696386e-08 \n", + "2 0.049757 5.200329e-08 \n", + "3 0.044416 1.235121e-07 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "condition_name = \"25 percent rotor-resistance increase\"\n", + "condition_params_dict = default_motor_params_dict.copy()\n", + "condition_params_dict[Rr] = 1.25 * default_motor_params_dict[Rr]\n", + "motor_system.set_param_dict(condition_params_dict)\n", + "\n", + "condition_solution = solve_ode(motor_system, timepoints).T\n", + "condition_speed = condition_solution[4]\n", + "condition_x3 = condition_solution[3]\n", + "\n", + "rotor_resistance_summary = []\n", + "fig, axes = plt.subplots(2, 1, figsize=(8, 6.5), sharex=True)\n", + "\n", + "axes[0].plot(\n", + " timepoints,\n", + " condition_speed,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full model\",\n", + ")\n", + "axes[1].plot(\n", + " timepoints,\n", + " condition_x3,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full model\",\n", + ")\n", + "\n", + "for model_name, reduced_model in motor_reduced_models:\n", + " reduced_model.set_param_dict(condition_params_dict)\n", + " reduced_solution = solve_ode(reduced_model, timepoints).T\n", + " reduced_speed = np.ravel(np.asarray(reduced_model.C, dtype=float) @ reduced_solution)\n", + " speed_error = condition_speed - reduced_speed\n", + "\n", + " summary_row = {\n", + " \"model\": model_name,\n", + " \"speed MAE\": float(np.mean(np.abs(speed_error))),\n", + " \"final speed error\": float(abs(condition_speed[-1] - reduced_speed[-1])),\n", + " \"x3 MAE\": np.nan,\n", + " \"final x3 error\": np.nan,\n", + " }\n", + "\n", + " axes[0].plot(timepoints, reduced_speed, linewidth=2, label=model_name)\n", + "\n", + " if phi_rq in reduced_model.x:\n", + " reduced_x3 = reduced_solution[reduced_model.x.index(phi_rq)]\n", + " x3_error = condition_x3 - reduced_x3\n", + " summary_row[\"x3 MAE\"] = float(np.mean(np.abs(x3_error)))\n", + " summary_row[\"final x3 error\"] = float(abs(condition_x3[-1] - reduced_x3[-1]))\n", + " axes[1].plot(timepoints, reduced_x3, linewidth=2, label=model_name)\n", + "\n", + " rotor_resistance_summary.append(summary_row)\n", + "\n", + "axes[0].set_title(condition_name)\n", + "axes[0].set_ylabel(r\"$\\Omega$ (rad/s)\")\n", + "axes[0].grid(alpha=0.3)\n", + "axes[0].legend(fontsize=7)\n", + "axes[1].set_xlabel(\"Time (s)\")\n", + "axes[1].set_ylabel(r\"$x_3$, q-axis rotor flux\")\n", + "axes[1].grid(alpha=0.3)\n", + "axes[1].legend(fontsize=7)\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "display(pd.DataFrame(rotor_resistance_summary))" + ] + }, + { + "cell_type": "markdown", + "id": "4c94aade", + "metadata": {}, + "source": [ + "## Conclusion\n", + "The reduced models do not all respond to changed operating conditions in the same way. The current-flux-speed model is usually closest for rotor speed in this setup, while the paper's flux-speed model gives a compact third-order alternative with a direct physical interpretation. The ranking changes only modestly across the tested load, voltage, and rotor-resistance regimes, which suggests that the retained electromechanical coupling is more important than simply keeping the largest number of states.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "autoreduce", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/ecological/Viral spread.ipynb b/examples/ecological/Viral spread.ipynb new file mode 100644 index 0000000..17aa47f --- /dev/null +++ b/examples/ecological/Viral spread.ipynb @@ -0,0 +1,1307 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ae7cfbe0", + "metadata": {}, + "source": [ + "# Viral Spread\n", + "\n", + "This notebook uses AutoReduce to study models of viral spread at two levels of detail. We start with a three-state SIR model, then expand the same modeling idea into a six-state SEIRVD model with exposure, vaccination, and deaths. The goal is to show that a reduced model can be appropriate for one output and one parameter regime, but less appropriate after the ecological/population assumptions change. These can be explored using Autoreduce.\n" + ] + }, + { + "cell_type": "markdown", + "id": "326a3988", + "metadata": {}, + "source": [ + "## The SIR model\n", + "\n", + "The commonly used susceptible-infected-recovered model is\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\dot{S} &= -\\beta \\frac{SI}{N}, \\\\\n", + "\\dot{I} &= \\beta \\frac{SI}{N} - \\gamma I, \\\\\n", + "\\dot{R} &= \\gamma I.\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "The total population $N=S+I+R$ is conserved. This model is useful when the incubation period, vaccination, and mortality are not the focus of the question.\n", + "\n", + "Let us create the model in AutoReduce directly by writing a Sympy ODE:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "577dfcaf", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from IPython.display import display, Math\n", + "from sympy import latex\n", + "\n", + "from autoreduce import (\n", + " System,\n", + " load_ode_model,\n", + " solve_ode,\n", + " solve_sensitivity,\n", + " solve_timescale_separation,\n", + ")\n", + "\n", + "sir_states, sir_rhs, sir_params = load_ode_model(3, 3)\n", + "S, I, R = sir_states\n", + "beta, gamma, N = sir_params\n", + "\n", + "sir_rhs[0] = -beta * S * I / N\n", + "sir_rhs[1] = beta * S * I / N - gamma * I\n", + "sir_rhs[2] = gamma * I\n", + "\n", + "sir_population = 1000.0\n", + "sir_params_values = np.array([0.30, 0.08, sir_population])\n", + "sir_params_dict = dict(zip(sir_params, sir_params_values))\n", + "sir_x_init = np.array([990.0, 10.0, 0.0])\n", + "sir_C = np.eye(3).tolist()\n", + "\n", + "sir_system = System(\n", + " sir_states,\n", + " sir_rhs,\n", + " params_dict=sir_params_dict,\n", + " C=sir_C,\n", + " x_init=sir_x_init,\n", + ")\n", + "\n", + "sir_timepoints = np.linspace(0.0, 160.0, 161)\n", + "sir_solution = solve_ode(sir_system, sir_timepoints).T" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "808b806d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(7, 4))\n", + "\n", + "for label, trajectory in zip(\n", + " [\"susceptible\", \"infected\", \"recovered\"],\n", + " sir_solution,\n", + "):\n", + " ax.plot(sir_timepoints, trajectory, linewidth=2, label=label)\n", + "\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_ylabel(\"Population\")\n", + "ax.set_title(\"SIR viral spread dynamics\")\n", + "ax.grid(alpha=0.3)\n", + "ax.legend()\n", + "fig.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "1755ca6c", + "metadata": {}, + "source": [ + "## Add exposure, vaccination, and deaths\n", + "\n", + "The SEIRVD model expands the SIR model by distinguishing people who have been exposed but are not yet infectious, people who leave the susceptible population through vaccination, and cumulative deaths.\n", + "\n", + "$$\n", + "S=\\text{susceptible},\\quad\n", + "E=\\text{exposed},\\quad\n", + "I=\\text{infected},\\quad\n", + "R=\\text{recovered},\\quad\n", + "V=\\text{vaccinated},\\quad\n", + "D=\\text{deceased}.\n", + "$$\n", + "\n", + "The state vector and parameter vector are\n", + "\n", + "$$\n", + "x =\n", + "\\begin{bmatrix}\n", + "S & E & I & R & V & D\n", + "\\end{bmatrix}^{T},\n", + "\\qquad\n", + "\\Theta =\n", + "\\begin{bmatrix}\n", + "\\beta & \\sigma & \\gamma & \\nu & \\mu & N\n", + "\\end{bmatrix}^{T}.\n", + "$$\n", + "\n", + "The governing equations are\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\dot{S} &= -\\frac{\\beta S I}{N} - \\nu S, \\\\\n", + "\\dot{E} &= \\frac{\\beta S I}{N} - \\sigma E, \\\\\n", + "\\dot{I} &= \\sigma E - \\gamma I - \\mu I, \\\\\n", + "\\dot{R} &= \\gamma I, \\\\\n", + "\\dot{V} &= \\nu S, \\\\\n", + "\\dot{D} &= \\mu I.\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "The infected population is the first output we ask the reduced models to preserve:\n", + "\n", + "$$\n", + "y=I.\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f13c265a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x0: susceptible\n", + "x1: exposed\n", + "x2: infected\n", + "x3: recovered\n", + "x4: vaccinated\n", + "x5: deceased\n" + ] + } + ], + "source": [ + "seirvd_states, seirvd_rhs, seirvd_params = load_ode_model(6, 6)\n", + "S, E, I, R, V, D = seirvd_states\n", + "beta, sigma, gamma, nu, mu, N = seirvd_params\n", + "\n", + "seirvd_rhs[0] = -beta * S * I / N - nu * S\n", + "seirvd_rhs[1] = beta * S * I / N - sigma * E\n", + "seirvd_rhs[2] = sigma * E - gamma * I - mu * I\n", + "seirvd_rhs[3] = gamma * I\n", + "seirvd_rhs[4] = nu * S\n", + "seirvd_rhs[5] = mu * I\n", + "\n", + "seirvd_params_values = np.array([\n", + " 0.35, # beta: transmission rate\n", + " 0.20, # sigma: exposed-to-infected rate\n", + " 0.10, # gamma: recovery rate\n", + " 0.01, # nu: vaccination rate\n", + " 0.005, # mu: mortality rate\n", + " 1000.0, # N: total population scale\n", + "])\n", + "seirvd_params_dict = dict(zip(seirvd_params, seirvd_params_values))\n", + "\n", + "seirvd_x_init = np.array([990.0, 9.0, 1.0, 0.0, 0.0, 0.0])\n", + "seirvd_C = np.zeros((1, len(seirvd_states)), dtype=int)\n", + "seirvd_C[0, 2] = 1\n", + "\n", + "seirvd_system = System(\n", + " seirvd_states,\n", + " seirvd_rhs,\n", + " params_dict=seirvd_params_dict,\n", + " C=seirvd_C.tolist(),\n", + " x_init=seirvd_x_init,\n", + ")\n", + "\n", + "for state, label in zip(\n", + " seirvd_states,\n", + " [\"susceptible\", \"exposed\", \"infected\", \"recovered\", \"vaccinated\", \"deceased\"],\n", + "):\n", + " print(f\"{state}: {label}\")" + ] + }, + { + "cell_type": "markdown", + "id": "a9d61afa", + "metadata": {}, + "source": [ + "## Simulate the baseline SEIRVD model\n", + "\n", + "The baseline parameter set has moderate transmission, a visible incubation period, slow vaccination, and low mortality. Plotting every state makes the compartment structure visible before any reduction is attempted.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "33491ade", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "seirvd_timepoints = np.linspace(0.0, 120.0, 121)\n", + "seirvd_solution = solve_ode(seirvd_system, seirvd_timepoints).T\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 4.5))\n", + "\n", + "for label, trajectory in zip(\n", + " [\"S\", \"E\", \"I\", \"R\", \"V\", \"D\"],\n", + " seirvd_solution,\n", + "):\n", + " ax.plot(seirvd_timepoints, trajectory, linewidth=2, label=label)\n", + "\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_ylabel(\"Population\")\n", + "ax.set_title(\"SEIRVD baseline dynamics\")\n", + "ax.grid(alpha=0.3)\n", + "ax.legend(ncol=3)\n", + "fig.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "608e8874", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'peak infected': 110.7496234300063,\n", + " 'time of infected peak': 49.0,\n", + " 'final susceptible': 44.60254674683289,\n", + " 'final vaccinated': 382.9135942777893,\n", + " 'final deceased': 27.14162836007647}" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "infected_baseline = seirvd_solution[2]\n", + "\n", + "baseline_summary = {\n", + " \"peak infected\": float(infected_baseline.max()),\n", + " \"time of infected peak\": float(seirvd_timepoints[infected_baseline.argmax()]),\n", + " \"final susceptible\": float(seirvd_solution[0, -1]),\n", + " \"final vaccinated\": float(seirvd_solution[4, -1]),\n", + " \"final deceased\": float(seirvd_solution[5, -1]),\n", + "}\n", + "\n", + "baseline_summary\n" + ] + }, + { + "cell_type": "markdown", + "id": "309501b2", + "metadata": {}, + "source": [ + "## Local sensitivity of the infected output\n", + "\n", + "AutoReduce can also compute local sensitivities. Here we look at the normalized sensitivity of the infected state $I$ with respect to each SEIRVD parameter. This helps identify which biological rates matter most for the output before selecting reduced models.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c0e13005", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sensitivity_timepoints = np.linspace(1.0, 120.0, 8)\n", + "normalized_sensitivity = solve_sensitivity(\n", + " seirvd_system,\n", + " sensitivity_timepoints,\n", + " normalize=True,\n", + ")\n", + "\n", + "infected_sensitivity = normalized_sensitivity[:, :, 2]\n", + "sensitivity_scale = np.max(np.abs(infected_sensitivity))\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 3.8))\n", + "image = ax.imshow(\n", + " infected_sensitivity.T,\n", + " aspect=\"auto\",\n", + " cmap=\"coolwarm\",\n", + " vmin=-sensitivity_scale,\n", + " vmax=sensitivity_scale,\n", + ")\n", + "\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_ylabel(\"Parameter\")\n", + "ax.set_title(\"Normalized sensitivity of infected population\")\n", + "ax.set_xticks(range(len(sensitivity_timepoints)))\n", + "ax.set_xticklabels([f\"{t:.0f}\" for t in sensitivity_timepoints])\n", + "ax.set_yticks(range(len(seirvd_params)))\n", + "ax.set_yticklabels([r\"$\\beta$\", r\"$\\sigma$\", r\"$\\gamma$\", r\"$\\nu$\", r\"$\\mu$\", r\"$N$\"])\n", + "fig.colorbar(image, ax=ax, label=\"normalized sensitivity\")\n", + "fig.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "1da96ed6", + "metadata": {}, + "source": [ + "## Reduce the SEIRVD model with visible state choices\n", + "\n", + "The reductions below are chosen deliberately rather than generated through a large helper routine. The first model keeps the transmission core $(S,E,I)$ and removes cumulative states that do not feed back into infection. The second model keeps $(S,I,R,V,D)$ and collapses the exposed state, which is a stronger biological assumption because it removes the incubation stage.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fd0b1704", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Successful solution obtained with states: [x0, x1, x2]!\n", + "Successful solution obtained with states: [x0, x2, x3, x4, x5]!\n" + ] + } + ], + "source": [ + "reduction_timepoints_ode = np.linspace(0.0, 120.0, 121)\n", + "reduction_timepoints_ssm = np.linspace(0.0, 120.0, 6)\n", + "\n", + "seirvd_core, core_fast_subsystem = solve_timescale_separation(\n", + " seirvd_system,\n", + " [S, E, I],\n", + " timepoints_ode=reduction_timepoints_ode,\n", + " timepoints_ssm=reduction_timepoints_ssm,\n", + ")\n", + "\n", + "seirvd_direct_infection, direct_fast_subsystem = solve_timescale_separation(\n", + " seirvd_system,\n", + " [S, I, R, V, D],\n", + " timepoints_ode=reduction_timepoints_ode,\n", + " timepoints_ssm=reduction_timepoints_ssm,\n", + ")\n", + "\n", + "seirvd_core.C = [[1 if state == I else 0 for state in seirvd_core.x]]\n", + "seirvd_direct_infection.C = [[1 if state == I else 0 for state in seirvd_direct_infection.x]]\n", + "\n", + "seirvd_reduced_models = [\n", + " (\"transmission core: S, E, I\", seirvd_core),\n", + " (\"direct infection: S, I, R, V, D\", seirvd_direct_infection),\n", + "]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "adf1cb9e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\text{Full SEIRVD system: } \\left[ - \\frac{P_{0} x_{0} x_{2}}{P_{5}} - P_{3} x_{0}, \\ \\frac{P_{0} x_{0} x_{2}}{P_{5}} - P_{1} x_{1}, \\ P_{1} x_{1} - P_{2} x_{2} - P_{4} x_{2}, \\ P_{2} x_{2}, \\ P_{3} x_{0}, \\ P_{4} x_{2}\\right]$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "transmission core: S, E, I\n", + "retained states: [x0, x1, x2]\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle \\text{reduced equations: } \\left[ \\frac{x_{0} \\left(- P_{0} x_{2} - P_{3} P_{5}\\right)}{P_{5}}, \\ \\frac{P_{0} x_{0} x_{2}}{P_{5}} - P_{1} x_{1}, \\ P_{1} x_{1} - P_{2} x_{2} - P_{4} x_{2}\\right]$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "direct infection: S, I, R, V, D\n", + "retained states: [x0, x2, x3, x4, x5]\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle \\text{reduced equations: } \\left[ \\frac{x_{0} \\left(- P_{0} x_{2} - P_{3} P_{5}\\right)}{P_{5}}, \\ \\frac{x_{2} \\left(P_{0} x_{0} - P_{5} \\left(P_{2} + P_{4}\\right)\\right)}{P_{5}}, \\ P_{2} x_{2}, \\ P_{3} x_{0}, \\ P_{4} x_{2}\\right]$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "display(Math(r\"\\text{Full SEIRVD system: } \" + latex(seirvd_rhs)))\n", + "\n", + "for model_name, reduced_model in seirvd_reduced_models:\n", + " print(model_name)\n", + " print(\"retained states:\", reduced_model.x)\n", + " display(Math(r\"\\text{reduced equations: } \" + latex(reduced_model.f)))\n", + " print()\n" + ] + }, + { + "cell_type": "markdown", + "id": "eaec70f1", + "metadata": {}, + "source": [ + "## Compare reduced infected trajectories\n", + "\n", + "Because the output is $I$, a model can discard states such as $R$, $V$, and $D$ without hurting this particular comparison if those states do not feed back into infection. Collapsing the exposed state is different: it changes how quickly infection responds to contact between susceptible and infected populations.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "bd20a289", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\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", + "
modelMAERMSEpeak error
0transmission core: S, E, I2.520298e-093.152292e-093.119496e-09
1direct infection: S, I, R, V, D2.833681e+014.019003e+017.304719e+01
\n", + "
" + ], + "text/plain": [ + " model MAE RMSE peak error\n", + "0 transmission core: S, E, I 2.520298e-09 3.152292e-09 3.119496e-09\n", + "1 direct infection: S, I, R, V, D 2.833681e+01 4.019003e+01 7.304719e+01" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "full_solution_for_reduction = solve_ode(seirvd_system, reduction_timepoints_ode).T\n", + "full_infected = full_solution_for_reduction[2]\n", + "\n", + "reduction_summary = []\n", + "fig, ax = plt.subplots(figsize=(8, 4.5))\n", + "ax.plot(\n", + " reduction_timepoints_ode,\n", + " full_infected,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full SEIRVD model\",\n", + ")\n", + "\n", + "for model_name, reduced_model in seirvd_reduced_models:\n", + " reduced_solution = solve_ode(reduced_model, reduction_timepoints_ode).T\n", + " reduced_infected = np.ravel(np.asarray(reduced_model.C, dtype=float) @ reduced_solution)\n", + " error = full_infected - reduced_infected\n", + "\n", + " reduction_summary.append({\n", + " \"model\": model_name,\n", + " \"MAE\": float(np.mean(np.abs(error))),\n", + " \"RMSE\": float(np.sqrt(np.mean(error**2))),\n", + " \"peak error\": float(abs(full_infected.max() - reduced_infected.max())),\n", + " })\n", + "\n", + " ax.plot(\n", + " reduction_timepoints_ode,\n", + " reduced_infected,\n", + " linewidth=2,\n", + " label=model_name,\n", + " )\n", + "\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_ylabel(\"Infected population\")\n", + "ax.set_title(\"Full and reduced infected trajectories\")\n", + "ax.grid(alpha=0.3)\n", + "ax.legend()\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "display(pd.DataFrame(reduction_summary))" + ] + }, + { + "cell_type": "markdown", + "id": "d6156b8c", + "metadata": {}, + "source": [ + "## Change the parameter regime\n", + "\n", + "The same reduced-state choices can behave differently when the biological regime changes. The cells below compare the full SEIRVD model with the two reduced models under higher transmission, faster vaccination, shorter incubation, and higher mortality.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a6c9fa3e", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "default_seirvd_params_dict = seirvd_system.params_dict.copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e5559d48", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\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", + "
modelpeak infectedMAEpeak error
0transmission core: S, E, I110.7496232.520298e-093.119496e-09
1direct infection: S, I, R, V, D110.7496232.833681e+017.304719e+01
\n", + "
" + ], + "text/plain": [ + " model peak infected MAE peak error\n", + "0 transmission core: S, E, I 110.749623 2.520298e-09 3.119496e-09\n", + "1 direct infection: S, I, R, V, D 110.749623 2.833681e+01 7.304719e+01" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "scenario_name = \"baseline\"\n", + "scenario_params_dict = default_seirvd_params_dict.copy()\n", + "seirvd_system.set_param_dict(scenario_params_dict)\n", + "\n", + "scenario_solution = solve_ode(seirvd_system, reduction_timepoints_ode).T\n", + "scenario_infected = scenario_solution[2]\n", + "\n", + "baseline_scenario_summary = []\n", + "fig, ax = plt.subplots(figsize=(8, 4.5))\n", + "ax.plot(\n", + " reduction_timepoints_ode,\n", + " scenario_infected,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full model\",\n", + ")\n", + "\n", + "for model_name, reduced_model in seirvd_reduced_models:\n", + " reduced_model.set_param_dict(scenario_params_dict)\n", + " reduced_solution = solve_ode(reduced_model, reduction_timepoints_ode).T\n", + " reduced_infected = np.ravel(np.asarray(reduced_model.C, dtype=float) @ reduced_solution)\n", + " error = scenario_infected - reduced_infected\n", + "\n", + " baseline_scenario_summary.append({\n", + " \"model\": model_name,\n", + " \"peak infected\": float(scenario_infected.max()),\n", + " \"MAE\": float(np.mean(np.abs(error))),\n", + " \"peak error\": float(abs(scenario_infected.max() - reduced_infected.max())),\n", + " })\n", + "\n", + " ax.plot(\n", + " reduction_timepoints_ode,\n", + " reduced_infected,\n", + " linewidth=2,\n", + " label=model_name,\n", + " )\n", + "\n", + "ax.set_title(scenario_name)\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_ylabel(\"Infected\")\n", + "ax.grid(alpha=0.3)\n", + "ax.legend(fontsize=8)\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "display(pd.DataFrame(baseline_scenario_summary))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "4f1a4628", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\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", + "
modelpeak infectedMAEpeak error
0transmission core: S, E, I214.6961635.139220e-070.000003
1direct infection: S, I, R, V, D214.6961635.629713e+01162.269047
\n", + "
" + ], + "text/plain": [ + " model peak infected MAE peak error\n", + "0 transmission core: S, E, I 214.696163 5.139220e-07 0.000003\n", + "1 direct infection: S, I, R, V, D 214.696163 5.629713e+01 162.269047" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "scenario_name = \"higher transmission\"\n", + "scenario_params_dict = default_seirvd_params_dict.copy()\n", + "scenario_params_dict[beta] = 0.55\n", + "seirvd_system.set_param_dict(scenario_params_dict)\n", + "\n", + "scenario_solution = solve_ode(seirvd_system, reduction_timepoints_ode).T\n", + "scenario_infected = scenario_solution[2]\n", + "\n", + "higher_transmission_summary = []\n", + "fig, ax = plt.subplots(figsize=(8, 4.5))\n", + "ax.plot(\n", + " reduction_timepoints_ode,\n", + " scenario_infected,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full model\",\n", + ")\n", + "\n", + "for model_name, reduced_model in seirvd_reduced_models:\n", + " reduced_model.set_param_dict(scenario_params_dict)\n", + " reduced_solution = solve_ode(reduced_model, reduction_timepoints_ode).T\n", + " reduced_infected = np.ravel(np.asarray(reduced_model.C, dtype=float) @ reduced_solution)\n", + " error = scenario_infected - reduced_infected\n", + "\n", + " higher_transmission_summary.append({\n", + " \"model\": model_name,\n", + " \"peak infected\": float(scenario_infected.max()),\n", + " \"MAE\": float(np.mean(np.abs(error))),\n", + " \"peak error\": float(abs(scenario_infected.max() - reduced_infected.max())),\n", + " })\n", + "\n", + " ax.plot(\n", + " reduction_timepoints_ode,\n", + " reduced_infected,\n", + " linewidth=2,\n", + " label=model_name,\n", + " )\n", + "\n", + "ax.set_title(scenario_name)\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_ylabel(\"Infected\")\n", + "ax.grid(alpha=0.3)\n", + "ax.legend(fontsize=8)\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "display(pd.DataFrame(higher_transmission_summary))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c3caee67", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\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", + "
modelpeak infectedMAEpeak error
0transmission core: S, E, I21.8071521.837548e-084.654848e-08
1direct infection: S, I, R, V, D21.8071523.197234e+005.816338e+00
\n", + "
" + ], + "text/plain": [ + " model peak infected MAE peak error\n", + "0 transmission core: S, E, I 21.807152 1.837548e-08 4.654848e-08\n", + "1 direct infection: S, I, R, V, D 21.807152 3.197234e+00 5.816338e+00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "scenario_name = \"faster vaccination\"\n", + "scenario_params_dict = default_seirvd_params_dict.copy()\n", + "scenario_params_dict[nu] = 0.04\n", + "seirvd_system.set_param_dict(scenario_params_dict)\n", + "\n", + "scenario_solution = solve_ode(seirvd_system, reduction_timepoints_ode).T\n", + "scenario_infected = scenario_solution[2]\n", + "\n", + "faster_vaccination_summary = []\n", + "fig, ax = plt.subplots(figsize=(8, 4.5))\n", + "ax.plot(\n", + " reduction_timepoints_ode,\n", + " scenario_infected,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full model\",\n", + ")\n", + "\n", + "for model_name, reduced_model in seirvd_reduced_models:\n", + " reduced_model.set_param_dict(scenario_params_dict)\n", + " reduced_solution = solve_ode(reduced_model, reduction_timepoints_ode).T\n", + " reduced_infected = np.ravel(np.asarray(reduced_model.C, dtype=float) @ reduced_solution)\n", + " error = scenario_infected - reduced_infected\n", + "\n", + " faster_vaccination_summary.append({\n", + " \"model\": model_name,\n", + " \"peak infected\": float(scenario_infected.max()),\n", + " \"MAE\": float(np.mean(np.abs(error))),\n", + " \"peak error\": float(abs(scenario_infected.max() - reduced_infected.max())),\n", + " })\n", + "\n", + " ax.plot(\n", + " reduction_timepoints_ode,\n", + " reduced_infected,\n", + " linewidth=2,\n", + " label=model_name,\n", + " )\n", + "\n", + "ax.set_title(scenario_name)\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_ylabel(\"Infected\")\n", + "ax.grid(alpha=0.3)\n", + "ax.legend(fontsize=8)\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "display(pd.DataFrame(faster_vaccination_summary))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "15b2a7cc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\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", + "
modelpeak infectedMAEpeak error
0transmission core: S, E, I171.1657821.345300e-099.221424e-10
1direct infection: S, I, R, V, D171.1657825.422404e+001.263104e+01
\n", + "
" + ], + "text/plain": [ + " model peak infected MAE peak error\n", + "0 transmission core: S, E, I 171.165782 1.345300e-09 9.221424e-10\n", + "1 direct infection: S, I, R, V, D 171.165782 5.422404e+00 1.263104e+01" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "scenario_name = \"shorter incubation\"\n", + "scenario_params_dict = default_seirvd_params_dict.copy()\n", + "scenario_params_dict[sigma] = 0.50\n", + "seirvd_system.set_param_dict(scenario_params_dict)\n", + "\n", + "scenario_solution = solve_ode(seirvd_system, reduction_timepoints_ode).T\n", + "scenario_infected = scenario_solution[2]\n", + "\n", + "shorter_incubation_summary = []\n", + "fig, ax = plt.subplots(figsize=(8, 4.5))\n", + "ax.plot(\n", + " reduction_timepoints_ode,\n", + " scenario_infected,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full model\",\n", + ")\n", + "\n", + "for model_name, reduced_model in seirvd_reduced_models:\n", + " reduced_model.set_param_dict(scenario_params_dict)\n", + " reduced_solution = solve_ode(reduced_model, reduction_timepoints_ode).T\n", + " reduced_infected = np.ravel(np.asarray(reduced_model.C, dtype=float) @ reduced_solution)\n", + " error = scenario_infected - reduced_infected\n", + "\n", + " shorter_incubation_summary.append({\n", + " \"model\": model_name,\n", + " \"peak infected\": float(scenario_infected.max()),\n", + " \"MAE\": float(np.mean(np.abs(error))),\n", + " \"peak error\": float(abs(scenario_infected.max() - reduced_infected.max())),\n", + " })\n", + "\n", + " ax.plot(\n", + " reduction_timepoints_ode,\n", + " reduced_infected,\n", + " linewidth=2,\n", + " label=model_name,\n", + " )\n", + "\n", + "ax.set_title(scenario_name)\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_ylabel(\"Infected\")\n", + "ax.grid(alpha=0.3)\n", + "ax.legend(fontsize=8)\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "display(pd.DataFrame(shorter_incubation_summary))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "4e7111ca", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\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", + "
modelpeak infectedMAEpeak error
0transmission core: S, E, I68.4110381.336092e-092.387722e-09
1direct infection: S, I, R, V, D68.4110381.816707e+015.048887e+01
\n", + "
" + ], + "text/plain": [ + " model peak infected MAE peak error\n", + "0 transmission core: S, E, I 68.411038 1.336092e-09 2.387722e-09\n", + "1 direct infection: S, I, R, V, D 68.411038 1.816707e+01 5.048887e+01" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "scenario_name = \"higher mortality\"\n", + "scenario_params_dict = default_seirvd_params_dict.copy()\n", + "scenario_params_dict[mu] = 0.03\n", + "seirvd_system.set_param_dict(scenario_params_dict)\n", + "\n", + "scenario_solution = solve_ode(seirvd_system, reduction_timepoints_ode).T\n", + "scenario_infected = scenario_solution[2]\n", + "\n", + "higher_mortality_summary = []\n", + "fig, ax = plt.subplots(figsize=(8, 4.5))\n", + "ax.plot(\n", + " reduction_timepoints_ode,\n", + " scenario_infected,\n", + " linestyle=\":\",\n", + " linewidth=3,\n", + " color=\"black\",\n", + " label=\"full model\",\n", + ")\n", + "\n", + "for model_name, reduced_model in seirvd_reduced_models:\n", + " reduced_model.set_param_dict(scenario_params_dict)\n", + " reduced_solution = solve_ode(reduced_model, reduction_timepoints_ode).T\n", + " reduced_infected = np.ravel(np.asarray(reduced_model.C, dtype=float) @ reduced_solution)\n", + " error = scenario_infected - reduced_infected\n", + "\n", + " higher_mortality_summary.append({\n", + " \"model\": model_name,\n", + " \"peak infected\": float(scenario_infected.max()),\n", + " \"MAE\": float(np.mean(np.abs(error))),\n", + " \"peak error\": float(abs(scenario_infected.max() - reduced_infected.max())),\n", + " })\n", + "\n", + " ax.plot(\n", + " reduction_timepoints_ode,\n", + " reduced_infected,\n", + " linewidth=2,\n", + " label=model_name,\n", + " )\n", + "\n", + "ax.set_title(scenario_name)\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_ylabel(\"Infected\")\n", + "ax.grid(alpha=0.3)\n", + "ax.legend(fontsize=8)\n", + "fig.tight_layout()\n", + "plt.show()\n", + "\n", + "display(pd.DataFrame(higher_mortality_summary))" + ] + }, + { + "cell_type": "markdown", + "id": "99934988", + "metadata": {}, + "source": [ + "\n", + "The comparisons show that reduced-model quality depends on the output and on the regime being studied. The $(S,E,I)$ transmission-core model preserves the infected trajectory very closely because $R$, $V$, and $D$ are cumulative states that do not feed back into infection in this model. The direct-infection reduction is more aggressive because it collapses the exposed state, so its error changes with transmission, incubation, vaccination, and mortality rates.\n", + "\n", + "This is the main modeling lesson: there is not one reduced viral-spread model that is best for every question. AutoReduce helps expose which state choices are compatible with the output and parameter regime that matter for the analysis.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "cc1f5559", + "metadata": {}, + "outputs": [], + "source": [ + "# end" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "autoreduce", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/gene expression analysis.ipynb b/examples/gene expression analysis.ipynb deleted file mode 100644 index 4f3a994..0000000 --- a/examples/gene expression analysis.ipynb +++ /dev/null @@ -1,555 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For full version of this notebook, check `IJRNC examples/`" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "$G_i + P \\quad[k^{b_P}_i]<->[k^{u_P}_i] \\quad G_i:P \\\\\n", - "G_i:P \\quad --> [k_i^{tx}] \\quad G_i + P + T_i \\\\\n", - "T_i + R \\quad [k^{b_R}_i]<->[k^{u_R}_i]\\quad T_i:R \\\\\n", - "T_i:R \\quad -->[k_i^{tl}]\\quad T_i + R + X_i \\\\\n", - "T_i + E \\quad [k^{b_E}_i]<->[k^{u_E}_i] \\quad T_i:E \\\\\n", - "T_i:E \\quad-->[\\delta_i]\\quad E \\\\\n", - "T \\quad-->[d_T]\\quad \\\\\n", - "X \\quad-->[d]\\quad $" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "from IPython.core.interactiveshell import InteractiveShell\n", - "InteractiveShell.ast_node_interactivity = \"all\"\n", - "from autoreduce import *\n", - "import numpy as np\n", - "from sympy import symbols" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Post conservation law and other approximations phenomenological model at the RNA level\n", - "n = 8 # Number of states : P, C1, T, R, C2, E, C3, X\n", - "nouts = 1 # Number of outputs, X_i\n", - "\n", - "# Inputs by user \n", - "x_init = np.zeros(n)\n", - "x_init[0] = 100\n", - "x_init[3] = 400\n", - "x_init[5] = 20\n", - "C = np.zeros((nouts,n), dtype=int)\n", - "C[0][7] = 1\n", - "\n", - "nstates_tol_max = 3\n", - "nsatees_tol_min = 2\n", - "error_tol = 3000\n", - "# System dynamics symbolically\n", - "\n", - "# k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d = params, len(params) = 10\n", - "\n", - "\n", - "x0 = symbols('P')\n", - "x1 = symbols('C1') # G:P\n", - "x2 = symbols('T')\n", - "x3 = symbols('R')\n", - "x4 = symbols('C2') # T:R\n", - "x5 = symbols('E')\n", - "x6 = symbols('C3') # T:E\n", - "x7 = symbols('X')\n", - "\n", - "x = [x0, x1, x2, x3, x4, x5, x6, x7]\n", - "\n", - "G = symbols('G')\n", - "k_bp = symbols('k_bp')\n", - "k_up = symbols('k_up')\n", - "k_tx = symbols('k_tx')\n", - "k_br = symbols('k_br')\n", - "k_ur = symbols('k_ur')\n", - "k_tl = symbols('k_tl')\n", - "k_be = symbols('k_be')\n", - "k_ue = symbols('k_ue')\n", - "d_i = symbols('d_i')\n", - "d = symbols('d')\n", - "d_T = symbols('d_T')\n", - "\n", - "E_tot = symbols('E_tot')\n", - "P_tot = symbols('P_tot')\n", - "R_tot = symbols('R_tot')\n", - "params = [k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d, d_T, E_tot, P_tot, R_tot, G]\n", - "# f0 = (k_bp + k_tx) * x1 - k_up * G * x0\n", - "f0 = (k_up + k_tx) * x1 - k_bp * G * x0\n", - "f1 = k_bp * G * x0 - (k_up + k_tx)*x1\n", - "f2 = k_tx * x1 + (k_ur + k_tl) * x4 + k_ue * x6 - k_br * x2 * x3 - k_be * x2 * x5 - d_T * x2\n", - "f3 = (k_ur + k_tl) * x4 - k_br * x2 * x3\n", - "f4 = k_br * x2 * x3 - (k_ur + k_tl) * x4\n", - "f5 = (k_ue + d_i) * x6 - k_be * x2 * x5\n", - "f6 = k_be * x2 * x5 - (k_ue + d_i) * x6\n", - "f7 = k_tl * x4 - d * x7\n", - " \n", - "f = [f0,f1,f2,f3,f4,f5,f6,f7]\n", - "# parameter values\n", - "# E_tot = 20\n", - "# P_tot = 100\n", - "# R_tot = 400\n", - "params_values = [80, 2, 0.50, 80, 2, 0.5, 10, 2, 0.1, 0.5, 0.01, 100, 100, 400, 10]\n", - "# params_values = [100, 10, 4, 10, 0.25, 2, 10, 0.5, 1, 1, 1000, 1000, 1000, 10]\n", - "sys = System(x, f, params = params, params_values = params_values, C = C, x_init = x_init)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Time')" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, '[Outputs]')" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from autoreduce.utils import get_ODE\n", - "timepoints_ode = np.linspace(0, 24, 100)\n", - "sys_ode = get_ODE(sys, timepoints_ode)\n", - "sol = sys_ode.solve_system().T\n", - "try:\n", - " import matplotlib.pyplot as plt\n", - " plt.plot(timepoints_ode, np.transpose(np.array(C)@sol));\n", - " plt.xlabel('Time');\n", - " plt.ylabel('[Outputs]');\n", - " plt.show();\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "from autoreduce.utils import get_reducible\n", - "timepoints_ssm = np.linspace(0,2,10)\n", - "timepoints_ode = np.linspace(0,2,100)\n", - "sys_reduce = get_reducible(sys, timepoints_ode, timepoints_ssm)\n", - "sys_reduce.nstates_tol_min = 2\n", - "sys_reduce.nstates_tol_max = 3" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "P, C1, T, R, C2, E, C3, X = sys.x\n", - "conserved_quantities = [P + C1 - P_tot, R + C2 - R_tot, E + C3 - E_tot]\n", - "states_to_eliminate = [C1, C2, C3]\n", - "f_cons = sys_reduce.set_conservation_laws(conserved_quantities, states_to_eliminate)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[-G*P*k_bp + (-P + P_tot)*(k_tx + k_up),\n", - " -E*T*k_be - R*T*k_br - T*d_T + k_tx*(-P + P_tot) + k_ue*(-E + E_tot) + (-R + R_tot)*(k_tl + k_ur),\n", - " -R*T*k_br + (-R + R_tot)*(k_tl + k_ur),\n", - " -E*T*k_be + (-E + E_tot)*(d_i + k_ue),\n", - " -X*d + k_tl*(-R + R_tot)]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "f_cons" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Time')" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, '[X]')" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAESCAYAAAArJ3joAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAnJUlEQVR4nO3deXxU5b3H8c8veyBhDTGsAqKs4kLQasWqFcW9rW2teq32aq3XXqvW64oLWsW1irV6W6xVW+tyq7WiuAAu1aqIgLJJQBYBDRDCEghJyDLP/eNMJpNhyTpzJjPf9+s1r8lzzjOT32FCvjnnPOc55pxDREQkmlL8LkBERBKfwkZERKJOYSMiIlGnsBERkahT2IiISNSl+V2An/Ly8tzAgQP9LkNEpEOZN29eqXOuV0tek9RhM3DgQObOnet3GSIiHYqZrWnpa3QYTUREok5hIyIiUaewERGRqFPYiIhI1ClsREQk6uImbMzsJjNzZvb7sGVmZpPMrNjMKs3sPTMbGfG6TDN7xMxKzWynmU0zs36x3wIREdmbuBj6bGbfAn4OLIxYdR1wDXARsAy4FZhpZkOdczuCfaYAZwHnApuBB4HXzGyMc64u+tWLSLxwzuEc1DlHoP7rgPd1wHnrA45g21tf/+yAQMCbBb/ROsCbHL+hn/ccbId93VBH2PqI+rx3Iqx/xGsb9d/9tU31a9xnL28MpKelMHZgjz2/MAp8Dxsz6wr8DbgYL0zqlxtwFXCPc+6l4LILgRLgPOCPwddeDPzMOTcz2OcCYA1wIvBW7LZEJDnU1gWoqKlj565aKqrrqKyu855r6qhq9Aiwq7aOXTUBdtUGqK4LUF0b/Lo2QE1dw6O6zlFbF6C2zlETCD7XBagLOOoCjtrQc6BRu/4RcPXPfv/rdBx5OZnMvfnEmH0/38MGmAq86Jx7x8xuDVs+CCgAZtQvcM5Vmtn7wNHAH4ExQHpEn3VmtjTYZ7ewMbNLgUsBBgwY0P5bI9IB1NQF2LqzmtLyarZWBB87qymrrGFbRQ1llTVsr6phe2Ut26tq2LmrlvJdteyoqmVXbcDv8qUD8jVszOznwBDggj2sLgg+b4xYvhHoG9anDijdQ58C9sA5NxUv4CgsLNTfQZJwtlfV8PWWSr7ZVsmGskqKy6rYWFZFyY5dbNxexabyXWyrqPG7zKhKTTFSDFLMgg9ISfG+NoNUMyz4dYqB4X1teP0suCzF8PoBBNfXty3sdUQsJ2K9hRcX7NCob/D1oS67dw8ub/ROjTpGrGny9V2z0/fyiujwLWzMbCgwGRjnnKveR9fIQLA9LNvt7ZvRR6TD2l5Vw8qSclZu2snq0nK+2lzBV6U7Wbelgu1VtVH93mbQOSONThmpdM5MIys9lU4Z3iMzLZWs9BSy01PJSk8lMy2FzPQUMlJTg88pZKQFH6kppKemkJ5qwecU0lKN9FQjLcX7uuHZSE3x2qnBr1PNSE31nlNSvABJMSMlZW+/dsVPfu7ZHAXkAYvDEj0VONbMLgPqR50VAOvCXpdPw97OhuBr8oBNEX3ej07ZIrETCDjWbKlg0TdlfFG8naIN2ylav4MN26va9L5m0KNTBj06Nzy6dcqgW6d0umWn0zU7nS7Z6XTJSic3K43crDRyMtPonOmFTPhf4SLN4WfY/BOInAXzSeBLvD2e5XhhMh74FMDMsoBxwLXB/vOAmmCfZ4N9+gHDgY+iWr1IFJRV1vDZ2q3MX7OVeWu3svDrMna0cE8lMy2Fft2z6du9E326ZtG7azYFXTPJ75JFfm4mvXIz6dEpg7TUuLnyQZKAb2HjnNsGbAtfZmY7gS3OucXB9hRgopkV4YXPzUA5wWBxzpWZ2RPA/WZWQsPQ54XArJhsiEgbVNXUMXvVZj5euZkPV5aypHj7XoexhktPNQbldWZIfg6D83IYmNeZQXmd6N+jE71yMrXnIXEnHkaj7ct9QDbwKNAd+AQ4KewaG4CrgVrghWDft4Gf6hobiVfryyqZ9cVG3ikq4aOVm5sc3dWjcwYH9+3KyD5dGN67C8N75zKwZ2ftmUiHYpEXCiWTwsJCp/vZSCxsKKvitYXFvL5oPfPXbttrvxSDkX26Mmb/7ozZvzuHDehG327Z2lORuGJm85xzhS15Tbzv2Yh0WFU1dby1ZAMvzvuaD1eU7vWCwyH5OYw7MI9vH5DHEYN70CUrtkNSRWJBYSPSztZs3skzs9fwf3O/pqxy9+tZUlOMowb35KSR+3H80Hz69+jkQ5UisaWwEWkn89Zs4X/fW8nbRSW7neQ3g6MG9+SsQ/swfkQBPTpn+FOkiE8UNiJt4Jzjgy9L+f07K5jz1Zbd1vfvkc05hf35/uH96Nst24cKReKDwkakleav3cp9bxYxe9XuIXP80F789KiBfOegXrqiXQSFjUiLrdtSwV3Tl/Lmkg2NlqelGN87rC+XfWcwQ/JzfapOJD4pbESaqaqmjqnvr+LRd1c0ujYmNcU4Z2x/fnn8EB0qE9kLhY1IM8xZvYXrXlzAV5srGi0/fXRvrjlpKIPyOvtUmUjHoLAR2YfK6jruf2sZT360utEIs5F9unDHWaMYs393/4oT6UAUNiJ7sfibMn713GesKt0ZWpablcZ1E4Zx3hEDSNWJf5FmU9iIRHDO8dycdUx6dQnVYedmvnNQL+49ezQFXbN8rE6kY1LYiISpqK5l4suLefmzb0LLOmekcsvpIzhnbH/NUSbSSgobkaCN26u45Om5LPqmLLRsWEEuj51/OIN75fhYmUjHp7ARwTs/c8nTcxvdAfOcwv7cftZIstJTfaxMJDEobCTpvVtUwuV/m09ljXcLpNQU446zRnL+kfv7XJlI4lDYSFKbtqCYX7/wObXB+f9zs9J47PzDGXdgL58rE0ksChtJWs/MXsMtrywOXT/Tr3s2T/1srKaaEYkChY0kpcffX8Vdry8NtQ/Mz+GvFx+pYc0iUaKwkaQz9f2VTH69KNQ+pH83nrpoLN11jxmRqFHYSFKJDJojB/XgiYvGkpOp/woi0aT/YZI0/vTBqt2C5smfjaVThv4biERbit8FiMTC83PWcuf0hnM0RyhoRGJKYSMJ79UFxdz48qJQe+zA7jyloBGJKYWNJLR3i0q4+oXPQ8ObR/XtwhMXKWhEYk1hIwlr/tqt/Nff5oUu2BySn8Nf/vNIumSl+1yZSPJR2EhCWrmpnIuf+pSqGu8WAf26Z/PMxUfSQ8ObRXyhsJGEU7K9igv/PIetFTUA9OicwV/+8whdsCniI4WNJJSdu2r52VOf8vXWSgCy01P580VjdYsAEZ8pbCRh1AUcVz7/GUuKtwPe7M2PnX84h/bv5m9hIqKwkcRx1/SlzFpaEmrf+b1RHD8s38eKRKSewkYSwl8//oo/f7g61P7FsYM594gBPlYkIuEUNtLhfbiilEmvfhFqTxhZwPUThvlYkYhEUthIh7Zm805++ex86oLX0ozu15WHzjmUlBTzuTIRCaewkQ5rR1UNlzw9l23BIc75uZlMvaCQ7IxUnysTkUgKG+mQAgHH1S8s4MuScgAy0lL44wVjdC2NSJxS2EiH9Pt3VzBr6cZQ++7vH8xhA7r7WJGI7IvCRjqcd5eV8NCs5aH2JccM4uwx/XysSESaorCRDmXt5gquer5hFudvDe7BDado5JlIvPMtbMzsl2a20My2Bx8fm9lpYevNzCaZWbGZVZrZe2Y2MuI9Ms3sETMrNbOdZjbNzPQnboKqqqnjsmfmUVbpDQgo6JLF7887nLRU/c0kEu/8/F/6NXA9cDhQCLwD/NPMRgfXXwdcA1wBjAVKgJlmlhv2HlOAs4FzgXFAF+A1M9NwpAR0+6tL+GK9NxVNRmoK//sfh5OXk+lzVSLSHL6FjXPuFefcG865Fc655c65icAO4CgzM+Aq4B7n3EvOucXAhUAucB6AmXUFLgaudc7NdM7NBy4ARgMn+rBJEkX/mP81z81ZF2rfesYIDQgQ6UDi4viDmaWa2U+AHOAjYBBQAMyo7+OcqwTeB44OLhoDpEf0WQcsDesjCeDLjTuY+PLiUPusQ/tw/pGaikakI/E1bMzsYDMrB3YBfwC+75xbhBc0ABsjXrIxbF0BUAeU7qPPnr7npWY218zmbtq0qa2bIFFWUV3L5X+bT2VNHQAH9OrM5O8fjLfzKyIdhd97NsuAQ4FvAf8LPG1mo8LWu4j+todlkfbZxzk31TlX6Jwr7NWrV8srlpi6fdoXoQs3s9JTeOz8MXTOTPO5KhFpKV/DxjlXHTxnM9c5dyPwOXA1sCHYJXIPJZ+GvZ0NQCqQt48+0oFNW1DMC3MbztPccdYohhbk7uMVIhKv/N6ziZQCZAKr8cJkfP0KM8vCG3H2UXDRPKAmok8/YHhYH+mg1m6u4KZ/LAq1zzq0Dz/ShZsiHZZvxyPM7B5gOrCOhlFmxwGnOeecmU0BJppZEbAcuBkoB54FcM6VmdkTwP1mVgJsBh4EFgKzYrs10p6qawNc8dx8ynfVArB/z07c+b1ROk8j0oH5efC7AHgm+FyGFxKnOOfeCq6/D8gGHgW6A58AJznndoS9x9VALfBCsO/bwE+dc3Ux2QKJiimzlrPg6zIA0lONR849jNysdJ+rEpG2MOeaOt+euAoLC93cuXP9LkPCzF61mXMfnx2ajuamU4dx6bEH+FuUiDRiZvOcc4UteU28nbORJFZWWcOvX2iY9+yYIXlccsxgf4sSkXahsJG44Jxj4suLKC6rAqBbp3Qe+NEhuuOmSIJQ2EhceOXzYl5buD7UvucHo3UjNJEEorAR3xVvq+SWVxqmozmnsD8TRu11EggR6YAUNuKrQMBx7YsL2FHlDXMe0KMTt54xwueqRKS9KWzEV3/5+Cs+XLEZADN48MeHaDoakQSksBHfrNxUzt1vFIXavzj2AAoH9vCxIhGJFoWN+KK2LsA1/7eAXbUBAIYV5HL1+AN9rkpEokVhI754/IPVfL5uG+DNEvDgjw8lM003WBVJVAobibnlG3fw0MzlofaV3z2QEX26+FiRiESbwkZiqiZ4+Ky6zjt8dnDfrlz2HU1HI5LoFDYSU1PfX8Wib7xJNjNSU/jtjw8hLVU/hiKJTv/LJWaWb9zBw7O+DLWvHn8QB+2nm6GJJAOFjcREXcBx7YsLQ4fPDunXlZ+PG+RzVSISKwobiYk//3s1C8JGn93/Ix0+E0km+t8uUbe6dCcPzFgWav/qhAN1+EwkyShsJKoCAcf1Ly0MXbw5oncXLjtOo89Eko3CRqLq+U/XMWf1FgBSU4z7fjiadB0+E0k6+l8vUbOhrIq7X18aal967GBG9e3qY0Ui4heFjUSFc45bXlnMjl3erQMG5XXmyu9q7jORZKWwkah4Y/EGZn6xMdS++wcHk5Wuuc9EkpXCRtpdWWUNt01bEmqfe8QAvjW4p48ViYjfFDbS7u59s4hNO3YBkJ+byQ2nDPO5IhHxm8JG2tWnX23h2U/Whtq3nzmSrtnpPlYkIvFAYSPtZldtHTf+Y1GofeLw/ZgwqsDHikQkXihspN1M/dcqVpSUA9A5I5U7zhqJmflclYjEA4WNtIvVpTt55N0Vofa1Jw+lT7dsHysSkXiisJE2c85xyz8XUx2ckmZ0v65ccNRAf4sSkbiisJE2m7agmH+vKAUgxWDy9w8mNUWHz0SkgcJG2qSsoobfvPZFqH3R0YM0JY2I7EZhI21y71tFlJZXA1DQJYtfn3SQzxWJSDxS2EirfbZ2K8/NabimZtKZI8jJTPOxIhGJVwobaZXaugA3/3MxznntE4blc/JIXVMjInumsJFWeWb2GpYUbwcgMy2F28/UNTUisndNHvMws1VteH8H/Idz7uM2vIfEmZLtVfx2xvJQ+4oThtC/RycfKxKReNecA+wDgSJgYxP9IqUDRwG6si/B3Dl9aeg+NYN7debnxw72uSIRiXfNPZt7p3Pu2Za8sZnlASUtL0ni2UcrSpm2oDjUvvOsUWSm6T41IrJvzTlnswwoa8V71wRfu7MVr5U4VF0b4Naw+9SceUgfjh6S52NFItJRNBk2zrnhzrnpLX1j51xZ8LWf7Gm9md1oZp+a2XYz22Rmr5rZqIg+ZmaTzKzYzCrN7D0zGxnRJ9PMHjGzUjPbaWbTzKxfS+uVpj354erQRJs5mWncfNpwnysSkY7Cz9FoxwGPAUcDJwC1wCwz6xHW5zrgGuAKYCzeYbmZZpYb1mcKcDZwLjAO6AK8ZmY6ttOO1pdV8vDbX4baV48/iPwuWT5WJCIdSbPCxsxGtORNzey/m+rjnDvZOfekc26xc24RcAHQC/h28D0MuAq4xzn3knNuMXAhkAucF+zTFbgYuNY5N9M5Nz/4PqOBE1tSs+zbna8tpaK6DoBhBblceNT+PlckIh1Jc/ds5pnZtdbEhRRmNsjM3gUebkUtucF6tgbbg4ACYEZ9B+dcJfA+3t4QwBi8UW/hfdYBS8P6SBv9+8tSpi9aH2rfcdYo0lJ1iZaINF9zf2PMAe4F/m1mQ/bUIbg3sxBvuPPEVtTyMPA5UH9NTv3l6JFDrjeGrSsA6oDSffSJrPNSM5trZnM3bdrUijKTS3VtgNumLQ61f3BYX44Y1GMfrxAR2V2zwsY59x28cyeHAgvM7Ff168L2Zn6Ht0dxuHPunpYUYWYPAscAZzvn6iK/fWT3PSzb7S331sc5N9U5V+icK+zVq1dLykxKT364mpWbvAGFOZlp3HDqMJ8rEpGOqNnHQpxzDwGHA4uBh4Ijw64HFtGwN/Mt59wX+3ib3ZjZQ3gn909wzoXPVrAh+By5h5JPw97OBiAViBx/G95HWmlDWVWjQQFXnXgg+bkaFCAiLdeiA+/OuWV4wfIH4FhgMvAVcJhz7m7nXKAl72dmD+Od7D/BOVcUsXo1XpiMD+ufhTfi7KPgonl41/OE9+kHDA/rI600+fWGQQEH7ZfDhUcP9LcgEemwWjMf/H8C5+P9kt8FHACcaWZFzrmmDm+FmNmjeCPHvgdsNbP6PZhy51y5c86Z2RRgopkVAcuBm4Fy4FnwruUxsyeA+82sBNgMPIh37mhWK7ZNgmav2txopoDbzxxFugYFiEgrNfu3h5n1NbM3gKnAKqAQOBiYDdwNfGRmLblz1uV4I9DeBtaHPf4nrM99eOHxKDAX6A2c5JzbEdbnauAfwAvAh3hhdMYezv1IM9XWBZgUNlPA6aN7c9QBPX2sSEQ6umbt2ZjZhcBDQA7wG+A3zrna4OrjgwMGJgOfm9ktwINN7eU455qcjz74HpOCj731qcK76POKprdEmuPZOWsp2uDleXZ6KhM1U4CItFFz92yeBL4GjnTO3RYWNAA4534HHAZ8BtwPfNCuVUrMbNlZ3ej2Af99whB6d9XE3SLSNs0Nm7uBMc65z/bWwTn3Jd7w5evxRq1JB/TAjGWUVdYAsH/PTlx8zCCfKxKRRNDc62wmOudqmtHPOefuR2HTIS3+pozn5qwNtW85bQRZ6ZpiTkTarsmwMbOjzaxFZ4edc0Vmlhp8bW7TrxC/OeeYNG0J9Wfajhvai+8Oz/e3KBFJGM3Zs/kAOLkV790t+NqxrXitxNi0BcXMXeNNS5eeatxy+giamApPRKTZmjMazYCeZjaghe/dI/haiXMV1bXc/XrDNbU/+/YgDuiV42NFIpJomntR55Tgo6WafZGn+Oexd1eyYXsVAHk5mVxxwh7nWhURabXmhM3tbfweq5ruIn5Zt6WCqR80fETXTRhKbla6jxWJSCJqMmycc20NG4ljd01fSnWtN6XdIf268sPDdUdtEWl/muwqiX20opQ3l2wItW87cyQpKTrNJiLtT2GTpGrrAtzxWsPdIH5wWF8OH9Ddx4pEJJEpbJLUc5+uC81/1ikjlesm6KZoIhI9CpskVFZRw4MzloXavzx+CAVddVM0EYkehU0SmvL2crZWeLMP9euerfnPRCTqFDZJZkVJOX/9eE2oPfHU4Zr/TESiTmGTZO6c/gW1Ae9a2yMH9WDCqIImXiEi0nYKmyTy7rIS3lu2CQAzuPUMzX8mIrGhsEkSNXUB7gwb6vyTsf0Z2aerjxWJSDJR2CSJv81ew8pNOwHIyUzj1+OH+lyRiCQThU0S2FZRzUOzvgy1rzhhCL1yM32sSESSjcImCUyZ9WXoVs8DenTiom8P9LcgEUk6CpsEt6KknGdmNwx1vunU4WSmaaiziMSWwibBTX59aaOhzieP3M/nikQkGSlsEtj7yzfxTlEJ4A111q2eRcQvCpsEVVsX4M7pDUOdfzSmH6P6aqiziPhDYZOgnv90Hcs3lgPerM7/c5KGOouIfxQ2CWh7VQ0PzVweal9+3AHkd9GsziLiH4VNAnr0nRVs3lkNQN9u2VwybrDPFYlIslPYJJi1myt48sOvQu3rJgzVrM4i4juFTYK5980iqusCABw2oBtnHtLH54pERBQ2CWXuV1uYvmh9qH3zaRrqLCLxQWGTIAIBx2+mLw21zzikD2P27+5jRSIiDRQ2CeLVhcUsWLcNgIy0FK47WUOdRSR+KGwSQFVNHfe+URRqX3zMIPr36ORjRSIijSlsEsAT/15NcVkVAD07Z3D5cQf4XJGISGMKmw6uZEcVj727ItS+evxB5Gal+1iRiMjuFDYd3EMzv2RndR0AB+bn8JOx/X2uSERkdwqbDmzZhh288OnaUPum04aTlqqPVETij34zdWB3vb6U4K1qGHdgHscd1MvfgkRE9sLXsDGzY81smpl9Y2bOzC6KWG9mNsnMis2s0szeM7OREX0yzewRMys1s53B9+sX0w3xwb+Wb+L95ZsASDGYeNpwXcApInHL7z2bHGAxcCVQuYf11wHXAFcAY4ESYKaZ5Yb1mQKcDZwLjAO6AK+ZWcJOCFYXcEwOu4Dzx4X9GVbQxceKRET2zdewcc697py7yTn3IhAIX2fen+lXAfc4515yzi0GLgRygfOCfboCFwPXOudmOufmAxcAo4ETY7clsfV/c9exbOMOwLtXza/HH+RzRSIi++b3ns2+DAIKgBn1C5xzlcD7wNHBRWOA9Ig+64ClYX0aMbNLzWyumc3dtGlTlEqPnp27avntjIZ71Vz2Hd2rRkTiXzyHTUHweWPE8o1h6wqAOqB0H30acc5Ndc4VOucKe/XqeCfU//ivlZSW7wKgoEsWP9e9akSkA4jnsKnnItq2h2WRmtOnw1lfVsnUD1aF2v9z8lCyMxL21JSIJJB4DpsNwefIPZR8GvZ2NgCpQN4++iSM385YTlWNd2prRO8u/OCwvj5XJCLSPPEcNqvxwmR8/QIzy8IbcfZRcNE8oCaiTz9geFifhLCkuIyX5n8dat982nBSUjTUWUQ6hjQ/v7mZ5QBDgs0UYICZHQpscc6tNbMpwEQzKwKWAzcD5cCzAM65MjN7ArjfzEqAzcCDwEJgViy3JZqcc9w1fSkueGDwu8PyOXpI5M6ciEj88jVsgELg3bD27cHH08BFwH1ANvAo0B34BDjJObcj7DVXA7XAC8G+bwM/dc7VRbv4WHl3WQkfrdwMQGqKceOpw3yuSESkZXwNG+fce3gn8/e23gGTgo+99anCu+jzivatLj7U1gWY/HrDvWrOPaI/Q/Jz9/EKEZH4E8/nbAR4/tN1rCgpByAnM42rTtQFnCLS8Shs4tiOqhqmzGq4gPO/jjuAvJxMHysSEWkdhU0c+8O/VlJaXg1A765ZXHzMIJ8rEhFpHYVNnCreVsmfPlgdal978lCy0nUBp4h0TAqbOPXAW8vYVetdwDmqbxe+d6gu4BSRjkthE4cWf1PGPz77JtSeeOoIXcApIh2awibOOOe4c/oXofaJw/fjqAN6+liRiEjbKWzizKylJcxetQXwLuC84RRdwCkiHZ/CJo7U1AW4+/WGO3Cef+QAhuTn+FiRiEj7UNjEkWc/Wcuq0p0A5GamceV3D/S5IhGR9qGwiRNllY0v4PzlCUPoqQs4RSRBKGzixGPvrmBrRQ0Afbtlc9HRA/0tSESkHSls4sDazRU8+eFXofb1pwzTBZwiklAUNnHg3jeLqK7zLuA8tH83zhjd2+eKRETal8LGZ3O/2sL0RetD7VtOH4GZLuAUkcSisPFRIOD4zfSGoc6nj+7NmP27+1iRiEh0KGx89OrCYhas2wZARloK10/QBZwikpgUNj6prK7j3jca7sB58TGD6N+jk48ViYhEj8LGJ398fyXFZVUA5OVkcPlxB/hckYhI9ChsfFC8rZI//GtlqH3NSUPJzUr3sSIRkehS2Pjg3jeLqKrxhjoP792FHxf297kiEZHoUtjE2Lw1W3nl8+JQ+7YzRpCqe9WISIJT2MRQIOC449UlofapBxfwrcG6V42IJD6FTQz9fd46FnxdBnhDnW88ZbjPFYmIxIbCJka2VVRz75vLQu1fHDtYQ51FJGkobGLktzOWs2VnNeDN6nz5cUN8rkhEJHYUNjGw+Jsy/vbJmlD7ltOHk52hWZ1FJHkobKIsEHDcNm0JAee1xx2Yx8kjC/wtSkQkxhQ2Ufbcp2uZt2YrAOmpxu1njtSsziKSdBQ2UbShrIp7Xm+Y/+zSYwczuFeOjxWJiPhDYRMlzjlueWUxO3bVAjA4rzNXnHCgz1WJiPhDYRMlby7ewMwvNobak39wsG71LCJJS2ETBVt2VnPrtIaZAs49YoBmChCRpKawaWfOOa79+wI27dgFQH5uJjecopuiiUhyU9i0sz9/+BVvF5WE2veePZqu2bp9gIgkN4VNO1r0dRn3vLE01L7kmEEcPyzfx4pEROKDwqadbNlZzX8/N5+aOu/qzdH9unLdBB0+ExEBhU272LqzmvP/9AlrNlcAkJOZxiPnHkZGmv55RUQggcLGzC43s9VmVmVm88xsXCy+77YKL2iWrt8erAPu/+Fo9u/ZORbfXkSkQ0iIsDGzc4CHgcnAYcBHwBtmNiBa37O2LsBbSzbwk6mz+SIsaB744SGccnDvaH1bEZEOKc3vAtrJr4GnnHOPB9tXmNkE4L+AG9vzG5XsqOKFOet4ds5a1pdVhZabwX1nj+bsMf3a89uJiCSEDh82ZpYBjAEeiFg1Azi6vb/flc99zserNjdalp5q3PX9g/lRYf/2/nYiIgmhw4cNkAekAhsjlm8ETozsbGaXApcCDBjQ8qNs5x05IBQ2PTtn8JMj+nPekfvTt1t2i99LRCRZJELY1HMRbdvDMpxzU4GpAIWFhbutb8rJIws4cfh+nHFIbyaMKiAzTfOdiYg0JRHCphSoAyLvSJbP7ns7bZaRlsKfLixs77cVEUloHX40mnOuGpgHjI9YNR5vVJqIiPgsEfZsAB4E/mpmc4APgcuAPsAffK1KRESABAkb59wLZtYTuBnoDSwGTnXOrfG3MhERgQQJGwDn3GPAY37XISIiu+vw52xERCT+KWxERCTqFDYiIhJ15lyLr2tMGGa2CWjtIII8vGt8klEybzsk9/Yn87ZDcm9/+Lbv75zr1ZIXJ3XYtIWZzXXOJeXVncm87ZDc25/M2w7Jvf1t3XYdRhMRkahT2IiISNQpbFpvqt8F+CiZtx2Se/uTedshube/TduuczYiIhJ12rMREZGoU9iIiEjUKWxERCTqFDYtZGaXm9lqM6sys3lmNs7vmmLBzCaZmYt4bPC7rmgxs2PNbJqZfRPc1osi1lvw36TYzCrN7D0zG+lTue2qGdv+1B5+Fmb7VG67MrMbzexTM9tuZpvM7FUzGxXRJyE/+2Zue6s/e4VNC5jZOcDDwGTgMLybs71hZgN8LSx2luHdwqH+cbC/5URVDt6tKq4EKvew/jrgGuAKYCxQAsw0s9yYVRg9TW07wCwa/yycGpvSou44vNnjjwZOAGqBWWbWI6xPon72x9H0tkNrP3vnnB7NfACfAI9HLPsSuNvv2mKw7ZOAxX7X4dO2lwMXhbUNWA9MDFuWDewAfuF3vdHc9uCyp4DX/K4tRtufg3fb+TOS8LNvtO1t/ey1Z9NMZpYBjAFmRKyagfeXQDIYHDy0strMnjezwX4X5JNBQAFhPwvOuUrgfZLnZ+EYMysxs+Vm9riZ5ftdUJTk4h0B2hpsJ9NnH7nt9Vr12Stsmi8PSAU2RizfiPfDl+g+AS4CTgF+jrfNHwXvkJps6j/vZP1ZeBP4KfBdvMNJRwDvmFmmr1VFx8PA58DHwXYyffaR2w5t+OwT5k6dMRR5FaztYVnCcc69Ed4OnhRcBVwIPOhLUf5L1p+F58Oai8xsHt7s6acB//CnqvZnZg8CxwDHOOfqIlYn9Ge/t21vy2evPZvmK8U7fhn510s+u/+Vk/Ccc+XAEuBAv2vxQf0oPP0sAM65YuBrEuhnwcweAs4FTnDOrQpblfCf/T62fTct+ewVNs3knKsG5gHjI1aNxxuVllTMLAsYhneyNNmsxvulE/pZCP57jCM5fxbygL4kyM+CmT0MnIf3y7YoYnVCf/ZNbPue+jf7s9dhtJZ5EPirmc0BPgQuA/oAf/C1qhgwsweAV4G1eH/F3QJ0Bp72s65oMbMcYEiwmQIMMLNDgS3OubVmNgWYaGZFwHLgZryRW8/6UG672te2Bx+TgJfwfsEMBO7GG/77coxLbXdm9ihwAfA9YKuZ1e/BlDvnyp1zLlE/+6a2PfhzMYnWfvZ+D6/raA/gcuArYBfens6xftcUo+1+HigGqoFvgj9wI/yuK4rbexzeMfjIx1PB9Rb8j7ceqAL+BYzyu+5obzveMN+3gr9gqvGO1z8F9Pe77nba9j1ttwMmhfVJyM++qW1v62evWZ9FRCTqdM5GRESiTmEjIiJRp7AREZGoU9iIiEjUKWxERCTqFDYiIhJ1ChuRGKq/+ZTfdYjEmmYQEGmDFgbHoKgVIhLndFGnSBuY2X9ELBoHXApMBT6IWPcy3pXXqc65qhiUJxI3tGcj0gbOuWfC22aWhhc2H0euC1MT9cJE4ozO2YjE0J7O2dQvM7Oewa9LzWyHmf2zfjJEM7vUzJaaWZWZFZnZWXt5/3PM7N/B11eY2Sdm9sNYbJvIvihsROLHm0BX4FbgceB04GUzuxa4Fm+G7RuADOBFM2t0DsjM7sSbMHUH3qzcNwAVwN/N7Jex2giRPdFhNJH4Mcc5FwoFMwO4Gu9+IaOcc9uDy98BFuAdrrsxuOxwYCJwt3PuprD3/J2Z/RO428z+4pzbEYsNEYmkPRuR+DElol0/wOAv9UED4JxbCGyn8d0Rz8ebDv5pM8sLfwDTgFzgqKhVLtIE7dmIxI/IW/BuDT6v3kPfrUDPsPZwvPus7Ovuivu1vjSRtlHYiMQJ51zdXlbtbblFfO2AU/bRf0krSxNpM4WNSGL4EpgArHXOLfW7GJFIOmcjkhj+GnyebGapkSvNLD/G9Yg0oj0bkQTgnPvUzG4Dbgc+N7O/A8VAb2AMcCrekGkRXyhsRBKEc+4OM5sH/Aq4CugMlACLgSt9LE1Ec6OJiEj06ZyNiIhEncJGRESiTmEjIiJRp7AREZGoU9iIiEjUKWxERCTqFDYiIhJ1ChsREYk6hY2IiETd/wMwvIH+Mwlu+QAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from autoreduce.utils import get_ODE\n", - "timepoints_ode = np.linspace(0, 24, 100)\n", - "# params = [k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d, E_tot, P_tot, R_tot, G]\n", - "# params_values = [100, 10, 4, 10, 0.25, 2, 10, 0.5, 1, 10, 10000, 10000, 10000, 0.01]\n", - "# params_values = [30, 10, 0.50, 80, 2, 8, 10, 2, 1, 0.5, 0.01, 20, 100, 400, 10]\n", - "# sys_reduce.params_values = params_values\n", - "sys_ode = get_ODE(sys_reduce, timepoints_ode)\n", - "sol = sys_ode.solve_system().T\n", - "try:\n", - " import matplotlib.pyplot as plt\n", - " fig, ax = plt.subplots()\n", - " plt.plot(timepoints_ode, np.transpose(np.array(sys_reduce.C)@sol), linewidth = 3)\n", - " plt.xlabel('Time', fontsize = 18)\n", - " plt.ylabel('[X]', fontsize = 18)\n", - " ax.tick_params(axis='both', which='major', labelsize=14)\n", - " # plt.legend()\n", - " plt.show();\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[-G*P*k_bp + (-P + P_tot)*(k_tx + k_up),\n", - " -E*T*k_be - R*T*k_br - T*d_T + k_tx*(-P + P_tot) + k_ue*(-E + E_tot) + (-R + R_tot)*(k_tl + k_ur),\n", - " -R*T*k_br + (-R + R_tot)*(k_tl + k_ur),\n", - " -E*T*k_be + (-E + E_tot)*(d_i + k_ue),\n", - " -X*d + k_tl*(-R + R_tot)]" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sys_reduce.f" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[P, T, R, E, X]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sys_reduce.x" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful time-scale separation solution obtained with states: [T, R, X]!\n" - ] - } - ], - "source": [ - "reduced_sys_trx, fast_ss = sys_reduce.solve_timescale_separation([T, R, X], fast_states = [P, E], debug = False)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle \\frac{- E_{tot} T d_{i} k_{be} \\left(G k_{bp} + k_{tx} + k_{up}\\right) + G P_{tot} k_{bp} k_{tx} \\left(T k_{be} + d_{i} + k_{ue}\\right) - \\left(G k_{bp} + k_{tx} + k_{up}\\right) \\left(T k_{be} + d_{i} + k_{ue}\\right) \\left(R T k_{br} + T d_{T} + \\left(R - R_{tot}\\right) \\left(k_{tl} + k_{ur}\\right)\\right)}{\\left(G k_{bp} + k_{tx} + k_{up}\\right) \\left(T k_{be} + d_{i} + k_{ue}\\right)}$" - ], - "text/plain": [ - "(-E_tot*T*d_i*k_be*(G*k_bp + k_tx + k_up) + G*P_tot*k_bp*k_tx*(T*k_be + d_i + k_ue) - (G*k_bp + k_tx + k_up)*(T*k_be + d_i + k_ue)*(R*T*k_br + T*d_T + (R - R_tot)*(k_tl + k_ur)))/((G*k_bp + k_tx + k_up)*(T*k_be + d_i + k_ue))" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "reduced_sys_trx.f[0]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Reduced model (obtained using time-scale separation above) vs Full model" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "reduced_sys = reduced_sys_trx\n", - "try:\n", - " fig, ax = plt.subplots() \n", - " # params = [k_bp, k_up, k_tx, k_br, k_ur, k_tl, k_be, k_ue, d_i, d, d_T, E_tot, P_tot, R_tot, G]\n", - " params_values_new = [80, 2, 0.5, 80, 2, 0.5, 8, 0.2, 0.1, 0.5, 0.05, 100, 100, 400, 0.1]\n", - " # Set new parameters \n", - " sys.params_values = params_values_new\n", - " reduced_sys.params_values = params_values_new\n", - " # Set new initial conditions \n", - " sys.x_init[0] = params_values_new[-3]\n", - " sys.x_init[3] = params_values_new[-2]\n", - " sys.x_init[5] = params_values_new[-4]\n", - " if P in reduced_sys.x:\n", - " ind = reduced_sys.x.index(P)\n", - " reduced_sys.x_init[ind] = params_values[-3]\n", - " if R in reduced_sys.x:\n", - " ind = reduced_sys.x.index(R)\n", - " reduced_sys.x_init[ind] = params_values[-2]\n", - " if E in reduced_sys.x:\n", - " ind = reduced_sys.x.index(E)\n", - " reduced_sys.x_init[ind] = params_values[-4]\n", - " # Solve ODEs and plot\n", - " sys_ode = get_ODE(sys, timepoints_ode)\n", - " sol = sys_ode.solve_system().T\n", - " _ = plt.plot(timepoints_ode, np.transpose(np.array(sys.C)@sol), 'k--', label = 'Full CRN model', linewidth = 5)\n", - " reduced_ode = get_ODE(reduced_sys, timepoints_ode)\n", - " reduced_sol = reduced_ode.solve_system().T\n", - " _ = plt.plot(timepoints_ode, np.transpose(np.array(reduced_sys.C)@reduced_sol), 'r', label = 'Reduced model', linewidth = 2)\n", - " \n", - " plt.savefig('trx.svg')\n", - " plt.show()\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Robustness [T, R, X]" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - } - ], - "source": [ - "Se_trx = sys_reduce.get_robustness_metric(reduced_sys_trx)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([3.83705486e+00, 3.36388190e+00, 8.76099204e-01, 2.00297842e-01,\n", - " 3.83705488e+00, 3.83705470e+00, 2.00297556e-01, 1.97825897e+04,\n", - " 5.23385286e-08, 1.79232933e+02, 5.08471194e-07, 6.58560796e-08,\n", - " 1.39836314e+02, 2.74921437e+01, 2.74921441e+01]),\n", - " 0.003875416964245933)" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Se_trx" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Uncomment to run all the other reduced models." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# [T, X] model" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful time-scale separation solution obtained with states: [T, X]!\n" - ] - } - ], - "source": [ - "reduced_sys_tx, fast_ss = sys_reduce.solve_timescale_separation([T, X], fast_states = [P, R, E], debug = False)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "For all of the robustness analysis, go to `IJRNC examples/gene expression analysis.ipynb`" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.9.12 ('base')", - "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.9.12" - }, - "vscode": { - "interpreter": { - "hash": "086edbbad6d007afd932f3998127bea1c36f47a35b43b79d0f508f10f9e57cc3" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/michaelis-menten example.ipynb b/examples/michaelis-menten example.ipynb deleted file mode 100644 index 5b6c995..0000000 --- a/examples/michaelis-menten example.ipynb +++ /dev/null @@ -1,328 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from autoreduce import *\n", - "import numpy as np" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "$ \\dot{x} = f(x, \\Theta) + g(x)u \\\\ y = Cx \\\\\n", - "y = h(x, \\Theta)$" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Post conservation law model\n", - "n = 2\n", - "nouts = 1 # Number of outputs\n", - "# Either\n", - "# sys.load_SBML_model('my_sbml_model.xml')\n", - "\n", - "# OR write ODEs\n", - "# x = ES, P\n", - "# P = a, d, k, Etot, Stot\n", - "\n", - "# parameter values\n", - "P = np.zeros(5)\n", - "P[0] = 10\n", - "P[1] = 10\n", - "P[2] = 0.1\n", - "P[3] = 1\n", - "P[4] = 1\n", - "\n", - "params_values = P.copy()\n", - "timepoints_ode = np.linspace(0, 150, 100) # timepoints for simulation\n", - "\n", - "x_init = np.zeros(n) # Initial conditions\n", - "\n", - "error_tol = 100\n", - "nstates_tol = 1\n", - "x,f,P = load_ODE_model(n, len(params_values))\n", - "params = P\n", - "f[0] = P[0]*(P[3] - x[0])*(P[4] - x[0] - x[1]) - P[1]*x[0] - P[2]*x[0]\n", - "f[1] = P[2]*x[0]\n", - "C = np.zeros((nouts,len(x)), dtype=int)\n", - "C[0][1] = 1\n", - "C = C.tolist()\n", - "sys = System(x,f,params=params,C=C, params_values=params_values,x_init=[0,0])" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAPXpJREFUeJzt3Qd8VfX9//FP9p4kJBACCUv2HgJuKKj8UIoD0QKi1Z+jVsW2ghWotYLYqjio/B38alsRtCp1MBQElaFh7z3DyCKQSda99//4fm8SEggQMPeee859Pfs4PeOeG74HSe473+njcDgcAgAAYBG+RhcAAACgIRFuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApfiLl7Hb7XLs2DGJiIgQHx8fo4sDAADqQU3LV1BQIE2bNhVf3wvXzXhduFHBJjk52ehiAACAy5Ceni7NmjW74D1eF25UjU3VX05kZKTRxQEAAPWQn5+vKyeqPscvxOvCTVVTlAo2hBsAAMylPl1K6FAMAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAsxdBw8/3338uwYcP0Cp9qOuX58+df9D3Lly+XHj16SFBQkLRu3Vr+8Y9/uKWsAADAHAwNN0VFRdK1a1eZOXNmve4/cOCADB06VK6//nrZuHGjPPHEE/LrX/9aFi9e7PKyAgAAczB04cybbrpJb/U1a9YsSU1NlZdfflmft2/fXlasWCGvvvqqDBkyxIUlBQDAOhwOh9gdNfbqf/rceVz1mkPdaz/zur3qWs3XHWe97hAJ8veVxpHBhj2fqVYFX716tQwaNKjWNRVqVA3O+ZSWluqt5pLpAADzs9sdUm63S4XNIeU2u5RX7vV5jesVdodUVL5uq/Eem/3Mtap71N5WY3Oen+965aYCQuU1e+W5uq4+6J33OD/0q65VH1ddrxE0nPc4n63qXn1edayCRq1rVednrjlq3F8VWKpCSdU1V+vRPFo+fWSAGMVU4SYjI0MSEhJqXVPnKrCcPn1aQkJCznnPtGnT5LnnnnNjKQHA+tSHb0mFTU6X2aSkwu7cl1dtdr0vrTh3X1phkzK9dx6XltulzGbX1/Rmc75Wda7CibpWrl9zSFmF7UyIUZ/mMIyPj4iP3vvovW/lBXUc6G/seCVThZvLMXHiRBk/fnz1uQpCycnJhpYJANxJhYTC0gopLKlw7ksrpKhyX1ym9jYpVtfKbPq8SJ2Xqdec+9Plam+TEnVe7gw0KoB4ogA/Hwnw8xV/38q9n4/4+/rq6/6V16uu1Tr28xE/nzPnfuo1Xx/x1V/HR5+r130rr/vpe8S591Hnol9zHp/Z1Ad+zff6+kj1dedrzlCgt8rjmq+rvOA8d76mgoRf5fWq96hooV5Xr1Xt/SrvqbrvnH1lGKkKJFXvq7quLitn3+/8mpUvejBThZvExETJzMysdU2dR0ZG1llro6hRVWoDALNSTRV5p8vlVHGZnDpdLnnF5ZJfUq6vVR3nn67Q+4KSM/uCyr2rg4j6LT0kwE+CA3wlWO39ncdB+pqf7n+htjPHfhIU4CuBfr5n9v6++uvozc+v+lgFC/WaCirOc+f9al8VWGoGGjN88ML1TBVu+vXrJwsWLKh17ZtvvtHXAcAsVK1JTmGp5BSWyYnCUjlZXCYnisokt7BMcovL5GRRmZwsLtfX1XF+SUWD/LkqgIQF+UtEsL+EBflJWKC/hAf5S2iQ2vtJaKC/hAY692E1zkPUFqDOnZsKJ1XX1bGqWQA8iaHhprCwUPbu3VtrqLca4h0bGyvNmzfXTUpHjx6Vf/7zn/r1hx56SN588035wx/+IPfdd598++238tFHH8lXX31l4FMAgLMPigoomfkllVupZBeUSnZhiWSp40Ln+YnCMt3MczlUEIkKCdBbdKhzr7ZItQX7670KLpHBAfreiGDnudrUuarlALyBoeFm7dq1es6aKlV9Y8aOHasn5zt+/LgcPny4+nU1DFwFmSeffFJee+01adasmbz77rsMAwfgUmo0igouR0+elmOnTsvRU6clI69EjueXyPHK46yC0kvq4KqabRqFBUlceKDEhgVKo/AgaRQWKDFhgRIbGqjDizqOCVVBJlCHGNX0AuDifBzqu9aLqA7FUVFRkpeXp/vqAICi+qkcPlEsh04US/rJYknPVfvTciS3WIeZ+vRbUd094sKDJCEySBpHBOt9fHiQxEcGO/cRgfp1tanmIQCu+fzmuwuA11Cjgw7mFMl+tWUXyoGcIjl4olgOnyjSfVwuFlwaRwRJ0+gQ5xYVLE2iQqRJVLAkVh6rWhiafgDjEW4AWE5uUZnsziyQPVmFsi+rUPZWbhn5JRd8n6pRaR4bIs1jQ6VZTKgkx4ZIckyoJMWE6ACjOs8C8HyEGwCmpSaB25NZKNuP5cvOjAIdaHZlFuiOu+ej+rW0jA+T1Di1hUtqXKg0jw2T5o1CdadbAObHdzIA0wyf3nYsX7YczZOtR/N0oNmXXXjeTryq1qVN4whp3ThcWseHS6vKfVRogNvLDsC9CDcAPI6aWn/n8QLZkH5SNh4+JZuP5ukgU9fwBzWqqEOTSGmXqLYIaZsYIW0ah9NhF/BifPcD8Ig+MmsP5sq6Qyf1pmpn6hqdlBgZLJ2SoqRzUpR0bBopHZpG6g69zEoLoCbCDQC3U/PC/Lj/hN7WHMyVfdlF59yjJqXr1jxGuidHS9fkKB1q1PBqALgYwg0Al1NLDKzcd0JW78uRH/fn6iHYZ1N9Y3qnxEjPFrHSvXm0pDYK0wsNAsClItwAcMkoprUHT8r3e7JlxZ4c3RG4JpVZVE3MlS0bSZ+UWOnZIkbPxgsADYFwA6BBHM87Lct3ZcuynVmycm+OFJXVXj9Jdfa9qnWc9GvVSHqnxur1jwDAFQg3AC6LWrlFzS3z9bZM+Xp7xjm1M/ERQXJNm3i5uk2cDGgdp88BwB0INwAuaeVrNTx7wZYMHWjSc09Xv6YGLHVLjpYbrmgs17drrIdn02cGgBEINwAuWkOzMf2UfLX5uCzYclyO5Z1ZwiDI31eubhMvgzsmyMB2jfXK1gBgNMINgDqpSfPmbzgq8zcerVVDExboJ4M6JMhNnZrINW3jJDSQHyMAPAs/lQDUmkzv841H5bMNR2XTkbxzAs3QzirQxEtwAAtIAvBchBvAy6l+NCv35cjcNenyzbZMKbM5Zwb28/WRa9rEyS97NJNftE+QkEACDQBzINwAXiqroETmpaXLvLXpcuTkmWYntazBbT2aybCuTRnhBMCUCDeAl3UOXnvopPxz9SFZtPW4lNucK1FGBPvL8G5JMrJ3sp5cDwDMjHADeMmMwf/dcEz+b9VB2XH8zHw0ambge/o2l5s7N6EfDQDLINwAFnayqEw++OmQvL/6kGQXlOprwQG+cmvXJBndrwW1NAAsiXADWNCRk8Xy9vf75aO16VJS7uwgnBgZLPcOSJG7eidLdCjrOAGwLsINYCFqte2/L9urh3JX2J39adRMwQ9ckypDOzeVQH9fo4sIAC5HuAEsYE9mgby5bK98semYVGYaGdC6kTxyXWvp36qR+Ki1EQDASxBuABM7fKJYZizZLZ9tPCqOylBzQ7vG8uj1rXVnYQDwRoQbwIQy8krkjW/3yLw16dXNT4M7JMhvB7ahkzAAr0e4AUykoKRc3lq+T95bcUBKK5wdhdVyCL8b3Fa6NIs2ungA4BEIN4AJVNjseibhV7/ZLTmFZfpa75QY+d3gK6Rvy0ZGFw8APArhBvBw3+3Olr98uV32ZBXq85ZxYTLx5vYyqH1jOgoDQB0IN4AHz1Xz/JfbZfG2TH0eExogTwxqK3f3bS4BfgzpBoDzIdwAHrhUwjvf79dDu9UEfGp17nv7p+jOwlEhAUYXDwA8HuEG8CCr9ubIH+dv1ZPxKX1TY+XPt3aSKxIjjC4aAJgG4QbwAHnF5TJ1wQ7daViJjwiSZ4e2l1u6NqVfDQBcIsINYLBFW4/LpP9uq17YcvSVLeT3N14hkcE0QQHA5SDcAAbJLSqTZ+dvkQVbMqpHQb14WxfpkxprdNEAwNQIN4ABvt2ZKX/4zxbJKSwVf18f+d9rW8pjN7SR4AA/o4sGAKZHuAHcqKi0Qv7y1Xb5MM3Zt6ZN43B5dWQ3lkwAgAZEuAHcZMPhk/L43I1yOLdYVB/h+wekyu+GXEFtDQA0MMIN4GJ2u0PeXbFfXlq0Sy9ymRQdIn+7o6v0a8WyCQDgCoQbwMWdhp/6aKMs25Wtz4d2aSLTRnRmJBQAuBDhBnCRtAO58tsPN0hGfokE+fvKlGEdZVSfZOatAQAXI9wADczhcMjslQf1pHw2u0NaxYfJm3f3kPZNIo0uGgB4BcIN0IBOl9lk4qebZf7GY/r8l92T5C/DO0lYEN9qAOAu/MQFGkh6brH877/Wyfbj+Xqxy0lD28vY/ik0QwGAmxFugAZa8PLROevlZHG5NAoLlJn39JArWzIaCgCMQLgBfqZ5aw7LHz/bqod5d20WJW/9qqc0jQ4xulgA4LUIN8DPmL/mpcW7ZNZ3+/T5rd2ayvTbujApHwAYjHADXGbH4fEfbZSFW52LXj4+sI08MagN/WsAwAMQboBLdKKwVO57f61sSj8lgX6+Mv32zvLL7s2MLhYAoBLhBrjEEVFjZ6fJ/pwiiQ4NkLdH95I+qbFGFwsAUAPhBqinXRkFMmb2T5KZX6rXh/rn/X2kVXy40cUCAJyFcAPUw7pDuXLfP9ZK3ulyaZsQLv+8r68kRgUbXSwAQB0IN8BFLNuVJQ//e52UlNulR/NomX1vb4kODTS6WACA8yDcABfw9bYMPTlfuc0h110RL2/d01NCAhnqDQCejHADnMfCLcflsQ836Mn5hnZuIjPu6iYBfr5GFwsAcBGEG6AOX2w6Jk/M26hX9VaT8718R1fxJ9gAgCkQboCz/HfjUXly3kaxO0RG9EiSv97eVS+ECQAwB8N/FZ05c6akpKRIcHCw9O3bV9LS0i54/4wZM+SKK66QkJAQSU5OlieffFJKSkrcVl54T7C5s1czgg0AmJCh4WbevHkyfvx4mTJliqxfv166du0qQ4YMkaysrDrvnzNnjkyYMEHfv2PHDnnvvff013jmmWfcXnZYs/Pw+I826WAzqk+yvDiiC8EGAEzI0HDzyiuvyAMPPCDjxo2TDh06yKxZsyQ0NFRmz55d5/2rVq2SAQMGyN13361rewYPHiyjRo26aG0PcDE/7MmW38zZoPvYjOieJC8M7yy+BBsAMCXDwk1ZWZmsW7dOBg0adKYwvr76fPXq1XW+p3///vo9VWFm//79smDBArn55pvP++eUlpZKfn5+rQ2oKe1Arjzwz7VSZrPLTZ0S5aXbuxBsAMDEDOtQnJOTIzabTRISEmpdV+c7d+6s8z2qxka976qrrhKHwyEVFRXy0EMPXbBZatq0afLcc881ePlhDZuPnJL7/rFGT9Cn5rF57a7ujIoCAJMz1U/x5cuXy9SpU+Xvf/+77qPz6aefyldffSXPP//8ed8zceJEycvLq97S09PdWmZ4rv3ZhXoRzMLSCumbGiuzftVTAv1N9S0BAPCkmpu4uDjx8/OTzMzMWtfVeWJiYp3vmTRpkowePVp+/etf6/POnTtLUVGRPPjgg/LHP/5RN2udLSgoSG9ATVkFJTL2/9LkZHG5dE6Kkvfu7S3BAcw8DABWYNivqYGBgdKzZ09ZunRp9TW73a7P+/XrV+d7iouLzwkwKiApqpkKqA9VU6OaotJzT0vz2FC9VlR4EFM+AYBVGPoTXQ0DHzt2rPTq1Uv69Omj57BRNTFq9JQyZswYSUpK0v1mlGHDhukRVt27d9dz4uzdu1fX5qjrVSEHuJBym10e+WC9bD2aL7FhgfL+fX0kPoKaPQCwEkPDzciRIyU7O1smT54sGRkZ0q1bN1m0aFF1J+PDhw/Xqql59tlnxcfHR++PHj0q8fHxOti88MILBj4FzELV7k34ZIt8vztbQgL8dI1NalyY0cUCADQwH4eXteeooeBRUVG6c3FkZKTRxYEbvbZkj7y6ZLeoUd7vjOklA9vXHqkHALDG5zdDQ+AVvtp8XAcb5S/DOxNsAMDCCDewvC1H8uSpjzfq4/sGpMrdfZsbXSQAgAsRbmBpWfklevZhNUnftW3j5Zmb2xldJACAixFuYFkl5TYdbDLyS6R143B5425mHwYAb8BPeliS6if/9CebZdORPIkODZD3xvaSyOAAo4sFAHADwg0safbKg/LfjcfE39dH3rqnp7RoxJBvAPAWhBtYzpqDuTJtwQ59/OzQ9tKvVSOjiwQAcCPCDSzXgVjNQFxhd8gtXZvK2P4pRhcJAOBmhBtYammF38zZINkFpdI2IVxevK2zntEaAOBdCDewjOkLd0rawVy9COasX/WU0EAWwwQAb0S4gSUs2HJc3l1xQB//7Y4u0jI+3OgiAQAMQriB6aXnFuth38r/XtNSbuzUxOgiAQAMRLiBqVXY7PL43A1SUFIh3ZtHy++GXGF0kQAABiPcwNRmLNkj6w+fkoggf3n9ru4SwAzEAOD1+CSAaa3alyMzl+/Vx1NHdJbk2FCjiwQA8ACEG5hSblGZPDlvozgcIiN7Jcuwrk2NLhIAwEMQbmDKdaP+8J9NkplfKq3iw2TKLR2MLhIAwIMQbmA6c9eky5IdWRLo7ytvjOrBfDYAgFoINzDdsO+/fLldH/9hyBXSoWmk0UUCAHgYwg1Mw253yFMfb5KiMpv0SY2V+wakGl0kAIAHItzANGavPCBpB3IlNNBP/nZ7V/H1Zd0oAMC5CDcwhb1ZBfLS4l36+NmhHaR5I4Z9AwDqRriBKVb7Hv/RJimrsMu1beNlVJ9ko4sEAPBghBt4vFnL98nmI3kSGewv02/rIj4+NEcBAM6PcAOPb45641vnLMR/vrWTJEYFG10kAICHI9zAo0dHTfhki5TZ7HJDu8ZyazdmIQYAXBzhBh7rg7TDsvbQSQkL9JPnh3eiOQoAUC+EG3ik43mnZfrCnfr490OukKToEKOLBAAwCcINPHLtqEnzt0lhaYV0bx4to/ulGF0kAICJEG7gcRZuzZAlOzIlwM9Hj47yY7I+AMAlINzAo+SdLpfJ/92mjx++rrW0TYgwukgAAJMh3MCjvPL1LskpLJVW8WHy6PWtjC4OAMCECDfwGNuO5cm/fjykj5+/tZME+fsZXSQAgAkRbuAxc9qo5ii7Q+R/ujSR/q3jjC4SAMCkCDfwCJ+sPyLrDp3UK36rhTEBALhchBsYLq+4XF6snNPmiUFtWGIBAPCzEG5guFe+2SUnisqkdeNwGTcg1ejiAABMjnADj+lE/OdbOkqAH/8kAQA/D58kMHQm4il0IgYANDDCDQyzYEuGXhgzJMBP/ji0vdHFAQBYBOEGhigpt8mLi3bo4/+9tqU0iWJhTABAwyDcwBDvrzoo6bmnJSEySB68pqXRxQEAWAjhBm53orBU3vx2rz7+/ZB2Ehrob3SRAAAWQriB281YskcKSiukU1KkjOieZHRxAAAWQ7iBW+3JLJA5aYf1sZqJ2NfXx+giAQAshnADt3phwQ6x2R0ypGOCXNmykdHFAQBYEOEGbvPDnmxZvitbAvx8ZMJNDP0GALgG4QZum7DvpUW79PGvrmwhqXFhRhcJAGBRhBu4xcKtGbLlaJ6EBfrJb65vbXRxAAAWRriBy1XY7PK3xc5am19f3VIahQcZXSQAgIURbuBy/1l3RPbnFElsWKD8+mpW/QYAuBbhBi5fZuG1pXv08SPXtZKI4ACjiwQAsDjCDVzqX6sPyfG8EmkaFaw7EgMA4GqEG7hMfkm5/H25c5mFJ37RVoID/IwuEgDACxBu4DLvfr9fThaXS6v4MJZZAAC4DeEGLpFbVCbvrTigj383+Arx9+OfGgDAPfjEgUu8+8N+KSqzSYcmkXJjp0SjiwMA8CKGh5uZM2dKSkqKBAcHS9++fSUtLe2C9586dUoeffRRadKkiQQFBUnbtm1lwYIFbisvLu5kUZm8v+qgPn58UBvx8WFxTACA+/iLgebNmyfjx4+XWbNm6WAzY8YMGTJkiOzatUsaN258zv1lZWXyi1/8Qr/2n//8R5KSkuTQoUMSHR1tSPlRt3dXnKm1GdwhwejiAAC8jKHh5pVXXpEHHnhAxo0bp89VyPnqq69k9uzZMmHChHPuV9dzc3Nl1apVEhDgnC9F1fpcSGlpqd6q5OfnN/hz4Oxam0P6+LcDqbUBAHhRs5SqhVm3bp0MGjToTGF8ffX56tWr63zP559/Lv369dPNUgkJCdKpUyeZOnWq2Gy28/4506ZNk6ioqOotOTnZJc8DJ9WJuLC0QtpTawMA8LZwk5OTo0OJCik1qfOMjIw637N//37dHKXep/rZTJo0SV5++WX5y1/+ct4/Z+LEiZKXl1e9paenN/izwOlUcZn8o6qvzcDW4utLrQ0AwMuapS6V3W7X/W3efvtt8fPzk549e8rRo0flr3/9q0yZMqXO96hOx2qD+2pt2iVGyOAOjJACAHhZuImLi9MBJTMzs9Z1dZ6YWPcHoxohpfraqPdVad++va7pUc1cgYGBLi83LlBrs7Kq1qYNtTYAAO9rllJBRNW8LF26tFbNjDpX/WrqMmDAANm7d6++r8ru3bt16CHYGEs1RxVU1toM6UitDQDAS+e5UcPA33nnHXn//fdlx44d8vDDD0tRUVH16KkxY8boPjNV1OtqtNTjjz+uQ40aWaU6FKsOxjBOcVlFdV+bR66nrw0AwIv73IwcOVKys7Nl8uTJummpW7dusmjRoupOxocPH9YjqKqokU6LFy+WJ598Urp06aLnuVFB5+mnnzbwKTA3LV1OFZdLi0ahcjOzEQMADObjcDgc9blxxIgRl/zF1bw1dU3GZyQ1z40aEq5GTkVGRhpdHNMrq7DLdX9dJsfySmTqLzvL3X2bG10kAIAFXcrnd71rbubPny933nmnhISE1Ov+OXPmSGFhoceFGzSszzcd08EmPiJIRvRg5W8AgMmapV5//fV6hxU1Hw2szW53yKzv9unj+69KleCAM6PYAADw+A7Fy5Ytk9jY2Hp/4YULF+o+MbCuJTsyZW9WoUQE+8s9NEcBAMxWc3Pttdde0he+6qqrLqc8MAnVVevvy521NqOvbCERwc61vgAAMOVQcDWJXlZW1jnXT5w4UWuCPVjXTwdyZWP6KQny95VxA1KNLg4AAD8v3JxvgJVafZvJ9LzDW5W1Nnf2StadiQEAMG2HYsXHx0feffddCQ8Pr35NLWb5/fffS7t27Rq+lPAoOzPy5bvd2aLm6nvg6pZGFwcAgMsPN6+++mp1zY2aw6ZmE5SqsUlJSdHXYW2zVxzQ+xs7JUrzRqFGFwcAgMsPNwcOOD/Urr/+evn0008lJibmUt4OC8gpLJX5G4/p4/uvotYGAGCR5RfUsHB4p3//eEjPStwtOVp6tiDcAgAs0qH4tttuk+nTp59z/aWXXpI77rijIcoFD1RSbtPhpmrSPgAALBNuVMfhm2+++ZzrN910k34N1l1qIaewTJpGBctNLJAJALBSuFFrRtU15DsgIEAvbAXrUZ3IqzoSj+2fIv5+l/VPBwAAl7usT6jOnTvLvHnzzrk+d+5c6dChQ0OUCx5m5d4TsjOjQEID/eSuPiy1AACwWIfiSZMmyYgRI2Tfvn1yww036GtLly6VDz/8UD7++OOGLiM8wHsr9uv9HT2bSVQISy0AACwWboYNGybz58+XqVOn6tW/Q0JCpEuXLrJkyZJLXoMKnk8tjrlsV7b4+AhLLQAArBlulKFDh+oN1vf+qoN6P7BdgqTEhRldHAAALoheobiggpJy+XT9EX08bkCK0cUBAMA1NTe+vr56fanzUetMwRo+23BUisps0io+TPq3amR0cQAAcE24+eyzz2qdl5eXy4YNG+T999+X55577nK+JDx0+Pc/Vzsn7Rt9ZYsLBloAAEwdbm699dZzrt1+++3SsWNHPUT8/vvvb4iywWCr95/QnYnV8O8RPZsZXRwAANzf5+bKK6/UQ8JhDf+qrLX5ZfckiQxm+DcAwMvCzenTp+X111+XpKSkhvqSMNDxvNPy9fZMfTy6XwujiwMAgGubpWJiYmr1v1B9MwoKCiQ0NFT+/e9/X86XhIf5MC1dbHaH9EmJlXaJkUYXBwAA14abV199tVa4UaOn4uPjpW/fvjr4wNzKKuzyYdphfUytDQDAK8LNvffe2/AlgcdYvC1DsgtKJT4iSIZ0ZPVvAIBFw83mzZvr/UXVUgwwf0fiUb2TJdCfeR4BABYNN926ddNNUap/jcIkfta0O7NA0g7mip+vj4zqy+rfAADzqfev5QcOHJD9+/fr/aeffiqpqany97//XU/epzZ13KpVK/nkk09cW2K4VFVfm4HtGkuTqBCjiwMAgOtqblq0ONOx9I477tDDvm+++eZaTVHJyckyadIkGT58+KWXBIYrKbfp5RaUUX2otQEAmNNldajYsmWLrrk5m7q2ffv2higXDOpIfKq4XJpEBcs1beONLg4AAO4LN+3bt5dp06ZJWVlZ9TV1rK6p12BOc9PS9f6OXsm6zw0AAF4zFHzWrFkybNgwadasWfXIKDWaSnUy/uKLLxq6jHCDgzlFei0p1U/8zl6sIwUA8LJw06dPH925+IMPPpCdO3fqayNHjpS7775bwsLCGrqMcIO5a5y1Nte0iZdmMaFGFwcAAPeGG0WFmAcffPDy/2R4jHKbXf6z7og+HtUn2ejiAABgTLjZt2+fzJgxQ3bs2KHPO3bsKL/97W/1cHCYy9IdWZJTWCpx4UEysH2C0cUBAMD9HYoXL14sHTp0kLS0NN3nRm0//vijDjjffPPNzysR3G7uGufcNrf3bCYBfsxIDADwwpqbCRMmyJNPPikvvvjiOdeffvpp+cUvftFQ5YOLHT11Wr7bna2PR/amSQoAYH6X9Wu6aoq6//77z7l+3333Mc+NyXy8Nl3UihpXtoyV1Dg6gwMAvDTcxMfHy8aNG8+5rq41bty4IcoFN7DbHdUdie/qzYzEAAAvbpZ64IEH9EgpNRy8f//++trKlStl+vTpMn78+IYuI1zkpwO5cuTkaYkI8pchHRONLg4AAMaFG7V+VEREhLz88ssyceJEfa1p06bypz/9SY+Ygjl8st5ZazO0SxMJCfQzujgAABgTbioqKmTOnDl6wj7VqbigoEBfV2EH5lFUWiELthyvHiUFAIDX9rnx9/eXhx56SEpKSqpDDcHGfBZtzZDiMpukNAqVni1ijC4OAADGdihWyy9s2LCh4UoBw5qkbuvRTK8JBgCAV/e5eeSRR+Spp56SI0eOSM+ePc9ZT6pqMU14piMni2XVvhP6+Jc9kowuDgAAxoebu+66S+9rdh5Wv/07HA69t9lsDVdCNLjP1h/V+34tG7FIJgDAci4r3Bw4cKDhSwK3UAG0qkmKjsQAACu65HCTn58vu3fvlrKyMt33Rk3oB/NYd+ikHDxRLKGBfnJjJ+a2AQB4ebhRMxDffPPNkpmZqWsA1Cipjz76SIYMGeK6EqJBVdXa3Ny5iYQFXfai8AAAWGO0lFoUMzU1VVasWCHr1q2TgQMHym9+8xvXlQ4NqqTcJl9uOl49SgoAACu6pF/dVaD5+uuvpUePHvp89uzZEhsbq5uqIiMjXVVGNJAlOzKloLRCkqJDpG9qrNHFAQDA+Jqb3NxcadbszG/80dHRehj4iRPOYcXwbPM3HNP74d2biq8vc9sAAKzpkjtdbN++XTIyMqrPVd+bHTt2VC/DoDDPjec5VVwm3+3O0se3dmNuGwCAdV1yuFH9bFSgqel//ud/mOfGwy3cmiHlNoe0bxIpbRNYLgMAYF2XFG6Y38a85m9wTtx3a7emRhcFAADP6HOzefNmSU5OlhYtWlx0U7Zt26ZXEK+PmTNnSkpKigQHB0vfvn0lLS2tXu+bO3eurikaPnx4fR/DKx07dVrSDubq42FdCTcAAGurd7jp3r37JXUc7tevnxw+fPii982bN0/Gjx8vU6ZMkfXr10vXrl31vDlZWc7+Iedz8OBB+d3vfidXX311vcvkrb7cfExUS2Kf1Fg9UgoAACurd7OU6k8zadIkCQ2t31pEagbj+njllVfkgQcekHHjxunzWbNmyVdffaWHmU+YMKHO96g+Pffcc48899xz8sMPP8ipU6fO+/VLS0v1VkUNW/fWUVI0SQEAvEG9w80111wju3btuqSam5CQkIsGIDV3zsSJE6uv+fr6yqBBg2T16tXnfd+f//xnady4sdx///063FzItGnTdAjyVnsyC2T78Xzx9/WRmzs1Mbo4AAB4TrhZvnx5g//hOTk5uhYmISGh1nV1vnPnzjrfo2ZHfu+99/RSEPWhgpNq9qpZc6P6DnmLzzc5a22ubRsvMWGBRhcHAACXM9XiQmoundGjR8s777wjcXFx9XpPUFCQ3ryRakr878bKJqnuzG0DAPAOhoYbFVD8/Pz0Qpw1qfPExHNXrN63b5/uSDxs2LDqa3a7Xe/9/f11s1mrVq3cUHJz2JB+Sg7nOlcAH9S+sdHFAQDA85ZfaGiBgYHSs2dPWbp0aa2wos5Vn52ztWvXTrZs2aKbpKq2W265Ra6//np97E3NTfXxeWWtzeAOCRIaaKpKOgAALpvhn3iqP8zYsWOlV69e0qdPH5kxY4YUFRVVj54aM2aMJCUl6Y7Bah6cTp061Xq/Wt9KOfu6t7PZHfLlZucK4LcwSgoA4EUMDzcjR46U7OxsmTx5sl6zqlu3brJo0aLqTsZqrhw1ggqXJu1AruQUlkpUSIBc1Tre6OIAAOA2Po6zF4qyODVaKioqSvLy8iQyMlKsatL8rfKvHw/JHT2byV/v6Gp0cQAAcNvnN1UiFm2SWrjV2SQ1tAtz2wAAvAvhxoJ+OnBCcgrLdJPUgNb1GzIPAIBVEG4saMEWZ63NkI4JEuDHf2IAgHfhk8+CTVKLtmbo46FdGCUFAPA+hBuLNklFhwZI/1aNjC4OAABuR7ixmK8q57YZ0iGRJikAgFfi089CKmz2Gk1SjJICAHgnwo3FJu47UeRskupHkxQAwEsRbizky8pRUjd2pEkKAOC9+AS0UJPUYpqkAAAg3FjFT5VNUjGqSaolTVIAAO9FuLGIqo7Egzskij9NUgAAL8anoAXY7Q75ersz3NzYKdHo4gAAYCjCjQVsOnJKMvNLJTzIX/q3pkkKAODdCDcWsGibs9bm+naNJcjfz+jiAABgKMKNyTkcDvl6W2b1QpkAAHg7wo3J7ckqlAM5RRLo7yvXXdHY6OIAAGA4wo3JVc1tc1XrON3nBgAAb0e4sUh/GzUrMQAAINyYWnpusWw7li++PiID29MkBQCAQrgxsa+3OzsS906JlUbhQUYXBwAAj0C4MbHFVU1STNwHAEA1wo1J5RSWypqDufp4MP1tAACoRrgxqSXbM8XhEOmcFCVJ0SFGFwcAAI9BuDF5kxQT9wEAUBvhxoSKSitk5d4T+ngITVIAANRCuDGhH/ZkS5nNLi0ahUrrxuFGFwcAAI9CuDGhJTuy9H5guwTx8fExujgAAHgUwo3J2OwOWbbTGW4GdWDiPgAAzka4MZmN6afkRFGZRAT768n7AABAbYQbk1mywzkrsVoBPMCP/3wAAJyNT0eTWVoZbgaxlhQAAHUi3JjI4RPFsjuzUPx8feS6toQbAADqQrgxYZNU75QYiQoNMLo4AAB4JMKNiSzdWdUkxazEAACcD+HGJPJLyuWn/c6FMgcSbgAAOC/CjUl8vztbKuwOaRUfJqlxYUYXBwAAj0W4MdEq4ApNUgAAXBjhxgQqbHZZtitbHw/qQLgBAOBCCDcmsO7QSck7XS4xoQHSo3mM0cUBAMCjEW5M4NvKtaSuv6KxnuMGAACcH+HGBJZXNkld146J+wAAuBjCjYc7duq07MosEFVhc02bOKOLAwCAxyPcmKTWRvW1iQ4NNLo4AAB4PMKNh1u2y9nf5ror4o0uCgAApkC48WClFTZZtTdHH193Bf1tAACoD8KNB1t78KQUldkkPiJIOjaNNLo4AACYAuHGgy2rHAJ+Xdt48fFhCDgAAPVBuPFgy3dXDgGnSQoAgHoj3Hio9Nxi2ZtVqCftu4oh4AAA1BvhxsNrbXo2j5GokACjiwMAgGkQbjzU8qr+Nu0YAg4AwKUg3HigknKbrNp3ono9KQAAUH+EGw+UdiBXTpfbJDEyWNolRhhdHAAATIVw4+GzEjMEHACAS0O48UDfVa0CzpILAACYM9zMnDlTUlJSJDg4WPr27StpaWnnvfedd96Rq6++WmJiYvQ2aNCgC95vxiHg+3OKxN/XRwa0Zgg4AACmCzfz5s2T8ePHy5QpU2T9+vXStWtXGTJkiGRlOZtmzrZ8+XIZNWqULFu2TFavXi3JyckyePBgOXr0qFjB93vOrAIeEcwQcAAALpWPw+FwiIFUTU3v3r3lzTff1Od2u10Hlscee0wmTJhw0ffbbDZdg6PeP2bMmIven5+fL1FRUZKXlyeRkZ63XtND/1oni7ZlyFO/aCuPDWxjdHEAAPAIl/L5bWjNTVlZmaxbt043LVUXyNdXn6tamfooLi6W8vJyiY2NrfP10tJS/RdSc/NUFTa7rNznXAX86rb0twEA4HIYGm5ycnJ0zUtCQkKt6+o8IyOjXl/j6aeflqZNm9YKSDVNmzZNJ72qTdUKeapNR/KkoKRCokMDpHNSlNHFAQDAlAzvc/NzvPjiizJ37lz57LPPdGfkukycOFFXYVVt6enp4ql+qOxvozoSqzWlAADApfMXA8XFxYmfn59kZmbWuq7OExMTL/jev/3tbzrcLFmyRLp06XLe+4KCgvRmBj/scTZJXcNCmQAAmLPmJjAwUHr27ClLly6tvqY6FKvzfv36nfd9L730kjz//POyaNEi6dWrl1hB3uly2Zh+Sh9f1Yb+NgAAmLLmRlHDwMeOHatDSp8+fWTGjBlSVFQk48aN06+rEVBJSUm674wyffp0mTx5ssyZM0fPjVPVNyc8PFxvZrV6X47Y7A5pFR8mSdEhRhcHAADTMjzcjBw5UrKzs3VgUUGlW7duukamqpPx4cOH9QiqKm+99ZYeZXX77bfX+jpqnpw//elPYlbfVzZJXU2tDQAA5p7nxt08cZ4b9Z/g6peWyZGTp2X2vb3khna1R48BAODt8s0yzw2cDp0o1sEmwM9H+qY2Mro4AACYGuHGA1QNAe/ZIkbCggxvKQQAwNQINx7U3+YaZiUGAOBnI9wYrNxml9X7Tujja+hMDADAz0a4MZia26awtEJiwwKlQxPP6OAMAICZEW4M9sNuZ3+bq1rHiS9LLgAA8LMRbgy2Ym9OdbgBAAA/H+HGQAUl5XolcKV/a4aAAwDQEAg3Bko7kKuXXGjRKFSaxYQaXRwAACyBcGOglXudo6T6t6JJCgCAhkK4MdCqfc7+NgNokgIAoMEQbgySU1gqOzMK9HG/loQbAAAaCuHGIKsqJ+5r3yRSGoUHGV0cAAAsg3BjkFWVQ8AHtKLWBgCAhkS4McjK6v42dCYGAKAhEW4MkJ5bLOm5p8Xf10f6pMYaXRwAACyFcGOAlZVNUt2SoyUsyN/o4gAAYCmEGwOsrOxM3J8mKQAAGhzhxs0cDoesrupvQ2diAAAaHOHGzXZlFkhOYZkEB/hK9+YxRhcHAADLIdwYtORC75RYCfTnrx8AgIbGp6tR89vQ3wYAAJcg3LhRhc0uPx3I1ccDWCwTAACXINy40ZajeVJYWiFRIQHSoWmk0cUBAMCSCDdu9ON+Z61N39RY8fP1Mbo4AABYEuHGjX7c7+xMfCWrgAMA4DKEGzcpt9ll7UFnzQ3hBgAA1yHcuMnWo3lSVGbT/W3aJUYYXRwAACyLcGNAfxtf+tsAAOAyhBs3ob8NAADuQbhxA/rbAADgPoQbN6C/DQAA7kO4cQP62wAA4D6EGzegvw0AAO5DuHEx+tsAAOBehBsXo78NAADuRbhxMfrbAADgXoQbF6O/DQAA7kW4cSH62wAA4H6EGxeivw0AAO5HuHEh+tsAAOB+hBs39LfpS5MUAABuQ7hxkYpa/W1ijS4OAABeg3DjItuO5ev+NpHB/tIuMdLo4gAA4DUINy7y0wFnk1Sf1Fjxo78NAABuQ7hxkZ+qOxPT3wYAAHci3LiAze6QtMr+Nn3pbwMAgFsRblxgx/F8KSipkPAgf+nQhP42AAC4E+HGBX464Ky16ZUSI/5+/BUDAOBOfPK6cn4b+tsAAOB2hJsGZrc7ZA39bQAAMAzhpoHtyiyQU8XlEhroJ52ToowuDgAAXodw08B+qmyS6tkiRgLobwMAgNvx6euizsRqsUwAAOB+hJsG5HA4JK0q3LBYJgAAhiDcNKC9WYVyoqhMggN8pUsz+tsAAOC14WbmzJmSkpIiwcHB0rdvX0lLS7vg/R9//LG0a9dO39+5c2dZsGCBeIIfK2ttejSPkSB/P6OLAwCAVzI83MybN0/Gjx8vU6ZMkfXr10vXrl1lyJAhkpWVVef9q1atklGjRsn9998vGzZskOHDh+tt69at4imdiZnfBgAA4/g4VEcRA6mamt69e8ubb76pz+12uyQnJ8tjjz0mEyZMOOf+kSNHSlFRkXz55ZfV16688krp1q2bzJo166J/Xn5+vkRFRUleXp5ERjbc0gjqr7HP1KWSXVAqcx+8Uq6kzw0AAA3mUj6/Da25KSsrk3Xr1smgQYPOFMjXV5+vXr26zveo6zXvV1RNz/nuLy0t1X8hNTdXOJBTpINNoL+vdEuOdsmfAQAALs7QcJOTkyM2m00SEhJqXVfnGRkZdb5HXb+U+6dNm6aTXtWmaoVc4dipEmkUFqiDTXAA/W0AAPDaPjeuNnHiRF2FVbWlp6e75M+5qk2crH12kLw9uqdLvj4AAKgffzFQXFyc+Pn5SWZmZq3r6jwxMbHO96jrl3J/UFCQ3tzBx8dHokMD3fJnAQAAD6y5CQwMlJ49e8rSpUurr6kOxeq8X79+db5HXa95v/LNN9+c934AAOBdDK25UdQw8LFjx0qvXr2kT58+MmPGDD0aaty4cfr1MWPGSFJSku47ozz++ONy7bXXyssvvyxDhw6VuXPnytq1a+Xtt982+EkAAIAnMDzcqKHd2dnZMnnyZN0pWA3pXrRoUXWn4cOHD+sRVFX69+8vc+bMkWeffVaeeeYZadOmjcyfP186depk4FMAAABPYfg8N+7mqnluAACA65hmnhsAAICGRrgBAACWQrgBAACWQrgBAACWQrgBAACWQrgBAACWQrgBAACWQrgBAACWQrgBAACWYvjyC+5WNSGzmukQAACYQ9Xndn0WVvC6cFNQUKD3ycnJRhcFAABcxue4WobhQrxubSm73S7Hjh2TiIgI8fHxafBUqUJTenq6V6xbxfNaG89rbd72vN74zPkWe14VV1Swadq0aa0FtevidTU36i+kWbNmLv0z1D8iK/xDqi+e19p4Xmvztuf1xmeOtNDzXqzGpgodigEAgKUQbgAAgKUQbhpQUFCQTJkyRe+9Ac9rbTyvtXnb83rjMwd52fN6dYdiAABgbdTcAAAASyHcAAAASyHcAAAASyHcAAAASyHcNJCZM2dKSkqKBAcHS9++fSUtLU2sYNq0adK7d289o3Pjxo1l+PDhsmvXrlr3lJSUyKOPPiqNGjWS8PBwue222yQzM1Os4MUXX9QzWT/xxBOWfd6jR4/Kr371K/08ISEh0rlzZ1m7dm3162rMweTJk6VJkyb69UGDBsmePXvEjGw2m0yaNElSU1P1s7Rq1Uqef/75WmvVmP15v//+exk2bJiexVX9250/f36t1+vzfLm5uXLPPffoid+io6Pl/vvvl8LCQjHb85aXl8vTTz+t/02HhYXpe8aMGaNnqbfi857toYce0vfMmDHDtM97uQg3DWDevHkyfvx4PeRu/fr10rVrVxkyZIhkZWWJ2X333Xf6g/zHH3+Ub775Rv+wGDx4sBQVFVXf8+STT8oXX3whH3/8sb5f/eAYMWKEmN2aNWvk//2//yddunSpdd1Kz3vy5EkZMGCABAQEyMKFC2X79u3y8ssvS0xMTPU9L730krz++usya9Ys+emnn/SHhPr3rUKe2UyfPl3eeustefPNN2XHjh36XD3fG2+8YZnnVd+b6meQ+oWrLvV5PvXBt23bNv09/+WXX+oP1AcffFDM9rzFxcX6Z7IKtGr/6aef6l/Obrnlllr3WeV5a/rss8/0z20Vgs5mpue9bGooOH6ePn36OB599NHqc5vN5mjatKlj2rRpDqvJyspSv+I6vvvuO31+6tQpR0BAgOPjjz+uvmfHjh36ntWrVzvMqqCgwNGmTRvHN99847j22msdjz/+uCWf9+mnn3ZcddVV533dbrc7EhMTHX/961+rr6m/g6CgIMeHH37oMJuhQ4c67rvvvlrXRowY4bjnnnss+bzq3+Vnn31WfV6f59u+fbt+35o1a6rvWbhwocPHx8dx9OhRh5mety5paWn6vkOHDln2eY8cOeJISkpybN261dGiRQvHq6++Wv2amZ/3UlBz8zOVlZXJunXrdNVuzfWr1Pnq1avFavLy8vQ+NjZW79Wzq9qcms/frl07ad68uamfX9VWDR06tNZzWfF5P//8c+nVq5fccccdutmxe/fu8s4771S/fuDAAcnIyKj1vGptF9X0asbn7d+/vyxdulR2796tzzdt2iQrVqyQm266yZLPe7b6PJ/aq6YK9e+iirpf/VxTNT1W+BmmmmrUM1rxedXi0KNHj5bf//730rFjx3Net9rzno/XLZzZ0HJycnQ7fkJCQq3r6nznzp1iJeqbRvU9Uc0YnTp10tfUD8rAwMDqHxQ1n1+9ZkZz587VVdiqWepsVnve/fv362Ya1az6zDPP6Gf+7W9/q59x7Nix1c9U179vMz7vhAkT9ErJKpD6+fnp790XXnhBV9MrVnves9Xn+dReBd2a/P399S80Zv87UE1vqg/OqFGjqheStNrzqqZWf39//X1cF6s97/kQbnBJtRlbt27Vv+laVXp6ujz++OO6LVp1Drc6FVjVb3BTp07V56rmRv03Vv0xVLixmo8++kg++OADmTNnjv6tduPGjTqwq34JVnxenKFqXO+8807doVoFeitSNcuvvfaa/uVM1U55M5qlfqa4uDj9G+DZo2XUeWJioljFb37zG93xbNmyZdKsWbPq6+oZVdPcqVOnLPH86oeD6gjeo0cP/duM2lSnYdUBUx2r33Ct9LxqxEyHDh1qXWvfvr0cPnxYH1c9k1X+fauqelV7c9ddd+kRNKr6XnUQV6MCrfi8Z6vP86n92YMhKioq9Agbs/4dVAWbQ4cO6V9cqmptrPa8P/zwg36W5s2bV//8Us/81FNP6dG8VnveCyHc/Eyq+r5nz566Hb/mb8PqvF+/fmJ26rccFWxUz/tvv/1WD6GtST27GmlT8/nVaAT14WjG5x84cKBs2bJF/0ZftamaDdVsUXVspedVTYxnD+1X/VFatGihj9V/b/UDr+bzqmYd1TZvxudVo2dU34Ka1C8n6nvWis97tvo8n9qr8K6CfhX1va/+jlTfHLMGGzXcfcmSJXrKg5qs9LwqrG/evLnWzy9VK6lC/eLFiy33vBdkdI9mK5g7d64ebfCPf/xD90R/8MEHHdHR0Y6MjAyH2T388MOOqKgox/Llyx3Hjx+v3oqLi6vveeihhxzNmzd3fPvtt461a9c6+vXrpzerqDlaymrPq0aO+Pv7O1544QXHnj17HB988IEjNDTU8e9//7v6nhdffFH/e/7vf//r2Lx5s+PWW291pKamOk6fPu0wm7Fjx+pRJF9++aXjwIEDjk8//dQRFxfn+MMf/mCZ51Uj/TZs2KA39SP+lVde0cdVo4Pq83w33nijo3v37o6ffvrJsWLFCj1ycNSoUQ6zPW9ZWZnjlltucTRr1syxcePGWj/DSktLLfe8dWlx1mgpsz3v5SLcNJA33nhDf+AFBgbqoeE//vijwwrUN09d2//93/9V36N+KD7yyCOOmJgY/cH4y1/+Uv/wsGq4sdrzfvHFF45OnTrpgN6uXTvH22+/Xet1NXx40qRJjoSEBH3PwIEDHbt27XKYUX5+vv5vqb5Xg4ODHS1btnT88Y9/rPVBZ/bnXbZsWZ3fsyrY1ff5Tpw4oT/swsPDHZGRkY5x48bpD1WzPa8KsOf7GabeZ7XnrW+4OWGi571cPur/jK49AgAAaCj0uQEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAFgKvfee68MHz7c6GIA8GD+RhcAAKr4+Phc8PUpU6bIa6+9phd0BYDzIdwA8BjHjx+vPp43b55Mnjy51qrl4eHhegOAC6FZCoDHSExMrN6ioqJ0TU7NayrYnN0sdd1118ljjz0mTzzxhMTExEhCQoK88847UlRUJOPGjZOIiAhp3bq1LFy4sNaftXXrVrnpppv011TvGT16tOTk5Bjw1AAaGuEGgOm9//77EhcXJ2lpaTroPPzww3LHHXdI//79Zf369TJ48GAdXoqLi/X9p06dkhtuuEG6d+8ua9eulUWLFklmZqbceeedRj8KgAZAuAFgel27dpVnn31W2rRpIxMnTpTg4GAddh544AF9TTVvnThxQjZv3qzvf/PNN3WwmTp1qrRr104fz549W5YtWya7d+82+nEA/Ez0uQFgel26dKk+9vPzk0aNGknnzp2rr6lmJyUrK0vvN23apINMXf139u3bJ23btnVLuQG4BuEGgOkFBATUOld9dWpeqxqFZbfb9b6wsFCGDRsm06dPP+drNWnSxOXlBeBahBsAXqdHjx7yySefSEpKivj782MQsBr63ADwOo8++qjk5ubKqFGjZM2aNbopavHixXp0lc1mM7p4AH4mwg0Ar9O0aVNZuXKlDjJqJJXqn6OGkkdHR4uvLz8WAbPzcTDVJwAAsBB+RQEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAGIl/x/lkiT+ogg+5gAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from autoreduce.utils import get_ODE\n", - "sys_ode = get_ODE(sys, timepoints_ode)\n", - "sol = sys_ode.solve_system().T\n", - "try:\n", - " import matplotlib.pyplot as plt\n", - " plt.plot(timepoints_ode, np.transpose(np.array(C)@sol))\n", - " plt.xlabel('Time')\n", - " plt.ylabel('[Product]')\n", - " plt.show()\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\ayush\\Box\\Research\\Caltech biotools and files\\autoReduce\\autoreduce\\local_sensitivity.py:251: RuntimeWarning: invalid value encountered in divide\n", - " SSM_normalized[:, j, i] = np.divide(\n" - ] - } - ], - "source": [ - "from autoreduce.utils import get_SSM\n", - "timepoints_ssm = np.linspace(0,60,10)\n", - "sys_ssm = get_SSM(sys, timepoints_ssm)\n", - "Ss = sys_ssm.compute_SSM(normalize = True) # len(timepoints) x len(params) x len(states)\n", - "out_Ss = []\n", - "for i in range(len(params)):\n", - " out_Ss.append((np.array(C)@(Ss[:,i,:].T)))\n", - "out_Ss = np.reshape(np.array(out_Ss), (len(timepoints_ssm), len(params), nouts))" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "try:\n", - " import seaborn as sn\n", - " for j in range(nouts):\n", - " sn.heatmap(out_Ss[:,:,j].T)\n", - " plt.xlabel('Time')\n", - " plt.ylabel('Parameters')\n", - " plt.title('Sensitivity of output[{0}] with respect to all parameters'.format(j))\n", - " plt.show()\n", - "except:\n", - " print('Plotting libraries missing.')" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful solution obtained with states: [x1]!\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n", - "SSM Progress: |██████████████████████████████████████████████████| 100.0% Complete\n" - ] - }, - { - "ename": "TypeError", - "evalue": "unhashable type: 'System'", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 5\u001b[39m\n\u001b[32m 3\u001b[39m timepoints_ode = np.linspace(\u001b[32m0\u001b[39m, \u001b[32m100\u001b[39m, \u001b[32m100\u001b[39m)\n\u001b[32m 4\u001b[39m sys_reduce = get_reducible(sys, timepoints_ode, timepoints_ssm)\n\u001b[32m----> \u001b[39m\u001b[32m5\u001b[39m results = sys_reduce.reduce_simple()\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\Box\\Research\\Caltech biotools and files\\autoReduce\\autoreduce\\model_reduction.py:1037\u001b[39m, in \u001b[36mReduce.reduce_simple\u001b[39m\u001b[34m(self, **kwargs)\u001b[39m\n\u001b[32m 1035\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 1036\u001b[39m Se, R = \u001b[38;5;28mself\u001b[39m.get_robustness_metric(reduced_sys, **kwargs)\n\u001b[32m-> \u001b[39m\u001b[32m1037\u001b[39m results_dict[reduced_sys] = [e, Se, R]\n\u001b[32m 1038\u001b[39m \u001b[38;5;28mself\u001b[39m.results_dict = results_dict\n\u001b[32m 1039\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m.results_dict\n", - "\u001b[31mTypeError\u001b[39m: unhashable type: 'System'" - ] - } - ], - "source": [ - "from autoreduce.utils import get_reducible\n", - "timepoints_ssm = np.linspace(0,60,10)\n", - "timepoints_ode = np.linspace(0, 100, 100)\n", - "sys_reduce = get_reducible(sys, timepoints_ode, timepoints_ssm)\n", - "results = sys_reduce.reduce_simple()" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{: [0.004223796000449995,\n", - " array([1602.00536597, 217.03400257, 847.81758415, 512.61413589,\n", - " 1962.49827603]),\n", - " 2.0355356851167846e-07]}" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "results" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [], - "source": [ - "err = results[list(results.keys())[0]][0]\n", - "Se = results[list(results.keys())[0]][1]\n", - "weighted_se = 0\n", - "for p, Se_i in zip(params_values, Se):\n", - " weighted_se += p*Se_i" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "4912710.711770492" - ] - }, - "execution_count": 62, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "d_R = weighted_se/err\n", - "d_R" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "4912.714935566492" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "w1 = 1\n", - "w2 = 1e-3\n", - "r = w1*err + w2*d_R\n", - "r" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Successful time-scale separation solution obtained with states: [x1]!\n" - ] - }, - { - "data": { - "text/latex": [ - "$\\displaystyle \\frac{P_{2} \\left(P_{0} P_{3} + P_{0} P_{4} - P_{0} x_{1} + P_{1} + P_{2} - \\sqrt{P_{0}^{2} P_{3}^{2} - 2 P_{0}^{2} P_{3} P_{4} + 2 P_{0}^{2} P_{3} x_{1} + P_{0}^{2} P_{4}^{2} - 2 P_{0}^{2} P_{4} x_{1} + P_{0}^{2} x_{1}^{2} + 2 P_{0} P_{1} P_{3} + 2 P_{0} P_{1} P_{4} - 2 P_{0} P_{1} x_{1} + 2 P_{0} P_{2} P_{3} + 2 P_{0} P_{2} P_{4} - 2 P_{0} P_{2} x_{1} + P_{1}^{2} + 2 P_{1} P_{2} + P_{2}^{2}}\\right)}{2 P_{0}}$" - ], - "text/plain": [ - "P2*(P0*P3 + P0*P4 - P0*x1 + P1 + P2 - sqrt(P0**2*P3**2 - 2*P0**2*P3*P4 + 2*P0**2*P3*x1 + P0**2*P4**2 - 2*P0**2*P4*x1 + P0**2*x1**2 + 2*P0*P1*P3 + 2*P0*P1*P4 - 2*P0*P1*x1 + 2*P0*P2*P3 + 2*P0*P2*P4 - 2*P0*P2*x1 + P1**2 + 2*P1*P2 + P2**2))/(2*P0)" - ] - }, - "execution_count": 64, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "slow_system, fast_system = sys_reduce.solve_timescale_separation([x[1]])\n", - "slow_system.f[0]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "py311-new", - "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.11.13" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/graphics/autoreduce_banner.png b/graphics/autoreduce_banner.png new file mode 100644 index 0000000..688d7cc Binary files /dev/null and b/graphics/autoreduce_banner.png differ diff --git a/pyproject.toml b/pyproject.toml index 2f29da0..cd248a2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,14 +1,15 @@ [build-system] -requires = ["hatchling"] -build-backend = "hatchling.build" +requires = ["setuptools>=77", "setuptools-scm>=8", "wheel"] +build-backend = "setuptools.build_meta" [project] name = "autoreduce" -version = "0.3.1" -description = "Python based automated model reduction tools for SBML models" +dynamic = ["version"] +description = "Python tools for automated model reduction of nonlinear dynamical systems" readme = "README.md" -requires-python = ">=3.9" -license = { file = "LICENSE" } +requires-python = ">=3.9,<=3.14.7" +license = "BSD-3-Clause" +license-files = ["LICENSE"] authors = [{ name = "Ayush Pandey", email = "ayushpandey@ucmerced.edu" }] keywords = [ "SBML", @@ -17,35 +18,128 @@ keywords = [ "QSSA", "Hill functions", ] -dependencies = ["python-libsbml", "sympy", "scipy", "numpy"] +dependencies = ["numpy", "python-libsbml>=5.21.1", "scipy>=1.10", "sympy>=1.11"] [project.optional-dependencies] -all = ["matplotlib", "seaborn"] -test = [ +all = ["control", "matplotlib", "pydmd", "seaborn", "pandas", "biocrnpyler"] +control = ["control"] +dmd = ["pydmd"] +bio = ["biocrnpyler"] +docs = [ + "nbsphinx", + "nbsphinx-link", + "numpydoc", + "pandoc", + "recommonmark", + "setuptools-scm", + "sphinx", + "sphinx-copybutton", + "sphinx-math-dollar", + "sphinx-toggleprompt", + "sphinx_rtd_theme", +] +dev = [ + "build", + "ipykernel", + "jupyter", + "nbconvert", + "nbformat", + "nbsphinx", + "nbsphinx-link", + "numpydoc", + "pandoc", "pytest", "pytest-cov", "pytest-xdist", - "jupyter", + "recommonmark", + "ruff", + "setuptools-scm", + "sphinx", + "sphinx-copybutton", + "sphinx-math-dollar", + "sphinx-toggleprompt", + "sphinx_rtd_theme", +] +test = [ "ipykernel", - "nbformat", + "jupyter", "nbconvert", + "nbformat", + "pytest", + "pytest-cov", + "pytest-xdist", + "matplotlib", + "pandas", ] - [project.urls] Documentation = "https://autoreduce.readthedocs.io" Source = "https://github.com/ayush9pandey/AutoReduce" Tracker = "https://github.com/ayush9pandey/AutoReduce/issues" -[tool.pytest.ini_options] -testpaths = ["tests", "examples"] -python_files = ["test_*.py"] -addopts = "--cov=autoreduce --cov-report=xml" +[tool.setuptools] +include-package-data = true + +[tool.setuptools.packages.find] +include = ["autoreduce", "autoreduce.*"] + +[tool.setuptools_scm] +version_file = "autoreduce/_version.py" +local_scheme = "no-local-version" [tool.coverage.run] +branch = true source = ["autoreduce"] omit = ["tests/*", "setup.py"] -[tool.flake8] -max-line-length = 100 -exclude = ["build", "dist", ".git", "__pycache__", "tests", "examples"] +[tool.coverage.report] +ignore_errors = true +exclude_lines = [ + "if self.debug:", + "pragma: no cover", + "raise NotImplementedError", + "if __name__ == .__main__.:", +] + +[tool.ruff] +line-length = 78 + +[tool.ruff.lint] +select = ["E", "F", "D", "I", "W"] +ignore = [ + "D100", + "D101", + "D102", + "D103", + "D104", + "D105", + "D106", + "D107", + "D200", + "D202", + "D205", + "D400", + "D404", + "D406", + "D407", + "D411", + "D401", + "D417", + "E501", +] + +[tool.ruff.lint.per-file-ignores] +"tests/**.py" = ["D", "E", "F841"] +"examples/**.py" = ["D", "E"] +"docs/**.py" = ["D", "E"] +"__init__.py" = ["F401"] + +[tool.ruff.format] +quote-style = "preserve" + +[tool.ruff.lint.pydocstyle] +convention = "numpy" + +[tool.isort] +profile = "black" +line_length = 78 diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 0000000..3dd9c3e --- /dev/null +++ b/pytest.ini @@ -0,0 +1,12 @@ +[pytest] +minversion = 7.0 +testpaths = + tests +python_files = + test_*.py +pythonpath = + . +addopts = + --durations=10 +markers = + notebooks: execute example notebooks. diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index 049f98b..0000000 --- a/requirements.txt +++ /dev/null @@ -1,13 +0,0 @@ -sympy -python-libsbml -scipy -numpy -pytest -pytest-cov -jupyter -ipykernel -nbformat -nbconvert -pytest-xdist -matplotlib -seaborn diff --git a/tests/README.md b/tests/README.md index e69ee35..3bf967a 100644 --- a/tests/README.md +++ b/tests/README.md @@ -1,5 +1,10 @@ -In order to run tests, simply run `pytest` from terminal. +Install test dependencies and run `pytest` from the repository root: + +```bash +pip install -e ".[test]" +pytest +``` Building Tests: Tests can be added with existing tests (which are organized by object) or as new test sets for more complex features. -All tests should be commented so that it is clear what the test is meant to check for. \ No newline at end of file +All tests should be commented so that it is clear what the test is meant to check for. diff --git a/tests/conftest.py b/tests/conftest.py index 69f3afa..3736e9b 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,11 +1,11 @@ -from sympy import Symbol # type: ignore +from pathlib import Path + import numpy as np # type: ignore import pytest # type: ignore -from pathlib import Path +from sympy import Symbol # type: ignore -from autoreduce.system import System -from autoreduce.utils import get_reducible -from autoreduce.converters import load_sbml +from autoreduce import System, load_sbml +from autoreduce.reductions.core import get_reducible @pytest.fixture diff --git a/tests/test_auto_reduce.py b/tests/test_auto_reduce.py index 7fa3906..2156058 100644 --- a/tests/test_auto_reduce.py +++ b/tests/test_auto_reduce.py @@ -1,7 +1,13 @@ # Copyright (c) 2020, Ayush Pandey. All rights reserved. # See LICENSE file in the project root directory for details. -from autoreduce.system import System +import warnings + +import pytest + +from autoreduce import explore_all_QSS_models, solve_timescale_separation +from autoreduce.reductions.core import Reduce +from autoreduce.system.system import System def test_get_reduced_model(reducible_system_1): @@ -24,11 +30,64 @@ def test_get_reduced_model(reducible_system_1): assert isinstance(collapsed_system, System) +def test_direct_solve_timescale_separation(system_1): + """Solve a QSSA reduction without creating a reducible object first.""" + A, _, C, D = system_1.x + assert system_1.timepoints_ode is None + reduced_system, collapsed_system = solve_timescale_separation( + system_1, [A, C, D], timepoints_ode=[0.0, 1.0] + ) + + assert system_1.timepoints_ode is None + assert isinstance(reduced_system, System) + assert isinstance(collapsed_system, System) + assert reduced_system.x == [A, C, D] + + +def test_direct_reduction_imports_are_public(): + """The simplified reduction helpers are exported from public packages.""" + from autoreduce import explore_all_QSS_models as package_explore + from autoreduce.reductions import ( + explore_all_QSS_models as reductions_explore, + ) + + assert package_explore is reductions_explore + + +def test_direct_explore_all_QSS_models(system_1): + """Explore candidate reductions without creating a reducible object first.""" + with warnings.catch_warnings(): + warnings.filterwarnings( + "ignore", message="Solve time-scale separation failed" + ) + results = explore_all_QSS_models( + system_1, + nstates_tol=3, + nstates_tol_min=2, + skip_numerical_computations=True, + ) + + assert isinstance(results, dict) + assert results + assert all(isinstance(reduced_system, System) for reduced_system in results) + assert all(result is None for result in results.values()) + + +def test_explore_all_QSS_models_requires_timepoints_for_metrics(system_1): + """Numerical metrics require ODE and SSM timepoints.""" + with pytest.raises( + ValueError, + match="timepoints_ode is used for accuracy", + ): + explore_all_QSS_models(system_1) + + def test_biocrnplyer_model(system_2): """ This function tests the biocrnpyler model """ assert isinstance(system_2, System) + assert not isinstance(system_2, Reduce) assert len(system_2.x) == 3 assert len(system_2.f) == 3 assert len(system_2.params) == 1 diff --git a/tests/test_conservation.py b/tests/test_conservation.py new file mode 100644 index 0000000..35d4f35 --- /dev/null +++ b/tests/test_conservation.py @@ -0,0 +1,76 @@ +import numpy as np +import pytest +from sympy import Symbol + +from autoreduce import System, find_conserved_sets, solve_conservation_laws +from autoreduce.reductions.core import Reduce + + +def test_search_depth_and_direct_solver(): + """Find and apply enzyme conservation from a plain System object.""" + S = Symbol("S") + E = Symbol("E") + C = Symbol("C") + P = Symbol("P") + k1 = Symbol("k1") + k2 = Symbol("k2") + k3 = Symbol("k3") + + system = System( + [S, E, C, P], + [ + -k1 * S * E + k2 * C, + -k1 * S * E + (k2 + k3) * C, + k1 * S * E - (k2 + k3) * C, + k3 * C, + ], + params=[k1, k2, k3], + params_values=[1.0, 0.5, 0.25], + x_init=[10.0, 1.0, 0.0, 0.0], + C=np.array([[0.0, 0.0, 0.0, 1.0]]), + ) + + with pytest.raises(ValueError, match="search_depth=1"): + find_conserved_sets(system, search_depth=1) + + assert find_conserved_sets(system, search_depth=2) == [[E, C]] + + conserved_system = solve_conservation_laws( + system, + total_quantities={"E_total": 1.0}, + conserved_sets=[[E, C]], + states_to_eliminate=[E], + ) + assert isinstance(conserved_system, System) + assert not isinstance(conserved_system, Reduce) + assert conserved_system.x == [S, C, P] + assert len(conserved_system.x_init) == len(conserved_system.x) + assert system.x == [S, E, C, P] + assert len(system.x_init) == len(system.x) + assert Symbol("E_total") in system.params + assert Symbol("E_total") in conserved_system.params + + +def test_conservation_rejects_eliminated_output_state(): + """A state used directly in y=Cx cannot be eliminated algebraically.""" + S = Symbol("S") + E = Symbol("E") + C = Symbol("C") + k = Symbol("k") + + system = System( + [S, E, C], + [-k * S * E, -k * S * E, k * S * E], + params=[k], + params_values=[1.0], + x_init=[10.0, 1.0, 0.0], + C=np.array([[0.0, 1.0, 0.0]]), + ) + + with pytest.raises(ValueError, match="linear output C@x"): + solve_conservation_laws( + system, + total_quantities={"E_total": 1.0}, + conserved_sets=[[E, C]], + states_to_eliminate=[E], + ) diff --git a/tests/test_converters.py b/tests/test_converters.py new file mode 100644 index 0000000..40063c8 --- /dev/null +++ b/tests/test_converters.py @@ -0,0 +1,60 @@ +from pathlib import Path + +import numpy as np +import pytest +from sympy import Symbol + +from autoreduce import load_ode_model, load_sbml + +MODEL_FILE = Path(__file__).parent / "models" / "example_1.xml" + + +def test_load_sbml_reports_missing_file(): + missing_file = Path(__file__).parent / "models" / "missing.xml" + + with pytest.raises(FileNotFoundError, match="SBML file not found"): + load_sbml(missing_file) + + +def test_load_sbml_rejects_unknown_output(): + with pytest.raises(ValueError, match="did not match any species"): + load_sbml(MODEL_FILE, outputs=["not_a_species"]) + + +def test_load_sbml_selects_matching_output(capsys): + system = load_sbml(MODEL_FILE, outputs=["P"]) + + captured = capsys.readouterr() + assert "Your output 'P' is now set using the system.C matrix!" in captured.out + np.testing.assert_array_equal(system.C, np.array([[0.0, 0.0, 1.0]])) + + +def test_load_sbml_creates_params_dict(): + system = load_sbml(MODEL_FILE) + + assert system.params_dict == dict(zip(system.params, system.params_values)) + + +def test_load_sbml_can_rename_species_for_analysis(): + system = load_sbml( + MODEL_FILE, + outputs=["protein_E"], + rename_species={"protein_E": "enzyme"}, + ) + + assert system.x[0] == Symbol("enzyme") + assert Symbol("enzyme") in system.f[1].free_symbols + np.testing.assert_array_equal(system.C, np.array([[1.0, 0.0, 0.0]])) + + +def test_load_ode_model_rejects_unknown_output(): + with pytest.raises(ValueError, match="did not match any state"): + load_ode_model(2, outputs=["x2"]) + + +def test_load_ode_model_accepts_known_output(): + x, f, params = load_ode_model(2, 1, outputs=["x1"]) + + assert [str(state) for state in x] == ["x0", "x1"] + assert [str(ode) for ode in f] == ["f0", "f1"] + assert [str(param) for param in params] == ["P0"] diff --git a/tests/test_jupyter_notebooks.py b/tests/test_jupyter_notebooks.py index 4fb771b..e149570 100644 --- a/tests/test_jupyter_notebooks.py +++ b/tests/test_jupyter_notebooks.py @@ -1,52 +1,72 @@ -from os import listdir, getcwd, pardir, environ -from os.path import join, abspath import asyncio +import os import sys +from pathlib import Path import pytest -# Set environment variable to use platformdirs -environ["JUPYTER_PLATFORM_DIRS"] = "1" +os.environ["JUPYTER_PLATFORM_DIRS"] = "1" +os.environ["JUPYTER_ALLOW_INSECURE_WRITES"] = "1" +os.environ["PYTHONPATH"] = ( + str(Path.cwd()) + + os.pathsep + + os.environ.get("PYTHONPATH", "") +) -# Set event loop policy for Windows if sys.platform == "win32": asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy()) nb_not_installed = False try: import nbformat - from nbconvert.preprocessors import ExecutePreprocessor, CellExecutionError + from nbconvert.preprocessors import ( + CellExecutionError, + ExecutePreprocessor, + ) except ModuleNotFoundError: nb_not_installed = True -# Helper function to load and run notebooks with a given name at a given path -def run_notebook(filename, path): - with open(filename) as nb_file: - ep = ExecutePreprocessor() - nb = nbformat.read(nb_file, nbformat.NO_CONVERT) - try: - ep.preprocess(nb, {"metadata": {"path": path}}) - except CellExecutionError: - msg = f"\nError executing the notebook {join(path, filename)}\n" - print(msg) - raise +def run_notebook(filename: Path): + """Execute a notebook in its own directory.""" + with filename.open(encoding="utf-8") as nb_file: + notebook = nbformat.read(nb_file, nbformat.NO_CONVERT) + processor = ExecutePreprocessor(timeout=600, kernel_name="python3") + try: + processor.preprocess( + notebook, + {"metadata": {"path": str(filename.parent)}}, + ) + except CellExecutionError: + msg = f"\nError executing the notebook {filename}\n" + print(msg) + raise + + +ALL_NOTEBOOKS = sorted(Path("examples").rglob("*.ipynb")) +EXECUTED_NOTEBOOKS = [ + Path("examples/ecological/Viral spread.ipynb"), +] -# Create a list of all notebooks to run -# ADD NEW EXAMPLE FOLDERS HERE IF NEEDED -cwd = getcwd() -paths = [join(cwd, "examples")] -nb_names = [] -for p in paths: - nb_names += [join(p, f) for f in listdir(p) if f[-6:] == ".ipynb"] +@pytest.mark.notebooks +@pytest.mark.parametrize("notebook", ALL_NOTEBOOKS) +@pytest.mark.skipif( + nb_not_installed, + reason="requires nbformat and nbconvert to be installed", +) +def test_notebook_is_valid_json(notebook): + """Read every example notebook with nbformat.""" + with notebook.open(encoding="utf-8") as handle: + nbformat.read(handle, nbformat.NO_CONVERT) -# create an iterative test to make sure each notebook runs without any errors. -@pytest.mark.parametrize("nb", nb_names) +@pytest.mark.notebooks +@pytest.mark.parametrize("notebook", EXECUTED_NOTEBOOKS) @pytest.mark.skipif( - nb_not_installed, reason="requires jupyter to be installed" + nb_not_installed, + reason="requires nbformat and nbconvert to be installed", ) -def test_jupyter_notebooks(nb): - path = abspath(join(nb, pardir)) - run_notebook(nb, path) +def test_smoke_jupyter_notebooks(notebook): + """Execute lightweight smoke notebooks without errors.""" + run_notebook(notebook) diff --git a/tests/test_objects.py b/tests/test_objects.py index 7611206..00033a5 100644 --- a/tests/test_objects.py +++ b/tests/test_objects.py @@ -1,69 +1,64 @@ import numpy as np # type: ignore -from autoreduce import load_ODE_model -from autoreduce import System -from autoreduce.ode import ODE -from autoreduce.local_sensitivity import SSM - - -# ## System object attributes - - -# Create symbolic objects -x, f, P = load_ODE_model(2, 2) -f[0] = -x[0] ** 2 + P[0] * x[1] -f[1] = -P[1] * x[1] -print("The states : {0}".format(x)) -print("The dynamics f : {0}".format(f)) -print("The dynamics P : {0}".format(P)) -C = np.array([[0, 1]]).tolist() - - -# System class -sys = System(x, f, params=P, C=C) - - -# ## Solve the System using the ODE subclass - - -# Solve ODE from System - -timepoints = np.linspace(0, 20, 100) -sys.params_values = [2, 4] -sys.x_init = [0, 10] -sys_ode = ODE( - sys.x, - sys.f, - params=sys.params, - params_values=sys.params_values, - C=sys.C, - x_init=sys.x_init, - timepoints=timepoints, -) -solution = sys_ode.solve_system() - - -# ## Local sensitivity analysis tools for System using the SSM subclass - - -# Solve for sensitivity analysis from System - -timepoints = np.linspace(0, 20, 10) -sys.params_values = [2, 4] -sys.x_init = [0, 10] -sys_ssm = SSM( - sys.x, - sys.f, - params=sys.params, - params_values=sys.params_values, - C=sys.C, - x_init=sys.x_init, - timepoints=timepoints, -) -solution = sys_ssm.compute_SSM() - -J = sys_ssm.compute_J([2, 1]) -Z = sys_ssm.compute_Zj([2, 1], 1) -print("J = ", J) -print("Z = ", Z) -print("SSM = ", solution) +from autoreduce.solvers.ode import ODE +from autoreduce.solvers.ssm import SSM +from autoreduce.solvers.utils import solve_sensitivity +from autoreduce.system.system import System +from autoreduce.utils.converters import load_ode_model + + +def test_solver_objects_from_symbolic_model(): + """Build ODE and SSM solver objects from a symbolic system.""" + x, f, params = load_ode_model(2, 2) + f[0] = -(x[0] ** 2) + params[0] * x[1] + f[1] = -params[1] * x[1] + output_matrix = np.array([[0, 1]]).tolist() + system = System(x, f, params=params, C=output_matrix) + + timepoints = np.linspace(0, 4, 3) + params_values = [2, 4] + x_init = [0, 10] + + ode_solver = ODE( + system.x, + system.f, + params=system.params, + params_values=params_values, + C=system.C, + x_init=x_init, + timepoints=timepoints, + ) + ssm_solver = SSM( + system.x, + system.f, + params=system.params, + params_values=params_values, + C=system.C, + x_init=x_init, + timepoints=timepoints, + ) + + assert isinstance(ode_solver.solve_system(), np.ndarray) + assert isinstance(ssm_solver.compute_J([2, 1]), np.ndarray) + assert isinstance(ssm_solver.compute_Zj([2, 1], 1), np.ndarray) + + +def test_direct_sensitivity_solver_matches_linear_analytic_solution(): + """Solve sensitivity ODEs directly for a one-state decay model.""" + x, f, params = load_ode_model(1, 1) + k = params[0] + f[0] = -k * x[0] + system = System( + x, + f, + params=params, + params_values=[0.4], + x_init=[5.0], + C=np.array([[1.0]]), + ) + + timepoints = np.linspace(0.0, 5.0, 101) + sensitivities = solve_sensitivity(system, timepoints) + analytical = -timepoints * 5.0 * np.exp(-0.4 * timepoints) + + np.testing.assert_allclose(sensitivities[:, 0, 0], analytical, atol=1e-6) diff --git a/tests/test_ode.py b/tests/test_ode.py index 39ab9ac..752e2c6 100644 --- a/tests/test_ode.py +++ b/tests/test_ode.py @@ -4,9 +4,9 @@ import numpy as np # type: ignore from scipy.integrate import odeint # type: ignore -from autoreduce.ode import ODE -from autoreduce.system import System -from autoreduce.utils import get_ODE +from autoreduce.solvers.ode import ODE +from autoreduce.solvers.utils import get_ODE +from autoreduce.system.system import System def test_ode_objects(system_1): diff --git a/tests/test_optional_integrations.py b/tests/test_optional_integrations.py new file mode 100644 index 0000000..ef8f715 --- /dev/null +++ b/tests/test_optional_integrations.py @@ -0,0 +1,60 @@ +import numpy as np +import pytest +from sympy import Symbol + + +def test_control_adapter_when_dependency_is_installed(): + """Convert a python-control nonlinear IO system when control is present.""" + control = pytest.importorskip("control") + + from autoreduce.system.control import from_nonlinear_io_system + from autoreduce.system.system import System + + def update(_t, x, _u, params): + return [-params["k"] * x[0]] + + io_system = control.NonlinearIOSystem(update, None, states=1) + x = [Symbol("x")] + k = Symbol("k") + system = from_nonlinear_io_system( + io_system, + x, + params=[k], + params_values=[2.0], + x_init=[1.0], + ) + + assert isinstance(system, System) + assert system.f == [-k * x[0]] + + +def test_dmd_projection_when_dependency_is_installed(): + """Fit a PyDMD model when PyDMD is present.""" + pytest.importorskip("pydmd") + + from autoreduce.reductions.projection.dmd import fit_dmd + + time = np.linspace(0.0, 1.0, 8) + snapshots = np.vstack([np.exp(-time), np.exp(-2.0 * time)]) + reduction = fit_dmd(snapshots, svd_rank=1) + + assert reduction.snapshots.shape == snapshots.shape + assert reduction.reduced_dimension == 1 + + +def test_pydmd_linear_operator_adapter(): + """Convert a DMD-style linear operator into a symbolic System.""" + from autoreduce.system.pydmd import from_linear_operator + from autoreduce.system.system import System + + x0 = Symbol("x0") + x1 = Symbol("x1") + system = from_linear_operator( + np.array([[0, 1], [-2, -3]]), + [x0, x1], + discrete_time=False, + ) + + assert isinstance(system, System) + assert system.x == [x0, x1] + assert system.f == [x1, -2 * x0 - 3 * x1] diff --git a/tests/test_system.py b/tests/test_system.py index b68cb15..8ae3edd 100644 --- a/tests/test_system.py +++ b/tests/test_system.py @@ -1,78 +1,147 @@ -# Copyright (c) 2020, Ayush Pandey. All rights reserved. -# See LICENSE file in the project root directory for details. +# Copyright (c) 2020, Ayush Pandey. All rights reserved. +# See LICENSE file in the project root directory for details. + +import numpy as np +import pytest +from sympy import Symbol + +from autoreduce import solve_conservation_laws, solve_timescale_separation +from autoreduce.system.system import System + + +def test_system_equality(system_1): + """Check that equivalent `System` objects compare equal.""" + system_copy = System( + system_1.x, + system_1.f, + params=system_1.params, + x_init=system_1.x_init, + params_values=system_1.params_values, + C=system_1.C, + g=system_1.g, + h=system_1.h, + u=system_1.u, + input_values=system_1.input_values, + ) + assert system_1 == system_copy + + +def test_system_attributes(system_1): + """Check that core symbolic system attributes are stored intact.""" + assert len(system_1.x) == 4 + assert len(system_1.f) == 4 + assert len(system_1.params) == 3 + assert system_1.params_values == [2, 4, 6] + assert system_1.params_dict == { + system_1.params[0]: 2, + system_1.params[1]: 4, + system_1.params[2]: 6, + } + assert np.array_equal(system_1.x_init, np.ones(4)) + assert system_1.C is None + assert system_1.g is None + assert system_1.h is None + assert system_1.u is None + + +def test_system_can_be_created_with_params_dict(): + """Create a System from params_dict instead of params and params_values.""" + x = [Symbol("x")] + k1 = Symbol("k1") + k2 = Symbol("k2") + system = System( + x, + [-k1 * x[0] + k2], + params_dict={k1: 2, k2: 4}, + x_init=[1.0], + ) + + assert system.params == [k1, k2] + assert system.params_values == [2, 4] + assert system.params_dict == {k1: 2, k2: 4} + + +def test_system_rejects_params_dict_with_params_values(system_1): + """Avoid ambiguous parameter inputs.""" + with pytest.raises(ValueError, match="params_dict"): + System( + system_1.x, + system_1.f, + params=system_1.params, + params_values=system_1.params_values, + params_dict=system_1.params_dict, + x_init=system_1.x_init, + ) + + +def test_system_get_and_set_param(system_1): + """Read and write one parameter by exact symbol key.""" + first_param = system_1.params[0] + + assert system_1.get_param(first_param) == 2 + assert system_1.set_param(first_param, 10) == 10 + assert system_1.get_param(first_param) == 10 + assert system_1.params_values[0] == 10 + + +def test_system_get_param_requires_exact_key(system_1): + """Parameter names are exact keys in params_dict.""" + with pytest.raises(ValueError, match="was not found"): + system_1.get_param("k1") + + +def test_system_update_param_dict(system_1): + """Push direct params_dict edits back to params_values.""" + second_param = system_1.params[1] + + system_1.params_dict[second_param] = 20 + system_1.update_param_dict() + + assert system_1.params_values[1] == 20 + + +def test_system_set_param_dict(system_1): + """Set parameter values from a dictionary.""" + first_param = system_1.params[0] + third_param = system_1.params[2] + + system_1.set_param_dict({first_param: 12, third_param: 30}) + + assert system_1.params_dict[first_param] == 12 + assert system_1.params_dict[third_param] == 30 + assert system_1.params_values == [12, 4, 30] + + +def test_system_set_param_dict_requires_exact_keys(system_1): + """set_param_dict uses exact parameter keys.""" + with pytest.raises(ValueError, match="were not found"): + system_1.set_param_dict({"k1": 12}) + + +def test_public_imports_are_exported(): + """Confirm common system and reduction APIs are importable.""" + import autoreduce.solvers + import autoreduce.system + import autoreduce.utils + + assert autoreduce.System is System + assert autoreduce.system.System is System + assert autoreduce.solvers.get_ODE.__name__ == "get_ODE" + assert not hasattr(autoreduce, "get_reducible") + with pytest.raises(AttributeError): + getattr(autoreduce.utils, "get_reducible") + with pytest.raises(AttributeError): + getattr(autoreduce.utils, "get_ODE") + assert solve_conservation_laws.__name__ == "solve_conservation_laws" + assert solve_timescale_separation.__name__ == "solve_timescale_separation" + + +def test_system_string_and_pretty_print(system_1, capsys): + """Check concise and rich text display for System objects.""" + assert str(system_1) == str(system_1.f) -import warnings -import pytest # type: ignore - - -@pytest.fixture -def system_1_setup(): - system1 = None - return system1 - - -@pytest.fixture -def system_2_setup(): - system2 = None - return system2 - - -def test_system_equality(system1=None, system2=None): - """ - Test all properties of two systems for equality - """ - if system1 is None and system2 is None: - return - elif system1 is None or system2 is None: - warnings.warn("One of the System objects is None.") - else: - test_states() - test_f() - test_g() - test_h() - test_params() - test_initial_conditions() - test_params_values() - test_C() - - -def test_states(system1=None, system2=None): - if system1 is not None and system2 is not None: - assert system1.x == system2.x - - -def test_f(system1=None, system2=None): - if system1 is not None and system2 is not None: - assert system1.f == system2.f - - -def test_g(system1=None, system2=None): - if system1 is not None and system2 is not None: - assert system1.g == system2.g - - -def test_h(system1=None, system2=None): - if system1 is not None and system2 is not None: - assert system1.h == system2.h - - -def test_params(system1=None, system2=None): - if system1 is not None and system2 is not None: - assert system1.params == system2.params - - -def test_params_values(system1=None, system2=None): - if system1 is not None and system2 is not None: - assert system1.params_values == system2.params_values - - -def test_initial_conditions(system1=None, system2=None): - if system1 is not None and system2 is not None: - if system1.x_init is not None and system2.x_init is not None: - assert system1.x_init == system2.x_init - - -def test_C(system1=None, system2=None): - if system1 is not None and system2 is not None: - if system1.C is not None and system2.C is not None: - assert system1.C == system2.C + system_1.pretty_print() + captured = capsys.readouterr() + assert "AutoReduce System object with 4 state variables" in captured.out + assert "system equations:" in captured.out + assert r"\left[" in captured.out diff --git a/tests/test_time_scale_separation.py b/tests/test_time_scale_separation.py index 556d1f2..b1c60d3 100644 --- a/tests/test_time_scale_separation.py +++ b/tests/test_time_scale_separation.py @@ -2,7 +2,8 @@ # See LICENSE file in the project root directory for details. import pytest # type: ignore -from autoreduce import System + +from autoreduce.system.system import System def test_reduced_models(system_1, reducible_system_1):