24/11/22

• Dialogue box now exists to insert asset parameters when a new asset is made. Note the actual numbers aren't taken in yet but the number of text boxes changes dynamically with the number of parameters.

• Small bug where there is an "Task Complete!" pop-up box even if the task is cancelled.
• The user library is now updated to the correct position whenever a project is loaded, however the directory control search bar is still blank.

23/11/22

• Objects are now loaded correctly from files. Whenever parameters are changed, and then the project saved, the objects can be loaded with the same parameters. In other words, the objects can be saved and loaded from files correctly.
• Fixed a small problem where the object list was just displaying "Asset" for all asset types. Now it shows the correct asset type. Note that this information is taken from the asset type class declaration in the System directory, so in theory should work for any new type of asset that is added.
• The New Asset button now works again, and the data can be saved when the whole project is saved.


• Bug when displaying the "Asset" type object. Seems to be a problem with numpy arrays... TypeError: iteration over a 0-d array
• The New Asset Dialogue still needs to be completed.
• There should be a way of deleting an asset (with an "Are you sure?" dialogue) by right-clicking the active asset list.


• Should have an option to import objects from other projects / user directory somewhere.
• Probably need to redo entire sphinx documentation process as too much has changed in the project.
• Definitely need to make the gui refresh after a new project is loaded.

22/11/22

• Completed the load project dialogue. This dialogue can be accessed via Data -> Load -> Load Project.
• The load project dialogue is also opened on start-up, since functionality of the GUI will now depend on there being an active project selected.
• There is a small issue with forward and back slashes, where python strings cannot contain a backslash, but the os active dirtectory is written with backslashes. This does not impede any functionality so will be ignored for now, but it looks ugly.


• Added the ability to switch between projects. The active project is always displayed at the status bar.
• Assets are now loaded from the /ENERGY_SYSTEM/ASSETS/ folder whenever a project is loaded.
• Added a class method for clearing all active assets.


• Need to add a method of the canvas refreshed whenever a new project is loaded.
• Need to change the New Asset dialogue to include a way of selecting all parameters etc before saving the new asset to a .open file.
• Small bug where the user directory search bar is now empty, rather than showing the active directory.
• The import of curves.py had to be commented out for the GUI to function properly, will have to rewrite the curves display next year.

21/11/22

