From e401e285954109608fb3214c3676eecebd59a502 Mon Sep 17 00:00:00 2001 From: Diego Mandelli Date: Mon, 27 Jan 2025 10:07:36 -0700 Subject: [PATCH] Mandd/cpm red (#52) * edits * edited src file and test file * cleaned files * cleaned files 2 * further development * working subpath search * last edits before PL * add resources to CPM model * finalized schedule * last fY24 edits * cleaning PR 1 * cleaning PR 2 * tests files * update test * delete whitespaces * edits * edits * edits * edits * edits * edits * edits * edits * edits * edits * addressing comments * delete whispaces --- doc/demos/CPM/CPM_paths_analysis.ipynb | 273 +++++++++++ doc/demos/CPM/CPM_testing.ipynb | 358 ++++++++++++++ doc/demos/CPM/model1.png | Bin 0 -> 53561 bytes doc/demos/CPM/model1A.png | Bin 0 -> 51825 bytes doc/demos/CPM/outageScheduleGenerator.ipynb | 302 ++++++++++++ doc/demos/CPM/resources_plot.ipynb | 166 +++++++ src/CPM/PertMain2.py | 494 +++++++++++++++++++- tests/unit_tests/CPM/CPM.py | 165 +++++++ tests/unit_tests/CPM/tests | 6 + 9 files changed, 1749 insertions(+), 15 deletions(-) create mode 100644 doc/demos/CPM/CPM_paths_analysis.ipynb create mode 100644 doc/demos/CPM/CPM_testing.ipynb create mode 100644 doc/demos/CPM/model1.png create mode 100644 doc/demos/CPM/model1A.png create mode 100644 doc/demos/CPM/outageScheduleGenerator.ipynb create mode 100644 doc/demos/CPM/resources_plot.ipynb create mode 100644 tests/unit_tests/CPM/CPM.py create mode 100644 tests/unit_tests/CPM/tests diff --git a/doc/demos/CPM/CPM_paths_analysis.ipynb b/doc/demos/CPM/CPM_paths_analysis.ipynb new file mode 100644 index 0000000..b205fec --- /dev/null +++ b/doc/demos/CPM/CPM_paths_analysis.ipynb @@ -0,0 +1,273 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Notebook designed to test PERT class methods (Model 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, '../../../src/CPM/')\n", + "from PertMain2 import Pert, Activity" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'start': ['a'],\n", + " 'a': ['b', 'f'],\n", + " 'b': ['c'],\n", + " 'c': ['d'],\n", + " 'd': ['e'],\n", + " 'e': ['i', 'l'],\n", + " 'f': ['g'],\n", + " 'g': ['h', 'd'],\n", + " 'h': ['e'],\n", + " 'i': ['end'],\n", + " 'l': ['end'],\n", + " 'end': []}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "start = Activity(\"start\", 1)\n", + "a = Activity(\"a\", 3)\n", + "b = Activity(\"b\", 5)\n", + "c = Activity(\"c\", 7)\n", + "d = Activity(\"d\", 4)\n", + "e = Activity(\"e\", 8)\n", + "f = Activity(\"f\", 3)\n", + "g = Activity(\"g\", 4)\n", + "h = Activity(\"h\", 6)\n", + "i = Activity(\"i\", 2)\n", + "l = Activity(\"l\", 2)\n", + "end = Activity(\"end\", 1)\n", + "\n", + "graph = {start: [a],\n", + " a: [b, f], \n", + " b: [c], \n", + " c: [d], \n", + " d: [e], \n", + " e: [i,l], \n", + " f: [g],\n", + " g: [h,d],\n", + " h: [e],\n", + " i: [end],\n", + " l: [end], \n", + " end:[]}\n", + "\n", + "pert = Pert(graph)\n", + "pert.returnGraphSymbolic()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['start', 'a', 'b', 'c', 'd', 'e', 'l', 'end']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pert.getCriticalPathSymbolic()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "e i end \n", + "a f g d \n", + "a f g h e \n" + ] + } + ], + "source": [ + "paths = pert.getSubpathsParalleltoCP()\n", + "for path in paths:\n", + " pert.printPathSymbolic(path)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "d: \n", + "e: \n", + "h: \n", + "i: \n", + "l: \n", + "end: \n", + "start: start a \n", + "b: b c \n", + "f: f g \n" + ] + } + ], + "source": [ + "pertRed = pert.simplifyGraph()\n", + "for node in pertRed.returnGraph():\n", + " print(node.returnName() + ': ' , end =\" \")\n", + " for sub in node.returnSubActivities():\n", + " print(' ' + sub.returnName(), end =\" \")\n", + " print()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'d': ['e'],\n", + " 'e': ['i', 'l'],\n", + " 'h': ['e'],\n", + " 'i': ['end'],\n", + " 'l': ['end'],\n", + " 'end': [],\n", + " 'start': ['b', 'f'],\n", + " 'b': ['d'],\n", + " 'f': ['h', 'd']}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pertRed.returnGraphSymbolic()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['start', 'b', 'd', 'e', 'l', 'end']" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pertRed.getCriticalPathSymbolic()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "CP = pertRed.getCriticalPath()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "start b d e i end \n", + "start f h e i end \n", + "start f h e l end \n", + "start f d e i end \n", + "start f d e l end \n" + ] + } + ], + "source": [ + "paths = pertRed.getAllPathsParallelToCP()\n", + "for path in paths:\n", + " pertRed.printPathSymbolic(path)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "start f h e \n", + "e i end \n", + "start f d \n" + ] + } + ], + "source": [ + "subpaths = pertRed.getSubpathsParalleltoCP()\n", + "for sub in subpaths:\n", + " pertRed.printPathSymbolic(sub)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "myenv", + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/demos/CPM/CPM_testing.ipynb b/doc/demos/CPM/CPM_testing.ipynb new file mode 100644 index 0000000..f782951 --- /dev/null +++ b/doc/demos/CPM/CPM_testing.ipynb @@ -0,0 +1,358 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Notebook designed to test PERT class methods (Model 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, '../../../src/CPM/')\n", + "\n", + "from PertMain2 import Pert, Activity\n", + "import copy\n", + "from datetime import datetime, time\n", + "import json" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initialize testing schedule" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'start': ['a', 'd', 'f'],\n", + " 'a': ['b'],\n", + " 'b': ['c'],\n", + " 'c': ['g', 'h'],\n", + " 'd': ['e'],\n", + " 'e': ['c'],\n", + " 'f': ['c'],\n", + " 'g': ['end'],\n", + " 'h': ['end'],\n", + " 'end': []}" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "start = Activity(\"start\", 5)\n", + "a = Activity(\"a\", 2)\n", + "b = Activity(\"b\", 3)\n", + "c = Activity(\"c\", 3)\n", + "d = Activity(\"d\", 4)\n", + "e = Activity(\"e\", 3)\n", + "f = Activity(\"f\", 6)\n", + "g = Activity(\"g\", 3)\n", + "h = Activity(\"h\", 6)\n", + "end = Activity(\"end\", 2)\n", + "\n", + "graph = {start: [a, d, f], \n", + " a: [b], \n", + " b: [c], \n", + " c: [g, h], \n", + " d: [e], \n", + " e: [c], \n", + " f: [c],\n", + " g: [end],\n", + " h: [end], \n", + " end:[]}\n", + "\n", + "outageStartTime = datetime(2025, 4, 25, 8)\n", + "\n", + "pert = Pert(graph, startTime=outageStartTime)\n", + "pert.returnGraphSymbolic()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "datetime.datetime(2025, 4, 26, 7, 0)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pert.returnScheduleEndTime()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image \n", + "\n", + "Image(url=\"model1.png\") " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Determine CP" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['start', 'd', 'e', 'c', 'h', 'end']" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pert.getCriticalPathSymbolic()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Image(url=\"model1A.png\") " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Determine paths parallel to CP" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "start a b c g end \n", + "start a b c h end \n", + "start d e c g end \n", + "start f c g end \n", + "start f c h end \n", + "start a b c g end \n", + "start a b c h end \n", + "start d e c g end \n", + "start f c g end \n", + "start f c h end \n" + ] + } + ], + "source": [ + "paths = pert.getAllPathsParallelToCP()\n", + "for path in paths:\n", + " pert.returnPathSymbolic(path)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Determine subpaths" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "start f c \n", + "c g end \n", + "start a b c \n" + ] + } + ], + "source": [ + "subpaths = pert.getSubpathsParalleltoCP()\n", + "for subpath in subpaths:\n", + " pert.printPathSymbolic(subpath)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simplify schedule" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'start': ['a', 'd', 'f'],\n", + " 'c': ['g', 'h'],\n", + " 'f': ['c'],\n", + " 'g': ['end'],\n", + " 'h': ['end'],\n", + " 'end': [],\n", + " 'a': ['c'],\n", + " 'd': ['c']}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pertRed = pert.simplifyGraph()\n", + "pertRed.returnGraphSymbolic()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "start: \n", + "c: \n", + "f: \n", + "g: \n", + "h: \n", + "end: \n", + "a: a b \n", + "d: d e \n" + ] + } + ], + "source": [ + "for node in pertRed.returnGraph():\n", + " print(node.returnName() + ': ' , end =\" \")\n", + " for sub in node.returnSubActivities():\n", + " print(' ' + sub.returnName(), end =\" \")\n", + " print()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['start', 'd', 'c', 'h', 'end']" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pertRed.getCriticalPathSymbolic()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "pert.saveScheduleToJsn()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "myenv", + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/demos/CPM/model1.png b/doc/demos/CPM/model1.png new file mode 100644 index 0000000000000000000000000000000000000000..cf6a6fc021af1e612211ae86c9d52d8131ed4e2c GIT binary patch literal 53561 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 literal 0 HcmV?d00001 diff --git a/doc/demos/CPM/model1A.png b/doc/demos/CPM/model1A.png new file mode 100644 index 0000000000000000000000000000000000000000..ced96e5d45ea144cfbf4bade2776936cd1776eb3 GIT binary patch literal 51825 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 A3;+NC literal 0 HcmV?d00001 diff --git a/doc/demos/CPM/outageScheduleGenerator.ipynb b/doc/demos/CPM/outageScheduleGenerator.ipynb new file mode 100644 index 0000000..699d204 --- /dev/null +++ b/doc/demos/CPM/outageScheduleGenerator.ipynb @@ -0,0 +1,302 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Notebook to construct the test plant outage schedule" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, '../../../src/CPM/')\n", + "from PertMain2 import Pert, Activity\n", + "import random\n", + "from datetime import datetime, time\n", + "\n", + "random.seed(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10310" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Main outage blocks\n", + "courseSchedule = {'start': ['1','2','3'], \n", + " '1': ['4','5','6','10'], \n", + " '2': ['15','16'], \n", + " '3': ['100','101','102','107','108'], \n", + " '4': ['7'],\n", + " '5': ['7'], \n", + " '6': ['8','9'],\n", + " '7': ['8'], \n", + " '8': ['301'],\n", + " '9': ['301'], \n", + "\n", + " '10': ['11','12'], \n", + " '11': ['13','14'],\n", + " '12': ['13','14'], \n", + " '13': ['302'], \n", + " '14': ['302'],\n", + " '15': ['17'], \n", + " '16': ['17'],\n", + " '17': ['18','19','20'], \n", + " '18': ['21','22'],\n", + " '19': ['21','22'], \n", + " '20': ['21','22'], \n", + " '21': ['302'],\n", + " '22': ['302'],\n", + "\n", + " '100': ['103'], \n", + " '101': ['103'], \n", + " '102': ['105','106'], \n", + " '103': ['104','105'], \n", + " '104': ['109'],\n", + " '105': ['109'], \n", + " '106': ['109'],\n", + " '107': ['110'], \n", + " '108': ['110'],\n", + " '109': ['303'], \n", + " '110': ['303'], \n", + "\n", + " '301': ['end'], \n", + " '302': ['end'], \n", + " '303': ['end'], \n", + "\n", + " 'end':[]}\n", + "\n", + "Nmin = 10\n", + "Nmax = 500\n", + "numAct = {}\n", + "for act in courseSchedule.keys():\n", + " if act in ['start','end']:\n", + " numAct[act] = 1\n", + " else:\n", + " numAct[act] = random.randint(Nmin, Nmax)\n", + "\n", + "fullActDict = {}\n", + "for act in courseSchedule.keys():\n", + " if act not in ['start','end']:\n", + " for i in range(numAct[act]):\n", + " name = act +'-'+ str(i)\n", + " duration = random.random()*2.0\n", + " fullActDict[name] = Activity(name, duration)\n", + " elif act=='start':\n", + " fullActDict['start'] = Activity('start', 24.)\n", + " elif act=='end':\n", + " fullActDict['end'] = Activity('end', 24.)\n", + " else:\n", + " print('error1') \n", + "\n", + "\n", + "outageSchedule = {}\n", + "for act in courseSchedule.keys():\n", + " if act=='end':\n", + " outageSchedule[fullActDict['end']] = []\n", + " else:\n", + " for i in range(numAct[act]):\n", + " if act=='start':\n", + " name = 'start'\n", + " else:\n", + " name = act +'-'+ str(i)\n", + " \n", + " if i==numAct[act]-1:\n", + " outageSchedule[fullActDict[name]] = []\n", + " for desc in courseSchedule[act]:\n", + " if desc=='end':\n", + " succ = 'end'\n", + " else:\n", + " succ = desc +'-'+ str(0)\n", + " outageSchedule[fullActDict[name]].append(fullActDict[succ])\n", + " else:\n", + " succ = act +'-'+ str(i+1)\n", + " outageSchedule[fullActDict[name]] = [fullActDict[succ]]\n", + "\n", + "len(fullActDict.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "datetime.datetime(2025, 7, 21, 5, 18, 30, 311548)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "outageStartTime = datetime(2025, 4, 25, 8)\n", + "\n", + "pert = Pert(outageSchedule, startTime=outageStartTime)\n", + "\n", + "pert.returnScheduleEndTime()\n", + "\n", + "#import json\n", + "#with open('benchmarkSchedule.json', 'w') as fp:\n", + "# json.dump(outageSchedule, fp)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "start\n", + "1\n", + "10\n", + "11\n", + "13\n", + "302\n", + "end\n" + ] + } + ], + "source": [ + "CP = pert.getCriticalPathSymbolic()\n", + "CP_mod = set()\n", + "for elem in CP:\n", + " head, sep, tail = elem.partition('-')\n", + " if head not in CP_mod:\n", + " CP_mod.add(head)\n", + " print(head)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "pert.saveScheduleToJsn('benchmarkOutageSchedule.json')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'start': ['1-0', '2-0', '3-0'],\n", + " 'end': [],\n", + " '1-0': ['4-0', '5-0', '6-0', '10-0'],\n", + " '2-0': ['15-0', '16-0'],\n", + " '3-0': ['100-0', '101-0', '102-0', '107-0', '108-0'],\n", + " '4-0': ['7-0'],\n", + " '5-0': ['7-0'],\n", + " '6-0': ['8-0', '9-0'],\n", + " '7-0': ['8-0'],\n", + " '8-0': ['301-0'],\n", + " '9-0': ['301-0'],\n", + " '10-0': ['11-0', '12-0'],\n", + " '11-0': ['13-0', '14-0'],\n", + " '12-0': ['13-0', '14-0'],\n", + " '13-0': ['302-0'],\n", + " '14-0': ['302-0'],\n", + " '15-0': ['17-0'],\n", + " '16-0': ['17-0'],\n", + " '17-0': ['18-0', '19-0', '20-0'],\n", + " '18-0': ['21-0', '22-0'],\n", + " '19-0': ['21-0', '22-0'],\n", + " '20-0': ['21-0', '22-0'],\n", + " '21-0': ['302-0'],\n", + " '22-0': ['302-0'],\n", + " '100-0': ['103-0'],\n", + " '101-0': ['103-0'],\n", + " '102-0': ['105-0', '106-0'],\n", + " '103-0': ['104-0', '105-0'],\n", + " '104-0': ['109-0'],\n", + " '105-0': ['109-0'],\n", + " '106-0': ['109-0'],\n", + " '107-0': ['110-0'],\n", + " '108-0': ['110-0'],\n", + " '109-0': ['303-0'],\n", + " '110-0': ['303-0'],\n", + " '301-0': ['end'],\n", + " '302-0': ['end'],\n", + " '303-0': ['end']}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pertRed = pert.simplifyGraph()\n", + "pertRed.returnGraphSymbolic()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "datetime.datetime(2025, 7, 21, 5, 18, 30, 311548)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pertRed.returnScheduleEndTime()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "myenv", + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/demos/CPM/resources_plot.ipynb b/doc/demos/CPM/resources_plot.ipynb new file mode 100644 index 0000000..a2e59f7 --- /dev/null +++ b/doc/demos/CPM/resources_plot.ipynb @@ -0,0 +1,166 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import pandas as pd \n", + "import datetime \n", + "import numpy as np \n", + "\n", + "import sys\n", + "sys.path.insert(0, '../../../src/CPM/')\n", + "from PertMain2 import Pert, Activity\n", + "\n", + "np.random.seed(0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "res_usage_raw = np.random.randint(1, 6, size=(7,4))\n", + "time_vals = np.array(['8','10','12','14','16','18','20']) \n", + "\n", + "comb_data = np.column_stack((time_vals.T, res_usage_raw))\n", + "df1 = pd.DataFrame(comb_data, columns=['time', 'res1', 'res2', 'res3', 'res4'])\n", + "df1=df1.astype(int)\n", + "\n", + "df1.plot(x='time', kind='bar', stacked=True, rot=0, title='Resorces usage')\n", + "\n", + "plt.axhline(y=12, color='0.6', linestyle='-')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " res1 res2 res3 res4\n", + "time \n", + "2019-01-01 00:00:00 13 14 18 19\n", + "2019-01-01 01:00:00 13 19 14 10\n", + "2019-01-01 02:00:00 13 18 13 12\n", + "2019-01-01 03:00:00 17 11 17 17\n", + "2019-01-01 04:00:00 10 11 15 12\n", + "2019-01-01 05:00:00 11 17 15 19\n", + "2019-01-01 06:00:00 19 19 10 12\n", + "2019-01-01 07:00:00 19 19 11 13\n", + "2019-01-01 08:00:00 10 13 15 13\n", + "2019-01-01 09:00:00 14 16 19 12\n" + ] + } + ], + "source": [ + "range_date = pd.date_range(start ='1/1/2019 0:00:00', end ='1/1/2019 23:00:00',freq ='h') \n", + "df_res = pd.DataFrame(range_date, columns =['date']) \n", + "df_res['res1'] = np.random.randint(10, 20, size =(len(range_date)))\n", + "df_res['res2'] = np.random.randint(10, 20, size =(len(range_date)))\n", + "df_res['res3'] = np.random.randint(10, 20, size =(len(range_date)))\n", + "df_res['res4'] = np.random.randint(10, 20, size =(len(range_date)))\n", + "\n", + "df_res['time'] = pd.to_datetime(df_res['date']) \n", + "df_res = df_res.set_index('time') \n", + "df_res.drop(['date'], axis = 1, inplace = True) \n", + " \n", + "print(df_res.head(10))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_res.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "start = Activity(\"start\", 1, 'res1')\n", + "a = Activity(\"a\", 2, 'res1')\n", + "b = Activity(\"b\", 3, 'res2')\n", + "c = Activity(\"c\", 3, 'res3')\n", + "d = Activity(\"d\", 4, 'res4')\n", + "e = Activity(\"e\", 3, 'res1')\n", + "f = Activity(\"f\", 6, 'res2')\n", + "g = Activity(\"g\", 3, 'res3')\n", + "h = Activity(\"h\", 6, 'res4')\n", + "end = Activity(\"end\", 1, 'res1')\n", + "\n", + "graph = {start: [a, d, f], \n", + " a: [b], \n", + " b: [c], \n", + " c: [g, h], \n", + " d: [e], \n", + " e: [c], \n", + " f: [c],\n", + " g: [end],\n", + " h: [end], \n", + " end:[]}\n", + "\n", + "startT = pd.to_datetime('1/1/2019 0:00:00')\n", + "\n", + "pert = Pert(graph, startTime=startT, resourcesTS=df_res)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "myenv", + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/CPM/PertMain2.py b/src/CPM/PertMain2.py index cb17571..f02346f 100644 --- a/src/CPM/PertMain2.py +++ b/src/CPM/PertMain2.py @@ -3,6 +3,13 @@ import math import copy +import networkx as nx +import matplotlib.pyplot as plt +import itertools +import datetime +import pandas as pd +import numpy as np +import json class Activity: """ @@ -10,14 +17,45 @@ class Activity: Extended from the original development of Nofar Alfasi Source https://github.com/nofaralfasi/PERT-CPM-graph """ - def __init__(self, name, duration): + def __init__(self, name, duration, res=None, childs=None): """ Constructor @ In, name, str, ID of the activity + @ In, duration, float, planned activity duration + @ In, res, str, required resource to complete the activity + @ In, child, list, list containing the names (str type) of the children (i.e., successors) @ Out, None """ - self.name = str(name) - self.duration = duration + self.name = str(name) # name ID of the activity + self.duration = duration # planned duration of of the activity + self.subActivities = [] # list of activities that have been clustered to this activity + self.belongsToCP = False # Boolean flag that indicates if the axctivity belongs to the CP + self.resources = res # required resource to complete the activity + + self.startTime = None # activity actual start time + self.endTime = None # activity actual completion time + + if childs is None: + self.childs = [] # list containing the names (str type) of the children (i.e., successors) + else: + self.childs = childs + + def printToJson(self): + """ + Method designed to print on file activity in json format + @ In, None + @ Out, file in json format + """ + return json.dumps(self.__dict__, sort_keys=True, default=str) + + def updateChilds(self, childs): + """ + Method designed to assign the childs of an activity + @ In, childs, list containing the names (str type) of the children (i.e., successors) + @ Out, None + """ + for child in childs: + self.childs.append(child.returnName()) def returnName(self): """ @@ -35,6 +73,14 @@ def returnDuration(self): """ return self.duration + def returnResources(self): + """ + Methods that returns the duration of the activity + @ In, None + @ Out, resources, str, resources required to complete the activity + """ + return self.resources + def updateDuration(self, newDuration): """ Methods that changes the duration of the activity @@ -43,38 +89,113 @@ def updateDuration(self, newDuration): """ self.duration = copy.deepcopy(newDuration) + def returnSubActivities(self): + """ + Methods that returns the list of subactivities + @ In, None + @ Out, subActivities, list, list of subactivities + """ + return self.subActivities + + def addSubActivities(self, subActivities): + """ + Method that associates a list of subactivities + @ In, subActivities, list, list of subactivities + @ Out, None + """ + self.subActivities = subActivities + tempDuration = 0. + for act in subActivities: + tempDuration += act.returnDuration() + self.duration = tempDuration + + def setOnCP(self): + """ + Methods that sets if an activity is part of the CP + @ In, None + @ Out, None + """ + self.belongsToCP = True + + def returnCPstatus(self): + """ + Return if an activity is part of the CP or not + @ In, None + @ Out, belongsToCP, bool, variable that flags if activity belongs to CP + """ + return self.belongsToCP + + def setTimes(self, Tin, Tfin): + """ + Set initial and final time of the activity based on CPM calculations + @ In, Tin, float, initial time of the activity + @ In, Tfin, float, final time of the activity + @ Out, None + """ + self.startTime = Tin + self.endTime = Tfin + + def returnAbsTimes(self): + """ + Return initial and final time of the activity based on CPM calculations + @ In, None + @ Out, (self.startTime,self.endTime), tuple, tuple containing initial and final time of the activity + """ + return (self.startTime,self.endTime) + + + class Pert: """ This is the base class for a schedule as a set of activities linked by a graph structure A graph is a map with activities as keys and list of outgoing activities as value for every key - The graph starts with a 'start' node and ends with a 'end' node + The graph starts with a 'start' node and ends with a 'end' node. Extended from the original development of Nofar Alfasi Source https://github.com/nofaralfasi/PERT-CPM-graph """ - def __init__(self, graph={}): + def __init__(self, graph={}, startTime=None, resourcesTS=None): """ Constructor - @ In, None + @ In, graph, dict, dictionary containing the child acitivities for each activity + @ In, startTime, float, absolute initial time of schedule + @ In, resourcesTS, dataframe, pandas dataframe containing resources availability @ Out, None """ self.forwardDict = graph # list of out going nodes for every activity + self.resources = resourcesTS + self.startTime = startTime + + if resourcesTS is not None: + self.checkResources() + if pd.infer_freq(resourcesTS.index) not in ['h','H']: + print("resourcesTS in PERT is set on the wrong index frequency: " + str(pd.infer_freq(resourcesTS.index)) + " instead of h or H") + self.backwardDict = {} # list of in going nodes for every activity self.infoDict = {} # map of details for every activity self.startActivity = Activity self.endActivity = Activity - self.resetInitialGraph() # first reset of the graph + self.resetInitialGraph() # first reset of the graph self.generateInfo() # entering values into 'info_dict' - # str method for pert + for act in self.forwardDict.keys(): + act.updateChilds(self.forwardDict[act]) + + if startTime is not None: + self.setActivitiesAbsTimes() + + if resourcesTS is not None: + self.resourcesTemporalCheck() + + def __str__(self): """ - Method designed to returun basic information of the schedule graph + Method designed to return basic information of the schedule graph @ In, None @ Out, None """ iterator = iter(self) - graph_str = 'Activities:\n' + graphStr = 'Activities:\n' for activity in iterator: graphStr += str(activity) + '\n' return (graphStr + 'Connections:\n' @@ -86,6 +207,16 @@ def __str__(self): def __iter__(self): return iter(self.forwardDict) + def checkResources(self): + """ + Method designed to check that the provided resource temporal profile contains allowed resource types + @ In, None + @ Out, None + """ + for act in self.forwardDict: + if act.returnResources() not in self.resources.columns: + raise IOError("Activity " + str(act.returnName()) + " requires a resource that is not allowed: " + str(act.returnResources())) + def resetInitialGraph(self): """ Method designed to reset the schedule graph: @@ -265,7 +396,7 @@ def getSlackForEachActivity(self): @ In, None @ Out, slackVals, list, list of slack value for all activities """ - slacks = {activity: self.infoDict[activity]["slack"] for activity in self.infoDict if self.infoDict[activity]["slack"] != 0} + slacks = {activity.returnName(): self.infoDict[activity]["slack"] for activity in self.infoDict if self.infoDict[activity]["slack"] != 0} slackVals = sorted(slacks.items(), key=lambda kv: kv[1], reverse=True) return slackVals @@ -336,10 +467,12 @@ def shortenCriticalPath(self): maxDecreaseToActivities[activity] = self.infoDict[path[1]]["slack"] - 1 return maxDecreaseToActivities - def getAllAlternativePaths(self, startActivity, endActivity, path=[]): + def getAllAlternativePaths(self, startActivity, endActivity, path=[], symbolic=False): """ Get all the paths between 2 nodes (activities) in the graph (pert) - @ In, None + @ In, startActivity, activity, activity at the beginning of the path + @ In, endActivity activity, activity at the end of the path + @ In, symbolic, bool, flag to indicate if alternate path should be generated in twerms of name of each activity @ Out, paths, list, list of paths between startActivity and endActivity """ onePath = path + [startActivity] @@ -350,10 +483,341 @@ def getAllAlternativePaths(self, startActivity, endActivity, path=[]): paths = [] for activity in self.forwardDict[startActivity]: paths += self.getAllAlternativePaths(activity, endActivity, onePath) - return paths + if symbolic: + symbPaths = [] + for path in paths: + symbPath = [] + for act in path: + symbPath.append(act.returnName()) + symbPaths.append(symbPath) + return symbPaths + else: + return paths + + def getAllPathsParallelToCP(self): + """ + Method designed to return all the paths parallel to the critical path + @ In, none + @ Out, pathsList, list, list of paths that are parallel to the critical path + """ + CP = self.getCriticalPath() + pathsList = self.getAllAlternativePaths(CP[0], CP[-1]) + pathsList.remove(CP) + return pathsList + + def returnSuccList(self,node): + """ + Method designed to return the immediate successors of a node + @ In, node, activity, activity being queried + @ Out, listSucc, list, list of activities that are immediate successors of "node" + """ + listSucc = list(self.forwardDict[node]) + return listSucc + + def returnNumberSucc(self,node): + """ + Method designed to return the number of immediate successors of a node + @ In, node, activity, activity being queried + @ Out, numSucc, int, number activities that are immediate successors of "node" + """ + numSucc = len(list(self.forwardDict[node])) + return numSucc + + def returnPredList(self,node): + """ + Method designed to return the immediate predecessors of a node + @ In, node, activity, activity being queried + @ Out, listPred, list, list of activities that are immediate predecessors of "node" + """ + listPred = (self.backwardDict[node]) + return listPred + + def returnNumberPred(self,node): + """ + Method designed to return the number of immediate predecessors of a node + @ In, node, activity, activity being queried + @ Out, numPred, int, number activities that are immediate predecessors of "node" + """ + numPred = len((self.backwardDict[node])) + return numPred + + def returnSubActivities(self, node): + """ + Method retrun the set of activities that have been merged into an activity + @ In, node, activity, activity to be queried + @ Out, listSubAct, list, list of activities + """ + listSubAct = node.returnSubActivities() + return listSubAct + + def deleteActivity(self,node): + """ + Method designed to delete an activity from a schedule + @ In, node, activity, activity to be removed + @ Out, none + """ + del self.forwardDict[node] + + def updateMergedSeries(self, node, listSucc, subActivities): + """ + Method designed to add a merged series to a schedule + @ In, node, activity, activity to be added + @ In, listSucc, list, list of sucessor activities associated with "node" + @ In, subActivities, list, list of activities that are part of the series + @ Out, none + """ + node.addSubActivities(subActivities) + self.forwardDict[node] = listSucc + + def simplifyGraph(self): + """ + Method designed to simplify the structure of a Pert graph by combining activities that are in series + @ In, none + @ Out, reducedPertModel, Pert model, reduced Pert model + """ + updatedGraph = copy.deepcopy(self.forwardDict) + reducedPertModel = Pert(updatedGraph) + + listPairs = reducedPertModel.pairsDetection() + + G = nx.DiGraph() + G.add_edges_from(listPairs) + + subgraphs_of_G_ex, removed_edges = graphPartitioning(G, plotting=False) + listSeries = list(subgraphs_of_G_ex) + + for series in listSeries: + temp = list(nx.topological_sort(series)) + succOFSeries = list(updatedGraph[temp[-1]]) + for node in list(series.nodes): + reducedPertModel.deleteActivity(node) + if checkForEndNode(temp) is None: + reducedPertModel.updateMergedSeries(temp[0], succOFSeries, temp) + else: + reducedPertModel.updateMergedSeries(checkForEndNode(temp), succOFSeries, temp) + + return reducedPertModel + + def pairsDetection(self): + """ + Method designed to identify pairs of activities that are in series + @ In, none + @ Out, pairs, list of tuples, list of pairs of activities, each pair is a tuple (activity_1, activity_2) + """ + pairs = [] + for node in self.forwardDict: + if self.returnNumberSucc(node)==1: + successor = self.returnSuccList(node)[0] + if self.returnNumberPred(successor)==1: + pairs.append((node,successor)) + return pairs + + def getSubpathsParalleltoCP(self): + """ + Method designed to return the subpaths that are parallel to CP + @ In, none + @ Out, subpathsSetRed, list of activities, list of activities that are parallel to the CP + """ + CP = self.getCriticalPath() + paths = self.getAllPathsParallelToCP() + subpathsSet = [] + for path in paths: + subpaths = getSubpaths(path,CP) + bSet = set(map(tuple,subpaths)) + subpathsSetRed = list(map(list,bSet)) + subpathsSetRed.remove([]) + subpathsSetExp = expandSubpaths(subpathsSetRed,path) + subpathsSet = subpathsSet + subpathsSetExp + + cSet = set(map(tuple,subpathsSet)) + subpathsSetRed = list(map(list,cSet)) + return subpathsSetRed + + def returnPathSymbolic(self, path): + """ + Method designed to print the symbolic name of a path + @ In, path, list, list of activities + @ Out, None + """ + symbPath = [] + for act in path: + symbPath.append(act.name) + return symbPath + + def setActivitiesAbsTimes(self): + """ + Method designed to assign, to each activity, its initial and final absolute time values + @ In, None + @ Out, None + """ + for act in self.forwardDict: + Tin = self.startTime + datetime.timedelta(hours=self.infoDict[act]['es']) + Tfin = Tin + datetime.timedelta(hours=act.returnDuration()) + act.setTimes(Tin,Tfin) + + def returnScheduleEndTime(self): + """ + Method designed to return the absolute end time of the aschdule + @ In, None + @ Out, endTime, float, absolute end time of the aschdule + """ + startTime, endTime = self.getCriticalPath()[-1].returnAbsTimes() + return endTime + + def saveScheduleToJsn(self, nameFile='schedule.json'): + """ + Method designed to print on file schedule in json format + @ In, nameFile, string, name of the generated file + @ Out, file in json format + """ + with open(nameFile, 'w', encoding="utf-8") as fp: + for act in self.forwardDict.keys(): + json.dump(act.printToJson(), fp, sort_keys=True, indent=4) + fp.write("\n") + + def resourcesTemporalCheck(self): + """ + Method designed to assess time depndendent resources requested by actual schedule + @ In, None + @ Out, None + """ + self.reqResources = pd.DataFrame().reindex_like(self.resources) + self.reqResources = self.reqResources.replace(np.nan, 0) + for act in self.forwardDict: + absTimeVals = act.returnAbsTimes() + res = act.returnResources() + if res is not None: + self.reqResources.loc[absTimeVals[0]:absTimeVals[1],res] += 1 + +def expandSubpaths(subpaths, path): + """ + Method designed to + @ In, path, list, critical path + @ In, subpaths, list, list of identified subpaths + @ Out, expandedPaths, , + """ + expandedPaths = [] + for subpath in subpaths: + idx1 = path.index(subpath[0]) + if len(subpath)==1: + expSubpath = path[idx1-1:idx1+2] + else: + expSubpath = path[idx1-1:idx1+len(subpath)+1] + expandedPaths.append(expSubpath) + return expandedPaths + +def checkForEndNode(listActivities): + """ + Method designed to return the end (i.e., final) activity + @ In, listActivities, list, list of activities + @ Out, elem, activty, schedule final activity + """ + for elem in listActivities: + if elem.returnName()=='end': + return elem + return None + +def getSubpaths(path,CP): + """ + Method designed to return the set of subpaths that are part of a path parallel to the CP + @ In, path, list, list of activities of a path that is parallel to the critical path + @ In, CP, list, list of activities that are part of the critical path + @ Out, subpaths, list, list of subpaths that are part "path" parallel to "CP" + """ + subpaths = [] + splitListRecursiveList(path, subpaths, [], CP) + return subpaths + +def splitListRecursiveList(testList, result, tempList, particularList): + """ + Recursive method designed to split a list in sub-lists separated by elements that are included in particularList + Source: https://www.geeksforgeeks.org/python-split-list-into-lists-by-particular-value/ + @ In, testList, list, + @ In, result, list, lis of subpath + @ In, tempList, list, temporary list of + @ In, particularList, list, list of element that mark a separation between sub-lists + @ Out, None + """ + if not testList: + result.append(tempList) + return + if testList[0] in particularList: + result.append(tempList) + splitListRecursiveList(testList[1:], result, [], particularList) + else: + splitListRecursiveList(testList[1:], + result, + tempList + [testList[0]], + particularList) + +def graphPartitioning(G, plotting=True): + """ + Partition a directed graph into a list of subgraphs that contain only entirely supported or entirely unsupported nodes. + @ In, G, graph, networkx graph to be analyzed + @ In, plotting, bool, flag to indicate if a plot should be generated + @ Out, subgraphs, list of graph nodes that are in series + @ Out, GminusH, set of removed edges + """ + # Categorize nodes by their node_type attribute + supportedNodes = {n for n, d in G.nodes(data="node_type") if d == "supported"} + unsupportedNodes = {n for n, d in G.nodes(data="node_type") if d == "unsupported"} + + # Make a copy of the graph. + H = G.copy() + # Remove all edges connecting supported and unsupported nodes. + H.remove_edges_from( + (n, nbr, d) + for n, nbrs in G.adj.items() + if n in supportedNodes + for nbr, d in nbrs.items() + if nbr in unsupportedNodes + ) + H.remove_edges_from( + (n, nbr, d) + for n, nbrs in G.adj.items() + if n in unsupportedNodes + for nbr, d in nbrs.items() + if nbr in supportedNodes + ) + + # Collect all removed edges for reconstruction. + GminusH = nx.DiGraph() + GminusH.add_edges_from(set(G.edges) - set(H.edges)) + + if plotting: + # Plot the stripped graph with the edges removed. + _nodeColors = [c for _, c in H.nodes(data="node_color")] + _pos = nx.spring_layout(H) + plt.figure(figsize=(8, 8)) + nx.draw_networkx_edges(H, _pos, alpha=0.3, edge_color="k") + nx.draw_networkx_nodes(H, _pos, node_color=_nodeColors) + nx.draw_networkx_labels(H, _pos, font_size=14) + plt.axis("off") + plt.title("The stripped graph with the edges removed.") + plt.show() + # Plot the edges removed. + _pos = nx.spring_layout(GminusH) + plt.figure(figsize=(8, 8)) + ncl = [G.nodes[n]["node_color"] for n in GminusH.nodes] + nx.draw_networkx_edges(GminusH, _pos, alpha=0.3, edge_color="k") + nx.draw_networkx_nodes(GminusH, _pos, node_color=ncl) + nx.draw_networkx_labels(GminusH, _pos, font_size=14) + plt.axis("off") + plt.title("The removed edges.") + plt.show() + + # Find the connected components in the stripped undirected graph. + # And use the sets, specifying the components, to partition + # the original directed graph into a list of directed subgraphs + # that contain only entirely supported or entirely unsupported nodes. + subgraphs = [ + H.subgraph(c).copy() for c in nx.connected_components(H.to_undirected()) + ] + return subgraphs, GminusH + ''' -# Example of usegae of the pert class +# Example of usage of the pert class if __name__ == "__main__": start = Activity("start", 5) a = Activity("a", 2) diff --git a/tests/unit_tests/CPM/CPM.py b/tests/unit_tests/CPM/CPM.py new file mode 100644 index 0000000..056b2a7 --- /dev/null +++ b/tests/unit_tests/CPM/CPM.py @@ -0,0 +1,165 @@ +""" + This Module performs Unit Tests for the utils methods + It cannot be considered part of the active code but of the regression test system +""" + +#For future compatibility with Python 3 +import warnings +warnings.simplefilter('default',DeprecationWarning) + +import os,sys +sys.path.insert(0, '../../../src/CPM/') +from PertMain2 import Pert, Activity + +import numpy as np +from datetime import datetime, time + +results = {"pass":0,"fail":0} + +def checkAnswer(comment,value,expected,tol=1e-10,updateResults=True): + """ + This method is aimed to compare two floats given a certain tolerance + @ In, comment, string, a comment printed out if it fails + @ In, value, float, the value to compare + @ In, expected, float, the expected value + @ In, tol, float, optional, the tolerance + @ In, updateResults, bool, optional, if True updates global results + @ Out, None + """ + if abs(value - expected) > tol: + print("checking answer",comment,value,"!=",expected) + if updateResults: + results["fail"] += 1 + return False + else: + if updateResults: + results["pass"] += 1 + return True + +def checkAnswerString(comment,value,expected,updateResults=True): + """ + This method compares two strings + @ In, comment, string, a comment printed out if it fails + @ In, value, string, the value to compare + @ In, expected, string, the expected value + @ In, updateResults, bool, optional, if True updates global results + @ Out, None + """ + if not value==expected: + print("checking answer",comment,value,"!=",expected) + if updateResults: + results["fail"] += 1 + return False + else: + if updateResults: + results["pass"] += 1 + return True + +def checkArray(comment,check,expected,tol=1e-10): + """ + This method is aimed to compare two arrays of floats given a certain tolerance + @ In, comment, string, a comment printed out if it fails + @ In, check, list, the value to compare + @ In, expected, list, the expected value + @ In, tol, float, optional, the tolerance + @ Out, None + """ + same=True + if len(check) != len(expected): + same=False + else: + for i in range(len(check)): + same = same*checkAnswer(comment+'[%i]'%i,check[i],expected[i],tol,False) + if not same: + print("checking array",comment,"did not match!") + results['fail']+=1 + return False + else: + results['pass']+=1 + return True + +def checkList(comment,check,expected): + same=True + if len(check) != len(expected): + same=False + else: + for i in range(len(check)): + same = same*checkAnswerString(comment+'[%i]'%i,check[i],expected[i],False) + if not same: + print("checking list",comment,"did not match!") + results['fail']+=1 + return False + else: + results['pass']+=1 + return True + +# Initialize schedule +start = Activity("start", 5) +a = Activity("a", 2) +b = Activity("b", 3) +c = Activity("c", 3) +d = Activity("d", 4) +e = Activity("e", 3) +f = Activity("f", 6) +g = Activity("g", 3) +h = Activity("h", 6) +end = Activity("end", 2) + +graph = {start: [a, d, f], + a: [b], + b: [c], + c: [g, h], + d: [e], + e: [c], + f: [c], + g: [end], + h: [end], + end:[]} + +outageStartTime = datetime(2025, 4, 25, 8) + +pert = Pert(graph, startTime=outageStartTime) + +# Test CP +symbCPlist = pert.getCriticalPathSymbolic() +expected = ['start', 'd', 'e', 'c', 'h', 'end'] +checkList('CP analysis (path)',symbCPlist,expected) + +# Test end time +endTime = pert.returnScheduleEndTime() +expected = '2025-04-26 07:00:00' +checkAnswerString('CP analysis (end time)',str(endTime),expected) + +# Test paths parallel to CP +paths = pert.getAllPathsParallelToCP() +expected = [['start', 'a', 'b', 'c', 'g', 'end'], + ['start', 'a', 'b', 'c', 'h', 'end'], + ['start', 'd', 'e', 'c', 'g', 'end'], + ['start', 'f', 'c', 'g', 'end'], + ['start', 'f', 'c', 'h', 'end']] +for index,path in enumerate(paths): + checkList('CP analysis (parallel paths)',pert.returnPathSymbolic(path),expected[index]) + +# Test subpaths +subpaths = pert.getSubpathsParalleltoCP() +subpathList = [] +for subpath in subpaths: + subpathList.append(pert.returnPathSymbolic(subpath)) +expected = [['c', 'g', 'end'], + ['start', 'a', 'b', 'c'], + ['start', 'f', 'c']] +subpathList.sort() +expected.sort() +for index,subpath in enumerate(subpaths): + checkList('CP analysis (subpaths)',subpathList[index],expected[index]) + +# Test reduced graph +pertRed = pert.simplifyGraph() +symbCPredList = pertRed.getCriticalPathSymbolic() +expected = ['start', 'd', 'c', 'h', 'end'] +checkList('CP analysis (path)',symbCPredList,expected) + +print(results) + +sys.exit(results["fail"]) + diff --git a/tests/unit_tests/CPM/tests b/tests/unit_tests/CPM/tests new file mode 100644 index 0000000..e7860af --- /dev/null +++ b/tests/unit_tests/CPM/tests @@ -0,0 +1,6 @@ +[Tests] + [./utils] + type = 'RavenPython' + input = 'CPM.py' + [../] +[] \ No newline at end of file