tutorials/5. Executing simulations/Executing individual simulations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f1506c01-7d11-47d9-8d6d-e028751fbe09",
   "metadata": {},
   "source": [
    "# Executing individual simulations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5bf717b-3d27-48e7-ac08-79124dd32af7",
   "metadata": {},
   "source": [
    "This tutorial illustrates how to use Python APIs for simulation tools to programmatically execute individual simulations. This flexibility functionality can be used for a variety of purposes such as for sampling ensembles of stochastic trajectories, scanning and estimating parameters, and co-simulating mutiple models. For co-simulation, we recommend [Vivarium](https://vivarium-collective.github.io/), a Python framework for multi-algorithmic co-simulation.\n",
    "\n",
    "Information about the capabilities (supported model formats, modeling frameworks, simulation types, simulation algorithms, observables) of each simulation tool is available from [BioSimulators](https://biosimulators.org). These capabilties are described using several ontologies. Please see the [Programmatically getting information about simulation tools from BioSimulators tutorial](../4.%20Finding%20simulation%20tools/Programmatically%20getting%20information%20about%20simulation%20tools%20from%20BioSimulators.ipynb) for more information about how to use this information to identify and use appropriate simulation tools."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4adbbc5d-ab9a-41cd-9815-931f7fc57ad4",
   "metadata": {},
   "source": [
    "## 1. Executing time course simulations (e.g., continuous and discrete kinetic simulations)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2ad09c8-7b6d-4cf6-a8ab-f3071f5c28c4",
   "metadata": {},
   "source": [
    "Use [BioSimulators-utils](https://github.com/biosimulators/Biosimulators_utils) to describe the desired simulation. BioSimulators-utils provides several classes for describing simulations which parallel the [Simulation Experiment Description Markup Language (SED-ML)](http://sed-ml.org/).\n",
    "\n",
    "These classes utilize three ontologies:\n",
    "* Modeling formats: [SED-ML model language URNs](https://sed-ml.org/urns.html)\n",
    "* Outputs of implicit simulation variables: [SED-ML symbol URNs](https://sed-ml.org/urns.html)\n",
    "* Simulation algorithms and their parameters: [Kinetic Simulation Algorithm Ontology (KiSAO)](https://github.com/SED-ML/KiSAO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "dc0a142c-314d-4c02-aeaa-6984d356451b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from biosimulators_utils.sedml.data_model import Task, Model, ModelLanguage, UniformTimeCourseSimulation, Algorithm, Variable, Symbol"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb4a0ef9-4344-45cf-8258-4081ee1d005a",
   "metadata": {},
   "source": [
    "For example, use these classes to describe a 10-time unit simulation of the continuous kinetic ([SBO_0000293](https://www.ebi.ac.uk/ols/ontologies/sbo/terms?iri=http%3A%2F%2Fbiomodels.net%2FSBO%2FSBO_0000293)) [Ciliberto et al. morphogenesis checkpoint model](../_data/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.xml) using the Systems Biology Markup Language (SBML) format ([EDAM:format_2585](https://www.ebi.ac.uk/ols/ontologies/edam/terms?iri=http%3A%2F%2Fedamontology.org%2Fformat_2585), SED-ML model language URN: `sbml`) and the CVODE algorithm ([KISAO_0000019](https://www.ebi.ac.uk/ols/ontologies/kisao/terms?iri=http%3A%2F%2Fwww.biomodels.net%2Fkisao%2FKISAO%23KISAO_0000019)) with the predicted variables recorded at the initial time point and at 10 additionally uniformly spaced steps from the initial time (0) to the final time (10)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "588118cc-9b76-4f48-b2f6-e594b405f2e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "task = Task(\n",
    "    model=Model(\n",
    "        source='../_data/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.xml',\n",
    "        language=ModelLanguage.SBML.value,        \n",
    "    ),\n",
    "    simulation=UniformTimeCourseSimulation(\n",
    "        initial_time=0.,\n",
    "        output_start_time=0.,\n",
    "        output_end_time=10.,\n",
    "        number_of_steps=10,\n",
    "        algorithm=Algorithm(\n",
    "            kisao_id='KISAO_0000019',\n",
    "        ),\n",
    "    ),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec88ab52-e51e-4806-839c-0be9cd01e662",
   "metadata": {},
   "source": [
    "Next, use these classes to describe the outputs (e.g., time, concentrations of species, fluxes/rates/velocities of reactions, sizes of compartments) that should be recorded for the simulation. Outputs for variables explicitly defined in SBML files must be described using their [XML XPaths](https://www.w3schools.com/xml/xpath_syntax.asp) (e.g., `/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Clb\"]` for the species with id `Clb`). Outputs for variables not explicitly defined in SBML files (e.g., time) must be described using SED-ML symbol URNs (e.g., `urn:sedml:symbol:time` for time)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ee55e283-b43b-42f5-b707-eb25aa8db214",
   "metadata": {},
   "outputs": [],
   "source": [
    "sbml_uri = 'http://www.sbml.org/sbml/level2/version4'\n",
    "variables = [\n",
    "    Variable(\n",
    "        id='time',\n",
    "        symbol=Symbol.time.value,\n",
    "        task=task,\n",
    "    ),    \n",
    "    Variable(\n",
    "        id='clb',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Clb\"]',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "    Variable(\n",
    "        id='cln',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Cln\"]',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "    Variable(\n",
    "        id='sbf',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"SBF\"]',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "    Variable(\n",
    "        id='sic1',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Sic\"]',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "690a5ec8-7378-467c-be73-3d1e9618be3e",
   "metadata": {},
   "source": [
    "Next, import a simulation tool which can execute time course simulations of models defined in SBML with CVODE such as [tellurium](https://biosimulators.org/simulators/tellurium). [BioSimulators](https://biosimulators.org) provides extensive information about the capabilities of each simulation tool which can be used to identify an appopriate tool for a specific simulation. In addition, [runBioSimulations](https://run.biosimulations.org/) provides wizards that can recommend specific simulation tools for specific projects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "28f787eb-fa25-43dc-9c6e-bc419d3df76a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import biosimulators_tellurium"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eceb613-2ec5-4000-bcc0-88e14415fd1f",
   "metadata": {},
   "source": [
    "Next, use the `exec_sed_task` method to execute the simulation and record the desired output variables. Each Python API validated by BioSimulators provides the same simulation methods with the same function signatures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "adc509c3-bce6-4255-978e-49a8ed20f791",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.9/site-packages/biosimulators_utils/warnings.py:31: BioSimulatorsWarning:\n",
      "\n",
      "\u001b[33mModel `None` may be invalid.\n",
      "  - The model file `../_data/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.xml` may be invalid.\n",
      "    - The value of the 'sboTerm' attribute on a <species> is expected to be an SBO identifier (http://www.biomodels.net/SBO/). In SBML Level 2 prior to Version 4 it is expected to refer to a participant physical type (i.e., terms derived from SBO:0000236, \"participant physical type\"); in Versions 4 and above it is expected to refer to a material entity (i.e., terms derived from SBO:0000240, \"material entity\").\n",
      "      Reference: L2V4 Section 5\n",
      "       SBO term 'SBO:0000014' on the <species> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <species> is expected to be an SBO identifier (http://www.biomodels.net/SBO/). In SBML Level 2 prior to Version 4 it is expected to refer to a participant physical type (i.e., terms derived from SBO:0000236, \"participant physical type\"); in Versions 4 and above it is expected to refer to a material entity (i.e., terms derived from SBO:0000240, \"material entity\").\n",
      "      Reference: L2V4 Section 5\n",
      "       SBO term 'SBO:0000236' on the <species> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <species> is expected to be an SBO identifier (http://www.biomodels.net/SBO/). In SBML Level 2 prior to Version 4 it is expected to refer to a participant physical type (i.e., terms derived from SBO:0000236, \"participant physical type\"); in Versions 4 and above it is expected to refer to a material entity (i.e., terms derived from SBO:0000240, \"material entity\").\n",
      "      Reference: L2V4 Section 5\n",
      "       SBO term 'SBO:0000236' on the <species> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000336' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000336' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000393' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000393' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000393' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000393' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000393' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000393' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000393' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <assignmentRule> <math> expression 'kswe_prime * Swe1 + kswe_doubleprime * Swe1M + kswe_tripleprime * PSwe1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <assignmentRule> <math> expression 'kmih_prime * Mih_ast + kmih_doubleprime * Mih' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <assignmentRule> <math> expression 'IEtot - IE' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <assignmentRule> <math> expression 'Cdh1tot - Cdh1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <assignmentRule> <math> expression 'Mih1tot - Mih1a' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <assignmentRule> <math> expression 'Mcmtot - Mcm' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <assignmentRule> <math> expression 'SBFtot - SBF' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdiss * Trim' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Trim * (kdsic_prime * Cln + kdsic_doubleprime * Clb + kdsic)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Trim * (kdclb_doubleprime * Cdh1 + kdclb_tripleprime * Cdc20a + kdclb_prime)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Trim * kswe' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kass * Sic * Clb' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'PTrim * kmih' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Clb * (kdclb_doubleprime * Cdh1 + kdclb_tripleprime * Cdc20a + kdclb_prime)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kswe * Clb' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'ksclb * mass * Jm * (eps + Mcm) / (mass + Jm)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kmih * PClb' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'SBF * (kisbf_prime + kisbf_doubleprime * Clb) / (jisbf + SBF)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'SBFin * (kasbf_prime * mass + kasbf_doubleprime * Cln) / (jasbf + SBFin)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'IE * kiie / (jiie + IE)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kaie * IEin * Clb / (jaie + IEin)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Cdc20a * kicdc20 / (jicdc20 + Cdc20a)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdcdc20 * Cdc20a' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kacdc20 * Cdc20 * IE / (jacdc20 + Cdc20)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Cdh1 * (kicdh * Clb + kicdh_prime * Cln) / (jicdh + Cdh1)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Cdh1in * (Kacdh_prime + Kacdh_doubleprime * Cdc20a) / (jacdh + Cdh1in)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'khsl1 * BUD * Swe1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'khsl1 * BUD * PSwe1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Viwee * Swe1 * Clb / (Jiwee + Swe1)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Viwee * Swe1M * Clb / (Jiwee + Swe1M)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdswe_prime * Swe1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'khsl1r * Swe1M' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'khsl1r * PSwe1M' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'PSwe1 * Vawee / (Jawee + PSwe1)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'PSwe1M * Vawee / (Jawee + PSwe1M)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'ksswe * SBF' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kssweC' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdswe_prime * PSwe1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdiss * PTrim' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'PTrim * (kdclb_doubleprime * Cdh1 + kdclb_tripleprime * Cdc20a + kdclb_prime)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'PTrim * (kdsic_prime * Cln + kdsic_doubleprime * Clb + kdsic)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kass * PClb * Sic' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Mih1a * Vimih / (jimih + Mih1a)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Vamih * Mih1 * Clb / (Jamih + Mih1)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Mcm * kimcm / (jimcm + Mcm)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Mcmin * Clb * kamcm / (jamcm + Mcmin)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdbud * BE' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'ksbud * Cln' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Sic * (kdsic_prime * Cln + kdsic_doubleprime * Clb + kdsic)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kssic' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdcln * Cln' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kscln * SBF' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdswe_prime * Swe1M' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdcdc20 * Cdc20' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kscdc20_prime + kscdc20_doubleprime * pow(Clb, 4) / (pow(jscdc20, 4) + pow(Clb, 4))' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdswe_doubleprime * PSwe1M' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'PClb * (kdclb_doubleprime * Cdh1 + kdclb_tripleprime * Cdc20a + kdclb_prime)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'mu * mass' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <event> <trigger> expression 'gt(Clb, 0.2)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <eventAssignment> <math> expression '1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <event> <trigger> expression 'and(lt(Clb, 0.2), gt(flag, 0))' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <eventAssignment> <math> expression '0' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <eventAssignment> <math> expression '0.5 * mass' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <event> <trigger> expression 'or(geq(Clb, 0.2), geq(BE, 0.6))' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <eventAssignment> <math> expression '1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <event> <trigger> expression 'and(lt(Clb, 0.2), lt(BE, 0.6))' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <eventAssignment> <math> expression '0' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kswe' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kswe_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kswe_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kswe_tripleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kmih' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kmih_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Mih_ast' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kmih_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Mih' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'IEin' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'IEtot' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Cdh1in' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Cdh1tot' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Mih1' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Mih1tot' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Mcmin' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Mcmtot' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'SBFin' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'SBFtot' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdiss' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdsic_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdsic_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdsic' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdclb_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdclb_tripleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdclb_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kass' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'ksclb' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Jm' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'eps' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kisbf_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kisbf_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jisbf' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kasbf_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kasbf_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jasbf' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kiie' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jiie' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kaie' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jaie' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kicdc20' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jicdc20' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdcdc20' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kacdc20' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jacdc20' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kicdh' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kicdh_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jicdh' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Kacdh_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Kacdh_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jacdh' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'khsl1' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'BUD' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Viwee' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Jiwee' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdswe_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'khsl1r' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Vawee' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Jawee' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'ksswe' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kssweC' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Vimih' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jimih' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Vamih' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Jamih' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kimcm' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jimcm' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kamcm' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jamcm' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdbud' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'ksbud' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kssic' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdcln' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kscln' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kscdc20_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kscdc20_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jscdc20' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdswe_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'mu' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'flag' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Swe1T' does not have a 'units' attribute.\n",
      "      \u001b[0m\n",
      "\n"
     ]
    }
   ],
   "source": [
    "outputs, log = biosimulators_tellurium.exec_sed_task(task, variables)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a826291-b0d1-424a-81c6-7e8b6278f30f",
   "metadata": {},
   "source": [
    "`exec_sed_task` returns two outputs, the results of the requested variables and a diagnostic log of the execution of the simulation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5810623a-5707-4287-99d2-41c15f584954",
   "metadata": {},
   "source": [
    "`outputs` is a dictionary that maps the id of each requested output variable to a `numpy.ndarray` with its results at each requested output time step. Run the following code to print out the predicted values of the variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a69135ea-0fb5-4f2b-ba4c-e06530be7a0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time:  0.000  1.000  2.000  3.000  4.000  5.000  6.000  7.000  8.000  9.000 10.000\n",
      "clb :  0.185  0.002  0.000  0.000  0.000  0.000  0.000  0.000  0.000  0.000  0.000\n",
      "cln :  0.054  0.052  0.051  0.050  0.049  0.049  0.048  0.048  0.048  0.048  0.048\n",
      "sbf :  0.124  0.036  0.040  0.041  0.042  0.043  0.045  0.046  0.047  0.048  0.050\n",
      "sic1:  0.004  0.069  0.211  0.311  0.395  0.472  0.543  0.610  0.673  0.733  0.788\n"
     ]
    }
   ],
   "source": [
    "for variable_id, value in outputs.items():\n",
    "    print('{}: {}'.format(variable_id.ljust(4, ' '), ' '.join('{:6.3f}'.format(v) for v in value)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07005b54-54d8-44c3-a6ac-34cf5dc205ae",
   "metadata": {},
   "source": [
    "`log.simulator_details` contains diagnostic information, such as the value of each parameter of CVODE that tellurium used. Run the following code to print this information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b5eb6345-f453-4bfb-8277-d5a98fbcdd52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "absolute_tolerance: 1.0e-12\n",
      "initial_time_step: 0.0\n",
      "max_output_rows: 100000\n",
      "maximum_adams_order: 12\n",
      "maximum_bdf_order: 5\n",
      "maximum_num_steps: 20000\n",
      "maximum_time_step: 0.0\n",
      "method: simulate\n",
      "minimum_time_step: 0.0\n",
      "multiple_steps: false\n",
      "relative_tolerance: 1.0e-06\n",
      "solver: cvode\n",
      "stiff: true\n",
      "variable_step_size: false\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import yaml\n",
    "print(yaml.dump(log.simulator_details))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d58a48c0-f6f5-45e7-a67c-a31d95a50551",
   "metadata": {},
   "source": [
    "## 2. Executing steady-state simulations (e.g., flux balance analysis, analysis of logical regulatory networks)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ce4f4e7-253a-4158-be4a-b3aa56a4d181",
   "metadata": {},
   "source": [
    "Similarly, first use BioSimulators' classes to describe the simulation that you would like to execute such as a flux balance analysis ([KISAO_0000437](https://www.ebi.ac.uk/ols/ontologies/kisao/terms?iri=http%3A%2F%2Fwww.biomodels.net%2Fkisao%2FKISAO%23KISAO_0000437)) simulation of a constraint-based ([SBO_0000624](https://www.ebi.ac.uk/ols/ontologies/sbo/terms?iri=http%3A%2F%2Fbiomodels.net%2FSBO%2FSBO_0000624)) [model of the central metabolism of *Escherichia coli*](../_data/Escherichia-coli-core-metabolism.xml) encoded in SBML ([EDAM:format_2585](https://www.ebi.ac.uk/ols/ontologies/edam/terms?iri=http%3A%2F%2Fedamontology.org%2Fformat_2585), SED-ML model language URN: `sbml`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4f2bc2cc-82b6-493e-904f-2e388ffcd560",
   "metadata": {},
   "outputs": [],
   "source": [
    "from biosimulators_utils.sedml.data_model import SteadyStateSimulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fc38b869-9fb5-4182-a73e-622b2f94ab20",
   "metadata": {},
   "outputs": [],
   "source": [
    "task = Task(\n",
    "    model=Model(\n",
    "        source='../_data/Escherichia-coli-core-metabolism.xml',\n",
    "        language=ModelLanguage.SBML.value,        \n",
    "    ),\n",
    "    simulation=SteadyStateSimulation(\n",
    "        algorithm=Algorithm(\n",
    "            kisao_id='KISAO_0000437',\n",
    "        ),\n",
    "    ),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d96f77fb-c594-4123-9ded-0b7f2c28748d",
   "metadata": {},
   "outputs": [],
   "source": [
    "sbml_uri = 'http://www.sbml.org/sbml/level3/version1/core'\n",
    "sbml_fbc_uri = 'http://www.sbml.org/sbml/level3/version1/fbc/version2'\n",
    "variables = [\n",
    "    Variable(\n",
    "        id='obj',\n",
    "        target='/sbml:sbml/sbml:model/fbc:listOfObjectives/fbc:objective[@fbc:id=\"obj\"]',\n",
    "        target_namespaces={'sbml': sbml_uri, 'fbc': sbml_fbc_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "     Variable(\n",
    "        id='ex_glc',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfReactions/sbml:reaction[@id=\"R_EX_glc__D_e\"]',\n",
    "        target_namespaces={'sbml': sbml_uri, 'fbc': sbml_fbc_uri},\n",
    "        task=task,\n",
    "    ),    \n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9bce268-297c-4578-b152-f99fe05576c5",
   "metadata": {},
   "source": [
    "Next, import a capable simulation tool such as [COBRApy](https://biosimulators.org/simulators/cobrapy)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b3776de2-0e63-4a62-a131-62ac26017b36",
   "metadata": {},
   "outputs": [],
   "source": [
    "import biosimulators_cobrapy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28566fbc-56e6-4574-8ad6-2dd1d6b6b535",
   "metadata": {},
   "source": [
    "Next, use COBRApy to execute the simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b073d0ea-6f03-4132-8651-a885b14a93ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scaling...\n",
      " A: min|aij| =  1.000e+00  max|aij| =  1.000e+00  ratio =  1.000e+00\n",
      "Problem data seem to be well scaled\n"
     ]
    }
   ],
   "source": [
    "outputs, log = biosimulators_cobrapy.exec_sed_task(task, variables)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd950b2d-000d-4ec5-b63f-ef6942008383",
   "metadata": {},
   "source": [
    "Next, print the predicted value of the objective and glucose exchange flux."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6403270a-6575-4e14-bb9d-d9385a36ede5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "obj   :   0.874\n",
      "ex_glc: -10.000\n"
     ]
    }
   ],
   "source": [
    "for variable_id, value in outputs.items():\n",
    "    print('{0:}: {1:7.3f}'.format(variable_id.ljust(6, ' '), value))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5578fb4-6be5-4795-be21-64b22c439153",
   "metadata": {},
   "source": [
    "## 3. Simulating variants of models"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2a52860-f379-48cf-9fee-5f398c18ec0a",
   "metadata": {},
   "source": [
    "BioSimulators APIs can modify models and simulate modified models. `exec_sed_task` methods can change the attributes of components of models, such as the values of parameters and initial conditions. In addition to changing the attributes of components of models, `exec_sed_doc` and `exec_sedml_docs_in_combine_archive` methods can also change the structures of models, such as to add, delete, and replace variables.\n",
    "\n",
    "BioSimulators-utils provides several classes for describing changes to models which parallel the `changeAttribute`, `computeChange`, `setValue`, `addXML`, `removeXML`, and `changeXML` classes of SED-ML. Changes to models encoded in SBML, must be described using XML XPaths for the XML element that corresponds to each model component/attribute.\n",
    "\n",
    "The following code illustrates how to simulate a variant of the Ciliberto model with the $k_{swe}^{''}$ (`kswe_prime`) parameter increased by 5%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e7926b44-b94f-45ee-b905-e91d6ad05ab6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from biosimulators_utils.sedml.data_model import ModelAttributeChange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a07dbd66-792c-48c5-8ab7-e81f8fe8befe",
   "metadata": {},
   "outputs": [],
   "source": [
    "task = Task(\n",
    "    model=Model(\n",
    "        source='../_data/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.xml',\n",
    "        language=ModelLanguage.SBML.value,        \n",
    "    ),\n",
    "    simulation=UniformTimeCourseSimulation(\n",
    "        initial_time=0.,\n",
    "        output_start_time=0.,\n",
    "        output_end_time=10.,\n",
    "        number_of_steps=10,\n",
    "        algorithm=Algorithm(\n",
    "            kisao_id='KISAO_0000019',\n",
    "        ),\n",
    "    ),\n",
    ")\n",
    "\n",
    "sbml_uri = 'http://www.sbml.org/sbml/level2/version4'\n",
    "variables = [\n",
    "    Variable(\n",
    "        id='time',\n",
    "        symbol=Symbol.time.value,\n",
    "        task=task,\n",
    "    ),    \n",
    "    Variable(\n",
    "        id='clb',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Clb\"]',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "    Variable(\n",
    "        id='cln',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Cln\"]',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "    Variable(\n",
    "        id='sbf',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"SBF\"]',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "    Variable(\n",
    "        id='sic1',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Sic\"]',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ff52454-526b-4fa2-a2be-a5ecd28b2b02",
   "metadata": {},
   "source": [
    "Simulate the original model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c8593f27-0070-4ec5-b772-4c6b5d7f02c2",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.9/site-packages/biosimulators_utils/warnings.py:31: BioSimulatorsWarning:\n",
      "\n",
      "\u001b[33mModel `None` may be invalid.\n",
      "  - The model file `../_data/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.xml` may be invalid.\n",
      "    - The value of the 'sboTerm' attribute on a <species> is expected to be an SBO identifier (http://www.biomodels.net/SBO/). In SBML Level 2 prior to Version 4 it is expected to refer to a participant physical type (i.e., terms derived from SBO:0000236, \"participant physical type\"); in Versions 4 and above it is expected to refer to a material entity (i.e., terms derived from SBO:0000240, \"material entity\").\n",
      "      Reference: L2V4 Section 5\n",
      "       SBO term 'SBO:0000014' on the <species> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <species> is expected to be an SBO identifier (http://www.biomodels.net/SBO/). In SBML Level 2 prior to Version 4 it is expected to refer to a participant physical type (i.e., terms derived from SBO:0000236, \"participant physical type\"); in Versions 4 and above it is expected to refer to a material entity (i.e., terms derived from SBO:0000240, \"material entity\").\n",
      "      Reference: L2V4 Section 5\n",
      "       SBO term 'SBO:0000236' on the <species> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <species> is expected to be an SBO identifier (http://www.biomodels.net/SBO/). In SBML Level 2 prior to Version 4 it is expected to refer to a participant physical type (i.e., terms derived from SBO:0000236, \"participant physical type\"); in Versions 4 and above it is expected to refer to a material entity (i.e., terms derived from SBO:0000240, \"material entity\").\n",
      "      Reference: L2V4 Section 5\n",
      "       SBO term 'SBO:0000236' on the <species> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000336' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000336' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000393' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000393' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000393' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000393' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000393' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000393' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - The value of the 'sboTerm' attribute on a <parameter> is expected to be an SBO identifier (http://www.biomodels.net/SBO/) referring to a quantitative parameter defined in SBO (i.e., terms derived from SBO:0000002, \"quantitative systems description parameter\"). \n",
      "      Reference: L2V4 Sections 4.9.5 and 5\n",
      "       SBO term 'SBO:0000393' on the <parameter> is not in the appropriate branch.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <assignmentRule> <math> expression 'kswe_prime * Swe1 + kswe_doubleprime * Swe1M + kswe_tripleprime * PSwe1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <assignmentRule> <math> expression 'kmih_prime * Mih_ast + kmih_doubleprime * Mih' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <assignmentRule> <math> expression 'IEtot - IE' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <assignmentRule> <math> expression 'Cdh1tot - Cdh1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <assignmentRule> <math> expression 'Mih1tot - Mih1a' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <assignmentRule> <math> expression 'Mcmtot - Mcm' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <assignmentRule> <math> expression 'SBFtot - SBF' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdiss * Trim' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Trim * (kdsic_prime * Cln + kdsic_doubleprime * Clb + kdsic)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Trim * (kdclb_doubleprime * Cdh1 + kdclb_tripleprime * Cdc20a + kdclb_prime)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Trim * kswe' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kass * Sic * Clb' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'PTrim * kmih' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Clb * (kdclb_doubleprime * Cdh1 + kdclb_tripleprime * Cdc20a + kdclb_prime)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kswe * Clb' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'ksclb * mass * Jm * (eps + Mcm) / (mass + Jm)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kmih * PClb' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'SBF * (kisbf_prime + kisbf_doubleprime * Clb) / (jisbf + SBF)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'SBFin * (kasbf_prime * mass + kasbf_doubleprime * Cln) / (jasbf + SBFin)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'IE * kiie / (jiie + IE)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kaie * IEin * Clb / (jaie + IEin)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Cdc20a * kicdc20 / (jicdc20 + Cdc20a)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdcdc20 * Cdc20a' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kacdc20 * Cdc20 * IE / (jacdc20 + Cdc20)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Cdh1 * (kicdh * Clb + kicdh_prime * Cln) / (jicdh + Cdh1)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Cdh1in * (Kacdh_prime + Kacdh_doubleprime * Cdc20a) / (jacdh + Cdh1in)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'khsl1 * BUD * Swe1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'khsl1 * BUD * PSwe1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Viwee * Swe1 * Clb / (Jiwee + Swe1)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Viwee * Swe1M * Clb / (Jiwee + Swe1M)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdswe_prime * Swe1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'khsl1r * Swe1M' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'khsl1r * PSwe1M' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'PSwe1 * Vawee / (Jawee + PSwe1)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'PSwe1M * Vawee / (Jawee + PSwe1M)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'ksswe * SBF' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kssweC' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdswe_prime * PSwe1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdiss * PTrim' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'PTrim * (kdclb_doubleprime * Cdh1 + kdclb_tripleprime * Cdc20a + kdclb_prime)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'PTrim * (kdsic_prime * Cln + kdsic_doubleprime * Clb + kdsic)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kass * PClb * Sic' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Mih1a * Vimih / (jimih + Mih1a)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Vamih * Mih1 * Clb / (Jamih + Mih1)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Mcm * kimcm / (jimcm + Mcm)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Mcmin * Clb * kamcm / (jamcm + Mcmin)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdbud * BE' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'ksbud * Cln' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'Sic * (kdsic_prime * Cln + kdsic_doubleprime * Clb + kdsic)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kssic' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdcln * Cln' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kscln * SBF' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdswe_prime * Swe1M' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdcdc20 * Cdc20' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kscdc20_prime + kscdc20_doubleprime * pow(Clb, 4) / (pow(jscdc20, 4) + pow(Clb, 4))' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'kdswe_doubleprime * PSwe1M' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'PClb * (kdclb_doubleprime * Cdh1 + kdclb_tripleprime * Cdc20a + kdclb_prime)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <kineticLaw> <math> expression 'mu * mass' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <event> <trigger> expression 'gt(Clb, 0.2)' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <eventAssignment> <math> expression '1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <event> <trigger> expression 'and(lt(Clb, 0.2), gt(flag, 0))' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <eventAssignment> <math> expression '0' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <eventAssignment> <math> expression '0.5 * mass' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <event> <trigger> expression 'or(geq(Clb, 0.2), geq(BE, 0.6))' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <eventAssignment> <math> expression '1' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <event> <trigger> expression 'and(lt(Clb, 0.2), lt(BE, 0.6))' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - In situations where a mathematical expression contains literal numbers or parameters whose units have not been declared, it is not possible to verify accurately the consistency of the units in the expression. \n",
      "       The units of the <eventAssignment> <math> expression '0' cannot be fully checked. Unit consistency reported as either no errors or further unit errors related to this object may not be accurate.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kswe' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kswe_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kswe_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kswe_tripleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kmih' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kmih_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Mih_ast' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kmih_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Mih' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'IEin' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'IEtot' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Cdh1in' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Cdh1tot' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Mih1' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Mih1tot' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Mcmin' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Mcmtot' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'SBFin' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'SBFtot' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdiss' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdsic_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdsic_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdsic' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdclb_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdclb_tripleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdclb_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kass' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'ksclb' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Jm' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'eps' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kisbf_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kisbf_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jisbf' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kasbf_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kasbf_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jasbf' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kiie' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jiie' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kaie' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jaie' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kicdc20' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jicdc20' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdcdc20' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kacdc20' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jacdc20' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kicdh' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kicdh_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jicdh' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Kacdh_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Kacdh_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jacdh' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'khsl1' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'BUD' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Viwee' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Jiwee' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdswe_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'khsl1r' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Vawee' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Jawee' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'ksswe' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kssweC' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Vimih' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jimih' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Vamih' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Jamih' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kimcm' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jimcm' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kamcm' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jamcm' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdbud' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'ksbud' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kssic' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdcln' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kscln' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kscdc20_prime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kscdc20_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'jscdc20' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'kdswe_doubleprime' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'mu' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'flag' does not have a 'units' attribute.\n",
      "      \n",
      "    - As a principle of best modeling practice, the units of a <parameter> should be declared rather than be left undefined. Doing so improves the ability of software to check the consistency of units and helps make it easier to detect potential errors in models.\n",
      "       The <parameter> with the id 'Swe1T' does not have a 'units' attribute.\n",
      "      \u001b[0m\n",
      "\n"
     ]
    }
   ],
   "source": [
    "outputs, _ = biosimulators_tellurium.exec_sed_task(task, variables)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a57ee15-6a4a-49c7-b3f4-7c5619643786",
   "metadata": {},
   "source": [
    "Modify the model and re-simulate it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "85892bb6-8e40-4932-992e-0b7d8e30f1fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "task.model.changes.append(\n",
    "    ModelAttributeChange(\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfParameters/sbml:parameter[@id=\"kswe_prime\"]/@value',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        new_value=2.1,\n",
    "    )\n",
    ")\n",
    "outputs, _ = biosimulators_tellurium.exec_sed_task(task, variables)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7473ef0-b4b8-40e1-a33c-12cd55a1bfe7",
   "metadata": {},
   "source": [
    "## 4. Setting the parameters of simulation algorithms to fine-tune their behavior"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dc7727c-1030-4f88-8077-ea8c122381b8",
   "metadata": {},
   "source": [
    "Most simulation algorithms expose one or more parameters for fine-tuning their behavior. Detailed information about the parameters supported by each simulation tool and algorithm is available from [BioSimulators](https://biosimulators.org). This includes information about the data type and default value of each parameter.\n",
    "\n",
    "The following code illustrates how to change the values of the absolute ([KISAO_0000211](https://www.ebi.ac.uk/ols/ontologies/kisao/terms?iri=http%3A%2F%2Fwww.biomodels.net%2Fkisao%2FKISAO%23KISAO_0000211)) and relative ([KISAO_0000209](https://www.ebi.ac.uk/ols/ontologies/kisao/terms?iri=http%3A%2F%2Fwww.biomodels.net%2Fkisao%2FKISAO%23KISAO_0000209)) tolerances of CVODE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "47a7cd8b-1b76-48fe-9c70-04c223963bd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from biosimulators_utils.sedml.data_model import AlgorithmParameterChange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ee5cc651-ffaf-4be1-8e82-4d5416c81c15",
   "metadata": {},
   "outputs": [],
   "source": [
    "task = Task(\n",
    "    model=Model(\n",
    "        source='../_data/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.xml',\n",
    "        language=ModelLanguage.SBML.value,        \n",
    "    ),\n",
    "    simulation=UniformTimeCourseSimulation(\n",
    "        initial_time=0.,\n",
    "        output_start_time=0.,\n",
    "        output_end_time=10.,\n",
    "        number_of_steps=10,\n",
    "        algorithm=Algorithm(\n",
    "            kisao_id='KISAO_0000019',\n",
    "            changes=[\n",
    "                AlgorithmParameterChange(\n",
    "                    kisao_id='KISAO_0000211',\n",
    "                    new_value=1e-8,\n",
    "                ),\n",
    "                AlgorithmParameterChange(\n",
    "                    kisao_id='KISAO_0000209',\n",
    "                    new_value=1e-9,\n",
    "                ),\n",
    "            ],\n",
    "        ),\n",
    "    ),\n",
    ")\n",
    "sbml_uri = 'http://www.sbml.org/sbml/level2/version4'\n",
    "variables = [\n",
    "    Variable(\n",
    "        id='time',\n",
    "        symbol=Symbol.time.value,\n",
    "        task=task,\n",
    "    ),    \n",
    "    Variable(\n",
    "        id='clb',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Clb\"]',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "05971b8e-5c83-400e-ab13-2809e1f623f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "outputs, log = biosimulators_tellurium.exec_sed_task(task, variables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "cef6a2ae-5681-485f-b580-0c441aa27a99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Absolute tolerance: 1e-08\n",
      "Relative tolerance: 1e-09\n"
     ]
    }
   ],
   "source": [
    "print(f'Absolute tolerance: {log.simulator_details[\"absolute_tolerance\"]}')\n",
    "print(f'Relative tolerance: {log.simulator_details[\"relative_tolerance\"]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f945ef34-2f19-45ff-bd22-4d4a66d86580",
   "metadata": {},
   "source": [
    "## 5. Executing simulations with alternative algorithms"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8134935-6f89-4c76-a080-537b0130346b",
   "metadata": {},
   "source": [
    "To reuse simulations across simulation tools, it is often necessary to use different simulation algorithms with each simulation tool. To make this easy, BioSimulators simulation tools can automatically use the [Kinetic Simulation Algorithm Ontology (KiSAO)](https://github.com/SED-ML/KiSAO) to identify and execute similar algorithms.\n",
    "\n",
    "Use the following code to use CVODE to execute the Ciliberto model with tellurium and also execute this with COPASI, which implements several similar algorithms, including LSODA.\n",
    "\n",
    "As described in the next section, BioSimulators provide a configuration option to controlling the degree to which simulation tools should automatically substitute algorithms without raising exceptions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b46b3743-3872-464c-ab01-f85ba49eacf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "task = Task(\n",
    "    model=Model(\n",
    "        source='../_data/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.xml',\n",
    "        language=ModelLanguage.SBML.value,        \n",
    "    ),\n",
    "    simulation=UniformTimeCourseSimulation(\n",
    "        initial_time=0.,\n",
    "        output_start_time=0.,\n",
    "        output_end_time=10.,\n",
    "        number_of_steps=10,\n",
    "        algorithm=Algorithm(\n",
    "            kisao_id='KISAO_0000019',\n",
    "        ),\n",
    "    ),\n",
    ")\n",
    "sbml_uri = 'http://www.sbml.org/sbml/level2/version4'\n",
    "variables = [\n",
    "    Variable(\n",
    "        id='time',\n",
    "        symbol=Symbol.time.value,\n",
    "        task=task,\n",
    "    ),    \n",
    "    Variable(\n",
    "        id='clb',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Clb\"]',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "7d15ffd3-1707-4d98-a20b-cf28dbe2a0af",
   "metadata": {},
   "outputs": [],
   "source": [
    "import biosimulators_copasi\n",
    "import biosimulators_tellurium"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "984d7ead-2fe5-4e50-8c95-1dd7d00ed4e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.9/site-packages/kisao/utils.py:477: AlgorithmSubstitutedWarning:\n",
      "\n",
      "\u001b[33m'LSODA/LSODAR hybrid method' (KISAO_0000560) will be substituted for 'CVODE'' (KISAO_0000019) at substitution policy 'SIMILAR_VARIABLES'.\u001b[0m\n",
      "\n"
     ]
    }
   ],
   "source": [
    "copasi_outputs, copasi_log = biosimulators_copasi.exec_sed_task(task, variables)\n",
    "tellurium_outputs, tellurium_log = biosimulators_tellurium.exec_sed_task(task, variables)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44c5b7b4-4300-4168-94a6-b20dffa0a13f",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">Note, COPASI raised a warning that indicated that it used LSODA (<a href=\"https://www.ebi.ac.uk/ols/ontologies/kisao/terms?iri=http%3A%2F%2Fwww.biomodels.net%2Fkisao%2FKISAO%23KISAO_0000560\">KISAO_0000560</a>) instead of CVODE.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d63efa36-4931-49e4-9631-d67c8bb687b6",
   "metadata": {},
   "source": [
    "Next, use the logs to inspect which algorithms COPASI and tellurium used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "18e08202-ddc0-4532-8a9e-9aa3079cc713",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "COPASI: KISAO_0000560\n",
      "tellurium: KISAO_0000019\n"
     ]
    }
   ],
   "source": [
    "print(f'COPASI: {copasi_log.algorithm}')\n",
    "print(f'tellurium: {tellurium_log.algorithm}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29d32c96-dbef-45bb-b9e9-4ee7a1d9230c",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 6. Disabling optional BioSimulators features, such as to increase simulation performance"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e95037c2-d4ac-4583-9c20-809bd1433334",
   "metadata": {},
   "source": [
    "By default, BioSimulators simulation tool APIs validate models, simulations, algorithms, and simulation results; substitute unsupported algorithms with similar ones; and log the execution of simulations. Optionally, these features can be disabled, such as for more performant simulation.\n",
    "\n",
    "These features can be disabled by creating a configuration object and passing it to `exec_sed_task` as illustrated below.\n",
    "* Disable validation: set `VALIDATE_SEDML`, `VALIDATE_SEDML_MODELS`, and `VALIDATE_RESULTS` to `False`\n",
    "* Disable logging: set `LOG` to `False`\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    Note:\n",
    "    <ul>\n",
    "        <li>Without validation, simulation tools may generate cryptic exceptions.</li>\n",
    "        <li>When algorithm substitution is disabled, simulation tools will raise exceptions for simulations they cannot execute.</li>\n",
    "        <li>When logging is disabled, the <code>log</code> output will be <code>None</code>.</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "598720f6-8155-4c1b-b9e8-36925c1929e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from biosimulators_utils.config import Config\n",
    "from kisao import AlgorithmSubstitutionPolicy\n",
    "config = Config(\n",
    "    VALIDATE_SEDML=False,\n",
    "    VALIDATE_SEDML_MODELS=False,\n",
    "    VALIDATE_RESULTS=False,\n",
    "    ALGORITHM_SUBSTITUTION_POLICY=AlgorithmSubstitutionPolicy.SAME_METHOD,\n",
    "    LOG=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "f2807852-6d98-48f1-8e88-e0c3f128b69b",
   "metadata": {},
   "outputs": [],
   "source": [
    "outputs, log = biosimulators_tellurium.exec_sed_task(task, variables, config=config)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e50f93da-7022-4164-a884-ae970ea96cef",
   "metadata": {},
   "source": [
    "The following code illustrates how these options prevent COPASI from executing the simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b19f00cb-8014-4adf-9cd2-e1de4187d788",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Algorithms cannot be substituted at policy 'SAME_METHOD'.\n"
     ]
    }
   ],
   "source": [
    "from kisao.exceptions import AlgorithmCannotBeSubstitutedException\n",
    "try:\n",
    "    biosimulators_copasi.exec_sed_task(task, variables, config=config)\n",
    "except AlgorithmCannotBeSubstitutedException as exception:\n",
    "    print(str(exception))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13980aa2-b34f-49cc-96ab-c472a0f9b529",
   "metadata": {},
   "source": [
    "## 7. Optimizing the execution of repeated simulations by preprocessing simulation tasks"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e67c5300-01ff-4a99-85cc-40d80d7588a7",
   "metadata": {},
   "source": [
    "BioSimulators uses SED-ML and KiSAO to provide investigators consistent APIs for executing simulations with multiple simulation tools. This simplicity has several advantages, including eliminating the need to learn distinct APIs for each tool, making it easy to run simulations with multiple tools such as to check reproducibility and validate simulation tools, and making it easier for investigators to co-simulate models that require distinct simulation methods and simulation tools. As a result, executing simulations through SED-ML and KiSAO requires simulation tools to map descriptions of models and simulations encoded in SED-ML and KiSAO into the simulation tool's internal representations.\n",
    "\n",
    "To avoid repeatedly calculating these maps, these maps can be calculated using the `preprocess_sed_task` method of each simulator's API and passed to `exec_sed_task` as illustrated below.\n",
    "\n",
    "`preprocess_sed_task` enables minor changes to be efficiently made to models and simulations:\n",
    "* Modify the values of parameters and initial conditions of models.\n",
    "* Modify the attributes of time coure simulations (initial time, output start time, output end time, number of steps).\n",
    "\n",
    "Note, `preprocess_sed_task` must be re-run to make more substantial changes to model and simulations:\n",
    "* Additional model attributes which were not preprocessed must be changed.\n",
    "* The structure of the model must be changed, or a different model must be simulated.\n",
    "* A simulation must be executed with a different algorithm or algorithm parameter.\n",
    "* Additional outputs which were not preprocessed must be recorded.\n",
    "* A simulation must be executed with a different simulation tool."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07e29e50-7610-4bbd-b992-6e5498242a9d",
   "metadata": {},
   "source": [
    "Run the following code to preprocess the Ciliberto simulation for tellurium."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "3b3b0da6-787e-43e9-9775-639d2f4148b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "preprocessed_task = biosimulators_tellurium.preprocess_sed_task(task, variables, config=config)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9171a9bb-d753-4fd1-8bd0-9d65f1bb0d29",
   "metadata": {},
   "source": [
    "Run the following code to pass the preprocessed information about the task to tellurium."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "38c019ec-2d9c-48f6-9966-ba376ab00496",
   "metadata": {},
   "outputs": [],
   "source": [
    "outputs, _, = biosimulators_tellurium.exec_sed_task(task, variables, preprocessed_task=preprocessed_task, config=config)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aa202ae-7985-485f-b6c7-308179a34ae9",
   "metadata": {},
   "source": [
    "The following code illustrates how to run multiple steps with tellurium with different initial conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "1f2ae704-cf7e-476d-899d-34c23db8b5e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "task = Task(\n",
    "    model=Model(\n",
    "        source='../_data/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.xml',\n",
    "        language=ModelLanguage.SBML.value,        \n",
    "        changes=[\n",
    "            ModelAttributeChange(\n",
    "                target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Clb\"]',\n",
    "                target_namespaces={'sbml': sbml_uri},\n",
    "            ),\n",
    "            ModelAttributeChange(\n",
    "                target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Cln\"]',\n",
    "                target_namespaces={'sbml': sbml_uri},\n",
    "            ),\n",
    "            ModelAttributeChange(\n",
    "                target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"SBF\"]',\n",
    "                target_namespaces={'sbml': sbml_uri},\n",
    "            ),\n",
    "            ModelAttributeChange(\n",
    "                target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Sic\"]',\n",
    "                target_namespaces={'sbml': sbml_uri},        \n",
    "            ),\n",
    "        ]\n",
    "    ),\n",
    "    simulation=UniformTimeCourseSimulation(\n",
    "        initial_time=0.,\n",
    "        output_start_time=0.,\n",
    "        output_end_time=10.,\n",
    "        number_of_steps=10,\n",
    "        algorithm=Algorithm(\n",
    "            kisao_id='KISAO_0000019',\n",
    "        ),\n",
    "    ),\n",
    ")\n",
    "sbml_uri = 'http://www.sbml.org/sbml/level2/version4'\n",
    "variables = [\n",
    "    Variable(\n",
    "        id='time',\n",
    "        symbol=Symbol.time.value,\n",
    "        task=task,\n",
    "    ),    \n",
    "    Variable(\n",
    "        id='clb',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Clb\"]',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "    Variable(\n",
    "        id='cln',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Cln\"]',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "    Variable(\n",
    "        id='sbf',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"SBF\"]',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "    Variable(\n",
    "        id='sic1',\n",
    "        target='/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\"Sic\"]',\n",
    "        target_namespaces={'sbml': sbml_uri},\n",
    "        task=task,\n",
    "    ),\n",
    "]\n",
    "preprocessed_task = biosimulators_tellurium.preprocess_sed_task(task, variables, config=config)\n",
    "\n",
    "time_step = 1.\n",
    "\n",
    "# set initial conditions and execute a simulation step\n",
    "task.simulation.initial_time = 0.\n",
    "task.simulation.output_start_time = 0.\n",
    "task.simulation.output_end_time = 1.\n",
    "task.model.changes[0].new_value = 0.18453673\n",
    "task.model.changes[1].new_value = 0.053600963\n",
    "task.model.changes[2].new_value = 0.12405464\n",
    "task.model.changes[3].new_value = 0.0035491784\n",
    "outputs, _, = biosimulators_tellurium.exec_sed_task(task, variables, preprocessed_task=preprocessed_task, config=config)\n",
    "\n",
    "# set the input to the next step equal to the output of the previous step, and execute a second simulation step\n",
    "task.simulation.initial_time += time_step\n",
    "task.simulation.output_start_time += time_step\n",
    "task.simulation.output_end_time += time_step\n",
    "task.model.changes[0].new_value = outputs['clb'][-1]\n",
    "task.model.changes[1].new_value = outputs['cln'][-1]\n",
    "task.model.changes[2].new_value = outputs['sbf'][-1]\n",
    "task.model.changes[3].new_value = outputs['sic1'][-1]\n",
    "outputs, _, = biosimulators_tellurium.exec_sed_task(task, variables, preprocessed_task=preprocessed_task, config=config)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68dc6e1d-dd26-4807-91cd-8ae693e632dd",
   "metadata": {},
   "source": [
    "## 8. Executing simulations with commercially-licensed solvers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e21e8de-7254-45a0-8a25-83d77384e407",
   "metadata": {},
   "source": [
    "Some simulation tools can optionally execute simulations more quickly with commercial solvers such as [Gurobi](https://www.gurobi.com/products/gurobi-optimizer/) and [IBM CPLEX](https://www.ibm.com/analytics/cplex-optimizer). Gurobi and IBM both provide free licenses for academic research. BioSimulators recommends Gurobi because Gurobi is easier to install, Gurobi provides APIs for a wide range of versions of Python, and it is easier to manage licenses for Gurobi.\n",
    "\n",
    "Currently, COBRApy and RBApy can be used with both CPLEX and Gurobi. To use CPLEX, you must also install CPLEX and its Python API. Note, CPLEX currently only provides Python APIs for Python 3.7 and 3.8. Gurobi can be installed by running `pip install gurobipy` or installing the BioSimulators interfaces to COBRApy and RBApy with the `gurobi` installation option (e.g., `pip install biosimulators-cobrapy[gurobi]`.\n",
    "\n",
    "COBRApy and RBApy provide two ways to use Gurobi licenses.\n",
    "- Save a copy of your license file to your home directory (`~/gurobi.lic`) or the default location (`/opt/gurobi/gurobi.lic` for Linux).\n",
    "- Set environment variables with the prefix `GRB_` for each variable of your license (e.g., `GRB_WLSACCESSID`, `GRB_WLSSECRET`, `GRB_LICENSEID`).\n",
    "\n",
    "BioSimulators recommends the former for local development and the latter for use with containers such as in cloud deployments and cloud continuous integration actions.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    Note, Gurobi provides three different licensing options for use inside and outside of containers.\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}