• Project data can now be saved into the active project directory.
• Currently there is only the option to save the entire project, which saves all of the assets and the market objects as .open files.
• There should be a dialogue that opens on start up that forces the user to select an active project to start (unless there isn't one).
• Note that there will be a "sample project" that will come with the OPENGUI install for demonstration purposes.


• Added a dialogue box to load a project to be the "active project" Data -> Load -> Load Project.

17/11/22

• Changed the way arrays are displayed in the wx.propertygrid in the Object Parameters panel. Object Parameter arrays can now be edited more easily, and the function that updates the changed values has been updated as well.
• System for better data permanance is to be implemented using data serialization.
• Proposed new file system to save user data in shown below. The user should be able to click File -> New -> Project and a new project should be created within "UserData" with the following directory tree:


• A new file type .open can be used using python's pickle module. This module can serialise data and store it in files that can then be read at a later date.
• The idea is for .open files to contain instantiated object information that can be loaded at a later date. This type of serialisation should lead to the ability to import projects to different machines etc., as well as more data permanance within the OPENGUI.


• Implementation started for saving files, a new function saveObject() was built in the SaveData.py module. This function should allow for selected instantiated objects to be saved to the UserData section.
• New Projects can be created by pressing File -> New -> Project. The active project is then displayed on the status bar at the bottom of the canvas.
• User should have the choice to save the entire project at any given time through Data -> Save -> Project Data. The user should also be asked about overwriting data, closing without saving, etc through pop-up windows.

Back to Business

15/11/22

• Sphinx support added, working on readthedocs documentation...
• Panel titles added for the four panels on the edges of the canvas.
• Energy system tree now expanded by default.
• Active objects panel now has bold column headers, as well as a fixed width for columns. This makes the active object list more readable.


• Changed gui name to OPEN_GUI rather than OPEN_CANVAS
• Changed main file from CurrentMainCanvas.py to OPENGUI_main.py
• Added a generic confirmation pop-up dialogue.


• Files are now loaded into the data grid by double clicking on a file in the user library. The data page in the notebook in the central panel is automatically selected.
• Added an on_close() function to be called when the window is closed to assure the program is killed.

18/04/22

• Meeting with supervisor conducted, discussed how to finish project and report.

16/04/22

• Conducted user feedback tests.
• Detailed analysis of the feedback results will be further discussed in the coming report.

15/04/22

• Added two new menu items to the Help menu.
• Since the html webviewer on wxPython does not support watching videos, I decided to instead have the tutorial page open in the user's default browser.
• The internal web viewer now accesses the OPEN documentation. This should aid in understanding the funcitonalities of the GUI.
• The third menu item opens the GitHub report an issue page, and is meant to be a place where users can report any bugs or issues in the code. This is a big part of the project's ability to be worked on in the future.

Added Proper Web Help Page

14/04/22

• Click Here
• This webpage includes small videos on how to do some of the basic functions of the GUI.

GitHub Repository Made Public

08/04/22

• Click Here
• Also, a small "Clear All" button was added to the data grid.

Future Plans

05/04/22

• Will make OPENGUI repository on GitHub Public
• Some changes will need to be added before this GUI can be used completely instead of coding.
• The user should be able to delete assets, choose what assets are used in the simulation etc.
• The user should be able to further manipulate the markets and choose an "active market" to use in simulation.
• A more generic simulation method should be developed to allow for more freedom.
• The network portion of the energy system currently has very little interaction, other than changing some values on the three active buses already a part of the current simulation. In the future more network manipulation should be added.
• Currently the visualisation of the energy system is still lacking. In the future some sort of colour-based drag-and-drop system should be used to display the network status.
• All created assets should be stored somewhere outside of the GUI for later use.
• The state of the GUI should be stored for later use, some sort of save file.

Web Help Fixed

02/04/22

• There was a problem with the html window within the GUI not being scrollable.
• This issue has been fixed, it was due to an inheritance issue.
• Now the web help functionality works as intended. However, there is no option to "go back" as one could on a normal browser.
• Although this is an option to be considered in the future, for now I will just remove the need to go back and forth on the new webpage.

Error Handling

25/03/22

• Added a generic error dialogue.
• This new error dialogue is set to pop up whenever a python or windows error occurs.
• The error dialogue has been implemented so that a small sentence with the type of error that occured is displayed whenever it appears.
• Note that not all errors are accounted for at the moment. I will have to either search for as many as I can, find some method of having it appear for all errors, or for having a part of the web help page that allows users to send in error reports.

Status Bar

20/03/22

• A simple status bar has actually been a part of the GUI for some time now, however now it has some basic functionalities.
• The right hand side of the status bar at the bottom will display the current version of the GUI.
• The left hand side is used for the file select system when a file is loaded, and shows the current active filepath for loading data.

User Library, Top Left Panel

18/03/22

• The user library now correlates with the rest of the GUI.
• Currently, whenever a file is double-clicked, it is considered active. Unfortunately this cannot be implemented for single-clicks so it is a little unintuitive.
• The selected file will be the one loaded whenever Data -> Load Selected File is selected.

Update on class storage system

14/03/22

• An asset class and a market class were created in a seperate python file called AssetList.py
• Each class contains a method of adding a new asset or market of every type available to a list of active assets (or markets).
• The list stores the actual class of the asset, or rather a pointer to each instantiation of the asset type. These can be called upon individually.
• A library of all of the different types of asset (etc..) and their default parameters exists to help in creating new assets.
• Meeting with supervisor was conducted.

09/03/22

• Added another menu button to add a new Market to the system.
• In the future the user should have the ability to choose which market is active.
• Added a market class.

07/03/22

• Added a menu button to add a new Asset object to the system.
• This is accessed through File -> New -> Asset
• Meeting with supervisor was conducted.

03/03/22

• Values are stored in class system, to be discussed further in meeting...

Parameter List, Top Right Panel

27/02/22

• Whenever an object is selected, the parameters are displayed in the top right panel, with their names and values.
• The code works so that the parameters are automatically read from the class definition in the System/Assets.py file.
• The code is set so that all of the assets will be refreshed once a value is typed into the table, so that the asset parameters are actually modified.
• Currently, there is no method to store assets outside of the GUI. This is something that should be added in the future.

Object List, Bottom Right Panel

24/02/22

• The Asset List appears whenever one element in the system tree is double clicked.
• Whenever an element in the system tree is selected, e.g. "Assets", all of the objects within that part of the system will be displayed.
• In other words, when a class within the energy system is selected, all

System Tree, Bottom left Panel

21/02/22

• There is now a system tree in the bottom left panel.
• The system consists of a dropdown tree labeled "Energy System".
• The tree contains three subcategories labeled "Assets", "Market", and "Network".
• The plan is to have an object list implemented in the bottom right panel to compliment this panel.
• Meeting with supervisor was conducted.

19/02/22

• Implemented a new central canvas page called "PARAMETERS"
• This PARAMETERS page contains a list of parameters for the building and market groups, all of which can be edited
• After updating the parameters they must be refreshed using the button at the bottom right of the panel

16/02/22

• Whenever a simulation is started through the Run -> Run Simulation -> OPEN Test menu, a new dialogue appears.
• Now the parameters of each bus in the power network can be edited before the simulation is run.
• Note at this point, I am not sure if this is the best way to implement this feature, as this would be tedious with multiple buses.

Plans for moving forward

14/02/22

• Will work my way across the OPEN UML diagram, from right to left
• I will try to add functionality and communication with OPEN for each class in an energy system

Second BEng Presentation

11/02/22

09/02/22

• Loading dialogue is now initiated on the EnergySystem.py file, in time with the usual timer that is displayed in the command console
• To fix the problem that was happening previously with the loading dialogue, I changed .ShowModal() to .Show() and this allows the rest of the code to continue while the dialogue is displayed
• Unfortunately, there seems to be a bug when using .Show() that does not display static text. I will attempt to have a loading bar shown again at some time in the future

07/02/22

• Meeting with supervisor was conducted.

05/02/22

• Moved all dialogues and pop-up dialogues (called pop-ups from now on) to seperate python scripts that are now called by the main canvas.
• Generic loading dialogue cannot be displayed and allow the rest of the code to continue...
• Unsure as to why this issue is caused, I believe it has to do with calling the dialogue in a print() statement

04/02/22

• Currently the main canvas file is really crowded, and quite long
• Since I want to maintain readability, I think I will move the generic dialogues and dialogue pop-ups to seperate files
• In order to do this, however, I will need to know how to pass variables across classes in seperate files, meaning I will need to do some more research in OOP

01/02/22

• Fixed a visual bug where the left-hand panels had a slight border

Bug Squashing

26/01/22

• Fixed a bug that made the container with the "Add Row" and "Add Column" buttons take up half of the central canvas on the "DATA" tab whenever fullscreen was enabled. Now the buttons remain the same size above the data grid.
• Fixed the "Add Row" and "Add Column" buttons on the "DATA" tab of the central canvas.
• Fixed .csv implementation. Now the grid size will change dynamically depending on the size of .csv file implemented, so the data grid will not run out of available cells when loading data.
• Fixed a bug where the characters  would be displayed in the first cell whenever a .csv file was loaded from a previous Excel spreadsheet. This problem was fixed by adding the line encoding='utf-8-sig' to the SavaData.py file.

24/01/22

• Meeting with supervisor conducted.

22/01/22

• A very basic test case that accesses OPEN through OPENGUI has been implemented.
• This test case utilises the existing OPEN_buildings_case_study.py file, however the file has been copied and renamed to "building_test.py" for my own testing purposes. Note also that the internal code in the original test script has been defined inside of a __main__() function for the sake of passing variables from the GUI.
• Currently, as a simple test, the "building_test.py" file can be run by pressing "Run" -> "Run Simulation" -> "OPEN Test"

• Once the "OPEN Test" menu item has been clicked, a dialogue titled "OPEN Simulation Test Parameters" appears, asking for what season should be selected. (Summer or Winter)
• This choice is then passed onto the "building_test.py" script and the entire script is executed. Note that it would be simple to add more parameters in the event dialogue to change inside of the test file.
• After the calculations have been completed, the graphs that are generated through the original OPEN library and MatPlotLib appear as seperate windows and can be saved individually.


• Obviously more functinality and communication between the OPEN library and OPENGUI will be added in the future, but this is a great first step in terms of functionality


• Also in the future I would like for there to be much more feedback to the GUI, such as the "network sim complete for t = #" etc to be displayed in the GUI.

21/01/22

• Note that there is currently dodgy support for wxPython through Linux distribututions. Although technically supported, there seems to be some libraries within the wxPython framework that aren't supported by the main linux Debian distributables.
• OPENGUI will be, in theory at least, cross platform. However, wxPython installs might be trickier for Linux users.
• Read more about installing wxPython for Linux here.

20/01/22

• A simple "Help" button has been added. The idea is that eventually there will be a help page or wiki environment for this program, and this help button will open up that page in a window inside of the GUI.
• Currently the Help button (on the toolbar) only opens a small window leading to this devlog as a placeholder.
• There is a known bug that the html window is not scrollable within the GUI. This has been noted and will be mended at a later date.

19/01/22

• Ability to load data from a .csv file is implemented. There is a known bug about file size, and the rows and columns of the data grid can not yet be dynamically changed. It might be easier to just add a couple hundred rows and columns and just have them loaded constantly.
• The next step from here would be to change the way that csv files are read to include empty spaces... Since the basic functionality is here I will put this problem on the backburner for the time being.

New Look!

17/01/22

• There are now four main tabs in a notebook in the central area of the canvas. The "Active Asset Attributes" panel at the top right of the canvas has also been updated to be a "Property Grid", which should allow for better displaying of the attributes of a selected asset once that function is in place.
• Also, the "Active Asset List" panel at the bottom right of the canvas is now a wxListCtrl, which is essentially just a list of text that allows for event handling when each item is selected. This is the obvious next step in the development process.
• Note also in the images below that the "Add Row" and "Add Column" buttons do not function as of yet.
• A notable new feature that has been developed is the ability to save data to a .csv filetype, and open this file in excell. A potential flaw here is my choice to not record any empty spaces between values. Since the data is small enough to be almost negliginle, I may decide to just record every item in the grid, regardless if it has value null or not.
• The writeToCSV() function is stored in an external .py file.
• Note that currently there is no user input to change the filename. It will just be "data", however the number next to data will increment if a file with that name already exists: data1, data2, etc...

• As of yet there is no ability to load data, although the tast should be relatively straightforward to implement. The reason I have not implemented this feature as of yet is due to the possibility of there being more data than can fit on the active grid within the canvas. I am not sure how the GUI would react and would like to do some testing.
• In the future, I would like to implement a library of asset types than can be accessed by the main file. This will allow for different strings to be shown in the "Active Asset Attributes" tab that will change dynamically depending on the class of asset chosen.
• I am not sure how to proceed with the curves section. wxWidgets requires the support of third party libraries to display graphs within the GUI so I will need to do some research. It should be easy enough, however to display some charts and graphs in external popup windows, the way OPEN already does.
• I have made a small list of naming conventions that I have been using for variables and functions so far... I will keep this updated as I continue and maybe cross-check this with colleagues to ensure it is comprehensible.

13/01/22

• The central canvas was fixed to have a main display, and have four buttons along the bottom to select what will be displayed.
• Eventually it will have the functionality of changing the main display to the button selected, i.e. show curves or the data table etc.
• I would also like to add some method of increasing or decreasing the number of cells in the data table, as well as have some method of loading / saving the data table to export to excell or something.

11/01/22

• I managed to get a data table showing on the central window of the canvas.
• Using the wxGrid library, I created a simple data table, and added a notebook tab at the top. The notebook tabs will make it possible to switch between data tables.
• At this point in time, I am not sure if other data display windows will also be included within these notebook tabs.

05/01/22

• Today I ended up solving the main functional problem I was facing yesterday. Now, whenever you select a folder using the browse button in the directory selector bar, an event handler causes the folder to be opened in the directory tree below it.

• By using a simple event handler, whenever the directory selected in the bar above is changed, the active folder in the directory is also changed. Here I used the GetPath() and SetPath() functions that are part of the DirCtrlPicker class in the wxWidgets library.
• In the example photos, I selected a folder called "oop practice", which can then be seen as selected in the directory below.
• The visual issues discussed yesterday are still issues, however now the functionality that I wanted is in place, so I can move on to another part of the canvas.
• Tomorrow I will attempt to show some sort of spreadsheet or data table in the central portion of the canvas.

04/01/22

• Happy New Year! I have taken an extended hiatus from work on this project due to exams at the end of last semester, as well as the holiday season. Sorry for lack of progress and updates.
• To start off, I have found a rather simple solution to the file directory panel on the canvas not showing the current working directory. Python has a basic os library that has a getcwd() command that provides the current working directory of wherever the python file is located.
• The current directory tab looks completely fine, although currently has a lack of any real functionality. That will likely be my next step since I have a clear vision of what I would like to do with it. Hopefully one should be able to type in any directory into the search bar and it should appear on the dropdown list shown.

• Something I am not happy with right now is the fact that the visual directory shows your entire computer's file tree. It is a bit ugly and since the search bar should have this function I would like to get rid of it, but it is also a minor problem so I might leave it on the backburner for now.
• Another minor problem is that currently there is no method of changing the size of the window. I think this is definitely something I would like to have working in the future.
• A larger overarching problem I can see myself running into at this point of the development process is the fact that everything is still running from one file. Since I have a clearer vision of what I am working on now I think one of my next steps should be to study up on how to clean up my code and introduce modularity through script files and data files of some sort.

26/11/21

• Meeting with OPEN development and research team.

22/11/21

• Meeting with supervisor was conducted.

07/11/21

• Found a visual implementation tool for wxWidgets (the parent library of wxPython), called wxFormBuilder. It seems to be a really useful and intuitive tool, and it is sure to speed up the development process a considerable amount.
• Just because I am using a visual implementation tool now doesn't mean that all of the time I spent learning the wxPython coding library is in vain however, since the tool seems to be limited. Some of the more advanced features will have to be coded in manually.
• The wxFormBuilder also doesn't seem to have very good documentation. It is essentially just taken from the wxWidgets library though, so this might not be that big of a problem.
• Below, a simple mock-up with buttons (right) based off of the planned canvas layout (left) (Click to enlarge):

• Something I am worried about at this stage is how to develop the central display window on the canvas. I will probably have to add this portion manually.

06/11/21

• Canvas seems to look okay in the window when the program runs. I am worried, however, about screen resolutions. I am developing this on a high resolution monitor, and although there are methods in wxPython to get the native resolution, namely wx.GetDisplaySize(), it only takes the display size of the monitor that the program initlialises to... I will have to look into this problem further.
• I tried creating seperate panels in the main frame of the GUI window. For my own aid, I coloured each region so I could tell where each panel was. (Click to enlarge)

• I found sizing to be a big issue. As stated before, depending on the size of the monitor, the size of the panel changes. This is something that is going to take some time to fix.

04/11/21

• Had first BEng Project presentation. Examiner made the following notes on my presentation:
  1. Presentation slides didn't support my spoken presentation very well. Images and visualisation is is good, but it is important that the information on the slides play an active role in presenting the information.
  2. I wasn't super clear on what OPEN is; I will need to have a more detailed description of OPEN and its significance.
  3. The displayed mock-up wasn't very good. I had the canvas shown, but it wasn't in very good detail, I will have to have a more in-detail mock-up of the GUI canvas.


• Had a meeting with supervisor, supervisor suggested attempting the main canvas code in the following sections, to help break up the workload:
  1. Model of the system, first tab of the GUI.
  2. Power information. Power diagrams and bus network displays should be visually appealing and easy to understand at a glance. Use of colour is recommended.
  3. Curves and graphs. Maybe have a MatPlotLib extension.
  4. Data. This should be in tabular format, and should be filterable.
  5. Also, it should be stated that the user should be able to upload their own datasets, their own asset library, and their own control algorithms.
  

  Image credit to Chaimaa Essayeh

01/11/21

• Created a method of sending user inputted text to the console. The code also includes a pop-up dialog after the user has submitted the text.

• This method should be useful when combined with code previously implemented in order to add new assets to an asset list. If the user can input the values manually, it should make it much easier to add new assets with user-defined attributes.

28/10/21

• Read a tutorial series that goes through some of the basics of wxPython, and works through most of the library.

27/10/21

• Created some background code using OOP methodology to create a new asset with some variables.

• The code above works by adding the asset described by the button code into an asset list, that is part of the Asset class in the code shown on the image to the right.
• Currently, the options for the asset to be added cannot be changed from the GUI. This is obviously something I would liket to change in the near future.

26/10/21

• Completed OOP tutorial series.

25/10/21

• Weekly meeting, discussed the following:
  1. Have an ability for the GUI to export data in xml or csv format etc...
  2. Have an ability to save and load projects (JSON?)
  3. Have a graph system with zoom features, multiple inputs, axis manipulation etc...
  4. UML diagrams and use cases.

22/10/21

• Did some quick research on how contemporary power simulation software GUIs look. A common theme is a comprehensive toolbar at the top of the screen. It also seems to be common to have a large central SPICE-esque canvas to place the grid entities. Colour is often used to have an intuitive first-glance read on the situation of the simulation. Another common theme is to keep different tabs for graphs and other information in smaller windows within the program. Examples are shown below: (Click to enlarge)

• With the other examples in mind, I have created a very basic skeleton of what the UI layout might look like. Note this is not a final product, and a more elaborate mock-up will be done soon. (Click to enlarge)

21/10/21

• Set about making a short-term list of goals to achieve with my understanding of the new GUI system (I keep track of these goals here). These should act as building blocks when I start putting the GUI together:
  1. be able to create a new entity, and edit that entity's attributes
  2. be able to display graphs after simulation
  3. be able to drag and drop entities
  4. be able to make connections
• I followed some basic tutorials on how to get a basic windows application up and running, starting with a simple program that prints to the console any number typed into a textbox before pressing a button to confirm your input:

20/10/21

• Noticed that the "drag and drop" visual GUI implementation tool for Python with Visual Studio 2019 is no longer supported
• Explored some methods for still using the "drag and drop" method by using C# or Visual Basic and running it in tandem with python code, but it seems dofficult to do and probably quite slow.
• Decided to use wxPython, a Python GUI development toolkit. WxPython uses native widget elements and is cross-platform, so it shouldn't look strange if it's run on MAC or LINUX distribututions. It also has ample documentation online so seems ideal for a first-time development.
• To brush up on some OOP in Python, I watched and followed along with Corey Schafer's tutorial playlist, very detailed and informative.

19/10/21

• Had meeting with Dr Morstyn, and Chaimaa Essayeh. We discussed some design principles to keep in mind moving forward. We also reviewed the mission statement for this project.

15/10/21

• Got OPEN case study working on Visual Studio 2019
• Virtual environment created with required packaged
• Started working on Gantt chart to plan progress in the project