mg-pso-gui 0.1.13__py3-none-any.whl → 0.2.75__py3-none-any.whl

mgpsogui/gui/RunTab/RunTab.py

@@ -8,54 +8,108 @@ import re
 import ast
 import pandas as pd
 import numpy as np
+import os
+import platform
+import subprocess
 
 from ...util import PSORunner
 from ...util import GraphGenerator
 from ...util.CTkToolTip import CTkToolTip as ctt
+import customtkinter
+
+from . import OptimalParameterView as opv
 
 def create_tab(self, tab):
     
     # URL
     tab.grid_columnconfigure(0, weight=1)
-    tab.grid_rowconfigure(0, weight=1)
-    tab.grid_rowconfigure(1, weight=200)
-    
-    """
-    self.url = customtkinter.CTkEntry(tab, textvariable=self.option_manager.get_arguments()['url'])
-    self.url.grid(row=0, column=0, columnspan=1, padx=(20, 20), pady=(20, 20), sticky="nsew")
+    tab.grid_columnconfigure(1, weight=5)
+    tab.grid_columnconfigure(2, weight=1)
+    tab.grid_rowconfigure(0, weight=200)
 
-    self.run_button = customtkinter.CTkButton(tab, text="Run", command=self.run)
-    self.run_button.grid(row=0, column=1, padx=(20, 20), pady=(20, 20), sticky="nsew")
-    ctt(self.run_button, delay=0.5, message="Start calibration...")
-    
-        self.stop_button = customtkinter.CTkButton(tab, text="Stop", command=self.stop)
-    self.stop_button.grid(row=0, column=2, padx=(20, 20), pady=(20, 20), sticky="nsew")
-    ctt(self.stop_button, delay=0.5, message="Stop calibration...")
-    
-    """
-    
-    self.progress_container = customtkinter.CTkFrame(tab)
-    self.progress_container.grid_columnconfigure(0, weight=1)
-    self.progress_container.grid_columnconfigure(1, weight=1)
-    self.progress_container.grid_columnconfigure(2, weight=1)
-    self.progress_container.grid(row=0, column=0, padx=(20, 20), pady=(20, 20), sticky="nsew")
+    #self.progress_container = customtkinter.CTkFrame(tab)
+    #self.progress_container.grid_columnconfigure(0, weight=1)
+    #self.progress_container.grid_columnconfigure(1, weight=1)
+    #self.progress_container.grid_columnconfigure(2, weight=1)
+    #self.progress_container.grid(row=0, column=0, padx=(20, 20), pady=(20, 20), sticky="nsew")
     
     # Add progress bar to progress container
-    self.progress_message_left = customtkinter.CTkLabel(self.progress_container, text="")
-    self.progress_message_left.grid(row=0, column=0, padx=(10, 10), pady=(10, 10), sticky="w")
-    
-    self.progress_message_middle = customtkinter.CTkLabel(self.progress_container, text="Calibration not running...")
-    self.progress_message_middle.grid(row=0, column=1, padx=(10, 10), pady=(10, 10), sticky="ew")
+    #self.progress_message_left = customtkinter.CTkLabel(self.progress_container, text="")
+    #self.progress_message_left.grid(row=0, column=0, padx=(10, 10), pady=(10, 10), sticky="w")
     
-    self.progress_message_right = customtkinter.CTkLabel(self.progress_container, text="")
-    self.progress_message_right.grid(row=0, column=2, padx=(10, 10), pady=(10, 10), sticky="e")
+    #self.progress_message_middle = customtkinter.CTkLabel(self.progress_container, text="Calibration not running...")
+    #self.progress_message_middle.grid(row=0, column=1, padx=(10, 10), pady=(10, 10), sticky="ew")
     
-    #self.progress_bar = customtkinter.CTkProgressBar(self.progress_container)
-    #self.progress_bar.grid(row=1, column=0, columnspan=3, padx=(10, 10), pady=(10, 10), sticky="ew")
-    #self.progress_bar.set(0)
-    #ctt(self.progress_bar, delay=0.5, message="Current calibration progress")
+    #self.progress_message_right = customtkinter.CTkLabel(self.progress_container, text="")
+    #self.progress_message_right.grid(row=0, column=2, padx=(10, 10), pady=(10, 10), sticky="e")
     
