FInalScript_copProblem.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "occupational-campus",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-df9d910721ab>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     75\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     76\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 77\u001b[0;31m \u001b[0mcL\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexecute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'DROP TABLE IF EXISTS flowReadings;'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     78\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m'table flowReadings deleted'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     79\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/lib/python3/dist-packages/MySQLdb/cursors.py\u001b[0m in \u001b[0;36mexecute\u001b[0;34m(self, query, args)\u001b[0m\n\u001b[1;32m    245\u001b[0m         \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    246\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 247\u001b[0;31m             \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_query\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mquery\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    248\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    249\u001b[0m             \u001b[0mexc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexc_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/lib/python3/dist-packages/MySQLdb/cursors.py\u001b[0m in \u001b[0;36m_query\u001b[0;34m(self, q)\u001b[0m\n\u001b[1;32m    409\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    410\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_query\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mq\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 411\u001b[0;31m         \u001b[0mrowcount\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_do_query\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mq\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    412\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_post_get_result\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    413\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mrowcount\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/lib/python3/dist-packages/MySQLdb/cursors.py\u001b[0m in \u001b[0;36m_do_query\u001b[0;34m(self, q)\u001b[0m\n\u001b[1;32m    372\u001b[0m         \u001b[0mdb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_db\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    373\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_last_executed\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mq\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 374\u001b[0;31m         \u001b[0mdb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mquery\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mq\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    375\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_do_get_result\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    376\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrowcount\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/lib/python3/dist-packages/MySQLdb/connections.py\u001b[0m in \u001b[0;36mquery\u001b[0;34m(self, query)\u001b[0m\n\u001b[1;32m    290\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_query_result\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    291\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 292\u001b[0;31m             \u001b[0m_mysql\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconnection\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mquery\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mquery\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    293\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    294\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__enter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import time\n",
    "import board\n",
    "import busio\n",
    "import pandas as pd\n",
    "from pandas import DataFrame\n",
    "from matplotlib import pylab\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import *\n",
    "import pylab\n",
    "import numpy as np\n",
    "import matplotlib.colors as clrs\n",
    "import matplotlib.cm as cm\n",
    "import matplotlib\n",
    "from collections import deque\n",
    "import os.path\n",
    "import datetime\n",
    "import time\n",
    "import math\n",
    "import struct\n",
    "from struct import *\n",
    "from pyModbusTCP.client import ModbusClient\n",
    "\n",
    "#matplotlib.use('TkAgg')\n",
    "%matplotlib notebook\n",
    "#%matplotlib inline\n",
    "\n",
    "\n",
    "#import time\n",
    "import sys\n",
    "import sqlite3\n",
    "#from time import sleep\n",
    "\n",
    "#import adafruit_ads1x15.ads1015 as ADS\n",
    "import adafruit_ads1x15.ads1115 as ADS\n",
    "from adafruit_ads1x15.analog_in import AnalogIn\n",
    "\n",
    "import MySQLdb as db\n",
    "\n",
    "HOST = \"10.208.8.122\"\n",
    "PORT = 3306\n",
    "USER = \"yogi\"\n",
    "PASSWORD = \"bittoo\"\n",
    "DB = \"TemaccessToRemoteRp2\"\n",
    "'''\n",
    "try:\n",
    "    connection = db.Connection(host=HOST, port=PORT,\n",
    "                               user=USER, passwd=PASSWORD, db=DB)\n",
    "\n",
    "    c = connection.cursor()\n",
    "    c.execute(\"SELECT * from temSensor\")\n",
    "    result = c.fetchall()\n",
    "    for item in result:\n",
    "        print (item)\n",
    "\n",
    "except Exception as e:\n",
    "    print (e)\n",
    "'''\n",
    "connectionL = db.connect(host=\"10.208.8.121\",\n",
    "                     user=\"yogi\",\n",
    "                     passwd=\"bittoo\",\n",
    "                     db=\"allSensors\")\n",
    "\n",
    "#c = conn.cursor()\n",
    "connectionR = db.Connection(host=HOST, port=PORT,user=USER, passwd=PASSWORD, db=DB)\n",
    "\n",
    "cR = connectionR.cursor()\n",
    "cL =connectionL.cursor()\n",
    "\n",
    "i2c = busio.I2C(board.SCL, board.SDA)\n",
    "\n",
    "# Create the ADC object using the I2C bus\n",
    "ads = ADS.ADS1115(i2c)\n",
    "\n",
    "ads.gain = 1\n",
    "\n",
    "\n",
    "cL.execute('DROP TABLE IF EXISTS flowReadings;')\n",
    "print ('table flowReadings deleted')\n",
    "\n",
    "\n",
    "cL.execute('CREATE TABLE flowReadings(id INT AUTO_INCREMENT PRIMARY KEY,  \\\n",
    "ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP, \\\n",
    "flowHP FLOAT, flowLoad FLOAT, watt FLOAT) ENGINE=MyISAM;')\n",
    "\n",
    "#cvsFileName = import os.path\n",
    "#os.path.exists(file_path)\n",
    "\n",
    "lol=[[], [], [], [], []]\n",
    "flowRateLoad  = []\n",
    "wattMeterKw = []\n",
    "################################\n",
    "##Cop functions, takes Tiem stamp of both Wattmegter and Tem values\n",
    "###\n",
    "###############################\n",
    "def flatten_watt(l_of_l):\n",
    "    '''this to flatten the watt tuple/list  whish is \n",
    "    present in lol[1]\n",
    "    '''\n",
    "    T = l_of_l[1]\n",
    "    flattend_l = [val for sublist in T for val in sublist]\n",
    "    #print ('flattened list is =', flattend_l)\n",
    "    return flattend_l\n",
    "\n",
    "\n",
    "timePeriod_watt = []\n",
    "def timeStampCreator_watt(Lol):\n",
    "    '''calculating timestamp of wattmeter'''\n",
    "    mHP = Lol[2]\n",
    "    T = flatten_watt(Lol)\n",
    "    if len(mHP) == 1:\n",
    "        timeStamp = 2/3600\n",
    "        timePeriod_watt.append(timeStamp)\n",
    "    elif len(mHP) > 1:\n",
    "        timeLast = T[-1][1]\n",
    "        timeSecondLast = T[-2][1]\n",
    "        timeStamp = timeLast -timeSecondLast\n",
    "        timeStamp = timeStamp.total_seconds()/3600\n",
    "        timePeriod_watt.append(timeStamp)\n",
    "    return \n",
    "\n",
    "def flatten_tem(l_of_l):\n",
    "    '''flatting the time lol to calculate time stamp b/w each'''\n",
    "    T = l_of_l[0]\n",
    "    flattend_l = [val for sublist in T for val in sublist]\n",
    "    #print ('flattened list is =', flattend_l)\n",
    "    return flattend_l\n",
    "\n",
    "timePeriod_tem = []\n",
    "def timeStampCreator_cop(Lol):\n",
    "    '''calculatng tem time stamp to calculate accuractly the mCT '''\n",
    "    mHP = Lol[2]\n",
    "    T = flatten_tem(Lol)\n",
    "    if len(mHP) == 1:\n",
    "        timeStamp = 2/3600\n",
    "        timePeriod_tem.append(timeStamp)\n",
    "    elif len(mHP) > 1:\n",
    "        timeLast = T[-1][1]\n",
    "        timeSecondLast = T[-2][1]\n",
    "        timeStamp = timeLast -timeSecondLast\n",
    "        timeStamp = timeStamp.total_seconds()/3600\n",
    "        timePeriod_tem.append(timeStamp)\n",
    "    return \n",
    "\n",
    "\n",
    "#@@@@@@@@@@@@@@@@@@\n",
    "###@@@@@@@@@@@@@@@@\n",
    "###COP@@@@@@@@@@@@@\n",
    "#@@@@@@@@@@@@@@@@@@\n",
    "#@@@@@@@@@@@@@@@@@@\n",
    "\n",
    "\n",
    "copPlotterList = []\n",
    "def Cop(Lol, time_stamp_tem, time_stamp_watt):\n",
    "    '''this function takes both time stamp Tem and Watt\n",
    "     because both Tem and watt are running at different timetamps\n",
    "    '''\n",
    "    mHP = Lol[2]\n",
    "    T = flatten_tem(Lol)\n",
    "    mL = Lol[3]\n",
    "    watt_kW = Lol[4]\n",
    "    p_LperH = [999.8473664794213 + 6.29265190e-02*x[2] - 8.42930922e-03*x[2]**2 + 6.77190849e-05*x[2]**3 \\\n",
    " - 4.40840180e-07*x[2]**4 + 1.29302849e-09*x[2]**5 for x in T]\n",
    "    mF_kgPerS =[ x*2.7777e-07*y for x, y in zip(p_LperH, mHP)]\n",
    "    cP_kjPerkgK = [4.253264761904763 - 0.00470305*b[2] for b in T]\n",
    "    mCT_kW = [c*a*(b[3]-b[4]) for c, a, b in zip(cP_kjPerkgK,mF_kgPerS, T)]\n",
    "    mCT_kWh_l = [x*y for x,y in zip (time_stamp_tem, mCT_kW)]\n",
    "    mCT_kWh = sum(mCT_kWh_l)\n",
    "    #electricty consumed:\n",
    "    watt_kW_l = [x*y for x,y in zip (time_stamp_watt,  watt_kW)]\n",
    "    watt_kWh = sum(watt_kW_l)\n",
    "    #cop \n",
    "    \n",
    "    #print ('XXXXXXXXXXXXXXXXXXX watt_kW is:',  watt_kW)\n",
    "    #print ('XXXXXXXXXXXXXXXXXXX mCT_kW is:',  mCT_kW)\n",
    "    ccop_list = [x/y for x, y in zip(mCT_kW, watt_kW)]\n",
    "    #print ('XXXXXXXXXXXXXXXXXX COP is:', ccop_list)\n",
    "    cop_lastValue = ccop_list[-1]\n",
    "    print ('XXXXXXXXXXXXXXXXXX COP with kW is:', cop_lastValue)\n",
    "    #copPlotterList.append(cop_lastValue)\n",
    "    \n",
    "    cop =mCT_kWh/watt_kWh\n",
    "    copPlotterList.append(cop)\n",
    "    \n",
    "    \n",
    "    #print ('cop of system is:', cop)\n",
    "    #print ('kwh heat addition is :', mCT_kWh)\n",
    "    #print ('whole kW list is:', mCT_kW)\n",
    "    print ('electricity in khW is:', watt_kWh)\n",
    "    \n",
    "    #print ('electricity consumption kW :', watt_kW)\n",
    "    return cop\n",
    "############################################################\n",
    "\n",
    "def MCT_timeStamp(Lol, time_stamp_tem):\n",
    "    mHP = Lol[2]\n",
    "    T = flatten_tem(Lol)\n",
    "    mL = Lol[3]\n",
    "    watt_kW = Lol[4]\n",
    "    p_LperH = [999.8473664794213 + 6.29265190e-02*x[2] - 8.42930922e-03*x[2]**2 + 6.77190849e-05*x[2]**3 \\\n",
    " - 4.40840180e-07*x[2]**4 + 1.29302849e-09*x[2]**5 for x in T]\n",
    "    mF_kgPerS =[ x*2.7777e-07*y for x, y in zip(p_LperH, mHP)]\n",
    "    cP_kjPerkgK = [4.253264761904763 - 0.00470305*b[2] for b in T]\n",
    "    mCT_kW = [c*a*(b[3]-b[4]) for c, a, b in zip(cP_kjPerkgK,mF_kgPerS, T)]\n",
    "    mCT_kWh_l = [x*y for x,y in zip (time_stamp_tem, mCT_kW)]\n",
    "    mCT_kWh = sum(mCT_kWh_l)\n",
    "    print ('heat addition in kwh is:', mCT_kWh)\n",
    "    return mCT_kW\n",
    "\n",
    "l_id = []\n",
    "def idGenerator(Id, l_id):\n",
    "    if Id not in l_id:\n",
    "       l_id.append(Id) \n",
    "    #print (l_id)\n",
    "    return l_id\n",
    "\n",
    "#df_conc= None\n",
    "def dfs(Lol):\n",
    "    mHP = Lol[2]\n",
    "    T = flatten_tem(Lol)\n",
    "    mL = Lol[3]\n",
    "    StartTemTestingtank = [ 'id', 'dateTime', 'Tamb', 'TtopTestTankHPCir', 'TbottomTestTankHpCir', 'TtopSourceTank', \\\n",
    "'TloadTankMix','TTopTestTankLoadCir', 'TloadMix', 'TbottomSourceTank', 'TbottomTestTankLoadCir']\n",
    "    l_T = ['T{}'.format(x) for x in range(0,10)]\n",
    "    L = StartTemTestingtank +l_T\n",
    "    df_mHP = DataFrame(mHP, columns=['flowHP'])\n",
    "    df_mL = DataFrame(mL, columns=['flowLoad'])\n",
    "    df_tem = DataFrame(T, columns = L)\n",
    "    df_conc = pd.concat([df_tem, df_mHP, df_mL], axis=1)\n",
    "    return df_conc\n",
    "\n",
    "def list2df(lis, column_name = None):\n",
    "    df  = pd.DataFrame(lis, columns = [column_name]) \n",
    "    return df\n",
    "\n",
    "\n",
    "def toCsv(df_full, load_kW, heatCapacity_kW, electrictyUsed_kW, COP, nDis, timePeriod_tem, timePeriod_watt ,\\\n",
    "         entropy_kjPerK, entropy_kJ, nStratCharging, TankEnergyTotal_kJ,\\\n",
    "         DisEntropy_kjPerK, DisEntropy_kJ, nStratDis, DisTankEnergyTotal_kJ):\n",
    "    df_Tem_Flow_Load_capacity_conc = pd.concat([df_full, load_kW, heatCapacity_kW, electrictyUsed_kW, \\\n",
    "                                                COP, nDis, timePeriod_tem , \\\n",
    "                                                timePeriod_watt, entropy_kjPerK,\\\n",
    "                                               entropy_kJ,nStratCharging, \\\n",
    "                                               TankEnergyTotal_kJ, \\\n",
    "                                               DisEntropy_kjPerK, \\\n",
    "                                                DisEntropy_kJ, \\\n",
    "                                                nStratDis, \\\n",
    "                                                DisTankEnergyTotal_kJ], axis=1)\n",
    "\n",
    "    file_name = 'csvFile_{}'.format(datetime.datetime.now().strftime(\"%Y_%m_%d\"))\n",
    "    suffix = '.csv'\n",
    "    filePath = os.path.join(os.getcwd(), file_name + suffix)\n",
    "    df_Tem_Flow_Load_capacity_conc.to_csv(filePath, header=True, na_rep=np.nan)\n",
    "    #print ('gross df with NAN is: ', df_Tem_Flow_Load_capacity_conc )\n",
    "    return df_Tem_Flow_Load_capacity_conc\n",
    "\n",
    "def Load_kWh(Lol, time_stamp_tem):\n",
    "    \n",
    "    #mHP = Lol[2]\n",
    "    T = flatten_tem(Lol)\n",
    "    #d = [x[10] for x in T]\n",
    "    #print ('XXXXTem tem diagnosis is :', d)\n",
    "    mL = Lol[3]\n",
    "    #this is density as polynomial function of T\n",
    "    p_LperH = [999.8473664794213 + 6.29265190e-02*x[7] - 8.42930922e-03*x[7]**2 + 6.77190849e-05*x[7]**3 \\\n",
    " - 4.40840180e-07*x[7]**4 + 1.29302849e-09*x[7]**5 for x in T]\n",
    "    #print ('denisty is:', p_LperH )\n",
    "    #print ('Tem is:', [x[10] for x in T])\n",
    "    # this is mass flow  in kg/S =  density*V(flow rate in m^3/sec)= d * (1000^-3/3600)\n",
    "    mF_kgPerS =[ x*2.7777e-07*y for x, y in zip(p_LperH, mL)]\n",
    "    #this is Cp as functiono of T linear function\n",
    "    cP_kjPerkgK = [4.253264761904763 - 0.00470305*b[7] for b in T]\n",
    "    #print ('Cp if load function is:')\n",
    "    #print ('Cp is:', cP_kjPerkgK)\n",
    "    #Cp*M*deltaT\n",
    "    load_mCT_kW = [c*a*(b[7]-b[10]) for c, a, b in zip(cP_kjPerkgK,mF_kgPerS, T)]\n",
    "    load_mCT_kW_l = [x*y for x,y in zip (time_stamp_tem, load_mCT_kW )]\n",
    "    load_mCT_kWh = sum(load_mCT_kW_l)\n",
    "    print ('Load in kWh is:', load_mCT_kWh)\n",
    "    #print ('Load in kW:', load_mCT_kW)\n",
    "    return load_mCT_kW\n",
    "\n",
    "def tankStrat(df):\n",
    "    dfT = df.iloc[:, 11:-2]\n",
    "    #print (dfT.columns)\n",
    "    #print (dfT)\n",
    "    dfT = dfT[['T4', 'T3', 'T2', 'T1', 'T0', 'T9', 'T8', 'T7', 'T6', 'T5']]\n",
    "    dfT = dfT.rename({'T4':'T0', 'T3':'T1', 'T2':'T2', 'T1':'T3', 'T0':'T4', 'T9':'T5', 'T8':'T6',\\\n",
    "              'T7':'T7','T6':'T8','T5':'T9'}, axis='columns')\n",
    "\n",
    "    return dfT\n",
    "#tankStratTem = tankStrat(df_conc)\n",
    "\n",
    "def create_color_step_obj(cmap_name, n):\n",
    "    \"\"\"\n",
    "    Return scalarMap object with n colors in gradient from color map\n",
    "    given in cmap_name.\n",
    "    \"\"\"\n",
    "    cmap = plt.get_cmap(cmap_name)\n",
    "    values = range(n)\n",
    "    cNorm  = clrs.Normalize(vmin=values[0], vmax=values[-1])\n",
    "    scalarMap = cm.ScalarMappable(norm=cNorm, cmap=cmap)\n",
    "    return scalarMap\n",
    "\n",
    "#import logging\n",
    "#logging.getLogger().setLevel(logging.CRITICAL)\n",
    "\n",
    "# colors\n",
    "cmap_name = \"jet\"\n",
    "scm = create_color_step_obj(cmap_name, 10)\n",
    "plt.ion()\n",
    "#plt.rcParams[\"figure.figsize\"]=5,5\n",
    "fig_size = plt.rcParams[\"figure.figsize\"]\n",
    "fig_size[0] = 8\n",
    "fig_size[1] = 3\n",
    "def plotObject(df, ax, fig, alpha =0.7, scm=None):\n",
    "    ax.clear()\n",
    "    for i in range (0, df.shape[1]):\n",
    "        ax.plot(df.index, df.iloc[:, i], color= scm.to_rgba(i, alpha=alpha),\\\n",
    "                label = 'Layer ' + str(i))\n",
    "        ax.legend(bbox_to_anchor=(0.4,0.8))\n",
    "    fig.canvas.draw()\n",
    "    ax.legend()\n",
    "    #plt.legend(loc='upper left')\n",
    "    return fig, ax\n",
    "    \n",
    "# initialize figure and interactivity\n",
    "fig = plt.figure(1)\n",
    "fig2 = plt.figure(2)\n",
    "fig3 = plt.figure(3)\n",
    "fig4 = plt.figure(4)\n",
    "\n",
    "#Figure 1 and 2 axes initialise\n",
    "ax = fig.add_subplot(121)\n",
    "ax_2 = fig.add_subplot(122)\n",
    "ax2 = fig2.add_subplot(122)\n",
    "ax2_1 = fig2.add_subplot(121)\n",
    "axTwin = ax2.twinx()\n",
    "\n",
    "#Figure 3 axis initialies\n",
    "ax3 = fig3.add_subplot(122)\n",
    "ax3_1 = fig3.add_subplot(121)\n",
    "ax3Twin = ax3.twinx()\n",
    "fig.canvas.draw()\n",
    "#plt.ion()\n",
    "\n",
    "#Figure 4 Axes initialise\n",
    "ax4 = fig4.add_subplot(122)\n",
    "ax4_1 = fig4.add_subplot(121)\n",
    "ax4Twin = ax4.twinx()\n",
    "\n",
    "#fig.show()\n",
    "\n",
    "ax.legend(loc='best')\n",
    "ax.set_xlabel('Index')\n",
    "ax.set_ylabel('Tem, C', color='r')\n",
    "#################################\n",
    "#Plot for HPin, Hpout, TmixL tem.\n",
    "\n",
    "fig.show()\n",
    "fig.canvas.draw()\n",
    "ax_2.legend(loc='best')\n",
    "ax_2.set_xlabel('Index')\n",
    "ax_2.set_ylabel('Load in kW', color='r')\n",
    "def plotObject_Tem_HpAndLoad(df, ax_2, fig):\n",
    "    ax_2.clear()\n",
    "    ax_2.plot(df.index, df.iloc[:, 3], label = 'Hp to Testing tank top')\n",
    "    ax_2.plot(df.index, df.iloc[:, 4], label = 'Testing tank to HP Bottom')\n",
    "    ax_2.plot(df.index, df.iloc[:, 8], label = 'load tem Mixed')\n",
    "    \n",
    "    ax_2.legend(bbox_to_anchor=(0.4,0.8))\n",
    "    fig.canvas.draw()\n",
    "    ax_2.legend()\n",
    "    fig.savefig('Temperatures3.png')\n",
    "    #plt.legend(loc='upper left')\n",
    "    return fig, ax_2\n",
    "##################################\n",
    "\n",
    "#fig2 = plt.figure(2)\n",
    "\n",
    "#plt.ion()\n",
    "\n",
    "fig2.show()\n",
    "fig2.canvas.draw()\n",
    "ax2.legend(loc='best')\n",
    "ax2.set_xlabel('Index')\n",
    "ax2.set_ylabel('Load in kW', color='r')\n",
    "def plotObject_Load(df, ax2, fig2):\n",
    "    ax2.clear()\n",
    "    axTwin.clear()\n",
    "    ax2.plot(df.index, df.iloc[:, -15],label = 'Load in kW')\n",
    "    #axTwin.plot(df.index, Nan2Zero(df).iloc[:, -11]*100, label = 'Discharge Efficiency', color = 'b')\n",
    "    axTwin.plot(df.index, df.iloc[:, -11]*100, label = 'Discharge Efficiency', color = 'b')\n",
    "    axTwin.set_ylabel('nDischarge',color ='b')\n",
    "    #ax2.plot(df.index, COP, label = 'cop')\n",
    "    #print (df.index)\n",
    "    ax2.legend(bbox_to_anchor=(0.4,0.8))\n",
    "    fig2.canvas.draw()\n",
    "    ax2.legend()\n",
    "    fig2.savefig('LoadNDiscCopHeatCapacityAndElectricty.png')\n",
    "    #plt.legend(loc='upper left')\n",
    "    return fig2, ax2\n",
    "    \n",
    "# initialize figure and interactivity\n",
    "####Plot for heat_Capacity:\n",
    "\n",
    "def Nan2Zero(df):\n",
    "    #df.replace('NaN', 0)\n",
    "     return df.fillna(0) \n",
    "\n",
    "fig2.show()\n",
    "fig2.canvas.draw()\n",
    "ax2_1.legend(loc='best')\n",
    "ax2_1.set_xlabel('Index')\n",
    "ax2_1.set_ylabel('Heat_Capacity in kW', color='r')\n",
    "def plotObject_Heat_Capacity(df, ax2_1, fig2):\n",
    "    ax2_1.clear()\n",
    "    #axTwin = ax2_1.twinx()\n",
    "    #axTwin.clear()\n",
    "    \n",
    "    ax2_1.plot(df.index, df.iloc[:, -14], label = 'heat_Capacity in kW')\n",
    "    ax2_1.plot(df.index, df.iloc[:, -13], label = 'electrcity_kW')\n",
    "    ax2_1.plot(df.index, df.iloc[:, -12], label = 'cop of system')\n",
    "    #axTwin.plot(df.index, Nan2Zero(df).iloc[:, -2]*100, label = 'Discharge Efficiency', color = 'b')\n",
    "    #axTwin.set_ylabel('nDischarge',color ='b')\n",
    "    \n",
    "    ax2_1.legend(bbox_to_anchor=(0.4,0.8))\n",
    "    plt.subplots_adjust(wspace = 0.5)\n",
    "    fig2.canvas.draw()\n",
    "    ax2_1.legend()\n",
    "    fig2.tight_layout()\n",
    "    #plt.legend(loc='upper left')\n",
    "    return fig2, ax2_1\n",
    "\n",
    "###########################################\n",
    "##########################################\n",
    "###########################################\n",
    "###########################################\n",
    "###########################################\n",
    "#########Discharging Strat Efficiency plots\n",
    "###########################################\n",
    "###########################################\n",
    "###########################################\n",
    "###########################################\n",
    "\n",
    "'''\n",
    "def refineDF_Discharge(df):\n",
    "    #this function refine -ve or >100 values frrom nStrat\n",
    "    #dropped_df = df.loc[((df<110) | (df>0)).any(1)]\n",
    "    #refined_df = df['nStratCharging'].where(df['nStratCharging'] >=110, 0.01, inplace=True)\n",
    "    #df.loc[df['nStratDischarge'] > 1.5] = 0.1\n",
    "    df.loc[df['nStratDischarge'] < -0.1] = 0.1\n",
    "    df_refined  = df['nStratDischarge']\n",
    "    #print ('refined df is:', df_refined)\n",
    "    #df.loc[df['nStratCharging'] > 110] = 0.1\n",
    "    #if refined_df\n",
    "    return df_refined\n",
    "'''\n",
    "\n",
    "fig4.show()\n",
    "fig4.canvas.draw()\n",
    "ax4.legend(loc='best')\n",
    "ax4.set_xlabel('Index')\n",
    "ax4.set_ylabel('Entropy_kJ', color='r')\n",
    "def plotObject_entropy_Discharge(df, ax4, ax4_1,  fig4):\n",
    "    ax4.clear()\n",
    "    ax4Twin.clear()\n",
    "    ax4_1.clear()\n",
    "    y1 = df.iloc[:, -3]\n",
    "    y2= df.iloc[:,  -4]\n",
    "    y3 = df.iloc[:, -1]\n",
    "    #print ('Figure: Discharge entropy is:', y1)\n",
    "    #print ('Figure: Discharge availability  is:', y3)\n",
    "    #y3_1 =refineDF_Discharge(df)\n",
    "    y3_1 =df['nStratDischarge']\n",
    "    #print ('Figure: Discharge Start Efficiency is:', y3_1)\n",
    "    #print ('Values of refiend df are:', y3_1)\n",
    "    #y3_1 = Nan2Zero(df.iloc[:, -2])\n",
    "    #ax3.plot(df.index, y1, label = 'entropy in kJ')\n",
    "    ax4.plot(df.index, y1, label = ' Discharging entropy in kJ')\n",
    "    ax4.plot(df.index, y2, label = 'Discharging Entropy in KJ/K')\n",
    "    #ax3.plot(df.index, y3, label = 'Availability kJ')\n",
    "    ax4Twin.plot(df.index, y3, label = 'Discharging Availability kJ', color = 'g')\n",
    "    #ax3.plot(df.index, df.iloc[:, 8], label = 'load tem Mixed')\n",
    "    ax4Twin.set_ylabel('Dishcarging availibility',color ='g')\n",
    "    ax4.legend(bbox_to_anchor=(0.4,0.8))\n",
    "    ax4Twin.legend(bbox_to_anchor=(0.4,0.8))\n",
    "    ax4.legend()\n",
    "    #Plot strt eff on first fig object of fig3\n",
    "\n",
    "    ax4_1.plot(df.index, y3_1, label = 'Disch_econdLawStratificationEff ')\n",
    "    #ax3_1.set_ylabel('secondLawStratificationEff')\n",
    "    ax4_1.legend(bbox_to_anchor=(0.4,0.8))\n",
    "    ax4_1.legend()\n",
    "\n",
    "    fig4.canvas.draw()\n",
    "    fig4.savefig('Disch_EntropyExergyAvailability.png')\n",
    "    #plt.legend(loc='upper left')\n",
    "    return fig4, ax4\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "############################\n",
    "##Exergy/Entropy/nStrt plots for charging\n",
    "#############################\n",
    "\n",
    "def refineDF(df):\n",
    "    #this function refine -ve or >100 values frrom nStrat\n",
    "    #dropped_df = df.loc[((df<110) | (df>0)).any(1)]\n",
    "    #refined_df = df['nStratCharging'].where(df['nStratCharging'] >=110, 0.01, inplace=True)\n",
    "    df.loc[df['nStratCharging'] > 1.5] = 0.1\n",
    "    df.loc[df['nStratCharging'] < -0.1] = 0.1\n",
    "    df_refined  = df['nStratCharging']\n",
    "    #df.loc[df['nStratCharging'] > 110] = 0.1\n",
    "    #if refined_df\n",
    "    return df_refined\n",
    "\n",
    "fig3.show()\n",
    "fig3.canvas.draw()\n",
    "ax3.legend(loc='best')\n",
    "ax3.set_xlabel('Index')\n",
    "ax3.set_ylabel('Entropy_kJ', color='r')\n",
    "def plotObject_entropy(df, ax3, ax3_1,  fig3):\n",
    "    ax3.clear()\n",
    "    ax3Twin.clear()\n",
    "    ax3_1.clear()\n",
    "    y1 = df.iloc[:, -7]\n",
    "    y2= df.iloc[:,  -8]\n",
    "    y3 = df.iloc[:, -5]\n",
    "    \n",
    "    y3_1 =refineDF(df)\n",
    "    #print ('Values of refiend df are:', y3_1)\n",
    "    #y3_1 = Nan2Zero(df.iloc[:, -2])\n",
    "    #ax3.plot(df.index, y1, label = 'entropy in kJ')\n",
    "    ax3.plot(df.index, y1, label = ' Charging entropy in kJ')\n",
    "    ax3.plot(df.index, y2, label = 'Charging Entropy in KJ/K')\n",
    "    #ax3.plot(df.index, y3, label = 'Availability kJ')\n",
    "    ax3Twin.plot(df.index, y3, label = 'Chanrging Availability kJ', color = 'g')\n",
    "    #ax3.plot(df.index, df.iloc[:, 8], label = 'load tem Mixed')\n",
    "    ax3Twin.set_ylabel('Charging availibility',color ='g')\n",
    "    ax3.legend(bbox_to_anchor=(0.4,0.8))\n",
    "    ax3Twin.legend(bbox_to_anchor=(0.4,0.8))\n",
    "    ax3.legend()\n",
    "    #Plot strt eff on first fig object of fig3\n",
    "\n",
    "    ax3_1.plot(df.index, y3_1, label = 'secondLawStratificationEff_charging ')\n",
    "    #ax3_1.set_ylabel('secondLawStratificationEff')\n",
    "    ax3_1.legend(bbox_to_anchor=(0.4,0.8))\n",
    "    ax3_1.legend()\n",
    "\n",
    "    fig3.canvas.draw()\n",
    "    fig3.savefig('entropyExergyAvailability.png')\n",
    "    #plt.legend(loc='upper left')\n",
    "    return fig3, ax3\n",
    "\n",
    "\n",
    "#######################\n",
    "###Discharge efficiency\n",
    "#######################\n",
    "def densityFumction(temVlaue):\n",
    "    #tcalculating density at a specific temp.\n",
    "    return temVlaue.map(lambda x: 999.8473664794213 + 6.29265190e-02*x - \\\n",
    "    8.42930922e-03*x**2 + 6.77190849e-05*x*3 \\\n",
    "    - 4.40840180e-07*x**4 + 1.29302849e-09*x**5)\n",
    "\n",
    "def flowCubeMeterPerSec(flow):\n",
    "    return flow.map(lambda x: x*0.001*0.000277777778)\n",
    "\n",
    "def specificHeatkJPerKgK(temValue):\n",
    "    return temValue.map(lambda x: 4.253264761904763 - 0.00470305*x)\n",
    "\n",
    "def dfMultiplication(df1_p_hot, cp_df_hot, df1_p_cold, cp_df_cold, df_V,  Tin, Tout, timeStamp_tem):\n",
    "    \n",
    "    #df_V_litersPerH =  df_V.map(lambda x: x*1000*3600)\n",
    "    #if df_V_litersPerH.iloc[-1] > 5:\n",
    "    \n",
    "    #Hot side p*V*Cp*T_hot in kj/sec, I will convert it to kwh by multiplying by timeStamp.Then to KJ\n",
    "    #Finally because I need to divide teh net energy extraccted by total energy mstore*C*dT which is \n",
    "    #in kJ.\n",
    "    #deltaT_df = Tout.subtract(Tin)\n",
    "    l2df_timeStamp_df= pd.DataFrame(timeStamp_tem)\n",
    "    #print ('type of timestamp object is:', type (l2df_timeStamp_df))\n",
    "    pcp_df_hot = df1_p_hot.multiply( cp_df_hot)\n",
    "    pVCp_df_hot = pcp_df_hot.multiply(df_V)\n",
    "    pCpVT_df_hot = pVCp_df_hot.multiply(Tout)\n",
    "    \n",
    "    #Cold side pCpVT_df_cold is in kJ/s:\n",
    "    # I am seperating hot from cold becasue density, Cp are funstion of temp.otherwise I would have\n",
    "    # only done pVCp [Thot -Tcold] without any problem, however, p&Cp are function of Thot and Tcold\n",
    "    #So I calculate them during hot and during cold side and just subtract them\n",
    "    pcp_df_cold = df1_p_cold.multiply(cp_df_cold)\n",
    "    pVCp_df_cold = pcp_df_cold.multiply(df_V)\n",
    "    pCpVT_df_cold = pVCp_df_cold.multiply(Tin)\n",
    "    \n",
    "    pVCpDeltaT_df_kJPersec = pCpVT_df_hot.subtract( pCpVT_df_cold )\n",
    "    #convert pandas series to pandas dataframe.otherwise it will not multiply with other PD series in\n",
    "    #next step:\n",
    "    pVCpDeltaT_df_kJPersec = pVCpDeltaT_df_kJPersec.to_frame()\n",
    "    #print ('type of timestamp object is:', type (pVCpDeltaT_df_kJPersec))\n",
    "    # convert the kJ/sec to kwH, as energy = power in time, \n",
    "    pVCpDeltaT_df_kWh = pVCpDeltaT_df_kJPersec.multiply(l2df_timeStamp_df, fill_value=0)\n",
    "    #pVCpDeltaT_sum  = pVCpDeltaT_df.sum()\n",
    "    pVCpDeltaT_df_kWh_sum  = pVCpDeltaT_df_kWh.sum()\n",
    "    #convert kwh to kJ as I need to divide mstore * C *DeltaT = kJ to calculate teh discharge\n",
    "    #efficiency, so energy taken out must be in kJ instead of kwh. To make sense \n",
    "    pVCpDeltaT_df_kJ_sum = pVCpDeltaT_df_kWh_sum*3600\n",
    "    pVCpDeltaT_df_kJ_sum  = pd.to_numeric(pVCpDeltaT_df_kJ_sum)\n",
    "    #print ('flow lools like this:',df_V)\n",
    "    print ('Total sum discharge in kJ is :',pVCpDeltaT_df_kJ_sum )\n",
    "    #print ('discharge in kJ/sec:',pVCpDeltaT_df_kJPersec ,'tiem df is',  l2df_timeStamp_df\\\n",
    "    #       , 'multiplied df is:', pVCpDeltaT_df_kWh)\n",
    "    #print ('multiplied df is :', )\n",
    "    #pVCpDeltaT = pVCp.multiply(deltaT_df)\n",
    "    return pVCpDeltaT_df_kJ_sum\n",
    "\n",
    "def TankVolumeDischarged(Lol,timeStamp):\n",
    "    mLoad = Lol[3]\n",
    "    #print ('len of Mload is:', len (mLoad))\n",
    "    #print ('len of tiem stamp is:', len (timeStamp))\n",
    "    litersDischarged = sum([x*y for x, y in zip (mLoad , timeStamp)])\n",
    "    print ('liters discharged is :',litersDischarged )\n",
    "    return litersDischarged\n",
    "\n",
    "nDischargePlotterList = []\n",
    "def nDicharge(df_conc_all, gross_DF):\n",
    "    '''\n",
    "    T_initial should be average tem of tank i.e. mean of 10 sensors just before the discharge\n",
    "    initiates \n",
    "\n",
    "    '''\n",
    "    df_flowGreaterThan5 = df_conc_all.loc[(df_conc_all['flowLoad']>0.5)&(df_conc_all['flowLoad']<5)]\n",
    "    #print ('df for just before discharge starts is:', df_flowGreaterThan5['flowLoad'], df_flowGreaterThan5['id'] )\n",
    "    df_flowGreaterThan5_temValues = df_flowGreaterThan5.iloc[-1, -12:-2]\n",
    "    #print ('df for just before discharge starts is:', df_flowGreaterThan5_temValues, df_flowGreaterThan5.iloc[-1]['id'] )\n",
    "    df_flowGreaterThan5_mean  = df_flowGreaterThan5_temValues.mean()\n",
    "    T_inlet = df_conc_all['TbottomTestTankLoadCir']\n",
    "    T_inlet_lastValue  =  T_inlet.iloc[-1]\n",
    "    cP_kjPerkgK = 4.253264761904763 - 0.00470305*df_flowGreaterThan5_mean \n",
    "    p_LperH = 999.8473664794213 + 6.29265190e-02*df_flowGreaterThan5_mean - \\\n",
    "    8.42930922e-03*df_flowGreaterThan5_mean**2 + 6.77190849e-05*df_flowGreaterThan5_mean**3 \\\n",
    " - 4.40840180e-07*df_flowGreaterThan5_mean**4 + 1.29302849e-09*df_flowGreaterThan5_mean**5 \n",
    "    \n",
    "    mcT_kJ = 0.397*p_LperH*cP_kjPerkgK*(df_flowGreaterThan5_mean-T_inlet_lastValue)\n",
    "    #mcT_kJ shoudl be constant throught the discharge process, as its the energy content of tank \n",
    "    #from very begineening of tank.\n",
    "    flowLoad  = df_conc_all['flowLoad']\n",
    "    T_out  = df_conc_all['TTopTestTankLoadCir']\n",
    "    #T_inlet = df_conc_all['TbottomTestTankLoadCir']\n",
    "    if not abs(T_out.iloc[-1]-T_inlet.iloc[-1]) <  0.8*abs(df_flowGreaterThan5_mean-T_inlet.iloc[-1]):\n",
    "        print ('OK ok oK oK ok if not small run ')\n",
    "\n",
    "        numerator = dfMultiplication(densityFumction(gross_DF['TTopTestTankLoadCir']), \\\n",
    "                         specificHeatkJPerKgK(gross_DF['TTopTestTankLoadCir']), \\\n",
    "                         densityFumction(gross_DF['TbottomTestTankLoadCir']),\\\n",
    "                         specificHeatkJPerKgK(gross_DF['TbottomTestTankLoadCir']),\\\n",
    "                         flowCubeMeterPerSec(gross_DF ['flowLoad']), \\\n",
    "                         gross_DF['TbottomTestTankLoadCir'], \\\n",
    "                         gross_DF['TTopTestTankLoadCir'], timePeriod_tem)\n",
    "        denominator = mcT_kJ\n",
    "        dischargeEfficiency =  numerator/denominator\n",
    "        dischargeEfficiency= dischargeEfficiency.to_numpy()[0]\n",
    "        print('type of nDis now is ', dischargeEfficiency)\n",
    "        #dischargeEfficiency = pd.to_numeric(dischargeEfficiency)\n",
    "        nDischargePlotterList.append(dischargeEfficiency)\n",
    "        print ('energy content of tank from the begineening of discharge in kJ, Inlet, mean, cp, p:' \\\n",
    "               , denominator, T_inlet_lastValue, df_flowGreaterThan5_mean, cP_kjPerkgK,p_LperH )\n",
    "        #print ('energy content of tank from the begineening of discharge in kJ:', denominator)\n",
    "        print ('energy/sec discharged from tank in kJ/sec:', numerator)\n",
    "        print ('discharge efficiency is:', dischargeEfficiency)\n",
    "\n",
    "        return dischargeEfficiency\n",
    "        \n",
    "###########################################\n",
    "###########################################\n",
    "#########Exergy calculation for discharge##\n",
    "###########################################\n",
    "###########################################\n",
    "\n",
    "\n",
    "def mcTForExergyDischarging (l_load_kwh, time_stamp_tem):\n",
    "    load_mCT_kW_l = [x*y for x,y in zip (l_load_kwh, time_stamp_tem )]\n",
    "    load_kwh_total = sum(load_mCT_kW_l)\n",
    "    load_kJ_total = load_kwh_total*3600\n",
    "    print ('Discharging: load_kJ_total mul 3600:',load_kJ_total)\n",
    "    return load_kJ_total\n",
    "\n",
    "\n",
    "DisEntropyPlotter_SUMList_KjPerK = []\n",
    "DisEntropyPlotter_SUMList_Kj = []\n",
    "DisMCTPlotterList_TankEnergyKJ = []\n",
    "def entropyDischarging(Df_conc):\n",
    "\n",
    "    mL =Df_conc['flowLoad']\n",
    "    T =Df_conc.iloc[: ,11:-2]\n",
    "    T_Load_out_df =  Df_conc['TTopTestTankLoadCir']\n",
    "    T_Load_in_df =  Df_conc['TbottomTestTankLoadCir']\n",
    "    T = T[['T4', 'T3', 'T2', 'T1', 'T0', 'T9', 'T8', 'T7', 'T6', 'T5']]\n",
    "    T = T.rename({'T4':'T0', 'T3':'T1', 'T2':'T2', 'T1':'T3', 'T0':'T4', 'T9':'T5', 'T8':'T6',\\\n",
    "              'T7':'T7','T6':'T8','T5':'T9'}, axis='columns')\n",
    "    df_density_columns = ['d{}'.format(x) for x in range(0,10)]\n",
    "    df_density = T.apply(lambda x: 999.8473664794213 + 6.29265190e-02*x - \\\n",
    "                         8.42930922e-03*x**2 + 6.77190849e-05*x**3 \\\n",
    "                         - 4.40840180e-07*x**4 + 1.29302849e-09*x**5)\n",
    "    #0.397/10 is probably mass of each layer which are 10 layers\n",
    "    #It is volume of each layer which multiply by density to give mass\n",
    "    df_m_kg = df_density.multiply(0.397/10, axis =1) \n",
    "    df_heatCapacity_kJPerkgK = T.apply(lambda x: 4.253264761904763 - 0.00470305*x)\n",
    "    #T0_ambient_df =pd.DataFrame([np.random.uniform(24, 26) for _ in range(T.shape[0])])\n",
    "    T0_ambient_df = np.random.uniform(21, 22)\n",
    "    #log [TinLoad/Ti(h)], Ti is the tanks stratified temperatures in height \n",
    "    df_Logvalues = T.apply(lambda x: np.log(T_Load_out_df/x))\n",
    "    #cpxLog[Tinlet/Ti]\n",
    "    lnT_Mul_Cp_df = df_Logvalues.multiply(df_heatCapacity_kJPerkgK, axis =1)\n",
    "    #mcpln[Tinlet/Ti]\n",
    "    mass_mul_lnT_and_cp_df = lnT_Mul_Cp_df.multiply(df_m_kg, axis =1)\n",
    "    #Tambient*DeltaS\n",
    "    entropy_df = mass_mul_lnT_and_cp_df.multiply(T0_ambient_df, axis =0)\n",
    "    #entropy sum for all teh columns, This si not time wise, so each tiem has one single value of tank\n",
    "    entropy_sum_heightWise = entropy_df.sum(axis = 1)\n",
    "    #print ('Entropy sum whole height wise is  :', entropy_sum_heightWise )\n",
    "    #print ('Entropy sum whole height wise is  :', entropy_sum_heightWise.iloc[0] )\n",
    "    \n",
    "    \n",
    "    entropy_sum_kjPerK = mass_mul_lnT_and_cp_df.sum(axis = 1)\n",
    "    entropyLastValue_kJPerK = entropy_sum_kjPerK.iloc[-1]\n",
    "    DisEntropyPlotter_SUMList_KjPerK.append(entropyLastValue_kJPerK)\n",
    "    #print ('entropy list kJ/k is :', DisEntropyPlotter_SUMList_KjPerK)\n",
    "    \n",
    "    DisEntropyPlotter_SUMList_Kj.append(entropy_sum_heightWise.iloc[-1])\n",
    "    #print ('Entropy sum whole height wise is  :', entropy_sum_heightWise.iloc[-1] )\n",
    "    #print ('Entropy appended list is  :',DisEntropyPlotter_SUMList_Kj )\n",
    "    #print ('entropy list kJ is :',DisEntropyPlotter_SUMList_Kj)\n",
    "    #print ('discharge: log values that shoudl be negative is:', df_Logvalues)\n",
    "    #print ('discharge: entropy df is :', entropy_df)\n",
    "    #print ('discharge: entropy_sum :', entropy_sum_heightWise)\n",
    "    MCT_df = df_heatCapacity_kJPerkgK.multiply(T, axis =1).multiply(df_m_kg, axis=1).sum(axis = 1)\n",
    "    #appned last value (current value of energy) as value- energy is decreasing as discharge goes on \n",
    "    DisMCTPlotterList_TankEnergyKJ.append(MCT_df.iloc[-1] )\n",
    "    print ('Availability :Total energy of in Kj is :', MCT_df.iloc[-1])\n",
    "    #print ('Availability whole df :Total energy of in Kj howle df :', MCT_df)\n",
    "    return entropy_sum_heightWise\n",
    "\n",
    "nStratDischragePlotterList = []\n",
    "def StratEffDischarge(load_kJ_total_float, entropy_sum_height_float):\n",
    "    #n1 = (load_kJ_total_float-entropy_sum_height_float)/ load_kJ_total_float\n",
    "    n2 = (load_kJ_total_float-entropy_sum_height_float.iloc[0])/ load_kJ_total_float\n",
    "    nStratDischragePlotterList.append(n2)\n",
    "    #print ('Discharge: strat efficiency sum_DF :', n1)\n",
    "    print ('Discharge: strat efficiency sum_float :', n2)\n",
    "    #print ('nStratDischarge plotter list is :', nStratDischragePlotterList[-1])\n",
    "    return n2\n",
    "\n",
    "\n",
    "###################################\n",
    "###Exergy calculation for charging\n",
    "###################################\n",
    "\n",
    "\n",
    "def mcTForExergyCharging(Lol, time_stamp_tem, time_stamp_watt):\n",
    "    #this calculates the energy addiction per timestamp in the tank. and integrates it over whole charging\n",
    "    \n",
    "    mHP = Lol[2]\n",
    "    T = flatten_tem(Lol)\n",
    "    #mL = Lol[3]\n",
    "    #watt_kW = Lol[4]\n",
    "    #p_LperH = [999.8473664794213 + 6.29265190e-02*x[2] - 8.42930922e-03*x[2]**2 + 6.77190849e-05*x[2]**3 \\\n",
    "    #- 4.40840180e-07*x[2]**4 + 1.29302849e-09*x[2]**5 for x in T]\n",
    "    p_LperH = [999.8473664794213 + 6.29265190e-02*x[3] - 8.42930922e-03*x[3]**2 + 6.77190849e-05*x[3]**3 \\\n",
    " - 4.40840180e-07*x[3]**4 + 1.29302849e-09*x[3]**5 for x in T]\n",
    "    mF_kgPerS =[ x*2.7777e-07*y for x, y in zip(p_LperH, mHP)]\n",
    "    #cP_kjPerkgK = [4.253264761904763 - 0.00470305*b[2] for b in T]\n",
    "    cP_kjPerkgK = [4.253264761904763 - 0.00470305*b[3] for b in T]\n",
    "    mCT_kW = [c*a*(b[3]-b[4]) for c, a, b in zip(cP_kjPerkgK,mF_kgPerS, T)]\n",
    "    mCT_kWh_l = [x*y for x,y in zip (time_stamp_tem, mCT_kW)]\n",
    "    #mCT_kJ_l = pd.DataFrame(mCT_kWh_l).multiply(3600)\n",
    "    mCT_kJ_l = pd.DataFrame(mCT_kWh_l)\n",
    "    #mCT_kWh_total = sum(mCT_kWh_l)\n",
    "    mCT_kWh_total = mCT_kJ_l.sum()\n",
    "    mCT_KJ_total = mCT_kWh_total*3600\n",
    "    #electricty consumed:\n",
    "    #watt_kW_l = [x*y for x,y in zip (time_stamp_watt,  watt_kW)]\n",
    "    #watt_kWh = sum(watt_kW_l)\n",
    "    #cop \n",
    "    #cop =mCT_kWh/watt_kWh\n",
    "    #copPlotterList.append(cop)\n",
    "    #print ('cop of system is:', cop)\n",
    "    #print ('kwh heat addition is :', mCT_kWh)\n",
    "    print ('chanrging : whole kJ list is mul by 3600:', mCT_KJ_total)\n",
    "    #print ('chanrging : df of mcT energy addition is:', mCT_kJ_l)\n",
    "    #print ('electricity in khW is:', watt_kWh)\n",
    "    \n",
    "    #print ('electricity consumption kW :', watt_kW)\n",
    "    return mCT_KJ_total\n",
    "\n",
    "entropyPlotter_SUMList_KjPerK = []\n",
    "entropyPlotter_SUMList_Kj = []\n",
    "MCTPlotterList_TankEnergyKJ = []\n",
    "def entropyCharging(Df_conc):\n",
    "    mHP =Df_conc['flowHP']\n",
    "    T =Df_conc.iloc[: ,11:-2]\n",
    "    T_hp_out_df =  Df_conc['TtopTestTankHPCir']\n",
    "    T_hp_in_df =  Df_conc['TbottomTestTankHpCir']\n",
    "    T = T[['T4', 'T3', 'T2', 'T1', 'T0', 'T9', 'T8', 'T7', 'T6', 'T5']]\n",
    "    T = T.rename({'T4':'T0', 'T3':'T1', 'T2':'T2', 'T1':'T3', 'T0':'T4', 'T9':'T5', 'T8':'T6',\\\n",
    "              'T7':'T7','T6':'T8','T5':'T9'}, axis='columns')\n",
    "    df_density_columns = ['d{}'.format(x) for x in range(0,10)]\n",
    "    df_density = T.apply(lambda x: 999.8473664794213 + 6.29265190e-02*x - \\\n",
    "                         8.42930922e-03*x**2 + 6.77190849e-05*x**3 \\\n",
    "                         - 4.40840180e-07*x**4 + 1.29302849e-09*x**5)\n",
    "    #0.397/10 is probably mass of each layer which are 10 layers\n",
    "    df_m_kg = df_density.multiply(0.397/10, axis =1) \n",
    "    df_heatCapacity_kJPerkgK = T.apply(lambda x: 4.253264761904763 - 0.00470305*x)\n",
    "    #T0_ambient_df =pd.DataFrame([np.random.uniform(24, 26) for _ in range(T.shape[0])])\n",
    "    T0_ambient_df = np.random.uniform(21, 22)\n",
    "    df_Logvalues = T.apply(lambda x: np.log(T_hp_out_df /x))\n",
    "    lnT_Mul_Cp_df = df_Logvalues.multiply(df_heatCapacity_kJPerkgK, axis =1)\n",
    "    mass_mul_lnT_and_cp_df = lnT_Mul_Cp_df.multiply(df_m_kg, axis =1)\n",
    "\n",
    "    entropy_df = mass_mul_lnT_and_cp_df.multiply(T0_ambient_df, axis =0)\n",
    "    entropy_sum_heightWise = entropy_df.sum(axis = 1)\n",
    "    \n",
    "    #entropyLastValue_kJPerK = mass_mul_lnT_and_cp_df.iloc[-1]\n",
    "    #appending entropy sum to entropyPlotter_SUMList_KjPerK\n",
    "    #entropyLastValue_kJPerK = entropy_sum_heightWise.iloc[-1]\n",
    "    \n",
    "    #calculates kJ/K  first without multiplication with T0 =Tambient\n",
    "    #and appends it to entropyPlotter_SUMList_KjPerK\n",
    "    entropy_sum_kjPerK = mass_mul_lnT_and_cp_df.sum(axis = 1)\n",
    "    entropyLastValue_kJPerK = entropy_sum_kjPerK.iloc[-1]\n",
    "    entropyPlotter_SUMList_KjPerK.append(entropyLastValue_kJPerK)\n",
    "    #print ('entropy list kJ/k is :', entropyPlotter_SUMList_KjPerK)\n",
    "    \n",
    "    #Now appned Kj Total of tank entropy, by multiplying it with To\n",
    "    entropyPlotter_SUMList_Kj.append(entropy_sum_heightWise.iloc[-1])\n",
    "    #print ('entropy list kJ is :',entropyPlotter_SUMList_Kj,)\n",
    "    \n",
    "    #saving entropy of each node in a numpy file.\n",
    "    #print ('shape of entropy df is:', mass_mul_lnT_and_cp_df.shape)\n",
    "    \n",
    "    #Exporting to csv each node entropy:\n",
    "    file_name = 'entropyNodeWise_{}'.format(datetime.datetime.now().strftime(\"%Y_%m_%d\"))\n",
    "    suffix = '.csv'\n",
    "    filePath = os.path.join(os.getcwd(), file_name + suffix)\n",
    "    #mass_mul_lnT_and_cp_df.to_csv(filePath, header=True, na_rep=np.nan)\n",
    "    \n",
    "    \n",
    "    #Calculation of Totoal energy in tank for availability = Energy - Entropy\n",
    "    #I have entropy in KJ i should calculate Totoal enegry to show, how much is lost in entropy \n",
    "    #just for comparison.\n",
    "    \n",
    "    MCT_df = df_heatCapacity_kJPerkgK.multiply(T, axis =1).multiply(df_m_kg, axis=1).sum(axis = 1)\n",
    "    MCTPlotterList_TankEnergyKJ.append(MCT_df.iloc[-1] )\n",
    "    print ('Availability :Total energy of in Kj is :', MCT_df.iloc[-1])\n",
    "    \n",
    "    \n",
    "    return entropy_sum_heightWise\n",
    "\n",
    "nStratPlotterList = []\n",
    "def nStratCharging(mCT_kWh_total_l, entropy_sum_heightWise):\n",
    "    nStart = (mCT_kWh_total_l - entropy_sum_heightWise.iloc[-1]) / mCT_kWh_total_l\n",
    "    nStratPlotterList.append(nStart.iloc[-1])\n",
    "    #print ('nStratCharging plotter list is :', nStratPlotterList)\n",
    "    print ('Charging stratified Efficiency:', nStart)\n",
    "    return nStart\n",
    "\n",
    "\n",
    "while True:\n",
    "    #c.execute(\"INSERT INTO flowReadings(flowHp, flowLoad) VALUES(?,?,?,?)\", (chan2.voltage, chan1.voltage))\n",
    "    #connection.commit()\n",
    "    \n",
    "    ###################################################################################\n",
    "    ################################################\n",
    "    ##Modbus connection for wattmeter readings in kW\n",
    "    ##https://stackoverflow.com/questions/28186746/python-convert-2-ints-to-float\n",
    "    ################################################\n",
    "    \n",
    "    c = ModbusClient(host=\"10.208.8.125\", port=502, auto_open=True)\n",
    "    \n",
    "    #This reads the register address 19026 where all teh meteric(values of wattmeter) \n",
    "    #values are stored in a 16 bit values.county = 2, means read two values in the\n",
    "    #same register address.Register is a column (like in spreadsheet). each register\n",
    "    #store a 16 bit value, we read two 16 bit value and would convert those 2 16 bit \n",
    "    #value to a 32 bit floating point value by the formula\n",
    "    regs = c.read_input_registers(19026, 2)\n",
    "    #this is forst value of two counts\n",
    "    a = regs[0]\n",
    "    #This is second value of two counts\n",
    "    b = regs[1]\n",
    "    #This is how we convert two 16 bit value to a single 32 floating point number.\n",
    "    #from stackoverflow\n",
    "    mypack = pack('>HH',a,b)\n",
    "    #print (mypack)\n",
    "    fl = unpack('>f', mypack)\n",
    "    #fl = struct.unpack('!f', bytes.fromhex('{0:02x}'.format(a) + '{0:02x}'.format(b)))\n",
    "    #fl is a tuple (5.0186,) I need to unpack it index it with [0] \n",
    "    fl = fl[0]*10**-3\n",
    "    #wattMeterKw.append(fl)\n",
    "    #lol[3].append(fl)\n",
    "    #print ('watter meter reaidngs are:', wattMeterKw)\n",
    "    #print ('gross lol is:', lol)\n",
    "    ####################################################################################\n",
    "    \n",
    "    chan1 = AnalogIn(ads, ADS.P0)\n",
    "    chan2 = AnalogIn(ads, ADS.P1)\n",
    "\n",
    "    chan1Vol = chan1.voltage\n",
    "    chan1curr = chan1Vol/159.42\n",
    "\n",
    "    chan2Vol = chan2.voltage\n",
    "    chan2curr=chan2Vol/159.65\n",
    "    #flow1 = ((chan1Vol/159.42)*1000 -4)/16*1000\n",
    "    flow1 = ((chan1Vol/159.42)-0.003956)/0.0000159\n",
    "    #flow2 = ((chan2Vol/159.65)*1000 -4)/16*4000 +20\n",
    "    #flow2 = ((chan2Vol/159.65)- 0.0005468893873066417)/1.09561608e-05\n",
    "    flow2 = ((chan2Vol/159.65)- 0.003973767754877122)/5.3038815e-06\n",
    "    cL.execute(\"INSERT INTO flowReadings(flowHp, flowLoad, watt) VALUES(%s, %s, %s)\", (flow2, flow1, fl))\n",
    "    connectionL.commit()\n",
    "    \n",
    "    #cL =connectionL.cursor()\n",
    "    cL.execute(\"SELECT * FROM flowReadings ORDER BY id DESC LIMIT 1\")\n",
    "    FlowFormDb = cL.fetchall()\n",
    "    #print ('flow and watt from FlowWattDB is :',FlowFormDb[-1][2],FlowFormDb )\n",
    "    #print ('Time period of flow load and watt is :',timePeriod_watt, [x* 3600 for x in timePeriod_watt])\n",
    "\n",
    "    #c.execute(\"SELECT * from temSensor\")\n",
    "    #cR.execute(\"SELECT * FROM temSensor ORDER BY id DESC LIMIT 1\")\n",
    "    #result = cR.fetchall()\n",
    "    \n",
    "    #print('flow HP:',\"{:>5}\\t{:>5.3f}\".format(chan2.value, chan2.voltage), '\\n\\n')\n",
    "    #print('flow load:',\"{:>5}\\t{:>5.3f}\".format(chan1.value, chan1.voltage, '\\n\\n'))\n",
    "    print('flow rates load is = ',chan1Vol, chan1curr,flow1 )\n",
    "    print('flow rates HP is = ',chan2Vol, chan2curr,flow2 )\n",
    "\n",
    "    connectionR = db.Connection(host=HOST, port=PORT,user=USER, passwd=PASSWORD, db=DB)\n",
    "    cR = connectionR.cursor()\n",
    "    #c.execute(\"SELECT * from temSensor\")\n",
    "    cR.execute(\"SELECT * FROM temSensor ORDER BY id DESC LIMIT 1\")\n",
    "    result = cR.fetchall()\n",
    "    print ('result is',result)\n",
    "    #print ('result diagnoses is',result[0])\n",
    "    id = result[0][0]\n",
    "    id_flowWatt = FlowFormDb[0][0]\n",
    "    flowHP  = FlowFormDb[-1][2]\n",
    "    flowLoad  = FlowFormDb[-1][3]\n",
    "    wattUsed = FlowFormDb[-1][4]\n",
    "    #print ('flow HP, flow Load, watt is:' ,flowHP, flowLoad, wattUsed)\n",
    "    #idGenerator(id, l_id)\n",
    "    #print ('id is :', id)\n",
    "    \n",
    "    flowRateLoad.append(flow1)\n",
    "    if lol[0] ==[] or id < lol[0][-1][0][0] :\n",
    "        lol[0].append(result)\n",
    "        #print (lol)\n",
    "        if lol[1] ==[] or id_flowWatt < lol[1][-1][0][0]:\n",
    "            lol[1].append(FlowFormDb)\n",
    "            lol[2].append(flowHP)\n",
    "            lol[3].append(flowLoad)\n",
    "            lol[4].append(wattUsed)\n",
    "            timeStampCreator_cop(lol)\n",
    "            timeStampCreator_watt(lol)\n",
    "            wattMeterKw.append(fl)\n",
    "    elif lol[0] != [] and id > lol[0][-1][0][0]:\n",
    "        lol[0].append(result)\n",
    "        if lol[1] != [] and id > lol[1][-1][0][0]:\n",
    "            lol[1].append(FlowFormDb)\n",
    "            lol[2].append(flowHP)\n",
    "            lol[3].append(flowLoad)\n",
    "            lol[4].append(wattUsed)\n",
    "            timeStampCreator_cop(lol)\n",
    "            timeStampCreator_watt(lol)\n",
    "            wattMeterKw.append(fl)\n",
    "        \n",
    "    print ('cop is:', Cop(lol, timePeriod_tem, timePeriod_watt ))\n",
    "    \n",
    "    df = tankStrat(dfs(lol))\n",
    "\n",
    "    GrossDf = toCsv(dfs(lol), list2df(Load_kWh(lol, timePeriod_tem), 'Load_kW'), \\\n",
    "                    list2df(MCT_timeStamp(lol, timePeriod_tem),'Heat_Capacity_kW'),\\\n",
    "                    list2df(wattMeterKw, 'electrcity_kW'), list2df(copPlotterList, 'COP'), \\\n",
    "                   list2df(nDischargePlotterList, 'nDis'), \\\n",
    "                    list2df(timePeriod_tem, 'timeStamp_Temp'),\\\n",
    "                    list2df(timePeriod_watt, 'timeStamp_watt'),\\\n",
    "                   list2df(entropyPlotter_SUMList_KjPerK , 'entropy_kJ/K'), \\\n",
    "                   list2df(entropyPlotter_SUMList_Kj , 'entropy_kJ'),\\\n",
    "                   list2df(nStratPlotterList , 'nStratCharging'),\\\n",
    "                   list2df(MCTPlotterList_TankEnergyKJ, 'TotalTanksEnergyForAvailability_kJ'),\\\n",
    "                    list2df(DisEntropyPlotter_SUMList_KjPerK , 'DisEntropy_kj/K'),\\\n",
    "                   list2df(DisEntropyPlotter_SUMList_Kj , 'DisEntropy_kj'), \\\n",
    "                   list2df(nStratDischragePlotterList , 'nStratDischarge'), \\\n",
    "                   list2df(DisMCTPlotterList_TankEnergyKJ,  'DisTotalTanksEnergyForAvailability_kJ'))\n",
    "    \n",
    "    #print ('gorss DF is :',GrossDf.iloc[:, -10] )\n",
    "    #GrossDf = toCsv(dfs(lol), list2df(Load_kWh(lol), 'Load_kW'), list2df(MCT_timeStamp(lol, timePeriod),'Heat_Capacity_kW'))\n",
    "    #heatAddition_kwh, cop = MCT_timeStamp(lol, timePeriod)\n",
    "    # Plot tem values as a seperate first fig\n",
    "\n",
    "    fig, ax = plotObject(df, ax,  fig, alpha=0.7, scm=scm)\n",
    "    #plot load_kW in different fig2 \n",
    "    fig2, ax2 = plotObject_Load(GrossDf, ax2, fig2)\n",
    "    #Plot heat_Capacity in the same fig as fig2 but as a subplot\n",
    "    fig2, ax2_1 =plotObject_Heat_Capacity(GrossDf, ax2_1, fig2)\n",
    "    #This plot the HP in and out and tmixL laod tem.\n",
    "    fig, ax_1 = plotObject_Tem_HpAndLoad(GrossDf, ax_2, fig)\n",
    "    \n",
    "    #Thjis plot plots Entropy in kJ/K and kJ\n",
    "    fig3, ax3 = plotObject_entropy(GrossDf, ax3,ax3_1, fig3)\n",
    "    \n",
    "    fig4, ax4 = plotObject_entropy_Discharge(GrossDf, ax4, ax4_1,  fig4)\n",
    "    \n",
    "    #fig4, ax4 = plotObject_entropy_Discharge(GrossDf, ax4, ax4_1,  fig4)\n",
    "\n",
    "    #print ('fetch the flow load:', nDicharge(dfs(lol)))\n",
    "    #nDicharge(dfs(lol))\n",
    "    #print ('lol len and lol itself is :', len (lol[0]), lol[0])\n",
    "    #print ('Density of df is :',densityFumction(GrossDf ['TbottomTestTankLoadCir']))\n",
    "    #print ('fow in cubeic meter per sec  :',flowCubeMeterPerSec(GrossDf ['flowLoad']))\n",
    "    #flowCubeMeterPerSec(flow)\n",
    "    #print ('discharge mcdelta T is :',dfMultiplication(densityFumction(), df2_V, Tin, Tout), flowCubeMeterPerSec(GrossDf ['flowLoad']))\n",
    "    #dfMultiplication(df1_p, df2_V, Tin, Tout)\n",
    "    #print ('flow in m3/sec:', flowCubeMeterPerSec(GrossDf ['flowLoad']))\n",
    "    #print ('hot water cp, cold water cp:', specificHeatkJPerKgK(GrossDf['TTopTestTankLoadCir']),specificHeatkJPerKgK(GrossDf['TbottomTestTankLoadCir']))\n",
    "    #print ('how water density, cold water density:', densityFumction(GrossDf['TTopTestTankLoadCir']),densityFumction(GrossDf['TbottomTestTankLoadCir']))\n",
    "    #nDicharge(dfs(lol), GrossDf)\n",
    "    #print ('tiem perod is :', pd.DataFrame({'time_tem':timePeriod_tem}))\n",
    "    #print ('nDis plottre list is:',nDischargePlotterList, len(nDischargePlotterList))\n",
    "    #print ('nDis plotter df looks like:',list2df(nDischargePlotterList, 'nDis'))\n",
    "    #if nDischargePlotterList\n",
    "    #print (' conc df wiuth Nan is :',dfs(lol))\n",
    "    #df_CONC = dfs(lol)\n",
    "    #print ('TemStrat is:',df)\n",
    "    #entropyCharging(dfs(lol))\n",
    "    #entropyCharging(dfs(lol))\n",
    "    #mcTForExergyCharging(lol,timePeriod_tem,timePeriod_watt)\n",
    "    #print ('nDis df looks like thuis :',Nan2Zero(list2df(nDischargePlotterList, 'nDis')))\n",
    "    #nStratCharging(mcTForExergyCharging(lol,timePeriod_tem,timePeriod_watt), entropyCharging(dfs(lol)))\n",
    "    #print ('GRoss DF is :', GrossDf )\n",
    "    if GrossDf ['flowLoad'].iloc[-1]>50:\n",
    "        #print ('Highre discharge calculating Discharge Efficiency',GrossDf ['flowLoad'].iloc[-1] )\n",
    "        nDicharge(dfs(lol), GrossDf)\n",
    "        TankVolumeDischarged(lol,timePeriod_watt)\n",
    "        StratEffDischarge(mcTForExergyDischarging (Load_kWh(lol, timePeriod_watt), timePeriod_watt), \\\n",
    "                          entropyDischarging(dfs(lol)))\n",
    "        #creat discharge grasphs only when discharge\n",
    "        \n",
    "        #plotObject_entropy_Discharge(GrossDf, ax4, ax4_1,  fig4)\n",
    "    \n",
    "    elif GrossDf ['flowHP'].iloc[-1]>0.5:\n",
    "        print ('charging is going on so I will calculate charging efficiency:==' )\n",
    "        #entropyCharging(dfs(lol))\n",
    "        #mcTForExergyCharging(lol,timePeriod_tem,timePeriod_watt)\n",
    "        nStratCharging(mcTForExergyCharging(lol,timePeriod_tem,timePeriod_watt), entropyCharging(dfs(lol)))\n",
    "        \n",
    "    else : \n",
    "        #This else conditions fills the nDischargePlotterList list even when discharge is not going on\n",
    "        #otehrwise its problem. \n",
    "        nDischargePlotterList.append(np.nan)\n",
    "\n",
    "    '''\n",
    "    dfMultiplication(densityFn in kwh is: 6.10671895076359umction(GrossDf['TTopTestTankLoadCir']), \\\n",
    "                     specificHeatkJPerKgK(GrossDf['TTopTestTankLoadCir']), \\\n",
    "                     densityFumction(GrossDf['TbottomTestTankLoadCir']),\\\n",
    "                     specificHeatkJPerKgK(GrossDf['TbottomTestTankLoadCir']),\\\n",
    "                     flowCubeMeterPerSec(GrossDf ['flowLoad']), \\\n",
    "                     GrossDf['TbottomTestTankLoadCir'], \\\n",
    "                     GrossDf['TTopTestTankLoadCir'], timePeriod_tem)\n",
    "    '''\n",
    "    \n",
    "    print('________________________________________________________________')\n",
    "    time.sleep(0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "crazy-drunk",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}