tutorials/3. Validating models and simulations/4. Validating simulation projects (COMBINE-OMEX archives).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a380d048-3f05-4787-a5b1-b46b5aba4c75",
   "metadata": {},
   "source": [
    "# Validating simulation projects (COMBINE-OMEX archives)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ef7d88c-9dbb-4eea-92bc-398034d2bcfc",
   "metadata": {},
   "source": [
    "This tutorial illustrates how to validate simulation projects encapsulated as [COMBINE/OMEX archives](https://combinearchive.org/). By default, this includes the validations listed below. As discussed in the final section, these validations can optionally be disabled.\n",
    "\n",
    "* Archive is a valid zip file\n",
    "* [Simulation Experiment Description Markup Language (SED-ML)](http://sed-ml.org/) files\n",
    "* The source (e.g., BNGL, CellML, RBA, SBML, XPP file) of each model of each SED-ML file\n",
    "* The targets for these model sources specified in the SED-ML files\n",
    "* Image files (BMP, GIF, JPEG, PNG, TIFF, WEBP)\n",
    "* [OMEX Metadata](https://sys-bio.github.io/libOmexMeta/) files\n",
    "* [OMEX Manifest](https://combinearchive.org/) files\n",
    "\n",
    "This format uses URIs to describe the format of each file in archives. `biosimulators_utils.combine.data_model.CombineArchiveContentFormat` enumerates many formats commonly used with COMBINE/OMEX archives.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    SED-ML is under active development. The SED-ML community is working toward a single interpretation of SED-ML. BioSimulators supports the interpretation of SED-ML described at <a href=\"https://docs.biosimulations.org/concepts/conventions/simulation-experiments/\">https://docs.biosimulations.org</a>.\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    BioSimulations relies on community-contributed validation tools for each model language to validate models. The thoroughness of these tools varies. In addition, some tools currently provide limited diagnostic information. We welcome contributions of improved validation tools.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13dfd4aa-55d2-4a60-a697-9b98b7fa914f",
   "metadata": {},
   "source": [
    "## 1. Validate a COMBINE/OMEX archive online"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5abfc0bc-530e-4302-b6d3-02e0dd25544d",
   "metadata": {},
   "source": [
    "The easiest way to validate a COMBINE/OMEX archive file is to use the web interface at https://run.biosimulations.org. An HTTP API for validating COMBINE/OMEX archive files is also available at [https://combine.api.biosimulations.org](https://combine.api.biosimulations.org/)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e2824ee-2e16-4342-a183-5f57117c0524",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 2. Validate a COMBINE/OMEX archive file with the BioSimulators command-line application"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d57cbf57-f29c-4472-8290-9f555c8dbb5d",
   "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": "1e307801-ac17-43d3-a277-72ec02f9584c",
   "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": "b2b5dc89-8ba0-4357-a812-7983dd0f85bb",
   "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": "a02f6a29-9b8e-494a-afe8-6793387122ce",
   "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-project [-h] filename\n",
      "\n",
      "Validate a modeling project (COMBINE/OMEX archive and its contents)\n",
      "\n",
      "positional arguments:\n",
      "  filename    Path to a COMBINE/OMEX archive\n",
      "\n",
      "optional arguments:\n",
      "  -h, --help  show this help message and exit\n"
     ]
    }
   ],
   "source": [
    "!biosimulators-utils validate-project --help"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25487d89-ccc3-426c-bbbc-f923c303e4e4",
   "metadata": {},
   "source": [
    "Next, use the command-line program to validate the simulation project (`../_data/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.omex`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ddf66061-75f9-459f-83ec-5ed22b59cdf5",
   "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 SED document is potentially incorrect.\n",
      "  - Model `Ciliberto2003_Morphogenesis` may be invalid.\n",
      "    - The model file `BIOMD0000000297_url.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",
      "/usr/local/lib/python3.9/site-packages/biosimulators_utils/warnings.py:31: BioSimulatorsWarning: \u001b[33mThe COMBINE/OMEX archive may be invalid.\n",
      "  - The SED-ML file at location `./simulation_1.sedml` may be invalid.\n",
      "    - Model `Ciliberto2003_Morphogenesis` may be invalid.\n",
      "      - The model file `BIOMD0000000297_url.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",
      "Archive contains 1 SED-ML documents with 1 models, 1 simulations, 1 tasks, 1 reports, and 4 plots:\n",
      "  simulation_1.sedml:\n",
      "    Tasks (1):\n",
      "      task_1\n",
      "    Reports (1):\n",
      "      report: 21 data sets\n",
      "    Plots (4):\n",
      "      Figure_3a: 4 curves\n",
      "      Figure_3b: 4 curves\n",
      "      Figure_3c: 4 curves\n",
      "      Figure_3d: 1 curves\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!biosimulators-utils validate-project ../_data/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.omex"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd507a76-516e-4a9b-b94e-857fcca33570",
   "metadata": {},
   "source": [
    "If the archive is invalid, a list of errors will be printed to your console."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ebf9dc5-63e8-4ab1-98c3-903e378769ab",
   "metadata": {},
   "source": [
    "## 3. Validate a COMBINE/OMEX archive file programmatically with Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19cfb4c3-290d-4451-ad79-b67dce577bb6",
   "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": "ae3a4a9e-cdce-445b-a001-8deda8709dd0",
   "metadata": {},
   "source": [
    "Next, use the `CombineArchiveReader` class to read and unpack the archive. Note, `CombineArchiveReader` raises exceptions on archives that cannot be reader (e.g., corrupt zip files)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0e9ed996-d738-4698-b367-0b0a533b4304",
   "metadata": {},
   "outputs": [],
   "source": [
    "from biosimulators_utils.combine.io import CombineArchiveReader\n",
    "import os\n",
    "import tempfile\n",
    "\n",
    "archive_filename = '../_data/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.omex'\n",
    "if not os.path.isdir('tmp'):\n",
    "    os.mkdir('tmp')\n",
    "archive_dirname = tempfile.mkdtemp(dir='tmp')\n",
    "archive = CombineArchiveReader().run(archive_filename, archive_dirname)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5c3364e-140b-4f30-b2b9-5ce955e380ed",
   "metadata": {},
   "source": [
    "Next, use the `validate` method to validate the content of the archive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5d0ed556-6410-45bc-b12c-f0d866dd3572",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.9/site-packages/biosimulators_utils/warnings.py:31: BioSimulatorsWarning: \u001b[33mThe SED document is potentially incorrect.\n",
      "  - Model `Ciliberto2003_Morphogenesis` may be invalid.\n",
      "    - The model file `BIOMD0000000297_url.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": [
    "from biosimulators_utils.combine.validation import validate\n",
    "errors, warnings = validate(archive, archive_dirname)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f11cd45-a6ea-4ad3-8869-4501bbc449fa",
   "metadata": {},
   "source": [
    "Human-readable messages can then be printed out using the `flatten_nested_list_of_strings` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "30b9f258-a1fd-4b0c-ab52-4e1fc06efb7d",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_307/783546003.py:5: UserWarning: - The SED-ML file at location `./simulation_1.sedml` may be invalid.\n",
      "  - Model `Ciliberto2003_Morphogenesis` may be invalid.\n",
      "    - The model file `BIOMD0000000297_url.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",
      "        \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": "0e5a4066-ce2d-492e-854f-f34025faff17",
   "metadata": {},
   "source": [
    "The output of the `CombineArchiveReader.run` method (`archive`) is an instance of `biosimulators_utils.combine.data_model.CombineArchive` that represents the contents of the archive. This includes the path to each file, the format of each file (described using URIs as explained above), and a flag (`master`) that indicates whether each file should be considered the primary entrypoint to the archive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "52fdd048-367f-4bb2-8b28-7be1ca7fb8ee",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'contents': [<biosimulators_utils.combine.data_model.CombineArchiveContent at 0x7f04cea0f220>,\n",
       "  <biosimulators_utils.combine.data_model.CombineArchiveContent at 0x7f04cea0f1c0>,\n",
       "  <biosimulators_utils.combine.data_model.CombineArchiveContent at 0x7f04cea0f2b0>,\n",
       "  <biosimulators_utils.combine.data_model.CombineArchiveContent at 0x7f04cea0f2e0>,\n",
       "  <biosimulators_utils.combine.data_model.CombineArchiveContent at 0x7f04cea0f310>,\n",
       "  <biosimulators_utils.combine.data_model.CombineArchiveContent at 0x7f04cea0f340>,\n",
       "  <biosimulators_utils.combine.data_model.CombineArchiveContent at 0x7f04cea0f370>,\n",
       "  <biosimulators_utils.combine.data_model.CombineArchiveContent at 0x7f04cea14ee0>],\n",
       " 'description': None,\n",
       " 'authors': [],\n",
       " 'created': None,\n",
       " 'updated': None}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(archive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "541bf577-b959-4f85-af30-f935f2d63028",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'location': './BIOMD0000000297_url.xml',\n",
       " 'format': 'http://identifiers.org/combine.specifications/sbml',\n",
       " 'master': False,\n",
       " 'description': None,\n",
       " 'authors': [],\n",
       " 'created': None,\n",
       " 'updated': None}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(archive.contents[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7136c430-8d95-4524-8463-b3e4316df1fd",
   "metadata": {},
   "source": [
    "# 4. Validation options"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "752f247d-16ce-4db8-8b7d-7e3c32a617f9",
   "metadata": {},
   "source": [
    "By default, BioSimulators aims to validate COMBINE/OMEX archives as comprehensively as possible. Optionally, each validation can be disabled. All of the validation interfaces support the same options.\n",
    "\n",
    "The online validator provides a graphical menu of validation options. The options for the HTTP API are described in its documentation. Validation options for the command-line application can be set via environment variables. Validation options for the Python API can be set by passing an additional `config` keywords argument to the `CombineArchiveReader.run` and `validate` methods.\n",
    "\n",
    "| Option                                     | HTTP API query parameter  | CLI environment variable     | Python configuration attribute | Default          | \n",
    "| ------------------------------------------ | ------------------------- | ---------------------------- | ------------------------------ | ---------------- |\n",
    "| OMEX Metadata format                       | `omexMetadataInputFormat` | `OMEX_METADATA_INPUT_FORMAT` | `OMEX_METADATA_INPUT_FORMAT`   | `rdfxml`         |\n",
    "| OMEX Metadata schema                       | `omexMetadataSchema`      | `OMEX_METADATA_SCHEMA`       | `OMEX_METADATA_SCHEMA`         | `BioSimulations` |\n",
    "| Validate OMEX Manifest                     | `validateOmexManifest`    | `VALIDATE_OMEX_MANIFESTS`    | `VALIDATE_OMEX_MANIFESTS`      | `True`           |\n",
    "| Validate SED-ML files                      | `validateSedml`           | `VALIDATE_SEDML`             | `VALIDATE_SEDML`               | `True`           |\n",
    "| Validate sources of models of SED-ML files | `validateSedmlModels`     | `VALIDATE_SEDML_MODELS`      | `VALIDATE_SEDML_MODELS`        | `True`           |\n",
    "| Validate OMEX Metadata files               | `validateOmexMetadata`    | `VALIDATE_OMEX_METADATA`     | `VALIDATE_OMEX_METADATA`       | `True`           |\n",
    "| Validate image files                       | `validateImages`          | `VALIDATE_IMAGES`            | `VALIDATE_IMAGES`              | `True`           |\n",
    "\n",
    "Two conventions for minimum metadata are supported:\n",
    "* **OMEX Metadata** (`rdf_triples`): This convention does not require any minimal set of metadata. This convention supports anything that can be encoded in RDF. Validation is performed using [libOmexMeta](https://sys-bio.github.io/libOmexMeta/).\n",
    "* **BioSimulations** (`BioSimulations`): We recommend using the BioSimulations convention. This convention imposes additional requirements beyond the OMEX Metadata convention for minimal metdata about a simulation project, including a title, at least one creator, and a license. More information about this convention is available at [https://docs.biosimulations.org](https://docs.biosimulations.org/concepts/conventions/simulation-project-metadata/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "24e7e8a4-5677-4eee-861e-193512586819",
   "metadata": {},
   "outputs": [],
   "source": [
    "from biosimulators_utils.config import Config\n",
    "from biosimulators_utils.omex_meta.data_model import OmexMetadataSchema\n",
    "config = Config(\n",
    "    VALIDATE_OMEX_MANIFESTS=True,\n",
    "    VALIDATE_SEDML=True,\n",
    "    VALIDATE_SEDML_MODELS=True,\n",
    "    VALIDATE_OMEX_METADATA=True,\n",
    "    OMEX_METADATA_SCHEMA=OmexMetadataSchema.biosimulations,\n",
    "    VALIDATE_IMAGES=True,\n",
    ")\n",
    "archive = CombineArchiveReader().run(archive_filename, archive_dirname, config=config)\n",
    "errors, warnings = validate(archive, archive_dirname, config=config)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b681c477-a44a-4a44-a6eb-4cf004df41fa",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    Plain zip archives can be validated by setting <code>VALIDATE_OMEX_MANIFESTS=False</code>.\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    Comprehensive validation of SED-ML requires <code>VALIDATE_SEDML=True</code> and <code>VALIDATE_SEDML_MODELS=True</code>. If the latter is false, the sources of the models in SED-ML files and targets to these models will not be validated.\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    OMEX Manifests are required for validating OMEX Metadata files. As a result, <code>VALIDATE_OMEX_METADATA=False</code> should often be used together with <code>VALIDATE_OMEX_MANIFESTS=False</code>.\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    When OMEX Metadata files describe thumbnail images (e.g., for projects), <code>VALIDATE_IMAGES=True</code> is required to comprehensively validate OMEX Metadata files, including linked images.\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    BioSimulations' minimum metadata conventions are required for publication to BioSimulations'. Currently, publication to BioSimulations is also restricted to RDF-XML OMEX Metadata files.\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}