tutorials/3. Validating models and simulations/1. Validating models (e.g., CellML, SBML files).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "097c9f05-a1eb-463b-8bb2-ff5a53321652",
   "metadata": {},
   "source": [
    "# Validating models (e.g., CellML, SBML files)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6958648f-a8e9-4c99-b71f-660755b966fc",
   "metadata": {},
   "source": [
    "This tutorial illustrates how to check whether model files are consistent with the specifications of their associated formats.\n",
    "\n",
    "BioSimulators currently supports several languages including\n",
    "* [BioNetGen Language (BNGL)](https://bionetgen.org)\n",
    "* [CellML](https://cellml.org): 1.0 and 2.0 (validation for 1.1 is not available)\n",
    "* [NeuroML](https://neuroml.org/)\n",
    "* [Low Entropy Model Specification (LEMS)](https://lems.github.io/LEMS/)\n",
    "* [Smoldyn simulation configurations](http://www.smoldyn.org/)\n",
    "* [Systems Biology Markup Language (SBML)](http://sbml.org), including all packages and versions\n",
    "* [XML format for Resource Balance Analysis (RBA) models](https://github.com/SysBioInra/RBApy/blob/master/docs/XML_format%20(RBApy.xml).pdf)\n",
    "* [XPP ODE format](http://www.math.pitt.edu/~bard/xpp/help/xppodes.html)\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    BioSimulators integrates community-contributed validators for each model language. For some model languages, these validators provide limited validation and/or limited reports of errors. We welcome contributions of improved validation tools.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b02c40c3-9cbe-4da6-9d15-a267587bc462",
   "metadata": {},
   "source": [
    "## 1. Validate a model online"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77e6170e-a992-4b0b-bda5-1fea7fb62b01",
   "metadata": {},
   "source": [
    "The easiest way to validate models is to use the web interface at https://run.biosimulations.org. An HTTP API for validating models is also available at [https://combine.api.biosimulations.org](https://combine.api.biosimulations.org/)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92546317-6304-49af-bb3b-a79e6eb29124",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 2. Validate a model with the BioSimulators command-line application"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cef968a-3d3b-4ddc-8579-160f14a7857b",
   "metadata": {},
   "source": [
    "First, install [BioSimulators-utils](https://github.com/biosimulators/Biosimulators_utils). Installation instructions are available at [https://docs.biosimulators.org](https://docs.biosimulators.org/Biosimulators_utils). Note, BioSimulators-utils must be installed with the installation options for the model languages that you wish to validate. A Docker image with BioSimulators utils and all dependencies is also available ([`ghcr.io/biosimulators/biosimulators`](https://github.com/biosimulators/Biosimulators/pkgs/container/biosimulators))."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3d12a2a-9f0c-4977-82cc-4102a5632119",
   "metadata": {},
   "source": [
    "Inline help for the `biosimulators-utils` command-line program is available by running the program with the `--help` option."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c3e1b40a-737d-4ff9-8456-f68d75ab9a0a",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid -W option ignored: invalid module name: 'biosimulators_utils.warnings'\n",
      "usage: biosimulators-utils [-h] [-d] [-q] [-v]\n",
      "                           {convert,exec,validate-project,validate-metadata,validate-simulation,validate-model,build-project}\n",
      "                           ...\n",
      "\n",
      "Utilities for working with containerized biosimulation tools\n",
      "\n",
      "optional arguments:\n",
      "  -h, --help            show this help message and exit\n",
      "  -d, --debug           full application debug mode\n",
      "  -q, --quiet           suppress all console output\n",
      "  -v, --version         show program's version number and exit\n",
      "\n",
      "sub-commands:\n",
      "  {convert,exec,validate-project,validate-metadata,validate-simulation,validate-model,build-project}\n",
      "    convert             Convert files among formats\n",
      "    exec                Execute a model project (COMBINE/OMEX archive)\n",
      "    validate-project    Validate a model project (COMBINE/OMEX archive)\n",
      "    validate-metadata   Validate metadata (OMEX Metadata file)\n",
      "    validate-simulation\n",
      "                        Validate a simulation experiment (SED-ML file)\n",
      "    validate-model      Validate a model (e.g., CellML, SBML file)\n",
      "    build-project       Build a modeling project\n"
     ]
    }
   ],
   "source": [
    "!biosimulators-utils --help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "756b8bfb-e2de-48ee-b28d-fc5bc7c06d0e",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid -W option ignored: invalid module name: 'biosimulators_utils.warnings'\n",
      "usage: biosimulators-utils validate-model [-h] language filename\n",
      "\n",
      "Validate a model (e.g., CellML, SBML file)\n",
      "\n",
      "positional arguments:\n",
      "  language    Model language (`BNGL`, `CellML`, `LEMS`, `RBA`, `SBML`,\n",
      "              `Smoldyn`, or `XPP`)\n",
      "  filename    Path to model\n",
      "\n",
      "optional arguments:\n",
      "  -h, --help  show this help message and exit\n"
     ]
    }
   ],
   "source": [
    "!biosimulators-utils validate-model --help"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db7d7f72-c153-46cf-b19e-c7f3e2751a7b",
   "metadata": {},
   "source": [
    "Next, use the command-line program to validate the [model](../_data/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.xml)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4af2d600-8f14-43da-b82f-7a34adbdb075",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid -W option ignored: invalid module name: 'biosimulators_utils.warnings'\n",
      "/usr/local/lib/python3.9/site-packages/biosimulators_utils/warnings.py:31: BioSimulatorsWarning: \u001b[33mThe 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",
      "  warnings.warn(termcolor.colored(message, Colors.warning.value), category)\n"
     ]
    }
   ],
   "source": [
    "!biosimulators-utils validate-model SBML ../_data/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.xml"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f4797e2-267a-4c3e-a764-6d77a4653e10",
   "metadata": {},
   "source": [
    "If the model is invalid, a list of errors will be printed to your console."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60bc77e3-85ea-4516-9402-a5c2ea8e2e4f",
   "metadata": {},
   "source": [
    "## 3. Validate a model programmatically with Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0a1d7fb-3c94-48de-b6fd-aa761f0d4074",
   "metadata": {},
   "source": [
    "First, install [BioSimulators-utils](https://github.com/biosimulators/Biosimulators_utils). Installation instructions are available at [https://docs.biosimulators.org](https://docs.biosimulators.org/Biosimulators_utils). Note, BioSimulators-utils must be installed with the installation options for the model languages that you wish to validate. A Docker image with BioSimulators utils and all dependencies is also available ([`ghcr.io/biosimulators/biosimulators`](https://github.com/biosimulators/Biosimulators/pkgs/container/biosimulators))."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fbd6d8b-e44c-43f5-a4ce-623a91896ff6",
   "metadata": {},
   "source": [
    "Next, import BioSimulators-utils' enumeration of model languages and model validation method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4a288b6d-b3dd-4507-bf09-21623801c7dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "from biosimulators_utils.sedml.data_model import ModelLanguage\n",
    "from biosimulators_utils.sedml.validation import validate_model_with_language"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09cfafbb-a225-4d2c-8f33-f4a38b5150a8",
   "metadata": {},
   "source": [
    "This enumeration can be inspected to determine the key for each model language."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "17b3c607-27cf-4acc-8ff5-b1fb2a11c999",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ModelLanguage.BNGL\n",
      "ModelLanguage.CellML\n",
      "ModelLanguage.CopasiML\n",
      "ModelLanguage.GINML\n",
      "ModelLanguage.HOC\n",
      "ModelLanguage.Kappa\n",
      "ModelLanguage.LEMS\n",
      "ModelLanguage.MASS\n",
      "ModelLanguage.MorpheusML\n",
      "ModelLanguage.NeuroML\n",
      "ModelLanguage.RBA\n",
      "ModelLanguage.SBML\n",
      "ModelLanguage.Smoldyn\n",
      "ModelLanguage.VCML\n",
      "ModelLanguage.XPP\n",
      "ModelLanguage.ZGINML\n",
      "ModelLanguage.pharmML\n"
     ]
    }
   ],
   "source": [
    "print('\\n'.join(sorted('ModelLanguage.' + lang for lang in ModelLanguage.__members__.keys())))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29ae7076-71b4-4c45-a70c-bea11add011d",
   "metadata": {},
   "source": [
    "Next, use the `validate_model_with_language` method to check the validity of a model file and retrieve list of errors and warnings and information about the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0b097154-1f0d-42eb-95c3-5988201792ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "model_filename = '../_data/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.xml'\n",
    "model_language = ModelLanguage.SBML\n",
    "errors, warnings, model = validate_model_with_language(model_filename, model_language)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4fc61c8-57a8-4aaf-8721-69ac8895a075",
   "metadata": {},
   "source": [
    "The first and second outputs (`errors` and `warnings`) are nested lists of error and warning messages. Next, use the `flatten_nested_list_of_strings` method to print out human-readable messages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5bb2bbfd-9733-4604-bde2-1d800d9bb037",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_77/783546003.py:5: UserWarning: - 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",
      "  \n",
      "  warn(flatten_nested_list_of_strings(warnings), UserWarning)\n"
     ]
    }
   ],
   "source": [
    "from biosimulators_utils.utils.core import flatten_nested_list_of_strings\n",
    "from warnings import warn\n",
    "\n",
    "if warnings:\n",
    "    warn(flatten_nested_list_of_strings(warnings), UserWarning)\n",
    "\n",
    "if errors:\n",
    "    raise ValueError(flatten_nested_list_of_strings(errors))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91e99872-ec5f-4305-bbbf-af58ea6f8e06",
   "metadata": {},
   "source": [
    "The third output of `validate_model_with_language` (`model`) contains information about the model. This type of this output depends on the model langauge. For SBML, this output is an instance of `libsbml.SBMLDocument`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2267c764-8f69-488d-815a-2fd82ace1d30",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "libsbml.SBMLDocument"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.__class__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06d98bb0-1e50-4143-94ee-083ea3ed48b2",
   "metadata": {},
   "source": [
    "`get_parameters_variables_outputs_for_simulation` uses this third output to identify the inputs (e.g., constants, initiation conditions) and outputs (observables, such as concentrations of species and velocities of reactions, that could be recorded from simulations) of models. See the [model introspection tutorial](../1.%20Introspecting%20models/Introspecting%20models.ipynb) for more information."
   ]
  }
 ],
 "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
}