+    self.optimal_param_frame = opv.OptimalParameterView(tab, option_manager=self.option_manager, label_text="Optimal Parameters")
+    self.optimal_param_frame.grid(row=0, column=0, padx=(20, 20), pady=(20, 20), sticky="nsew")
+    self.optimal_param_frame.grid_columnconfigure(0, weight=1)
+    self.optimal_param_frame.grid_rowconfigure(0, weight=1)
+
     self.textbox = customtkinter.CTkTextbox(tab)
-    self.textbox.grid(row=1, column=0, padx=(20, 20), pady=(20, 20), sticky="nsew")
-    self.textbox.insert("0.0", "Welcome to the CSIP PSO Calibration Tool!\n\nUse the Calibration tab to define steps and calibration parameters. Use this tab to run and observe calibration progress. Once finished, use the Visualization tab to generate figures and graphs.")
-        
+    self.textbox.grid(row=0, column=1, padx=(20, 20), pady=(20, 20), sticky="nsew")
+    self.textbox.insert("0.0", "Welcome to the CSIP PSO Calibration Tool!\n\nUse the Setup tab to define steps and calibration parameters. Use this tab to view logs and manage your Project. Once finished, use the Results tab to generate figures and graphs.")
+        
+    self.project_editor = customtkinter.CTkScrollableFrame(tab, label_text="Project Editor")
+    self.project_editor.grid(row=0, column=2, padx=(20, 20), pady=(20, 20), sticky="nsew")
+    self.project_editor.grid_columnconfigure(0, weight=1)
+    self.project_editor.grid_rowconfigure(0, weight=1)
+
+    customtkinter.CTkLabel(self.project_editor, text="Copy Data to Current Mode:").grid(row=0, column=0, padx=(20, 20), pady=(5, 10), sticky="ew")
+
+    def copy_sense():
+        self.option_manager.copy_list("Sensitivity Analysis")
+        self.refresh_step_view(0)
+
+    def copy_halton():
+        self.option_manager.copy_list("Sampling: Halton")
+        self.refresh_step_view(0)
+    
+    def copy_random():
+        self.option_manager.copy_list("Sampling: Random")
+        self.refresh_step_view(0)
+
+    def copy_optim():
+        self.option_manager.copy_list("Optimization")
+        self.refresh_step_view(0)
+
+    def open_project_folder():
+        # Open the file in the default program
+        folder = self.option_manager.get_project_folder()
+        
+        if not os.path.exists(folder):
+            os.makedirs(folder)
+        
+        if platform.system() == "Windows":
+            os.startfile(folder)
+        elif platform.system() == "Darwin":
+            subprocess.Popen(["open", folder])
+        else:
+            subprocess.Popen(["xdg-open", folder])
+
+    self.halton_copy = customtkinter.CTkButton(self.project_editor, text="From Sampling: Halton", command=copy_halton)
+    self.halton_copy.grid(row=1, column=0, padx=(20, 20), pady=(5, 10), sticky="ew")
+
+    self.random_copy = customtkinter.CTkButton(self.project_editor, text="From Sampling: Random", command=copy_random)
+    self.random_copy.grid(row=2, column=0, padx=(20, 20), pady=(5, 10), sticky="ew")
+
+    self.analysis_copy = customtkinter.CTkButton(self.project_editor, text="From Sensitivity Analysis", command=copy_sense)
+    self.analysis_copy.grid(row=3, column=0, padx=(20, 20), pady=(5, 10), sticky="ew")
+
+    self.optimization_copy = customtkinter.CTkButton(self.project_editor, text="From Optimization", command=copy_optim)
+    self.optimization_copy.grid(row=4, column=0, padx=(20, 20), pady=(5, 10), sticky="ew")
+
+    customtkinter.CTkLabel(self.project_editor, text="Project Management:").grid(row=5, column=0, padx=(20, 20), pady=(5, 10), sticky="ew")
+
+    self.open_folder = customtkinter.CTkButton(self.project_editor, text="Open Project Folder", command=open_project_folder)
+    self.open_folder.grid(row=6, column=0, padx=(20, 20), pady=(5, 10), sticky="ew")
+
+    customtkinter.CTkLabel(self.project_editor, text="Project Name:").grid(row=7, column=0, padx=(20, 20), pady=(10, 5), sticky="ew")
+    self.project_name_label = customtkinter.CTkLabel(self.project_editor, text=self.option_manager.get_project_data()["name"])
+    self.project_name_label.grid(row=8, column=0, padx=(20, 20), pady=(5, 10), sticky="ew")
+
+    customtkinter.CTkLabel(self.project_editor, text="Project Path:").grid(row=9, column=0, padx=(20, 20), pady=(10, 5), sticky="ew")
+    self.project_path_label = customtkinter.CTkLabel(self.project_editor, text=self.option_manager.get_project_data()["path"])
+    self.project_path_label.grid(row=10, column=0, padx=(20, 20), pady=(5, 10), sticky="ew")

