notebook/Unit4-3-RefrigerationCycle_OOP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Refrigeration cycle Analysis - OOP\n",
    "\n",
    "* expressions to code directly\n",
    "\n",
    "\n",
    "* Object-oriented programming\n",
    "\n",
    "\n",
    "> SimVCCE Branch : B2023-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 The vapor-compression refrigeration cycle\n",
    "\n",
    ">Yunus A. Cengel, Michael A. Boles,Thermodynamics: An Engineering Approach, 8th Edition, McGraw-Hill,2015\n",
    "\n",
    "### EXAMPLE 11–1 The Ideal Vapor-Compression Refrigeration  Cycle\n",
    "\n",
    "\n",
    "A refrigerator uses R134a as the working fluid and operates on an ideal vapor-compression refrigeration cycle between 0.14 and 0.8 MPa.\n",
    "\n",
    "If the mass flow rate of the refrigerant is 0.05 kg/s, \n",
    "\n",
    "**Determine** \n",
    "\n",
    "* (a) the rate of heat\n",
    "removal from the refrigerated space and the power input to the compressor,\n",
    "* (b) the rate of heat rejection to the environment, and \n",
    "* (c) the COP of the refrigerator.\n",
    "\n",
    "\n",
    "![ivcr-11-1](./img/vcr/ivcr-11-1.jpg)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 The Object-oriented Programming of Refrigeration cycle\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### 2.1   Decomposition and Abstraction  of  Refrigeration cycle\n",
    "\n",
    "Programming is about managing <b>complexity</b> in a way that <b>facilitates change</b>.\n",
    "\n",
    "There are **two** powerful mechanisms available for accomplishing this: \n",
    "\n",
    "* <b style=\"color:blue\">decomposition</b> \n",
    "\n",
    "* <b style=\"color:blue\">abstraction</b>`  \n",
    "\n",
    "We apply decomposition and abstraction with OOP to code the Vapor-Compression Refrigeration Cycle\n",
    "\n",
    "The Ideal Vapor-Compression Refrigeration  Cycle\n",
    "\n",
    "![](./img/vcr/vcr-cycle.jpg)\n",
    "\n",
    "\n",
    "**Decomposition**\n",
    "\n",
    "We can model the program accordingly to the **\"real things\"** appear in the VCR cycle.\n",
    "\n",
    "**`device` Objects** in a Ideal Vapor-Compression Refrigeration Cycle\n",
    "\n",
    "* Compressor\n",
    "* Condenser\n",
    "* Expansion Valve\n",
    "* Evaporator\n",
    "\n",
    "![](./img/oop/vcr-objects.jpg)\n",
    "\n",
    "\n",
    "**`port` Object** in a Vapor-Compression Refrigeration Cycle\n",
    "\n",
    "* the device of cycle have **port**s,the devices are **connected through** ports to the cycle\n",
    "\n",
    "![](./img/vcr/vcc-evaporator.jpg)\n",
    "\n",
    "So,the refrigeration cycle have **two** kind of objects:\n",
    "\n",
    "* **1** - <b style=\"color:blue\">devices</b>:  Compressor，Condenser，Expansion Valve，Evaporator, **Flash Chamber**, **Mixture Chamber**\n",
    "\n",
    "* **2** - <b style=\"color:blue\">port</b>: interacting with each device\n",
    "\n",
    "**Abstraction**  : Define the classes of item in cycle : \n",
    "\n",
    "* <b style=\"color:blue\">Attribute and Methods</b>\n",
    "\n",
    "**Algorithms** : \n",
    "\n",
    "* **connect** the devices to cycle through the ports\n",
    "\n",
    "* obtain the **solutions**: device and cycle "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2  The Python Project of Refrigeration Cycle with OOP\n",
    "\n",
    "* SimVCCE Branch: B2023-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "<vccpython>\n",
    "   | \n",
    "   |── vccapp.py  #  main app\n",
    "   |── vccapp_json.py  #  main app using json\n",
    "   |\n",
    "   |── <components> port and devices classes\n",
    "   |      |   \n",
    "   |      |── port.py\n",
    "   |      |── device_siso.py\n",
    "   |      |── compressor.py\n",
    "   |           .... \n",
    "   |── <vcc> the cycle analysis methods\n",
    "   |      |\n",
    "   |      |── connector.py # The Connector\n",
    "   |      |── vccobj.py # the VCRCycle \n",
    "   |      |── utils.py #  utils methods  \n",
    "   |              \n",
    "   |── <vccmodel> the cycle data dicts\n",
    "   |      |\n",
    "   |      |── *vcr*.py # the cycle dict\n",
    "   | \n",
    "   |── <jsonmodel> json of the cycle flowchart and data \n",
    "   |      |\n",
    "   |      |── *vcr*.json\n",
    "   |\n",
    "   |── <result>          \n",
    "         |\n",
    "         |─ *vcr*.txt \n",
    "```         \n",
    "\n",
    "The working floder is \n",
    "\n",
    "```\n",
    "<SE>\n",
    "   | \n",
    "   |─ <SEES>\n",
    "   |   |   \n",
    "   |   |─<notebook> **current working dir**\n",
    "   |     \n",
    "   |─ <SimVCCE>\n",
    "      |   \n",
    "      |─<vccpython> \n",
    "```     \n",
    "\n",
    "So, the Python's project dir `../../SimVCCE/vccpython` for loading source codes into the notebook\n",
    "\n",
    ">**`..`** (double-dot) to refer to the **parent** directory "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 components Package\n",
    "\n",
    "./components/\n",
    "\n",
    "* `__init__.py`\n",
    "\n",
    "* port.py\n",
    "\n",
    "* device_siso.py\n",
    "\n",
    "* compressor.py\n",
    "\n",
    "* condenser.py\n",
    "\n",
    "* expansionvalve.py\n",
    "\n",
    "* evaporator.py\n",
    "\n",
    "\n",
    "![Components package](./img/vcr/uml/package-components.jpg)  \n",
    "\n",
    "#### UML: Package \n",
    "\n",
    "Package : a general purpose mechanism for **organising model** elements into **groups**.\n",
    "\n",
    "**Package diagrams** can use packages that represent the different layers of a software system to illustrate the **layered architecture** of a software system\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Port Class\n",
    "\n",
    " \n",
    "* **Properties:** index, `refrigerant`, p,t,h,s,x,mdot,etc \n",
    "\n",
    "* **Methods:** state(), `__str__`\n",
    "\n",
    "![uml-port](./img/vcr/uml/uml-port.jpg)\n",
    "\n",
    "\n",
    "<b style=\"color:blue\">Port: dictnode dict</b>\n",
    " \n",
    "The inlet port of compresor\n",
    "\n",
    "```python\n",
    "{\"refrigerant\":\"R134a\",\"p\":0.14,\"t\": None,  \"x\": 1, \"mdot\": 0.05}\n",
    "  \n",
    "```\n",
    "using the the **cycle_refrigerant**: \n",
    "\n",
    "```python\n",
    "{\"p\":0.14,\"t\": None,  \"x\": 1, \"mdot\": 0.05}\n",
    "\n",
    "```\n",
    "remove the `None` item\n",
    "\n",
    "```python\n",
    "{\"p\":0.14,\"x\": 1, \"mdot\": 0.05}\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b style=\"color:blue\">update([other])</b>\n",
    "\n",
    "Update the dictionary with the `key/value` pairs from other, **overwriting** existing keys. Return None.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kwargs = {'refrigerant':'R134a', \n",
    "              'index': None,\n",
    "              'p': None,\n",
    "              't': None,\n",
    "              'h': None,\n",
    "              's': None,\n",
    "              'x': None,\n",
    "              'mdot': None\n",
    "              }\n",
    "\n",
    "node1={\"p\": 0.14,  \"x\": 1, \"mdot\": 0.05}\n",
    "\n",
    "kwargs.update(node1)    \n",
    "\n",
    "print(kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b style=\"color:blue\">The class attribute .`__dict__`</b>\n",
    "\n",
    "The built-in class attribute `__dict__`\n",
    "\n",
    "* The `dictionary` containing instance variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Port:\n",
    "    cycle_refrigerant = 'R134a'\n",
    "    def __init__(self):\n",
    "        self.p=None\n",
    "        self.t=None\n",
    "        self.x=None\n",
    "        self.h=None\n",
    "        self.mdot=None\n",
    "\n",
    "port1=Port()\n",
    "print(port1.__dict__)\n",
    "print(port1.__dict__.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**object.`__dict__` and update()**\n",
    "\n",
    "update the instance **port1** attributes  with the  dictionary **node1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "node1={\"p\": 0.14,  \"x\": 1, \"mdot\": 0.05}\n",
    "\n",
    "port1.__dict__.update(node1)\n",
    "\n",
    "print(port1.__dict__)\n",
    "\n",
    "print(port1.p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "update the instance attributes of **port** with the input dictionary **dictnode**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Port:\n",
    "    cycle_refrigerant = 'R134a'\n",
    "    \n",
    "    def __init__(self,dictnode):\n",
    "        self.p=None\n",
    "        self.t=None\n",
    "        self.x=None\n",
    "        self.h=None\n",
    "        self.mdot=None\n",
    "        self.__dict__.update(dictnode)  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "port1=Port(node1)\n",
    "\n",
    "\n",
    "print(port1.__dict__)\n",
    "print(port1.p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../../SimVCCE/vccpython/components/port.py\n",
    "\"\"\"\n",
    "General Object-oriented Abstraction of VC Cycle \n",
    "  The port of device：\n",
    "       dictNode: {\"p\",\"t\",\"x\",\"mdot\",\"refrigerant\"}\n",
    "       the default refrigerant  is Port.cycle_refrigerant\n",
    "\n",
    " Author: Cheng Maohua cmh@seu.edu.cn\n",
    "\"\"\"\n",
    "from phyprops.prop_coolprop import *\n",
    "\n",
    "class Port:\n",
    "    cycle_refrigerant = 'R134a'\n",
    "  \n",
    "    w = 12\n",
    "    title = f'{\"Index\":^6s} {\"P(MPa)\":^{w}s} {\"T(°C)\":^{w}s} {\"H(kJ/kg)\":^{w}s} {\"S(kJ/kg.K)\":^{w}s} {\"Quality\":^{w}s} {\"MDOT(kg/s)\":^{w}s}'\n",
    "\n",
    "    pairs = {('p', 't'): {'h': pt_h, 's': pt_s},\n",
    "             ('t', 'x'): {'p': tx_p, 'h': tx_h, 's': tx_s},\n",
    "             ('p', 'x'): {'t': px_t, 'h': px_h, 's': px_s},\n",
    "             ('p', 's'): {'h': ps_h, 't': ps_t, 'x': ps_x},\n",
    "             ('p', 'h'): {'s': ph_s, 't': ph_t, 'x': ph_x}}\n",
    "\n",
    "    def __init__(self, dictnode):\n",
    "        \"\"\" create the node object\"\"\"\n",
    "        self.refrigerant = Port.cycle_refrigerant\n",
    "        self.index = None\n",
    "        self.p = None\n",
    "        self.t = None\n",
    "        self.h = None\n",
    "        self.s = None\n",
    "        self.x = None\n",
    "        self.mdot = None\n",
    "        # update the instance attributes with  dictnode\n",
    "        self.__dict__.update(dictnode)\n",
    "        # step1 state : input values\n",
    "        self.stateok = False\n",
    "        \n",
    "        self.state()\n",
    "\n",
    "    def state(self):\n",
    "        if self.stateok == False:\n",
    "            for pair,keyfun in Port.pairs.items():\n",
    "                \n",
    "                v0 = self.__dict__[pair[0]] \n",
    "                v1 = self.__dict__[pair[1]]\n",
    "                \n",
    "                if v0 is not None and v1 is not None:\n",
    "                    stateok=True\n",
    "                    # loop to get all props of (v0,v1)\n",
    "                    for key, fun in keyfun.items():\n",
    "                        if self.__dict__[key] is None:\n",
    "                            try:\n",
    "                                self.__dict__[key] = fun(v0,v1, self.refrigerant)\n",
    "                            except:\n",
    "                                stateok = False\n",
    "                    # end loop to get all props of (v0,v1)\n",
    "                    self.stateok = stateok\n",
    "                    break  # exit for pair,keyfun\n",
    "\n",
    "    def __str__(self):\n",
    "        result = f'{self.index:^6d}' if type(self.index) is int else f'{3*\"-\":^6s}'\n",
    "\n",
    "        OutStrs = {self.p: '.4f',\n",
    "                   self.t: '.2f',\n",
    "                   self.h: '.2f',\n",
    "                   self.s: '.3f',\n",
    "                   self.x: '.3f',\n",
    "                   self.mdot: '.4f'}\n",
    "        for value, fstr in OutStrs.items():\n",
    "            valuestr = f' {value:^{Port.w}{fstr}}' if type(value) is float else f'{5*\"-\":>10s}'\n",
    "            result += valuestr\n",
    "        return result\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Device Classes\n",
    "\n",
    "#### 3.2.1 The Class Device_SISO \n",
    "\n",
    "The class **Device_SISO** has the **common**  Attributes and Methods of all sigle inlet and outlet devices \n",
    "\n",
    "**Compressor，Condenser，Expansion Valve，Evaporator**\n",
    "\n",
    "* **Attributes:**  \n",
    "  \n",
    "  * energy(class)\n",
    "  \n",
    "  * devtype(class)\n",
    " \n",
    "  * name\n",
    "   \n",
    "  * iPort，oPort\n",
    "\n",
    "* **Methods:**  \n",
    "  \n",
    "  * state\n",
    "\n",
    "  * mass_balance\n",
    "  \n",
    "  * balance\n",
    "  \n",
    "  * `__str__`\n",
    "\n",
    "\n",
    "![device_siso](img/vcr/uml/device_siso.jpg)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../../SimVCCE/vccpython/components/device_siso.py\n",
    "\"\"\"\n",
    "General Object-oriented Abstraction of VC Cycle \n",
    "\n",
    "The base class for single inlet and outlet device\n",
    "\n",
    " Author: Cheng Maohua cmh@seu.edu.cn   \n",
    "\"\"\"\n",
    "from .port import *\n",
    "\n",
    "class Device_SISO:\n",
    "    \"\"\" The base class for single inlet and outlet device\"\"\"\n",
    "    energy = \"\"\n",
    "    devtype = \"SISO\"\n",
    "\n",
    "    def __init__(self, dictDev):\n",
    "        \"\"\"   Initializes   \"\"\"\n",
    "        self.name = dictDev['name']\n",
    "        self.iPort = Port(dictDev['iPort'])\n",
    "        self.oPort = Port(dictDev['oPort'])\n",
    "     \n",
    "    def state(self):\n",
    "        raise Exception(\"override state() for the specified device\")\n",
    "\n",
    "    def mass_balance(self):\n",
    "        if self.iPort.mdot is None and self.oPort.mdot is None:\n",
    "            raise ValueError(\"mdot is None\")\n",
    "        if self.iPort.mdot is not None:\n",
    "            self.oPort.mdot = self.iPort.mdot\n",
    "        elif self.oPort.mdot is not None:\n",
    "            self.iPort.mdot = self.oPort.mdot\n",
    "\n",
    "    def balance(self):\n",
    "        \"\"\"  mass and energy balance    \"\"\"\n",
    "        self.mass_balance()\n",
    "\n",
    "    def __str__(self):\n",
    "        result = '\\n' + self.name\n",
    "        result += '\\n' + \" PORTS \" + Port.title\n",
    "        result += '\\n' + \" iPort \" + self.iPort.__str__()\n",
    "        result += '\\n' + \" oPort \" + self.oPort.__str__()\n",
    "        return result\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.2  Compressor Class\n",
    "\n",
    "![vcr-compressor](./img/vcr/vcr-compressor.jpg)\n",
    "\n",
    "* **Attributes:**  \n",
    " \n",
    "  * iPort，oPort\n",
    "  \n",
    "  * compressor work: Wc\n",
    "  \n",
    "  * isentropic compressor efficiency：ef\n",
    "\n",
    "* **Process:**  \n",
    "  \n",
    "  * Isentropic compression(ideal VPR cycle)\n",
    "\n",
    "\n",
    "![uml-compressor](./img/vcr/uml/uml-compressor.jpg)\n",
    "\n",
    "The dict  of device\n",
    "```python\n",
    "{\n",
    "        \"name\": \"Compressor\",\n",
    "        \"devtype\": \"COMPRESSOR\",\n",
    "        \"iPort\": {\"p\": 0.14,  \"x\": 1, \"mdot\": 0.05},\n",
    "        \"oPort\": {},\n",
    "        \"ef\": 1.0\n",
    "}\n",
    "```   \n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../../SimVCCE/vccpython/components/compressor.py\n",
    "\n",
    "\"\"\"\n",
    "General Object-oriented Abstraction of VC Cycle \n",
    "\n",
    " Compressor:\n",
    "      if ef=1.0, Isentropic compression \n",
    " \n",
    " Author: Cheng Maohua cmh@seu.edu.cn   \n",
    "\"\"\"\n",
    "from .device_siso import Device_SISO\n",
    "\n",
    "\n",
    "class Compressor(Device_SISO):\n",
    "    \"\"\" compression of the refrigerant\"\"\"\n",
    "    energy = \"CompressionWork\"\n",
    "    devtype = \"COMPRESSOR\"\n",
    "\n",
    "    def __init__(self, dictDev):\n",
    "        \"\"\"  Initializes  \"\"\"\n",
    "        super().__init__(dictDev)\n",
    "        if (\"ef\" in dictDev):\n",
    "            try:\n",
    "                self.ef = float(dictDev['ef'])\n",
    "            except:\n",
    "                self.ef = None\n",
    "        else:\n",
    "            self.ef = 1.0\n",
    "        # add your code here for the input Wc\n",
    "\n",
    "    def state(self):\n",
    "        \"\"\"\n",
    "            if ef=1.0, Isentropic compression \n",
    "        \"\"\"\n",
    "        if self.ef == 1.0:\n",
    "            self.oPort[0].s = self.iPort[0].s\n",
    "         # ef\n",
    "        if self.ef is None or self.ef != 1.0:\n",
    "            pass  # add your code here to get the oPort state\n",
    "\n",
    "    def balance(self):\n",
    "        \"\"\"  mass and energy balance    \"\"\"\n",
    "\n",
    "        # add your code here to get the mass flow rate\n",
    "\n",
    "        # mass balance\n",
    "        super().mass_balance()\n",
    "        # energy balance\n",
    "\n",
    "        # add your code here when Wc is known\n",
    "\n",
    "        self.Wc = self.iPort[0].mdot * (self.oPort[0].h - self.iPort[0].h)\n",
    "\n",
    "    def __str__(self):\n",
    "        result = super().__str__()\n",
    "        result += f'\\nThe compressor efficiency(%): \\t{self.ef:{\">.2%\" if self.ef is not None else \"\"}}'\n",
    "        result += f'\\nWc(kW): \\t{self.Wc:{\">.2f\" if type(self.Wc) is float else \"\"}}'\n",
    "        return result\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.3 Condenser Class\n",
    "\n",
    "The Condenser \n",
    "\n",
    "![vcr-condenser](./img/vcr/vcr-condenser.jpg)\n",
    "\n",
    "* **Attributes:**  \n",
    " \n",
    "  * iPort，oPort \n",
    "  * Qout\n",
    "  \n",
    "* **Process** \n",
    "\n",
    "  *  heat rejection\n",
    "\n",
    "\n",
    "![uml-condenser](./img/vcr/uml/uml-condenser.jpg)\n",
    "\n",
    "The dict \n",
    " \n",
    "```python\n",
    "  {\n",
    "        \"name\": \"Condenser\",\n",
    "        \"devtype\": \"CONDENSER\",\n",
    "        \"iPort\": {},\n",
    "        \"oPort\": {\"p\": 0.8,  \"x\": 0},\n",
    "\n",
    "    }\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../../SimVCCE/vccpython/components/condenser.py\n",
    "\n",
    "\"\"\"\n",
    "General Object-oriented Abstraction of VC Cycle \n",
    "   Condenser: heat rejection\n",
    " \n",
    " Author: Cheng Maohua cmh@seu.edu.cn\n",
    "\"\"\"\n",
    "from .device_siso import Device_SISO\n",
    "\n",
    "class Condenser(Device_SISO):\n",
    "\n",
    "    energy = \"QOUT\"\n",
    "    devtype = \"CONDENSER\"\n",
    "\n",
    "    def __init__(self, dictDev):\n",
    "        \"\"\" Initializes the condenser \"\"\"\n",
    "        super().__init__(dictDev)\n",
    "        if (\"Qout\" in dictDev):\n",
    "            self.Qout = float(dictDev[\"Qout\"])\n",
    "        else:\n",
    "            self.Qout = None\n",
    "      \n",
    "    def state(self):\n",
    "        \"\"\" ideal  Isobaric \"\"\"\n",
    "        if self.oPort[0].p is not None and self.iPort[0].p is None:\n",
    "            self.iPort[0].p = self.oPort[0].p\n",
    "        elif self.iPort[0].p is not None and self.oPort[0].p is None:\n",
    "            self.oPort[0].p = self.iPort[0].p\n",
    "    \n",
    "    \n",
    "    def balance(self):\n",
    "        \"\"\" mass and energy balance of the condenser  \"\"\"\n",
    "        if self.Qout is not None:\n",
    "            self.iPort[0].mdot = self.Qout/(self.iPort[0].h-self.oPort[0].h)\n",
    "   \n",
    "        super().mass_balance()\n",
    "        \n",
    "        if self.Qout is None:\n",
    "            self.Qout = self.iPort[0].mdot*(self.iPort[0].h-self.oPort[0].h)\n",
    "\n",
    "    def __str__(self):\n",
    "        result = super().__str__()\n",
    "        result += f'\\nQout(kW): \\t{self.Qout:{\">.2f\" if type(self.Qout) is float else \"\"}}'\n",
    "        return result\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.4 Expansion Valve Class\n",
    "\n",
    "![vcr-expansionvalve](./img/vcr/vcr-expansionvalve.jpg)\n",
    "\n",
    "* **Attributes:**  \n",
    " \n",
    "  * iPort，oPort\n",
    "  \n",
    "* **Process**\n",
    "  * Throttling : (ideal Isenthalpic )expansion\n",
    "\n",
    "![uml-expansionvalve](./img/vcr/uml/uml-expansionvalve.jpg)\n",
    "\n",
    "The Dict\n",
    "\n",
    "```python\n",
    "   {\n",
    "        \"name\": \"ExpansionValve\",\n",
    "        \"devtype\": \"EXPANSIONVALVE\",\n",
    "        \"iPort\": {},\n",
    "        \"oPort\": {},\n",
    "    }\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../../SimVCCE/vccpython/components/expansionvalve.py\n",
    "\"\"\"\n",
    "General Object-oriented Abstraction of VC Cycle \n",
    "  ExpansionValve:\n",
    " \n",
    " Author: Cheng Maohua cmh@seu.edu.cn   \n",
    "\"\"\"\n",
    "from .device_siso import Device_SISO\n",
    "\n",
    "class ExpansionValve(Device_SISO):\n",
    "\n",
    "    energy = \"None\"\n",
    "    devtype = \"EXPANSIONVALVE\"\n",
    "\n",
    "    def state(self):\n",
    "        \"\"\" ideal Isenthalpic expansion \"\"\"\n",
    "        if self.iPort[0].h is not None and self.oPort[0].h is None:\n",
    "           self.oPort[0].h = self.iPort[0].h\n",
    "        elif self.oPort[0].h is not None and self.iPort[0].h is None:\n",
    "            self.iPort[0].h = self.oPort[0].h\n",
    "     \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.5 Evaporator Class\n",
    "\n",
    "The Evaporator \n",
    "\n",
    "![vcr-evaporator](./img/vcr/vcr-evaporator.jpg)\n",
    "`\n",
    "* **Attributes:**  \n",
    "\n",
    "  * iPort，oPort \n",
    "  \n",
    "  * Qin\n",
    "\n",
    "* **Process**\n",
    "  \n",
    "  *  heat addition (ideal isobaric)\n",
    "\n",
    "\n",
    "![uml-evaporator](./img/vcr/uml/uml-evaporator.jpg)\n",
    "\n",
    "The dict\n",
    "```python\n",
    "\n",
    "   {\n",
    "        \"name\": \"Evaporator\",\n",
    "        \"devtype\": \"EVAPORATOR\",\n",
    "        \"iPort\": {},\n",
    "        \"oPort\": {},\n",
    "    }\n",
    "\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../../SimVCCE/vccpython/components/evaporator.py\n",
    "\n",
    "\"\"\"\n",
    "General Object-oriented Abstraction of VC Cycle \n",
    "\n",
    "Evaporator:\n",
    "    heat addition\n",
    "\n",
    "Author: Cheng Maohua cmh@seu.edu.cn    \n",
    "\"\"\"\n",
    "from .device_siso import Device_SISO\n",
    "\n",
    "class Evaporator(Device_SISO):\n",
    "\n",
    "    energy = \"QIN\"\n",
    "    devtype = \"EVAPORATOR\"\n",
    "\n",
    "    def __init__(self, dictDev):\n",
    "        \"\"\" Initializes the Evaporator \"\"\"\n",
    "        super().__init__(dictDev)\n",
    "        self.Qin=None\n",
    "\n",
    "    def state(self):\n",
    "        \"\"\" ideal Isobaric \"\"\"\n",
    "        if self.oPort[0].p is not None and self.iPort[0].p is None:\n",
    "            self.iPort[0].p = self.oPort[0].p\n",
    "        elif self.iPort[0].p is not None and self.oPort[0].p is None:\n",
    "            self.oPort[0].p = self.iPort[0].p\n",
    "\n",
    "    def balance(self):\n",
    "        \"\"\" mass and energy balance  \"\"\"\n",
    "\n",
    "        # mass balance\n",
    "        super().mass_balance()\n",
    "\n",
    "        # energy balance\n",
    "        self.Qin = self.iPort[0].mdot * (self.oPort[0].h - self.iPort[0].h)\n",
    "\n",
    "    def __str__(self):\n",
    "        result = super().__str__()\n",
    "        result += f'\\nQin(kW): \\t{self.Qin:{\">.2f\" if type(self.Qin) is float  else \"\"}}'\n",
    "        return result\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 The Class and Instance Relationship\n",
    "\n",
    "#### 3.3.1 The Class Inheritance Relationship\n",
    "\n",
    "\n",
    "![components_device_siso](./img/vcr/uml/components_device_siso.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3.2 The Instance Composition \n",
    "\n",
    "The **Instance-level(实例层关系）** relation :\n",
    "\n",
    "**Composition(组合）** represents a whole-part relationship \n",
    "\n",
    "* the **whole** is **destroyed**, the **parts** are also **destroyed**, \n",
    "\n",
    "**Example**: House and Room. Rooms don't exist separate to a House.\n",
    "\n",
    "The UML representation of a composition relationship shows composition as a **filled diamond** shape on the **whole(整体）end** of the lines that connect **parts(部分)** classes to the whole class.\n",
    "\n",
    "![composition](img/vcr/uml/composition.jpg)\n",
    "\n",
    "The **Instance-level** relationships relation between **components** and **Port** is :**Composition(组合)**\n",
    "\n",
    "![components_port](img/vcr/uml/components_port.jpg)\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4 `__init__.py`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../../SimVCCE/vccpython/components/__init__.py\n",
    "\"\"\"\n",
    "General Object-oriented Abstraction of VC Cycle \n",
    "\n",
    "   Components Package: port and devices\n",
    "   \n",
    " Author: Cheng Maohua cmh@seu.edu.cn    \n",
    "\"\"\"\n",
    "\n",
    "from .compressor import Compressor\n",
    "from .condenser import Condenser\n",
    "from .expansionvalve import ExpansionValve\n",
    "from .evaporator import Evaporator\n",
    "\n",
    "# ------------------------------------------------------------------------------\n",
    "# compdict\n",
    "#      devtype : class\n",
    "# Note: add devtype of the class to the dict after you add the new device class\n",
    "# --------------------------------------------------------------------------------\n",
    "\n",
    "compdict = {\n",
    "    Compressor.devtype: Compressor,\n",
    "    Condenser.devtype: Condenser,\n",
    "    ExpansionValve.devtype: ExpansionValve,\n",
    "    Evaporator.devtype: Evaporator\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 vcc  Package\n",
    "```\n",
    "<vcc> the cycle analysis methods\n",
    "  |\n",
    "  |── __init__.py  \n",
    "  |\n",
    "  |── connector.py # the Class Connector \n",
    "  |\n",
    "  |── vccobj.py # the Class VCR cycle \n",
    "  |     \n",
    "  |── utils.py #  utils methods  \n",
    "```  \n",
    "\n",
    "![package-vcc](./img/vcr/uml/package-vcc.jpg)\n",
    "\n",
    "#### UML: The `import` relation of packages\n",
    "\n",
    "A package import is shown using a **dashed** arrow with an open arrowhead from the **importing** namespace to the **imported** package.\n",
    "\n",
    "![vcc_components](./img/vcr/uml/vcc_components.jpg)  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1  `__init__.py`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../../SimVCCE/vccpython/vcc/__init__.py\n",
    "\n",
    "\"\"\"\n",
    " General Object-oriented Abstraction of VC Cycle \n",
    "\"\"\"\n",
    "\n",
    "import sys\n",
    "sys.path.append('../')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2  Connector \n",
    "\n",
    "#### 4.2.1 The Class  Connector \n",
    "\n",
    "**Properties**\n",
    "\n",
    "* nodes=[] : \n",
    "\n",
    "**Methods:**\n",
    "\n",
    "*  __combined_node_value(self, node, port)\n",
    "\n",
    "* __add_node(self,index, portpairs, comps):\n",
    "\n",
    "\n",
    "![uml-connector](./img/vcr/uml/uml-connector.jpg)\n",
    "\n",
    "portpairs is the tuple:\n",
    " \n",
    "* (\"compnameA.portname0\"：\"compnameB.portname1\")\n",
    "\n",
    "for example:\n",
    "\n",
    "```python\n",
    "\"Compressor.oPort\":\"Condenser.iPort\"\n",
    "```\n",
    "\n",
    "![](./img/vcr/vcr-cycle.jpg)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../../SimVCCE/vccpython/vcc/connector.py\n",
    "\"\"\"\n",
    "General Object-oriented Abstraction of VC Cycle \n",
    "  \n",
    "  class Connector\n",
    "\n",
    " Author: Cheng Maohua cmh@seu.edu.cn\n",
    "\"\"\"\n",
    "\n",
    "from components.port import *\n",
    "\n",
    "\n",
    "class Connector:\n",
    "\n",
    "    def __init__(self, connectors, comps):\n",
    "        self.nodes = []\n",
    "        for i,item in enumerate(connectors.items()):\n",
    "            self.__add_node(i,item, comps)\n",
    "     \n",
    "    def __combined_node_value(self, node, port):\n",
    "        \"\"\" \n",
    "           the node is the connector of two ports ,so the node may get values from all of two ports\n",
    "            the values is the union set of the non-none values within two ports \n",
    "        \"\"\"\n",
    "        for key, portvalue in port.__dict__.items():\n",
    "            nodevalue = node.__dict__[key]\n",
    "            if portvalue is not None and nodevalue is None:\n",
    "                node.__dict__[key] = portvalue\n",
    "      \n",
    "    def __add_node(self, index, portpairs, comps):\n",
    "        \"\"\" node : (\"comp0.port0\", \"comp1.port1\")\"\"\"\n",
    "        comp0, port0 = portpairs[0].split(\".\")\n",
    "        comp1, port1 = portpairs[1].split(\".\")\n",
    "\n",
    "        # 1 get the index of port in nodes\n",
    "        comps[comp0].__dict__[port0].index = index\n",
    "        # 2 create the new node with port0\n",
    "        self.nodes.append(comps[comp0].__dict__[port0])  # port0\n",
    "\n",
    "        # 3 merge comp1's port1 info into  nodes[index]\n",
    "        self.__combined_node_value(self.nodes[index], comps[comp1].__dict__[port1])\n",
    "        # 4 set port0 and port1 as the alias of  nodes[index]\n",
    "        comps[comp0].__dict__[port0]= self.nodes[index]\n",
    "        comps[comp1].__dict__[port1] = self.nodes[index]\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.2.2 Using the alias\n",
    "\n",
    "* [Unit1-4-2-List.ipynb#5-Aliasing](./Unit1-4-2-List.ipynb#5-Aliasing)\n",
    "\n",
    "Python is `dynamically typed`, which means that \n",
    "\n",
    "* A **variable** is just a **name** of an **object**\n",
    "\n",
    "* `Variables`  is **not** the `object`\n",
    "\n",
    "```python\n",
    "  comps[comp0].__dict__[port0]= self.nodes[index]\n",
    "  comps[comp1].__dict__[port1] = self.nodes[index]\n",
    "```        \n",
    "![port_alias](./img/vcr/port_alias.jpg)\n",
    "\n",
    "There are **three** distinct paths(`variables`) to the **same** the instance `object of port` \n",
    "\n",
    "We can mutate the the instance object of port in any path(variable), and the effect of the mutation will be visible through any path(variable).\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### 4.3 The VC Cycle Analysis\n",
    "\n",
    "#### 4.3.1 The flowchart for  the VC  cycle analysis\n",
    "\n",
    "  \n",
    "* 1 init devices,connector \n",
    "   * 1.1 devices\n",
    "   * 1.2 connector \n",
    "\n",
    "* 2 simulate devices\n",
    "  \n",
    "  * 2.1 port state of device\n",
    "  * 2.2 thermal process of device\n",
    "  * 2.3 mass and energy balance of device \n",
    "\n",
    "* 3 the cycle performance\n",
    "\n",
    "![vcc-flowchart](./img/vcr/uml/vcc-flowchart.jpg)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.3.2 The Class VCCycle\n",
    "\n",
    "![vcrcycle](img/vcr/uml/uml-vccycle.jpg)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../../SimVCCE/vccpython/vcc/vccobj.py\n",
    "\"\"\"\n",
    "General Object-oriented Abstraction of VC Cycle \n",
    "\n",
    " class VCCycle: the Simulator class of VC Cycle  \n",
    "\n",
    " Author: Cheng Maohua cmh@seu.edu.cn\n",
    "\"\"\"\n",
    "\n",
    "from time import time, localtime, strftime\n",
    "from getpass import getuser\n",
    "\n",
    "from components import compdict\n",
    "from components.port import Port\n",
    "from .connector import Connector\n",
    "\n",
    "\n",
    "class VCCycle:\n",
    "\n",
    "    def __init__(self, dictcycle):\n",
    "        \"\"\"\n",
    "          dictcycle={\"name\":namestring,\n",
    "                     \"refrigerant\":refrigerantstring,\n",
    "                     \"components\":[{component1},{component2},...],\n",
    "                     \"connectors\":{\"name1.port1\":\"name2.port2\",...}\n",
    "                  }\n",
    "          TO:     \n",
    "             self.comps : dict of all component objects      \n",
    "             self.conns : the connector object\n",
    "        \"\"\"\n",
    "        self.name = dictcycle[\"name\"]\n",
    "        self.cycle_refrigerant = dictcycle[\"refrigerant\"]\n",
    "        Port.cycle_refrigerant = self.cycle_refrigerant\n",
    "\n",
    "        # 1 convert dict to the dict of device objects: {device name:device obiect}\n",
    "        self.comps = {}\n",
    "        for curdev in dictcycle[\"components\"]:\n",
    "            self.comps[curdev['name']] = compdict[curdev['devtype']](curdev)\n",
    "\n",
    "        # 2 set the nodes value and alias between the item of nodes and the port of devices\n",
    "        self.conns = Connector(dictcycle[\"connectors\"], self.comps)\n",
    "    \n",
    "    def __component_simulator(self):\n",
    "        \"\"\" calculate the state of ports \"\"\"\n",
    "        # 2 the ports state of device\n",
    "        for key in self.comps:\n",
    "            self.comps[key].state()\n",
    "\n",
    "        # 3 the nodes state of connectors\n",
    "        for item in self.conns.nodes:\n",
    "            if item.stateok == False:\n",
    "                item.state()\n",
    "        # 4 comps[key].balance()\n",
    "        for curdev in self.comps:\n",
    "            self.comps[curdev].balance()\n",
    "    \n",
    "    def simulator(self):\n",
    "        self.__component_simulator()\n",
    "\n",
    "        self.Wc = 0.0\n",
    "        self.Qin = 0.0\n",
    "        self.Qout = 0.0\n",
    "\n",
    "        for key in self.comps:\n",
    "            if self.comps[key].energy == \"CompressionWork\":\n",
    "                self.Wc += self.comps[key].Wc\n",
    "            elif self.comps[key].energy == \"QIN\":\n",
    "                self.Qin += self.comps[key].Qin\n",
    "            elif self.comps[key].energy == \"QOUT\":\n",
    "                self.Qout += self.comps[key].Qout\n",
    "\n",
    "        self.cop = self.Qin / self.Wc\n",
    "        self.cop_hp = self.Qout / self.Wc\n",
    "\n",
    "    def __str__(self):\n",
    "        curtime = strftime(\"%Y/%m/%d %H:%M:%S\", localtime(time()))\n",
    "        result = f\"\\nThe Vapor-Compression Cycle: {self.name} ({curtime} by {getuser()})\\n\"\n",
    "        result += f\"\\nRefrigerant: {self.cycle_refrigerant}\\n\"\n",
    "        \n",
    "        rusult_items = {'Compression Work(kW): ': self.Wc,\n",
    "                        'Refrigeration Capacity(kW): ': self.Qin,\n",
    "                        '\\tCapacity(ton): ': self.Qin*60*(1/211),\n",
    "                        'The heat transfer rate(kW): ': self.Qout,\n",
    "                        'The coefficient of performance: ': self.cop,\n",
    "                        'The coefficient of performance(heat pump):': self.cop_hp}\n",
    "        for name, value in rusult_items.items():\n",
    "            result += f'{name:>35} {value:{\">5.2f\" if type(value) is float else \"\"}}\\n'\n",
    "        return result\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  4.3.3 The Instance  Aggregation\n",
    "\n",
    "The Instance-level **Aggregation(聚合）** represents **Has-A's** relationship， \n",
    "\n",
    "* the **whole** is **destroyed**, the **parts** are usually **not destroyed**\n",
    "\n",
    "**Example**: Class and Student. Delete the Class and the Students still exist.\n",
    "\n",
    "In UML, it is graphically represented as a **hollow diamond** shape on the **whole(整体）** class with a single line that connects it to the **part(部分）** classes. \n",
    "\n",
    "![Aggregation](./img/vcr/uml/aggregation.jpg) \n",
    "\n",
    "\n",
    "**The Aggregation and Composition relation of VCR Cycle and it's components**\n",
    "\n",
    "\n",
    "![vccycle relations_instance](./img/vcr/uml/vccycle_relations_instance.jpg) \n",
    "\n",
    "\n",
    "**The  Class and Instance relations**\n",
    "\n",
    "![vccycle relations_all](./img/vcr/uml/vccycle_relations_all.jpg) \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.3.4 The dictcycle\n",
    "\n",
    "The dict of VC cycle \n",
    "\n",
    "```python\n",
    "  {\"name\":namestring,\n",
    "  \"refrigerant\":refrigerantstring,              \n",
    "  \n",
    "  \"components\":[{component1},{component2},...],\n",
    "  \"connectors\":{\"name1.port1\":\"name2.port2\",...}\n",
    "  }\n",
    "```\n",
    "<b style=\"color:blue\"> the dict of components</b>\n",
    "\n",
    "```python\n",
    "{\n",
    "        \"name\": \"namestring\",\n",
    "        \"devtype\": \"typestriR\",\n",
    "        \"Port*\": {port dict},\n",
    "        \"Port*\": {port dict},\n",
    "        \"v*\":value\n",
    "  },\n",
    "```\n",
    "\n",
    "For example\n",
    "\n",
    "```python\n",
    "{\n",
    "        \"name\": \"Compressor\",\n",
    "        \"devtype\": \"COMPRESSOR\",\n",
    "        \"iPort\": {\"p\": 0.14,  \"x\": 1, \"mdot\": 0.05},\n",
    "        \"oPort\": {},\n",
    "        \"ef\": 1.0\n",
    "  },\n",
    "```\n",
    "<b style=\"color:blue\">The dict of Connector</b>\n",
    "\n",
    "* the item of dict：\"compnameA.portname0\"：\"compnameB.portname1\"\n",
    "\n",
    "For example:\n",
    "\n",
    "```python\n",
    "\"Compressor.oPort\":\"Condenser.iPort\"\n",
    "```\n",
    "![](./img/vcr/vcr-cycle.jpg)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../../SimVCCE/vccpython/vccmodel/ivcr_11_1.py\n",
    "cycle = {\"name\": \"The Ideal VCR Example 11-1\",\n",
    "         \"refrigerant\":\"R134a\"}\n",
    "\n",
    "cycle[\"components\"] = [\n",
    "    {\n",
    "        \"name\": \"Compressor\",\n",
    "        \"devtype\": \"COMPRESSOR\",\n",
    "        \"iPort\": {\"p\": 0.14,  \"x\": 1, \"mdot\": 0.05},\n",
    "        \"oPort\": {},\n",
    "        \"ef\": 1.0\n",
    "    },\n",
    "    {\n",
    "        \"name\": \"Condenser\",\n",
    "        \"devtype\": \"CONDENSER\",\n",
    "        \"iPort\": {},\n",
    "        \"oPort\": {\"p\": 0.8,  \"x\": 0},\n",
    "\n",
    "    },\n",
    "    {\n",
    "        \"name\": \"ExpansionValve\",\n",
    "        \"devtype\": \"EXPANSIONVALVE\",\n",
    "        \"iPort\": {},\n",
    "        \"oPort\": {},\n",
    "    },\n",
    "    {\n",
    "        \"name\": \"Evaporator\",\n",
    "        \"devtype\": \"EVAPORATOR\",\n",
    "        \"iPort\": {},\n",
    "        \"oPort\": {},\n",
    "    }\n",
    "]\n",
    "\n",
    "cycle[\"connectors\"] = {\"Compressor.oPort\":\"Condenser.iPort\",\n",
    "                       \"Condenser.oPort\":\"ExpansionValve.iPort\",\n",
    "                       \"ExpansionValve.oPort\":\"Evaporator.iPort\",\n",
    "                       \"Evaporator.oPort\":\"Compressor.iPort\"}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4   The thermophysical property methods\n",
    "\n",
    "#### 1 Two Sources of Physical Property calculation\n",
    "\n",
    "The thermophysical property: **`Two` Sources of Physical Property calculation**\n",
    "\n",
    "1. Port's **known** parameter pairs\n",
    "2. Component's **thermodynamic process, mass and energy balance**\n",
    "\n",
    "#####  (1) Port's known parameter pairs\n",
    "\n",
    "* `__init__`:  the port's known parameter pairs in the  instantiating port\n",
    "\n",
    "* `state(self)`: after obtain the new parameter pairs \n",
    "\n",
    "\n",
    "```python\n",
    "class Port:\n",
    "    \n",
    "def __init__(self, dictnode):\n",
    "        \"\"\" create the node object\n",
    "            step1 state : input values\n",
    "        \"\"\"\n",
    "        self.stateok = False\n",
    "        self.state()\n",
    "  \n",
    "def state(self):\n",
    "     \"\"\" step3 state: after obtain the new parameter pairs \"\"\"\n",
    "    if self.stateok == False:\n",
    "            try:\n",
    "                for pair,keyfun in Port.pairs.items():\n",
    "                     v0 = self.__dict__[pair[0]]\n",
    "                    v1 = self.__dict__[pair[1]]\n",
    "                    if v0 is not None and v1 is not None:\n",
    "                        for key, fun in keyfun.items():\n",
    "                            if self.__dict__[key] is None:\n",
    "                                self.__dict__[key] = fun(v0,v1, self.refrigerant)\n",
    "                        self.stateok = True\n",
    "            except:\n",
    "                self.stateok = False\n",
    "       \n",
    "```\n",
    "\n",
    "##### (2)  Component's thermodynamic process\n",
    "\n",
    "* def state(self):\n",
    "\n",
    "* def balance(self):\n",
    "\n",
    "For example: `Class Compressor(Device_SISO)`\n",
    "\n",
    "```python\n",
    "class Compressor(Device_SISO):\n",
    "    \"\"\" compression of the refrigerant\"\"\"\n",
    "    def state(self):\n",
    "        \"\"\" if ef=1.0, Isentropic compression \"\"\"\n",
    "        self.isos = self.iPort.s\n",
    "        if self.ef == 1.0:\n",
    "            self.oPort.s = self.iPort.s\n",
    "   \n",
    "    def balance(self):\n",
    "        \"\"\"  mass and energy balance    \"\"\"\n",
    "              \n",
    "```\n",
    "\n",
    "####  2  Steps to obtain the Port's state in VCRCycle\n",
    "\n",
    "1. `Port(dictNode)` - port:  the input parameter pairs \n",
    "\n",
    "2. `comps[key].state()` - device:  thermal process\n",
    "\n",
    "3. `curcon.nodes[i].state()` - port:  get the new parameter pairs from **the device thermal process** \n",
    "\n",
    "4. `comps[key].balance()` -  device:  get the new parameter pairs from **the energy and mass  balance** \n",
    "\n",
    "```python\n",
    " def __component_simulator(self):\n",
    "        # 2 the ports state of device\n",
    "        for key in self.comps:\n",
    "            self.comps[key].state()\n",
    "\n",
    "        # 3 the nodes state of connectors\n",
    "        for item in self.conns.nodes:\n",
    "            if item.stateok == False:\n",
    "                item.state()\n",
    "        # 4 comps[key].balance()\n",
    "        for curdev in self.comps:\n",
    "            self.comps[curdev].balance()\n",
    "``` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.5 The  Sequential-modular Approach\n",
    "\n",
    "**Sequential-modular approach(SM 序贯模块法):**\n",
    "\n",
    "Process **units** are solved in  <b style=\"color:blue\">sequence</b>  \n",
    "\n",
    "In the example\n",
    "\n",
    "```python\n",
    "for key in self.comps:\n",
    "   self.comps[key].state()\n",
    "            \n",
    "for curdev in self.comps:\n",
    "   self.comps[curdev].balance()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.6 utils.py\n",
    "\n",
    "*  OutFiles(cycle, outfilename=None)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../../SimVCCE/vccpython/vcc/utils.py\n",
    "\"\"\"\n",
    "General Object-oriented Abstraction of VC Cycle \n",
    "\n",
    " - OutFiles(cycle, outfilename=None)\n",
    "\n",
    " Author: Cheng Maohua cmh@seu.edu.cn\n",
    "\"\"\"\n",
    "import sys\n",
    "import json\n",
    "from components.port import Port\n",
    "\n",
    "\n",
    "def OutFiles(cycle, outfilename=None):\n",
    "    savedStdout = sys.stdout\n",
    "    # redirect to the outfilename\n",
    "    if outfilename is not None:\n",
    "        datafile = open(outfilename, 'w', encoding='utf-8')\n",
    "        sys.stdout = datafile\n",
    "\n",
    "    # 1 output cycle performance\n",
    "    print(cycle)\n",
    "\n",
    "    # 2 output nodes\n",
    "    print(Port.title)\n",
    "    for item in cycle.conns.nodes:\n",
    "        print(item)\n",
    "    # 3 output devices\n",
    "    for key in cycle.comps:\n",
    "        print(cycle.comps[key])\n",
    "\n",
    "    # return to sys.stdout\n",
    "    if (outfilename != None):\n",
    "        datafile.close()\n",
    "        sys.stdout = savedStdout\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 vccmodel Package  \n",
    "\n",
    "./vccmodel/\n",
    "\n",
    "* `__init__.py` (null contents)\n",
    "\n",
    "* ivcr_11_1.py\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../../SimVCCE/vccpython/vccmodel/ivcr_11_1.py\n",
    "cycle = {\"name\": \"The Ideal VCR Example 11-1\",\n",
    "         \"refrigerant\":\"R134a\"}\n",
    "\n",
    "cycle[\"components\"] = [\n",
    "    {\n",
    "        \"name\": \"Compressor\",\n",
    "        \"devtype\": \"COMPRESSOR\",\n",
    "        \"iPort\": {\"p\": 0.14,  \"x\": 1, \"mdot\": 0.05},\n",
    "        \"oPort\": {},\n",
    "        \"ef\": 1.0\n",
    "    },\n",
    "    {\n",
    "        \"name\": \"Condenser\",\n",
    "        \"devtype\": \"CONDENSER\",\n",
    "        \"iPort\": {},\n",
    "        \"oPort\": {\"p\": 0.8,  \"x\": 0},\n",
    "\n",
    "    },\n",
    "    {\n",
    "        \"name\": \"ExpansionValve\",\n",
    "        \"devtype\": \"EXPANSIONVALVE\",\n",
    "        \"iPort\": {},\n",
    "        \"oPort\": {},\n",
    "    },\n",
    "    {\n",
    "        \"name\": \"Evaporator\",\n",
    "        \"devtype\": \"EVAPORATOR\",\n",
    "        \"iPort\": {},\n",
    "        \"oPort\": {},\n",
    "    }\n",
    "]\n",
    "\n",
    "cycle[\"connectors\"] = {\"Compressor.oPort\":\"Condenser.iPort\",\n",
    "                       \"Condenser.oPort\":\"ExpansionValve.iPort\",\n",
    "                       \"ExpansionValve.oPort\":\"Evaporator.iPort\",\n",
    "                       \"Evaporator.oPort\":\"Compressor.iPort\"}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 Main App\n",
    "\n",
    "* `./vccapp.py`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load ../../SimVCCE/vccpython/vccapp.py\n",
    "\n",
    "\"\"\"\n",
    "General Object-oriented Abstraction  of VC Cycle \n",
    "\n",
    "The Simulator of Ideal VCR 11-1 Page612\n",
    "\n",
    "Yunus A. Cengel, Michael A. Boles, Thermodynamics: An Engineering Approach, 8th Edition,McGraw-Hill, 2015.\n",
    "\n",
    "  * Input : The cycle dict model: ivcr_11_1.py\n",
    "  * Output: text file\n",
    "\n",
    "Author: Cheng Maohua cmh@seu.edu.cn\n",
    "\"\"\"\n",
    "from vcc.vccobj import VCCycle\n",
    "from vcc.utils import OutFiles\n",
    "from vccmodel.ivcr_11_1 import cycle\n",
    "from platform import os\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "\n",
    "    curpath = os.path.abspath(os.path.dirname(__file__))\n",
    "    ResultFilePath = curpath+'/result/'\n",
    "    ResultFileName = ResultFilePath+cycle['name'] + '.txt'\n",
    "\n",
    "    thecycle = VCCycle(cycle)\n",
    "    thecycle.simulator()\n",
    "    # output to console\n",
    "    OutFiles(thecycle)\n",
    "    # output to text file\n",
    "    OutFiles(thecycle, ResultFileName)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python ../../SimVCCE/vccpython/vccapp.py  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reference\n",
    "\n",
    "* [The Class Diagrams of VCCE in PlantUML](https://gitee.com/thermalogic/simvcce/tree/B2023-1/uml/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.7"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "570.667px",
    "left": "25px",
    "top": "66px",
    "width": "211px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}