WPP.Generate-Floorplan_PIPE-003_v2.1.1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Copyright (c) Microsoft Corporation.\n",
    "# Licensed under the MIT license.\n",
    "\n",
    "\n",
    "\n",
    "from IPython.display import display, Markdown, clear_output, HTML, Javascript, display_html\n",
    "import subprocess\n",
    "import sys\n",
    "\n",
    "display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index(), IPython.notebook.get_selected_index()+1)'))\n",
    "\n",
    "HTML('''<script>{\n",
    "    $('div.input').hide();\n",
    "    }''')\n",
    "\n",
    "display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index(), IPython.notebook.get_selected_index()+1)'))\n",
    "HTML('''<script>\n",
    "    code_show=true; \n",
    "    function code_toggle() {\n",
    "     if (code_show){\n",
    "     $('div.input').hide();\n",
    "     } else {\n",
    "     $('div.input').show();\n",
    "     }\n",
    "     code_show = !code_show\n",
    "    } \n",
    "    $( document ).ready(code_toggle);\n",
    "    </script>\n",
    "    The raw code for this IPython notebook is by default hidden for easier reading toggle on/off the raw code by clicking <a href=\"javascript:code_toggle()\">here</a>.''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import numpy as np\n",
    "import ipywidgets as widgets\n",
    "from ipyfilechooser import FileChooser\n",
    "from itertools import combinations, permutations, product\n",
    "from math import radians, cos, sin, asin, sqrt\n",
    "from ast import literal_eval as make_tuple\n",
    "from datetime import datetime, timedelta,date, time\n",
    "import os\n",
    "import random\n",
    "import pulp\n",
    "import csv\n",
    "from io import StringIO\n",
    "import scipy as sc\n",
    "from scipy import optimize as op\n",
    "import json\n",
    "import time\n",
    "import logging\n",
    "import sys\n",
    "from collections import deque\n",
    "import re\n",
    "\n",
    "\n",
    "def toggle_on_click_mode(change):\n",
    "    if change.new != None:\n",
    "        display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+2)'))\n",
    "\n",
    "\n",
    "def toggle_on_start_mode(change):\n",
    "    if change.new != None:\n",
    "        clear_output()\n",
    "        display(widgets.VBox([mode_title,mode_btns]))\n",
    "        display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+2)'))\n",
    "\n",
    "        \n",
    "stndmode_btn = widgets.ToggleButtons(\n",
    "    options=['Standard'],\n",
    "    value =None,\n",
    "    disabled=False,\n",
    "    button_style='info'\n",
    ")        \n",
    "        \n",
    "        \n",
    "\n",
    "mode_btns = widgets.ToggleButtons(\n",
    "    options=['Standard', 'Fixed Spaces'],\n",
    "    value =None,\n",
    "    disabled=False,\n",
    "    button_style='info'\n",
    ")\n",
    "\n",
    "start_title = widgets.Output()\n",
    "with start_title:\n",
    "    display(Markdown(\"# Generate Floorplan\"))\n",
    "    display(Markdown(\"This notebook is the final step of the Workspace Collaboration Optimizer. Select standard mode to create an optimized seating plan using the previously validated input files in the Final Files folder. After creating a seating plan in standard mode you will also have the option to run Fixed Spaces mode. Utilize Fixed Spaces mode after editing your original seating plan. This option will place unassigned teams in workspaces based on your validated files, while keeping your changes to the seatplan. Please see the documentation for more detailed steps on using this feature.\"))\n",
    "    display(Markdown(\"##  Click below to start standard mode\"))\n",
    "\n",
    "\n",
    "mode_title = widgets.Output()\n",
    "with mode_title:\n",
    "    display(Markdown(\"##  Fixed Space option added\"))\n",
    "    display(Markdown(\"<b> To run Fixed Spaces, complete standard mode steps below to create your optimized floorplan. Then make any necessary changes to your floorplan and save it as a csv. Circle back to this notebook and click Fixed Spaces button below:</b> \"))\n",
    "    \n",
    "    \n",
    "# standard_btn = widgets.Button(description='Standard',button_style = 'primary')\n",
    "\n",
    "# fixed_spcs_btn = widgets.Button(description='Fixed Spaces',button_style = 'primary')\n",
    "\n",
    "# variable_seats_btn = widgets.Button(description='Variable Seats',button_style = 'primary')\n",
    "\n",
    "clear_output()\n",
    "#display(Markdown(\"##  Choose your mode\"))\n",
    "display(widgets.VBox([start_title,stndmode_btn]))\n",
    "\n",
    "stndmode_btn.observe(toggle_on_start_mode,'value')\n",
    "\n",
    "mode_btns.observe(toggle_on_click_mode,'value')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def go_to_nextblock(btn):\n",
    "        display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+3)'))\n",
    "\n",
    "global fixedSpaces\n",
    "#global variableSeats\n",
    "global mode\n",
    "clear_output()\n",
    "\n",
    "cwd = os.getcwd()\n",
    "\n",
    "load_fsp_file = FileChooser(cwd)\n",
    "load_tsz_file = FileChooser(cwd)\n",
    "load_spc_file = FileChooser(cwd)\n",
    "\n",
    "style = {'description_width': '135px'}\n",
    "layout = {'width': '385px'}\n",
    "create_outputfile_Name = widgets.Output()\n",
    "with create_outputfile_Name:\n",
    "    display(Markdown(\"#### Give the name of the output file here without a .xlsx extension at the end. The output file will be saved in the app_results folder in the same location as this python file\"))\n",
    "\n",
    "name_out_file = widgets.Text(placeholder='No.xlsx extension at the end',\n",
    "        description='New results name:',\n",
    "        layout=layout,\n",
    "        style=style,\n",
    "        disabled=False\n",
    "        )\n",
    "\n",
    "out = widgets.Output(layout={'border': '1px solid black'})\n",
    "CGREEN  = '\\33[32m'\n",
    "CRED = '\\033[91m'\n",
    "CEND = '\\033[0m'\n",
    "BOLD = '\\033[1m'\n",
    "\n",
    "go_to_next_btn = widgets.Button(description='Go',button_style = 'primary')\n",
    "go_to_next_btn.on_click(go_to_nextblock)\n",
    "\n",
    "if mode_btns.value == None:\n",
    "    mode_btns.value = 'Standard'\n",
    "    \n",
    "    ###############################################################\n",
    "    #############IF STANDARD IS CHOSEN:######################\\\n",
    "\n",
    "if mode_btns.value == 'Standard':\n",
    "    \n",
    "    display(Markdown(\"## Standard\"))\n",
    "\n",
    "    display(Markdown(\"<b>All four files will be programmatically read from previous stage of validations from the Final Files set folder:</b> \"))\n",
    "    display(Markdown((\"{interactions.csv, team_size.csv, space_capacity.csv, and distance.csv}\")))\n",
    "\n",
    "\n",
    "\n",
    "    display(out)        \n",
    "\n",
    "    #display(Markdown(\"#### Give the name of the output file here without a .xlsx extension at the end. The output file will be saved in the app_results folder in the same location as this python file\"))\n",
    "    \n",
    "\n",
    "    \n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "    cwd = os.getcwd()\n",
    "    inputpathffs = cwd + '\\\\Final Files set\\\\'        \n",
    "    input_path = inputpathffs\n",
    "\n",
    "    fixedSpaces = False\n",
    "    variableSeats = False\n",
    "    \n",
    "    display(create_outputfile_Name)\n",
    "    display(widgets.HBox([name_out_file,go_to_next_btn]))\n",
    "\n",
    "    mode = 0\n",
    "    \n",
    "    fp_orig = None\n",
    "    fp_modif = None\n",
    "    \n",
    "    ###############################################################\n",
    "    #############IF FIXED SPACES IS CHOSEN:######################\n",
    "    \n",
    "    \n",
    "    \n",
    "elif mode_btns.value == 'Fixed Spaces':\n",
    "    \n",
    "    \n",
    "    \n",
    "    #load_fsp_file = FileChooser(cwd)\n",
    "    clear_output()\n",
    "    loadfiles_markdown = widgets.Output()\n",
    "    tab_nest_fsp = widgets.Accordion()\n",
    "    \n",
    "    \n",
    "    \n",
    "    display(Markdown(\"## Fixed Spaces\"))\n",
    "\n",
    "    with loadfiles_markdown:\n",
    "        display(Markdown('<div class=\"alert alert-block alert-info\"><b> Load Data: </b> Select your fixed space file.</div>'))\n",
    "\n",
    "   \n",
    "\n",
    "    display(widgets.VBox([create_outputfile_Name,name_out_file]))\n",
    "\n",
    "    \n",
    "    display(Markdown(\"#### For fixed spaces, select the location of the initial floor plan with teams fixed to assigned spaces as well as the name of the file.\"))\n",
    "    display(Markdown(\"#### The fixed space plan file should have the exact same format as the floorplan that is output by the code without fixed spaces.  It should also be in .csv format.\"))\n",
    "    display(Markdown(\" Example: C:/myfolder/files/fs_floorplan.csv\"))\n",
    "    \n",
    "    fixedSpaces = True\n",
    "    variableSeats = False\n",
    "    \n",
    "    tab_nest_fsp.children = [load_fsp_file]\n",
    "    tab_nest_fsp.set_title(0,'Fixed Spaces file')\n",
    "    display(loadfiles_markdown)\n",
    "    display(widgets.VBox([tab_nest_fsp,go_to_next_btn]))\n",
    "    display(out)\n",
    "   \n",
    "    #display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+2)'))\n",
    "\n",
    " \n",
    "    \n",
    "    fxspcs_mkdown = widgets.Output()\n",
    "    fxspcs_mkdown2 = widgets.Output()\n",
    "\n",
    "    outreq = widgets.Output(layout={'border': '2px solid blue'})\n",
    "\n",
    "    tab_nest_fxspcs = widgets.Accordion(selected_index=None)\n",
    "    style = {'description_width': '185px'}\n",
    "    layout = {'width': '505px'}\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    with fxspcs_mkdown:\n",
    "        display(Markdown('<div class=\"alert alert-block alert-info\"><b>  Validate Fixed Spaces File:</div>'))\n",
    "    #display(teamsize_mkdown)\n",
    "\n",
    "    with fxspcs_mkdown2:\n",
    "\n",
    "        display(Markdown('<p>&nbsp; &nbsp; a. <b>Validate space size comparison</b>.</p>'))\n",
    "        display(Markdown('<p>&emsp; &emsp; i. Ensure that the sum of all rows for each column (which corresponds to spaces) in the user provided fixed space file does not exceed the space capacity of that space.</p>'))\n",
    "        display(Markdown('<p>&nbsp; &nbsp; b. <b>Validate dimensions layout</b>.</p>'))\n",
    "    #     display(Markdown('<p>&emsp; &emsp; i. No NA, None or string</p>'))\n",
    "        display(Markdown('<p>&emsp; &emsp; i. Ensure that the size of the fixed space file is the same dimensions as the floor plan that will be produced by the run.  So make sure the file is has n rows and k columns, where n is the number of groups and k is  the number of spaces. </p>'))\n",
    "\n",
    "\n",
    "    tab_nest_fxspcs.children = [widgets.VBox([fxspcs_mkdown,fxspcs_mkdown2])]\n",
    "\n",
    "    tab_nest_fxspcs.set_title(0,'Validate Fixed Spaces File Requirements')\n",
    "    \n",
    "    mode = 2\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "mode_map = {\n",
    "  \n",
    "  0: {'mode': 'Standard',\n",
    "     'reDistAdjSeats': False, 'officeOutput': False, 'relConstraints':False, 'relConstraintsForm': False,\n",
    "     'numTries': 1, 'flatInteractionBool': True, 'isRerun': False, 'officeFloorCapacityFileFormat': True, \n",
    "     'scaleUnits': False, 'relContraints': False, 'fpRank': False,\n",
    "     'runFWOptimizer': True, 'runScipyTrOptimizer': False, \n",
    "     'preSetupTeamAllocation': list(), 'changeIdx': None, 'rawCsvs': dict(), \n",
    "     'modechangeIdx': None, 'validation': True, 'pseudoTeams':False},\n",
    "  1: {'mode': 'Interactive',\n",
    "     'reDistAdjSeats': False, 'officeOutput': False, 'relConstraints': False, 'relConstraintsForm': False,\n",
    "     'numTries': 1, 'flatInteractionBool': True, 'isRerun': True, 'officeFloorCapacityFileFormat': True, \n",
    "     'scaleUnits': False, 'relContraints': False, 'fpRank': False,\n",
    "     'runFWOptimizer': True, 'runScipyTrOptimizer': False, \n",
    "     'preSetupTeamAllocation': list(), 'changeIdx': None, 'rawCsvs': dict(), \n",
    "     'modechangeIdx': None, 'validation': False, 'pseudoTeams':False},\n",
    "  2: {'mode': 'Fixed Spaces',\n",
    "     'reDistAdjSeats': False, 'officeOutput': False, 'relConstraints': False, 'relConstraintsForm': False,\n",
    "     'numTries': 1, 'flatInteractionBool': True, 'isRerun': True, 'officeFloorCapacityFileFormat': True, \n",
    "     'scaleUnits': False, 'relContraints': False, 'fpRank': False,\n",
    "     'runFWOptimizer': True, 'runScipyTrOptimizer': False, \n",
    "     'preSetupTeamAllocation': list(), 'changeIdx': None, 'rawCsvs': dict(), \n",
    "     'modechangeIdx': None, 'validation': True, 'pseudoTeams':False},\n",
    "  3: {'mode': 'CoLocated Teams',\n",
    "     'reDistAdjSeats': False, 'officeOutput': False, 'relConstraints':False, 'relConstraintsForm': False,\n",
    "     'numTries': 1, 'flatInteractionBool': True, 'isRerun': False, 'officeFloorCapacityFileFormat': True, \n",
    "     'scaleUnits': False, 'relContraints': False, 'fpRank': False,\n",
    "     'runFWOptimizer': True, 'runScipyTrOptimizer': False, \n",
    "     'preSetupTeamAllocation': list(), 'changeIdx': None, 'rawCsvs': dict(), \n",
    "     'modechangeIdx': None, 'validation': True, 'pseudoTeams':True}\n",
    "}\n",
    "  \n",
    "mode_params = mode_map[int(mode)]\n",
    "notebook_mode = mode_params['mode']\n",
    "#print(f\"MODE: {notebook_mode}\")    \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#############################################################\n",
    "#  Helper routines - Prepare data for Frank Wolfe algo\n",
    "#############################################################\n",
    "\n",
    "def rawFCtoPandas(rawFC):\n",
    "    \"\"\"\n",
    "    transposes a matrix. (12 x 2) --> (1 x 13)\n",
    "\n",
    "\n",
    "    inputs:\n",
    "    ------\n",
    "    rawFC: df; floor capacity\n",
    "    \n",
    "    returns:\n",
    "    -------\n",
    "    newFC: df; floor capacity transposed\n",
    "    \"\"\"\n",
    "    try:\n",
    "        newFC = rawFC.transpose().reset_index()\n",
    "        newFC.columns = newFC.iloc[0,:]\n",
    "        newFC = newFC.drop([0], axis = 0).reset_index(drop = True)\n",
    "        cols = newFC.columns\n",
    "        newFC[cols[1]] = pd.to_numeric(newFC[cols[1]])\n",
    "        return newFC\n",
    "    except: \n",
    "        return {\"error\":\"error within [rawFCtoPandas]\"}\n",
    "    #newFC['Capacity'] = pd.to_numeric(newFC['Capacity'])\n",
    "    \n",
    "\n",
    "def getFloorNamesDF(floor_capacity):\n",
    "    \"\"\"\n",
    "    drops duplicates from floor_capacity\n",
    "\n",
    "    inputs:\n",
    "    -------\n",
    "    floor_capacity\n",
    "\n",
    "    returns:\n",
    "    -----\n",
    "    floor_capacity\n",
    "    \"\"\"\n",
    "    cols = floor_capacity.columns\n",
    "    return floor_capacity[cols[0]].drop_duplicates().reset_index(drop = True)\n",
    "    #return floor_capacity[[\"Floor\"]].drop_duplicates().reset_index(drop = True)\n",
    "\n",
    "def getTeamNamesDF(team_size):\n",
    "    \"\"\"\n",
    "    drops duplicates from team_size\n",
    "    \"\"\"\n",
    "    cols = team_size.columns\n",
    "    return team_size[[cols[0]]].drop_duplicates().reset_index(drop = True)\n",
    "    #return team_size[[\"Team\"]].drop_duplicates().reset_index(drop = True)\n",
    "\n",
    "def validateFloors(floorNames, rawDistanceCols, numFloors):\n",
    "    \"\"\"\n",
    "    used for validation of floor names.\n",
    "    \"\"\"\n",
    "    #this can be a placeholder for future string name validations\n",
    "    #currently just the length\n",
    "    return (len(floorNames) == len(rawDistanceCols)) and (len(floorNames) == numFloors)\n",
    "\n",
    "def validateTeams(teamNames, rawInteractionsCols, numTeams):\n",
    "    \"\"\"\n",
    "    used for validation of teamNames\n",
    "    \"\"\"\n",
    "    #this can be a placeholder for future string name validations\n",
    "    #currently just the length\n",
    "    return (len(teamNames) == len(rawInteractionsCols)) and (len(teamNames) == numTeams) \n",
    "\n",
    "def getTeamSizeVector(team_size):\n",
    "    #TO DO. Deprecate in next version\n",
    "    cols = team_size.columns\n",
    "    return tuple(team_size[cols[1]].values)\n",
    "    #return tuple(team_size[\"Size\"].values)\n",
    "\n",
    "def getTeamSizeVector2(team_size):\n",
    "    # please note this version now assumes team names are on Index --> so Team Size is read from FIRST column\n",
    "    cols = team_size.columns\n",
    "    return tuple(team_size[cols[0]].values)\n",
    "\n",
    "def sortFloorsDF(fcDF, dropIdx = True):\n",
    "    \"\"\"\n",
    "    sorts the floor columns by alphabetical + numerical order.\n",
    "    this is important to make sure data looks consistent throughout the process.\n",
    "\n",
    "    ex. [NORTH-FLOOR-1, NORTH-FLOOR-2, EAST-FLOOR-1] --> [EAST-FLOOR-1, NORTH-FLOOR-1, NORTH-FLOOR-2]\n",
    "\n",
    "    inputs:\n",
    "    ------\n",
    "    fcDF: pandas dataframe also known as rawfloorCapacity .\n",
    "    \"\"\"\n",
    "    cols = fcDF.columns\n",
    "    sortedDF = fcDF.sort_values(by = [cols[0]])\n",
    "    if (dropIdx):\n",
    "        sortedDF = sortedDF.reset_index(drop = True)\n",
    "    else:\n",
    "        sortedDF = sortedDF.reset_index()\n",
    "    return sortedDF\n",
    "\n",
    "def sortTeamsDF(tsDF, dropIdx = True):\n",
    "    \"\"\"\n",
    "    columns names can be changed. thats why we take it by relative position\n",
    "    \n",
    "    sorts the team column by alphabetical + numerical order.\n",
    "    this is important to make sure data looks consistent throughout the process.\n",
    "\n",
    "    ex. [SALES, ENGINEERING, MARKETING] --> [ENGINEERING, MARKETING, SALES]\n",
    "\n",
    "    inputs:\n",
    "    ------\n",
    "    tsDF: pandas dataframe also known as team size\n",
    "    \n",
    "    \"\"\"\n",
    "    cols = tsDF.columns\n",
    "    sortedDF = tsDF.sort_values(by = [cols[0]])\n",
    "    if (dropIdx):\n",
    "        sortedDF = sortedDF.reset_index(drop = True)\n",
    "    else:\n",
    "        sortedDF = sortedDF.reset_index()\n",
    "    return sortedDF\n",
    "\n",
    "def sortInteractions(iDF):\n",
    "    rawCols = iDF.columns\n",
    "    idxMap = {} \n",
    "    #sort rows\n",
    "    sortedRawI = iDF.sort_values([rawCols[0]])\n",
    "    #keep old rows idx i.e. just put it aside and forget about it (kept copy for audit purposes)\n",
    "    copyIdxRows = sortedRawI.reset_index().iloc[:, [0,1]]\n",
    "    copyIdxRows.rename(columns = {\"index\" : \"orig_index\"}, inplace = True)\n",
    "    idxMap[\"rows\"] = copyIdxRows.copy()\n",
    "    sortedRawI = sortedRawI.reset_index(drop = True)\n",
    "    #transpose \n",
    "    temp = sortedRawI.set_index(sortedRawI.columns[0])\n",
    "    transposeRawI = temp.transpose()\n",
    "    transposeRawI = transposeRawI.reset_index()\n",
    "    transposeRawI.rename(columns = {\"index\" : rawCols[0]}, inplace = True)\n",
    "    transposeRawI.columns.name = None\n",
    "    #sort columns \n",
    "    sortedRawI2 = transposeRawI.sort_values([transposeRawI.columns[0]])\n",
    "    #record old column idx, put it aside and forget about it (just in case it is needed... kept a copy...)\n",
    "    copyIdxCols = sortedRawI2.reset_index().iloc[:, [0,1]]\n",
    "    copyIdxCols.rename(columns = {\"index\" : \"orig_index\"}, inplace = True)\n",
    "    idxMap[\"cols\"] = copyIdxCols.copy()\n",
    "    sortedRawI2 = sortedRawI2.reset_index(drop = True)\n",
    "    #transpose back\n",
    "    temp2 = sortedRawI2.set_index(sortedRawI2.columns[0])\n",
    "    transposeRawI2 = temp2.transpose()\n",
    "    transposeRawI2 = transposeRawI2.reset_index()\n",
    "    transposeRawI2.rename(columns = {\"index\" : rawCols[0]}, inplace = True)\n",
    "    transposeRawI2.columns.name = None\n",
    "    return transposeRawI2, idxMap \n",
    "\n",
    "def sortDistance(tDF):\n",
    "    rawCols = tDF.columns\n",
    "    idxMap = {} \n",
    "    #sort rows\n",
    "    sortedRawT = tDF.sort_values([rawCols[0]])\n",
    "    #record old rows idx, put it aside and forget about it (just in case it is needed... kept a copy...)\n",
    "    copyIdxRows = sortedRawT.reset_index().iloc[:, [0,1]]\n",
    "    copyIdxRows.rename(columns = {\"index\" : \"orig_index\"}, inplace = True)\n",
    "    idxMap[\"rows\"] = copyIdxRows.copy()\n",
    "    sortedRawT = sortedRawT.reset_index(drop = True)\n",
    "    #transpose \n",
    "    temp = sortedRawT.set_index(sortedRawT.columns[0])\n",
    "    transposeRawT = temp.transpose()\n",
    "    transposeRawT = transposeRawT.reset_index()\n",
    "    transposeRawT.rename(columns = {\"index\" : rawCols[0]}, inplace = True)\n",
    "    transposeRawT.columns.name = None\n",
    "    #sort columns \n",
    "    sortedRawT2 = transposeRawT.sort_values([transposeRawT.columns[0]])\n",
    "    #record old column idx, put it aside and forget about it (just in case it is needed... kept a copy...)\n",
    "    copyIdxCols = sortedRawT2.reset_index().iloc[:, [0,1]]\n",
    "    copyIdxCols.rename(columns = {\"index\" : \"orig_index\"}, inplace = True)\n",
    "    idxMap[\"cols\"] = copyIdxCols.copy()\n",
    "    sortedRawT2 = sortedRawT2.reset_index(drop = True)\n",
    "    temp2 = sortedRawT2.set_index(sortedRawT2.columns[0])\n",
    "    transposeRawT2 = temp2.transpose()\n",
    "    transposeRawT2 = transposeRawT2.reset_index()\n",
    "    transposeRawT2.rename(columns = {\"index\" : rawCols[0]}, inplace = True)\n",
    "    transposeRawT2.columns.name = None\n",
    "    return transposeRawT2, idxMap\n",
    "\n",
    "def sortFloorplan(floorplan):\n",
    "    \"\"\"\n",
    "    sorts floorplan columns and rows. makes index team name\n",
    "    \n",
    "    inputs:\n",
    "    --------\n",
    "    floorplan: floorplan dataframe - either original or interactive\n",
    "    \n",
    "    returns:\n",
    "    -----\n",
    "    transposeRawFP2: sorted floor plan\n",
    "    idxMap: we don't use that..\n",
    "    \"\"\"\n",
    "    if isinstance(floorplan, pd.DataFrame): \n",
    "        rawCols = floorplan.columns\n",
    "        idxMap = {} \n",
    "        #sort rows\n",
    "        sortedFP = floorplan.sort_values([rawCols[0]])\n",
    "        #keep old rows idx i.e. just put it aside and forget about it (kept copy for audit purposes)\n",
    "        copyIdxRows = sortedFP.reset_index().iloc[:, [0,1]]\n",
    "        copyIdxRows.rename(columns = {\"index\" : \"orig_index\"}, inplace = True)\n",
    "        idxMap[\"rows\"] = copyIdxRows.copy()\n",
    "        sortedFP = sortedFP.reset_index(drop = True)\n",
    "        #transpose \n",
    "        temp = sortedFP.set_index(sortedFP.columns[0])\n",
    "        transposeRawFP = temp.transpose()\n",
    "        transposeRawFP = transposeRawFP.reset_index()\n",
    "        transposeRawFP.rename(columns = {\"index\" : rawCols[0]}, inplace = True)\n",
    "        transposeRawFP.columns.name = None\n",
    "        #sort columns \n",
    "        sortedRawFP2 = transposeRawFP.sort_values([transposeRawFP.columns[0]])\n",
    "        #record old column idx, put it aside and forget about it (just in case it is needed... kept a copy...)\n",
    "        copyIdxCols = sortedRawFP2.reset_index().iloc[:, [0,1]]\n",
    "        copyIdxCols.rename(columns = {\"index\" : \"orig_index\"}, inplace = True)\n",
    "        idxMap[\"cols\"] = copyIdxCols.copy()\n",
    "        sortedRawFP2 = sortedRawFP2.reset_index(drop = True)\n",
    "        #transpose back\n",
    "        temp2 = sortedRawFP2.set_index(sortedRawFP2.columns[0])\n",
    "        transposeRawFP2 = temp2.transpose()\n",
    "        transposeRawFP2 = transposeRawFP2.reset_index()\n",
    "        transposeRawFP2.rename(columns = {\"index\" : rawCols[0]}, inplace = True)\n",
    "        transposeRawFP2.columns.name = None\n",
    "\n",
    "        transposeRawFP2.index = transposeRawFP2[rawCols[0]]\n",
    "        transposeRawFP2 = transposeRawFP2.drop(columns=[rawCols[0]])\n",
    "        return transposeRawFP2, idxMap \n",
    "    else:\n",
    "        return None, None\n",
    "\n",
    "#############################################################\n",
    "#  Helper routines - Scale data for FW Algo\n",
    "#############################################################\n",
    "def minMaxScaler(x, exclude_cols = []):\n",
    "    if isinstance(x,np.ndarray):\n",
    "        z = x.copy()\n",
    "    elif isinstance(x, pd.DataFrame):\n",
    "        #keep cols order (whatever it may be)\n",
    "        origCols = tuple(x.columns)\n",
    "        tempColsAll = [ str(s) + \"_\"+ str(i) for i,s in enumerate(x.columns)]\n",
    "        tempColsMapIdxAll = { s : i for i,s in enumerate(tempColsAll)}\n",
    "        temp1 = x.copy()\n",
    "        temp1.columns = tempColsAll\n",
    "        #keep numeric columns\n",
    "        temp2 = temp1.select_dtypes(include = 'number')\n",
    "        numCols = temp2.columns\n",
    "        z = temp2.to_numpy()\n",
    "                \n",
    "    min_x = z.min()\n",
    "    z -= min_x\n",
    "    minMaxRange = z.ptp()\n",
    "    \n",
    "    if minMaxRange != 0:\n",
    "        z = z / minMaxRange\n",
    "        if isinstance(x,np.ndarray):\n",
    "            return z, minMaxRange, min_x\n",
    "        elif isinstance(x, pd.DataFrame):           \n",
    "            for j in range(z.shape[1]):\n",
    "                tempColsLabel = numCols[j] \n",
    "                cols_idx = tempColsMapIdxAll[tempColsLabel]\n",
    "                temp1.iloc[:,cols_idx]= z[:,j]\n",
    "                temp1.columns = origCols\n",
    "            return temp1, minMaxRange, min_x\n",
    "    else:\n",
    "        return x, None, None\n",
    "\n",
    "def minMaxUnScale(z, MinMaxRange, min_x):\n",
    "    if MinMaxRange:\n",
    "        if isinstance(z,np.ndarray):\n",
    "            x = z.copy()\n",
    "        elif isinstance(z, pd.DataFrame):\n",
    "            #keep cols order (whatever it may be)\n",
    "            origCols = tuple(z.columns)\n",
    "            tempColsAll = [ str(s) + \"_\"+ str(i) for i,s in enumerate(z.columns)]\n",
    "            tempColsMapIdxAll = { s : i for i,s in enumerate(tempColsAll)}\n",
    "            temp1 = z.copy()\n",
    "            temp1.columns = tempColsAll\n",
    "            #keep numeric columns\n",
    "            temp2 = temp1.select_dtypes(include = 'number')\n",
    "            numCols = temp2.columns\n",
    "            x = temp2.to_numpy()\n",
    "        \n",
    "        \n",
    "        x = x * MinMaxRange + min_x\n",
    "        \n",
    "        if isinstance(z,np.ndarray):\n",
    "            return x\n",
    "        elif isinstance(z, pd.DataFrame):           \n",
    "            for j in range(x.shape[1]):\n",
    "                tempColsLabel = numCols[j] \n",
    "                cols_idx = tempColsMapIdxAll[tempColsLabel]\n",
    "                temp1.iloc[:,cols_idx]= x[:,j]\n",
    "                temp1.columns = origCols\n",
    "            return temp1\n",
    "    else:\n",
    "        return z\n",
    "\n",
    "#############################################################\n",
    "#  Interactive Helper Functions\n",
    "#############################################################\n",
    "def cleanNanCopy(X):\n",
    "    \"\"\"\n",
    "    replaces nulls with 0\n",
    "    \"\"\"\n",
    "    if isinstance(X, pd.DataFrame): \n",
    "        temp = X.fillna(0)\n",
    "    else: \n",
    "        temp = X.copy()\n",
    "        temp[np.isnan(temp)] = 0\n",
    "    return temp  \n",
    "\n",
    "def getPreSetupTeamAllocation(X0, X1, teamSizeVec = None, byFloor = True ):\n",
    "    #Assumes X0 and X1 are comming from user input \n",
    "    #and have actual team e.g 70 headcount instead of 0.6 team ratio\n",
    "    if (X0.shape == X1.shape):\n",
    "        res, keys = [],[]\n",
    "        K,N = X0.shape[0], X0.shape[1]\n",
    "        if teamSizeVec is not None:\n",
    "            temp1 = np.round(cleanNanCopy(X0))\n",
    "            temp2 = np.round(cleanNanCopy(X1))\n",
    "            diff = temp2 - temp1\n",
    "            keys =  np.where(diff!= 0)\n",
    "            teamSizeMat = np.repeat(teamSizeVec,N).reshape(K,N)\n",
    "            Xteamratio = np.round( X1 / teamSizeMat,4)\n",
    "            if isinstance(Xteamratio, pd.DataFrame):\n",
    "                res = [(x,y,Xteamratio.iloc[x,y]) for x,y in keys]\n",
    "            else:\n",
    "                res = [(x,y,Xteamratio[x,y]) for x,y in keys]\n",
    "        else:\n",
    "            temp1 = np.round(cleanNanCopy(X0))\n",
    "            temp2 = np.round(cleanNanCopy(X1))\n",
    "            diff = temp2 - temp1\n",
    "            keys =  np.where(diff!= 0)\n",
    "            if (byFloor):\n",
    "                teams = set(keys[0])\n",
    "                floorIdx = [ (i,j) for i in teams for j in range(N)]\n",
    "                if isinstance(X1, pd.DataFrame):\n",
    "                    res = [(x,y,temp2.iloc[x,y]) for x,y in floorIdx]\n",
    "                else:\n",
    "                    res = [(x,y,temp2[x,y]) for x,y in floorIdx]   \n",
    "            else:\n",
    "                if isinstance(X1, pd.DataFrame):\n",
    "                    res = [(x,y,X1.iloc[x,y]) for x,y in zip(keys[0],keys[1]) ]\n",
    "                else:\n",
    "                    res = [(x,y,X1[x,y]) for x,y in zip(keys[0],keys[1])]\n",
    "        return res, keys\n",
    "        \n",
    "def whereChangeFlat(X0,X1, K, N):\n",
    "    if (X0.shape == X1.shape and X0.shape[0] == K and X0.shape[1] == N):\n",
    "        temp1 = np.round(cleanNanCopy(X0))\n",
    "        temp2 = np.round(cleanNanCopy(X1))\n",
    "        # transpose and flatten\n",
    "        flat1 = np.asarray(temp1).T.ravel()\n",
    "        flat2 = np.asarray(temp2).T.ravel()\n",
    "        diff = flat2 - flat1\n",
    "        flatIdxs = np.where(diff !=0)\n",
    "        return flatIdxs[0]\n",
    "\n",
    "def isValidpreSetupAllocation(preSetupTeamAllocation, teamSizeVector ):\n",
    "    teamSize = {}\n",
    "    for x,y,v in preSetupTeamAllocation:\n",
    "        if x not in teamSize:\n",
    "            teamSize[x] = v\n",
    "        else:\n",
    "            teamSize[x] = v + teamSize[x]\n",
    "    for i,v in teamSize.items():\n",
    "        if (teamSize[i] != teamSizeVector[i]):\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "def getX1(input_path = \"\"):\n",
    "    X = pd.read_csv(input_path+\"floorplacment000.csv\")\n",
    "    return X\n",
    "\n",
    "def getX2(input_path = \"\"):\n",
    "    modifiedX = pd.read_csv(input_path+\"floorplacment.csv\")\n",
    "    return modifiedX\n",
    "\n",
    "def getChangeVectors(X1,X2):\n",
    "    \"\"\"\n",
    "    this is a key function in Interactive Mode and Fixed Spaces. it identifies the changes a user made.\n",
    "\n",
    "    inputs:\n",
    "    ------\n",
    "    X1: original floor plan\n",
    "    X2: modified floor plan\n",
    "\n",
    "    returns:\n",
    "    ------\n",
    "    preSet: known as preSetupTeamAllocation in code; has format (team_indx, floor_indx, value) --> (0, 1, 71)\n",
    "        --> (engineering team, floor 1, +71 new heads)\n",
    "    changeIdxs: also known as changeIdx; has format (team_indx, floor_indx); shows which cells are different\n",
    "        between original and modified floor plan. Used by FWOptimizer\n",
    "    \"\"\"\n",
    "    # if X1 is None: getX1() # pandas dataframe \n",
    "    # if X2 is None: getX2() \n",
    "    preSetup, Idxs = getPreSetupTeamAllocation(X1,X2, byFloor=False)\n",
    "    print(preSetup)\n",
    "    changeIdxs = whereChangeFlat(X1,X2, X1.shape[0], X1.shape[1])\n",
    "    return preSetup, changeIdxs\n",
    "\n",
    "\n",
    "def createInteractionsMatrix2(flatInteractions):\n",
    "    \"\"\"\n",
    "    if flatInteractionBool is True we run this function. we turn a big dataframe with \n",
    "    daily interactions into a smaller, summed one.\n",
    "\n",
    "    inputs:\n",
    "    -------\n",
    "    flatInteractions: also known as rawI or rawIraw in code. it is a pandas dataframe which has\n",
    "        the collab time between team 1 (TimeInvestors) and team 2 (Collaborators) on a date.\n",
    "    \n",
    "    returns:\n",
    "    -------\n",
    "    df: also known as rawI. it sums of the total time spent in collaboration between teams.\n",
    "        if flatInteractions had 5 unique teams, it sum up how much time the 5 teams have spent working\n",
    "        with the other 5 teams.\n",
    "\n",
    "\n",
    "    sums of total time spent in collaboration.\n",
    "    \"\"\"\n",
    "    #get unique names of participants\n",
    "    organizersNames = flatInteractions.iloc[:,0].unique()\n",
    "    contributorsNames = flatInteractions.iloc[:,1].unique()\n",
    "    allNames = set(organizersNames).union(set(contributorsNames))\n",
    "    removeNames = [\"Other_Collaborators\", \"Unclassified_Internal\", \"Unclassified_External\", \"Collaborators Within Group\"]\n",
    "    keepNames = allNames - set(removeNames)\n",
    "    cols = flatInteractions.columns\n",
    "    \n",
    "    #add up withing group collaboration \n",
    "    temp = flatInteractions.copy()\n",
    "    temp.loc[temp[cols[1]]=='Collaborators Within Group', cols[1]] = temp[cols[0]]\n",
    "    temp = temp.drop(temp.columns[[2]], axis=1) # drop date column\n",
    "    \n",
    "    #remove unwanted rows\n",
    "    temp =  temp[~ ((temp[cols[0]].isin(list(removeNames))) | (temp[cols[1]].isin(list(removeNames))))]\n",
    "    \n",
    "    #build matrix\n",
    "    key_cols = [cols[0], cols[1]]\n",
    "    interactionsMatrix = temp.set_index(key_cols).groupby(key_cols)[cols[-1]].agg(['sum']).unstack()\n",
    "\n",
    "\n",
    "    #clean and wrap up\n",
    "    df = interactionsMatrix.fillna(0.0)\n",
    "    df.columns = df.columns.droplevel(0)\n",
    "    df.columns.name = None\n",
    "    df.index.name = None\n",
    "    df = df.reset_index()\n",
    "    df.rename(columns = {df.columns[0]: 'Collab' }, inplace = True)\n",
    "    return df\n",
    "\n",
    "#############################################################\n",
    "#  Helper routines - Load relative constraints\n",
    "#############################################################\n",
    "\n",
    "def validTeamNames(teamNames, sRawTS):\n",
    "    names = set(teamNames)\n",
    "    validNames = set(sRawTS[sRawTS.columns[0]])\n",
    "    return names.issubset(validNames)\n",
    "\n",
    "def getTeamIdsDF(sRawTS):\n",
    "    return (sRawTS[[sRawTS.columns[0]]].reset_index())[[sRawTS.columns[0],\"index\"]]\n",
    "\n",
    "def getFloorIdsDF(floorsDF):\n",
    "    return (floorsDF[[floorsDF.columns[0]]].reset_index())[[floorsDF.columns[0],\"index\"]]\n",
    "\n",
    "def parseConstraints(rawCons, sRawTS):\n",
    "    rawCons.rename(columns = {rawCons.columns[0]: \"Constraint_Type\",\\\n",
    "                          rawCons.columns[1]: \"From\",\\\n",
    "                          rawCons.columns[2]: \"To\",\\\n",
    "                          rawCons.columns[3]: \"Eq_Type\",\\\n",
    "                          rawCons.columns[4]: \"Amount\"\\\n",
    "                          }, inplace = True)\n",
    "\n",
    "    rawCons[\"From\"] = rawCons[\"From\"].str.strip()\n",
    "    rawCons[\"To\"] = rawCons[\"To\"].str.strip()\n",
    "    allNames = set(rawCons[\"From\"]).union(set(rawCons[\"To\"]))\n",
    "    if validTeamNames(allNames, sRawTS):\n",
    "        rawCons[\"Constraint_Type\"] = rawCons[\"Constraint_Type\"].str.upper()\n",
    "        dcDF = rawCons[rawCons[\"Constraint_Type\"] == \"DISTANCE\"]\n",
    "        dcDF = dcDF.sort_values(by = ['From','To'])\n",
    "        icDF = rawCons[rawCons[\"Constraint_Type\"] == \"INTERACTION\"]\n",
    "        return dcDF, icDF\n",
    "    else:\n",
    "        print(\"error relative constraints team names not valid\")\n",
    "        return None,None\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clear_output()\n",
    "global out_filename\n",
    "if len(name_out_file.value)> 0:\n",
    "    out_filename = name_out_file.value+\".xlsx\"\n",
    "    print(BOLD,out_filename)\n",
    "    display(out)\n",
    "\n",
    "else:\n",
    "    timestamp = datetime.now().replace(microsecond=0).isoformat()\n",
    "    timestamp = timestamp.replace(\":\",\"\")\n",
    "    print('You did not enter an output file name above. A default name of [floor_plan_' + timestamp+ ' ] will be used.')\n",
    "    out_filename = 'floor_plan_'+ timestamp +'.xlsx'\n",
    "    print(BOLD,out_filename)\n",
    "    display(out)\n",
    "display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+1)'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for local files\n",
    "clear_output()\n",
    "\n",
    "writer = None\n",
    "base_path = './app_results/' \n",
    "\n",
    "#print(os.getcwd())\n",
    "#print(base_path)\n",
    "\n",
    "\n",
    "\n",
    "if not (os.path.exists(base_path) and os.path.isdir(base_path)):\n",
    "        os.mkdir(base_path)\n",
    "        print('app_results folder has been created')\n",
    "else:\n",
    "    print('app_results folder already exists')\n",
    "        \n",
    "#check dir is created\n",
    "#all_dirs = [ x[0] for x in os.walk(\".\")]\n",
    "#all_dirs\n",
    "\n",
    "#helper function to save results\n",
    "class write2File:\n",
    "    def __init__(self, writer = None, output = './app_results/output.xlsx'):\n",
    "        if not writer:\n",
    "            self.writer = pd.ExcelWriter(output,  engine ='xlsxwriter')\n",
    "        else:\n",
    "            self.writer = writer\n",
    "        self.output = output   \n",
    "      \n",
    "    def to_excel(self,df, tab_name = \"001\"):\n",
    "         df.to_excel(self.writer, tab_name)\n",
    "    \n",
    "    def save(self):\n",
    "        self.writer.save()\n",
    "\n",
    "\n",
    "\n",
    "###########################################################################\n",
    "######## Helper routine for FW algo - mostly unchanged from Jupyter #######\n",
    "###########################################################################\n",
    "\n",
    "\n",
    "\n",
    "#############################################################\n",
    "#  Helper routines - Prepare data for Frank Wolfe algo\n",
    "#############################################################\n",
    "\n",
    "def rawFCtoPandas(rawFC):\n",
    "    \"\"\"\n",
    "    transposes a matrix. (12 x 2) --> (1 x 13)\n",
    "\n",
    "\n",
    "    inputs:\n",
    "    ------\n",
    "    rawFC: df; floor capacity\n",
    "    \n",
    "    returns:\n",
    "    -------\n",
    "    newFC: df; floor capacity transposed\n",
    "    \"\"\"\n",
    "    try:\n",
    "        newFC = rawFC.transpose().reset_index()\n",
    "        newFC.columns = newFC.iloc[0,:]\n",
    "        newFC = newFC.drop([0], axis = 0).reset_index(drop = True)\n",
    "        cols = newFC.columns\n",
    "        newFC[cols[1]] = pd.to_numeric(newFC[cols[1]])\n",
    "        return newFC\n",
    "    except: \n",
    "        return {\"error\":\"error within [rawFCtoPandas]\"}\n",
    "    #newFC['Capacity'] = pd.to_numeric(newFC['Capacity'])\n",
    "    \n",
    "\n",
    "def getFloorNamesDF(floor_capacity):\n",
    "    \"\"\"\n",
    "    drops duplicates from floor_capacity\n",
    "\n",
    "    inputs:\n",
    "    -------\n",
    "    floor_capacity\n",
    "\n",
    "    returns:\n",
    "    -----\n",
    "    floor_capacity\n",
    "    \"\"\"\n",
    "    cols = floor_capacity.columns\n",
    "    return floor_capacity[cols[0]].drop_duplicates().reset_index(drop = True)\n",
    "    #return floor_capacity[[\"Floor\"]].drop_duplicates().reset_index(drop = True)\n",
    "\n",
    "def getTeamNamesDF(team_size):\n",
    "    \"\"\"\n",
    "    drops duplicates from team_size\n",
    "    \"\"\"\n",
    "    cols = team_size.columns\n",
    "    return team_size[[cols[0]]].drop_duplicates().reset_index(drop = True)\n",
    "    #return team_size[[\"Team\"]].drop_duplicates().reset_index(drop = True)\n",
    "\n",
    "def validateFloors(floorNames, rawDistanceCols, numFloors):\n",
    "    \"\"\"\n",
    "    used for validation of floor names.\n",
    "    \"\"\"\n",
    "    #this can be a placeholder for future string name validations\n",
    "    #currently just the length\n",
    "    return (len(floorNames) == len(rawDistanceCols)) and (len(floorNames) == numFloors)\n",
    "\n",
    "def validateTeams(teamNames, rawInteractionsCols, numTeams):\n",
    "    \"\"\"\n",
    "    used for validation of teamNames\n",
    "    \"\"\"\n",
    "    #this can be a placeholder for future string name validations\n",
    "    #currently just the length\n",
    "    return (len(teamNames) == len(rawInteractionsCols)) and (len(teamNames) == numTeams) \n",
    "\n",
    "def getTeamSizeVector(team_size):\n",
    "    #TO DO. Deprecate in next version\n",
    "    cols = team_size.columns\n",
    "    return tuple(team_size[cols[1]].values)\n",
    "    #return tuple(team_size[\"Size\"].values)\n",
    "\n",
    "def getTeamSizeVector2(team_size):\n",
    "  # please note this version now assumes team names are on Index --> so Team Size is read from FIRST column\n",
    "    cols = team_size.columns\n",
    "    return tuple(team_size[cols[0]].values)\n",
    "\n",
    "def sortFloorsDF(fcDF, dropIdx = True):\n",
    "    \"\"\"\n",
    "    sorts the floor columns by alphabetical + numerical order.\n",
    "    this is important to make sure data looks consistent throughout the process.\n",
    "\n",
    "    ex. [NORTH-FLOOR-1, NORTH-FLOOR-2, EAST-FLOOR-1] --> [EAST-FLOOR-1, NORTH-FLOOR-1, NORTH-FLOOR-2]\n",
    "\n",
    "    inputs:\n",
    "    ------\n",
    "    fcDF: pandas dataframe also known as rawfloorCapacity .\n",
    "    \"\"\"\n",
    "    cols = fcDF.columns\n",
    "    sortedDF = fcDF.sort_values(by = [cols[0]])\n",
    "    if (dropIdx):\n",
    "        sortedDF = sortedDF.reset_index(drop = True)\n",
    "    else:\n",
    "        sortedDF = sortedDF.reset_index()\n",
    "    return sortedDF\n",
    "\n",
    "def sortTeamsDF(tsDF, dropIdx = True):\n",
    "    \"\"\"\n",
    "    columns names can be changed. thats why we take it by relative position\n",
    "    \n",
    "    sorts the team column by alphabetical + numerical order.\n",
    "    this is important to make sure data looks consistent throughout the process.\n",
    "\n",
    "    ex. [SALES, ENGINEERING, MARKETING] --> [ENGINEERING, MARKETING, SALES]\n",
    "\n",
    "    inputs:\n",
    "    ------\n",
    "    tsDF: pandas dataframe also known as team size\n",
    "    \n",
    "    \"\"\"\n",
    "    cols = tsDF.columns\n",
    "    sortedDF = tsDF.sort_values(by = [cols[0]])\n",
    "    if (dropIdx):\n",
    "        sortedDF = sortedDF.reset_index(drop = True)\n",
    "    else:\n",
    "        sortedDF = sortedDF.reset_index()\n",
    "    return sortedDF\n",
    "\n",
    "def sortInteractions(iDF):\n",
    "    rawCols = iDF.columns\n",
    "    idxMap = {} \n",
    "    #sort rows\n",
    "    sortedRawI = iDF.sort_values([rawCols[0]])\n",
    "    #keep old rows idx i.e. just put it aside and forget about it (kept copy for audit purposes)\n",
    "    copyIdxRows = sortedRawI.reset_index().iloc[:, [0,1]]\n",
    "    copyIdxRows.rename(columns = {\"index\" : \"orig_index\"}, inplace = True)\n",
    "    idxMap[\"rows\"] = copyIdxRows.copy()\n",
    "    sortedRawI = sortedRawI.reset_index(drop = True)\n",
    "    #transpose \n",
    "    temp = sortedRawI.set_index(sortedRawI.columns[0])\n",
    "    transposeRawI = temp.transpose()\n",
    "    transposeRawI = transposeRawI.reset_index()\n",
    "    transposeRawI.rename(columns = {\"index\" : rawCols[0]}, inplace = True)\n",
    "    transposeRawI.columns.name = None\n",
    "    #sort columns \n",
    "    sortedRawI2 = transposeRawI.sort_values([transposeRawI.columns[0]])\n",
    "    #record old column idx, put it aside and forget about it (just in case it is needed... kept a copy...)\n",
    "    copyIdxCols = sortedRawI2.reset_index().iloc[:, [0,1]]\n",
    "    copyIdxCols.rename(columns = {\"index\" : \"orig_index\"}, inplace = True)\n",
    "    idxMap[\"cols\"] = copyIdxCols.copy()\n",
    "    sortedRawI2 = sortedRawI2.reset_index(drop = True)\n",
    "    #transpose back\n",
    "    temp2 = sortedRawI2.set_index(sortedRawI2.columns[0])\n",
    "    transposeRawI2 = temp2.transpose()\n",
    "    transposeRawI2 = transposeRawI2.reset_index()\n",
    "    transposeRawI2.rename(columns = {\"index\" : rawCols[0]}, inplace = True)\n",
    "    transposeRawI2.columns.name = None\n",
    "    return transposeRawI2, idxMap \n",
    "\n",
    "def sortDistance(tDF):\n",
    "    rawCols = tDF.columns\n",
    "    idxMap = {} \n",
    "    #sort rows\n",
    "    sortedRawT = tDF.sort_values([rawCols[0]])\n",
    "    #record old rows idx, put it aside and forget about it (just in case it is needed... kept a copy...)\n",
    "    copyIdxRows = sortedRawT.reset_index().iloc[:, [0,1]]\n",
    "    copyIdxRows.rename(columns = {\"index\" : \"orig_index\"}, inplace = True)\n",
    "    idxMap[\"rows\"] = copyIdxRows.copy()\n",
    "    sortedRawT = sortedRawT.reset_index(drop = True)\n",
    "    #transpose \n",
    "    temp = sortedRawT.set_index(sortedRawT.columns[0])\n",
    "    transposeRawT = temp.transpose()\n",
    "    transposeRawT = transposeRawT.reset_index()\n",
    "    transposeRawT.rename(columns = {\"index\" : rawCols[0]}, inplace = True)\n",
    "    transposeRawT.columns.name = None\n",
    "    #sort columns \n",
    "    sortedRawT2 = transposeRawT.sort_values([transposeRawT.columns[0]])\n",
    "    #record old column idx, put it aside and forget about it (just in case it is needed... kept a copy...)\n",
    "    copyIdxCols = sortedRawT2.reset_index().iloc[:, [0,1]]\n",
    "    copyIdxCols.rename(columns = {\"index\" : \"orig_index\"}, inplace = True)\n",
    "    idxMap[\"cols\"] = copyIdxCols.copy()\n",
    "    sortedRawT2 = sortedRawT2.reset_index(drop = True)\n",
    "    temp2 = sortedRawT2.set_index(sortedRawT2.columns[0])\n",
    "    transposeRawT2 = temp2.transpose()\n",
    "    transposeRawT2 = transposeRawT2.reset_index()\n",
    "    transposeRawT2.rename(columns = {\"index\" : rawCols[0]}, inplace = True)\n",
    "    transposeRawT2.columns.name = None\n",
    "    return transposeRawT2, idxMap\n",
    "\n",
    "def sortFloorplan(floorplan):\n",
    "    \"\"\"\n",
    "    sorts floorplan columns and rows. makes index team name\n",
    "    \n",
    "    inputs:\n",
    "    --------\n",
    "    floorplan: floorplan dataframe - either original or interactive\n",
    "    \n",
    "    returns:\n",
    "    -----\n",
    "    transposeRawFP2: sorted floor plan\n",
    "    idxMap: we don't use that..\n",
    "    \"\"\"\n",
    "    if isinstance(floorplan, pd.DataFrame): \n",
    "        rawCols = floorplan.columns\n",
    "        idxMap = {} \n",
    "        #sort rows\n",
    "        sortedFP = floorplan.sort_values([rawCols[0]])\n",
    "        #keep old rows idx i.e. just put it aside and forget about it (kept copy for audit purposes)\n",
    "        copyIdxRows = sortedFP.reset_index().iloc[:, [0,1]]\n",
    "        copyIdxRows.rename(columns = {\"index\" : \"orig_index\"}, inplace = True)\n",
    "        idxMap[\"rows\"] = copyIdxRows.copy()\n",
    "        sortedFP = sortedFP.reset_index(drop = True)\n",
    "        #transpose \n",
    "        temp = sortedFP.set_index(sortedFP.columns[0])\n",
    "        transposeRawFP = temp.transpose()\n",
    "        transposeRawFP = transposeRawFP.reset_index()\n",
    "        transposeRawFP.rename(columns = {\"index\" : rawCols[0]}, inplace = True)\n",
    "        transposeRawFP.columns.name = None\n",
    "        #sort columns \n",
    "        sortedRawFP2 = transposeRawFP.sort_values([transposeRawFP.columns[0]])\n",
    "        #record old column idx, put it aside and forget about it (just in case it is needed... kept a copy...)\n",
    "        copyIdxCols = sortedRawFP2.reset_index().iloc[:, [0,1]]\n",
    "        copyIdxCols.rename(columns = {\"index\" : \"orig_index\"}, inplace = True)\n",
    "        idxMap[\"cols\"] = copyIdxCols.copy()\n",
    "        sortedRawFP2 = sortedRawFP2.reset_index(drop = True)\n",
    "        #transpose back\n",
    "        temp2 = sortedRawFP2.set_index(sortedRawFP2.columns[0])\n",
    "        transposeRawFP2 = temp2.transpose()\n",
    "        transposeRawFP2 = transposeRawFP2.reset_index()\n",
    "        transposeRawFP2.rename(columns = {\"index\" : rawCols[0]}, inplace = True)\n",
    "        transposeRawFP2.columns.name = None\n",
    "\n",
    "        transposeRawFP2.index = transposeRawFP2[rawCols[0]]\n",
    "        transposeRawFP2 = transposeRawFP2.drop(columns=[rawCols[0]])\n",
    "        return transposeRawFP2, idxMap \n",
    "    else:\n",
    "        return None, None\n",
    "\n",
    "#############################################################\n",
    "#  Helper routines - Scale data for FW Algo\n",
    "#############################################################\n",
    "def minMaxScaler(x, exclude_cols = []):\n",
    "    if isinstance(x,np.ndarray):\n",
    "        z = x.copy()\n",
    "    elif isinstance(x, pd.DataFrame):\n",
    "        #keep cols order (whatever it may be)\n",
    "        origCols = tuple(x.columns)\n",
    "        tempColsAll = [ str(s) + \"_\"+ str(i) for i,s in enumerate(x.columns)]\n",
    "        tempColsMapIdxAll = { s : i for i,s in enumerate(tempColsAll)}\n",
    "        temp1 = x.copy()\n",
    "        temp1.columns = tempColsAll\n",
    "        #keep numeric columns\n",
    "        temp2 = temp1.select_dtypes(include = 'number')\n",
    "        numCols = temp2.columns\n",
    "        z = temp2.to_numpy()\n",
    "                \n",
    "    min_x = z.min()\n",
    "    z -= min_x\n",
    "    minMaxRange = z.ptp()\n",
    "    \n",
    "    if minMaxRange != 0:\n",
    "        z = z / minMaxRange\n",
    "        if isinstance(x,np.ndarray):\n",
    "            return z, minMaxRange, min_x\n",
    "        elif isinstance(x, pd.DataFrame):           \n",
    "            for j in range(z.shape[1]):\n",
    "                tempColsLabel = numCols[j] \n",
    "                cols_idx = tempColsMapIdxAll[tempColsLabel]\n",
    "                temp1.iloc[:,cols_idx]= z[:,j]\n",
    "                temp1.columns = origCols\n",
    "            return temp1, minMaxRange, min_x\n",
    "    else:\n",
    "        return x, None, None\n",
    "\n",
    "def minMaxUnScale(z, MinMaxRange, min_x):\n",
    "    if MinMaxRange:\n",
    "        if isinstance(z,np.ndarray):\n",
    "            x = z.copy()\n",
    "        elif isinstance(z, pd.DataFrame):\n",
    "            #keep cols order (whatever it may be)\n",
    "            origCols = tuple(z.columns)\n",
    "            tempColsAll = [ str(s) + \"_\"+ str(i) for i,s in enumerate(z.columns)]\n",
    "            tempColsMapIdxAll = { s : i for i,s in enumerate(tempColsAll)}\n",
    "            temp1 = z.copy()\n",
    "            temp1.columns = tempColsAll\n",
    "            #keep numeric columns\n",
    "            temp2 = temp1.select_dtypes(include = 'number')\n",
    "            numCols = temp2.columns\n",
    "            x = temp2.to_numpy()\n",
    "        \n",
    "        \n",
    "        x = x * MinMaxRange + min_x\n",
    "        \n",
    "        if isinstance(z,np.ndarray):\n",
    "            return x\n",
    "        elif isinstance(z, pd.DataFrame):           \n",
    "            for j in range(x.shape[1]):\n",
    "                tempColsLabel = numCols[j] \n",
    "                cols_idx = tempColsMapIdxAll[tempColsLabel]\n",
    "                temp1.iloc[:,cols_idx]= x[:,j]\n",
    "                temp1.columns = origCols\n",
    "            return temp1\n",
    "    else:\n",
    "        return z\n",
    "\n",
    "###########################################################################\n",
    "######## Core Frank Wolfe Algo  #################\n",
    "###########################################################################\n",
    "\n",
    "\n",
    "def objectiveFunc(I,X,T):\n",
    "    return np.trace(T @ X.T @ I @ X)\n",
    "       #def ObjectiveFunc():\n",
    "       #    X = np.asmatrix([ [X] * N for _ in range(K)])\n",
    "       #    ObjFun = ((T % t(X) % I % X).transpose()).trace()\n",
    "       #    return ObjFun\n",
    "\n",
    "def boostTeamsInternalCollab(I, booster = 100):\n",
    "    if (type(I) == np.matrix and I.shape[0] == I.shape[1]):\n",
    "        boostI = I.copy()\n",
    "        np.fill_diagonal(boostI, booster*np.max(I))\n",
    "        return boostI\n",
    "\n",
    "\n",
    "def FwOptimizer2(I,X,T,teamSizeVector, floorCapVector, K, N, changeIdx, relConstraints = False, teamIdMap = None, dcDF = None):\n",
    "    \"\"\"\n",
    "    Frank Wolfe algorithm\n",
    "    NOTE: Microsoft research paper\n",
    "    # SEARCH FOR THIS TAG\n",
    "\n",
    "    inputs:\n",
    "    ------\n",
    "    I: interactions matrix\n",
    "    X: floor plan matrix\n",
    "    T: distance matrix\n",
    "    teamSizeVector: team size file\n",
    "    floorCapVector: floor capacity file\n",
    "    K: number of teams\n",
    "    N: number of floors\n",
    "    changeIdx: for interactive mode - delta of user changes - what user changes\n",
    "    in interaction mode\n",
    "    relConstraints: additional constraints that a user adds (boolean) \n",
    "    teamIdMap: when user uploads the file for the first time, it sorts the file and maps it to an id\n",
    "    dcDF: relative constraints input from user for distance constraints\n",
    "    \n",
    "    returns:\n",
    "    ------\n",
    "    X: floor plan - matrix \n",
    "    success: boolean\n",
    "    count: \n",
    "    txx: loss function to minmize\n",
    "    \"\"\"\n",
    "    #initialize linear search\n",
    "    try:\n",
    "        eps = 0.001\n",
    "        frobeniusNorm = eps+1\n",
    "        count = 0\n",
    "        gamma = 1.0 / (count + 2)\n",
    "        debug = False\n",
    "        pacifier = True\n",
    "        verbose = False # turn on for debuging\n",
    "        success = False\n",
    "        initX = X\n",
    "        while(frobeniusNorm > eps):\n",
    "            ############################################################################################\n",
    "            ## Data for Linear Program (formerly LpSove)\n",
    "            ############################################################################################\n",
    "            #Objective function. Min linear G(Xk)* Y \n",
    "            def getGradient(I, X, T):\n",
    "              \"\"\"\n",
    "              previous1: #return (I + I.T) @ X @ T\n",
    "              previous2: I.T @ X @ T + I @ X @ T.T --> (I^T X * T + I * X* T^T)\n",
    "              \"\"\"\n",
    "              return I @ X @ T + I.T @ X @ T.T\n",
    "            \n",
    "                \n",
    "      \n",
    "            Gmat= getGradient(I, X, T)\n",
    "            G =  np.array(Gmat.T).ravel()\n",
    "            #Constraint 1. Allocate All team members i.e. sum of team = 100% of team size (acroos all floors)\n",
    "            teamIdxPerFloor = []\n",
    "            for start_i in range(K):\n",
    "                temp_i = [K*j+start_i for j in range(N)]\n",
    "                teamIdxPerFloor.append(temp_i)\n",
    "            #Constraint 2. All variables >= 0\n",
    "            # x_i allocation >= 0 (see linear program below) \n",
    "            #Constraint 3. Floor <= floor capacity\n",
    "            floorIdxAllTeams = []\n",
    "            for j in range(0,N*K,K):\n",
    "                temp_j = [j + i for i in range(K)]\n",
    "                floorIdxAllTeams.append(temp_j)\n",
    "            #Constraint 4. Interactive \n",
    "            #   changeIdxs = whereChangeFlat(X1,X2, K, N)  #Calculated in driver program\n",
    "            if(debug):    \n",
    "                print(\" G(Xk) : \" , G)\n",
    "                print(\"Constraint1.X.indexes: \", teamIdxPerFloor)\n",
    "                print(\"Constraint3.X.indexes: \", floorIdxAllTeams)\n",
    "            ############################################################################################\n",
    "            ## Linear Program \n",
    "            ############################################################################################\n",
    "            #Define problem\n",
    "            prob = pulp.LpProblem(\"FW line search\", pulp.LpMinimize )\n",
    "            #Define variables\n",
    "            var_idxs = list(range(N*K))\n",
    "            S = pulp.LpVariable.dict(\"x_\", var_idxs, lowBound=0, upBound = 1)\n",
    "            #check_idxs(X, var_idxs)\n",
    "            #Define objective Function.\n",
    "            prob += sum([G[i] * S[i] for i in range(K*N)])\n",
    "            #Constraint 1. Allocate all teams\n",
    "            for i in range(K):\n",
    "                prob += sum([S[j] for j in teamIdxPerFloor[i]]) == 1\n",
    "            #Constraint 2. All variables >= 0\n",
    "            for x_i in range(K*N):\n",
    "                prob += S[x_i] >= 0\n",
    "            #Constraint 3. floor <= floor capacity\n",
    "            teamSize = np.tile(teamSizeVector,N)\n",
    "            for j in range(N):\n",
    "                 prob +=sum([teamSize[i] * S[i] for i in floorIdxAllTeams[j]])<= floorCapVector[j]\n",
    "            #Constraint 4. Interactive\n",
    "            if (changeIdx is not None and len(changeIdx) > 0):\n",
    "                flatX = np.asarray(X).T.ravel()\n",
    "                for i in changeIdx:\n",
    "                    prob += S[i] == flatX[i]\n",
    "            if(debug):\n",
    "                print(\"  lpVariable.dict: \",  S)\n",
    "                print(\"  lpProblem...\",prob)\n",
    "            #Constraint 5. Relative Constraint\n",
    "            isRelCons = (relConstraints and (teamIdMap is not None))\n",
    "            if(isRelCons):\n",
    "                prob = addRelConstraintDistanceAvg2Avg(dcDF, T, S, teamIdMap, teamIdxPerFloor, prob)\n",
    "                print(\"LpProb after adding constraints...\")\n",
    "                print(prob)\n",
    "            ############################################################################################\n",
    "            ## Lp Solve & Wrap up results\n",
    "            ############################################################################################\n",
    "            print(\"Solving... \")\n",
    "            prob.solve()\n",
    "            print(\"Status:\", pulp.LpStatus[prob.status])\n",
    "            Xid = { str(v) : k for k,v in S.items()}\n",
    "            SoptVector = np.zeros(K*N)\n",
    "            for v in prob.variables():\n",
    "                #print(Xid[v.name], v.name, \"=\", v.varValue )\n",
    "                SoptVector[int(Xid[v.name])] = v.varValue\n",
    "            Sopt = np.matrix(SoptVector.reshape(N,K).T)\n",
    "            if(debug):\n",
    "                print(\"result: \", type(Sopt), np.round(Sopt,2))\n",
    "\n",
    "            ########################################################################################\n",
    "            ### Relative Constraints - Raw Output from Optimizer (for User Testing and Wire-framing)\n",
    "            #########################################################################################\n",
    "            #TO DO. Add addtional relative constraint test cases\n",
    "            if(isRelCons and pulp.LpStatus[prob.status] == 'Optimal'):\n",
    "                success = True\n",
    "                return Sopt, success, count\n",
    "\n",
    "            ############################################################################################\n",
    "            ## Optimize step size (gamma)\n",
    "            ############################################################################################\n",
    "            #plugin line search result (1-gamma) Y - gamma X into objective function\n",
    "            Y = Sopt\n",
    "            tXX = np.trace(T @ X.T @ I @ X)\n",
    "            tXY = np.trace(T @ X.T @ I @ Y) + np.trace(T @ Y.T @ I @ X)   \n",
    "            tYY = np.trace(T @ Y.T @ I @ Y)\n",
    "            a1 = tXX-tXY+tYY # gradient - how big of a jump to take\n",
    "            b1 = tXY-2*tXX\n",
    "            c1 = tXX\n",
    "            #solve for gamma and optimize inside region of interest\n",
    "            if(a1 > 0):\n",
    "                #find minimum of quadratic a1*gamma^2 + b1*gamma + c1\n",
    "                z = (-1*b1)/ (2*a1)    \n",
    "                #by definition gamma [0,1] (gamma is weighted average of line between X and Y points in solution space)\n",
    "                if (z>1): gamma = 1\n",
    "                elif (z<0): gamma = 3/(count+2)\n",
    "                else: gamma = z\n",
    "            if(a1<0):\n",
    "                #find maximum of quadratic a1*gamma^2 + b1*gamma + c1 \n",
    "                z = (-1*b1)/ (2*a1)\n",
    "                #by definition gamma [0,1] \n",
    "                if(z>=1): gamma = 3/(count+2)       # follow inverse direction of steepest descent\n",
    "                elif(z<0): gamma = 1\n",
    "                else:                     # inside polygon of valid solution\n",
    "                    if((a1+b1)> 0): gamma = 3/(count+2)\n",
    "                    else: gamma = 1\n",
    "            if (a1==0):     \n",
    "                #find minimum of linear b1*gamma  + c1 sbt [0,1] region\n",
    "                if (b1 >=0): gamma = 3/(count+2)\n",
    "                else: gamma = 1\n",
    "            \n",
    "\n",
    "            #update Xkplus1\n",
    "            Xk = X\n",
    "            X = Xk + gamma * (Y -Xk)\n",
    "            if(debug):\n",
    "                print(\"tXX :\", round(tXX,4)) # what we're trying to minmize (a1)\n",
    "                print(\"tXY :\", round(tXY,4))\n",
    "                print(\"tYY :\", round(tYY,4))\n",
    "                print(\"a1  : \", round(a1,2))\n",
    "                print(\"b1  : \", round(b1,2))\n",
    "                print(\"c1  : \", round(c1,2))\n",
    "                print(\"z   : \",  (-1*b1)/ (2*a1))\n",
    "                print(\"gamma: \", gamma)\n",
    "            ############################################################################################\n",
    "            ## Stop criteria\n",
    "            ############################################################################################\n",
    "            frobeniusNorm = np.linalg.norm(X-Xk, 'fro')\n",
    "            count+=1\n",
    "            #emergency break in case not converging\n",
    "            #usualy converge after 15 iterations\n",
    "            if (count>1000):\n",
    "              print(\"more than 1000 iterations... cannot converge\")\n",
    "              break\n",
    "            if(pacifier):\n",
    "                print(\"lp iteration: \" + str(count) + \" fNorm : \" + str(round(frobeniusNorm,6)))\n",
    "        if(verbose):\n",
    "                print(\"Initial placement... X0\")\n",
    "                print(initX)\n",
    "                print(\"FW Optimal placement... X\")\n",
    "                print(X)\n",
    "                print(\"Last Lp placement... Y\")\n",
    "                print(Y)\n",
    "        if (frobeniusNorm <= eps):\n",
    "            success = True\n",
    "            return X, success, count, tXX\n",
    "        else:\n",
    "            success = False\n",
    "            return X, success, count, tXX\n",
    "    except:\n",
    "        return {\"error\":\"error within FwOptimizer\"}\n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+2)'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "###########################################################################\n",
    "######## Initial placement heuristic - use arrangeTeams2  #################\n",
    "###########################################################################\n",
    "\n",
    "\n",
    "debug_temp = []\n",
    "def arrangeTeams(iterFloor, iterTeam, I, T, c, s, flag_max, preSetupTeamAllocation, useTeamRatio = False): ##TODO: REVIEW\n",
    "    \"\"\"\n",
    "      follows wpa collab data to set starting points. takes one team - looks for max collab in group-to-group query and place it close to the team it collabs closely with. (X0); starting point for frank wolfe algo\n",
    "    \"\"\"\n",
    "    global debug_temp\n",
    "    debug = False\n",
    "    if isinstance(s,np.ndarray):\n",
    "        requestedSeats = s.copy()\n",
    "    elif isinstance(s, tuple) or isinstance(s, list):\n",
    "        requestedSeats = np.array(s)\n",
    "    #flag_max = FALSE\n",
    "    \n",
    "    N = T.shape[0]\n",
    "    #K - teams number\n",
    "    K = I.shape[0]\n",
    "\n",
    "    listTeams = None\n",
    "    #find the largest team\n",
    "    teamInd = 0 #iterTeam  #which.max(s) #TODO: Update\n",
    "    floorNum = iterFloor\n",
    "     \n",
    "    if listTeams == None:\n",
    "        listTeams = [0]#[teamInd] \n",
    "    else:\n",
    "        listTeams = [listTeams, teamInd]\n",
    "  \n",
    "    #################################################################################################\n",
    "    #Changing capacity and team size according to user input/constrains for correct X0 initialization\n",
    "    #################################################################################################\n",
    "    X0 = np.asmatrix([ [0] * N for _ in range(K)])\n",
    "    # i = 1\n",
    "    persistantS = tuple(s)\n",
    "    if (len(preSetupTeamAllocation) > 0):  \n",
    "        for i in range(0, len(preSetupTeamAllocation)):\n",
    "            constrain = preSetupTeamAllocation[i]\n",
    "            indTeam = constrain[0]\n",
    "            indFloor  = constrain[1]\n",
    "            if useTeamRatio:\n",
    "                teamRatio = constrain[2]\n",
    "                teamAlloc  =  teamRatio * persistantS[indTeam]\n",
    "            else:\n",
    "                teamAlloc  = constrain[2]\n",
    "                \n",
    "            if(isinstance(X0,pd.DataFrame)):\n",
    "                X0.iloc[indTeam, indFloor] = np.round(teamAlloc)\n",
    "                requestedSeats[indTeam] = requestedSeats[indTeam] - np.round(teamAlloc)\n",
    "            else:\n",
    "                X0[indTeam, indFloor] = np.round(teamAlloc)\n",
    "                requestedSeats[indTeam] = requestedSeats[indTeam] - np.round(teamAlloc)\n",
    "            \n",
    "    s = np.round(s, 4)\n",
    "    c = np.round(c, 4)\n",
    "    \n",
    "    #inmutable copy of user requested initializations (to be used by placeTeamOnFloor)\n",
    "    preAllocX =  X0.copy()\n",
    "    preAllocX.setflags(write = 0)\n",
    "           \n",
    "    while (len(listTeams) <= K):\n",
    "        if(debug):\n",
    "            debug_temp.append((listTeams.copy(), teamInd, floorNum, requestedSeats.copy(), X0.copy()))\n",
    "        res = placeTeamOnFloor(floorNum, teamInd, c, requestedSeats, X0, 1, preAllocX)\n",
    "        X0 = res[\"X0\"]\n",
    "        \n",
    "        floorNum = res[\"floorNum\"]\n",
    "        \n",
    "        if (len(listTeams) == K):\n",
    "            break\n",
    "\n",
    "        #TODO: update names change froim length\n",
    "        length = len(listTeams)\n",
    "        pickFrom = list(set(list(range(0, len(s)))) - set(list(range(teamInd, teamInd+1))))\n",
    "        while len(listTeams) != (length + 1):\n",
    "            #TODO; dupplicate casting to list\n",
    "            topCollabTeamInd = list([pickFrom[np.argmax(np.array(I[teamInd:teamInd+1,[pickFrom]].tolist()))]]) #TODO: CHECK FOR VALIDITY\n",
    "            if flag_max:\n",
    "                topCollabTeamInd = random.randint(0, len(delete))\n",
    "\n",
    "            topCollabTeamInd = topCollabTeamInd[0]\n",
    "\n",
    "            if (len(set(listTeams).intersection([topCollabTeamInd])) == 0):\n",
    "                listTeams.append(topCollabTeamInd)\n",
    "\n",
    "            pickFrom = list(set(pickFrom) - set([topCollabTeamInd])) #TODO REVIEW: changes to return List, set failing on place team on floor else cases\n",
    "            \n",
    "        teamInd = listTeams[len(listTeams)-1] #TODO: Review, added -1\n",
    "\n",
    "    #rmatS = np.asmatrix([persistantS] * N)\n",
    "    #X0 =  np.around(X0/np.rot90(rmatS, 3), 4)\n",
    "\n",
    "    return X0\n",
    "\n",
    "\n",
    "def arrangeTeams2(iterFloor, iterTeam, I, T, K, N, floorCapVector, teamSizeVector, flag_max, preSetupTeamAllocation, useTeamRatio = False, flatX0 = False):\n",
    "    \"\"\"\n",
    "    flatX0 is now set to True\n",
    "    \"\"\"\n",
    "    #Random initializatin. \n",
    "    #N - number of floors, K - number of teams\n",
    "    res1 = []\n",
    "    for floorID in range(N):\n",
    "        if not flatX0: #not guaranteed to make constraint (equal number of team - can be greater or less)\n",
    "#             print('ACTIVATED!')\n",
    "            floorX0Ratio = 1/N*np.random.uniform(0,1,(1,K)) #same seed, same results; different seed, different results --> return best floor plan\n",
    "            floorCap = [floorCapVector[floorID]] * K\n",
    "            floorX0 = [ x * y for x, y in zip(floorCap, floorX0Ratio)] \n",
    "        else:\n",
    "            floorX0Ratio = np.array([1/N] * K).reshape(1,K) # runs this when flatX0 is at default True\n",
    "            floorCap = [floorCapVector[floorID]] * K\n",
    "            floorX0 = [ x * y for x, y in zip(floorCap, floorX0Ratio)]\n",
    "        res1.append(list(floorX0))\n",
    "    res2 = np.concatenate(res1).T\n",
    "    \n",
    "    #### Add user input from \"Interactive\" mode. i.e. preSetupTeamAllocation ###\n",
    "    X0 = res2\n",
    "    if (len(preSetupTeamAllocation) > 0):  \n",
    "        for i in range(0, len(preSetupTeamAllocation)):\n",
    "            constrain = preSetupTeamAllocation[i]\n",
    "            indTeam = constrain[0]\n",
    "            indFloor  = constrain[1]\n",
    "            if useTeamRatio:\n",
    "                teamRatio = constrain[2]\n",
    "                teamAlloc  =  teamRatio * persistantS[indTeam]\n",
    "            else:\n",
    "                teamAlloc  = constrain[2]\n",
    "                \n",
    "            if(isinstance(X0,pd.DataFrame)):\n",
    "                X0.iloc[indTeam, indFloor] = np.round(teamAlloc)\n",
    "                #requestedSeats[indTeam] = requestedSeats[indTeam] - np.round(teamAlloc)\n",
    "            else:\n",
    "                X0[indTeam, indFloor] = np.round(teamAlloc)\n",
    "                #requestedSeats[indTeam] = requestedSeats[indTeam] - np.round(teamAlloc)\n",
    "    \n",
    "    return X0\n",
    "  \n",
    "  \n",
    "  \n",
    "  \n",
    " #s1 =[]\n",
    "\n",
    "def placeTeamOnFloor(floorNum, teamInd, c, s, X0, folds, preAllocMat): ##TODO: COMPLETE\n",
    "    s1 = s #.copy()\n",
    "    if s1[teamInd] == 0:\n",
    "        res = {}\n",
    "        res[\"X0\"] = X0\n",
    "        res[\"s\"] = s\n",
    "        res[\"floorNum\"] = floorNum\n",
    "        return res\n",
    "\n",
    "    #think on bad scenario\n",
    "    #print(folds)\n",
    "    if (folds  > len(c)):\n",
    "        res = {}\n",
    "        res[\"X0\"] = -1\n",
    "        res[\"s\"] = -1 #updated team size\n",
    "        res[\"floorNum\"] = -1\n",
    "        return res\n",
    "   \n",
    "    if (preAllocMat[teamInd, floorNum] == 0):\n",
    "        \n",
    "        occupiedSpaceOnFloor = sum(X0[:,floorNum])\n",
    "        availableSpace = np.asmatrix(c[floorNum]) - occupiedSpaceOnFloor\n",
    "        seatsNeededForTeam = s1[teamInd]\n",
    "\n",
    "        if (availableSpace >= seatsNeededForTeam):\n",
    "            X0[teamInd, floorNum] = seatsNeededForTeam      \n",
    "            s1[teamInd] = 0\n",
    "\n",
    "        else:\n",
    "            s1[teamInd] = seatsNeededForTeam - availableSpace\n",
    "            X0[teamInd, floorNum] = availableSpace\n",
    "\n",
    "            if (floorNum < len(c)):\n",
    "                floorNum += 1\n",
    "            else:\n",
    "                floorNum = 1\n",
    "\n",
    "            folds += 1\n",
    "    else:\n",
    "        print(\"Skiping pre-allocated values..\" , teamInd, floorNum, X0[teamInd,floorNum] )\n",
    "        if (floorNum < len(c)):\n",
    "            floorNum += 1\n",
    "        else:\n",
    "            floorNum = 1\n",
    "        folds += 1\n",
    "\n",
    "    return placeTeamOnFloor(floorNum, teamInd, c, s1, X0, folds,preAllocMat)\n",
    "\n",
    "\n",
    "\n",
    "display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+2)'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "######              START: local files INPUT \n",
    "\n",
    "##################################################\n",
    "#       Load local Files ** Start Here **\n",
    "###################################################\n",
    "inputpathffs = cwd + '\\\\Final Files set\\\\'        \n",
    "input_path = inputpathffs\n",
    "\n",
    "if fixedSpaces:\n",
    "    fs_input_path = load_fsp_file.selected_path + '\\\\'+ load_fsp_file.selected_filename\n",
    "    \n",
    "\n",
    "#parameters for X0 heuristics test\n",
    "X0_heuristics_options = { 0 : \"Azt Classic - WPA Data\", 2: \"Stacker Tool - Uniform\", 3:  \"Azt New - Larger  v1\" }\n",
    "X0_heuristics = X0_heuristics_options[2]\n",
    "\n",
    "\n",
    "#input flat version of G2G query\n",
    "flatInteractionBool = True\n",
    "\n",
    "rawIraw = pd.read_csv(input_path+\"interactions.csv\")\n",
    "if(flatInteractionBool):\n",
    "    rawI = createInteractionsMatrix2(rawIraw)\n",
    "rawT =  pd.read_csv(input_path+\"distance.csv\")\n",
    "\n",
    "\n",
    "if not variableSeats:\n",
    "    rawfloorCapacity = pd.read_csv(input_path+\"space_capacity.csv\")\n",
    "    rawTS = pd.read_csv(input_path+\"team_size.csv\")\n",
    "    \n",
    "    col1_TS = rawTS.columns[0]\n",
    "    rawTS[col1_TS] = rawTS[col1_TS].astype(str)\n",
    "    \n",
    "\n",
    "    \n",
    "\n",
    "##################################################\n",
    "#       Simulate Fixed Spaces INPUT  ** Here **\n",
    "###################################################\n",
    "if fixedSpaces:\n",
    "    \n",
    "    rawFixedSpaces = pd.read_csv(fs_input_path)\n",
    "\n",
    "    #clean and prep fs file input\n",
    "    rawFixedSpaces.fillna(0, inplace = True)\n",
    "    fs_cols = rawFixedSpaces.columns\n",
    "    rawFixedSpaces = rawFixedSpaces.sort_values(by = [fs_cols[0]])\n",
    "    fs_team_names = list(rawFixedSpaces.iloc[:,0])\n",
    "    rawFixedSpaces.index = fs_team_names \n",
    "    rawFixedSpaces.drop(columns = [fs_cols[0]], inplace = True)\n",
    "    fs_space_names = list(rawFixedSpaces.columns)\n",
    "\n",
    "    K = rawFixedSpaces.shape[0]\n",
    "    N = rawFixedSpaces.shape[1]\n",
    "\n",
    "    print(\"loading fixed spaces from file... \")\n",
    "    print(\"fixed spaces input path:\", load_fsp_file.selected_path)\n",
    "    print(\"fixed spaces filename:\", load_fsp_file.selected_filename)\n",
    "    \n",
    "    \n",
    "    ### Use fixed spaces floorplan to create a floorplan that resembles the users floorplan with all zeroes as original_floorplan\n",
    "    fp_orig = rawFixedSpaces.copy()\n",
    "    fp_modif = rawFixedSpaces.copy()\n",
    "    \n",
    "    for col in fp_orig .columns:\n",
    "        fp_orig[col].values[:] = 0\n",
    "    #############################################################################\n",
    "    ## FIXED SPACES VALIDATIONS:\n",
    "    #1\n",
    "        ##Validation #1.  Ensure that the sum of all rows for each column (which corresponds to spaces) \n",
    "        ##in the user provided fixed space file does not exceed the space capacity of that space.\n",
    "\n",
    "    getfloorcaps = rawFixedSpaces.reset_index()\n",
    "    getfloorcaps = getfloorcaps.drop(getfloorcaps.columns[0],axis=1)\n",
    "    floorcaps1 = getfloorcaps.melt(var_name='Floor',value_name='Total Used').groupby('Floor').sum()\n",
    "    floorcaps1 = floorcaps1.reset_index()\n",
    "    floorcaps_validation1 = floorcaps1.merge(rawfloorCapacity,on='Floor')\n",
    "    floorcaps_validation1['exceedsCapacity'] = np.select([floorcaps_validation1['Total Used'] > floorcaps_validation1['Total Capacity']],[1],default=0)\n",
    "    validation1_fsp_failed = floorcaps_validation1[floorcaps_validation1['exceedsCapacity']==1]   \n",
    "    if len(validation1_fsp_failed) > 0:\n",
    "        print(CRED,BOLD,'Validation Fixed Spaces 1 Error:',CEND,' One or more rows in the user provided fixed space file', BOLD,'exceeds',CEND,'the space capacity of that space')\n",
    "        display(out)\n",
    "        display(validation1_fsp_failed)\n",
    "        raise SystemExit('Validation Fixed Spaces 1 Error!')\n",
    "    else:\n",
    "        print(CGREEN,'Validation Fixed Spaces 1-Passed')\n",
    "\n",
    "\n",
    "\n",
    "    ##2\n",
    "        ##Validation #2.  Ensure that the size of the fixed space file is the same dimensions as the floor plan that \n",
    "        ##will be produced by the run.  So make sure the file is has n rows and k columns, \n",
    "        ##where n is the number of groups and k is  the number of spaces.\n",
    "\n",
    "    dimensions_INTX = set(rawIraw[rawIraw.columns[0]])\n",
    "    dimensions_FC = set(rawfloorCapacity[rawfloorCapacity.columns[0]])\n",
    "\n",
    "    indx_rawFSP = rawFixedSpaces.reset_index().copy()\n",
    "    dimensions_row_FSP = set(indx_rawFSP[indx_rawFSP.columns[0]])\n",
    "\n",
    "    colscount_FSP= len(rawFixedSpaces.columns)\n",
    "    dimensions_col_FSP = set(getfloorcaps[getfloorcaps.columns[0:colscount_FSP]])\n",
    "\n",
    "    if(len(dimensions_col_FSP) > len(dimensions_FC)):\n",
    "        uniquediffFSP = dimensions_col_FSP - dimensions_FC\n",
    "    else:\n",
    "        uniquediffFSP = dimensions_FC - dimensions_col_FSP\n",
    "\n",
    "    if(len(dimensions_row_FSP) > len(dimensions_INTX)):\n",
    "        uniquediffFSP2 = dimensions_row_FSP - dimensions_INTX\n",
    "    else:\n",
    "        uniquediffFSP2 = dimensions_INTX - dimensions_row_FSP\n",
    "\n",
    "    if len(uniquediffFSP) > 0 and len(uniquediffFSP2) > 0:\n",
    "        print(CRED,BOLD,'Validation Fixed Spaces 2 - Error: n-cols',CEND)\n",
    "        print(' One or more column dimensions in the user provided fixed space file', BOLD,'is not the same',CEND,' as expected.')\n",
    "        print(uniquediffFSP)\n",
    "        display(out)\n",
    "        print(CRED,BOLD,'Validation Fixed Spaces 2 - Error: k-rows',CEND)\n",
    "        print(' One or more rows of dimensions in the user provided fixed space file', BOLD,'is not the same',CEND,' as expected.')\n",
    "        print(uniquediffFSP2)\n",
    "        display(out)\n",
    "        raise SystemExit('Validation Fixed Spaces 2 - Errors!')\n",
    "\n",
    "    if len(uniquediffFSP) == 0 and len(uniquediffFSP2) == 0 and (len(uniquediffFSP) > 0 or len(uniquediffFSP2) > 0):\n",
    "        print(CGREEN,'Validation Fixed Spaces 2-Passed')\n",
    "\n",
    "\n",
    "    if len(uniquediffFSP) > 0 and len(uniquediffFSP2) == 0:\n",
    "        print(CRED,BOLD,'Validation 2 - Error: n-cols',CEND)\n",
    "        print(' One or more column dimensions in the user provided fixed space file', BOLD,'is not the same',CEND,' as expected.')\n",
    "        print(uniquediffFSP)\n",
    "        display(out)\n",
    "        raise SystemExit('Validation Fixed Spaces 2 - Error: n-cols!')\n",
    "    else:\n",
    "        print(CGREEN,'Validation Fixed Spaces 2-Passed: n-cols')\n",
    "\n",
    "    if len(uniquediffFSP) == 0 and len(uniquediffFSP2) > 0:\n",
    "        print(CRED,BOLD,'Validation 2 - Error: k-rows',CEND)\n",
    "        print(' One or more rows of dimensions in the user provided fixed space file', BOLD,'is not the same',CEND,' as expected.')\n",
    "        print(uniquediffFSP2)\n",
    "        display(out)\n",
    "        raise SystemExit('Validation 2 - Error: k-rows!')\n",
    "    else:\n",
    "        print(CGREEN,'Validation Fixed Spaces 2-Passed: k-rows',CEND)\n",
    "        \n",
    "\n",
    "        \n",
    "        \n",
    "##############################################################################\n",
    "######## sort files - make sure its consistently ordered, normally     #######\n",
    "######## this is because floorplans are serialized and passed as jsons #######\n",
    "##############################################################################\n",
    "\n",
    "# logging_output = output_log(logging_output, \"StdOut\", \"Sorting Four Input Files + Floorplans.\")\n",
    "# logging_output.to_json(\"/dbfs/\" + log_folder + \"full_log.json\", orient='records')\n",
    "\n",
    "try:\n",
    "    ### sort before passing into function\n",
    "    # sort floors\n",
    "    floorsDF = sortFloorsDF(rawfloorCapacity)\n",
    "    # sort Team Size\n",
    "    sRawTS = sortTeamsDF(rawTS)\n",
    "    # sort interactions\n",
    "    rawI = createInteractionsMatrix2(rawIraw)\n",
    "    sRawI, idxMapI = sortInteractions(rawI)\n",
    "    # sort distance\n",
    "    sRawT, idxMapT = sortDistance(rawT)\n",
    "\n",
    "    # sort floor plan\n",
    "    #fp_orig, idxMapFPo = sortFloorplan(floorplan_orig)\n",
    "    # ensure floorplan columns are the same\n",
    "#     if isinstance(floorplan_modif, pd.DataFrame):\n",
    "#         floorplan_modif.columns = ['teamName'] + [x.split('_')[1] for x in floorplan_modif.columns if x != 'teamName']\n",
    "#         fp_modif, idxMapFPi = sortFloorplan(floorplan_modif)\n",
    "\n",
    "\n",
    "except Exception as e:\n",
    "#     logging_output = output_log(logging_output, \"StdErr\", str(e))\n",
    "#     logging_output.to_json(\"/dbfs/\" + log_folder + \"full_log.json\", orient='records')\n",
    "    raise ValueError(e)\n",
    "    \n",
    "\n",
    "######              END: local files INPUT \n",
    "\n",
    "display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+2)'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "################################################################################################\n",
    "#                       Variable Workspaces - Helper Functions\n",
    "################################################################################################\n",
    "\n",
    "def parseSpaceTypeColumns(floorsDF, idxFirstCol = 1):\n",
    "    \"\"\"\n",
    "    chops first column so that index is floors\n",
    "    and columns are total capacty, seat type 1, seat type 2, etc.\n",
    "    \n",
    "    essentially drops the Floor column and turns it into an index.\n",
    "    \"\"\"\n",
    "    spaceTypesDF = floorsDF.iloc[:,idxFirstCol:]\n",
    "    spaceTypesDF.index = floorsDF.iloc[:,0]\n",
    "    spaceTypesDF.index.name = None\n",
    "    return spaceTypesDF\n",
    "\n",
    "def parseTeamSeatTypeColumns(sRawTS, idxFirstCol = 1):\n",
    "    \"\"\"\n",
    "    turns column 0 into the index. the index is now Division 1, Division 2, etc\n",
    "    and the columns are the total team size, role 1, role 2, etc.\n",
    "    \n",
    "    essentially drop the Team column in positoin 0 and turn it into an index.\n",
    "    \"\"\"\n",
    "    idxFirstCol = 1\n",
    "    teamSeatTypesDF = sRawTS.iloc[:,idxFirstCol:]\n",
    "    teamSeatTypesDF.index = sRawTS.iloc[:,0]\n",
    "    teamSeatTypesDF.index.name = None\n",
    "    return teamSeatTypesDF\n",
    "\n",
    "def createSpaceTypesCatalog(spaceTypesDF):\n",
    "    \"\"\"\n",
    "    NOTE: This function assumes there are only two different space types.\n",
    "    \n",
    "    This function splits a floorplan consisting of multiple seat types into two \n",
    "    different dataframes specific for the floorplan.\n",
    "    \n",
    "    For example, East-Floor1 --> East-Floor1-Offices = 30; East-Floor1-Cubicles = 100\n",
    "    \"\"\"\n",
    "    #seatType1SpacesLabels = []\n",
    "    #seatType2SpacesLabels = []\n",
    "    seatType1SpacesSeats = []\n",
    "    seatType2SpacesSeats = []\n",
    "    allSpaces = list(spaceTypesDF.index)\n",
    "    cols = spaceTypesDF.columns\n",
    "    seatTypeName1 = cols[1]\n",
    "    seatTypeName2 = cols[2]\n",
    "    for spaceName in allSpaces:\n",
    "        seatType1SpacesRow = {}\n",
    "        newSpaceName1 = spaceName +\"_\" + seatTypeName1\n",
    "        seatType1SpacesRow[\"actual_space_name\"] = spaceName\n",
    "        seatType1SpacesRow[\"variable_space_name\"] = newSpaceName1\n",
    "        seatType1SpacesRow[\"seat_type\"] = seatTypeName1\n",
    "        #seatType1SpacesLabels.append(seatType1SpacesRow.copy())\n",
    "        seatType2SpacesRow = {}\n",
    "        newSpaceName2 = spaceName +\"_\" + seatTypeName2\n",
    "        seatType2SpacesRow[\"actual_space_name\"] = spaceName\n",
    "        seatType2SpacesRow[\"variable_space_name\"] = newSpaceName2\n",
    "        seatType2SpacesRow[\"seat_type\"] = seatTypeName2\n",
    "        #seatType2SpacesLabels.append(seatType2SpacesRow.copy())\n",
    "        seatsType1Cap = spaceTypesDF.loc[spaceName, cols[1]]\n",
    "        seatsType2Cap = spaceTypesDF.loc[spaceName, cols[2]]\n",
    "        seatsTotalCap = seatsType1Cap + seatsType2Cap\n",
    "        totalRaw = spaceTypesDF.loc[spaceName, cols[0]]\n",
    "        if (seatsTotalCap != totalRaw):\n",
    "            print(\"WARNING: Total seats do not match for Variable Workspace. Space Capacity input file validation \")\n",
    "            print(\"total firxt column Total Capacity Column:\", totalRaw)\n",
    "            print(\"total Seats Type 1:\", seatsType1, \"Seats Type 2:\", seatsType2, \"total both columns:\", seatsTotal)\n",
    "        seatType1SpacesRow[\"space_capacity\"] = seatsType1Cap\n",
    "        seatType2SpacesRow[\"space_capacity\"] = seatsType2Cap\n",
    "        seatType1SpacesSeats.append(seatType1SpacesRow.copy())\n",
    "        seatType2SpacesSeats.append(seatType2SpacesRow.copy())\n",
    "    spaceType1DF = pd.DataFrame(seatType1SpacesSeats)\n",
    "    spaceType2DF = pd.DataFrame(seatType2SpacesSeats)\n",
    "    return spaceType1DF, spaceType2DF\n",
    "\n",
    "def createTeamSeatTypesCatalog(teamSeatTypesDF):\n",
    "    \"\"\"\n",
    "    NOTE: This function assumes there are only two different type of roles.\n",
    "    \n",
    "    This function splits a team consisting of multiple roles into two \n",
    "    different dataframes specific to the role\n",
    "    \n",
    "    For example, Team1 --> Team1-Directors = 10, Team1-Contributors = 100\n",
    "    \"\"\"\n",
    "    seatType1 = []\n",
    "    seatType2 = []\n",
    "    allTeams = list(teamSeatTypesDF.index)\n",
    "    cols = teamSeatTypesDF.columns\n",
    "    seatTypeName1 = cols[1]\n",
    "    seatTypeName2 = cols[2]\n",
    "    for teamName in allTeams:\n",
    "        seatType1Row = {}\n",
    "        newTeamName1 = teamName +\"_\" + seatTypeName1\n",
    "        seatType1Row[\"actual_team_name\"] = teamName\n",
    "        seatType1Row[\"variable_team_name\"] = newTeamName1\n",
    "        seatType1Row[\"seat_type\"] = seatTypeName1\n",
    "        seatType2Row = {}\n",
    "        newTeamName2 = teamName +\"_\" + seatTypeName2\n",
    "        seatType2Row[\"actual_team_name\"] = teamName\n",
    "        seatType2Row[\"variable_team_name\"] = newTeamName2\n",
    "        seatType2Row[\"seat_type\"] = seatTypeName2\n",
    "        #seatType2SpacesLabels.append(seatType2SpacesRow.copy())\n",
    "        seatsType1Size = teamSeatTypesDF.loc[teamName, cols[1]]\n",
    "        seatsType2Size = teamSeatTypesDF.loc[teamName, cols[2]]\n",
    "        seatsTotalSize = seatsType1Size + seatsType2Size\n",
    "        totalSizeRaw = teamSeatTypesDF.loc[teamName, cols[0]]\n",
    "        if (seatsTotalSize != totalSizeRaw):\n",
    "            print(\"WARNING: Total seats do not match for Variable Workspace. TEAM SIZE input file validation \")\n",
    "            print(\"total first column Size:\", totalSizeRaw)\n",
    "            print(\"total Seats Type 1:\", seatsType1Size, \"Seats Type 2:\", seatsType2Size, \"total both columns:\", seatsTotalSize)\n",
    "        seatType1Row[\"team_size\"] = seatsType1Size\n",
    "        seatType2Row[\"team_size\"] = seatsType2Size\n",
    "        seatType1.append(seatType1Row.copy())\n",
    "        seatType2.append(seatType2Row.copy())\n",
    "    seatType1DF = pd.DataFrame(seatType1)\n",
    "    seatType2DF = pd.DataFrame(seatType2)\n",
    "    return seatType1DF, seatType2DF\n",
    "\n",
    "##################################################  \n",
    "# THESE ARE REPEATED FOR N NUMBER OF TEAMS\n",
    "##################################################\n",
    "  \n",
    "def createDummyFloorsDF(spaceTypeCatalog, floorsDF ):\n",
    "    \"\"\"\n",
    "    Create a floorplans for its respective seat type.\n",
    "    \"\"\"\n",
    "    dummyFloorsDF  = spaceTypeCatalog[[\"variable_space_name\", \"space_capacity\"]].copy()\n",
    "    dummyFloorsDF.rename(columns = {\"variable_space_name\" : floorsDF.columns[0], \"space_capacity\" : floorsDF.columns[1]}, inplace = True)\n",
    "    return dummyFloorsDF\n",
    "  \n",
    "def createDummyTeamSize(teamSeatTypes, sRawTS):\n",
    "    \"\"\"\n",
    "    Create a team size files for its respective role type.\n",
    "    \"\"\"\n",
    "    dummyTS =  teamSeatTypes[[\"variable_team_name\", \"team_size\"]].copy()\n",
    "    dummyTS.rename(columns = {\"variable_team_name\" : sRawTS.columns[0], \"team_size\":sRawTS.columns[1] }, inplace = True )\n",
    "    return dummyTS\n",
    "\n",
    "def createDummyDistanceMatrix(dummyFloorsDF, sRawT):\n",
    "    \"\"\"\n",
    "    Creates a distance file respective to its seat-specific floorplan.\n",
    "    \"\"\"\n",
    "    dummyT = sRawT.copy()\n",
    "    dummyT.iloc[:,0] = dummyFloorsDF.iloc[:,0]\n",
    "    firstDummyCol = [dummyT.columns[0]]\n",
    "    dummyT.columns = firstDummyCol + list(dummyFloorsDF.iloc[:,0])\n",
    "    return dummyT\n",
    "\n",
    "def createDummyInteractionsMatrix(dummyTS, sRawI):\n",
    "    \"\"\"\n",
    "    creates an interaction file specific for the role type.\n",
    "    \"\"\"\n",
    "    dummyI = sRawI.copy()\n",
    "    dummyI.iloc[:,0] = dummyTS.iloc[:,0]\n",
    "    firstDummyCol = [dummyI.columns[0]]\n",
    "    dummyI.columns = firstDummyCol + list(dummyTS.iloc[:,0])\n",
    "    return dummyI\n",
    "\n",
    "display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+2)'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### pass information into the rawCsv dictionary for FWAlgo\n",
    "rawCsv = dict()\n",
    "\n",
    "rawCsv['distance'] = sRawT\n",
    "rawCsv['space_capacity'] = floorsDF\n",
    "rawCsv['interaction'] = sRawI\n",
    "rawCsv['team_size'] = sRawTS\n",
    "rawCsv['floorPlan_original'] = fp_orig\n",
    "rawCsv['floorPlan_modified'] = fp_modif\n",
    "\n",
    "display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+2)'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#################################################################################################\n",
    "########## for JJ - FWOptimizer2 has three new parameters - they are not used in first run ######\n",
    "########## variableWorkSpaces = False, numSeatTypes = 1, teamSizeVectorOffices = tuple()   ######\n",
    "########## in addition there is a new constraint - #Constraint 3B. For variable workspaces ######\n",
    "#################################################################################################\n",
    "\n",
    "\n",
    "def objectiveFunc(I,X,T):\n",
    "    return np.trace(T @ X.T @ I @ X)\n",
    "       #def ObjectiveFunc():\n",
    "       #    X = np.asmatrix([ [X] * N for _ in range(K)])\n",
    "       #    ObjFun = ((T % t(X) % I % X).transpose()).trace()\n",
    "       #    return ObjFun\n",
    "\n",
    "def boostTeamsInternalCollab(I, booster = 100):\n",
    "    if (type(I) == np.matrix and I.shape[0] == I.shape[1]):\n",
    "        boostI = I.copy()\n",
    "        np.fill_diagonal(boostI, booster*np.max(I))\n",
    "        return boostI\n",
    "\n",
    "\n",
    "# def FwOptimizer2(I,X,T,teamSizeVector, floorCapVector, K, N, changeIdx, relConstraints = False, teamIdMap = None, dcDF = None, variableWorkSpaces = False, numSeatTypes = 1, teamSizeVectorOffices = tuple()):\n",
    "#     \"\"\"\n",
    "#     Frank Wolfe algorithm\n",
    "#     NOTE: Microsoft research paper\n",
    "\n",
    "#     inputs:\n",
    "#     ------\n",
    "#     I: interactions matrix\n",
    "#     X: floor plan matrix\n",
    "#     T: distance matrix\n",
    "#     teamSizeVector: team size file\n",
    "#     floorCapVector: floor capacity file\n",
    "#     K: number of teams\n",
    "#     N: number of floors\n",
    "#     changeIdx: for interactive mode - delta of user changes - what user changes\n",
    "#     in interaction mode\n",
    "#     relConstraints: additional constraints that a user adds (boolean) \n",
    "#     teamIdMap: when user uploads the file for the first time, it sorts the file and maps it to an id\n",
    "#     dcDF: relative constraints input from user for distance constraints\n",
    "    \n",
    "#     returns:\n",
    "#     ------\n",
    "#     X: floor plan - matrix \n",
    "#     success: boolean\n",
    "#     count: \n",
    "#     txx: loss function to minmize\n",
    "#     \"\"\"\n",
    "#     print(\"This is FW Optimizer with the new Condition as per Aaron Sept 28 ...\")\n",
    "#     #initialize linear search\n",
    "#     try:\n",
    "#         eps = 0.001\n",
    "#         frobeniusNorm = eps+1\n",
    "#         count = 0\n",
    "#         gamma = 1.0 / (count + 2)\n",
    "#         debug = False\n",
    "#         pacifier = True\n",
    "#         verbose = False # turn on for debuging\n",
    "#         success = False\n",
    "#         initX = X\n",
    "#         while(frobeniusNorm > eps):\n",
    "#             ############################################################################################\n",
    "#             ## Data for Linear Program (formerly LpSove)\n",
    "#             ############################################################################################\n",
    "#             #Objective function. Min linear G(Xk)* Y \n",
    "#             def getGradient(I, X, T):\n",
    "#               \"\"\"\n",
    "\n",
    "#               \"\"\"\n",
    "#               return I @ X @ T + I.T @ X @ T.T \n",
    "      \n",
    "#             Gmat= getGradient(I, X, T)\n",
    "#             G =  np.array(Gmat.T).ravel()\n",
    "#             #Constraint 1. Allocate All team members i.e. sum of team = 100% of team size (acroos all floors)\n",
    "#             teamIdxPerFloor = []\n",
    "#             for start_i in range(K):\n",
    "#                 temp_i = [K*j+start_i for j in range(N)]\n",
    "#                 teamIdxPerFloor.append(temp_i)\n",
    "#             #Constraint 2. All variables >= 0\n",
    "#             # x_i allocation >= 0 (see linear program below) \n",
    "#             #Constraint 3. Floor <= floor capacity\n",
    "#             floorIdxAllTeams = []\n",
    "#             for j in range(0,N*K,K):\n",
    "#                 temp_j = [j + i for i in range(K)]\n",
    "#                 floorIdxAllTeams.append(temp_j)\n",
    "#             #Constraint 4. Interactive \n",
    "#             #   changeIdxs = whereChangeFlat(X1,X2, K, N)  #Calculated in driver program\n",
    "#             if(debug):    \n",
    "#                 print(\" G(Xk) : \" , G)\n",
    "#                 print(\"Constraint1.X.indexes: \", teamIdxPerFloor)\n",
    "#                 print(\"Constraint3.X.indexes: \", floorIdxAllTeams)\n",
    "#             ############################################################################################\n",
    "#             ## Linear Program \n",
    "#             ############################################################################################\n",
    "#             #Define problem\n",
    "#             prob = pulp.LpProblem(\"FW line search\", pulp.LpMinimize )\n",
    "#             #Define variables\n",
    "#             var_idxs = list(range(N*K))\n",
    "#             S = pulp.LpVariable.dict(\"x_\", var_idxs, lowBound=0, upBound = 1)\n",
    "#             #check_idxs(X, var_idxs)\n",
    "#             #Define objective Function.\n",
    "#             prob += sum([G[i] * S[i] for i in range(K*N)])\n",
    "#             #Constraint 1. Allocate all teams\n",
    "#             for i in range(K):\n",
    "#                 prob += sum([S[j] for j in teamIdxPerFloor[i]]) == 1\n",
    "#             #Constraint 2. All variables >= 0\n",
    "#             for x_i in range(K*N):\n",
    "#                 prob += S[x_i] >= 0\n",
    "                \n",
    "#             #Constraint 3. floor <= floor capacity\n",
    "#             teamSize = np.tile(teamSizeVector,N)\n",
    "#             for j in range(N):\n",
    "#                  prob +=sum([teamSize[i] * S[i] for i in floorIdxAllTeams[j]])<= floorCapVector[j]\n",
    "                    \n",
    "#             ###########################################################################\n",
    "#             ####                    Here are the changes for the new condition\n",
    "#             ####                    left many print statements so easier to debug and fine tune in jupyter\n",
    "#             ####                    those should be removed for last version\n",
    "#             ###########################################################################                    \n",
    "            \n",
    "#             #Constraint 3B. For variable workspaces \n",
    "#             print(\"constraint 3B...\")\n",
    "#             print(variableWorkSpaces, numSeatTypes, teamSizeVectorOffices )\n",
    "#             isVariableWSpaces = (variableWorkSpaces and numSeatTypes > 1)\n",
    "#             print(\"isVariableWSpaces\", isVariableWSpaces)\n",
    "#             if(isVariableWSpaces):\n",
    "#                 teamSize1 = np.tile(teamSizeVector,N)       #total number of seats requested\n",
    "#                 teamSize2 = np.tile(teamSizeVectorOffices,N)  #number of office seats requested\n",
    "#                 print(\"teamSize1.shape\", teamSize1.shape)\n",
    "#                 print(teamSize1)\n",
    "#                 print(\"teamSize2.shape\", teamSize2.shape)\n",
    "#                 print(teamSize2)\n",
    "#                 for j in range(int(N/numSeatTypes)):\n",
    "#                     #print(f'Offices: {floorIdxAllTeams[j]}')\n",
    "#                     #print(f'Offices: {[teamSize2[i] * S[i] for i in floorIdxAllTeams[j]]}')\n",
    "#                     prob +=sum([teamSize2[i] * S[i] for i in floorIdxAllTeams[j]])<= floorCapVector[j]\n",
    "#             print(\"so far so good...\")\n",
    "#             #Constraint 4. Interactive\n",
    "#             if (changeIdx is not None and len(changeIdx) > 0):\n",
    "#                 flatX = np.asarray(X).T.ravel()\n",
    "#                 for i in changeIdx:\n",
    "#                     prob += S[i] == flatX[i]\n",
    "#             if(debug):\n",
    "#                 print(\"  lpVariable.dict: \",  S)\n",
    "#                 print(\"  lpProblem...\",prob)\n",
    "#             #Constraint 5. Relative Constraint\n",
    "#             isRelCons = (relConstraints and (teamIdMap is not None))\n",
    "#             if(isRelCons):\n",
    "#                 prob = addRelConstraintDistanceAvg2Avg(dcDF, T, S, teamIdMap, teamIdxPerFloor, prob)\n",
    "#                 print(\"LpProb after adding constraints...\")\n",
    "#                 print(prob)\n",
    "#             ############################################################################################\n",
    "#             ## Lp Solve & Wrap up results\n",
    "#             ############################################################################################\n",
    "#             print(\"Solving... \")\n",
    "#             prob.solve()\n",
    "#             print(\"Status:\", pulp.LpStatus[prob.status])\n",
    "#             Xid = { str(v) : k for k,v in S.items()}\n",
    "#             SoptVector = np.zeros(K*N)\n",
    "#             for v in prob.variables():\n",
    "#                 #print(Xid[v.name], v.name, \"=\", v.varValue )\n",
    "#                 SoptVector[int(Xid[v.name])] = v.varValue\n",
    "#             Sopt = np.matrix(SoptVector.reshape(N,K).T)\n",
    "#             if(debug):\n",
    "#                 print(\"result: \", type(Sopt), np.round(Sopt,2))\n",
    "\n",
    "#             ########################################################################################\n",
    "#             ### Relative Constraints - Raw Output from Optimizer (for User Testing and Wire-framing)\n",
    "#             #########################################################################################\n",
    "#             #TO DO. Add addtional relative constraint test cases\n",
    "#             if(isRelCons and pulp.LpStatus[prob.status] == 'Optimal'):\n",
    "#                 success = True\n",
    "#                 return Sopt, success, count\n",
    "\n",
    "#             ############################################################################################\n",
    "#             ## Optimize step size (gamma)\n",
    "#             ############################################################################################\n",
    "#             #plugin line search result (1-gamma) Y - gamma X into objective function\n",
    "#             Y = Sopt\n",
    "#             tXX = np.trace(T @ X.T @ I @ X)\n",
    "#             print(f'X: {X}')\n",
    "#             print(f'tXX: {tXX}')\n",
    "#             tXY = np.trace(T @ X.T @ I @ Y) + np.trace(T @ Y.T @ I @ X)   \n",
    "#             tYY = np.trace(T @ Y.T @ I @ Y)\n",
    "#             a1 = tXX-tXY+tYY # gradient - how big of a jump to take\n",
    "#             b1 = tXY-2*tXX\n",
    "#             c1 = tXX\n",
    "#             #solve for gamma and optimize inside region of interest\n",
    "#             if(a1 > 0):\n",
    "#                 #find minimum of quadratic a1*gamma^2 + b1*gamma + c1\n",
    "#                 z = (-1*b1)/ (2*a1)    \n",
    "#                 #by definition gamma [0,1] (gamma is weighted average of line between X and Y points in solution space)\n",
    "#                 if (z>1): gamma = 1\n",
    "#                 elif (z<0): gamma = 3/(K+2)\n",
    "#                 else: gamma = z\n",
    "#             if(a1<0):\n",
    "#                 #find maximum of quadratic a1*gamma^2 + b1*gamma + c1 \n",
    "#                 z = (-1*b1)/ (2*a1)\n",
    "#                 #by definition gamma [0,1] \n",
    "#                 if(z>=1): gamma = 3/(K+2)       # follow inverse direction of steepest descent\n",
    "#                 elif(z<0): gamma = 1\n",
    "#                 else:                     # inside polygon of valid solution\n",
    "#                     if((a1+b1)> 0): gamma = 3/(K+2)\n",
    "#                     else: gamma = 1\n",
    "#             if (a1==0):     \n",
    "#                 #find minimum of linear b1*gamma  + c1 sbt [0,1] region\n",
    "#                 if (b1 >=0): gamma = 3/(K+2)\n",
    "#                 else: gamma = 1\n",
    "            \n",
    "\n",
    "#             #update Xkplus1\n",
    "#             Xk = X\n",
    "#             X = Xk + gamma * (Y -Xk)\n",
    "            \n",
    "# #             diff_matrix = X.sum(axis=1) - [1]\n",
    "# #             requested_penalty = np.sum([x**2 for x in np.array(diff_matrix).flatten()]).round(5)\n",
    "# #             requested_penalty\n",
    "\n",
    "#             if(debug):\n",
    "#                 print(\"tXX :\", round(tXX,4)) # what we're trying to minmize (a1)\n",
    "#                 print(\"tXY :\", round(tXY,4))\n",
    "#                 print(\"tYY :\", round(tYY,4))\n",
    "#                 print(\"a1  : \", round(a1,2))\n",
    "#                 print(\"b1  : \", round(b1,2))\n",
    "#                 print(\"c1  : \", round(c1,2))\n",
    "#                 print(\"z   : \",  (-1*b1)/ (2*a1))\n",
    "#                 print(\"gamma: \", gamma)\n",
    "#             ############################################################################################\n",
    "#             ## Stop criteria\n",
    "#             ############################################################################################\n",
    "#             frobeniusNorm = np.linalg.norm(X-Xk, 'fro')\n",
    "#             count+=1\n",
    "#             #emergency break in case not converging\n",
    "#             #usualy converge after 15 iterations\n",
    "#             if (count>1000):\n",
    "#                 print(\"more than 1000 iterations... cannot converge\")\n",
    "#                 break\n",
    "#             if(pacifier):\n",
    "#                 print(\"lp iteration: \" + str(count) + \" fNorm : \" + str(round(frobeniusNorm,6)))\n",
    "#         if(verbose):\n",
    "#                 print(\"Initial placement... X0\")\n",
    "#                 print(initX)\n",
    "#                 print(\"FW Optimal placement... X\")\n",
    "#                 print(X)\n",
    "#                 print(\"Last Lp placement... Y\")\n",
    "#                 print(Y)\n",
    "#         if (frobeniusNorm <= eps):\n",
    "#             success = True\n",
    "#             return X, success, count, tXX\n",
    "#         else:\n",
    "#             success = False\n",
    "#             return X, success, count, tXX\n",
    "#     except:\n",
    "#         return {\"error\":\"error within FwOptimizer\"}\n",
    "    \n",
    "display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+2)'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#################################################################################################\n",
    "########## algoFrankWolfe has three new parameters - they are not used in first run ####\n",
    "########## variableWorkSpaces = False, numSeatTypes = 1, teamSizeVectorOffices = tuple()   ######\n",
    "#################################################################################################\n",
    "\n",
    "\n",
    "#############################################################\n",
    "# Optimization algorithm - entry point or \"driver\"\n",
    "#############################################################\n",
    "# def algoFrankWolfe(numTries=1, preSetupTeamAllocation = list(), rawCsvs = dict(), runFWOptimizer = True, changeIdx = None, \n",
    "#                    isRerun = False, officeFloorCapacityFileFormat = True, \n",
    "#                    officeOutput = False,  reDistAdjSeats = False, scaleUnits = False, \n",
    "#                    relConstraints = False, fpRank = True, relConstraintsForm = False, runScipyTrOptimizer = False, X0HeurOpt = 2, \n",
    "#                    randomSeed=8, variableWorkSpaces=False, numSeatTypes=1, teamSizeVectorOffices = tuple()):\n",
    "#     \"\"\"\n",
    "\n",
    "#     inputs:\n",
    "#     ------\n",
    "#     is_rerun: if True then interactive mode; otherwise standard\n",
    "#     \"\"\"\n",
    "#     #select initial placement\n",
    "#     X0HeuristicsOptions = { 0 : \"Azt Classic - WPA Data\", 2: \"Stacker Tool - Uniform\", 3:  \"Azt New - Larger  v1\" }\n",
    "#     if(X0HeurOpt not in X0HeuristicsOptions):\n",
    "#         print(\"ERROR: \" + str(X0HeurOpt) + \" Not a valid Heuristics option\")\n",
    "#         print(\"Please select one of the following Heuristics for initial placement: \", X0HeuristicsOptions)\n",
    "#     else:\n",
    "#         print(\"Using X0Heuristics for initial placement: \", X0HeuristicsOptions[X0HeurOpt])\n",
    "#     X0Heuristics = X0HeuristicsOptions[X0HeurOpt]\n",
    "    \n",
    "    \n",
    "#     tables = dict()\n",
    "    \n",
    "#     rawI = rawCsv[\"interaction\"]\n",
    "#     rawT = rawCsv[\"distance\"]\n",
    "#     rawfloorCapacity = rawCsv[\"space_capacity\"]\n",
    "#     sRawTS = rawCsv[\"team_size\"]\n",
    "    #originalFloorPlan = rawCsvs[\"floorPlan_original\"]\n",
    "    #modifiedFloorPlan = rawCsvs[\"floorPlan_modified\"]\n",
    "#     # getChangeVectors if not Standard\n",
    "# #     if isRerun:\n",
    "# #         preSetupTeamAllocation, changeIdx = getChangeVectors(originalFloorPlan, modifiedFloorPlan)\n",
    "\n",
    "\n",
    "#     #scale units\n",
    "#     if(scaleUnits == True):\n",
    "#         zRawT, minMaxRangeT, minT  = minMaxScaler(rawT)\n",
    "#         print(f'Scaler on: {minMaxRangeT, minT}')\n",
    "#         print('')\n",
    "#         #print(zRawT)\n",
    "#         zRawI, minMaxRangeI, minI  = minMaxScaler(rawI)\n",
    "#         print(f'Scaler on: {minMaxRangeI, minI}')\n",
    "#         print('')\n",
    "#         #print(zRawI)\n",
    "#     else:\n",
    "#         zRawT, minMaxRangeT, minT = rawT, 1,0\n",
    "#         print('Scaler off')\n",
    "#         #print(zRawT)\n",
    "#         print('')\n",
    "#         zRawI, minMaxRangeI, minI = rawI, 1,0\n",
    "#         #print(zRawI)\n",
    "\n",
    "#     # Parse relative constraints file\n",
    "#     isRelCons = ((relConstraints or relConstraintsForm) and (rawCon is not None))\n",
    "#     if(isRelCons):      \n",
    "#         runScipyTrOptimizer = True\n",
    "#         rawDcDF, rawIcDF = parseConstraints(rawCon,sRawTS)\n",
    "#         print(rawDcDF)\n",
    "#         dcDF, icDF = preCheckRelConsInput(rawDcDF, rawIcDF)\n",
    "#     else:\n",
    "#         runScipyTrOptimizer = False\n",
    "#         dcDF, icDF = None,None\n",
    "\n",
    "#     #Team id is a consecutive ID number for identifying teams in the Team Size File (In general, NOT the same number as LP variable dict(x) X_i variable index )\n",
    "#     teamsIds = getTeamIdsDF(sRawTS)\n",
    "#     teamIdMap = dict(teamsIds.to_dict(orient = 'split')['data'])\n",
    "#     teamLabels = dict([ [id, team] for team, id in teamsIds.to_dict(orient = 'split')['data']])\n",
    "#     #floor id...\n",
    "#     floorIds = getFloorIdsDF(floorsDF)\n",
    "#     floorIdMap = dict(floorIds.to_dict(orient = 'split')['data'])\n",
    "#     floorLabels = dict([ [id, floor] for floor, id in floorIds.to_dict(orient = 'split')['data']])\n",
    "#     #TO DO... validating team names and team IDs might be something we want to move to general validating routine (i.e. names and IDs need to match across all files, currently assuming sorting names is enough)\n",
    "\n",
    "\n",
    "#     #fill \"tables\" for callback\n",
    "#     tables['teamCollaboration'] = sRawI\n",
    "#     tables['locationDistance'] = sRawT\n",
    "#     tables['locationCapacity'] = rawfloorCapacity\n",
    "#     tables['teamSize'] = sRawTS\n",
    "\n",
    "#     #get floor names\n",
    "#     floorNames = getFloorNamesDF(floorsDF)\n",
    "#     floorColumns = np.delete(zRawT.columns, [0])\n",
    "    \n",
    "#     # As a reminder: Distance measured in time units.T[i,j] time to get between floors i and j\n",
    "#     T = np.asmatrix(zRawT.iloc[0:, 1:])      \n",
    "#     #N - number of floors\n",
    "#     N = T.shape[0]\n",
    "\n",
    "#     if not validateFloors(floorNames, floorColumns, N):\n",
    "#         error_log = \"Floor columns dont match: Check floor capacity vs distance files\"\n",
    "#         return None, None, None, error_log\n",
    "\n",
    "#     #get teams names\n",
    "#     teamNames = getTeamNamesDF(sRawTS)\n",
    "#     rowNames = teamNames\n",
    "#     teamRowsIdx = np.delete(zRawI.columns, [0])\n",
    "    \n",
    "#     I = np.asmatrix(zRawI.iloc[0:, 1:])\n",
    "#     #K - number of teams\n",
    "#     K = I.shape[0]\n",
    "#     validNumTeams =  validateTeams(teamNames, teamRowsIdx, K)\n",
    "#     if not validNumTeams:\n",
    "#         error_log = \"Team columns dont match: Check team size vs Interactions files\"\n",
    "#         return None, None, None, error_log\n",
    "#         #print(\"Team columns dont match: Check team size vs Interactions files\")\n",
    "#         #0/0\n",
    "\n",
    "#     if(reDistAdjSeats):\n",
    "#         if(validAdjFile(rawTS)):\n",
    "#             print(\"Reading Adj seats columns...\")\n",
    "#             print(\"Adj Seats Flag: \", reDistAdjSeats )\n",
    "#             #load adjacency constraints \n",
    "#             adjTable, teamSizeDF, adjTeamsDF, adjTeamsList = splitAdjConstraints(sRawTS) \n",
    "#             adjSeatsDF = addAdjSeats(teamSizeDF, adjTable)\n",
    "#             teamSizeFree = tuple(adjSeatsDF[\"free\"])\n",
    "\n",
    "#             #display adjusted seats (just informative)\n",
    "#             adjVsAct = adjSeatsDF[list(set(adjSeatsDF.columns) - set(adjSeatsDF.columns[0:3]))].copy()\n",
    "#             adjVsAct = adjVsAct.astype(int)\n",
    "#             print(adjVsAct)\n",
    "#         else:\n",
    "#             #if user selects the flag but no valid columns available\n",
    "#             # reverting back \n",
    "#             print(\"Adj seats columns not available...\")\n",
    "#             reDistAdjSeats = False\n",
    "#             print(\"Adj Seats Flag : \", reDistAdjSeats )\n",
    "#             idxTeamSizeCol = 1\n",
    "#             idxTeamNamesCol = 0\n",
    "#             adjSeatsDF = sRawTS.iloc[:,idxTeamSizeCol:]\n",
    "#             adjSeatsDF.index = sRawTS.iloc[:,idxTeamNamesCol]\n",
    "#     else:\n",
    "#         # Making Team Size read from FIRST column\n",
    "#         idxTeamSizeCol = 1\n",
    "#         idxTeamNamesCol = 0\n",
    "#         adjSeatsDF = sRawTS.iloc[:,idxTeamSizeCol:]\n",
    "#         adjSeatsDF.index = sRawTS.iloc[:,idxTeamNamesCol]\n",
    "\n",
    "#     #capacity and team size to numpy array\n",
    "#     floorCapVector = floorsDF[floorsDF.columns[1]].values\n",
    "#     teamSizeVector = getTeamSizeVector2(adjSeatsDF)\n",
    "#     c = floorCapVector\n",
    "#     s = np.array(teamSizeVector)\n",
    "#     print(f'Seats requested: {s}')\n",
    "\n",
    "#     #some parameters\n",
    "#     iterFloor = 0         #current floor \n",
    "#     count11 = 1\n",
    "#     print('')\n",
    "#     smallestObjFun = 1e+29\n",
    "#     random.seed(randomSeed)  \n",
    "# #     np.random.seed(randomSeed)\n",
    "    \n",
    "   \n",
    "\n",
    "#     ### running placement\n",
    "#     for iters in range(numTries):\n",
    "#         iters = iters + 1\n",
    "#         print(\"iteration... \", iters)\n",
    "\n",
    "#         if (iters <= (N*K)):\n",
    "#             iterTeam = iters % K       # current team. i.e. teams index for this iteration\n",
    "#             flag = iters % K           # flag to indicate when all teams have been processed. \n",
    "         \n",
    "#             if (iterTeam == 0): # Line 161 in App.R\n",
    "#                 # initial placement\n",
    "#                 iterTeam = K\n",
    " \n",
    "#             try: \n",
    "#                 if X0Heuristics == X0HeuristicsOptions[0]:\n",
    "#                     X0 = pd.DataFrame(arrangeTeams(iterFloor, iterTeam, I, T, floorCapVector, teamSizeVector, False, preSetupTeamAllocation ))\n",
    "#                     print('Heuristic 0')\n",
    "#                 elif X0Heuristics == X0HeuristicsOptions[2]:\n",
    "#                     print('Heuristic 2')\n",
    "#                     # first seed will use the basic team placement\n",
    "#                     if randomSeed == 0:\n",
    "#                         flatX0 = True\n",
    "#                     # the rest will be random\n",
    "#                     else:\n",
    "#                         flatX0 = False\n",
    "#                     X0 = pd.DataFrame(arrangeTeams2(iterFloor, iterTeam, I, T, K, N, floorCapVector, teamSizeVector, False, preSetupTeamAllocation, useTeamRatio = False, flatX0 = flatX0 ))\n",
    "      \n",
    "#                 # running FW algo to produce Space Planning Matrix\n",
    "#                 teamSizeMat = np.repeat(teamSizeVector,N).reshape(K,N)\n",
    "#                 tempRawX0 = X0\n",
    "#                 X0 = np.round(tempRawX0 / teamSizeMat,4)\n",
    "#                 X = np.asmatrix(X0.values)\n",
    "\n",
    "\n",
    "#                 Xopt, FWoptStatus, FWOptCount, tXX = FwOptimizer2(I,X,T,teamSizeVector, floorCapVector, K, N, changeIdx, \n",
    "#                                                                   relConstraints = relConstraints, teamIdMap = teamIdMap, dcDF = dcDF, \n",
    "#                                                                   variableWorkSpaces=variableWorkSpaces, numSeatTypes=numSeatTypes, \n",
    "#                                                                   teamSizeVectorOffices = teamSizeVectorOffices)\n",
    "                  \n",
    "\n",
    "#                 XoptDF = pd.DataFrame(np.round(np.multiply(Xopt, teamSizeMat)))\n",
    "#                 if XoptDF.shape[1] == floorColumns.size:\n",
    "#                     XoptDF.columns = floorColumns\n",
    "#                     XoptDF.index = list(rowNames[\"Team\"].values)\n",
    "#                     XoptDF.columns = XoptDF.columns.str.replace(',',' -')\n",
    "#                     if (reDistAdjSeats):\n",
    "#                         newFP = reDistributeAdjSeats(XoptDF, adjTeamsDF, adjTeamsList)\n",
    "#                     else:\n",
    "#                         newFP = XoptDF\n",
    "#                     if (officeOutput):\n",
    "#                         Xoutput, floorsDF2 = splitByOfficeWorkCapacity(newFP, floorsDF)\n",
    "#                     else:\n",
    "#                         Xoutput = newFP\n",
    "\n",
    "#                     tables['floorPlan'] = Xoutput.to_dict(orient='dict')\n",
    "#                     tables['teamCollaboration'] = tables['teamCollaboration'].set_index(tables['teamCollaboration'].columns[0]).to_dict(orient='dict')\n",
    "#                     tables['locationDistance'] = tables['locationDistance'].set_index(tables['locationDistance'].columns[0]).to_dict(orient='dict')\n",
    "#                     tables['locationCapacity'] = tables['locationCapacity'].set_index(tables['locationCapacity'].columns[0]).to_dict(orient='dict')\n",
    "#                     tables['teamSize'] = tables['teamSize'].set_index(tables['teamSize'].columns[0]).to_dict(orient='dict')\n",
    "#                     #print(FWoptStatus, FWOptCount, tXX)\n",
    "#                 return tables, FWoptStatus, FWOptCount, tXX\n",
    "#             except Exception as e:\n",
    "#                 print(e)\n",
    "#                 print(\"error generating the floorplan\")\n",
    "\n",
    "def algoFrankWolfe(numTries=1, preSetupTeamAllocation = list(), rawCsvs = dict(), runFWOptimizer = True, changeIdx = None, isRerun = False, officeFloorCapacityFileFormat = True, officeOutput = False,  reDistAdjSeats = False, scaleUnits = False, relConstraints = False, fpRank = True, relConstraintsForm = False, runScipyTrOptimizer = False, X0HeurOpt = 2, randomSeed=8):\n",
    "    \"\"\"\n",
    "\n",
    "    inputs:\n",
    "    ------\n",
    "    is_rerun: if True then interactive mode; otherwise standard\n",
    "    \"\"\"\n",
    "    #select initial placement\n",
    "    X0HeuristicsOptions = { 0 : \"Azt Classic - WPA Data\", 2: \"Stacker Tool - Uniform\", 3:  \"Azt New - Larger  v1\" }\n",
    "    if(X0HeurOpt not in X0HeuristicsOptions):\n",
    "        print(\"ERROR: \" + str(X0HeurOpt) + \" Not a valid Heuristics option\")\n",
    "        print(\"Please select one of the following Heuristics for initial placement: \", X0HeuristicsOptions)\n",
    "    else:\n",
    "        print(\"Using X0Heuristics for initial placement: \", X0HeuristicsOptions[X0HeurOpt])\n",
    "    X0Heuristics = X0HeuristicsOptions[X0HeurOpt]\n",
    "    \n",
    "    \n",
    "    tables = dict()\n",
    "    \n",
    "    rawI = rawCsvs[\"interaction\"]\n",
    "    rawT = rawCsvs[\"distance\"]\n",
    "    rawfloorCapacity = rawCsvs[\"space_capacity\"]\n",
    "    sRawTS = rawCsvs[\"team_size\"]\n",
    "    originalFloorPlan = rawCsvs[\"floorPlan_original\"]\n",
    "    modifiedFloorPlan = rawCsvs[\"floorPlan_modified\"]\n",
    "    # getChangeVectors if not Standard\n",
    "    if isRerun:\n",
    "      preSetupTeamAllocation, changeIdx = getChangeVectors(originalFloorPlan, modifiedFloorPlan)\n",
    "\n",
    "\n",
    "    #scale units\n",
    "    if(scaleUnits == True):\n",
    "        zRawT, minMaxRangeT, minT  = minMaxScaler(rawT)\n",
    "        zRawI, minMaxRangeI, minI  = minMaxScaler(rawI)\n",
    "    else:\n",
    "        zRawT, minMaxRangeT, minT = rawT, 1,0\n",
    "        zRawI, minMaxRangeI, minI = rawI, 1,0\n",
    "\n",
    "    # Parse relative constraints file\n",
    "    isRelCons = ((relConstraints or relConstraintsForm) and (rawCon is not None))\n",
    "    if(isRelCons):      \n",
    "        runScipyTrOptimizer = True\n",
    "        rawDcDF, rawIcDF = parseConstraints(rawCon,sRawTS)\n",
    "        print(rawDcDF)\n",
    "        dcDF, icDF = preCheckRelConsInput(rawDcDF, rawIcDF)\n",
    "    else:\n",
    "        runScipyTrOptimizer = False\n",
    "        dcDF, icDF = None,None\n",
    "\n",
    "    #Team id is a consecutive ID number for identifying teams in the Team Size File (In general, NOT the same number as LP variable dict(x) X_i variable index )\n",
    "    teamsIds = getTeamIdsDF(sRawTS)\n",
    "    teamIdMap = dict(teamsIds.to_dict(orient = 'split')['data'])\n",
    "    teamLabels = dict([ [id, team] for team, id in teamsIds.to_dict(orient = 'split')['data']])\n",
    "    #floor id...\n",
    "    floorIds = getFloorIdsDF(floorsDF)\n",
    "    floorIdMap = dict(floorIds.to_dict(orient = 'split')['data'])\n",
    "    floorLabels = dict([ [id, floor] for floor, id in floorIds.to_dict(orient = 'split')['data']])\n",
    "    #TO DO... validating team names and team IDs might be something we want to move to general validating routine (i.e. names and IDs need to match across all files, currently assuming sorting names is enough)\n",
    "\n",
    "\n",
    "    #fill \"tables\" for callback\n",
    "    tables['teamCollaboration'] = sRawI\n",
    "    tables['locationDistance'] = sRawT\n",
    "    tables['locationCapacity'] = rawfloorCapacity\n",
    "    tables['teamSize'] = sRawTS\n",
    "\n",
    "    #get floor names\n",
    "    floorNames = getFloorNamesDF(floorsDF)\n",
    "    floorColumns = np.delete(zRawT.columns, [0])\n",
    "    \n",
    "    # As a reminder: Distance measured in time units.T[i,j] time to get between floors i and j\n",
    "    T = np.asmatrix(zRawT.iloc[0:, 1:])      \n",
    "    #N - number of floors\n",
    "    N = T.shape[0]\n",
    "\n",
    "    if not validateFloors(floorNames, floorColumns, N):\n",
    "        error_log = \"Floor columns dont match: Check floor capacity vs distance files\"\n",
    "        print(error_log)\n",
    "        return None, None, None, error_log\n",
    "\n",
    "\n",
    "    #get teams names\n",
    "    teamNames = getTeamNamesDF(sRawTS)\n",
    "    rowNames = teamNames\n",
    "    teamRowsIdx = np.delete(zRawI.columns, [0])\n",
    "    \n",
    "    I = np.asmatrix(zRawI.iloc[0:, 1:])\n",
    "    #K - number of teams\n",
    "    K = I.shape[0]\n",
    "    validNumTeams =  validateTeams(teamNames, teamRowsIdx, K)\n",
    "    if not validNumTeams:\n",
    "        error_log = \"Team columns dont match: Check team size vs Interactions files\"\n",
    "        print(error_log)\n",
    "        return None, None, None, error_log\n",
    "\n",
    "    if(reDistAdjSeats):\n",
    "        if(validAdjFile(rawTS)):\n",
    "            print(\"Reading Adj seats columns...\")\n",
    "            print(\"Adj Seats Flag: \", reDistAdjSeats )\n",
    "            #load adjacency constraints \n",
    "            adjTable, teamSizeDF, adjTeamsDF, adjTeamsList = splitAdjConstraints(sRawTS) \n",
    "            adjSeatsDF = addAdjSeats(teamSizeDF, adjTable)\n",
    "            teamSizeFree = tuple(adjSeatsDF[\"free\"])\n",
    "\n",
    "            #display adjusted seats (just informative)\n",
    "            adjVsAct = adjSeatsDF[list(set(adjSeatsDF.columns) - set(adjSeatsDF.columns[0:3]))].copy()\n",
    "            adjVsAct = adjVsAct.astype(int)\n",
    "            print(adjVsAct)\n",
    "        else:\n",
    "            #if user selects the flag but no valid columns available\n",
    "            # reverting back \n",
    "            print(\"Adj seats columns not available...\")\n",
    "            reDistAdjSeats = False\n",
    "            print(\"Adj Seats Flag : \", reDistAdjSeats )\n",
    "            idxTeamSizeCol = 1\n",
    "            idxTeamNamesCol = 0\n",
    "            adjSeatsDF = sRawTS.iloc[:,idxTeamSizeCol:]\n",
    "            adjSeatsDF.index = sRawTS.iloc[:,idxTeamNamesCol]\n",
    "    else:\n",
    "        # Making Team Size read from FIRST column\n",
    "        idxTeamSizeCol = 1\n",
    "        idxTeamNamesCol = 0\n",
    "        adjSeatsDF = sRawTS.iloc[:,idxTeamSizeCol:]\n",
    "        adjSeatsDF.index = sRawTS.iloc[:,idxTeamNamesCol]\n",
    "\n",
    "    #capacity and team size to numpy array\n",
    "    floorCapVector = floorsDF[floorsDF.columns[1]].values\n",
    "    teamSizeVector = getTeamSizeVector2(adjSeatsDF)\n",
    "    c = floorCapVector\n",
    "    s = np.array(teamSizeVector)\n",
    "\n",
    "    #some parameters\n",
    "    iterFloor = 0         #current floor \n",
    "    count11 = 1\n",
    "    print('')\n",
    "    smallestObjFun = 1e+29\n",
    "    random.seed(randomSeed)  \n",
    "#     np.random.seed(randomSeed)\n",
    "    \n",
    "   \n",
    "\n",
    "    ### running placement\n",
    "    for iters in range(numTries):\n",
    "        iters = iters + 1\n",
    "        print(\"iteration... \", iters)\n",
    "\n",
    "        if (iters <= (N*K)):\n",
    "            iterTeam = iters % K       # current team. i.e. teams index for this iteration\n",
    "            flag = iters % K           # flag to indicate when all teams have been processed. \n",
    "         \n",
    "            if (iterTeam == 0): # Line 161 in App.R\n",
    "                # initial placement\n",
    "                iterTeam = K\n",
    " \n",
    "            try: \n",
    "                if X0Heuristics == X0HeuristicsOptions[0]:\n",
    "                    X0 = pd.DataFrame(arrangeTeams(iterFloor, iterTeam, I, T, floorCapVector, teamSizeVector, False, preSetupTeamAllocation ))\n",
    "                    print('Heuristic 0')\n",
    "                elif X0Heuristics == X0HeuristicsOptions[2]:\n",
    "                    print('Heuristic 2')\n",
    "                    # first seed will use the basic team placement\n",
    "                    if randomSeed == 0:\n",
    "                      flatX0 = True\n",
    "                    # the rest will be random\n",
    "                    else:\n",
    "                      flatX0 = False\n",
    "                    X0 = pd.DataFrame(arrangeTeams2(iterFloor, iterTeam, I, T, K, N, floorCapVector, teamSizeVector, False, preSetupTeamAllocation, useTeamRatio = False, flatX0 = flatX0 ))\n",
    "      \n",
    "                # running FW algo to produce Space Planning Matrix\n",
    "                teamSizeMat = np.repeat(teamSizeVector,N).reshape(K,N)\n",
    "                tempRawX0 = X0\n",
    "                X0 = np.round(tempRawX0 / teamSizeMat,4)\n",
    "                X = np.asmatrix(X0.values)\n",
    "                \n",
    "                Xopt, FWoptStatus, FWOptCount, tXX = FwOptimizer2(I,X,T,teamSizeVector, floorCapVector, K, N, changeIdx, relConstraints = relConstraints, teamIdMap = teamIdMap, dcDF = dcDF)\n",
    "               \n",
    "                print(Xopt)\n",
    "#                 Xopt = np.asarray(Xopt, dtype= 'float64')\n",
    "                XoptDF = pd.DataFrame(np.round(np.multiply(Xopt, teamSizeMat)))\n",
    "                if XoptDF.shape[1] == floorColumns.size:\n",
    "                    XoptDF.columns = floorColumns\n",
    "                    XoptDF.index = list(rowNames[\"Team\"].values)\n",
    "                    XoptDF.columns = XoptDF.columns.str.replace(',',' -')\n",
    "                    if (reDistAdjSeats):\n",
    "                        newFP = reDistributeAdjSeats(XoptDF, adjTeamsDF, adjTeamsList)\n",
    "                    else:\n",
    "                        newFP = XoptDF\n",
    "                    if (officeOutput):\n",
    "                        Xoutput, floorsDF2 = splitByOfficeWorkCapacity(newFP, floorsDF)\n",
    "                    else:\n",
    "                        Xoutput = newFP\n",
    "\n",
    "                    tables['floorPlan'] = Xoutput.to_dict(orient='dict')\n",
    "                    tables['teamCollaboration'] = tables['teamCollaboration'].set_index(tables['teamCollaboration'].columns[0]).to_dict(orient='dict')\n",
    "                    tables['locationDistance'] = tables['locationDistance'].set_index(tables['locationDistance'].columns[0]).to_dict(orient='dict')\n",
    "                    tables['locationCapacity'] = tables['locationCapacity'].set_index(tables['locationCapacity'].columns[0]).to_dict(orient='dict')\n",
    "                    tables['teamSize'] = tables['teamSize'].set_index(tables['teamSize'].columns[0]).to_dict(orient='dict')\n",
    "                    #print(FWoptStatus, FWOptCount, tXX)\n",
    "                return tables, FWoptStatus, FWOptCount, tXX\n",
    "            except Exception as e:\n",
    "                print(e)\n",
    "                print(\"error generating the floorplan\")\n",
    "\n",
    "display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+2)'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# manually set\n",
    "X0HeurOpt = 2\n",
    "rawCsvs = rawCsv\n",
    "\n",
    "# we run the algorithm 13 times using random seeds to make sure we get the best floor plan\n",
    "np.random.seed(42)\n",
    "randomSeeds = [0, 7, 8, 10, 14, 42] + [np.random.randint(10000) for x in range(7)]\n",
    "\n",
    "\n",
    "#################################################################################################\n",
    "########## Running the algorithm  - can do it for any mode                     ##################\n",
    "#################################################################################################\n",
    "\n",
    "try:\n",
    "    # manually set\n",
    "    X0HeurOpt = 2\n",
    "    # parsed from dcitionary\n",
    "    numTries = mode_params['numTries']\n",
    "    preSetupTeamAllocation = mode_params['preSetupTeamAllocation']\n",
    "    rawCsvs = rawCsv\n",
    "    runFWOptimizer = mode_params['runFWOptimizer']\n",
    "    changeIdx = mode_params['changeIdx']\n",
    "    #flatInteractionBool = mode_params['flatInteractionBool']\n",
    "    isRerun = mode_params['isRerun']\n",
    "    officeFloorCapacityFileFormat = mode_params['officeFloorCapacityFileFormat']\n",
    "    officeOutput = mode_params['officeOutput']\n",
    "    reDistAdjSeats = mode_params['reDistAdjSeats']\n",
    "    scaleUnits = mode_params['scaleUnits']\n",
    "    relConstraints = mode_params['relConstraints']\n",
    "    fpRank = mode_params['fpRank']\n",
    "    relConstraintsForm = mode_params['relConstraintsForm']\n",
    "    runScipyTrOptimizer =  mode_params['runScipyTrOptimizer']\n",
    "    \n",
    "    # RUNNING THE ALGORITHM\n",
    "    np.random.seed(42)\n",
    "    randomSeeds = [0, 7, 8, 10, 14, 42] + [np.random.randint(10000) for x in range(7)]\n",
    "    tables_list = [] # for tracking all floorplans for the 13 rounds\n",
    "    scores = [] # keep track of tXX scores\n",
    "    \n",
    "    for seed in randomSeeds:\n",
    "        tables, FWoptStatus, FWoptCount, tXX = algoFrankWolfe(numTries, preSetupTeamAllocation, rawCsvs, runFWOptimizer, changeIdx, \n",
    "                                                              isRerun, officeFloorCapacityFileFormat, officeOutput,  reDistAdjSeats, scaleUnits, \n",
    "                                                              relConstraints, fpRank, relConstraintsForm, \n",
    "                                                              runScipyTrOptimizer, X0HeurOpt, randomSeed=seed)\n",
    "#         tables, FWoptStatus, FWoptCount, tXX = algoFrankWolfe(numTries, preSetupTeamAllocation, rawCsvs, \n",
    "#                                                               runFWOptimizer, changeIdx, isRerun, officeFloorCapacityFileFormat,\n",
    "#                                                               officeOutput, reDistAdjSeats, scaleUnits, \n",
    "#                                                               relConstraints, fpRank, relConstraintsForm, \n",
    "#                                                               runScipyTrOptimizer, X0HeurOpt, randomSeed=seed,\n",
    "#                                                              variableWorkSpaces=False, numSeatTypes=1, teamSizeVectorOffices = tuple())\n",
    "        tables_list.append(tables)\n",
    "        scores.append(np.round(tXX, 2))\n",
    "  \n",
    "    # choose best table\n",
    "    best_score_indx = np.argmin(scores) # save this seed to history map (so if you run it again you same seed) \n",
    "    best_floor_plan = tables_list[best_score_indx]\n",
    "    print('\\n\\n\\n')\n",
    "    print(f'Status: {FWoptStatus}')\n",
    "    print(scores)\n",
    "    print(f'Best iteration: {best_score_indx}. Best Score: {scores[best_score_indx]}')\n",
    "\n",
    "except Exception as e:\n",
    "    raise ValueError(e)\n",
    "    \n",
    "\n",
    "display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+2)'))\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "savefinsh = '<div class=\"alert alert-block alert-success\"><b> Done: </b> Your ' + '<b>'+out_filename+'</b> file has successfully saved back to a app_results folder inside the location of this Notebook.</div>'\n",
    "\n",
    "\n",
    "if variableSeats:\n",
    "    initalDF = pd.DataFrame(best_floor_plan['floorPlan'])\n",
    "    \n",
    "else:\n",
    "    #####################\n",
    "    ### Save results  ###\n",
    "    #####################\n",
    "    floorplan_df = pd.DataFrame(best_floor_plan['floorPlan'])\n",
    "    floorplan_final_path = os.getcwd() + '\\\\'+ 'app_results'+'\\\\'+out_filename\n",
    "    floorplan_df.to_excel(r''+ floorplan_final_path, sheet_name='Floorplan')\n",
    "    \n",
    "    print(floorplan_final_path)\n",
    "    display(Markdown(savefinsh))\n",
    "    \n",
    "display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+2)'))\n",
    "   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #################################################################################################\n",
    "# ########## Pre-process files again to prepare for Variable Seats  ######################\n",
    "# #################################################################################################\n",
    "\n",
    "# clear_output()\n",
    "\n",
    "# if variableSeats:\n",
    "#     # GET EMPTY FLOOR PLAN\n",
    "#     T = np.asmatrix(sRawT.iloc[0:, 1:]) \n",
    "#     #N - number of floors\n",
    "#     N = T.shape[0]\n",
    "\n",
    "#     I = np.asmatrix(sRawI.iloc[0:, 1:])\n",
    "#     #K - number of teams\n",
    "#     K = I.shape[0]\n",
    "#     originalFloorPlan = np.zeros((K,N))\n",
    "#     print(f'original floor plan (empty) shape: {originalFloorPlan.shape}')\n",
    "\n",
    "#     # TREAT THIS AS MODIFIED - preSetupTeamAllocation will be passe din second go\n",
    "#     Xoutput2 = pd.DataFrame(tables['floorPlan'])\n",
    "#     modifiedFloorPlan = Xoutput2\n",
    "#     preSetupTeamAllocation, changeIdx = getChangeVectors(originalFloorPlan, modifiedFloorPlan)\n",
    "#     changeIdx = []\n",
    "\n",
    "#     ############################################################\n",
    "#     ###### PREPROCESSING AGAIN\n",
    "#     ############################################################\n",
    "\n",
    "#     # CREATE COMBINED FLOORPLAN\n",
    "#     floorNamesSeatType2 = getFloorNamesDF(dummyFloorsDF2)\n",
    "#     floorColumnsSeatType2 = np.delete(dummyT2.columns, [0])\n",
    "\n",
    "#     dummyFloorplanSeatType2 = pd.DataFrame(np.zeros((K,N)))\n",
    "#     dummyFloorplanSeatType2.columns = floorColumnsSeatType2\n",
    "\n",
    "#     Xdummy1 = dummyFloorplanSeatType2\n",
    "#     Xdummy1.index = origTS.iloc[:,0]\n",
    "\n",
    "#     Xdummy2 = Xoutput2.copy()\n",
    "#     Xdummy2.index = origTS.iloc[:,0]\n",
    "\n",
    "#     variableSpacesFloorplan = pd.concat([Xdummy2,Xdummy1], axis = 1)\n",
    "\n",
    "#     # CREATE COMBINED DISTANCE\n",
    "#     #create two copies and concatenate horizontally - for seat Type 1\n",
    "#     seatType1Names  = dummyT1.iloc[:,0]\n",
    "#     tempDummyT2 = dummyT2.copy()\n",
    "#     tempDummyT2.iloc[:,0] = seatType1Names\n",
    "#     dummyT1T2repHorizontal1 = pd.merge(dummyT1,tempDummyT2, left_on =  [dummyT1.columns[0]], right_on =  [tempDummyT2.columns[0]])\n",
    "#     #print(dummyT1.shape, dummyT2.shape, dummyT1T2repHorizontal1.shape)\n",
    "#     dummyT1T2repHorizontal1Cols = dummyT1T2repHorizontal1.columns\n",
    "\n",
    "#     #create two copies and concatenate horizontally - for seat Type 2\n",
    "#     seatType2Names  = dummyT2.iloc[:,0]\n",
    "#     tempDummyT1 = dummyT1.copy()\n",
    "#     tempDummyT1.iloc[:,0] = seatType2Names\n",
    "#     dummyT2T1repHorizontal2 = pd.merge(dummyT2,tempDummyT1, left_on =  [dummyT2.columns[0]], right_on =  [tempDummyT1.columns[0]])\n",
    "#     #print(dummyT1.shape, dummyT2.shape, dummyT2T1repHorizontal2.shape)\n",
    "#     #print(dummyT2T1repHorizontal2.columns)\n",
    "#     dummyT2T1repHorizontal2.columns = dummyT1T2repHorizontal1Cols\n",
    "\n",
    "#     dummyT1T2Combined = pd.concat([dummyT1T2repHorizontal1, dummyT2T1repHorizontal2], axis = 0, ignore_index = True)\n",
    "\n",
    "#     # CREATE COMBINED FLOOR CAPACITY\n",
    "#     dummyFloorsDF12Combined = pd.concat([dummyFloorsDF1, dummyFloorsDF2], axis = 0, ignore_index = True)\n",
    "\n",
    "\n",
    "#     sRawI = origI\n",
    "#     sRawT = dummyT1T2Combined\n",
    "#     floorsDF = dummyFloorsDF12Combined\n",
    "#     sRawTS = origTS\n",
    "\n",
    "#     ### pass into dictionary\n",
    "#     rawCsv['distance'] = sRawT\n",
    "#     rawCsv['space_capacity'] = floorsDF\n",
    "#     rawCsv['interaction'] = sRawI\n",
    "#     rawCsv['team_size'] = sRawTS\n",
    "    \n",
    "\n",
    "# display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+2)'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #######################################################################################\n",
    "# ########## Running FW algo a second time - with variable seats parameters   ###########\n",
    "# ##########                       turned on                                  ###########\n",
    "# #######################################################################################\n",
    "# clear_output()\n",
    "\n",
    "# if variableSeats:\n",
    "#     #for Variable Workspaces - turn these flags on\n",
    "#     variableWorkSpaces = True  # flag to indicate Aaron Constraint Sept 28\n",
    "#     numSeatTypes = 2 \n",
    "#     teamSizeVectorOffices = getTeamSizeVector(dummyTS1)\n",
    "\n",
    "#     # now run WSP again\n",
    "#     try:\n",
    "#         tables_list = []\n",
    "#         scores = []\n",
    "\n",
    "#         #start_time = time.time()\n",
    "#         for seed in randomSeeds:\n",
    "#             tables, FWoptStatus, FWoptCount, tXX = algoFrankWolfe(numTries, preSetupTeamAllocation, rawCsvs, \n",
    "#                                                               runFWOptimizer, changeIdx, isRerun, officeFloorCapacityFileFormat,\n",
    "#                                                               officeOutput, reDistAdjSeats, scaleUnits, \n",
    "#                                                               relConstraints, fpRank, relConstraintsForm, \n",
    "#                                                               runScipyTrOptimizer, X0HeurOpt, randomSeed=seed,\n",
    "#                                                              variableWorkSpaces=True, numSeatTypes=2, teamSizeVectorOffices = teamSizeVectorOffices)\n",
    "\n",
    "#             # keep track of floorplans, keep track of scores\n",
    "#             tables_list.append(tables)\n",
    "#             scores.append(np.round(tXX, 5))\n",
    "            \n",
    "            \n",
    "#         # choose best table\n",
    "#         best_score_indx = np.argmin(scores) # save this seed to history map (so if you run it again you same seed) \n",
    "#         best_floor_plan = tables_list[best_score_indx]\n",
    "#         print('\\n\\n\\n')\n",
    "#         print(f'Status: {FWoptStatus}')\n",
    "#         print(scores)\n",
    "#         print(f'Best iteration: {best_score_indx}. Best Score: {scores[best_score_indx]}')\n",
    "#     except Exception as e:\n",
    "#         raise ValueError(e)\n",
    "    \n",
    "#     final_floorplan_df = pd.DataFrame(best_floor_plan['floorPlan'])\n",
    "    \n",
    "# display(Javascript('IPython.notebook.execute_cell_range(IPython.notebook.get_selected_index()+1, IPython.notebook.get_selected_index()+2)'))\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# clear_output()\n",
    "# if variableSeats:\n",
    "#     #####################\n",
    "#     ### Save results  ###\n",
    "#     #####################\n",
    "#     final_floorplan_df = pd.DataFrame(best_floor_plan['floorPlan'])\n",
    "#     floorplan_final_path = os.getcwd() + '\\\\'+ 'app_results'+'\\\\'+out_filename\n",
    "#     final_floorplan_df.to_excel(r''+ floorplan_final_path, sheet_name='Floorplan')\n",
    "    \n",
    "#     print(floorplan_final_path)\n",
    "#     display(Markdown(savefinsh))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}