mgpsogui/gui/SetupTab/BoundsEditorWindow.py

@@ -54,7 +54,7 @@ class BoundsEditorWindow(CTkInputDialog):
                                         hover_color=self._button_hover_color,
                                         text_color=self._button_text_color,
                                         text='Cancel',
-                                        command=self._ok_event)
+                                        command=self._cancel_event)
         self._cancel_button.grid(row=2, column=1, columnspan=1, padx=(10, 20), pady=(0, 20), sticky="ew")
         
     def _ok_event(self, event=None):

mgpsogui/gui/SetupTab/BoundsList.py

@@ -13,6 +13,8 @@ import json
 import PIL
 from PIL import Image
 import os
+import pandas as pd
+from tkinter.filedialog import askopenfilename
 
 class BoundsList(CTkFrame):
     def __init__(self, *args,
@@ -21,20 +23,8 @@ class BoundsList(CTkFrame):
                  **kwargs):
         super().__init__(*args, **kwargs)
         
-        self.optParams = []
         self.option_manager = option_manager
 
-        details = self.option_manager.get_service_parameters()
-        self.paramMap = {}
-        if "parameter" in details:
-            for param in details["parameter"]:
-                self.paramMap[param["name"]] = param
-                if "min" in param:
-                    self.optParams.append(param["name"])
-                    
-            self.optParams.sort()
-        
-
         self.edit_mode = False
         self.tooltip_list = []
         
@@ -62,6 +52,34 @@ class BoundsList(CTkFrame):
         index = 0
         
         self.tooltip_list = []
+
+        mode = self.option_manager.get_mode()
+
+        # Load bound parameters depending on the mode
+        self.optParams = []
+        if mode == "Optimization" or mode == "Sampling: Halton" or mode == "Sampling: Random":
+            details = self.option_manager.serialize_data(self.option_manager.get("service_request_data"))
+            self.paramMap = {}
+            if "parameter" in details:
+                for param in details["parameter"]:
+                    self.paramMap[param["name"]] = param
+                    if "min" in param:
+                        self.optParams.append(param["name"])
+                        
+                self.optParams.sort()
+        elif mode == "Sensitivity Analysis":
+            file_path = self.option_manager.get("sensitivity_analysis_path").get()
+            folder = self.option_manager.get_project_folder()
+            file_path = os.path.join(folder, "results", file_path)
+            if os.path.exists(file_path):
+                try:
+                    df = pd.read_csv(file_path)
+                    self.optParams = df.columns.tolist()
+                except Exception as e:
+                    print(f"Error loading CSV file: {e}")
+            else:
+                print(f"File does not exist: {file_path}")
+
         
         self.containerFrame = CTkFrame(self, fg_color="transparent")
         self.containerFrame.grid(row=0, column=0, padx=(5, 5), pady=(5, 5), sticky="nsew")
@@ -71,12 +89,16 @@ class BoundsList(CTkFrame):
         
         CTkLabel(self.containerFrame, text="Type:").grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="nsew")
         CTkLabel(self.containerFrame, text="Name:").grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="nsew")
