QLearningAgent_VirtualEnv.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:22.960822Z",
     "start_time": "2023-06-18T12:49:20.252333Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "# calculating wet air properties\n",
    "import psychrolib\n",
    "import datetime\n",
    "import copy\n",
    "# set international units\n",
    "psychrolib.SetUnitSystem(psychrolib.SI)\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "from tqdm import tqdm\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cooling Tower\n",
    "from EnergyPlus EngineeringReference\n",
    "### calculating outlet water temperature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:24.117805Z",
     "start_time": "2023-06-18T12:49:24.112859Z"
    }
   },
   "outputs": [],
   "source": [
    "def cal_Twb(Tdb,reHum):\n",
    "    assert 0.0 <= reHum <= 1.0,'Invalid Relative Humidity'\n",
    "    assert Tdb < 60,'Invalid Dry Bulb Temperature'\n",
    "    Twb = psychrolib.GetTDewPointFromRelHum(Tdb, reHum)\n",
    "    return Twb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:26.945913Z",
     "start_time": "2023-06-18T12:49:24.475828Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22.972692530223053"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check the above function\n",
    "cal_Twb(29,0.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:27.117336Z",
     "start_time": "2023-06-18T12:49:27.102405Z"
    }
   },
   "outputs": [],
   "source": [
    "# the cooling tower models from Page. 1024 Chapter 16. Simulation models - Encyclopedic reference in EngineeringReference\n",
    "# these coefficients you can find from Page. 1025 \n",
    "def CT_ApproachTCoeffDict(type = 'CoolTools'):\n",
    "    if type == 'CoolTools':\n",
    "        coeffDict = {'Coeff1':0.5204971,'Coeff2':-10.6170464,'Coeff3':10.729297,'Coeff4':-2.7498838,'Coeff5':4.7362994,\n",
    "                     'Coeff6':-8.2575970,'Coeff7':1.5764094,'Coeff8':6.5111964,'Coeff9':1.5043352,'Coeff10':-3.2888529,\n",
    "                     'Coeff11':0.0257786,'Coeff12':0.1824643,'Coeff13':-0.0818947,'Coeff14':-0.2150100,'Coeff15':0.0186741,\n",
    "                     'Coeff16':0.0536842,'Coeff17':-0.0027097,'Coeff18':0.0011228,'Coeff19':-0.0012776,'Coeff20':0.0000760,\n",
    "                     'Coeff21':1.4360009,'Coeff22':-0.5198696,'Coeff23':0.1173396,'Coeff24':1.5049281,'Coeff25':-0.1358989,\n",
    "                     'Coeff26':-0.1525776,'Coeff27':-0.0533844,'Coeff28':0.0049329,'Coeff29':-0.0079626,'Coeff30':0.0002226,\n",
    "                     'Coeff31':-0.0543952,'Coeff32':0.0047427,'Coeff33':-0.0185855,'Coeff34':0.0011566,'Coeff35':0.0008074}\n",
    "    elif type == 'YorkCalc':\n",
    "        coeffDict = {'Coeff1':-0.359741205,'Coeff2':-0.055053608,'Coeff3':0.0023850432,'Coeff4':0.173926877,\n",
    "                     'Coeff5':-0.0248473764,'Coeff6':0.00048430224,'Coeff7':-0.005589849456,'Coeff8':0.000577079712,\n",
    "                     'Coeff9':-0.00001342427256,'Coeff10':2.84765801111111,'Coeff11':-0.121765149,'Coeff12':0.0014599242,\n",
    "                     'Coeff13':1.680428651,'Coeff14':-0.0166920786,'Coeff15':-0.0007190532,'Coeff16':-0.025485194448,\n",
    "                     'Coeff17':0.0000487491696,'Coeff18':0.00002719234152,'Coeff19':-0.0653766255555556,\n",
    "                     'Coeff20':-0.002278167,'Coeff21':0.0002500254,'Coeff22':-0.0910565458,'Coeff23':0.00318176316,\n",
    "                     'Coeff24':0.000038621771,'Coeff25':-0.0034285382352,'Coeff26':0.00000856589904,'Coeff27':-0.000001516821552}\n",
    "    return coeffDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:27.290439Z",
     "start_time": "2023-06-18T12:49:27.275432Z"
    }
   },
   "outputs": [],
   "source": [
    "# calculate temperature of cooling water leaving cooling towers - in the way of loop\n",
    "# FRair = the ratio of real-time fan frequency(Hz) to 50\n",
    "def CT_T_outwater(coeffDict,FRair,FRwater,Tr,Twb):\n",
    "    assert 0 <= FRair <= 1,'Invalid FRair'\n",
    "    assert 0 <= FRwater <= 1,'Invalid FRwater'\n",
    "    # assert -1.0 <= Twb <= 26.7,'wet bulb temperature is not in the valid range'\n",
    "    approachT = coeffDict['Coeff1'] + coeffDict['Coeff2'] * FRair + coeffDict['Coeff3'] * (FRair ** 2) + \\\n",
    "                coeffDict['Coeff4'] * (FRair ** 3) + coeffDict['Coeff5'] * FRwater + \\\n",
    "                coeffDict['Coeff6'] * FRair * FRwater + coeffDict['Coeff7'] * (FRair ** 2) * FRwater + \\\n",
    "                coeffDict['Coeff8'] * (FRwater ** 2) + coeffDict['Coeff9'] * FRair * (FRwater ** 2) + \\\n",
    "                coeffDict['Coeff10'] * (FRwater ** 3) + coeffDict['Coeff11'] * Twb + coeffDict['Coeff12'] * FRair * Twb + \\\n",
    "                coeffDict['Coeff13'] * (FRair ** 2) * Twb + coeffDict['Coeff14'] * FRwater * Twb + \\\n",
    "                coeffDict['Coeff15'] * FRair * FRwater * Twb + coeffDict['Coeff16'] * (FRwater ** 2) * Twb + \\\n",
    "                coeffDict['Coeff17'] * (Twb ** 2) + coeffDict['Coeff18'] * FRair * (Twb ** 2)+ \\\n",
    "                coeffDict['Coeff19'] * FRwater * (Twb ** 2) + coeffDict['Coeff20'] * (Twb ** 3) + coeffDict['Coeff21'] * Tr + \\\n",
    "                coeffDict['Coeff22'] * FRair * Tr + coeffDict['Coeff23'] * (FRair ** 2) * Tr + \\\n",
    "                coeffDict['Coeff24'] * FRwater * Tr + coeffDict['Coeff25'] * FRair * FRwater * Tr + \\\n",
    "                coeffDict['Coeff26'] * (FRwater ** 2) * Tr + coeffDict['Coeff27'] * Twb * Tr + \\\n",
    "                coeffDict['Coeff28'] * FRair * Twb * Tr + coeffDict['Coeff29'] * FRwater * Twb * Tr + \\\n",
    "                coeffDict['Coeff30'] * (Twb ** 2) * Tr + coeffDict['Coeff31'] * (Tr ** 2) + coeffDict['Coeff32'] * FRair * (Tr ** 2) + \\\n",
    "                coeffDict['Coeff33'] * FRwater * (Tr ** 2) + coeffDict['Coeff34'] * Twb * (Tr ** 2) + coeffDict['Coeff35'] * (Tr ** 2)\n",
    "    # assert 1.1 <= approachT <= 11.1,\"approachT not in the valid range\"\n",
    "    T_outwater = abs(approachT) + Twb\n",
    "    return T_outwater"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:27.459270Z",
     "start_time": "2023-06-18T12:49:27.446313Z"
    }
   },
   "outputs": [],
   "source": [
    "# In order to simplify the process, I use loop to find the most appropriate candidate temperature\n",
    "# Alert: this not ensures convergence\n",
    "def cal_T_outwater(FRair,FRwater,T_inwater,Tdb,reHum):\n",
    "    coeffDict = CT_ApproachTCoeffDict(type = 'CoolTools')\n",
    "    Twb = cal_Twb(Tdb,reHum)\n",
    "    res_lis = []\n",
    "    \n",
    "    for T_test in np.arange(0,T_inwater +0.1,0.1):\n",
    "        # T_outwater should be less than T_inwater\n",
    "        T_outwater = CT_T_outwater(coeffDict,FRair,FRwater,T_inwater - T_test,Twb)\n",
    "        res_lis.append(abs(T_test - T_outwater))\n",
    "    \n",
    "    min_num = res_lis[0]\n",
    "    min_index = 0\n",
    "    for i in range(len(res_lis)):\n",
    "        if res_lis[i] < min_num:\n",
    "            min_num = res_lis[i]\n",
    "            min_index = i\n",
    "            \n",
    "    # assert 1.1 <= abs(T_inwater - T_outwater) <= 11.1,'delta of cooling supply and return water temperature needs fall in the valid range'\n",
    "    #print(min_num,'minimum residuals')\n",
    "            \n",
    "    T_outwater = 0.1 * min_index\n",
    "    return float(format(T_outwater,'.1f'))\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:27.632641Z",
     "start_time": "2023-06-18T12:49:27.619427Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22.2"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test \n",
    "cal_T_outwater(FRair = 0.9,FRwater = 0.8,T_inwater = 30,Tdb = 24,reHum = 0.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### calcluating fan power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:27.805536Z",
     "start_time": "2023-06-18T12:49:27.793512Z"
    }
   },
   "outputs": [],
   "source": [
    "# coz the cubic relationship between power and frequency\n",
    "# the coefficients is based on a real model, you can change the coefficents based on your reality\n",
    "def CT_Power_coeff():\n",
    "    coeff = {'coeff1': -9.436,'coeff2':0.7328, 'coeff3':-0.01375, 'coeff4':0.0002145}\n",
    "    return coeff\n",
    "\n",
    "def cal_CT_FanPower(f):\n",
    "    coeff = CT_Power_coeff()\n",
    "    # we set the reasonable frequency range is 30-50Hz based on reality and safety issue\n",
    "    assert 30 <= f <= 50,\"invalid frequency\"\n",
    "    # unit ： KWH\n",
    "    FanPower = coeff['coeff1'] + coeff['coeff2'] * f + coeff['coeff3'] * (f ** 2) + coeff['coeff4'] * (f ** 3)\n",
    "    return FanPower\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:28.499977Z",
     "start_time": "2023-06-18T12:49:28.481045Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19.6415"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test\n",
    "cal_CT_FanPower(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cooling Water Pump"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:29.122117Z",
     "start_time": "2023-06-18T12:49:29.112950Z"
    }
   },
   "outputs": [],
   "source": [
    "# In our system, we have two kinds of water power, with big and small capacities\n",
    "# In our case, go for simplicity, the water pump frequency is fixed (50Hz), so the water pump fan is fixed ideally\n",
    "def CWP_Big_Power(f=50):\n",
    "    power = 19 # unit KW\n",
    "    return power\n",
    "\n",
    "def CWP_Small_Power(f=50):\n",
    "    power = 8 # unit KW\n",
    "    return power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:29.769635Z",
     "start_time": "2023-06-18T12:49:29.766079Z"
    }
   },
   "outputs": [],
   "source": [
    "# CWP_Big_Q   <==> CWP_Big_Power\n",
    "# CWP_Small_Q <==> CWP_Small_Power\n",
    "# When presuming the pipe resistance is unchanged, other things are perfectly, the real-time water flow is proportion to frequency\n",
    "# Big Water pump has two, and small water pump has one\n",
    "# the maximum wateflow is 3000 m³/h\n",
    "def CWP_Big_Q(f=50):\n",
    "    Q = 1100 # unit m³/h\n",
    "    return Q\n",
    "\n",
    "def CWP_Small_Q(f=50):\n",
    "    Q = 800 # unit m³/h\n",
    "    return Q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chilled Water Pump"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:30.341891Z",
     "start_time": "2023-06-18T12:49:30.327392Z"
    }
   },
   "outputs": [],
   "source": [
    "# the part of chilled water pumps is the same as that of cooling water pumps\n",
    "def CHWP_Big_Power(f=50):\n",
    "    power = 23 # unit KW\n",
    "    return power\n",
    "\n",
    "def CHWP_Small_Power(f=50):\n",
    "    power = 10.5 # unit KW\n",
    "    return power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:30.827016Z",
     "start_time": "2023-06-18T12:49:30.818858Z"
    }
   },
   "outputs": [],
   "source": [
    "# wanna explain the relationship between cooling water pumps and chilled water pumps\n",
    "# one big cooling water pump matches one big chilled water pump\n",
    "# one small cooling water pump matches one small chilled water pump\n",
    "# based on that, there are two big chilled water pumps and single small chilled water pump\n",
    "# When one big chilled water pump is on, there must have a big cooling water pump under operation \n",
    "def CHWP_Big_Q(f=50):\n",
    "    Q = 450 # unit m³/h\n",
    "    return Q\n",
    "\n",
    "def CHWP_Small_Q(f=50):\n",
    "    Q = 300 # unit m³/h\n",
    "    return Q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chiller  (one kind has smaller capacity, one has larger capacity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Chiller with smaller capacity\n",
    "**small chiller matches smaller cooling/chilled water pump**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:33.585337Z",
     "start_time": "2023-06-18T12:49:33.567200Z"
    }
   },
   "outputs": [],
   "source": [
    "# the Empirical Formula to obtain COP of the chiller with smaller capacity\n",
    "# the formula is based on 14.3.9 and 14.3.10 EIR model, which is widely used in various papers\n",
    "# EnergyPlus supply official .idf files where you can find different kinds of chillers in case of the lack of chiller model to hand\n",
    "def coeffDict_CapFTemp_small():\n",
    "    coeff_CapFTemp = {'coeff1':0.4742518,'coeff2':-0.05109937,'coeff3':-0.002845323,\n",
    "                      'coeff4':0.0857997,'coeff5':-0.003404799,'coeff6':0.005625321}\n",
    "    return coeff_CapFTemp\n",
    "\n",
    "def coeffDict_EIRFTemp_small():\n",
    "    coeff_EIRFTemp = {'coeff1':0.2950574,'coeff2':-0.1036684,'coeff3':-0.004169567,\n",
    "                      'coeff4':0.1256790,'coeff5':-0.004004203,'coeff6':0.006718687}\n",
    "    return coeff_EIRFTemp\n",
    "\n",
    "def coeffDict_EIRFPLR_small():\n",
    "    coeff_EIRFPLR = {'coeff1':0.2374010,'coeff2':-0.1796745,'coeff3':0.9441507}\n",
    "    return coeff_EIRFPLR\n",
    "\n",
    "# Q_part: partial load\n",
    "# Q_ref: nominal capacity marked on nameplate\n",
    "# COP_ref: nominal COP marked on nameplate\n",
    "# T_cwl: the temperature of chilled supply water\n",
    "# T_conde: the temperature of cooling supply water (generated by cooling tower)\n",
    "def cal_chiller_COP_small(T_cwl,T_conde,Q_part,Q_ref,COP_ref):\n",
    "    # York YT 1368kW/7.35COP/VSD (this is the make and model of the smaller chiller, you can change whatever you want)\n",
    "    PLR = Q_part / Q_ref\n",
    "    coeff_CapFTemp = coeffDict_CapFTemp_small()\n",
    "    coeff_EIRFTemp = coeffDict_EIRFTemp_small()\n",
    "    coeff_EIRFPLR = coeffDict_EIRFPLR_small()\n",
    "    \n",
    "    ChillerCapFTemp = coeff_CapFTemp['coeff1'] + coeff_CapFTemp['coeff2'] * T_cwl + coeff_CapFTemp['coeff3'] * (T_cwl ** 2) + \\\n",
    "                      coeff_CapFTemp['coeff4'] * T_conde + coeff_CapFTemp['coeff5'] * (T_conde ** 2) + \\\n",
    "                      coeff_CapFTemp['coeff6'] * T_cwl * T_conde\n",
    "    #Q_ref_spec = ChillerCapFTemp * Q_ref\n",
    "    \n",
    "    ChillerEIRTemp = coeff_EIRFTemp['coeff1'] + coeff_EIRFTemp['coeff2'] * T_cwl + coeff_EIRFTemp['coeff3'] * (T_cwl ** 2) + \\\n",
    "                     coeff_EIRFTemp['coeff4'] * T_conde + coeff_EIRFTemp['coeff5'] * (T_conde ** 2) + \\\n",
    "                     coeff_EIRFTemp['coeff6'] * T_cwl * T_conde\n",
    "    \n",
    "    #COP_ref_spec = (ChillerEIRTemp * (COP_ref ** -1)) ** -1\n",
    "    \n",
    "    ChillerEIRFPLR = coeff_EIRFPLR['coeff1'] + coeff_EIRFPLR['coeff2'] * PLR + coeff_EIRFPLR['coeff3'] * (PLR ** 2)\n",
    "    P = (ChillerCapFTemp * ChillerEIRFPLR * ChillerEIRFPLR * Q_ref) / COP_ref\n",
    "    \n",
    "    COP = Q_part / P\n",
    "    \n",
    "    Result = {'COP':abs(COP),'P':abs(P)}\n",
    "    \n",
    "    return Result\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:33.805642Z",
     "start_time": "2023-06-18T12:49:33.786700Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'COP': 6.630672085602478, 'P': 205.55985613578338}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cal_chiller_COP_small(T_cwl=7,T_conde=21,Q_part=1363,Q_ref=1363,COP_ref=7.35)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Chiller with larger capacity\n",
    "**larger chiller matches larger chilled/cooling water pump**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:34.859469Z",
     "start_time": "2023-06-18T12:49:34.850503Z"
    }
   },
   "outputs": [],
   "source": [
    "# same with the chiller with smaller capacity\n",
    "def coeffDict_CapFTemp_big():\n",
    "    coeff_CapFTemp = {'coeff1':0.2210324,'coeff2':-0.02752320,'coeff3':0.0004903763,\n",
    "                      'coeff4':0.07337449,'coeff5':-0.001919426,'coeff6':0.001935659}\n",
    "    return coeff_CapFTemp\n",
    "\n",
    "def coeffDict_EIRFTemp_big():\n",
    "    coeff_EIRFTemp = {'coeff1':0.2267558,'coeff2':-0.07615857,'coeff3':0.002140583,\n",
    "                      'coeff4':0.07088812,'coeff5':-0.001124968,'coeff6':0.0006089843}\n",
    "    return coeff_EIRFTemp\n",
    "\n",
    "def coeffDict_EIRFPLR_big():\n",
    "    coeff_EIRFPLR = {'coeff1':0.3023576,'coeff2':-0.02893592,'coeff3':0.7262269}\n",
    "    return coeff_EIRFPLR\n",
    "\n",
    "# Q_part: partial load\n",
    "# Q_ref: nominal capacity marked on nameplate\n",
    "# COP_ref: nominal COP marked on nameplate\n",
    "# T_cwl: the temperature of chilled supply water\n",
    "# T_conde: the temperature of cooling supply water (generated by cooling tower)\n",
    "def cal_chiller_COP_big(T_cwl,T_conde,Q_part,Q_ref,COP_ref):\n",
    "    # York YK 4396kW/6.63COP/\n",
    "    PLR = Q_part / Q_ref\n",
    "    coeff_CapFTemp = coeffDict_CapFTemp_big()\n",
    "    coeff_EIRFTemp = coeffDict_EIRFTemp_big()\n",
    "    coeff_EIRFPLR = coeffDict_EIRFPLR_big()\n",
    "    \n",
    "    ChillerCapFTemp = coeff_CapFTemp['coeff1'] + coeff_CapFTemp['coeff2'] * T_cwl + coeff_CapFTemp['coeff3'] * (T_cwl ** 2) + \\\n",
    "                      coeff_CapFTemp['coeff4'] * T_conde + coeff_CapFTemp['coeff5'] * (T_conde ** 2) + \\\n",
    "                      coeff_CapFTemp['coeff6'] * T_cwl * T_conde\n",
    "    Q_ref_spec = ChillerCapFTemp * Q_ref\n",
    "    #plr = CL / (nominal_cap * cap_factor)\n",
    "    #PLR = Q_part / (COP_ref * ChillerCapFTemp)\n",
    "    \n",
    "    ChillerEIRTemp = coeff_EIRFTemp['coeff1'] + coeff_EIRFTemp['coeff2'] * T_cwl + coeff_EIRFTemp['coeff3'] * (T_cwl ** 2) + \\\n",
    "                     coeff_EIRFTemp['coeff4'] * T_conde + coeff_EIRFTemp['coeff5'] * (T_conde ** 2) + \\\n",
    "                     coeff_EIRFTemp['coeff6'] * T_cwl * T_conde\n",
    "    \n",
    "    COP_ref_spec = (ChillerEIRTemp * (COP_ref ** -1)) ** -1\n",
    "    #p = nominal_power * cap_factor * eir_t_factor * eir_plr_factor\n",
    "    \n",
    "    ChillerEIRFPLR = coeff_EIRFPLR['coeff1'] + coeff_EIRFPLR['coeff2'] * PLR + coeff_EIRFPLR['coeff3'] * (PLR ** 2)\n",
    "    P = (ChillerCapFTemp * ChillerEIRFPLR * ChillerEIRFPLR * Q_ref) / COP_ref\n",
    "    #P = (Q_ref/COP_ref) * ChillerCapFTemp * ChillerEIRTemp * ChillerEIRFPLR\n",
    "    \n",
    "    COP = Q_part / P\n",
    "    \n",
    "    Result = {'COP':abs(COP),'P':abs(P)}\n",
    "    \n",
    "    #return Result\n",
    "    return Result\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:35.262258Z",
     "start_time": "2023-06-18T12:49:35.250244Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'COP': 8.503912042045894, 'P': 61.148327667191744}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test\n",
    "cal_chiller_COP_big(T_cwl = 7,T_conde = 20.9,Q_part = 520,Q_ref = 3868,COP_ref = 6.33)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cooling load reloading...\n",
    "**the unit of cooling load is KW**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:36.473398Z",
     "start_time": "2023-06-18T12:49:36.447172Z"
    }
   },
   "outputs": [],
   "source": [
    "df_load = pd.read_csv(r'CoolingLoad.csv')\n",
    "cal_load = copy.deepcopy(df_load['cooling load'].values[::4])\n",
    "cal_load[cal_load<100] = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## weather reloading..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:38.082978Z",
     "start_time": "2023-06-18T12:49:37.236443Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_weather = pd.read_csv(r'Weather.csv')\n",
    "time = df_weather['DateTime'].values[::4]\n",
    "tout = df_weather['tout'].values[::4]\n",
    "\n",
    "plt.figure(figsize=(20,6))\n",
    "plt.plot(time,tout)\n",
    "plt.xticks([])\n",
    "plt.title('dry bulb temperature - time')\n",
    "plt.show()\n",
    "\n",
    "hout = df_weather['hout'].values[::4]\n",
    "plt.figure(figsize=(20,6))\n",
    "plt.plot(time,hout)\n",
    "plt.xticks([])\n",
    "plt.title('humidity - time')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## subfunction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### All nominal parameters we need"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:41.929197Z",
     "start_time": "2023-06-18T12:49:41.915268Z"
    }
   },
   "outputs": [],
   "source": [
    "def equipment_parameters(): \n",
    "    \n",
    "    chiller_big_parameters = {'Reference Capacity KW':2799,\n",
    "                              'Reference COP':6.40,\n",
    "                              'Reference Leaving Chilled Water Temperature':6.67,\n",
    "                              'Reference Entering Condenser Fluid Temperature':26.11,\n",
    "                              'Reference Chilled Water Flow Rate m3/s':0.09893,\n",
    "                              'Reference Condenser Fluid Flow Rate':0.13761}\n",
    "\n",
    "    chiller_small_parameters = {'Reference Capacity KW':1723,\n",
    "                                'Reference COP':8.32,\n",
    "                                'Reference Leaving Chilled Water Temperature':6.11,\n",
    "                                'Reference Entering Condenser Fluid Temperature':12.78,\n",
    "                                'Reference Chilled Water Flow Rate m3/s':0.04757,\n",
    "                                'Reference Condenser Fluid Flow Rate':0.06934}\n",
    "\n",
    "    cooling_tower_parameters = {'Reference Water Flow m3/h':150,\n",
    "                               'Reference Fan Frequency Hz':50,\n",
    "                               'Number of Cooling Towers':20}\n",
    "    \n",
    "    equipment_parameters = {'chiller_big':chiller_big_parameters,\n",
    "                           'chiller_small':chiller_small_parameters,\n",
    "                           'cooling_tower':cooling_tower_parameters}\n",
    "    \n",
    "    return equipment_parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:42.317018Z",
     "start_time": "2023-06-18T12:49:42.298082Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Reference Water Flow m3/h': 150,\n",
       " 'Reference Fan Frequency Hz': 50,\n",
       " 'Number of Cooling Towers': 20}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test\n",
    "equipment_parameters()['cooling_tower']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### determine chiller, chilled/cooling water pump operation, and then determine power of water pumps and water flow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:43.605439Z",
     "start_time": "2023-06-18T12:49:43.598517Z"
    }
   },
   "outputs": [],
   "source": [
    "# determine chiller operation\n",
    "def cal_chillers_condition(load):\n",
    "    \n",
    "    # default is all chillers are down\n",
    "    # unit:KW\n",
    "    if load <= 100:\n",
    "        chillers_condition = {'chiller_big_num':0,'chiller_small_num':0}    \n",
    "    elif 0 < load <= 1720:\n",
    "        chillers_condition = {'chiller_big_num':0,'chiller_small_num':1}        \n",
    "    elif 1720 < load <= 2780:\n",
    "        chillers_condition = {'chiller_big_num':1,'chiller_small_num':0}  \n",
    "    elif 2780 < load <= 4500:\n",
    "        chillers_condition = {'chiller_big_num':1,'chiller_small_num':1}    \n",
    "    elif 4500 < load <= 5560:\n",
    "        chillers_condition = {'chiller_big_num':2,'chiller_small_num':0}\n",
    "    elif 5560 < load <= 7280:\n",
    "        chillers_condition = {'chiller_big_num':2,'chiller_small_num':1}    \n",
    "    elif 7280 < load <= 8340:\n",
    "        chillers_condition = {'chiller_big_num':3,'chiller_small_num':0}   \n",
    "    else:\n",
    "        chillers_condition = {'chiller_big_num':3,'chiller_small_num':1}\n",
    "    \n",
    "    #print('larger chiller',chillers_condition['chiller_big_num'],'under operation，smaller chiller',chillers_condition['chiller_small_num'],'uder operation')\n",
    "    \n",
    "    return chillers_condition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:44.228128Z",
     "start_time": "2023-06-18T12:49:44.207190Z"
    }
   },
   "outputs": [],
   "source": [
    "# determine water pump operation\n",
    "def cal_pumps_condition(chillers_condition):\n",
    "    pumps_condition = {'chilled_cooling_pump_big':0,'chilled_cooling_pump_small':0}\n",
    "    \n",
    "    if chillers_condition == {'chiller_big_num':0,'chiller_small_num':1}:\n",
    "        pumps_condition = {'chilled_cooling_pump_big':0,'chilled_cooling_pump_small':1}\n",
    "        \n",
    "    elif chillers_condition == {'chiller_big_num':1,'chiller_small_num':0}:\n",
    "        pumps_condition = {'chilled_cooling_pump_big':1,'chilled_cooling_pump_small':0}\n",
    "        \n",
    "    elif chillers_condition == {'chiller_big_num':1,'chiller_small_num':1}:\n",
    "        pumps_condition = {'chilled_cooling_pump_big':1,'chilled_cooling_pump_small':1}\n",
    "        \n",
    "    elif chillers_condition == {'chiller_big_num':2,'chiller_small_num':0}:\n",
    "        pumps_condition = {'chilled_cooling_pump_big':2,'chilled_cooling_pump_small':0}\n",
    "        \n",
    "    elif chillers_condition == {'chiller_big_num':2,'chiller_small_num':1}:\n",
    "        pumps_condition = {'chilled_cooling_pump_big':2,'chilled_cooling_pump_small':1}\n",
    "        \n",
    "    elif chillers_condition == {'chiller_big_num':3,'chiller_small_num':0}:\n",
    "        pumps_condition = {'chilled_cooling_pump_big':3,'chilled_cooling_pump_small':0}\n",
    "        \n",
    "    elif chillers_condition == {'chiller_big_num':3,'chiller_small_num':1}:\n",
    "        pumps_condition = {'chilled_cooling_pump_big':3,'chilled_cooling_pump_small':1}\n",
    "        \n",
    "    return pumps_condition\n",
    "\n",
    "# calculate power (electricity consumption) of water pumps\n",
    "def cal_pumps_power(pumps_condition):\n",
    "    # for cooling water pumps\n",
    "    CWP_small = CWP_Small_Power() * pumps_condition['chilled_cooling_pump_small']\n",
    "    CWP_big = CWP_Big_Power() * pumps_condition['chilled_cooling_pump_big']\n",
    "    # for chilled water pumps\n",
    "    CHWP_small = CHWP_Small_Power() * pumps_condition['chilled_cooling_pump_small']\n",
    "    CHWP_big = CHWP_Big_Power() * pumps_condition['chilled_cooling_pump_big']\n",
    "    Pumps_all = CWP_small + CWP_big + CHWP_small + CHWP_big\n",
    "    return Pumps_all\n",
    "\n",
    "# calculate the total water flow in cooling water loop and chilled water loop\n",
    "def cal_Qchwcw(pumps_condition):\n",
    "    # chilled/cooling water flow unit m³/h\n",
    "    Q_condition = {'Q_chilled':CHWP_Small_Q() * pumps_condition['chilled_cooling_pump_small'] + \\\n",
    "                               CHWP_Big_Q() * pumps_condition['chilled_cooling_pump_big'],\n",
    "                   'Q_cooling':CWP_Small_Q() * pumps_condition['chilled_cooling_pump_small'] + \\\n",
    "                               CWP_Big_Q() * pumps_condition['chilled_cooling_pump_big']}\n",
    "    return Q_condition\n",
    "\n",
    "# calculate the chilled supply water temperature\n",
    "# theoretically, the chillers have capacity of meeting the setpoint temperature of chilled supply water\n",
    "def cal_Tchs(load,chillers_condition,pumps_condition,T_chsset,Tchr=12):\n",
    "    # when chillers are on\n",
    "    if 0 <= load <= 12967:\n",
    "        Tchs = 7\n",
    "    elif load < 0:\n",
    "        print('invalid load, value much be greater than zero')\n",
    "        Tchs = 7 \n",
    "    else:\n",
    "        Q_chilled = cal_Qchwcw(pumps_condition)['Q_chilled']        \n",
    "        Tchs = -(12967 * 3600)/(4.2 * 1000 * Q_chilled) + Tr\n",
    "        if Tchs < Tchsset: # if Tchs is less than 7, which means operating chillers are able to generate 7 Celsius water\n",
    "            Tchs = Tchsset\n",
    "    return Tchs\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:44.836216Z",
     "start_time": "2023-06-18T12:49:44.817300Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'chiller_big_num': 1, 'chiller_small_num': 1}\n",
      "{'chilled_cooling_pump_big': 1, 'chilled_cooling_pump_small': 1}\n",
      "60.5\n",
      "{'Q_chilled': 750, 'Q_cooling': 1900}\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "chillers_condition = cal_chillers_condition(4000)\n",
    "print(chillers_condition)\n",
    "pumps_condition = cal_pumps_condition(chillers_condition)\n",
    "print(pumps_condition)\n",
    "power_pumps = cal_pumps_power(pumps_condition)\n",
    "print(power_pumps)\n",
    "Q_condition = cal_Qchwcw(pumps_condition)\n",
    "print(Q_condition)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q-Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:46.269502Z",
     "start_time": "2023-06-18T12:49:46.257213Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def Q_table_ini():\n",
    "    # presume the maximun load is 7000 KW or so\n",
    "    # allocate part of load to chiller will smaller capacity\n",
    "    Q_table = pd.DataFrame(columns=[np.arange(0,1.05,0.05)],index=[np.arange(0,1.05,0.05)])\n",
    "    Q_table.fillna(0,inplace = True)\n",
    "    return Q_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:46.689195Z",
     "start_time": "2023-06-18T12:49:46.635376Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 100/100 [00:00<00:00, 3583.53it/s]\n"
     ]
    }
   ],
   "source": [
    "# test above function: randomized experiments\n",
    "# Q_table: the column is ratio of part load of smaller chiller, the row is ratio of part load of larger chiller\n",
    "Q_table = Q_table_ini()\n",
    "for i in tqdm(range(100)):\n",
    "    Q_table.loc[tuple((random.choice(np.arange(0,1.05,0.05)),)),\n",
    "                tuple((random.choice(np.arange(0,1.05,0.05)),))] = random.choice(np.arange(0,100,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:47.028822Z",
     "start_time": "2023-06-18T12:49:47.015809Z"
    }
   },
   "outputs": [],
   "source": [
    "def Q_para_ini():\n",
    "    # parameters for reward update\n",
    "    para_dict = {'alpha':0.9,\n",
    "                 'gamma':0.01,\n",
    "                 'epsilon':0.1}\n",
    "    return para_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:47.369527Z",
     "start_time": "2023-06-18T12:49:47.356542Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'alpha': 0.9, 'gamma': 0.01, 'epsilon': 0.1}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q_para_ini()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### update value in Q table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:48.020923Z",
     "start_time": "2023-06-18T12:49:48.012674Z"
    }
   },
   "outputs": [],
   "source": [
    "def update_Q_table(value_old,reward,value_max,a,y):\n",
    "    value_new = value_old + a * (reward + y * value_max - value_old)\n",
    "    return value_new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:48.400269Z",
     "start_time": "2023-06-18T12:49:48.392297Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.6"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test\n",
    "update_Q_table(2,6,0,0.9,0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### classification for load allocation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:49.034864Z",
     "start_time": "2023-06-18T12:49:49.026821Z"
    }
   },
   "outputs": [],
   "source": [
    "def class_chillers_condition(load):\n",
    "    chillers_condition = cal_chillers_condition(load)\n",
    "    if (chillers_condition['chiller_big_num'] == 0 or\n",
    "        chillers_condition['chiller_small_num'] == 0):\n",
    "        class_type = 'one' # either smaller chiller or larger chiller under operation\n",
    "        \n",
    "    else:\n",
    "        class_type = 'two' # two kinds of chillers will be operating\n",
    "        \n",
    "    return class_type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:49.411100Z",
     "start_time": "2023-06-18T12:49:49.398059Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'two'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test\n",
    "class_chillers_condition(4000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### discretization ratio of part load"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:50.001708Z",
     "start_time": "2023-06-18T12:49:49.993668Z"
    }
   },
   "outputs": [],
   "source": [
    "def cal_discrete_load(load):\n",
    "    load_max_set = 7000 # unit KW\n",
    "    assert load <= load_max_set,'invalid real-time load, greater than upper limit'\n",
    "    plr = load / load_max_set\n",
    "    # print('current part load rate:',plr)\n",
    "    for value in np.arange(0,1.05,0.05):\n",
    "        if value >= plr:\n",
    "            discrete_load = value\n",
    "            break\n",
    "    return discrete_load"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:50.392769Z",
     "start_time": "2023-06-18T12:49:50.378816Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test\n",
    "cal_discrete_load(400)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### when no need to allocate load, the following function is used to allocate load between two chiller of same make and model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:51.016934Z",
     "start_time": "2023-06-18T12:49:51.005007Z"
    }
   },
   "outputs": [],
   "source": [
    "# load allocation\n",
    "def cal_chillers_load_sharing(load,chillers_condition):\n",
    "    chiller_big_parameters = equipment_parameters()['chiller_big']\n",
    "    chiller_small_parameters = equipment_parameters()['chiller_small']\n",
    "    \n",
    "    if chillers_condition['chiller_big_num'] != 0 or chillers_condition['chiller_small_num'] != 0:\n",
    "        PL_big = ((load * chiller_big_parameters['Reference Capacity KW']) / \n",
    "                  (chillers_condition['chiller_big_num'] * chiller_big_parameters['Reference Capacity KW'] +\n",
    "                   chillers_condition['chiller_small_num'] * chiller_small_parameters['Reference Capacity KW']))\n",
    "        #print('PL-larger chiller',PL_big)\n",
    "\n",
    "        PL_small = ((load * chiller_small_parameters['Reference Capacity KW']) / \n",
    "                    (chillers_condition['chiller_big_num'] * chiller_big_parameters['Reference Capacity KW'] +\n",
    "                     chillers_condition['chiller_small_num'] * chiller_small_parameters['Reference Capacity KW']))\n",
    "        #print('PL-smaller chiller',PL_small)\n",
    "    else:\n",
    "        PL_big = 0\n",
    "        PL_small = 0\n",
    "    \n",
    "    Result = {'PL_big':PL_big,'PL_small':PL_small} # unit: KW\n",
    "    return Result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:51.393439Z",
     "start_time": "2023-06-18T12:49:51.381433Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'PL_big': 649.7968659315148, 'PL_small': 400.0}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chillers_condition = cal_chillers_condition(400)\n",
    "cal_chillers_load_sharing(400,chillers_condition)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### This part is used in decoupling the system\n",
    "**presume the fixed temperature of chilled water entering chillers, calculate the temperature of chilled water leaving chiller**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:52.029013Z",
     "start_time": "2023-06-18T12:49:52.017085Z"
    }
   },
   "outputs": [],
   "source": [
    "def cal_Tchs(load,chillers_load_sharing,tchr = 12):\n",
    "    chillers_condition = cal_chillers_condition(load)\n",
    "    # chillers_load_sharing = cal_chillers_load_sharing(load,chillers_condition)\n",
    "    pumps_condition = cal_pumps_condition(chillers_condition)\n",
    "    Q_condition = cal_Qchwcw(pumps_condition)\n",
    "    # calculate the temperature of chilled return water for two kinds of chillers\n",
    "    tchss = tchr - (chillers_load_sharing['PL_small']*3600)/(CHWP_Small_Q()*1000*4.2)\n",
    "    tchsb = tchr - (chillers_load_sharing['PL_big']*3600)/(CHWP_Big_Q()*1000*4.2)\n",
    "    tchs = (pumps_condition['chilled_cooling_pump_big']*CHWP_Big_Q()*tchsb + \n",
    "            pumps_condition['chilled_cooling_pump_small']*CHWP_Small_Q()*tchss) / (pumps_condition['chilled_cooling_pump_big']*CHWP_Big_Q() +\n",
    "                                                                                   pumps_condition['chilled_cooling_pump_small']*CHWP_Small_Q())\n",
    "    Result = {'tchss':tchss,'tchsb':tchsb,'tchs':tchs}\n",
    "    return Result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:52.403161Z",
     "start_time": "2023-06-18T12:49:52.389291Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'tchss': 7.645416061161307,\n",
       " 'tchsb': 7.284008340178177,\n",
       " 'tchs': 7.42857142857143}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test\n",
    "chillers_condition = cal_chillers_condition(4000)\n",
    "chillers_load_sharing = cal_chillers_load_sharing(4000,chillers_condition)\n",
    "cal_Tchs(4000,chillers_load_sharing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### calculate the total chiller COP  under some circumstance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:53.131067Z",
     "start_time": "2023-06-18T12:49:53.117876Z"
    }
   },
   "outputs": [],
   "source": [
    "# calculate the power (electricity consumption) of chillers\n",
    "# presume the fixed temperature of the cooling water entering chillers\n",
    "# but the temperature of the chilled water leaving chillers is unknown\n",
    "# chillers_condition: the number of chillers under operation\n",
    "# chillers_load_sharing: load allocation\n",
    "# T_cwl: the temperaute of chilled water leaving chillers\n",
    "# T_conde: the temperature of cooling water entering chillers\n",
    "def cal_chillers_powers(chillers_condition,chillers_load_sharing,T_cwl,T_conde):\n",
    "    # load the parameters of chillers\n",
    "    chiller_big_parameters = equipment_parameters()['chiller_big']\n",
    "    chiller_small_parameters = equipment_parameters()['chiller_small']\n",
    "    \n",
    "    power_chillers_big = (chillers_condition['chiller_big_num'] * \n",
    "                          cal_chiller_COP_big(T_cwl['tchsb'],T_conde,chillers_load_sharing['PL_big'],\n",
    "                                              chiller_big_parameters['Reference Capacity KW'],\n",
    "                                              chiller_big_parameters['Reference COP'])['P'])\n",
    "                     \n",
    "    power_chillers_small = (chillers_condition['chiller_small_num'] * \n",
    "                            cal_chiller_COP_small(T_cwl['tchss'],T_conde,chillers_load_sharing['PL_small'],\n",
    "                                                  chiller_small_parameters['Reference Capacity KW'],\n",
    "                                                  chiller_small_parameters['Reference COP'])['P'])\n",
    "    \n",
    "    # total COP\n",
    "    COP_all = (chillers_load_sharing['PL_small'] * chillers_condition['chiller_small_num'] + \n",
    "               chillers_load_sharing['PL_big'] * chillers_condition['chiller_big_num']) / (power_chillers_big + \n",
    "                                                                                           power_chillers_small)\n",
    "        \n",
    "    Result = {'power_chillers_big':power_chillers_big,\n",
    "              'power_chillers_small':power_chillers_small,\n",
    "              'power_chillers_all':power_chillers_big + power_chillers_small,\n",
    "              'COP_all':COP_all}\n",
    "    \n",
    "    return Result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:53.503684Z",
     "start_time": "2023-06-18T12:49:53.490745Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'tchss': 7.645416061161307, 'tchsb': 7.284008340178177, 'tchs': 7.42857142857143}\n"
     ]
    }
   ],
   "source": [
    "chillers_condition = cal_chillers_condition(4000)\n",
    "chillers_load_sharing = cal_chillers_load_sharing(4000,chillers_condition)\n",
    "T_cwl = cal_Tchs(4000,chillers_load_sharing)\n",
    "cal_chillers_powers(chillers_condition,chillers_load_sharing,T_cwl,25)\n",
    "print(cal_Tchs(4000,chillers_load_sharing))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### calculate the temperature of cooling water entering cooling tower (decoupling)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:54.353023Z",
     "start_time": "2023-06-18T12:49:54.333026Z"
    }
   },
   "outputs": [],
   "source": [
    "# Tcws_lis: the initialization for calulation of temperature of cooling water leaving cooling tower\n",
    "# load: cooling load\n",
    "# Q_cooling: the waterflow in cooling water loop\n",
    "# num_ct: the number of cooling towers under operation\n",
    "# f_ct: the real-time frequency of fan in cooling towers\n",
    "# tout: dry bulb temperature of ambient air\n",
    "# hout: humidity of ambient air\n",
    "# Tchs: temperature of chilled water leaving chillers\n",
    "def cal_Tcws(Tcws_lis,load,Q_cooling,num_ct,f_ct,tout,\n",
    "             hout,chillers_condition,chillers_load_sharing,Tchs):\n",
    "    # load the parameters of coolings\n",
    "    cooling_tower_parameters = equipment_parameters()['cooling_tower']\n",
    "    \n",
    "    inter_num = 0 # initialization for iteration\n",
    "    Tcws_final = 0 # in case no result finally\n",
    "    while inter_num < 100: # set the maximum of iteration\n",
    "        # calculate Temperature of cooling water leaving cooling tower from the perspective of cooling tower\n",
    "        Tcwr = cal_T_outwater(FRair = f_ct/50,\n",
    "                              FRwater = Q_cooling/(num_ct * cooling_tower_parameters['Reference Water Flow m3/h']),\n",
    "                              T_inwater = Tcws_lis[inter_num],Tdb = tout,reHum = (hout/100))\n",
    "        \n",
    "        # calculate the power (electricity consumption) of chillers\n",
    "        power_chillers_all = cal_chillers_powers(chillers_condition,chillers_load_sharing,Tchs,Tcwr)['power_chillers_all']\n",
    "        \n",
    "        # calculate Temperature of cooling water leaving cooling tower from the perspective of chillers\n",
    "        # Temp of cooling water leaving cooling tower == Temp of cooling water entering chillers\n",
    "        # Given the perfect insulation\n",
    "        Tcws = ((load + power_chillers_all) * 3600)/(4.2 * 1000 * Q_cooling) + Tcwr                    \n",
    "        if abs(Tcws_lis[inter_num] - Tcws) < 0.05:\n",
    "            Tcws_final = Tcws\n",
    "            Tcwr_final = Tcwr\n",
    "            break\n",
    "        Tcws_lis.append(Tcws)\n",
    "        inter_num += 1\n",
    "\n",
    "    if Tcws_final == 0: # means cannot converge\n",
    "        # from two perspectives (chiller and cooling tower), much difference between two kinds of Temperature\n",
    "        # failure of decoupling\n",
    "        Tcws_final = Tcws # use the result of the last time\n",
    "        Tcwr_final = Tcwr\n",
    "        \n",
    "    Result = {'Tcws':Tcws_final,'Tcwr':Tcwr_final}\n",
    "    # print('Celsius|temperature water entering tower',Tcws_final,'temperature water leaving tower:',Tcwr_final)\n",
    "    \n",
    "    return Result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:54.883930Z",
     "start_time": "2023-06-18T12:49:54.848891Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Tcws': 19.81533053139127, 'Tcwr': 17.8}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chillers_condition = cal_chillers_condition(4000)\n",
    "chillers_load_sharing = cal_chillers_load_sharing(4000,chillers_condition)\n",
    "T_cwl = cal_Tchs(4000,chillers_load_sharing)\n",
    "cal_chillers_powers(chillers_condition,chillers_load_sharing,T_cwl,25)\n",
    "cal_Tcws([30],4000,Q_condition['Q_cooling'],\n",
    "         20,40,25,60,chillers_condition,chillers_load_sharing,T_cwl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### After we using Q-learning to decide load allocation, we use traditional mode-based method to solve the optimal control set of cooling towers (the number of cooling towers we need, the real-time frequency of cooling tower fan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:49:55.860735Z",
     "start_time": "2023-06-18T12:49:55.843730Z"
    }
   },
   "outputs": [],
   "source": [
    "# for one load, optimal control set\n",
    "# tcws: the temperature of cooling water entering cooling tower\n",
    "def cal_optimal_control_for_load(load,chillers_load_sharing,tout,hout,tcws):\n",
    "    # loading equipment parameters\n",
    "    chiller_big_parameters = equipment_parameters()['chiller_big'] # load larger chiller parameter\n",
    "    chiller_small_parameters = equipment_parameters()['chiller_small'] # load smaller chiller parameter\n",
    "    cooling_tower_parameters = equipment_parameters()['cooling_tower'] # load cooling tower\n",
    "      \n",
    "    # determine chiller operation\n",
    "    chillers_condition = cal_chillers_condition(load)\n",
    "    \n",
    "    if chillers_condition == {'chiller_big_num':0,'chiller_small_num':0}:\n",
    "        \n",
    "        print('no load, no need for optimization')\n",
    "        Result = {'load':load,'tout':tout,'hout':hout,'num_ct':0,\n",
    "                  'f_ct':0,'num_ch_small':chillers_condition['chiller_small_num'],\n",
    "                  'num_ch_big':chillers_condition['chiller_big_num'],\n",
    "                  'tcws':cal_Twb(tout,hout/100),'tcwr':cal_Twb(tout,hout/100),\n",
    "                  'power_cts':0,'power_chillers_small':0,'power_chillers_big':0,\n",
    "                  'power_chillers_all':0,'power_pumps':0,'power_all':0,\n",
    "                  'PLR_chiller_small':0,'PLR_chiller_big':0,\n",
    "                  'COP_total':0}\n",
    "        \n",
    "    else:\n",
    "        print('needs optimization')\n",
    "        \n",
    "        # for one load, needs to save these parameters\n",
    "        num_ct_lis = [] # the number of cooling towers\n",
    "        f_ct_lis = [] # the frequency of fan in cooling towers\n",
    "        tcws_lis = [] # the temperature of cooling water entering cooling towers\n",
    "        tcwr_lis = [] # the temperature of cooling water leaving cooling towers\n",
    "        power_cts_lis = [] # the power (electricity consumption) of cooling towers\n",
    "        power_chillers_small_lis = [] # the power (electricity consumption) of smaller chillers\n",
    "        power_chillers_big_lis = [] # the power (electricity consumption) of bigger chillers\n",
    "        power_chillers_all_lis = [] # the power (electricity consumption) of all chillers\n",
    "        power_all_lis = [] # the power (electricity consumption) of chillers + cooling towers\n",
    "        \n",
    "        # determine the pump operation\n",
    "        pumps_condition = cal_pumps_condition(chillers_condition)\n",
    "        # waterflow in chilled/cooling water loop\n",
    "        Q_condition = cal_Qchwcw(pumps_condition)\n",
    "        # calculate the power (electricity consumption) of all water pumps\n",
    "        power_pumps = cal_pumps_power(pumps_condition)\n",
    "        \n",
    "        # waterflow in chilled/cooling water loop\n",
    "        Q_chilled = Q_condition['Q_chilled']\n",
    "        Q_cooling = Q_condition['Q_cooling']\n",
    "        \n",
    "        \n",
    "        # chillers_load_sharing = cal_chillers_load_sharing(load,chillers_condition)\n",
    "        # calculate the temperature of chilled water leaving chillers\n",
    "        T_cwl = cal_Tchs(load,chillers_load_sharing)\n",
    "        # permutation of the number cooling tower and fan frequency considering safety issue\n",
    "        group_lis = []\n",
    "        for num_ct in range(1,21):\n",
    "            if (Q_cooling/(num_ct * cooling_tower_parameters['Reference Water Flow m3/h'])) <= 1:  \n",
    "                for f_best in range(30,51):\n",
    "                    group_lis.append([num_ct,f_best])\n",
    "        print('the number of permutation',len(group_lis),'can choose')\n",
    "        \n",
    "        for group in group_lis:\n",
    "            # print(group,'one control set in permutation')\n",
    "            \n",
    "            # cal_Tcws(Tcws_lis,load,Q_cooling,num_ct,f_ct,tout,hout,chillers_condition,chillers_load_sharing,Tchs)\n",
    "            Tcw_condition = cal_Tcws([tcws],load,Q_cooling,group[0],group[1],\n",
    "                                     tout,hout,chillers_condition,chillers_load_sharing,T_cwl)\n",
    "            \n",
    "            \n",
    "            power_cts = group[0] * cal_CT_FanPower(group[1])\n",
    "            \n",
    "            \n",
    "            # cal_chillers_powers(chillers_condition,chillers_load_sharing,T_cwl,T_conde)\n",
    "            power_chs = cal_chillers_powers(chillers_condition,chillers_load_sharing,T_cwl,Tcw_condition['Tcwr'])\n",
    "            \n",
    "            num_ct_lis.append(group[0]) # the number of cooling towers under operation\n",
    "            f_ct_lis.append(group[1]) # the frequency of cooling tower fan\n",
    "            tcws_lis.append(Tcw_condition['Tcws']) # Temp of cooling water entering cooling tower\n",
    "            tcwr_lis.append(Tcw_condition['Tcwr']) # Temp of cooling water leaving cooling tower\n",
    "            power_cts_lis.append(power_cts) # the power (electricity consumption) of cooling towers\n",
    "            power_chillers_big_lis.append(power_chs['power_chillers_big']) # the power (electricity consumption) of smaller chillers\n",
    "            power_chillers_small_lis.append(power_chs['power_chillers_small']) # the power (electricity consumption) of bigger chillers\n",
    "            power_chillers_all_lis.append(power_chs['power_chillers_all']) # the power (electricity consumption) of all chillers\n",
    "            power_all_lis.append(power_cts + power_chs['power_chillers_all'] + power_pumps) # the power (electricity consumption) of chillers + cooling towers\n",
    "        \n",
    "        # pick one control set from reasonable permutation (the minmum power of all chillers and cooling towers)\n",
    "        index_optimal = power_all_lis.index(min(power_all_lis))\n",
    "        Result = {'load':load,'tout':tout,'hout':hout,'num_ct':num_ct_lis[index_optimal],\n",
    "                  'f_ct':f_ct_lis[index_optimal],'num_ch_small':chillers_condition['chiller_small_num'],\n",
    "                  'num_ch_big':chillers_condition['chiller_big_num'],'tcws':tcws_lis[index_optimal],\n",
    "                  'tcwr':tcwr_lis[index_optimal],'power_cts':power_cts_lis[index_optimal],\n",
    "                  'power_chillers_small':power_chillers_small_lis[index_optimal],\n",
    "                  'power_chillers_big':power_chillers_big_lis[index_optimal],\n",
    "                  'power_chillers_all':power_chillers_all_lis[index_optimal],\n",
    "                  'power_pumps':power_pumps,'power_all':power_all_lis[index_optimal],\n",
    "                  'PLR_chiller_small':chillers_load_sharing['PL_small']/chiller_small_parameters['Reference Capacity KW'],\n",
    "                  'PLR_chiller_big':chillers_load_sharing['PL_big']/chiller_big_parameters['Reference Capacity KW']}\n",
    "        \n",
    "        COP_total = Result['load'] / Result['power_all']\n",
    "        Result['COP_total'] = COP_total\n",
    "                                        \n",
    "        \n",
    "        print('optimal control set：the number of cooling tower',Result['num_ct'],', real-time frequency',Result['f_ct'],'Hz，the number of larger chillers',\n",
    "              chillers_condition['chiller_big_num'],', the number of smaller chillers',chillers_condition['chiller_small_num'],'\\n the temperature of water entering towers',Result['tcws'],\n",
    "              'Celsius, the temperature of water leaving towers',Result['tcwr'],'Celsius, All electricity consumption',Result['power_all'],'KW\\n total COP',\n",
    "              Result['COP_total'])\n",
    "        \n",
    "    return Result\n",
    "            \n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:50:23.370337Z",
     "start_time": "2023-06-18T12:49:57.240251Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "needs optimization\n",
      "the number of permutation 315 can choose\n",
      "optimal control set：the number of cooling tower 6 , real-time frequency 30 Hz，the number of larger chillers 0 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 24.659723036602113 Celsius, the temperature of water leaving towers 22.9 Celsius, All electricity consumption 196.69516749530607 KW\n",
      " total COP 7.626013486253016\n"
     ]
    }
   ],
   "source": [
    "# the preparation of Q-learning is done\n",
    "chillers_condition = cal_chillers_condition(1500)\n",
    "chillers_load_sharing = cal_chillers_load_sharing(1500,chillers_condition)\n",
    "optimal_result_a_load = cal_optimal_control_for_load(1500,chillers_load_sharing,24,83,30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:50:23.716166Z",
     "start_time": "2023-06-18T12:50:23.703209Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8705745792222868"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "optimal_result_a_load['PLR_chiller_small']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### optimize the load allocation by Q-learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:50:28.004109Z",
     "start_time": "2023-06-18T12:50:27.995138Z"
    }
   },
   "outputs": [],
   "source": [
    "def cal_chillers_load_sharing_Q(load,chillers_condition,action):\n",
    "    chiller_big_parameters = equipment_parameters()['chiller_big']\n",
    "    chiller_small_parameters = equipment_parameters()['chiller_small']\n",
    "    # goal is optimize the load allocation for smaller chillers\n",
    "    PL_small = chiller_small_parameters['Reference Capacity KW'] * action\n",
    "    PL_big = (load - PL_small * chillers_condition['chiller_small_num']) / chillers_condition['chiller_big_num']\n",
    "    Result = {'PL_big':PL_big,'PL_small':PL_small}\n",
    "    return Result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:50:28.596745Z",
     "start_time": "2023-06-18T12:50:28.578655Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'PL_big': 2353.875, 'PL_small': 1292.25}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test\n",
    "chillers_condition = cal_chillers_condition(6000)\n",
    "cal_chillers_load_sharing_Q(6000,chillers_condition,random.choice(np.arange(0,1.05,0.05)))\n",
    "# 0 means no need to use smaller chillers to generate chilled water\n",
    "# 1 means smaller chillers will run at full capacity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### training Q-table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:50:29.904481Z",
     "start_time": "2023-06-18T12:50:29.886548Z"
    }
   },
   "outputs": [],
   "source": [
    "def train_Q(load,tout,hout,Q_table):\n",
    "    #Q_table = Q_table_ini()\n",
    "    Q_para_dict = Q_para_ini()\n",
    "    num_ct_lis = [] # every load, the number of cooling towers\n",
    "    f_ct_lis = [] # every load, the frequency of fan in cooling towers\n",
    "    num_ch_small_lis = [] # every load, the number of larger chillers\n",
    "    num_ch_big_lis = [] # every load, the number of smaller chillers\n",
    "    plr_ch_small_lis = [] # the ratio of part load for smaller chillers\n",
    "    plr_ch_big_lis = [] # the ratio of part load for larger chillers\n",
    "    tcws_lis = [] # the best control set, temperature of water entering tower\n",
    "    tcwr_lis = [] # the best control set, temperature of water leaving tower\n",
    "    power_cts_lis = [] # the best control set, power(electricity consumption) for cooling towers\n",
    "    power_chillers_small_lis = [] # the best control set, power(electricity consumption) for smaller chillers\n",
    "    power_chillers_big_lis = [] # the best control set, power(electricity consumption) for larger chillers\n",
    "    power_chillers_all_lis = [] # the best control set, power(electricity consumption) for all chillers\n",
    "    power_all_lis = [] # the best control set, power(electricity consumption) for all\n",
    "    COP_total_lis = []\n",
    "    Q_or_not = [] # in the load, whether using Q-learning or not, 0 is no, 1 is yes\n",
    "    \n",
    "    for i in range(len(load)):\n",
    "        print(load[i],tout[i],hout[i])\n",
    "        # chillers_condition = cal_chillers_condition(load[i])\n",
    "        #print('A')\n",
    "        \n",
    "        try:\n",
    "            tcws = tcws_lis[-1]\n",
    "        except:\n",
    "            tcws = 30\n",
    "            \n",
    "        if class_chillers_condition(load[i]) == 'one':\n",
    "            # only need one kind of chillers\n",
    "            print('no need to use Q-learning')\n",
    "            Q_or_not.append(0)\n",
    "            chillers_load_sharing = cal_chillers_load_sharing(load[i],\n",
    "                                                              chillers_condition)\n",
    "\n",
    "            optimal_result = cal_optimal_control_for_load(load[i],chillers_load_sharing,\n",
    "                                                          tout[i],hout[i],tcws)\n",
    "            \n",
    "            print('------')\n",
    "        else:\n",
    "            print('need to use Q-learning')\n",
    "            Q_or_not.append(1)\n",
    "            state = cal_discrete_load(load[i])\n",
    "            # Take the Q value of all the actions in this state\n",
    "            if random.uniform(0, 1) < Q_para_dict['epsilon']:\n",
    "                action = random.choice(np.arange(0,1.05,0.05))            \n",
    "            # Then the action of taking the Q value with a certain probability\n",
    "            else:\n",
    "                action = Q_table[tuple((state,))].idxmax()[0]\n",
    "            # Or, there is a certain probability that another action will be selected from a series of actions\n",
    "            # Then calculate the load distribution under this action\n",
    "            chillers_load_sharing = cal_chillers_load_sharing_Q(load[i],chillers_condition,action)\n",
    "            # and then calculate Temp of chilled water leaving chillers\n",
    "            # and then calculate the total COP\n",
    "            optimal_result = cal_optimal_control_for_load(load[i],chillers_load_sharing,\n",
    "                                                            tout[i],hout[i],tcws)\n",
    "            \n",
    "            # using load allocation for next load (using random order)\n",
    "            \n",
    "            while 1:\n",
    "                load_next = random.choice(load)\n",
    "                chillers_condition_next = cal_chillers_condition(load_next)\n",
    "                if class_chillers_condition(load_next) != 'one':\n",
    "                    break\n",
    "            state_next = cal_discrete_load(load_next)\n",
    "            max_next = Q_table[tuple((state_next,))].values.max()        \n",
    "            \n",
    "            print('oupdated state',state,', action',action,', the inital Q value',Q_table.loc[tuple((action,)),tuple((state,))])\n",
    "            print('reward(total COP)',optimal_result['COP_total'])\n",
    "            #print('the maximun of next step',max_next)\n",
    "            #print('parameter alpha and gamma', Q_para_dict['alpha'],Q_para_dict['gamma'])\n",
    "            # update Q table\n",
    "            Q_table.loc[tuple((action,)),tuple((state,))] = update_Q_table(value_old = copy.deepcopy(Q_table.loc[tuple((action,)),tuple((state,))]),\n",
    "                                                                           reward = optimal_result['COP_total'],\n",
    "                                                                           value_max = max_next,\n",
    "                                                                           a = Q_para_dict['alpha'],\n",
    "                                                                           y = Q_para_dict['gamma'])\n",
    "            print('updated Q value',Q_table.loc[tuple((action,)),tuple((state,))])\n",
    "            print('------')\n",
    "        #print('B')\n",
    "        num_ct_lis.append(optimal_result['num_ct']) \n",
    "        f_ct_lis.append(optimal_result['f_ct']) \n",
    "        num_ch_small_lis.append(optimal_result['num_ch_small']) \n",
    "        num_ch_big_lis.append(optimal_result['num_ch_big']) \n",
    "        tcws_lis.append(optimal_result['tcws']) \n",
    "        tcwr_lis.append(optimal_result['tcwr']) \n",
    "        power_cts_lis.append(optimal_result['power_cts']) \n",
    "        power_chillers_small_lis.append(optimal_result['power_chillers_small']) \n",
    "        power_chillers_big_lis.append(optimal_result['power_chillers_big']) \n",
    "        power_chillers_all_lis.append(optimal_result['power_chillers_all']) \n",
    "        power_all_lis.append(optimal_result['power_all']) \n",
    "        plr_ch_small_lis.append(optimal_result['PLR_chiller_small']) \n",
    "        plr_ch_big_lis.append(optimal_result['PLR_chiller_big']) \n",
    "        COP_total_lis.append(optimal_result['COP_total'])\n",
    "        \n",
    "    return num_ct_lis,f_ct_lis,num_ch_small_lis,num_ch_big_lis,tcws_lis,tcwr_lis,power_cts_lis,power_chillers_small_lis,power_chillers_big_lis,power_chillers_all_lis,power_all_lis,plr_ch_small_lis,plr_ch_big_lis,COP_total_lis,Q_table\n",
    "        \n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-18T12:53:45.977095Z",
     "start_time": "2023-06-18T12:50:31.662785Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3923.769926 23.0 94.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.0620878565251 Celsius, the temperature of water leaving towers 24.2 Celsius, All electricity consumption 341.8966559639741 KW\n",
      " total COP 11.476479390934582\n",
      "oupdated state 0.6000000000000001 , action 0.0 , the inital Q value 0\n",
      "reward(total COP) 11.476479390934582\n",
      "updated Q value 10.328831451841124\n",
      "------\n",
      "3923.769926 23.0 94.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.04520235718107 Celsius, the temperature of water leaving towers 24.2 Celsius, All electricity consumption 304.46713241803945 KW\n",
      " total COP 12.887334980422732\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 0.0\n",
      "reward(total COP) 12.887334980422732\n",
      "updated Q value 11.691560965447028\n",
      "------\n",
      "3923.769926 23.0 94.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.04520235718107 Celsius, the temperature of water leaving towers 24.2 Celsius, All electricity consumption 304.46713241803945 KW\n",
      " total COP 12.887334980422732\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 11.691560965447028\n",
      "reward(total COP) 12.887334980422732\n",
      "updated Q value 12.872981627614184\n",
      "------\n",
      "3923.769926 24.0 90.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.24514019276572 Celsius, the temperature of water leaving towers 24.4 Celsius, All electricity consumption 304.3293346306841 KW\n",
      " total COP 12.893170258337575\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 12.872981627614184\n",
      "reward(total COP) 12.893170258337575\n",
      "updated Q value 13.007008229913763\n",
      "------\n",
      "3923.769926 26.0 88.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.544459437847333 Celsius, the temperature of water leaving towers 25.7 Celsius, All electricity consumption 302.8203278949244 KW\n",
      " total COP 12.957419184096217\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.007008229913763\n",
      "reward(total COP) 12.957419184096217\n",
      "updated Q value 13.079441162747196\n",
      "------\n",
      "3923.769926 27.0 78.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.744935120098365 Celsius, the temperature of water leaving towers 24.9 Celsius, All electricity consumption 303.874756884715 KW\n",
      " total COP 12.91245763954198\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.079441162747196\n",
      "reward(total COP) 12.91245763954198\n",
      "updated Q value 13.046870962327226\n",
      "------\n",
      "3923.769926 26.0 80.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.34510485384699 Celsius, the temperature of water leaving towers 24.5 Celsius, All electricity consumption 304.2510000274996 KW\n",
      " total COP 12.896489824668947\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.046870962327226\n",
      "reward(total COP) 12.896489824668947\n",
      "updated Q value 13.02894977709572\n",
      "------\n",
      "3923.769926 29.0 74.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.544459437847333 Celsius, the temperature of water leaving towers 25.7 Celsius, All electricity consumption 302.8203278949244 KW\n",
      " total COP 12.957419184096217\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.02894977709572\n",
      "reward(total COP) 12.957419184096217\n",
      "updated Q value 13.081832791390028\n",
      "------\n",
      "3923.769926 28.0 72.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.44506667712089 Celsius, the temperature of water leaving towers 24.6 Celsius, All electricity consumption 304.1663749513103 KW\n",
      " total COP 12.900077882139671\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.081832791390028\n",
      "reward(total COP) 12.900077882139671\n",
      "updated Q value 13.035989868187217\n",
      "------\n",
      "3923.769926 29.0 75.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.881741665651766 Celsius, the temperature of water leaving towers 26.0 Celsius, All electricity consumption 385.46259952807964 KW\n",
      " total COP 10.179379091003527\n",
      "oupdated state 0.6000000000000001 , action 0.9500000000000001 , the inital Q value 0.0\n",
      "reward(total COP) 10.179379091003527\n",
      "updated Q value 9.27876509071686\n",
      "------\n",
      "3923.769926 30.0 68.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.344595385254316 Celsius, the temperature of water leaving towers 25.5 Celsius, All electricity consumption 303.1216779803997 KW\n",
      " total COP 12.944537494456984\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.035989868187217\n",
      "reward(total COP) 12.944537494456984\n",
      "updated Q value 13.071006640643693\n",
      "------\n",
      "3923.769926 29.0 70.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.944833226379835 Celsius, the temperature of water leaving towers 25.1 Celsius, All electricity consumption 303.64889247529504 KW\n",
      " total COP 12.922062366221997\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.071006640643693\n",
      "reward(total COP) 12.922062366221997\n",
      "updated Q value 13.054595853429959\n",
      "------\n",
      "3923.769926 29.0 73.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.344595385254316 Celsius, the temperature of water leaving towers 25.5 Celsius, All electricity consumption 303.1216779803997 KW\n",
      " total COP 12.944537494456984\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.054595853429959\n",
      "reward(total COP) 12.944537494456984\n",
      "updated Q value 13.07303469303515\n",
      "------\n",
      "3923.769926 28.0 74.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.844885592142784 Celsius, the temperature of water leaving towers 25.0 Celsius, All electricity consumption 303.7649699165073 KW\n",
      " total COP 12.917124469877107\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.07303469303515\n",
      "reward(total COP) 12.917124469877107\n",
      "updated Q value 13.050372804430227\n",
      "------\n",
      "3923.769926 27.0 77.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.64498181024658 Celsius, the temperature of water leaving towers 24.8 Celsius, All electricity consumption 303.97825337991804 KW\n",
      " total COP 12.908061291792457\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.050372804430227\n",
      "reward(total COP) 12.908061291792457\n",
      "updated Q value 13.039745798296106\n",
      "------\n",
      "3923.769926 26.0 80.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.342968355669726 Celsius, the temperature of water leaving towers 24.5 Celsius, All electricity consumption 299.5150957345619 KW\n",
      " total COP 13.100407898897181\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 0.0\n",
      "reward(total COP) 13.100407898897181\n",
      "updated Q value 11.907724821192128\n",
      "------\n",
      "3923.769926 25.0 85.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.34510485384699 Celsius, the temperature of water leaving towers 24.5 Celsius, All electricity consumption 304.2510000274996 KW\n",
      " total COP 12.896489824668947\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.039745798296106\n",
      "reward(total COP) 12.896489824668947\n",
      "updated Q value 13.028173134216328\n",
      "------\n",
      "3923.769926 24.0 89.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.145172693877083 Celsius, the temperature of water leaving towers 24.3 Celsius, All electricity consumption 304.4013787608641 KW\n",
      " total COP 12.890118770068025\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.028173134216328\n",
      "reward(total COP) 12.890118770068025\n",
      "updated Q value 13.021177764690803\n",
      "------\n",
      "3923.769926 24.0 92.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.54502566258742 Celsius, the temperature of water leaving towers 24.7 Celsius, All electricity consumption 304.0754594021165 KW\n",
      " total COP 12.903934877596008\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.021177764690803\n",
      "reward(total COP) 12.903934877596008\n",
      "updated Q value 13.032849766187704\n",
      "------\n",
      "3923.769926 23.0 93.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 25.94522918267769 Celsius, the temperature of water leaving towers 24.1 Celsius, All electricity consumption 304.5265956022102 KW\n",
      " total COP 12.884818543485935\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.032849766187704\n",
      "reward(total COP) 12.884818543485935\n",
      "updated Q value 13.0169173136518\n",
      "------\n",
      "3923.769926 23.0 95.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.14514331762733 Celsius, the temperature of water leaving towers 24.3 Celsius, All electricity consumption 304.33626140724925 KW\n",
      " total COP 12.892876806255385\n",
      "oupdated state 0.6000000000000001 , action 0.65 , the inital Q value 0.0\n",
      "reward(total COP) 12.892876806255385\n",
      "updated Q value 11.720741381452713\n",
      "------\n",
      "3923.769926 23.0 95.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.145172693877083 Celsius, the temperature of water leaving towers 24.3 Celsius, All electricity consumption 304.4013787608641 KW\n",
      " total COP 12.890118770068025\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.0169173136518\n",
      "reward(total COP) 12.890118770068025\n",
      "updated Q value 13.019950880249269\n",
      "------\n",
      "3923.769926 23.0 95.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.145172693877083 Celsius, the temperature of water leaving towers 24.3 Celsius, All electricity consumption 304.4013787608641 KW\n",
      " total COP 12.890118770068025\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.019950880249269\n",
      "reward(total COP) 12.890118770068025\n",
      "updated Q value 13.020281539008392\n",
      "------\n",
      "3923.769926 23.0 96.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.24514019276572 Celsius, the temperature of water leaving towers 24.4 Celsius, All electricity consumption 304.3293346306841 KW\n",
      " total COP 12.893170258337575\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.020281539008392\n",
      "reward(total COP) 12.893170258337575\n",
      "updated Q value 13.023063920255732\n",
      "------\n",
      "3923.769926 23.0 97.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.4671092347087 Celsius, the temperature of water leaving towers 24.6 Celsius, All electricity consumption 353.0273776042885 KW\n",
      " total COP 11.11463352397045\n",
      "oupdated state 0.6000000000000001 , action 0.8500000000000001 , the inital Q value 0.0\n",
      "reward(total COP) 11.11463352397045\n",
      "updated Q value 10.120377746855707\n",
      "------\n",
      "3923.769926 23.0 93.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 25.94522918267769 Celsius, the temperature of water leaving towers 24.1 Celsius, All electricity consumption 304.5265956022102 KW\n",
      " total COP 12.884818543485935\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.023063920255732\n",
      "reward(total COP) 12.884818543485935\n",
      "updated Q value 13.015850656445215\n",
      "------\n",
      "3923.769926 24.0 89.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.04520235718107 Celsius, the temperature of water leaving towers 24.2 Celsius, All electricity consumption 304.46713241803945 KW\n",
      " total COP 12.887334980422732\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.015850656445215\n",
      "reward(total COP) 12.887334980422732\n",
      "updated Q value 13.017329203932988\n",
      "------\n",
      "3923.769926 24.0 89.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.04520235718107 Celsius, the temperature of water leaving towers 24.2 Celsius, All electricity consumption 304.46713241803945 KW\n",
      " total COP 12.887334980422732\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.017329203932988\n",
      "reward(total COP) 12.887334980422732\n",
      "updated Q value 13.017490365609156\n",
      "------\n",
      "3923.769926 27.0 75.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.145172693877083 Celsius, the temperature of water leaving towers 24.3 Celsius, All electricity consumption 304.4013787608641 KW\n",
      " total COP 12.890118770068025\n",
      "oupdated state 0.6000000000000001 , action 0.25 , the inital Q value 13.017490365609156\n",
      "reward(total COP) 12.890118770068025\n",
      "updated Q value 13.020013342912621\n",
      "------\n",
      "3923.769926 29.0 66.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.04306765323515 Celsius, the temperature of water leaving towers 24.2 Celsius, All electricity consumption 299.735205337911 KW\n",
      " total COP 13.090787655645851\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 11.907724821192128\n",
      "reward(total COP) 13.090787655645851\n",
      "updated Q value 13.089661492286693\n",
      "------\n",
      "3923.769926 29.0 65.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 25.84311994750573 Celsius, the temperature of water leaving towers 24.0 Celsius, All electricity consumption 299.8511243043698 KW\n",
      " total COP 13.085726908988008\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.089661492286693\n",
      "reward(total COP) 13.085726908988008\n",
      "updated Q value 13.203927320748456\n",
      "------\n",
      "3923.769926 31.0 62.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.74279702741801 Celsius, the temperature of water leaving towers 24.9 Celsius, All electricity consumption 299.13531810992936 KW\n",
      " total COP 13.11703997639641\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.203927320748456\n",
      "reward(total COP) 13.11703997639641\n",
      "updated Q value 13.24456405671835\n",
      "------\n",
      "3923.769926 31.0 57.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 25.64316111849122 Celsius, the temperature of water leaving towers 23.8 Celsius, All electricity consumption 299.94238665554275 KW\n",
      " total COP 13.081745363672464\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.24456405671835\n",
      "reward(total COP) 13.081745363672464\n",
      "updated Q value 13.217228309487519\n",
      "------\n",
      "3923.769926 32.0 55.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 25.84311994750573 Celsius, the temperature of water leaving towers 24.0 Celsius, All electricity consumption 299.8511243043698 KW\n",
      " total COP 13.085726908988008\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.217228309487519\n",
      "reward(total COP) 13.085726908988008\n",
      "updated Q value 13.217832103823346\n",
      "------\n",
      "3923.769926 32.0 55.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 25.84311994750573 Celsius, the temperature of water leaving towers 24.0 Celsius, All electricity consumption 299.8511243043698 KW\n",
      " total COP 13.085726908988008\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.217832103823346\n",
      "reward(total COP) 13.085726908988008\n",
      "updated Q value 13.217897917405953\n",
      "------\n",
      "3923.769926 32.0 56.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.04306765323515 Celsius, the temperature of water leaving towers 24.2 Celsius, All electricity consumption 299.735205337911 KW\n",
      " total COP 13.090787655645851\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.217897917405953\n",
      "reward(total COP) 13.090787655645851\n",
      "updated Q value 13.222459763078515\n",
      "------\n",
      "3923.769926 31.0 60.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.24300423567947 Celsius, the temperature of water leaving towers 24.4 Celsius, All electricity consumption 299.59462975616646 KW\n",
      " total COP 13.096930105834911\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.222459763078515\n",
      "reward(total COP) 13.096930105834911\n",
      "updated Q value 13.228485209426978\n",
      "------\n",
      "3923.769926 30.0 69.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.442390141358512 Celsius, the temperature of water leaving towers 25.6 Celsius, All electricity consumption 298.2333873446963 KW\n",
      " total COP 13.156709116088772\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.228485209426978\n",
      "reward(total COP) 13.156709116088772\n",
      "updated Q value 13.282943092307434\n",
      "------\n",
      "3923.769926 29.0 68.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.542888253186415 Celsius, the temperature of water leaving towers 24.7 Celsius, All electricity consumption 299.3375352298886 KW\n",
      " total COP 13.108178775463555\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.282943092307434\n",
      "reward(total COP) 13.108178775463555\n",
      "updated Q value 13.24520169497871\n",
      "------\n",
      "3923.769926 29.0 71.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.042639332605862 Celsius, the temperature of water leaving towers 25.2 Celsius, All electricity consumption 298.7857612763297 KW\n",
      " total COP 13.132385925081389\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.24520169497871\n",
      "reward(total COP) 13.132385925081389\n",
      "updated Q value 13.26287431732593\n",
      "------\n",
      "3923.769926 27.0 82.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.34245661040226 Celsius, the temperature of water leaving towers 25.5 Celsius, All electricity consumption 298.3807270583369 KW\n",
      " total COP 13.150212363524597\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.26287431732593\n",
      "reward(total COP) 13.150212363524597\n",
      "updated Q value 13.280844427760663\n",
      "------\n",
      "3923.769926 26.0 87.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.34245661040226 Celsius, the temperature of water leaving towers 25.5 Celsius, All electricity consumption 298.3807270583369 KW\n",
      " total COP 13.150212363524597\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.280844427760663\n",
      "reward(total COP) 13.150212363524597\n",
      "updated Q value 13.28280316979805\n",
      "------\n",
      "3923.769926 26.0 89.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.742174049299628 Celsius, the temperature of water leaving towers 25.9 Celsius, All electricity consumption 297.7543832808461 KW\n",
      " total COP 13.177874605120573\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.28280316979805\n",
      "reward(total COP) 13.177874605120573\n",
      "updated Q value 13.307912690116504\n",
      "------\n",
      "3923.769926 25.0 90.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.142581206025934 Celsius, the temperature of water leaving towers 25.3 Celsius, All electricity consumption 298.6569140241536 KW\n",
      " total COP 13.138051529196035\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.307912690116504\n",
      "reward(total COP) 13.138051529196035\n",
      "updated Q value 13.274808859499132\n",
      "------\n",
      "3923.769926 25.0 91.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.142581206025934 Celsius, the temperature of water leaving towers 25.3 Celsius, All electricity consumption 298.6569140241536 KW\n",
      " total COP 13.138051529196035\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.274808859499132\n",
      "reward(total COP) 13.138051529196035\n",
      "updated Q value 13.271200541961838\n",
      "------\n",
      "3923.769926 25.0 92.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.34245661040226 Celsius, the temperature of water leaving towers 25.5 Celsius, All electricity consumption 298.3807270583369 KW\n",
      " total COP 13.150212363524597\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.271200541961838\n",
      "reward(total COP) 13.150212363524597\n",
      "updated Q value 13.281751986245977\n",
      "------\n",
      "3923.769926 25.0 92.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " the temperature of water entering towers 27.34245661040226 Celsius, the temperature of water leaving towers 25.5 Celsius, All electricity consumption 298.3807270583369 KW\n",
      " total COP 13.150212363524597\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.281751986245977\n",
      "reward(total COP) 13.150212363524597\n",
      "updated Q value 13.282902093672948\n",
      "------\n",
      "3923.769926 25.0 92.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.351973709807034 Celsius, the temperature of water leaving towers 25.5 Celsius, All electricity consumption 319.4769640722551 KW\n",
      " total COP 12.281855555358831\n",
      "oupdated state 0.6000000000000001 , action 0.75 , the inital Q value 0.0\n",
      "reward(total COP) 12.281855555358831\n",
      "updated Q value 11.173216118666005\n",
      "------\n",
      "3923.769926 24.0 100.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.642248860807197 Celsius, the temperature of water leaving towers 25.8 Celsius, All electricity consumption 297.92021545595105 KW\n",
      " total COP 13.170539367376861\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.282902093672948\n",
      "reward(total COP) 13.170539367376861\n",
      "updated Q value 13.301321758849525\n",
      "------\n",
      "3923.769926 25.0 91.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.24252029862473 Celsius, the temperature of water leaving towers 25.4 Celsius, All electricity consumption 298.521902618156 KW\n",
      " total COP 13.143993427574241\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.301321758849525\n",
      "reward(total COP) 13.143993427574241\n",
      "updated Q value 13.279438156531414\n",
      "------\n",
      "3923.769926 27.0 86.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.041932929849295 Celsius, the temperature of water leaving towers 26.2 Celsius, All electricity consumption 297.2199018326028 KW\n",
      " total COP 13.201571973500975\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.279438156531414\n",
      "reward(total COP) 13.201571973500975\n",
      "updated Q value 13.328873535212804\n",
      "------\n",
      "3923.769926 27.0 86.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.041932929849295 Celsius, the temperature of water leaving towers 26.2 Celsius, All electricity consumption 297.2199018326028 KW\n",
      " total COP 13.201571973500975\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.328873535212804\n",
      "reward(total COP) 13.201571973500975\n",
      "updated Q value 13.334261991489074\n",
      "------\n",
      "3923.769926 29.0 77.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.14184699505664 Celsius, the temperature of water leaving towers 26.3 Celsius, All electricity consumption 297.029413042212 KW\n",
      " total COP 13.210038311735739\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.334261991489074\n",
      "reward(total COP) 13.210038311735739\n",
      "updated Q value 13.342469037634473\n",
      "------\n",
      "3923.769926 30.0 73.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.241758279442706 Celsius, the temperature of water leaving towers 26.4 Celsius, All electricity consumption 296.8327600979999 KW\n",
      " total COP 13.218790017330162\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.342469037634473\n",
      "reward(total COP) 13.218790017330162\n",
      "updated Q value 13.351240140699304\n",
      "------\n",
      "3923.769926 31.0 66.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.642248860807197 Celsius, the temperature of water leaving towers 25.8 Celsius, All electricity consumption 297.92021545595105 KW\n",
      " total COP 13.170539367376861\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.351240140699304\n",
      "reward(total COP) 13.170539367376861\n",
      "updated Q value 13.308770605975399\n",
      "------\n",
      "3923.769926 32.0 63.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.742174049299628 Celsius, the temperature of water leaving towers 25.9 Celsius, All electricity consumption 297.7543832808461 KW\n",
      " total COP 13.177874605120573\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.308770605975399\n",
      "reward(total COP) 13.177874605120573\n",
      "updated Q value 13.310743140659834\n",
      "------\n",
      "3923.769926 33.0 60.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.84209645697079 Celsius, the temperature of water leaving towers 26.0 Celsius, All electricity consumption 297.58238695191983 KW\n",
      " total COP 13.185491138069137\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.310743140659834\n",
      "reward(total COP) 13.185491138069137\n",
      "updated Q value 13.317813026594145\n",
      "------\n",
      "3923.769926 34.0 61.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.841167588512395 Celsius, the temperature of water leaving towers 27.0 Celsius, All electricity consumption 295.5233952024763 KW\n",
      " total COP 13.277358035602052\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.317813026594145\n",
      "reward(total COP) 13.277358035602052\n",
      "updated Q value 13.401263851940609\n",
      "------\n",
      "3923.769926 33.0 62.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.44157250575103 Celsius, the temperature of water leaving towers 26.6 Celsius, All electricity consumption 296.42096174811115 KW\n",
      " total COP 13.237154021969241\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.401263851940609\n",
      "reward(total COP) 13.237154021969241\n",
      "updated Q value 13.374176379633843\n",
      "------\n",
      "3923.769926 33.0 65.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.941059407149556 Celsius, the temperature of water leaving towers 27.1 Celsius, All electricity consumption 295.283593181514 KW\n",
      " total COP 13.28814067765701\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.374176379633843\n",
      "reward(total COP) 13.28814067765701\n",
      "updated Q value 13.417111835271399\n",
      "------\n",
      "3923.769926 32.0 69.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 29.04094844496544 Celsius, the temperature of water leaving towers 27.2 Celsius, All electricity consumption 295.0376270067302 KW\n",
      " total COP 13.299218699011885\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.417111835271399\n",
      "reward(total COP) 13.299218699011885\n",
      "updated Q value 13.43176201915528\n",
      "------\n",
      "3923.769926 30.0 74.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.44157250575103 Celsius, the temperature of water leaving towers 26.6 Celsius, All electricity consumption 296.42096174811115 KW\n",
      " total COP 13.237154021969241\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.43176201915528\n",
      "reward(total COP) 13.237154021969241\n",
      "updated Q value 13.377500679860242\n",
      "------\n",
      "3923.769926 29.0 80.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.641375608774258 Celsius, the temperature of water leaving towers 26.8 Celsius, All electricity consumption 295.98450678293665 KW\n",
      " total COP 13.256673359857778\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.377500679860242\n",
      "reward(total COP) 13.256673359857778\n",
      "updated Q value 13.389153597976767\n",
      "------\n",
      "3923.769926 28.0 82.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.341666783007504 Celsius, the temperature of water leaving towers 26.5 Celsius, All electricity consumption 296.62994299996626 KW\n",
      " total COP 13.227828203440831\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.389153597976767\n",
      "reward(total COP) 13.227828203440831\n",
      "updated Q value 13.364463125276215\n",
      "------\n",
      "3923.769926 27.0 86.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.14184699505664 Celsius, the temperature of water leaving towers 26.3 Celsius, All electricity consumption 297.029413042212 KW\n",
      " total COP 13.210038311735739\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.364463125276215\n",
      "reward(total COP) 13.210038311735739\n",
      "updated Q value 13.345760961217273\n",
      "------\n",
      "3923.769926 27.0 87.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.241758279442706 Celsius, the temperature of water leaving towers 26.4 Celsius, All electricity consumption 296.8327600979999 KW\n",
      " total COP 13.218790017330162\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.345760961217273\n",
      "reward(total COP) 13.218790017330162\n",
      "updated Q value 13.351598960369829\n",
      "------\n",
      "3923.769926 26.0 87.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.442390141358512 Celsius, the temperature of water leaving towers 25.6 Celsius, All electricity consumption 298.2333873446963 KW\n",
      " total COP 13.156709116088772\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.351598960369829\n",
      "reward(total COP) 13.156709116088772\n",
      "updated Q value 13.296362491160206\n",
      "------\n",
      "3923.769926 26.0 83.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.842747243301904 Celsius, the temperature of water leaving towers 25.0 Celsius, All electricity consumption 299.0249633192177 KW\n",
      " total COP 13.121880803681474\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.296362491160206\n",
      "reward(total COP) 13.121880803681474\n",
      "updated Q value 13.25899623484979\n",
      "------\n",
      "3923.769926 26.0 80.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.342968355669726 Celsius, the temperature of water leaving towers 24.5 Celsius, All electricity consumption 299.5150957345619 KW\n",
      " total COP 13.100407898897181\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.25899623484979\n",
      "reward(total COP) 13.100407898897181\n",
      "updated Q value 13.235597698606089\n",
      "------\n",
      "3923.769926 26.0 77.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 25.84311994750573 Celsius, the temperature of water leaving towers 24.0 Celsius, All electricity consumption 299.8511243043698 KW\n",
      " total COP 13.085726908988008\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.235597698606089\n",
      "reward(total COP) 13.085726908988008\n",
      "updated Q value 13.21983436723727\n",
      "------\n",
      "3923.769926 26.0 78.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 25.84311994750573 Celsius, the temperature of water leaving towers 24.0 Celsius, All electricity consumption 299.8511243043698 KW\n",
      " total COP 13.085726908988008\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.21983436723727\n",
      "reward(total COP) 13.085726908988008\n",
      "updated Q value 13.21811616411807\n",
      "------\n",
      "3923.769926 25.0 84.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.04306765323515 Celsius, the temperature of water leaving towers 24.2 Celsius, All electricity consumption 299.735205337911 KW\n",
      " total COP 13.090787655645851\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.21811616411807\n",
      "reward(total COP) 13.090787655645851\n",
      "updated Q value 13.222483551970136\n",
      "------\n",
      "3923.769926 25.0 84.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.04306765323515 Celsius, the temperature of water leaving towers 24.2 Celsius, All electricity consumption 299.735205337911 KW\n",
      " total COP 13.090787655645851\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.222483551970136\n",
      "reward(total COP) 13.090787655645851\n",
      "updated Q value 13.222959597246012\n",
      "------\n",
      "3923.769926 26.0 84.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.842747243301904 Celsius, the temperature of water leaving towers 25.0 Celsius, All electricity consumption 299.0249633192177 KW\n",
      " total COP 13.121880803681474\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.222959597246012\n",
      "reward(total COP) 13.121880803681474\n",
      "updated Q value 13.250995319413141\n",
      "------\n",
      "3923.769926 27.0 81.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.24252029862473 Celsius, the temperature of water leaving towers 25.4 Celsius, All electricity consumption 298.521902618156 KW\n",
      " total COP 13.143993427574241\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.250995319413141\n",
      "reward(total COP) 13.143993427574241\n",
      "updated Q value 13.27395257463285\n",
      "------\n",
      "3923.769926 29.0 75.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.742174049299628 Celsius, the temperature of water leaving towers 25.9 Celsius, All electricity consumption 297.7543832808461 KW\n",
      " total COP 13.177874605120573\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.27395257463285\n",
      "reward(total COP) 13.177874605120573\n",
      "updated Q value 13.306947975243498\n",
      "------\n",
      "3923.769926 30.0 71.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.84209645697079 Celsius, the temperature of water leaving towers 26.0 Celsius, All electricity consumption 297.58238695191983 KW\n",
      " total COP 13.185491138069137\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.306947975243498\n",
      "reward(total COP) 13.185491138069137\n",
      "updated Q value 13.317399353563765\n",
      "------\n",
      "3923.769926 32.0 62.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.642248860807197 Celsius, the temperature of water leaving towers 25.8 Celsius, All electricity consumption 297.92021545595105 KW\n",
      " total COP 13.170539367376861\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.317399353563765\n",
      "reward(total COP) 13.170539367376861\n",
      "updated Q value 13.305081960177624\n",
      "------\n",
      "3923.769926 32.0 57.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 26.44292969483871 Celsius, the temperature of water leaving towers 24.6 Celsius, All electricity consumption 299.42939755913596 KW\n",
      " total COP 13.104157300470382\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.305081960177624\n",
      "reward(total COP) 13.104157300470382\n",
      "updated Q value 13.243995504082704\n",
      "------\n",
      "3923.769926 33.0 59.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.642248860807197 Celsius, the temperature of water leaving towers 25.8 Celsius, All electricity consumption 297.92021545595105 KW\n",
      " total COP 13.170539367376861\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.243995504082704\n",
      "reward(total COP) 13.170539367376861\n",
      "updated Q value 13.29708094058419\n",
      "------\n",
      "3923.769926 34.0 58.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.14184699505664 Celsius, the temperature of water leaving towers 26.3 Celsius, All electricity consumption 297.029413042212 KW\n",
      " total COP 13.210038311735739\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.29708094058419\n",
      "reward(total COP) 13.210038311735739\n",
      "updated Q value 13.338416303085841\n",
      "------\n",
      "3923.769926 34.0 59.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.341666783007504 Celsius, the temperature of water leaving towers 26.5 Celsius, All electricity consumption 296.62994299996626 KW\n",
      " total COP 13.227828203440831\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.338416303085841\n",
      "reward(total COP) 13.227828203440831\n",
      "updated Q value 13.358932760133104\n",
      "------\n",
      "3923.769926 33.0 62.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.341666783007504 Celsius, the temperature of water leaving towers 26.5 Celsius, All electricity consumption 296.62994299996626 KW\n",
      " total COP 13.227828203440831\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.358932760133104\n",
      "reward(total COP) 13.227828203440831\n",
      "updated Q value 13.361169053951256\n",
      "------\n",
      "3923.769926 32.0 65.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.241758279442706 Celsius, the temperature of water leaving towers 26.4 Celsius, All electricity consumption 296.8327600979999 KW\n",
      " total COP 13.218790017330162\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.361169053951256\n",
      "reward(total COP) 13.218790017330162\n",
      "updated Q value 13.353278442477833\n",
      "------\n",
      "3923.769926 32.0 69.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 29.04094844496544 Celsius, the temperature of water leaving towers 27.2 Celsius, All electricity consumption 295.0376270067302 KW\n",
      " total COP 13.299218699011885\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.353278442477833\n",
      "reward(total COP) 13.299218699011885\n",
      "updated Q value 13.42480417934078\n",
      "------\n",
      "3923.769926 30.0 73.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.341666783007504 Celsius, the temperature of water leaving towers 26.5 Celsius, All electricity consumption 296.62994299996626 KW\n",
      " total COP 13.227828203440831\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.42480417934078\n",
      "reward(total COP) 13.227828203440831\n",
      "updated Q value 13.368349038644892\n",
      "------\n",
      "3923.769926 29.0 77.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 28.241758279442706 Celsius, the temperature of water leaving towers 26.4 Celsius, All electricity consumption 296.8327600979999 KW\n",
      " total COP 13.218790017330162\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.368349038644892\n",
      "reward(total COP) 13.218790017330162\n",
      "updated Q value 13.354061060809439\n",
      "------\n",
      "3923.769926 28.0 80.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.94201608382068 Celsius, the temperature of water leaving towers 26.1 Celsius, All electricity consumption 297.40422646917204 KW\n",
      " total COP 13.193389927855398\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.354061060809439\n",
      "reward(total COP) 13.193389927855398\n",
      "updated Q value 13.329643590698087\n",
      "------\n",
      "3923.769926 27.0 84.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.84209645697079 Celsius, the temperature of water leaving towers 26.0 Celsius, All electricity consumption 297.58238695191983 KW\n",
      " total COP 13.185491138069137\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.329643590698087\n",
      "reward(total COP) 13.185491138069137\n",
      "updated Q value 13.319873175648315\n",
      "------\n",
      "3923.769926 26.0 87.0\n",
      "need to use Q-learning\n",
      "needs optimization\n",
      "the number of permutation 168 can choose\n",
      "optimal control set：the number of cooling tower 13 , real-time frequency 30 Hz，the number of larger chillers 1 , the number of smaller chillers 1 \n",
      " the temperature of water entering towers 27.442390141358512 Celsius, the temperature of water leaving towers 25.6 Celsius, All electricity consumption 298.2333873446963 KW\n",
      " total COP 13.156709116088772\n",
      "oupdated state 0.6000000000000001 , action 0.30000000000000004 , the inital Q value 13.319873175648315\n",
      "reward(total COP) 13.156709116088772\n",
      "updated Q value 13.292904380625561\n",
      "------\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "Q_table = Q_table_ini()\n",
    "num_ct_lis,f_ct_lis,num_ch_small_lis,num_ch_big_lis,tcws_lis,tcwr_lis,power_cts_lis,power_chillers_small_lis,power_chillers_big_lis,power_chillers_all_lis,power_all_lis,plr_ch_small_lis,plr_ch_big_lis,COP_total_lis,Q_table = train_Q(cal_load[30:120],\n",
    "                                                                                                                                                                                                                                         tout[30:120],\n",
    "                                                                                                                                                                                                                                         hout[30:120],Q_table)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "343.992px",
    "left": "53px",
    "top": "110.267px",
    "width": "383.003px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "position": {
    "height": "331.4px",
    "left": "984.133px",
    "right": "20px",
    "top": "120px",
    "width": "350px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}