PRC_COREAlgorithms.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import numpy as np\n",
    "import timeit\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing DataFrames"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In case of having lesser or higher number of shading positions (Ps) depending on the facade resolution that will be adapted,each shading state along with time-dependent simulations regarding each user's visual comfort performance should be uploaded here. \n",
    "\n",
    "Each file contains the following simulations for every 20-minute time interval proposed as a case study:\n",
    "\n",
    "- Vertical Eye Illuminance (Ev) for each user\n",
    "- Task Illuminance (Et) for each user\n",
    "- Uniformity level for each workstation of the user\n",
    "- Lighting power needed for each sensor (in Watts)\n",
    "- Calculated lighting fractional power for each sensor\n",
    "- Shading position for each facade section (facade is divided into 3 sections as 3*4 modular columns in this study)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "###YOU NEED TO CHANGE THE CSV FILES ADDRESS \n",
    "ps000 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps000.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps002 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps002.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps004 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps004.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps008 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps008.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps020 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps020.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps022 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps022.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps024 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps024.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps028 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps028.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps040 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps040.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps042 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps042.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps044 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps044.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps048 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps048.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps080 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps080.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps082 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps082.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps084 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps084.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps088 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps088.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps200 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps200.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps202 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps202.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps204 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps204.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps208 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps208.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps220 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps220.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps222 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps222.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps224 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps224.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps228 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps228.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps240 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps240.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps242 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps242.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps244 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps244.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps248 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps248.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps280 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps280.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps282 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps282.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps284 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps284.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps288 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps288.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps400 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps400.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps402 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps402.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps404 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps404.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps408 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps408.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps420 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps420.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps422 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps422.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps424 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps424.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps428 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps428.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps440 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps440.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps442 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps442.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps444 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps444.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps448 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps448.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps480 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps480.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps482 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps482.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps484 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps484.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps488 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps488.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps800 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps800.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps802 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps802.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps804 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps804.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps808 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps808.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps820 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps820.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps822 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps822.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps824 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps824.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps828 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps828.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps840 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps840.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps842 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps842.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps844 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps844.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps848 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps848.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps880 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps880.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps882 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps882.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps884 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps884.csv\", index_col = 'DATE', parse_dates = True)\n",
    "ps888 = pd.read_csv(r\"H:\\Stage5\\alldata\\Ps888.csv\", index_col = 'DATE', parse_dates = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We should assign a unique ID for each shading position for future recalling:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ps_dic = {'Ps000':0,'Ps002':1,'Ps004':2 ,'Ps008':3,'Ps020':4,'Ps022':5,'Ps024':6,'Ps028':7,'Ps040':8,'Ps042':9,'Ps044':10,'Ps048':11,'Ps080':12,'Ps082':13,'Ps084':14,'Ps088':15,'Ps200':16,'Ps202':17,'Ps204':18,\n",
    "                'Ps208':19,'Ps220':20,'Ps222':21,'Ps224':22,'Ps228':23,'Ps240':24,'Ps242':25,'Ps244':26,'Ps248':27,'Ps280':28,'Ps282':29,'Ps284':30,'Ps288':31,'Ps400':32,'Ps402':33,'Ps404':34,'Ps408':35,'Ps420':36,'Ps422':37,\n",
    "                'Ps424':38,'Ps428':39,'Ps440':40,'Ps442':41,'Ps444':42,'Ps448':43,'Ps480':44,'Ps482':45,'Ps484':46,'Ps488':47,'Ps800':48,'Ps802':49,'Ps804':50,'Ps808':51,'Ps820':52,'Ps822':53,'Ps824':54,'Ps828':55,'Ps840':56,\n",
    "                'Ps842':57,'Ps844':58,'Ps848':59,'Ps880':60,'Ps882':61,'Ps884':62,'Ps888':63}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding View Ratios "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "View Ratios should be added as new columns for each user separately:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_files = [ps000,ps002,ps004,ps008,ps020,ps022,ps024,ps028,ps040,ps042,ps044,ps048,ps080,ps082,ps084,ps088,ps200,ps202,ps204,\n",
    "                ps208,ps220,ps222,ps224,ps228,ps240,ps242,ps244,ps248,ps280,ps282,ps284,ps288,ps400,ps402,ps404,ps408,ps420,ps422,\n",
    "                ps424,ps428,ps440,ps442,ps444,ps448,ps480,ps482,ps484,ps488,ps800,ps802,ps804,ps808,ps820,ps822,ps824,ps828,ps840,\n",
    "                ps842,ps844,ps848,ps880,ps882,ps884,ps888]\n",
    "for d in list_of_files:\n",
    "    d['ViewU1'] = d['ViewU12']\n",
    "    d['ViewU2'] = d['ViewU12']\n",
    "    d['ViewU3'] = d['ViewU34']\n",
    "    d['ViewU4'] = d['ViewU34']\n",
    "    d['ViewU5'] = d['ViewU56']\n",
    "    d['ViewU6'] = d['ViewU56']\n",
    "    d.drop('ViewU12', axis =1 , inplace = True)\n",
    "    d.drop('ViewU34', axis =1 , inplace = True)\n",
    "    d.drop('ViewU56', axis =1 , inplace = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concatenating DataFrames "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to convert the entire data frames into one single data file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alldata = pd.concat([ps000,ps002,ps004,ps008,ps020,ps022,ps024,ps028,ps040,ps042,ps044,ps048,ps080,ps082,ps084,ps088,ps200,ps202,ps204,\n",
    "                ps208,ps220,ps222,ps224,ps228,ps240,ps242,ps244,ps248,ps280,ps282,ps284,ps288,ps400,ps402,ps404,ps408,ps420,ps422,\n",
    "                ps424,ps428,ps440,ps442,ps444,ps448,ps480,ps482,ps484,ps488,ps800,ps802,ps804,ps808,ps820,ps822,ps824,ps828,ps840,\n",
    "                ps842,ps844,ps848,ps880,ps882,ps884,ps888], axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding Unoccupied Hours as Zeros"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "During unoccupied hours, there is no occupant in the space, thus there is no user feedback due to visual discomfort. \n",
    "So, we assume ZERO values for unoccupied hours that need to be repeated before/after working hours (e.g.8am-5pm) throughout all available columns in the data frame (2304 columns in this case)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cols = list(alldata.columns)\n",
    "new_chunks = np.split(alldata, 365) #dividing dataframe into days\n",
    "new_df = pd.DataFrame()\n",
    "for i in range(len(new_chunks)): #Adding additional values during unoccupied hours\n",
    "    part1 = np.zeros((24, 2304))\n",
    "    part2 = new_chunks[i].values\n",
    "    part3 = np.zeros((20, 2304))\n",
    "    one_day_data = np.vstack((part1, part2, part3))\n",
    "    one_day_data = pd.DataFrame(one_day_data)\n",
    "    new_df = pd.concat([new_df, one_day_data])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adjusting the Column Names and Dates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assigning 20-minute time intervals with dates for each row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df.columns = cols\n",
    "DATE = pd.date_range('2019-01-01', periods=26280, freq='20Min')\n",
    "new_df[\"DATE\"] = DATE\n",
    "new_df[\"Datetime\"] = pd.to_datetime(new_df['DATE'])\n",
    "new_df = new_df.drop(['DATE'], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df.info() #Verify the data properties"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding Individual Occupancy Schedules as New Columns\n",
    "- This is a very important step to import the occupancy profiles as new additional columns for each user created by a 3rd party interface (in this research Occupancy Simulator http://occupancysimulator.lbl.gov/ was used):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "###YOU NEED TO CHANGE THE CSV FILE ADDRESS \n",
    "OC = pd.read_csv(r'H:\\Stage5\\OccupantPRC.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df['U1'] = OC['U1'].values\n",
    "new_df['U2'] = OC['U2'].values\n",
    "new_df['U3'] = OC['U3'].values\n",
    "new_df['U4'] = OC['U4'].values\n",
    "new_df['U5'] = OC['U5'].values\n",
    "new_df['U6'] = OC['U6'].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "OCC = new_df.set_index('Datetime')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding Weekends and Holidays to identify WorkingHours\n",
    "- Identify the control logic scenario among Scenario A and B from the starting point of ts (January 1st, 1a.m) based on working hours to set a clear target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "OCC['WEEKDAY'] = pd.to_datetime(OCC.index).dayofweek "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "holidays = ['2019-01-01', '2019-01-28','2019-03-11','2019-04-20', '2019-04-21','2019-04-22',\n",
    "            '2019-04-25','2019-06-10','2019-09-27','2019-11-05','2019-12-25','2019-12-26' ]\n",
    "holidays = pd.to_datetime(holidays)\n",
    "OCC['HOLIDAY'] = OCC.index.floor('D').isin(holidays)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "OCC[\"WorkingHours\"] = OCC['WEEKDAY'].where((OCC.index.isin(OCC.between_time('8:00', '17:00', include_start=True, include_end=True).index)) & (OCC['WEEKDAY'] < 5) & (OCC['HOLIDAY'].isin([False])), -1) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "OCC[\"WorkingHours\"] = OCC['WorkingHours'].apply(lambda x: 'True' if x >= 0 else 'False')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA = OCC.replace(-999,0) #JUST IN CASE IF THERE IS STILL NEGATIVE NUMBERS IN THE LIST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contatenating with Solar Radiation Dataframe\n",
    "- During unoccpupied hours, facade will be adjusted based on outdoor solar radiation, thus we need to add solar radiation values for each time interval as new a column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "###YOU NEED TO CHANGE THE CSV FILE ADDRESS \n",
    "SOL = pd.read_csv(r\"H:\\Stage5\\SolarRadiation.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SOL = SOL.drop('Datetime', axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SOL['global'] = SOL['dir']+SOL['dif']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "DATA['global'] = SOL['global'].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Integrating PnCn Loops into a Global Loop"
   ]
  },
  {
   "attachments": {
    "2021-09-07_192443.jpg": {
     "image/jpeg": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>This is the CORE of the PRC algorithm</b> \n",
    "    \n",
    "This algorithm is compatible to different adjustments where in my research, I modified the algorithm and studied their results based on three additional scenarios:\n",
    "\n",
    "- Limiting user preferences extremes (maximum and minimum values among users) by 30% \n",
    "- Equalizing the user preferences (assuming all users have similar visual comfort preferences)\n",
    "\n",
    "![2021-09-07_192443.jpg](attachment:2021-09-07_192443.jpg)\n",
    "\n",
    "- Re-ordering the prioritization list (originally Ev is prior to Et and VR, but in this scenario, Et is prior to VR and Ev)\n",
    "\n",
    "Final control decisions are based on several drivers and their respective definitions as a proof of concept:\n",
    "\n",
    "•\tP1C1 – adjust the shading position in response to acceptable EV thresholds for corresponding user with least impact on neighbors’ view ratio,\n",
    "\n",
    "•\tP1C2 – Keep the shades in current position,\n",
    "\n",
    "•\tP1C3 – Changing to fully-closed shading position for all columns,\n",
    "\n",
    "•\tP2C1 – Adjust the shading position in response to view ratio where EV is in comfortable range for all other users,\n",
    "\n",
    "•\tP2C2 – Keep the shades in current position,\n",
    "\n",
    "•\tP2C3 - Adjust the shading position in response to view ratio where EV is in comfortable range for all other users if possible, (there might be times during a day that providing sufficient view can increase risk of discomfort glare)\n",
    "\n",
    "•\tP3C1 - Adjust the shading position in response to task illuminance where EV is in comfortable range,\n",
    "\n",
    "•\tP3C2 – Keep the shades in current position,\n",
    "\n",
    "•\tP3C3 – Changing shading position corresponding to the same column to fully-open position.\n",
    "\n",
    "•\t‘NoAction’ – When both users of the same column are absent, position the shades according to the required indoor illuminance for each column (Stage B.2), only if there is no other feedback from other users.\n",
    "\n",
    "<b>NOTE: The algorithm can be optimized in future investigations or can host AI to enhance its performance. Possible recommendations for further enhansements are discussed in the Thesis</b> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "###THIS IS WHERE THE PERSONALIZED CONTROL ALGORITHMS BEGINS TO SIMUALTE\n",
    "\n",
    "start = timeit.default_timer()\n",
    "\n",
    "result = []\n",
    "Driver = []\n",
    "RECORDS = []\n",
    "for i in range(0,26280):\n",
    "    stageA2 = []\n",
    "    if DATA.iloc[i]['WorkingHours'] == 'False': #STAGE A.2\n",
    "        for ts in range(i,i+1):\n",
    "            if (DATA.index[i].month == 6) or (DATA.index[i].month == 7) or (DATA.index[i].month == 8): #Winter Season\n",
    "                ps = ps_dic['Ps444']\n",
    "                stageA2 = 'Ps444'\n",
    "            elif (DATA.index[i].month != 6) and (DATA.index[i].month != 7) and (DATA.index[i].month != 8): #Other Seasons\n",
    "                if DATA.iloc[i]['global'] > 150:\n",
    "                    ps = ps_dic['Ps000']\n",
    "                    stageA2 = 'Ps000'\n",
    "                elif DATA.iloc[i]['global'] <= 150:\n",
    "                    ps = ps_dic['Ps444']\n",
    "                    stageA2 = 'Ps444'               \n",
    "            result.append(stageA2)\n",
    "            Driver.append('SolarRadiation')\n",
    "            Rec = {'Ev-col1':'Unoccupied','Ev-col2':'Unoccupied','Ev-col3':'Unoccupied','View-col1':'Unoccupied','View-col2':'Unoccupied','View-col3':'Unoccupied','ill-col1':'Unoccupied','ill-col2':'Unoccupied','ill-col3':'Unoccupied','ts': DATA.iloc[ts].name}\n",
    "            RECORDS.append(Rec)\n",
    "            Records = pd.DataFrame(RECORDS)\n",
    "            Records.set_index('ts', inplace = True)\n",
    "    elif DATA.iloc[i]['WorkingHours'] == 'True': #STAGE B.2 & STAGE B.3\n",
    "        ##Clustering the comfortable thresholds for each user individually based on PnCn and OC Schedules##\n",
    "        for ts in range(i,i+1):  #U1 = 2800, U2 = 1500\n",
    "            if (DATA.iloc[ts]['U1'] == 1) and (DATA.iloc[ts]['U2'] == 1):\n",
    "                if (DATA['User1-Ev'].values[ts][ps] <= 2800 ) and (DATA['User2-Ev'].values[ts][ps] > 1500) or (DATA['User1-Ev'].values[ts][ps] > 2800 ) and (DATA['User2-Ev'].values[ts][ps] <= 1500):\n",
    "                    x = 'P1C1'\n",
    "                elif (DATA['User1-Ev'].values[ts][ps] <= 2800 ) and (DATA['User2-Ev'].values[ts][ps] <= 1500):\n",
    "                    x = 'P1C2'\n",
    "                elif (DATA['User1-Ev'].values[ts][ps] > 2800 ) and (DATA['User2-Ev'].values[ts][ps] > 1500):\n",
    "                    x = 'P1C3'\n",
    "            elif (DATA.iloc[ts]['U1'] == 0) and (DATA.iloc[ts]['U2'] == 1):\n",
    "                if (DATA['User1-Ev'].values[ts][ps] <= 2800 ) and (DATA['User2-Ev'].values[ts][ps] > 1500):\n",
    "                    x = 'P1C1'\n",
    "                elif (DATA['User1-Ev'].values[ts][ps] > 2800 ) and (DATA['User2-Ev'].values[ts][ps] <= 1500):\n",
    "                    x = 'P1C2'\n",
    "                elif (DATA['User1-Ev'].values[ts][ps] > 2800 ) and (DATA['User2-Ev'].values[ts][ps] > 1500):\n",
    "                    x = 'P1C1'\n",
    "                elif (DATA['User1-Ev'].values[ts][ps] <= 2800 ) and (DATA['User2-Ev'].values[ts][ps] <= 1500):\n",
    "                    x = 'P1C2'\n",
    "            elif (DATA.iloc[ts]['U1'] == 1) and (DATA.iloc[ts]['U2'] == 0):\n",
    "                if (DATA['User1-Ev'].values[ts][ps] <= 2800 ) and (DATA['User2-Ev'].values[ts][ps] > 1500):\n",
    "                    x = 'P1C2'\n",
    "                elif (DATA['User1-Ev'].values[ts][ps] > 2800 ) and (DATA['User2-Ev'].values[ts][ps] <= 1500):\n",
    "                    x = 'P1C1'\n",
    "                elif (DATA['User1-Ev'].values[ts][ps] > 2800 ) and (DATA['User2-Ev'].values[ts][ps] > 1500):\n",
    "                    x = 'P1C1'\n",
    "                elif (DATA['User1-Ev'].values[ts][ps] <= 2800 ) and (DATA['User2-Ev'].values[ts][ps] <= 1500):\n",
    "                    x = 'P1C2'\n",
    "            elif (DATA.iloc[ts]['U1'] == 0) and (DATA.iloc[ts]['U2'] == 0):\n",
    "                x = 'NoAction'\n",
    "        cluster_Ev12 = {'Ev-col3' : [x], 'ts': DATA.iloc[ts].name}\n",
    "        cluster_Ev_df = pd.DataFrame(cluster_Ev12)\n",
    "        CLUSTER_EV_U12 = cluster_Ev_df.set_index('ts')\n",
    "\n",
    "        for ts in range(i,i+1):  #U3 = 1350, U4 = 2000\n",
    "            if (DATA.iloc[ts]['U3'] == 1) and (DATA.iloc[ts]['U4'] == 1):            \n",
    "                if (DATA['User3-Ev'].values[ts][ps] <= 1350 ) and (DATA['User4-Ev'].values[ts][ps] > 2000) or (DATA['User3-Ev'].values[ts][ps] > 1350 ) and (DATA['User4-Ev'].values[ts][ps] <= 2000):\n",
    "                    x = 'P1C1'\n",
    "                elif (DATA['User3-Ev'].values[ts][ps] <= 1350 ) and (DATA['User4-Ev'].values[ts][ps] <= 2000):\n",
    "                    x = 'P1C2'\n",
    "                elif (DATA['User3-Ev'].values[ts][ps] > 1350 ) and (DATA['User4-Ev'].values[ts][ps] > 2000):\n",
    "                    x = 'P1C3'\n",
    "            elif (DATA.iloc[ts]['U3'] == 0) and (DATA.iloc[ts]['U4'] == 1):\n",
    "                if (DATA['User3-Ev'].values[ts][ps] <= 1350 ) and (DATA['User4-Ev'].values[ts][ps] > 2000):\n",
    "                    x = 'P1C1'\n",
    "                elif (DATA['User3-Ev'].values[ts][ps] > 1350 ) and (DATA['User4-Ev'].values[ts][ps] <= 2000):\n",
    "                    x = 'P1C2'\n",
    "                elif (DATA['User3-Ev'].values[ts][ps] <= 1350 ) and (DATA['User4-Ev'].values[ts][ps] <= 2000):\n",
    "                    x = 'P1C2'\n",
    "                elif (DATA['User3-Ev'].values[ts][ps] > 1350 ) and (DATA['User4-Ev'].values[ts][ps] > 2000):\n",
    "                    x = 'P1C1'\n",
    "            elif (DATA.iloc[ts]['U3'] == 1) and (DATA.iloc[ts]['U4'] == 0):\n",
    "                if (DATA['User3-Ev'].values[ts][ps] <= 1350 ) and (DATA['User4-Ev'].values[ts][ps] > 2000):\n",
    "                    x = 'P1C2'\n",
    "                elif (DATA['User3-Ev'].values[ts][ps] > 1350 ) and (DATA['User4-Ev'].values[ts][ps] <= 2000):\n",
    "                    x = 'P1C1'\n",
    "                elif (DATA['User3-Ev'].values[ts][ps] > 1350 ) and (DATA['User4-Ev'].values[ts][ps] > 2000):\n",
    "                    x = 'P1C1'\n",
    "                elif (DATA['User3-Ev'].values[ts][ps] <= 1350 ) and (DATA['User4-Ev'].values[ts][ps] <= 2000):\n",
    "                    x = 'P1C2'\n",
    "            elif (DATA.iloc[ts]['U3'] == 0) and (DATA.iloc[ts]['U4'] == 0):\n",
    "                x = 'NoAction'\n",
    "        cluster_Ev34 = {'Ev-col2' : [x], 'ts': DATA.iloc[ts].name}\n",
    "        cluster_Ev_df = pd.DataFrame(cluster_Ev34)\n",
    "        CLUSTER_EV_U34 = cluster_Ev_df.set_index('ts')\n",
    "\n",
    "        for ts in range(i,i+1):  #U5 = 3600, U6 = 3000\n",
    "            if (DATA.iloc[ts]['U5'] == 1) and (DATA.iloc[ts]['U6'] == 1):\n",
    "                if (DATA['User5-Ev'].values[ts][ps] <= 3600 ) and (DATA['User6-Ev'].values[ts][ps] > 3000) or (DATA['User5-Ev'].values[ts][ps] > 3600 ) and (DATA['User6-Ev'].values[ts][ps] <= 3000):\n",
    "                    x = 'P1C1'\n",
    "                elif (DATA['User5-Ev'].values[ts][ps] <= 3600 ) and (DATA['User6-Ev'].values[ts][ps] <= 3000):\n",
    "                    x = 'P1C2'\n",
    "                elif (DATA['User5-Ev'].values[ts][ps] > 3600 ) and (DATA['User6-Ev'].values[ts][ps] > 3000):\n",
    "                    x = 'P1C3'\n",
    "            elif (DATA.iloc[ts]['U5'] == 0) and (DATA.iloc[ts]['U6'] == 1):\n",
    "                if (DATA['User5-Ev'].values[ts][ps] <= 3600 ) and (DATA['User6-Ev'].values[ts][ps] <= 3000):\n",
    "                    x = 'P1C2'\n",
    "                elif (DATA['User5-Ev'].values[ts][ps] > 3600 ) and (DATA['User6-Ev'].values[ts][ps] > 3000):\n",
    "                    x = 'P1C1'\n",
    "                elif (DATA['User5-Ev'].values[ts][ps] > 3600 ) and (DATA['User6-Ev'].values[ts][ps] <= 3000):\n",
    "                    x = 'P1C2'\n",
    "                elif (DATA['User5-Ev'].values[ts][ps] <= 3600 ) and (DATA['User6-Ev'].values[ts][ps] > 3000):\n",
    "                    x = 'P1C1'\n",
    "            elif (DATA.iloc[ts]['U5'] == 1) and (DATA.iloc[ts]['U6'] == 0):\n",
    "                if (DATA['User5-Ev'].values[ts][ps] <= 3600 ) and (DATA['User6-Ev'].values[ts][ps] <= 3000):\n",
    "                    x = 'P1C2'\n",
    "                elif (DATA['User5-Ev'].values[ts][ps] > 3600 ) and (DATA['User6-Ev'].values[ts][ps] > 3000):\n",
    "                    x = 'P1C1'\n",
    "                elif (DATA['User5-Ev'].values[ts][ps] > 3600 ) and (DATA['User6-Ev'].values[ts][ps] <= 3000):\n",
    "                    x = 'P1C1'\n",
    "                elif (DATA['User5-Ev'].values[ts][ps] <= 3600 ) and (DATA['User6-Ev'].values[ts][ps] > 3000):\n",
    "                    x = 'P1C2'\n",
    "            elif (DATA.iloc[ts]['U5'] == 0) and (DATA.iloc[ts]['U6'] == 0):\n",
    "                x = 'NoAction'\n",
    "        cluster_Ev56 = {'Ev-col1': [x], 'ts': DATA.iloc[ts].name}\n",
    "        cluster_Ev_df = pd.DataFrame(cluster_Ev56)\n",
    "        CLUSTER_EV_U56 = cluster_Ev_df.set_index('ts')\n",
    "\n",
    "        for ts in range(i,i+1):  #U1 = 70%, U2 = 50%\n",
    "            if (DATA.iloc[ts]['U1'] == 1) and (DATA.iloc[ts]['U2'] == 1):\n",
    "                if (DATA['ViewU1'].values[ts][ps] <= 70 ) and (DATA['ViewU2'].values[ts][ps] > 50) or (DATA['ViewU1'].values[ts][ps] > 70 ) and (DATA['ViewU2'].values[ts][ps] <= 50):\n",
    "                    x = 'P2C1'\n",
    "                elif (DATA['ViewU1'].values[ts][ps] <= 70 ) and (DATA['ViewU2'].values[ts][ps] <= 50):\n",
    "                    x = 'P2C3'\n",
    "                elif (DATA['ViewU1'].values[ts][ps] > 70 ) and (DATA['ViewU2'].values[ts][ps] > 50):\n",
    "                    x = 'P2C2'\n",
    "            elif (DATA.iloc[ts]['U1'] == 0) and (DATA.iloc[ts]['U2'] == 1):\n",
    "                if (DATA['ViewU1'].values[ts][ps] <= 70 ) and (DATA['ViewU2'].values[ts][ps] > 50):\n",
    "                    x = 'P2C2'\n",
    "                elif (DATA['ViewU1'].values[ts][ps] > 70 ) and (DATA['ViewU2'].values[ts][ps] > 50):\n",
    "                    x = 'P2C2'\n",
    "                elif (DATA['ViewU1'].values[ts][ps] <= 70 ) and (DATA['ViewU2'].values[ts][ps] <= 50):\n",
    "                    x = 'P2C1'\n",
    "                elif (DATA['ViewU1'].values[ts][ps] > 70 ) and (DATA['ViewU2'].values[ts][ps] <= 50):\n",
    "                    x = 'P2C1'\n",
    "            elif (DATA.iloc[ts]['U1'] == 1) and (DATA.iloc[ts]['U2'] == 0):\n",
    "                if (DATA['ViewU1'].values[ts][ps] <= 70 ) and (DATA['ViewU2'].values[ts][ps] > 50):\n",
    "                    x = 'P2C1'\n",
    "                elif (DATA['ViewU1'].values[ts][ps] > 70 ) and (DATA['ViewU2'].values[ts][ps] > 50):\n",
    "                    x = 'P2C2'\n",
    "                elif (DATA['ViewU1'].values[ts][ps] <= 70 ) and (DATA['ViewU2'].values[ts][ps] <= 50):\n",
    "                    x = 'P2C1'\n",
    "                elif (DATA['ViewU1'].values[ts][ps] > 70 ) and (DATA['ViewU2'].values[ts][ps] <= 50):\n",
    "                    x = 'P2C2'\n",
    "            elif (DATA.iloc[ts]['U1'] == 0) and (DATA.iloc[ts]['U2'] == 0):\n",
    "                x = 'NoAction'\n",
    "        cluster_View12 = {'View-col3': [x], 'ts': DATA.iloc[ts].name}\n",
    "        cluster_View_df = pd.DataFrame(cluster_View12)\n",
    "        CLUSTER_VIEW_U12 = cluster_View_df.set_index('ts')\n",
    "\n",
    "        for ts in range(i,i+1):  #U3 = 50%, U4 = 50%\n",
    "            if (DATA.iloc[ts]['U3'] == 1) and (DATA.iloc[ts]['U4'] == 1):\n",
    "                if (DATA['ViewU3'].values[ts][ps] <= 50 ) and (DATA['ViewU4'].values[ts][ps] > 50) or (DATA['ViewU3'].values[ts][ps] > 50 ) and (DATA['ViewU4'].values[ts][ps] <= 50):\n",
    "                    x = 'P2C1'\n",
    "                elif (DATA['ViewU3'].values[ts][ps] <= 50 ) and (DATA['ViewU4'].values[ts][ps] <= 50):\n",
    "                    x = 'P2C3'\n",
    "                elif (DATA['ViewU3'].values[ts][ps] > 50 ) and (DATA['ViewU4'].values[ts][ps] > 50):\n",
    "                    x = 'P2C2'\n",
    "            elif (DATA.iloc[ts]['U3'] == 0) and (DATA.iloc[ts]['U4'] == 1):\n",
    "                if (DATA['ViewU3'].values[ts][ps] <= 50 ) and (DATA['ViewU4'].values[ts][ps] <= 50):\n",
    "                    x = 'P2C1'\n",
    "                elif (DATA['ViewU3'].values[ts][ps] > 50 ) and (DATA['ViewU4'].values[ts][ps] > 50):\n",
    "                    x = 'P2C2'\n",
    "                elif (DATA['ViewU3'].values[ts][ps] > 50 ) and (DATA['ViewU4'].values[ts][ps] <= 50):\n",
    "                    x = 'P2C1'\n",
    "                elif (DATA['ViewU3'].values[ts][ps] <= 50 ) and (DATA['ViewU4'].values[ts][ps] > 50):\n",
    "                    x = 'P2C2'\n",
    "            elif (DATA.iloc[ts]['U3'] == 1) and (DATA.iloc[ts]['U4'] == 0):\n",
    "                if (DATA['ViewU3'].values[ts][ps] <= 50 ) and (DATA['ViewU4'].values[ts][ps] <= 50):\n",
    "                    x = 'P2C1'\n",
    "                elif (DATA['ViewU3'].values[ts][ps] > 50 ) and (DATA['ViewU4'].values[ts][ps] > 50):\n",
    "                    x = 'P2C2'\n",
    "                elif (DATA['ViewU3'].values[ts][ps] > 50 ) and (DATA['ViewU4'].values[ts][ps] <= 50):\n",
    "                    x = 'P2C2'\n",
    "                elif (DATA['ViewU3'].values[ts][ps] <= 50 ) and (DATA['ViewU4'].values[ts][ps] > 50):\n",
    "                    x = 'P2C1'\n",
    "            elif (DATA.iloc[ts]['U3'] == 0) and (DATA.iloc[ts]['U4'] == 0):\n",
    "                x = 'NoAction'\n",
    "        cluster_View34 = {'View-col2': [x], 'ts': DATA.iloc[ts].name}\n",
    "        cluster_View_df = pd.DataFrame(cluster_View34)\n",
    "        CLUSTER_VIEW_U34 = cluster_View_df.set_index('ts')\n",
    "\n",
    "        for ts in range(i,i+1): #U5 = 90%, U6 = 35%\n",
    "            if (DATA.iloc[ts]['U5'] == 1) and (DATA.iloc[ts]['U6'] == 1):            \n",
    "                if (DATA['ViewU5'].values[ts][ps] <= 90 ) and (DATA['ViewU6'].values[ts][ps] > 35) or (DATA['ViewU5'].values[ts][ps] > 90 ) and (DATA['ViewU6'].values[ts][ps] <= 35):\n",
    "                    x = 'P2C1'\n",
    "                elif (DATA['ViewU5'].values[ts][ps] <= 90 ) and (DATA['ViewU6'].values[ts][ps] <= 35):\n",
    "                    x = 'P2C3'\n",
    "                elif (DATA['ViewU5'].values[ts][ps] > 90 ) and (DATA['ViewU6'].values[ts][ps] > 35):\n",
    "                    x = 'P2C2'\n",
    "            elif (DATA.iloc[ts]['U5'] == 0) and (DATA.iloc[ts]['U6'] == 1):\n",
    "                if (DATA['ViewU5'].values[ts][ps] <= 90 ) and (DATA['ViewU6'].values[ts][ps] <= 35):\n",
    "                    x = 'P2C1'\n",
    "                elif (DATA['ViewU5'].values[ts][ps] > 90 ) and (DATA['ViewU6'].values[ts][ps] > 35):\n",
    "                    x = 'P2C2'\n",
    "                elif (DATA['ViewU5'].values[ts][ps] > 90 ) and (DATA['ViewU6'].values[ts][ps] <= 35):\n",
    "                    x = 'P2C1'\n",
    "                elif (DATA['ViewU5'].values[ts][ps] <= 90 ) and (DATA['ViewU6'].values[ts][ps] > 35):\n",
    "                    x = 'P2C2'\n",
    "            elif (DATA.iloc[ts]['U5'] == 1) and (DATA.iloc[ts]['U6'] == 0):\n",
    "                if (DATA['ViewU5'].values[ts][ps] <= 90 ) and (DATA['ViewU6'].values[ts][ps] <= 35):\n",
    "                    x = 'P2C1'\n",
    "                elif (DATA['ViewU5'].values[ts][ps] > 90 ) and (DATA['ViewU6'].values[ts][ps] > 35):\n",
    "                    x = 'P2C2'\n",
    "                elif (DATA['ViewU5'].values[ts][ps] > 90 ) and (DATA['ViewU6'].values[ts][ps] <= 35):\n",
    "                    x = 'P2C2'\n",
    "                elif (DATA['ViewU5'].values[ts][ps] <= 90 ) and (DATA['ViewU6'].values[ts][ps] > 35):\n",
    "                    x = 'P2C1'\n",
    "            elif (DATA.iloc[ts]['U5'] == 0) and (DATA.iloc[ts]['U6'] == 0):\n",
    "                x = 'NoAction'\n",
    "        cluster_View56 = {'View-col1': [x], 'ts': DATA.iloc[ts].name}\n",
    "        cluster_View_df = pd.DataFrame(cluster_View56)\n",
    "        CLUSTER_VIEW_U56 = cluster_View_df.set_index('ts')\n",
    "\n",
    "        for ts in range(i,i+1): #U1 = 300, U2 = 650\n",
    "            if (DATA.iloc[ts]['U1'] == 1) and (DATA.iloc[ts]['U2'] == 1):\n",
    "                if (DATA['User1-ill'].values[ts][ps] < 300 ) and (DATA['User2-ill'].values[ts][ps] >= 650) or (DATA['User1-ill'].values[ts][ps] >= 300 ) and (DATA['User2-ill'].values[ts][ps] < 650):\n",
    "                    x = 'P3C1'\n",
    "                elif (DATA['User1-ill'].values[ts][ps] >= 300 ) and (DATA['User2-ill'].values[ts][ps] >= 650):\n",
    "                    x = 'P3C2'\n",
    "                elif (DATA['User1-ill'].values[ts][ps] < 300 ) and (DATA['User2-ill'].values[ts][ps] < 650):\n",
    "                    x = 'P3C3'\n",
    "            elif (DATA.iloc[ts]['U1'] == 0) and (DATA.iloc[ts]['U2'] == 1):\n",
    "                if (DATA['User1-ill'].values[ts][ps] >= 300 ) and (DATA['User2-ill'].values[ts][ps] >= 650):\n",
    "                    x = 'P3C2'\n",
    "                elif (DATA['User1-ill'].values[ts][ps] < 300 ) and (DATA['User2-ill'].values[ts][ps] < 650):\n",
    "                    x = 'P3C1'\n",
    "                elif (DATA['User1-ill'].values[ts][ps] > 300 ) and (DATA['User2-ill'].values[ts][ps] < 650):\n",
    "                    x = 'P3C1'\n",
    "                elif (DATA['User1-ill'].values[ts][ps] < 300 ) and (DATA['User2-ill'].values[ts][ps] > 650):\n",
    "                    x = 'P3C2'\n",
    "            elif (DATA.iloc[ts]['U1'] == 1) and (DATA.iloc[ts]['U2'] == 0):\n",
    "                if (DATA['User1-ill'].values[ts][ps] >= 300 ) and (DATA['User2-ill'].values[ts][ps] >= 650):\n",
    "                    x = 'P3C2'\n",
    "                elif (DATA['User1-ill'].values[ts][ps] < 300 ) and (DATA['User2-ill'].values[ts][ps] < 650):\n",
    "                    x = 'P3C1'\n",
    "                elif (DATA['User1-ill'].values[ts][ps] > 300 ) and (DATA['User2-ill'].values[ts][ps] < 650):\n",
    "                    x = 'P3C2'\n",
    "                elif (DATA['User1-ill'].values[ts][ps] < 300 ) and (DATA['User2-ill'].values[ts][ps] > 650):\n",
    "                    x = 'P3C1'\n",
    "            elif (DATA.iloc[ts]['U1'] == 0) and (DATA.iloc[ts]['U2'] == 0):\n",
    "                x = 'NoAction'\n",
    "        cluster_ill12 = {'ill-col3': [x], 'ts': DATA.iloc[ts].name}\n",
    "        cluster_ill_df = pd.DataFrame(cluster_ill12)\n",
    "        CLUSTER_ILL_U12 = cluster_ill_df.set_index('ts')\n",
    "\n",
    "        for ts in range(i,i+1): #U3 = 2500, U4 = 1500\n",
    "            if (DATA.iloc[ts]['U3'] == 1) and (DATA.iloc[ts]['U4'] == 1):\n",
    "                if (DATA['User3-ill'].values[ts][ps] < 2500 ) and (DATA['User4-ill'].values[ts][ps] >= 1500) or (DATA['User3-ill'].values[ts][ps] >= 2500 ) and (DATA['User4-ill'].values[ts][ps] < 1500):\n",
    "                    x = 'P3C1'\n",
    "                elif (DATA['User3-ill'].values[ts][ps] >= 2500 ) and (DATA['User4-ill'].values[ts][ps] >= 1500):\n",
    "                    x = 'P3C2'\n",
    "                elif (DATA['User3-ill'].values[ts][ps] < 2500 ) and (DATA['User4-ill'].values[ts][ps] < 1500):\n",
    "                    x = 'P3C3'\n",
    "            elif (DATA.iloc[ts]['U3'] == 0) and (DATA.iloc[ts]['U4'] == 1):\n",
    "                if (DATA['User3-ill'].values[ts][ps] >= 2500 ) and (DATA['User4-ill'].values[ts][ps] >= 1500):\n",
    "                    x = 'P3C2'\n",
    "                elif (DATA['User3-ill'].values[ts][ps] < 2500 ) and (DATA['User4-ill'].values[ts][ps] < 1500):\n",
    "                    x = 'P3C1'\n",
    "                elif (DATA['User3-ill'].values[ts][ps] < 2500 ) and (DATA['User4-ill'].values[ts][ps] > 1500):\n",
    "                    x = 'P3C2'\n",
    "                elif (DATA['User3-ill'].values[ts][ps] > 2500 ) and (DATA['User4-ill'].values[ts][ps] < 1500):\n",
    "                    x = 'P3C1'\n",
    "            elif (DATA.iloc[ts]['U3'] == 1) and (DATA.iloc[ts]['U4'] == 0):\n",
    "                if (DATA['User3-ill'].values[ts][ps] >= 2500 ) and (DATA['User4-ill'].values[ts][ps] >= 1500):\n",
    "                    x = 'P3C2'\n",
    "                elif (DATA['User3-ill'].values[ts][ps] < 2500 ) and (DATA['User4-ill'].values[ts][ps] < 1500):\n",
    "                    x = 'P3C1'\n",
    "                elif (DATA['User3-ill'].values[ts][ps] < 2500 ) and (DATA['User4-ill'].values[ts][ps] > 1500):\n",
    "                    x = 'P3C1'\n",
    "                elif (DATA['User3-ill'].values[ts][ps] > 2500 ) and (DATA['User4-ill'].values[ts][ps] < 1500):\n",
    "                    x = 'P3C2'\n",
    "            elif (DATA.iloc[ts]['U3'] == 0) and (DATA.iloc[ts]['U4'] == 0):\n",
    "                x = 'NoAction'\n",
    "        cluster_ill34 = {'ill-col2': [x], 'ts': DATA.iloc[ts].name}\n",
    "        cluster_ill_df = pd.DataFrame(cluster_ill34)\n",
    "        CLUSTER_ILL_U34 = cluster_ill_df.set_index('ts')\n",
    "\n",
    "        for ts in range(i,i+1): #U5 = 1000, U6 = 150\n",
    "            if (DATA.iloc[ts]['U5'] == 1) and (DATA.iloc[ts]['U6'] == 1):\n",
    "                if (DATA['User5-ill'].values[ts][ps] < 1000 ) and (DATA['User6-ill'].values[ts][ps] >= 150) or (DATA['User5-ill'].values[ts][ps] >= 1000 ) and (DATA['User6-ill'].values[ts][ps] < 150):\n",
    "                    x = 'P3C1'\n",
    "                elif (DATA['User5-ill'].values[ts][ps] >= 1000 ) and (DATA['User6-ill'].values[ts][ps] >= 150):\n",
    "                    x = 'P3C2'\n",
    "                elif (DATA['User5-ill'].values[ts][ps] < 1000 ) and (DATA['User6-ill'].values[ts][ps] < 150):\n",
    "                    x = 'P3C3'\n",
    "            elif (DATA.iloc[ts]['U5'] == 0) and (DATA.iloc[ts]['U6'] == 1):\n",
    "                if (DATA['User5-ill'].values[ts][ps] >= 1000 ) and (DATA['User6-ill'].values[ts][ps] >= 150):\n",
    "                    x = 'P3C2'\n",
    "                elif (DATA['User5-ill'].values[ts][ps] < 1000 ) and (DATA['User6-ill'].values[ts][ps] < 150):\n",
    "                    x = 'P3C1'\n",
    "                elif (DATA['User5-ill'].values[ts][ps] < 1000 ) and (DATA['User6-ill'].values[ts][ps] > 150):\n",
    "                    x = 'P3C2'\n",
    "                elif (DATA['User5-ill'].values[ts][ps] > 1000 ) and (DATA['User6-ill'].values[ts][ps] < 150):\n",
    "                    x = 'P3C1'\n",
    "            elif (DATA.iloc[ts]['U5'] == 1) and (DATA.iloc[ts]['U6'] == 0):\n",
    "                if (DATA['User5-ill'].values[ts][ps] >= 1000 ) and (DATA['User6-ill'].values[ts][ps] >= 150):\n",
    "                    x = 'P3C2'\n",
    "                elif (DATA['User5-ill'].values[ts][ps] < 1000 ) and (DATA['User6-ill'].values[ts][ps] < 150):\n",
    "                    x = 'P3C1'\n",
    "                elif (DATA['User5-ill'].values[ts][ps] < 1000 ) and (DATA['User6-ill'].values[ts][ps] > 150):\n",
    "                    x = 'P3C1'\n",
    "                elif (DATA['User5-ill'].values[ts][ps] > 1000 ) and (DATA['User6-ill'].values[ts][ps] < 150):\n",
    "                    x = 'P3C2'\n",
    "            elif (DATA.iloc[ts]['U5'] == 0) and (DATA.iloc[ts]['U6'] == 0):\n",
    "                x = 'NoAction'\n",
    "        cluster_ill56 = {'ill-col1': [x], 'ts': DATA.iloc[ts].name}\n",
    "        cluster_ill_df = pd.DataFrame(cluster_ill56)\n",
    "        CLUSTER_ILL_U56 = cluster_ill_df.set_index('ts')\n",
    "        Rec = {**cluster_Ev56,**cluster_Ev34,**cluster_Ev12,**cluster_View56,**cluster_View34,**cluster_View12,**cluster_ill56,**cluster_ill34,**cluster_ill12}\n",
    "        RECORDS.append(Rec)\n",
    "        Records = pd.DataFrame(RECORDS)\n",
    "        Records.set_index('ts', inplace = True)\n",
    "\n",
    "        Clusters = pd.concat([CLUSTER_EV_U56,CLUSTER_EV_U34,CLUSTER_EV_U12,CLUSTER_VIEW_U56,CLUSTER_VIEW_U34,CLUSTER_VIEW_U12,CLUSTER_ILL_U56,CLUSTER_ILL_U34,CLUSTER_ILL_U12], axis =1 )\n",
    "\n",
    "        ##---------------------------------------------------Generating the POOL--------------------------------------------------##\n",
    "        cluster_app = []\n",
    "        for psi in range(0,64):\n",
    "            for nts in range(i+1,i+2):\n",
    "                if (DATA['User1-Ev'].values[nts][psi] <= 2800 ) and (DATA['User2-Ev'].values[nts][psi] > 1500) or (DATA['User1-Ev'].values[nts][psi] > 2800 ) and (DATA['User2-Ev'].values[nts][psi] <= 1500):\n",
    "                    ev12 = 'P1C1'\n",
    "                elif (DATA['User1-Ev'].values[nts][psi] <= 2800 ) and (DATA['User2-Ev'].values[nts][psi] <= 1500):\n",
    "                    ev12 = 'P1C2'\n",
    "                elif (DATA['User1-Ev'].values[nts][psi] > 2800 ) and (DATA['User2-Ev'].values[nts][psi] > 1500):\n",
    "                    ev12 = 'P1C3'\n",
    "                if (DATA['User3-Ev'].values[nts][psi] <= 1350 ) and (DATA['User4-Ev'].values[nts][psi] > 2000) or (DATA['User3-Ev'].values[nts][psi] > 1350 ) and (DATA['User4-Ev'].values[nts][psi] <= 2000):\n",
    "                    ev34 = 'P1C1'\n",
    "                elif (DATA['User3-Ev'].values[nts][psi] <= 1350 ) and (DATA['User4-Ev'].values[nts][psi] <= 2000):\n",
    "                    ev34 = 'P1C2'\n",
    "                elif (DATA['User3-Ev'].values[nts][psi] > 1350 ) and (DATA['User4-Ev'].values[nts][psi] > 2000):\n",
    "                    ev34 = 'P1C3'\n",
    "                if (DATA['User5-Ev'].values[nts][psi] <= 3600 ) and (DATA['User6-Ev'].values[nts][psi] > 3000) or (DATA['User5-Ev'].values[nts][psi] > 3600 ) and (DATA['User6-Ev'].values[nts][psi] <= 3000):\n",
    "                    ev56 = 'P1C1'\n",
    "                elif (DATA['User5-Ev'].values[nts][psi] <= 3600 ) and (DATA['User6-Ev'].values[nts][psi] <= 3000):\n",
    "                    ev56 = 'P1C2'\n",
    "                elif (DATA['User5-Ev'].values[nts][psi] > 3600 ) and (DATA['User6-Ev'].values[nts][psi] > 3000):\n",
    "                    ev56 = 'P1C3'\n",
    "                if (DATA['ViewU1'].values[nts][psi] <= 70 ) and (DATA['ViewU2'].values[nts][psi] > 50) or (DATA['ViewU1'].values[nts][psi] > 70 ) and (DATA['ViewU2'].values[nts][psi] <= 50):\n",
    "                    V12 = 'P2C1'\n",
    "                elif (DATA['ViewU1'].values[nts][psi] <= 70 ) and (DATA['ViewU2'].values[nts][psi] <= 50):\n",
    "                    V12 = 'P2C3'\n",
    "                elif (DATA['ViewU1'].values[nts][psi] > 70 ) and (DATA['ViewU2'].values[nts][psi] > 50):\n",
    "                    V12 = 'P2C2'\n",
    "                if (DATA['ViewU3'].values[nts][psi] <= 50 ) and (DATA['ViewU4'].values[nts][psi] > 50) or (DATA['ViewU3'].values[nts][psi] > 50 ) and (DATA['ViewU4'].values[nts][psi] <= 50):\n",
    "                    V34 = 'P2C1'\n",
    "                elif (DATA['ViewU3'].values[nts][psi] <= 50 ) and (DATA['ViewU4'].values[nts][psi] <= 50):\n",
    "                    V34 = 'P2C3'\n",
    "                elif (DATA['ViewU3'].values[nts][psi] > 50 ) and (DATA['ViewU4'].values[nts][psi] > 50):\n",
    "                    V34 = 'P2C2'\n",
    "                if (DATA['ViewU5'].values[nts][psi] <= 90 ) and (DATA['ViewU6'].values[nts][psi] > 35) or (DATA['ViewU5'].values[nts][psi] > 90 ) and (DATA['ViewU6'].values[nts][psi] <= 35):\n",
    "                    V56 = 'P2C1'\n",
    "                elif (DATA['ViewU5'].values[nts][psi] <= 90 ) and (DATA['ViewU6'].values[nts][psi] <= 35):\n",
    "                    V56 = 'P2C3'\n",
    "                elif (DATA['ViewU5'].values[nts][psi] > 90 ) and (DATA['ViewU6'].values[nts][psi] > 35):\n",
    "                    V56 = 'P2C2'\n",
    "                if (DATA['User1-ill'].values[nts][psi] < 1000 ) and (DATA['User2-ill'].values[nts][psi] >= 1200) or (DATA['User1-ill'].values[nts][psi] >= 1000 ) and (DATA['User2-ill'].values[nts][psi] < 1200):\n",
    "                    il12 = 'P3C1'\n",
    "                elif (DATA['User1-ill'].values[nts][psi] >= 1000 ) and (DATA['User2-ill'].values[nts][psi] >= 1200):\n",
    "                    il12 = 'P3C2'\n",
    "                elif (DATA['User1-ill'].values[nts][psi] < 1000 ) and (DATA['User2-ill'].values[nts][psi] < 1200):\n",
    "                    il12 = 'P3C3'\n",
    "                if (DATA['User3-ill'].values[nts][psi] < 2500 ) and (DATA['User4-ill'].values[nts][psi] >= 1500) or (DATA['User3-ill'].values[nts][psi] >= 2500 ) and (DATA['User4-ill'].values[nts][psi] < 1500):\n",
    "                    il34 = 'P3C1'\n",
    "                elif (DATA['User3-ill'].values[nts][psi] >= 2500 ) and (DATA['User4-ill'].values[nts][psi] >= 1500):\n",
    "                    il34 = 'P3C2'\n",
    "                elif (DATA['User3-ill'].values[nts][psi] < 2500 ) and (DATA['User4-ill'].values[nts][psi] < 1500):\n",
    "                    il34 = 'P3C3'\n",
    "                if (DATA['User5-ill'].values[nts][psi] < 8000 ) and (DATA['User6-ill'].values[nts][psi] >= 3000) or (DATA['User5-ill'].values[nts][psi] >= 8000 ) and (DATA['User6-ill'].values[nts][psi] < 3000):\n",
    "                    il56 = 'P3C1'\n",
    "                elif (DATA['User5-ill'].values[nts][psi] >= 8000 ) and (DATA['User6-ill'].values[nts][psi] >= 3000):\n",
    "                    il56 = 'P3C2'\n",
    "                elif (DATA['User5-ill'].values[nts][psi] < 8000 ) and (DATA['User6-ill'].values[nts][psi] < 3000):\n",
    "                    il56 = 'P3C3'\n",
    "                if (DATA['User1-ill'].values[nts][psi] >= 500 ) and (DATA['User2-ill'].values[nts][psi] >= 500) and (DATA['User3-ill'].values[nts][psi] >= 500 ) and (DATA['User4-ill'].values[nts][psi] >= 500) and (DATA['User5-ill'].values[nts][psi] >= 500) and (DATA['User6-ill'].values[nts][psi] >= 500):\n",
    "                    stageB2 = 'Met'\n",
    "                elif (DATA['User1-ill'].values[nts][psi] < 500 ) or (DATA['User2-ill'].values[nts][psi] < 500) or (DATA['User3-ill'].values[nts][psi] < 500 ) and (DATA['User4-ill'].values[nts][psi] >= 500) or (DATA['User5-ill'].values[nts][psi] < 500) or (DATA['User6-ill'].values[nts][psi] < 500):\n",
    "                    stageB2 = 'NOTMet'\n",
    "            cluster = {'Ev-col1' : ev56, 'Ev-col2' : ev34,'Ev-col3': ev12, 'View-col1': V56,'View-col2': V34,'View-col3': V12, 'ill-col1': il56,'ill-col2': il34,'ill-col3': il12, 'StageB2': stageB2, 'ts': DATA.iloc[i+1].name}\n",
    "            cluster_app.append(cluster)\n",
    "            cluster_df = pd.DataFrame(cluster_app)\n",
    "            Next_PnCn = cluster_df.set_index('ts')  \n",
    "\n",
    "        #----------------------------------------------------P1C3-------------------------------------------------------------------\n",
    "        #Identifiying the optimum shading position and its ID as \"PSnnn\"\n",
    "        # CONDITION: Changing to fully-closed shading position for all columns \n",
    "        # CENTRALIZED MECHANISM\n",
    "        def P1C3_nps(t): \n",
    "            for key, value in ps_dic.items(): \n",
    "                 if t == value: \n",
    "                    return key\n",
    "        ID_P1C3 = []\n",
    "        if (Clusters['Ev-col3'].values[0] == 'P1C3') or (Clusters['Ev-col2'].values[0] == 'P1C3') or (Clusters['Ev-col1'].values[0] == 'P1C3'):\n",
    "            P1C3_Opt = 'Ps000'\n",
    "        else:\n",
    "            P1C3_Opt = P1C3_nps(ps)\n",
    "        P1C3_dic = {'ts':DATA.index[i+1],'COL1' : P1C3_Opt[2], 'COL2':P1C3_Opt[3], 'COL3': P1C3_Opt[4]}\n",
    "        ID_P1C3.append(P1C3_dic)\n",
    "        P1C3 = pd.DataFrame(ID_P1C3)\n",
    "        P1C3.set_index('ts', inplace=True)\n",
    "        X1 = P1C3_dic['COL1']\n",
    "        X2 = P1C3_dic['COL2']\n",
    "        X3 = P1C3_dic['COL3']\n",
    "        P1C3_XX = 'Ps'+X1+X2+X3\n",
    "        P1C3_check = ps_dic[P1C3_XX]\n",
    "        if P1C3_check != ps:\n",
    "            result.append(P1C3_XX)\n",
    "            ps = P1C3_check\n",
    "            Driver.append('P1C3')\n",
    "            continue\n",
    "        else:\n",
    "            ps = P1C3_check\n",
    "\n",
    "        #----------------------------------------------------P2C3-------------------------------------------------------------------\n",
    "        #Identifiying the optimum shading position and its ID as \"PSnnn\"\n",
    "        # CONDITION: Adjust the shading position in response to View Rate where Ev is in comfortable range for other users if possible \n",
    "        # DECENTRALIZED MECHANISM\n",
    "\n",
    "        ID_P2C3 = []\n",
    "        for P2C3_i in range(0,64):\n",
    "            if (Clusters['View-col3'].values[0] == 'P2C3') and (Next_PnCn.iloc[P2C3_i][5] == 'P2C2') and (Next_PnCn.iloc[P2C3_i][0] != 'P1C3') and (Next_PnCn.iloc[P2C3_i][1] != 'P1C3') and (Next_PnCn.iloc[P2C3_i][2] != 'P1C3'):\n",
    "                P2C3_col3 = 'Yes'\n",
    "            else:\n",
    "                P2C3_col3 = 'No'\n",
    "            if (Clusters['View-col2'].values[0] == 'P2C3') and (Next_PnCn.iloc[P2C3_i][4] == 'P2C2') and (Next_PnCn.iloc[P2C3_i][0] != 'P1C3') and (Next_PnCn.iloc[P2C3_i][1] != 'P1C3') and (Next_PnCn.iloc[P2C3_i][2] != 'P1C3'):\n",
    "                P2C3_col2 = 'Yes'\n",
    "            else:\n",
    "                P2C3_col2 = 'No'\n",
    "            if (Clusters['View-col1'].values[0] == 'P2C3') and (Next_PnCn.iloc[P2C3_i][3] == 'P2C2') and (Next_PnCn.iloc[P2C3_i][0] != 'P1C3') and (Next_PnCn.iloc[P2C3_i][1] != 'P1C3') and (Next_PnCn.iloc[P2C3_i][2] != 'P1C3'):\n",
    "                P2C3_col1 = 'Yes'\n",
    "            else:\n",
    "                P2C3_col1 = 'No'\n",
    "            P2C3_dic = {'COL1' : P2C3_col1, 'COL2':P2C3_col2, 'COL3':P2C3_col3}\n",
    "            ID_P2C3.append(P2C3_dic)\n",
    "        P2C3_df = pd.DataFrame(ID_P2C3)\n",
    "\n",
    "        #Finding the ps corresponding to each column in a decentralized way\n",
    "\n",
    "        views_P2C3 = []\n",
    "        for P2C3_v3i in range(0,64):\n",
    "            if (P2C3_df.iloc[P2C3_v3i]['COL3'] == 'Yes') and (P2C3_df.iloc[P2C3_v3i]['COL2'] == 'Yes') and (P2C3_df.iloc[P2C3_v3i]['COL1'] == 'Yes') :\n",
    "                V123 = P2C3_df.iloc[P2C3_v3i].name\n",
    "                break\n",
    "            else: \n",
    "                V123 = -1\n",
    "        \n",
    "        P2C3_views = {'ts':DATA.index[i+1],'COL1':V123, 'COL2':V123,'COL3':V123}\n",
    "        views_P2C3.append(P2C3_views)\n",
    "        P2C3_IDs = pd.DataFrame(views_P2C3)\n",
    "        P2C3_IDs.set_index('ts',inplace = True)\n",
    "\n",
    "        indices_P2C3 = P2C3_IDs[['COL1','COL2','COL3']].values\n",
    "\n",
    "        ### Exracting the next Ps based on above order for P2C3 ###\n",
    "\n",
    "        def P2C3_nps(t): \n",
    "            for key, value in ps_dic.items(): \n",
    "                 if t == value: \n",
    "                    return key\n",
    "\n",
    "        P2C3_keys = []\n",
    "        for P2C3_ki in range(0,3):\n",
    "            if indices_P2C3[0][P2C3_ki] >= 0:\n",
    "                x = indices_P2C3[0][P2C3_ki]\n",
    "                P2C3_npss = P2C3_nps(x)[P2C3_ki+2] \n",
    "            elif indices_P2C3[0][P2C3_ki] == -1:\n",
    "                P2C3_npss = P2C3_nps(ps)[P2C3_ki+2]\n",
    "            P2C3_keys.append(P2C3_npss)\n",
    "        P2C3 = pd.DataFrame(P2C3_keys).transpose()\n",
    "        P2C3.rename(columns = {0:'COL1', 1:'COL2',2:'COL3'}, inplace = True)\n",
    "        P2C3['ts'] = DATA.index[i+1]\n",
    "        P2C3.set_index('ts',inplace = True)\n",
    "        X1 = str(int(P2C3['COL1'].values[0]))\n",
    "        X2 = str(int(P2C3['COL2'].values[0]))\n",
    "        X3 = str(int(P2C3['COL3'].values[0]))\n",
    "        P2C3_XX = 'Ps'+X1+X2+X3\n",
    "        P2C3_check = ps_dic[P2C3_XX]\n",
    "        if P2C3_check != ps:\n",
    "            result.append(P2C3_XX)\n",
    "            ps = P2C3_check\n",
    "            Driver.append('P2C3')\n",
    "            continue\n",
    "        else:\n",
    "            ps = P2C3_check\n",
    "\n",
    "        #----------------------------------------------------P1C1-------------------------------------------------------------------\n",
    "        #Identifiying the optimum shading position and its ID as \"PSnnn\"\n",
    "        # CONDITION: Adjust the shading position in response to Ev with least impact on neighbours’ view rate\n",
    "        # DECENTRALIZED MECHANISM\n",
    "        ID_P1C1 = []\n",
    "        for P1C1_i in range(0,64):\n",
    "            if (Clusters['Ev-col3'].values[0] == 'P1C1') or (Clusters['Ev-col2'].values[0] == 'P1C1') or (Clusters['Ev-col1'].values[0] == 'P1C1'):\n",
    "                if (Next_PnCn.iloc[P1C1_i][0] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][1] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][2] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][3] == 'P2C2') and (Next_PnCn.iloc[P1C1_i][4] == 'P2C2') and (Next_PnCn.iloc[P1C1_i][5] == 'P2C2'):\n",
    "                    P1C1_Opt = 'Yes'\n",
    "                elif (Next_PnCn.iloc[P1C1_i][0] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][1] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][2] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][3] == 'P2C2') and (Next_PnCn.iloc[P1C1_i][4] == 'P2C1') and (Next_PnCn.iloc[P1C1_i][5] == 'P2C2'):\n",
    "                    P1C1_Opt = 'Yes'\n",
    "                elif (Next_PnCn.iloc[P1C1_i][0] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][1] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][2] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][3] == 'P2C2') and (Next_PnCn.iloc[P1C1_i][4] == 'P2C2') and (Next_PnCn.iloc[P1C1_i][5] == 'P2C1'):\n",
    "                    P1C1_Opt = 'Yes'\n",
    "                elif (Next_PnCn.iloc[P1C1_i][0] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][1] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][2] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][3] == 'P2C1') and (Next_PnCn.iloc[P1C1_i][4] == 'P2C2') and (Next_PnCn.iloc[P1C1_i][5] == 'P2C2'):\n",
    "                    P1C1_Opt = 'Yes'\n",
    "                elif (Next_PnCn.iloc[P1C1_i][0] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][1] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][2] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][3] == 'P2C2') and (Next_PnCn.iloc[P1C1_i][4] == 'P2C1') and (Next_PnCn.iloc[P1C1_i][5] == 'P2C1'):\n",
    "                    P1C1_Opt = 'Yes'\n",
    "                elif (Next_PnCn.iloc[P1C1_i][0] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][1] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][2] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][3] == 'P2C1') and (Next_PnCn.iloc[P1C1_i][4] == 'P2C1') and (Next_PnCn.iloc[P1C1_i][5] == 'P2C2'):\n",
    "                    P1C1_Opt = 'Yes'\n",
    "                elif (Next_PnCn.iloc[P1C1_i][0] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][1] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][2] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][3] == 'P2C1') and (Next_PnCn.iloc[P1C1_i][4] == 'P2C2') and (Next_PnCn.iloc[P1C1_i][5] == 'P2C1'):\n",
    "                    P1C1_Opt = 'Yes'\n",
    "                elif (Next_PnCn.iloc[P1C1_i][0] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][1] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][2] == 'P1C2') and (Next_PnCn.iloc[P1C1_i][3] == 'P2C1') and (Next_PnCn.iloc[P1C1_i][4] == 'P2C1') and (Next_PnCn.iloc[P1C1_i][5] == 'P2C1'):\n",
    "                    P1C1_Opt = 'Yes'\n",
    "                else:\n",
    "                    P1C1_Opt = 'No'\n",
    "            else:\n",
    "                P1C1_Opt = 'No'\n",
    "            P1C1_dic = {'OPT' : P1C1_Opt}\n",
    "            ID_P1C1.append(P1C1_dic)\n",
    "            P1C1_df = pd.DataFrame(ID_P1C1)\n",
    "        P1C1_IDs = P1C1_df[P1C1_df['OPT'].str.contains(\"Yes\")]\n",
    "\n",
    "\n",
    "        indices_P1C1 = P1C1_IDs.index.tolist()\n",
    "\n",
    "        ### Exracting the next Ps based on above order for P1C1 from the dictionary ###\n",
    "\n",
    "        def P1C1_nps(t): \n",
    "            for key, value in ps_dic.items(): \n",
    "                 if t == value: \n",
    "                    return key\n",
    "\n",
    "        #Finding the optimum Ps based on the indoor illuminance in the depth of the room \n",
    "\n",
    "        max_ill_P1C1 = []\n",
    "        if indices_P1C1 != []:\n",
    "            for P1C1_ii in indices_P1C1:\n",
    "                P1C1_Backill = DATA.iloc[i+1]['Non-daylit Sensor'][P1C1_ii]\n",
    "                max_ill_P1C1.append(P1C1_Backill)\n",
    "                max_val = np.array(max_ill_P1C1).max()\n",
    "                max_val2 = np.array(max_ill_P1C1).argmax()\n",
    "                P1C1_max = indices_P1C1[max_val2]\n",
    "                P1C1_max_index = P1C1_nps(P1C1_max)\n",
    "                max_ill_P1C1_dic = {'COL1' : P1C1_max_index[2] , 'COL2':P1C1_max_index[3], 'COL3': P1C1_max_index[4], 'max_ill': max_val}\n",
    "        elif indices_P1C1 == []: #List is empty! then, keep current position\n",
    "            max_ill_P1C1_dic = {'COL1' : P1C1_nps(ps)[2] , 'COL2':P1C1_nps(ps)[3], 'COL3': P1C1_nps(ps)[4]}    \n",
    "        max_ill_df = pd.DataFrame(max_ill_P1C1_dic, index = ['0'])\n",
    "\n",
    "        P1C1_nps = max_ill_df.max().values[0:3]\n",
    "        P1C1 = pd.DataFrame(P1C1_nps).transpose()\n",
    "        P1C1.rename(columns = {0:'COL1', 1:'COL2',2:'COL3'}, inplace = True)\n",
    "        P1C1['ts'] = DATA.index[i+1]\n",
    "        P1C1.set_index('ts',inplace = True)\n",
    "        X1 = str(int(P1C1['COL1'].values[0]))\n",
    "        X2 = str(int(P1C1['COL2'].values[0]))\n",
    "        X3 = str(int(P1C1['COL3'].values[0]))\n",
    "        P1C1_XX = 'Ps'+X1+X2+X3\n",
    "        P1C1_check = ps_dic[P1C1_XX]\n",
    "        if P1C1_check != ps:\n",
    "            result.append(P1C1_XX)\n",
    "            ps = P1C1_check\n",
    "            Driver.append('P1C1')\n",
    "            continue\n",
    "        else:\n",
    "            ps = P1C1_check\n",
    "\n",
    "        #----------------------------------------------------P2C1-------------------------------------------------------------------\n",
    "        # Identifiying the optimum shading position and its ID as \"PSnnn\"\n",
    "        # CONDITION: Adjust the shading position in response to View Rate where Ev is in comfortable range \n",
    "        # DECENTRALIZED MECHANISM\n",
    "\n",
    "        ID_P2C1 = []\n",
    "        for P2C1_i in range(0,64):\n",
    "            if (Clusters['View-col3'].values[0] == 'P2C1') and (Next_PnCn.iloc[P2C1_i][5] == 'P2C2') and (Next_PnCn.iloc[P2C1_i][0] == 'P1C2') and (Next_PnCn.iloc[P2C1_i][1] == 'P1C2') and (Next_PnCn.iloc[P2C1_i][2] == 'P1C2'):\n",
    "                P2C1_col3 = 'Yes'\n",
    "            else:\n",
    "                P2C1_col3 = 'No'\n",
    "            if (Clusters['View-col2'].values[0] == 'P2C1') and (Next_PnCn.iloc[P2C1_i][4] == 'P2C2') and (Next_PnCn.iloc[P2C1_i][0] == 'P1C2') and (Next_PnCn.iloc[P2C1_i][1] == 'P1C2') and (Next_PnCn.iloc[P2C1_i][2] == 'P1C2'):\n",
    "                P2C1_col2 = 'Yes'\n",
    "            else:\n",
    "                P2C1_col2 = 'No'\n",
    "            if (Clusters['View-col1'].values[0] == 'P2C1') and (Next_PnCn.iloc[P2C1_i][3] == 'P2C2') and (Next_PnCn.iloc[P2C1_i][0] == 'P1C2') and (Next_PnCn.iloc[P2C1_i][1] == 'P1C2') and (Next_PnCn.iloc[P2C1_i][2] == 'P1C2'):\n",
    "                P2C1_col1 = 'Yes'\n",
    "            else:\n",
    "                P2C1_col1 = 'No'\n",
    "            P2C1_dic = {'COL1' : P2C1_col1, 'COL2':P2C1_col2, 'COL3':P2C1_col3}\n",
    "            ID_P2C1.append(P2C1_dic)\n",
    "        P2C1_df = pd.DataFrame(ID_P2C1)\n",
    "\n",
    "        #Finding the ps corresponding to each column in a decentralized way\n",
    "\n",
    "        views_P2C1 = []\n",
    "        for P2C1_v3i in range(0,64):\n",
    "            if (P2C1_df.iloc[P2C1_v3i]['COL3'] == 'Yes') and (P2C1_df.iloc[P2C1_v3i]['COL2'] == 'Yes') and (P2C1_df.iloc[P2C1_v3i]['COL1'] == 'Yes'):\n",
    "                V123 = P2C1_df.iloc[P2C1_v3i].name\n",
    "                break\n",
    "            else: \n",
    "                V123 = -1\n",
    "    \n",
    "        P2C1_views = {'ts':DATA.index[i+1],'COL1':V123, 'COL2':V123,'COL3':V123}\n",
    "        views_P2C1.append(P2C1_views)\n",
    "        P2C1_IDs = pd.DataFrame(views_P2C1)\n",
    "        P2C1_IDs.set_index('ts',inplace = True)\n",
    "\n",
    "        indices_P2C1 = P2C1_IDs[['COL1','COL2','COL3']].values\n",
    "\n",
    "        ### Exracting the next Ps based on above order for P2C1 ###\n",
    "\n",
    "        def P2C1_nps(t): \n",
    "            for key, value in ps_dic.items(): \n",
    "                 if t == value: \n",
    "                    return key\n",
    "\n",
    "        P2C1_keys = []\n",
    "        for P2C1_k in range(0,3):\n",
    "            if indices_P2C1[0][P2C1_k] >= 0:\n",
    "                x = indices_P2C1[0][P2C1_k]\n",
    "                P2C1_npss = P2C1_nps(x)[P2C1_k+2]\n",
    "            elif indices_P2C1[0][P2C1_k] == -1:  #If could not find an option, keep the position\n",
    "                P2C1_npss = P2C1_nps(ps)[P2C1_k+2] \n",
    "            P2C1_keys.append(P2C1_npss)\n",
    "        P2C1 = pd.DataFrame(P2C1_keys).transpose()\n",
    "        P2C1.rename(columns = {0:'COL1', 1:'COL2',2:'COL3'}, inplace = True)\n",
    "        P2C1['ts'] = DATA.index[i+1]\n",
    "        P2C1.set_index('ts',inplace = True)\n",
    "        X1 = str(int(P2C1['COL1'].values[0]))\n",
    "        X2 = str(int(P2C1['COL2'].values[0]))\n",
    "        X3 = str(int(P2C1['COL3'].values[0]))\n",
    "        P2C1_XX = 'Ps'+X1+X2+X3\n",
    "        P2C1_check = ps_dic[P2C1_XX]\n",
    "        if P2C1_check != ps:\n",
    "            result.append(P2C1_XX)\n",
    "            ps = P2C1_check\n",
    "            Driver.append('P2C1')\n",
    "            continue\n",
    "        else:\n",
    "            ps = P2C1_check\n",
    "\n",
    "        #----------------------------------------------------P3C3:P3C1-------------------------------------------------------------------\n",
    "        #Identifiying the optimum shading position and its ID as \"PSnnn\"\n",
    "        # CONDITION for P3C1: Adjust the shading position in response to Task illuminance where Ev is in comfortable range\n",
    "        # DECENTRALIZED MECHANISM\n",
    "\n",
    "        def P3C3_nps(t): \n",
    "            for key, value in ps_dic.items(): \n",
    "                 if t == value: \n",
    "                    return key\n",
    "        ID_P3C3o1 = []\n",
    "        for m in range(0,64):\n",
    "            if (Clusters['ill-col3'].values[0] == 'P3C3'):\n",
    "                P3C3o1_col3 = 'Fully-Open' \n",
    "            else:\n",
    "                if (Clusters['ill-col3'].values[0] == 'P3C1'):\n",
    "                    if (Next_PnCn.iloc[m][8] == 'P3C2') and (Next_PnCn.iloc[m][2] == 'P1C2'): #Ideal Option\n",
    "                        P3C3o1_col3 = 'Yes'\n",
    "                    elif (Next_PnCn.iloc[m][8] == 'P3C1') and (Next_PnCn.iloc[m][2] == 'P1C2'):\n",
    "                        P3C3o1_col3 = 'ConditionalYES' #One user remain dissatisfied, lights should turn ON\n",
    "                    else:\n",
    "                        P3C3o1_col3 = 'LightsON' # Turn on the lights if there is glare for all 64 positions (!=P1C2)\n",
    "                else:\n",
    "                    P3C3o1_col3 = 'No' # !=P3C1\n",
    "            if (Clusters['ill-col2'].values[0] == 'P3C3'): \n",
    "                P3C3o1_col2 =  'Fully-Open' \n",
    "            else:\n",
    "                if (Clusters['ill-col2'].values[0] == 'P3C1'): \n",
    "                    if (Next_PnCn.iloc[m][7] == 'P3C2') and (Next_PnCn.iloc[m][1] == 'P1C2'):\n",
    "                        P3C3o1_col2 = 'Yes'\n",
    "                    elif (Next_PnCn.iloc[m][7] == 'P3C1') and (Next_PnCn.iloc[m][1] == 'P1C2'):\n",
    "                        P3C3o1_col2 = 'ConditionalYES'\n",
    "                    else:\n",
    "                        P3C3o1_col2 = 'LightsON'\n",
    "                else:\n",
    "                    P3C3o1_col2 = 'No'\n",
    "            if (Clusters['ill-col1'].values[0] == 'P3C3'):\n",
    "                P3C1_col1 =  'Fully-Open' \n",
    "            else: \n",
    "                if (Clusters['ill-col1'].values[0] == 'P3C1'):\n",
    "                    if (Next_PnCn.iloc[m][6] == 'P3C2') and (Next_PnCn.iloc[m][0] == 'P1C2'):\n",
    "                        P3C3o1_col1 = 'Yes'\n",
    "                    elif (Next_PnCn.iloc[m][6] == 'P3C1') and (Next_PnCn.iloc[m][0] == 'P1C2'):\n",
    "                        P3C3o1_col1 = 'ConditionalYES'\n",
    "                    else:\n",
    "                        P3C3o1_col1 = 'LightsON'\n",
    "                else:\n",
    "                    P3C3o1_col1 = 'No'       \n",
    "            P3C3o1_dic = {'COL1' : P3C3o1_col1, 'COL2':P3C3o1_col2, 'COL3':P3C3o1_col3}\n",
    "            ID_P3C3o1.append(P3C3o1_dic)\n",
    "        P3C3o1_df = pd.DataFrame(ID_P3C3o1)\n",
    "\n",
    "        #Finding the ps corresponding to each column in a decentralized way\n",
    "\n",
    "        ills_P3C3o1 = []\n",
    "        for m1 in range(0,64):\n",
    "            if P3C3o1_df.iloc[m1]['COL3'] == 'Fully-Open':\n",
    "                i3 = P3C3_nps(42)\n",
    "                break\n",
    "            elif P3C3o1_df.iloc[m1]['COL3'] == 'Yes':\n",
    "                i3 = P3C3o1_df.iloc[m1].name\n",
    "                break\n",
    "            elif P3C3o1_df.iloc[m1]['COL3'] == 'ConditionalYES':\n",
    "                i3 = -1\n",
    "            elif P3C3o1_df.iloc[m1]['COL3'] == 'No': \n",
    "                i3 = -2\n",
    "            elif P3C3o1_df.iloc[m1]['COL3'] == 'LightsON': \n",
    "                i3 = -3\n",
    "        for m2 in range(0,64):\n",
    "            if P3C3o1_df.iloc[m2]['COL2'] == 'Fully-Open':\n",
    "                i2 = P3C3_nps(42)\n",
    "                break\n",
    "            elif P3C3o1_df.iloc[m2]['COL2'] == 'Yes':\n",
    "                i2 = P3C3o1_df.iloc[m2].name\n",
    "                break\n",
    "            elif P3C3o1_df.iloc[m2]['COL2'] == 'ConditionalYES':\n",
    "                i2 = -1\n",
    "            elif P3C3o1_df.iloc[m2]['COL2'] =='No': \n",
    "                i2 = -2\n",
    "            elif P3C3o1_df.iloc[m2]['COL2'] == 'LightsON': \n",
    "                i2 = -3\n",
    "        for m3 in range(0,64):\n",
    "            if P3C3o1_df.iloc[m3]['COL1'] == 'Fully-Open':\n",
    "                i1 = P3C3_nps(42)\n",
    "                break    \n",
    "            elif P3C3o1_df.iloc[m3]['COL1'] == 'Yes':\n",
    "                i1 = P3C3o1_df.iloc[m3].name\n",
    "                break\n",
    "            elif P3C3o1_df.iloc[m3]['COL1'] == 'ConditionalYES':\n",
    "                i1 = -1\n",
    "            elif P3C3o1_df.iloc[m3]['COL1'] == 'No': \n",
    "                i1 = -2\n",
    "            elif P3C3o1_df.iloc[m3]['COL1'] == 'LightsON': \n",
    "                i1 = -3\n",
    "        P3C3o1_views = {'ts':DATA.index[nts],'COL1':i1, 'COL2':i2,'COL3':i3}\n",
    "        ills_P3C3o1.append(P3C3o1_views)\n",
    "        P3C3o1_IDs = pd.DataFrame(ills_P3C3o1)\n",
    "        P3C3o1_IDs.set_index('ts',inplace = True)\n",
    "\n",
    "        indices_P3C3o1 = P3C3o1_IDs[['COL1','COL2','COL3']].values\n",
    "\n",
    "        ### Exracting the next Ps based on above order for P3C3 ###\n",
    "\n",
    "        def P3C1_nps(t): \n",
    "            for key, value in ps_dic.items(): \n",
    "                 if t == value: \n",
    "                    return key\n",
    "\n",
    "        P3C3o1_keys = []\n",
    "        for m4 in range(0,3):\n",
    "            if indices_P3C3o1[0][m4] == 'Ps444' :\n",
    "                P3C3o1_npss = P3C1_nps(42)[m4+2]\n",
    "            elif indices_P3C3o1[0][m4] >= 0:\n",
    "                x = indices_P3C3o1[0][m4]\n",
    "                P2C3o1_npss = P3C1_nps(x)[m4+2]\n",
    "            elif indices_P3C3o1[0][m4] == -1:\n",
    "                P3C3o1_npss = P3C1_nps(ps)[m4+2] #+ ' *' #Keep the initial Ps and Light is ON for one of the users\n",
    "            elif indices_P3C3o1[0][m4] == -2:\n",
    "                P3C3o1_npss = P3C1_nps(ps)[m4+2]\n",
    "            elif indices_P3C3o1[0][m4] == -3:\n",
    "                P3C3o1_npss = P3C1_nps(ps)[m4+2] #+ ' **' #Keep the initial Ps and Light is ON for both users\n",
    "            P3C3o1_keys.append(P3C3o1_npss)\n",
    "        P3C3_P3C1 = pd.DataFrame(P3C3o1_keys).transpose()\n",
    "        P3C3_P3C1.rename(columns = {0:'COL1', 1:'COL2',2:'COL3'}, inplace = True)\n",
    "        P3C3_P3C1['ts'] = DATA.index[i+1]\n",
    "        P3C3_P3C1.set_index('ts',inplace = True)\n",
    "        X1 = str(int(P3C3_P3C1['COL1'].values[0]))\n",
    "        X2 = str(int(P3C3_P3C1['COL2'].values[0]))\n",
    "        X3 = str(int(P3C3_P3C1['COL3'].values[0]))\n",
    "        P3C3_P3C1_XX = 'Ps'+X1+X2+X3\n",
    "\n",
    "        P3C3_P3C1_check = ps_dic[P3C3_P3C1_XX]\n",
    "        if P3C3_P3C1_check != ps:\n",
    "            result.append(P3C3_P3C1_XX)\n",
    "            ps = P3C3_P3C1_check\n",
    "            Driver.append('P3C3_P3C1')\n",
    "            continue\n",
    "        else:\n",
    "            ps = P3C3_P3C1_check\n",
    "\n",
    "    #----------------------------------------------------P1C2:P2C2:P3C2----------------------------------------------------------\n",
    "        def PnC2_nps(t): \n",
    "            for key, value in ps_dic.items(): \n",
    "                 if t == value: \n",
    "                    return key\n",
    "        if (Clusters['Ev-col3'].values[0] != 'P1C1') and (Clusters['Ev-col3'].values[0] != 'P1C3') and (Clusters['ill-col3'].values[0] != 'P3C1') and (Clusters['ill-col3'].values[0] != 'P3C3') and (Clusters['View-col3'].values[0] != 'P2C1') and (Clusters['View-col3'].values[0] != 'P2C3') and (Clusters['Ev-col2'].values[0] != 'P1C1') and (Clusters['Ev-col2'].values[0] != 'P1C3') and (Clusters['ill-col2'].values[0] != 'P3C1') and (Clusters['ill-col2'].values[0] != 'P3C3') and (Clusters['View-col2'].values[0] != 'P2C1') and (Clusters['View-col2'].values[0] != 'P2C3') and (Clusters['Ev-col1'].values[0] != 'P1C1') and (Clusters['Ev-col1'].values[0] != 'P1C3') and (Clusters['ill-col1'].values[0] != 'P3C1') and (Clusters['ill-col1'].values[0] != 'P3C3') and (Clusters['View-col1'].values[0] != 'P2C1') and (Clusters['View-col1'].values[0] != 'P2C3'):\n",
    "            for PnC2_i in range(0,64):\n",
    "                if (Next_PnCn.iloc[PnC2_i][9] == 'Met'):\n",
    "                    PnC2_check = PnC2_nps(PnC2_i)\n",
    "                    ps = ps_dic[PnC2_check]\n",
    "                    result.append(PnC2_check)\n",
    "                    Driver.append('PnC2')\n",
    "                    break\n",
    "                elif (Next_PnCn['StageB2'].all() == 'NOTMet'):\n",
    "                    ps = ps_dic['Ps444']\n",
    "                    result.append('Ps444')\n",
    "                    Driver.append('PnC2')\n",
    "                    break\n",
    "        else:\n",
    "            PnC2_check = PnC2_nps(ps)\n",
    "            result.append(PnC2_check)\n",
    "            ps = ps_dic[PnC2_check]\n",
    "            Driver.append('NONE')\n",
    "        \n",
    "                  \n",
    "\n",
    "stop = timeit.default_timer()\n",
    "execution_time = stop - start\n",
    "\n",
    "print(\"Program Executed in \"+str(execution_time)) # It returns time in seconds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Adding the time-dependent control decisions delivered by PRC algorithm including the shading position and visual comfort driver based on pre-defined clusters introduced in the research:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Records['PS']=result\n",
    "Records['Driver'] = Driver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ps_ALL = list(Records['PS'])\n",
    "Ps_ALL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>THE OUTCOME WILL BE A SINGLE DATAFRAME (Ps_ALL) THAT CONTAINS VISUAL COMFORT PREFERENCES FOR EACH COLUMNS BASED ON THE DEVELOPED CLUTSERS, THE DELIVERED SHADING POSITION AND THE CONTROL DRIVER FOR EACH TIME-STEP<b>\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### REPORTING and VISUALIZING"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Plotting the shading position frequecies for each column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "VAR = Ps_ALL  \n",
    "PS_Freq = []\n",
    "for ts in range(0,26280):\n",
    "    x1 = VAR[ts][2]\n",
    "    x2 = VAR[ts][3]\n",
    "    x3 = VAR[ts][4]\n",
    "    PS_Freq_dic = {'COL1': x1, 'COL2': x2, 'COL3' : x3, 'ts':DATA.iloc[ts].name}\n",
    "    PS_Freq.append(PS_Freq_dic)\n",
    "    Frequency = pd.DataFrame(PS_Freq)\n",
    "    \n",
    "Frequency_COL1 = Frequency.pivot_table(index=['COL1'], aggfunc='size')\n",
    "Frequency_COL2 = Frequency.pivot_table(index=['COL2'], aggfunc='size')\n",
    "Frequency_COL3 = Frequency.pivot_table(index=['COL3'], aggfunc='size')\n",
    "Frequency_COL1.to_frame(name=\"COL1\")\n",
    "Frequency_COL2.to_frame(name=\"COL1\")\n",
    "Frequency_COL3.to_frame(name=\"COL1\")\n",
    "FRQ = pd.concat([Frequency_COL1,Frequency_COL2,Frequency_COL3], axis = 1)\n",
    "FRQ.rename(columns={0:'COL1',1:'COL2',2:'COL3'})\n",
    "Frequency.set_index('ts',inplace=True)\n",
    "FRQ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Following the delivered shading configuration for each time-step, here, we are plotting the final visual comfort performance of each user with respect to Et, Ev, and VR, plus fractional lighting power for each daylit space and non-daylit space at depth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "VAR = Ps_ALL\n",
    "\n",
    "plt_appended = []\n",
    "for ts in range(0,26280):\n",
    "    U1_ill = DATA['User1-ill'].values[ts][ps_dic[VAR[ts]]]\n",
    "    U2_ill = DATA['User2-ill'].values[ts][ps_dic[VAR[ts]]] \n",
    "    U3_ill = DATA['User3-ill'].values[ts][ps_dic[VAR[ts]]]\n",
    "    U4_ill = DATA['User4-ill'].values[ts][ps_dic[VAR[ts]]] \n",
    "    U5_ill = DATA['User5-ill'].values[ts][ps_dic[VAR[ts]]]\n",
    "    U6_ill = DATA['User6-ill'].values[ts][ps_dic[VAR[ts]]] \n",
    "    U1_Ev = DATA['User1-Ev'].values[ts][ps_dic[VAR[ts]]] \n",
    "    U2_Ev = DATA['User2-Ev'].values[ts][ps_dic[VAR[ts]]] \n",
    "    U3_Ev = DATA['User3-Ev'].values[ts][ps_dic[VAR[ts]]] \n",
    "    U4_Ev = DATA['User4-Ev'].values[ts][ps_dic[VAR[ts]]] \n",
    "    U5_Ev = DATA['User5-Ev'].values[ts][ps_dic[VAR[ts]]] \n",
    "    U6_Ev = DATA['User6-Ev'].values[ts][ps_dic[VAR[ts]]] \n",
    "    U1_VR = DATA['ViewU1'].values[ts][ps_dic[VAR[ts]]] \n",
    "    U2_VR = DATA['ViewU2'].values[ts][ps_dic[VAR[ts]]] \n",
    "    U3_VR = DATA['ViewU3'].values[ts][ps_dic[VAR[ts]]] \n",
    "    U4_VR = DATA['ViewU4'].values[ts][ps_dic[VAR[ts]]] \n",
    "    U5_VR = DATA['ViewU5'].values[ts][ps_dic[VAR[ts]]] \n",
    "    U6_VR = DATA['ViewU6'].values[ts][ps_dic[VAR[ts]]]\n",
    "    U1_Uo = DATA['User1-Uo'].values[ts][ps_dic[VAR[ts]]]\n",
    "    U2_Uo = DATA['User2-Uo'].values[ts][ps_dic[VAR[ts]]]\n",
    "    U3_Uo = DATA['User3-Uo'].values[ts][ps_dic[VAR[ts]]]\n",
    "    U4_Uo = DATA['User4-Uo'].values[ts][ps_dic[VAR[ts]]]\n",
    "    U5_Uo = DATA['User5-Uo'].values[ts][ps_dic[VAR[ts]]]\n",
    "    U6_Uo = DATA['User6-Uo'].values[ts][ps_dic[VAR[ts]]]    \n",
    "    lght_col3 = DATA['LightingFractionZoneOne'].values[ts][ps_dic[VAR[ts]]]\n",
    "    lght_col2 = DATA['LightingFractionZoneTwo'].values[ts][ps_dic[VAR[ts]]]\n",
    "    lght_col1 = DATA['LightingFractionZoneThree'].values[ts][ps_dic[VAR[ts]]]\n",
    "    lght_depth = DATA['LightingFraction-Non-daylit'].values[ts][ps_dic[VAR[ts]]]\n",
    "    U1_OCC = DATA['U1'].values[ts]\n",
    "    U2_OCC = DATA['U2'].values[ts]\n",
    "    U3_OCC = DATA['U3'].values[ts]\n",
    "    U4_OCC = DATA['U4'].values[ts]\n",
    "    U5_OCC = DATA['U5'].values[ts]\n",
    "    U6_OCC = DATA['U6'].values[ts]\n",
    "\n",
    "    plotting = {'U1_Uo':U1_Uo,'U2_Uo':U2_Uo,'U3_Uo':U3_Uo,'U4_Uo':U4_Uo,'U5_Uo':U5_Uo,'U6_Uo':U6_Uo,'U1_Ev':U1_Ev,'U2_Ev':U2_Ev,'U3_Ev':U3_Ev,'U4_Ev':U4_Ev,'U5_Ev':U5_Ev,'U6_Ev':U6_Ev,'U1_VR':U1_VR,'U2_VR':U2_VR,'U3_VR':U3_VR,'U4_VR':U4_VR,'U5_VR':U5_VR,'U6_VR':U6_VR,'U1_ill': U1_ill,'U2_ill':U2_ill,'U3_ill':U3_ill,'U4_ill': U4_ill,'U5_ill': U5_ill,'U6_ill': U6_ill, 'LightPowerCOL1':lght_col1,'LightPowerCOL2':lght_col2, 'LightPowerCOL3':lght_col3,'LightPowerDEPTH':lght_depth, 'U1':U1_OCC,'U2':U2_OCC,'U3':U3_OCC,'U4':U4_OCC,'U5':U5_OCC,'U6':U6_OCC, 'ts': DATA.iloc[ts].name}\n",
    "    plt_appended.append(plotting)\n",
    "    PLOT = pd.DataFrame(plt_appended)\n",
    "    PLOT.set_index('ts', inplace = True)\n",
    "    PLOT[\"LightPowerCOL1\"].replace({0:0.15}, inplace=True)\n",
    "    PLOT[\"LightPowerCOL2\"].replace({0:0.15}, inplace=True)\n",
    "    PLOT[\"LightPowerCOL3\"].replace({0:0.15}, inplace=True)\n",
    "    PLOT[\"LightPowerDEPTH\"].replace({0:0.15}, inplace=True)\n",
    "    PLOT\n",
    "    \n",
    "\n",
    "# End"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Plotting number of discomfort frequencies for each user with respect to Et, Ev, and VR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DIS = []\n",
    "for i in range(0,26280):\n",
    "    if PLOT['U1'].values[i] == 0:\n",
    "        dis_U1_Ev = 0\n",
    "        dis_U1_ill = 0\n",
    "        dis_U1_VR = 0\n",
    "    elif PLOT['U1'].values[i] == 1:\n",
    "        if PLOT['U1_Ev'].values[i] <= 2800:\n",
    "            dis_U1_Ev = 0\n",
    "        elif PLOT['U1_Ev'].values[i] > 2800:\n",
    "            dis_U1_Ev = 1\n",
    "        if PLOT['U1_VR'].values[i] <= 70:\n",
    "            dis_U1_VR = 1\n",
    "        elif PLOT['U1_VR'].values[i] > 70:\n",
    "            dis_U1_VR = 0\n",
    "        if PLOT['U1_ill'].values[i] <= 300:\n",
    "            dis_U1_ill = 1\n",
    "        elif PLOT['U1_ill'].values[i] > 300:\n",
    "            dis_U1_ill = 0\n",
    "    if PLOT['U2'].values[i] == 0:\n",
    "        dis_U2_Ev = 0\n",
    "        dis_U2_ill = 0\n",
    "        dis_U2_VR = 0\n",
    "    elif PLOT['U2'].values[i] == 1:\n",
    "        if PLOT['U2_Ev'].values[i] <= 1500:\n",
    "            dis_U2_Ev = 0\n",
    "        elif PLOT['U2_Ev'].values[i] > 1500:\n",
    "            dis_U2_Ev = 1\n",
    "        if PLOT['U2_VR'].values[i] <= 50:\n",
    "            dis_U2_VR = 1\n",
    "        elif PLOT['U2_VR'].values[i] > 50:\n",
    "            dis_U2_VR = 0\n",
    "        if PLOT['U2_ill'].values[i] <= 650:\n",
    "            dis_U2_ill = 1\n",
    "        elif PLOT['U2_ill'].values[i] > 650:\n",
    "            dis_U2_ill = 0\n",
    "    if PLOT['U3'].values[i] == 0:\n",
    "        dis_U3_Ev = 0\n",
    "        dis_U3_ill = 0\n",
    "        dis_U3_VR = 0\n",
    "    elif PLOT['U3'].values[i] == 1:\n",
    "        if PLOT['U3_Ev'].values[i] <= 1350:\n",
    "            dis_U3_Ev = 0\n",
    "        elif PLOT['U3_Ev'].values[i] > 1350:\n",
    "            dis_U3_Ev = 1\n",
    "        if PLOT['U3_VR'].values[i] <= 50:\n",
    "            dis_U3_VR = 1\n",
    "        elif PLOT['U3_VR'].values[i] > 50:\n",
    "            dis_U3_VR = 0\n",
    "        if PLOT['U3_ill'].values[i] <= 2500:\n",
    "            dis_U3_ill = 1\n",
    "        elif PLOT['U3_ill'].values[i] > 2500:\n",
    "            dis_U3_ill = 0\n",
    "    if PLOT['U4'].values[i] == 0:\n",
    "        dis_U4_Ev = 0\n",
    "        dis_U4_ill = 0\n",
    "        dis_U4_VR = 0\n",
    "    elif PLOT['U4'].values[i] == 1:\n",
    "        if PLOT['U4_Ev'].values[i] <= 2000:\n",
    "            dis_U4_Ev = 0\n",
    "        elif PLOT['U4_Ev'].values[i] > 2000:\n",
    "            dis_U4_Ev = 1\n",
    "        if PLOT['U4_VR'].values[i] <= 50:\n",
    "            dis_U4_VR = 1\n",
    "        elif PLOT['U4_VR'].values[i] > 50:\n",
    "            dis_U4_VR = 0\n",
    "        if PLOT['U4_ill'].values[i] <= 1500:\n",
    "            dis_U4_ill = 1\n",
    "        elif PLOT['U4_ill'].values[i] > 1500:\n",
    "            dis_U4_ill = 0\n",
    "    if PLOT['U5'].values[i] == 0:\n",
    "        dis_U5_Ev = 0\n",
    "        dis_U5_ill = 0\n",
    "        dis_U5_VR = 0\n",
    "    elif PLOT['U5'].values[i] == 1:\n",
    "        if PLOT['U5_Ev'].values[i] <= 3600:\n",
    "            dis_U5_Ev = 0\n",
    "        elif PLOT['U5_Ev'].values[i] > 3600:\n",
    "            dis_U5_Ev = 1\n",
    "        if PLOT['U5_VR'].values[i] <= 90:\n",
    "            dis_U5_VR = 1\n",
    "        elif PLOT['U5_VR'].values[i] > 90:\n",
    "            dis_U5_VR = 0\n",
    "        if PLOT['U5_ill'].values[i] <= 1000:\n",
    "            dis_U5_ill = 1\n",
    "        elif PLOT['U5_ill'].values[i] > 1000:\n",
    "            dis_U5_ill = 0\n",
    "    if PLOT['U6'].values[i] == 0:\n",
    "        dis_U6_Ev = 0\n",
    "        dis_U6_ill = 0\n",
    "        dis_U6_VR = 0\n",
    "    elif PLOT['U6'].values[i] == 1:\n",
    "        if PLOT['U6_Ev'].values[i] <= 3000:\n",
    "            dis_U6_Ev = 0\n",
    "        elif PLOT['U6_Ev'].values[i] > 3000:\n",
    "            dis_U6_Ev = 1\n",
    "        if PLOT['U6_VR'].values[i] <= 35:\n",
    "            dis_U6_VR = 1\n",
    "        elif PLOT['U6_VR'].values[i] > 35:\n",
    "            dis_U6_VR = 0\n",
    "        if PLOT['U6_ill'].values[i] <= 150:\n",
    "            dis_U6_ill = 1\n",
    "        elif PLOT['U6_ill'].values[i] > 150:\n",
    "            dis_U6_ill = 0\n",
    "    dis = {'U1_Ev': dis_U1_Ev, 'U1_VR':dis_U1_VR, 'U1_ill':dis_U1_ill,\n",
    "           'U2_Ev': dis_U2_Ev, 'U2_VR':dis_U2_VR, 'U2_ill':dis_U2_ill,\n",
    "          'U3_Ev': dis_U3_Ev, 'U3_VR':dis_U3_VR, 'U3_ill':dis_U3_ill,\n",
    "          'U4_Ev': dis_U4_Ev, 'U4_VR':dis_U4_VR, 'U4_ill':dis_U4_ill,\n",
    "          'U5_Ev': dis_U5_Ev, 'U5_VR':dis_U5_VR, 'U5_ill':dis_U5_ill,\n",
    "          'U6_Ev': dis_U6_Ev, 'U6_VR':dis_U6_VR, 'U6_ill':dis_U6_ill,}\n",
    "    DIS.append(dis)\n",
    "    DISCOMFORT = pd.DataFrame(DIS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DISCOMFORT.sum().plot.bar(figsize=(15,5), color='Red')"
   ]
  },
  {
   "attachments": {
    "DIS_SC_01.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![DIS_SC_01.png](attachment:DIS_SC_01.png)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}