-        CTkLabel(self.containerFrame, text="Bounds:").grid(row=row, column=2, columnspan=2, padx=(5, 5), pady=(5, 5), sticky="nsew")
-        CTkLabel(self.containerFrame, text="Default:").grid(row=row, column=4, padx=(5, 5), pady=(5, 5), sticky="nsew")
-        CTkLabel(self.containerFrame, text="Strategy:").grid(row=row, column=5, padx=(5, 5), pady=(5, 5), sticky="nsew")
+
+        if mode != "Sensitivity Analysis":
+            CTkLabel(self.containerFrame, text="Bounds:").grid(row=row, column=2, columnspan=2, padx=(5, 5), pady=(5, 5), sticky="nsew")
+
+            if mode == "Optimization":
+                CTkLabel(self.containerFrame, text="Default:").grid(row=row, column=4, padx=(5, 5), pady=(5, 5), sticky="nsew")
+                CTkLabel(self.containerFrame, text="Strategy:").grid(row=row, column=5, padx=(5, 5), pady=(5, 5), sticky="nsew")
         row += 1
         
-        bounds = self.option_manager.get_steps()[self.step_index]["param"]
+        bounds = self.option_manager.get_steps()[self.step_index]["parameter_objects"]
         
         for bound in bounds:
             tt1 = None
@@ -112,34 +134,53 @@ class BoundsList(CTkFrame):
                 bb.grid(row=row, column=2, padx=(5, 5), pady=(5, 5), sticky="new")
                 ctt(bb, delay=0.1, alpha=0.95, message="Delete this bound...")
             else:
+                
+                if mode == "Sensitivity Analysis":
+                    row += 1
+                    index += 1
+                    continue
+
                 bounds_min = CTkEntry(self.containerFrame)
                 vcmd = (self.register(self.validate_number), '%P', cc, bounds_min)
                 bounds_min.grid(row=row, column=2, padx=(5, 5), pady=(5, 5), sticky="new")
-                bounds_min.configure(textvariable=bound["bounds"][0], validate='all', validatecommand=vcmd)
+                bounds_min.configure(textvariable=bound["min_bound"], validate='all', validatecommand=vcmd)
                 self.validate_number(bounds_min.get(), cc, bounds_min)
                             
                 bounds_max = CTkEntry(self.containerFrame)
                 vcmd = (self.register(self.validate_number), '%P', cc, bounds_max)
                 bounds_max.grid(row=row, column=3, padx=(5, 5), pady=(5, 5), sticky="new")
-                bounds_max.configure(textvariable=bound["bounds"][1], validate='all', validatecommand=vcmd)
+                bounds_max.configure(textvariable=bound["max_bound"], validate='all', validatecommand=vcmd)
                 self.validate_number(bounds_max.get(), cc, bounds_max)
                 tt2 = ctt(bounds_max, delay=0.1, alpha=0.95, message="...")
                 
-                default_value = CTkEntry(self.containerFrame)
-                default_value.grid(row=row, column=4, padx=(5, 5), pady=(5, 5), sticky="new")
-                default_value.configure(textvariable=bound["default_value"])
-            
-                
                 if (bound_type == "list"):
                     def button_click_event(bound_index):
-                        dialog = BEW(title="Edit List Bound", step_index=self.step_index, bound_index=bound_index, option_manager=self.option_manager)
-                        print("Number:", dialog.get_input())
+                        BEW(title="Edit List Bound", step_index=self.step_index, bound_index=bound_index, option_manager=self.option_manager)
 
                     open_window = lambda event=None, bound_index=index: (button_click_event(bound_index))
                     expand_image = CTkImage(Image.open(os.path.join("./images", "expand.png")), size=(20, 20))
                     button = CTkButton(self.containerFrame, width=30, text=None, image=expand_image, command=open_window)
                     button.grid(row=row, column=6, padx=(5, 5), pady=(5, 5), sticky="new")
                 
+                if mode == "Sampling: Random" or mode == "Sampling: Halton":
+                    
+                    tt1 = ctt(bounds_min, delay=0.1, alpha=0.95, message="...")
+                    tt2 = ctt(bounds_max, delay=0.1, alpha=0.95, message="...")
+                    if cc is not None:
+                        tt3 = ctt(cc, delay=0.1, alpha=0.95, message="...")
+                            
+                    self.tooltip_list.append([tt3, tt1, tt2])
+                            
+                    self.update_tooltips(index)
+
+                    row += 1
+                    index += 1
+                    continue
+
+                default_value = CTkEntry(self.containerFrame)
+                default_value.grid(row=row, column=4, padx=(5, 5), pady=(5, 5), sticky="new")
+                default_value.configure(textvariable=bound["default_value"])
+
                 calibration_strat = CTkOptionMenu(self.containerFrame, dynamic_resizing=False, values=['none', 'mean', 'single'], variable=bound["calibration_strategy"])
                 calibration_strat.grid(row=row, column=5, padx=(5, 5), pady=(5, 5), sticky="new")
                 
@@ -161,26 +202,48 @@ class BoundsList(CTkFrame):
                 CTkButton(self.containerFrame, text="Exit", command=self.toggle_edit_mode).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="new")
             else:
                 CTkButton(self.containerFrame, text="Edit", command=self.toggle_edit_mode).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="new")
-            CTkButton(self.containerFrame, text="Add Bound", command=add_func).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="new")
-        else:
-            CTkButton(self.containerFrame, text="Add Bound", command=add_func).grid(row=row, column=0, columnspan=2, padx=(5, 5), pady=(5, 5), sticky="new")
+        
+        CTkButton(self.containerFrame, text="Add Bound", command=add_func).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="new")
+
+        def import_csv():
+            filename = askopenfilename(filetypes=[("CSV", "*.csv")], title="Open Bound CSV", multiple=False)
+            print(filename)
+
+            # Open CSV file
+            if filename is not None and filename != "":
+                df = pd.read_csv(filename)
+                for _, row in df.iterrows():
+                    if "name" not in row:
+                        continue
+                    name = row["name"] if "name" in row else "name"
+                    type_ = row["type"] if "type" in row else "custom"
+                    min_bound = row["min_bound"] if "min_bound" in row else 0
+                    max_bound = row["max_bound"] if "max_bound" in row else 1
+                    default_value = row["default_value"] if "default_value" in row else 1
+                    calibration_strategy = row["calibration_strategy"] if "calibration_strategy" in row else "none"
+                    self.option_manager.add_bound(step_index=self.step_index, name=name, min=min_bound, max=max_bound, type=type_, default_value=default_value, calibration_strategy=calibration_strategy)
+
+            self.clear()
+            self.render()
+
+        CTkButton(self.containerFrame, text="Import CSV", command=import_csv).grid(row=row, column=2, padx=(5, 5), pady=(5, 5), sticky="new")
             
     def update_type(self, index, option):
         value = option.get()
-        self.option_manager.get_steps()[self.step_index]["param"][index]["type"].set(value)
+        self.option_manager.get_steps()[self.step_index]["parameter_objects"][index]["type"].set(value)
         self.refresh()
             
     def update_values(self, index):
-        name = self.option_manager.get_steps()[self.step_index]["param"][index]["name"].get()
+        name = self.option_manager.get_steps()[self.step_index]["parameter_objects"][index]["name"].get()
         if name in self.paramMap:
             obj = self.paramMap[name]
-            self.option_manager.get_steps()[self.step_index]["param"][index]["bounds"][0].set(obj["softmin"])
-            self.option_manager.get_steps()[self.step_index]["param"][index]["bounds"][1].set(obj["softmax"])
+            self.option_manager.get_steps()[self.step_index]["parameter_objects"][index]["min_bound"].set(obj["softmin"])
+            self.option_manager.get_steps()[self.step_index]["parameter_objects"][index]["max_bound"].set(obj["softmax"])
             
     def update_tooltips(self, index):
         try:
-            name = self.option_manager.get_steps()[self.step_index]["param"][index]["name"].get()
-            bound_type = self.option_manager.get_steps()[self.step_index]["param"][index]["type"].get()
+            name = self.option_manager.get_steps()[self.step_index]["parameter_objects"][index]["name"].get()
+            bound_type = self.option_manager.get_steps()[self.step_index]["parameter_objects"][index]["type"].get()
             
             tooltips = self.tooltip_list[index]
             t3 = tooltips[0]

mgpsogui/gui/SetupTab/CustomFunctionEditorWindow.py

@@ -0,0 +1,74 @@
+from typing import Union, Tuple, Optional
+
+from customtkinter import CTkLabel
+from customtkinter import CTkButton
+from customtkinter import CTkEntry
+from customtkinter import CTkInputDialog
+from .CustomFunctionMetrics import CustomFunctionsMetricsView as ListView
+
+class CustomFunctionEditorWindow(CTkInputDialog):
+    """
+    Dialog with extra window, message, entry widget, cancel and ok button.
+    For detailed information check out the documentation.
+    """
+
+    def __init__(self, *args,
+                 step_index: 0,
+                 function_index: 0,
+                 option_manager: None,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
+        
+        self.geometry("400x800")
+        
+        self.step_index = step_index
+        self.function_index = function_index  
+        self.option_manager = option_manager
+        self.bounds = None
+
+    def _create_widgets(self):
+
+        self.grid_columnconfigure((0, 1), weight=1)
+        self.rowconfigure(0, weight=1)
+
+        self.bounds = ListView(
+                self, step_index=self.step_index, function_index=self.function_index, option_manager=self.option_manager)
+        self.bounds.grid(row=0, column=0, columnspan=2, padx=(10, 10),
+                    pady=(10, 10), sticky="nsew")
+        self.bounds.grid_columnconfigure(0, weight=1)
+
+        self._ok_button = CTkButton(master=self,
+                                    width=100,
+                                    border_width=0,
+                                    fg_color=self._button_fg_color,
+                                    hover_color=self._button_hover_color,
+                                    text_color=self._button_text_color,
+                                    text='Save',
+                                    command=self._ok_event)
+        self._ok_button.grid(row=2, column=0, columnspan=1, padx=(20, 10), pady=(0, 20), sticky="ew")
+
+        self._cancel_button = CTkButton(master=self,
+                                        width=100,
+                                        border_width=0,
+                                        fg_color=self._button_fg_color,
+                                        hover_color=self._button_hover_color,
+                                        text_color=self._button_text_color,
+                                        text='Cancel',
+                                        command=self._cancel_event)
+        self._cancel_button.grid(row=2, column=1, columnspan=1, padx=(10, 20), pady=(0, 20), sticky="ew")
+        
+    def _ok_event(self, event=None):
+        # Save values in bounds editor...
+        
+        self.bounds.push_to_option_manager()
+        
+        self.grab_release()
+        self.destroy()
+
+    def _on_closing(self):
+        self.grab_release()
+        self.destroy()
+
+    def _cancel_event(self):
+        self.grab_release()
+        self.destroy()

mgpsogui/gui/SetupTab/CustomFunctionMetrics.py

@@ -0,0 +1,156 @@
+from customtkinter import CTkScrollableFrame
+from customtkinter import CTkFrame
+from customtkinter import CTkLabel
+from customtkinter import CTkButton
+from customtkinter import CTkEntry
+from customtkinter import CTkOptionMenu
+import tkinter as tk
+import subprocess
+import platform
+import os
+
+global option_manager
+
+class CustomFunctionsMetricsView(CTkScrollableFrame):
+    def __init__(self, *args,
+                 option_manager: None,
+                 step_index: 0,
+                 function_index: 0,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
+        
+        self.option_manager = option_manager
+        self.step_index = step_index
+        self.functions_index = function_index
+        self.key_values = []
+        
+        self.edit_mode = False
+
+        self.columns = ["absdiff",
+                        "absdifflog",
+                        "ave",
+                        "bias",
+                        "fhf",
+                        "ioa",
+                        "ioa2",
+                        "kge",
+                        "kge09",
+                        "mns",
+                        "mse",
+                        "ns",
+                        "ns2log",
+                        "nslog1p",
+                        "nslog2",
+                        "pbias",
+                        "pmcc",
+                        "rmse",
+                        "trmse"]
+        
+        self.positive_best = {"absdiff": True,
+                        "absdifflog": True,
+                        "ave": True,
+                        "bias": True,
+                        "fhf": True,
+                        "ioa": True,
+                        "ioa2": True,
+                        "kge": True,
+                        "kge09": True,
+                        "mns": True,
+                        "mse": True,
+                        "ns": False,
+                        "ns2log": True,
+                        "nslog1p": True,
+                        "nslog2": True,
+                        "pbias": True,
+                        "pmcc": True,
+                        "rmse": True,
+                        "trmse": True}
+
+        equation = self.option_manager.get_steps()[self.step_index]["objective_functions"][self.functions_index]["custom_function"].get()
+        
+        # Example equation (0 * (1 - ns)) + (bias * 0) + (pbias * 0) + (absdiff * 0)
+        try:
+            if equation != "":
+                equation = equation.replace("1 - ", "")
+                equation = equation.replace("(", "")
+                equation = equation.replace(")", "")
+                equation = equation.replace(" ", "")
+                pairs = equation.split("+")
+                for pair in pairs:
+                    key, value = pair.split("*")
+                    self.add_key(key, value)
+        except Exception as e:
+            self.key_values = []
+
+        self.render()
+
+    def clear(self):
+        self.containerFrame.destroy()
+        
+    def toggle_edit_mode(self):
+        self.clear()
+        self.edit_mode = not self.edit_mode
+        self.render()
+        
+    def add_key(self, key="ns", value="0"):
+        obj = {"name": tk.StringVar(), "value": tk.StringVar()}
+        obj['name'].set(key)
+        obj['value'].set(value)
+        self.key_values.append(obj)
+        
+    def remove_key(self, index):
+        self.key_values.pop(index)
+        
+    def render(self):
+        row = 0
+        index = 0
+        
+        self.containerFrame = CTkFrame(self)
+        self.containerFrame.grid(row=0, column=0, padx=(5, 5), pady=(5, 5), sticky="nsew")
+        self.containerFrame.grid_columnconfigure((0, 1), weight=1)
+        
+        CTkLabel(self.containerFrame, text="Objective:").grid(row=row, column=0, columnspan=1, padx=5, pady=5, sticky="")
+        CTkLabel(self.containerFrame, text="Weight:").grid(row=row, column=1, columnspan=1, padx=5, pady=5, sticky="")
+        row += 1
+        
+        for key_value_pair in self.key_values:
+            CTkOptionMenu(self.containerFrame, values=self.columns, variable=self.key_values[index]["name"]).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
+
+
+            if self.edit_mode:
+                return_func = lambda index=index: (self.clear(), self.remove_key(index), self.render())
+                CTkButton(self.containerFrame, text="Remove", command=return_func).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")
+            else:
+                bb = CTkEntry(self.containerFrame)
+                bb.grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")
+                bb.configure(textvariable=self.key_values[index]["value"])
+            row += 1
+            index += 1
+            
+        if self.edit_mode:
+            CTkButton(self.containerFrame, text="Exit", command=self.toggle_edit_mode).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
+        else:
+            CTkButton(self.containerFrame, text="Edit", command=self.toggle_edit_mode).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
+            
+        add_key_func = lambda: (self.clear(), self.add_key(), self.render())
+        CTkButton(self.containerFrame, text="Add", command=add_key_func).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")
+        
+        row += 1
+        
+    def push_to_option_manager(self):
+        equation = ""
+
+        for key_value in self.key_values:
+            name = key_value["name"].get()
+            weight = key_value["value"].get()
+
+            positiveBest = self.positive_best[name]
+
+            if positiveBest:
+                equation += f"({name} * {weight}) + "
+            else:
+                equation += f"((1 - {name}) * {weight}) + "
+
+        equation = equation[:-3]  # Remove the last " + "
+
+        self.option_manager.get_steps()[self.step_index]["objective_functions"][self.functions_index]["custom_function"].set(equation)