chromaquant 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

chromaquant/__main__.py

@@ -16,7 +16,7 @@ License: BSD 3-Clause License
 SCRIPT FOR SIMPLIFYING ANALYSIS WORKFLOW
 
 Julia Hancock
-Started 01-04-2024
+Started 12-10-2024
 
 """
 
@@ -27,11 +27,13 @@ from tkinter import ttk
 from ttkthemes import ThemedTk
 import tkinter.font as tkFont
 import os
-import subprocess
 import sys
 from PIL import Image, ImageTk
 from datetime import datetime
 import importlib.util
+import threading
+import time
+import json
 
 """ LOCAL PACKAGES """
 print("[__main__] Importing local packages...")
@@ -41,7 +43,9 @@ file_dir = os.path.dirname(os.path.abspath(__file__))
 subpack_dir = {'Handle':os.path.join(file_dir,'Handle','__init__.py'),
                'Manual':os.path.join(file_dir,'Manual','__init__.py'),
                'Match':os.path.join(file_dir,'Match','__init__.py'),
-               'Quant':os.path.join(file_dir,'Quant','__init__.py')}
+               'Quant':os.path.join(file_dir,'Quant','__init__.py'),
+               'UAPP':os.path.join(file_dir,'UAPP','__init__.py'),
+               'Hydro':os.path.join(file_dir,'Hydro','__init__.py')}
 
 #Define function to import from path
 def import_from_path(module_name,path):
@@ -60,14 +64,17 @@ hd = import_from_path("hd",subpack_dir['Handle'])
 mn = import_from_path("mn",subpack_dir['Manual'])
 qt = import_from_path("qt",subpack_dir['Quant'])
 mt = import_from_path("mt",subpack_dir['Match'])
+ua = import_from_path("ua",subpack_dir['UAPP'])
+#hy = import_from_path("hy",subpack_dir['Hydro'])
 
 """ PARAMETERS """
 print("[__main__] Defining parameters...")
-version = "0.3.1"
-__version__ = "0.3.1"
+__version__ = "0.4.0"
+version = "0.4.0"
 
-""" UI FUNCTION """
+""" RUNUI FUNCTION """
 
+#Function to run the UI
 def runUI():
 
     """ DIRECTORIES """
@@ -75,419 +82,445 @@ def runUI():
     print("[__main__] Using Handle package...")
     #Get directories from handling script
     directories = hd.handle(os.path.dirname(os.path.abspath(__file__)))
-    #Unpack directories
-    #Primary files directory
-    files = directories['files']
-    #Resources directory
-    RE_Dir = directories['resources']
-    #Theme directory
-    theme_Dir = directories['theme']
-    #Response factor directory
-    RF_Dir = directories['rf']
-    #Data directory
-    DF_Dir = directories['data']
-    #Images directory
-    img_Dir = directories['images']
-    #AutoFpmMatch directory + file
-    afm_Dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),'AutoFpmMatch.py')
-    #AutoQuantification directory + file
-    aq_Dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),'AutoQuantification.py')
-    
+
     """ DATA SEARCH """
     print("[__main__] Searching for valid data files...")
     #Get a list of all available sample data directories (excluding "old") in the data files directory
-    sampleList = [f.name for f in os.scandir(DF_Dir) if f.is_dir() if f.name != "old"]
-      
-    """ FUNCTIONS """
-    print("[__main__] Defining functions...")
-    #Function for setting up the UI
-    def uiSetup(theme_Dir):
-        
-        #Initialize UI window
-        root = ThemedTk(theme='adapta')
-    
-        # Import the tcl file with the tk.call method
-        root.tk.call('source', theme_Dir)
-    
-        # Set the theme with the theme_use method
-        style = ttk.Style(root)
-        style.theme_use('forest-light')
-        #Set up style button font
-        style.configure('QuantButton.TButton',font=('TKDefaultFont',16))
-        #Set up style accent button font
-        style.configure('Accent.TButton',font=('TKDefaultFont',16))
-        #Set up labelframe font
-        style.configure('QuantLabelframe.TLabelframe.Label',font=('TKDefaultFont',16))
-    
-        root.geometry("1090x560")
-        root.title("ChromaQuant – Quantification Made Easy")
-        root.resizable(0,0)
-    
-        #style.theme_use('forest')
-        #Configure the grid
-        root.columnconfigure(0,weight=2)
-        root.columnconfigure(1,weight=2)
-        root.columnconfigure(2,weight=2)
-        root.columnconfigure(3,weight=2)
-    
-        #Create a main frame
-        mainframe = ttk.Frame(root)
-        mainframe.grid(column=0,row=0)
-        
-        return root, mainframe
-    #Function for sample selection combobox
-    def on_select(event):
-        
-       sname = sampleBox.get()
-       print("User selected "+sampleBox.get())
-       return sname
-    
-    #Function for fidpms phase selection combobox
-    def fidpms_select():
-        
-        sphase = fpmVar.get()
-        print("User selected " + sphase)
-        
-        if sphase == "Liquid":
-            #Set variable to first order
-            fpmMVar.set('First order (linear)')
-            #Disable third order
-            third.config(state=tk.DISABLED)
-        else:
-            third.config(state=tk.NORMAL)
-        
-        return sphase
-    
-    #Function for model selection combobox
-    def fidpms_select_model():
-        
-        model = fpmMVar.get()
-        print("User selected " + model)
-        
-        return model
+    sampleList = [f.name for f in os.scandir(directories['data']) if f.is_dir() if f.name != "old"]
+
+    """ CODE """
+    #Define ChromaQuantUI as class
+    class chromaUI:
+
+        #Key variables = sampleVar, fpm_typevar, fpm_modelvar, quant_typevar, quant_modelvar, hydro_typevar
+        #Initialization function – master here will be our root widget
+        def __init__(self, master, directories):
+
+            self.master = master
+            self.directories = directories
+
+            #ANALYSIS CONFIGURATION
+            print("[__main__] Interpreting analysis configuration...")
+            #Read analysis configuration file
+            with open(os.path.join(self.directories['resources'],'analysis-config.json')) as f:
+                self.analysis_config = json.load(f)
+
+            #Extract analysis configuration info
+            #File suffixes to add to form data filenames
+            self.file_suffix_list = [i[0] for i in list(self.analysis_config["file-suffix"].values())]
+
+            #Standard padding
+            self.std_padx = 10
+            self.std_pady = 10
+
+            #Padding for widgets/widget rows
+            self.widget_padx = 20
+            self.widget_pady = 20
+
+            #Initialize user variable dictionary
+            self.var_dict = {}
+            #Initialize user variable entries
+            self.var_dict['sampleVar'] = tk.StringVar()
+            self.var_dict['fpm_typevar'] = tk.StringVar()
+            self.var_dict['fpm_modelvar'] = tk.StringVar()
+            self.var_dict['quant_typevar'] = tk.StringVar()
+            self.var_dict['quant_modelvar'] = tk.StringVar()
+            self.var_dict['hydro_typevar'] = tk.StringVar()
+            self.var_dict['hydro_matchvar'] = tk.StringVar()
+
+            #Initialize list of variables to have an anonymous printing function
+            self.varSelect_list = ['sampleVar','fpm_typevar','fpm_modelvar','quant_modelvar','hydro_typevar','hydro_matchvar']
+
+            #Initialize radiobutton object dictionary
+            self.radio_dict = {}
+
+            #Setup UI
+            self.setupUI()
+
+            #Create font objects
+            self.title_font = tkFont.Font(size=18,weight='bold')   #Title font
+            
+            #SETUP SELECT FUNCTIONS
+            self.setupVarSelect()
+
+            #IMAGE AND TITLE
+            #Add a frame for the logo and title/sample info
+            self.topFrame = ttk.Frame(self.mainframe)
+            self.topFrame.grid(column=0,row=0,sticky='WE')
+            self.topFrame.grid_columnconfigure((0,3),weight=1)
+            self.setupTitle()
+
+            #WIDGETS
+            #Add a frame for the first row of widgets
+            self.rowoneFrame = ttk.Frame(self.mainframe)
+            self.rowoneFrame.grid(column=0,row=1,sticky='WE')
+            self.rowoneFrame.grid_columnconfigure((0,4),weight=1)
+
+            #Add a frame for the second row of widgets
+            self.rowtwoFrame = ttk.Frame(self.mainframe)
+            self.rowtwoFrame.grid(column=0,row=2,sticky='WE')
+            self.rowtwoFrame.grid_columnconfigure((0,4),weight=1)
+
+            #FILE TRACKING
+            #Add a frame for tracking data files
+            self.trackFrame = ttk.LabelFrame(self.rowoneFrame,text='File Tracking',style='QuantLabelframe.TLabelframe')
+            self.trackFrame.grid(column=1,row=0,sticky='NSWE',padx=self.widget_padx,pady=self.widget_pady)
+            self.setupFileTrack()
+
+            #UNKNOWNS ANALYSIS POSTPROCESS
+            #Add a frame for the UA_UPP script
+            self.uppFrame = ttk.LabelFrame(self.rowoneFrame,text='Unknowns Analysis Postprocessing',style='QuantLabelframe.TLabelframe')
+            self.uppFrame.grid(column=2,row=0,sticky='NSWE',padx=(0,self.widget_padx),pady=self.widget_pady)
+            self.setupUPP()
+            #padx=self.widget_padx,pady=self.widget_pady
+            
+            #FIDpMS MATCHING
+            #Add a frame for the main matching script
+            self.matchFrame = ttk.LabelFrame(self.rowoneFrame,text='Peak Matching',style='QuantLabelframe.TLabelframe')
+            self.matchFrame.grid(column=3,row=0,sticky='NSWE',padx=(0,self.widget_padx),pady=self.widget_pady)
+            self.setupMatch()
+
+            #QUANTIFICATION
+            #Add a frame for the main quantification script
+            self.quantFrame = ttk.LabelFrame(self.rowtwoFrame,text='Quantification',style='QuantLabelframe.TLabelframe')
+            self.quantFrame.grid(column=1,row=0,sticky='NSWE',padx=self.widget_padx,pady=(0,self.widget_pady))
+            self.setupQuant()
+
+            #HYDROUI
+            #Add a frame for the hydroUI script
+            self.hydroFrame = ttk.LabelFrame(self.rowtwoFrame,text='HydroUI (WIP)',style='QuantLabelframe.TLabelframe')
+            self.hydroFrame.grid(column=2,row=0,sticky='NSWE',padx=(0,self.widget_padx),pady=(0,self.widget_pady))
+            self.setupHydro()
+
+        def default(self):
+            print("[__main__][TEST] Testing message")
         
-    #Function for fidpms speculative labeling combobox
-    def fidpms_select2():
+        def setupUI(self):
         
-        specLabTF = fpm2Var.get()
-        print("User selected " + specLabTF)
-    
-        return specLabTF
-    
-    #Function for quant phase selection combobox
-    def quant_select(event):
+            # Import the tcl file with the tk.call method
+            self.master.tk.call('source', self.directories['theme'])
         
-        global quantphases
-        quantphases = logBox.get
-    
-    #Function for running method functions
-    def runProcess(sname,pythonFun,varList):
-        """
-        Function that runs an external main function
-        Parameters
-        ----------
-        sname : String
-            Name of sample to be analyzed.
-        pythonFun : Function
-            Function to be run.
-        varList : List
-            List of reformatted variables to be passed to the function.
-    
-        Returns
-        -------
-        None.
-    
-        """
-        #Start time for execution time
-        exec_start = datetime.now()
-        #Insert sname at the beginning of the variables list
-        varList.insert(0,sname)
-        #Run the method function
-        pythonFun(*varList)
-        #End time for execution time
-        exec_end = datetime.now()
-        #Execution time
-        exec_time = (exec_end-exec_start).total_seconds()*10**3
-        print("Time to execute: {:.03f}ms".format(exec_time))
-        print("Program complete")
+            # Set the theme with the theme_use method
+            style = ttk.Style(root)
+            style.theme_use('forest-light')
+            #Set up style button font
+            style.configure('QuantButton.TButton',font=('Arial',16))
+            #Set up style accent button font
+            style.configure('Accent.TButton',font=('Arial',16))
+            #Set up labelframe font
+            style.configure('QuantLabelframe.TLabelframe.Label',font=('Arial',16))
+            #Set up labelframe border
+            style.configure('QuantLabelframe.TLabelframe',borderwidth=5,bordercolor='red')
+            #Set up file tracking text font
+            self.fileTrackFont = tkFont.Font(size=14)
         
-        return None
-    
-    #Function for running FIDpMS script
-    def runFIDpMS(sname,specLabTF,sphase,model):
-        """
-        Parameters
-        ----------
-        sname : STRING
-            Name of sample to be analyzed.
-        specLabTF : STRING
-            True/false string describing whether speculative labeling is to be performed.
-        sphase : TYPE
-            String describing whether liquid or gas is to be performed.
-        model : TYPE
-            String describing which model is to be performed.
-    
-        Returns
-        -------
-        NONE
-    
-        """
+            #root.geometry("890x1000")
+            root.title("ChromaQuant – Quantification Made Easy")
         
-        #Function for reformatting provided variables
-        def reformatVar(var_initial,ifTF_list):
-            """
-            Parameters
-            ----------
-            var_initial : STRING, BOOLEAN
-                The initial variable to be reformatted.
-            ifTF_list : LIST
-                A list containing two lists, the first containing the variable options and the second containing reformatted values.
-    
-            Returns
-            -------
-            var_final : STRING
-                The final, reformatted variable.
-    
-            """
+            #Create a main frame
+            self.mainframe = ttk.Frame(root)
+            self.mainframe.grid(column=0,row=0)
+
+        def setupTitle(self):
+
+            #Add a frame for the ChromaQuant logo
+            self.logoFrame = ttk.Frame(self.topFrame)
+            self.logoFrame.grid(column=1,row=0,sticky='WE')
             
-            #Set default value of reformatted value
-            var_final = "N/A"
+            #Add a frame for the title text and sample selection
+            self.tsFrame = ttk.Frame(self.topFrame)
+            self.tsFrame.grid(column=2,row=0,sticky='E')
+
+            #Add title text
+            tk.Label(self.tsFrame,text="ChromaQuant v"+version,font=self.title_font)\
+                .grid(column=0,row=0,pady=self.std_pady,padx=self.std_padx)
             
-            #Get the length of the variable option list
-            listLength = len(ifTF_list[0])
+            #Add an image for the ChromaQuant logo
+            #Load the image
+            self.image_i = Image.open(os.path.join(self.directories['images'],'ChromaQuantIcon.png'))
+            #Resize the image
+            self.resize_image = self.image_i.resize((100,100))
+            #Redefine the image
+            self.image = ImageTk.PhotoImage(self.resize_image)
+            #Add the image to a label
+            image_label = tk.Label(self.logoFrame, image=self.image)
+            image_label.grid(column=0,row=0,pady=10,padx=10)
+
+            #Add a frame for selecting the sample
+            sampleFrame = ttk.Frame(self.tsFrame)
+            sampleFrame.grid(column=0,row=1,pady=10,padx=10)
             
-            #For every entry in the variable option list...
-            for i in range(listLength):
-                
-                #If the variable is equal to the ith variable option...
-                if var_initial == ifTF_list[0][i]:
-                    #Assign the variable to the first reformatted value
-                    var_final = ifTF_list[1][i]
-                #Otherwise, pass
-                else:
-                    pass
-    
-            return var_final
-        
-        #A dictionary containing the ifTF_lists for every passed variable
-        ifTF_Dict = {'specLabTF':[[1,0],['True','False']],'sphase':[['Gas','Liquid'],['G','L']],'model':[['First order (linear)','Third order','Retention time'],['F','T','R']]}
-        
-        #A dictionary of all passed variables excluding sname
-        passed_dict = {'sphase':sphase,'specLabTF':specLabTF,'model':model}
+            #Add text to the top of the sample frame
+            tk.Label(sampleFrame,text='Select a sample to analyze:').grid(column=0,row=0)
+            self.var_dict['sampleVar'] = tk.StringVar()
+            self.sampleBox = ttk.Combobox(sampleFrame,textvariable=self.var_dict['sampleVar'])
+            self.sampleBox['values'] = sampleList
+            self.sampleBox.state(["readonly"])
+            self.sampleBox.grid(column=0,row=1)
         
-        print("User selected sample name {0} with phase {2} and entered {1} for running speculative labeling. Modeling is {3}".format(sname,specLabTF,sphase,model))
+            #Bind the sampleBox to a function
+            self.sampleBox.bind("<<ComboboxSelected>>",self.sampleSelect)
         
-        #A dictionary for all reformatted variables
-        reformatVar_dict = {}
-        
-        #A dictionary of booleans describing whether or not values in reformatVar_dict are "N/A"
-        reformatBool_dict = {}
-        
-        #Reformat all variables
-        for i in passed_dict.keys():
+        def setupFileTrack(self):
+
+            #Create text window, place in grid
+            self.fileTrack_Text = tk.Text(self.trackFrame, height=12, width=20, fg='black', font=self.fileTrackFont)
+            self.fileTrack_Text.grid(column=0,row=0,padx=20,pady=10,sticky='NSWE')
+            #Set text config to NORMAL
+            self.fileTrack_Text.config(state=tk.NORMAL)
+            #Configure text options
+            #Option for default text
+            self.fileTrack_Text.tag_config('default', background="white", foreground="black")
+            #Option for present file
+            self.fileTrack_Text.tag_config('true', background="white", foreground='green')
+            #Option for file not found
+            self.fileTrack_Text.tag_config('false', background="white", foreground='red')
+
+            #Create default options
+            for i in self.file_suffix_list:
+                self.fileTrack_Text.insert(tk.END,"\n{0}".format(i),'default')
+            
+        def updateFileTrack(self):
+
+            #Delete all text in file tracking widget
+            self.fileTrack_Text.delete(1.0,tk.END)
+
+            #Get list of files currently in data and raw data directory
+            self.rawDataFiles = [f.lower() for f in os.listdir(directories['raw']) if os.path.isfile(os.path.join(directories['raw'],f))]
+            self.dataFiles = [f.lower() for f in os.listdir(directories['sample']) if os.path.isfile(os.path.join(directories['sample'],f))]
             
-            #Print reformatted variable name
-            print("Reformatting " + i + "...")
-            #Reformat variable, append to dictionary
-            reformatVar_dict[i] = reformatVar(passed_dict[i],ifTF_Dict[i])
-            #Print resulting reformatted value
-            print("Variable has been reformatted to {0}".format(reformatVar_dict[i]))
+            #Loop through the data files to search for everything but the INFO file (last index)
+            for i in self.file_suffix_list[:-1]:
+
+                #If given file exists in list, color green
+                if (self.sname+i).lower() in self.rawDataFiles:
+                    self.fileTrack_Text.insert(tk.END,"\n{0}".format(i),'true')
+
+                #Otherwise, color red
+                else:
+                    self.fileTrack_Text.insert(tk.END,"\n{0}".format(i),'false')
+
+            #If last data file (INFO) exists in data files directory, color green
+            if (self.sname+self.file_suffix_list[-1]).lower() in self.dataFiles:
+                    self.fileTrack_Text.insert(tk.END,"\n{0}".format(self.file_suffix_list[-1]),'true')
             
-            #Check if reformatted variable is equal to "N/A". If it is, assign False
-            if reformatVar_dict[i] == "N/A":
-                reformatBool_dict[i] = False
-            #Otherwise, assign True
+            #Otherwise, color red
             else:
-                reformatBool_dict[i] = True
-        
-        #If any of the required fields are empty, pass
-        if False in list(reformatBool_dict.values()) or sname == "":
-            print("Cannot run FIDpMS script, one or more variables are not defined")
-            pass
-        
-        #Otherwise, run the FIDpMS script
-        else:
-            print("Running FIDpMS script...")
+                    self.fileTrack_Text.insert(tk.END,"\n{0}".format(self.file_suffix_list[-1]),'false')
+
+            print("[__main__] File tracking results updated...")
+
+        def setupUPP(self):
+
+            #Add start button
+            self.setupStartButton(self.uppFrame,[0,0],[20,20],1,self.runUPP)
+
+        def setupMatch(self):
+            
+            #Add a radiobutton set for selecting sample type
+            self.radio_dict['fpm_typevar'] = self.setupRadioButton(self.matchFrame,'Please select the sample type:',[0,1],[20,20],1,'fpm_typevar',{'Liquid':'L','Gas':'G'},self.select_dict['fpm_typevar'],'L')
+            #Add a radiobutton set for selecting match model
+            self.radio_dict['fpm_modelvar'] = self.setupRadioButton(self.matchFrame,'Please select the desired matching fit model:',[0,2],[20,20],1,'fpm_modelvar',{'Retention\nTime':'R','Polynomial':'P'},self.select_dict['fpm_modelvar'],'R')
+            #Add start button
+            self.setupStartButton(self.matchFrame,[0,3],[20,20],4,self.runMatch)
+
+        def setupQuant(self):
+            
+            #Add a radiobutton set for selecting sample type
+            self.radio_dict['quant_typevar'] = self.setupRadioButton(self.quantFrame,'Which components are present in the sample?',[0,1],[20,20],1,'quant_typevar',{'Liquid\nOnly':'L','Gas\nOnly':'G','Liquid\nand Gas':'LG'},self.quant_typevarSelect,'L')
             
-            try:
-                #Get list of reformatVar_dict values
-                reformatVar_list = list(reformatVar_dict.values())
-                print(reformatVar_list)
-                #Append list with directories list
-                reformatVar_list.append(directories)
-                print(reformatVar_list)
-                #Run subprocess
-                runProcess(sname,mt.main_AutoFpmMatch,reformatVar_list)
+            #Add a radiobutton set for selecting the gas quantification method
+            self.radio_dict['quant_modelvar'] = self.setupRadioButton(self.quantFrame,'Which method should be used to quantify gas phase products?',[0,2],[20,0],1,'quant_modelvar',{'CO2\nVolume':'C','Scale\nFactor':'S','Internal\nStandard':'I'},self.select_dict['quant_modelvar'],'Disabled')
+            
+            #Add start button
+            self.setupStartButton(self.quantFrame,[0,3],[20,20],4,self.runQuant)
+
+        def setupHydro(self):
+            
+            #Add a radiobutton set for selecting sample type
+            self.radio_dict['hydro_typevar'] = self.setupRadioButton(self.hydroFrame,'Which phase to analyze?',[0,1],[20,20],1,'hydro_typevar',{'Liquid':'L','Gas':'G'},self.select_dict['hydro_typevar'],'L')
+            #Add a radiobutton set for selecting sample type
+            self.radio_dict['hydro_matchvar'] = self.setupRadioButton(self.hydroFrame,'Display FID and MS matches?',[0,2],[20,20],1,'hydro_matchvar',{'Yes':'T','No':'F'},self.select_dict['hydro_matchvar'],'F')
+            #Add start button
+            self.setupStartButton(self.hydroFrame,[0,3],[20,20],4,self.runHydro)
+
+        def setupStartButton(self,frame,placement,pad,columnspan,function):
+
+            #Add a start button
+            ttk.Button(frame,text="\n\n\nRun Script\n\n\n",width=20,style='Accent.TButton',command=function)\
+                .grid(column=placement[0],row=placement[1],padx=pad[0],pady=pad[1],columnspan=columnspan)
+
+        def setupRadioButton(self,frame,label_text,placement,pad,columnspan,var_name,option_val_dict,function,init_state='Option Blank'):
+            
+            #placement = [column,row]
+            #pad = [padx,pady]
+            #var_dict = {'var_1':tk.StringVar(),...}
+            #var_name = 'var_1'
+            #text_val_dict = {'option_1':'value_1',...}
+
+            #Set up a radiobutton for selecting liquid or gas
+            #Add a label
+            tk.Label(frame,text=label_text).grid(column=placement[0],row=placement[1],padx=pad[0],pady=pad[1],columnspan=columnspan,sticky='e')
+
+            #Define current column as column to the right of label
+            current_col = placement[0] + 1
+            #Define radiobutton padding loop iterable
+            current_pad = 0
+            #Define list to iterate through for radiobutton padding
+            radiopad = [(10,10) for i in range(len(option_val_dict))]
+            radiopad[-1] = (10,20)
+
+            #Define list of radiobutton objects
+            dict_radiobutton = {i:0 for i in option_val_dict}
+
+            #For every option in the option-value dictionary, add a radiobutton (iterate over columns)
+            for option in option_val_dict:
+
+                #Store the radiobutton object
+                dict_radiobutton[option] = ttk.Radiobutton(frame , text=option , variable=self.var_dict[var_name] , value=option_val_dict[option] , command=function)
+                dict_radiobutton[option].grid(column=current_col , row=placement[1] , padx=radiopad[current_pad] , sticky='w')
                 
-            except subprocess.CalledProcessError as e:
-                print(f'Command {e.cmd} failed with error {e.returncode}')
+                #Iterate current column and radio padding list
+                current_col += 1
+                current_pad += 1
+
+            #Select the initial radiobutton state based on the init_state argument
+            #If init_state is 'Option Blank', select the first radiobutton
+            if init_state == 'Option Blank':
+                self.var_dict[var_name].set(next(iter(option_val_dict.values())))
+
+            #If init_state is 'Disabled', set the radiobuttons to be disabled
+            elif init_state == 'Disabled':
+                for option in option_val_dict:
+                    dict_radiobutton[option].config(state=tk.DISABLED)
+
+            #Otherwise, if the init_state does not have a counterpart in the values of the option_val_dict, select the first radiobutton
+            elif init_state not in option_val_dict.values():
+                self.var_dict[var_name].set(next(iter(option_val_dict.values())))
+            
+            #Otherwise, select the specified radiobutton
+            else:
+                self.var_dict[var_name].set(init_state)
+
+            return dict_radiobutton
         
-        return None
-    
-    #Function for running quant script
-    def runQuant(sname,quantphases):
-    
-        print("User selected sample name {0} with phase(s) {1}".format(sname,quantphases))
-        #If any of the required fields are empty, pass
-        if sname == "" or quantphases == "":
-            print("User did not enter a value for at least one required argument, canceling script run")
-            pass
-        #Otherwise, run the FIDpMS script
-        else:
-            print("Running Quantification script...")
+
+        def sampleSelect(self,event):
+
+            self.sname = self.sampleBox.get()
+
+            print("[__main__] User selected " + self.sname)
+
+            print("[__main__] Getting sample directories...")
+
+            #Sample directory
+            self.directories['sample'] = os.path.join(self.directories['data'],self.sname)
+
+            #Data file log directory
+            self.directories['log'] = os.path.join(self.directories['sample'],'log')
+
+            #Data file breakdowns directory
+            self.directories['break'] = os.path.join(self.directories['sample'],'breakdowns')
+
+            #Raw data file directory
+            self.directories['raw'] = os.path.join(self.directories['sample'],'raw data')
+
+            print("[__main__] Checking files...")
+            self.updateFileTrack()
+
+            return self.sname
+
+        #Function for setting up anonymous varaible select functions for printing messages
+        def setupVarSelect(self):
             
-            try:
-                #Run subprocess
-                runProcess(sname,qt.main_AutoQuantification,[quantphases,directories])
+            #Predefine dictionary for selection functions
+            self.select_dict = {}
+
+            #For every variable...
+            for i in self.var_dict:
+
+                #If variable is listed in the anonymous variable list...
+                if i in self.varSelect_list:
+                    #Define lambda function using default argument for user selection message
+                    self.select_dict[i] = lambda i=i: print("[__main__] User Selected " + self.var_dict[i].get() + " for " + i)
                 
-            except subprocess.CalledProcessError as e:
-                print(f'Command {e.cmd} failed with error {e.returncode}')
+                #Otherwise, pass
+                else:
+                    pass
+
+            return None
+
+        #Function for quant_typevar selection
+        def quant_typevarSelect(self):
+
+            #If the phase selected is either gas or both liquid and gas...
+            if self.var_dict['quant_typevar'].get() == 'G' or self.var_dict['quant_typevar'].get() == 'LG':
+                #Enable all radiobuttons
+                for radiobutton in self.radio_dict['quant_modelvar']:
+                    self.radio_dict['quant_modelvar'][radiobutton].config(state=tk.NORMAL)
+
+            #Otherwise, disable all radiobuttons
+            else:
+                #Disable all radiobuttons
+                for radiobutton in self.radio_dict['quant_modelvar']:
+                    print(radiobutton)
+                    self.radio_dict['quant_modelvar'][radiobutton].config(state=tk.DISABLED)
+                
+                #Set quant_modelvar to none
+                self.var_dict['quant_modelvar'].set(None)
+
+            print("[__main__] User Selected " + self.var_dict['quant_typevar'].get() + " for quant_typevar")
+
+            return None
+
+        #Function for 
+        def runUPP(self):
+            #Function for running the UPP function
+            print("[__main__] Running Unknowns Analysis Postprocessing...")
+            ua.mainUAPP(self.var_dict['sampleVar'].get())
+            print("[__main__] UAPP complete")
+            return None
         
-        return None
-    
-    """ CODE """
-    print("[__main__] Initializing UI mainframe...")
-    #Run the UI setup
-    root, mainframe = uiSetup(theme_Dir)
-    
-    #Create font objects
-    title_font = tkFont.Font(size=18)   #Title font
+        def runMatch(self):
+            #Function for running the match function
+            print("[__main__] Running FID and MS matching...")
+            mt.mainMatch(self.var_dict['sampleVar'].get(), self.var_dict['fpm_typevar'].get(),self.var_dict['fpm_modelvar'].get())
+            print("[__main__] Matching complete")
+            return None
+        
+        def runQuant(self):
+            #Function for running the quantification function
+            print("[__main__] Running quantification...")
+            qt.mainQuant(self.var_dict['sampleVar'].get(), self.var_dict['quant_typevar'].get(), self.var_dict['quant_modelvar'].get())
+            print("[__main__] Quantification complete")
+            return None
         
-    #IMAGE AND TITLE
-    #Add a frame for the logo and title/sample info
-    topFrame = ttk.Frame(mainframe)
-    topFrame.grid(column=0,row=0,sticky='w',padx=(350,0))
-    
-    #Add a frame for the ChromaQuant logo
-    logoFrame = ttk.Frame(topFrame)
-    logoFrame.grid(column=0,row=0)
-    
-    #Add a frame for the title text and sample selection
-    tsFrame = ttk.Frame(topFrame)
-    tsFrame.grid(column=1,row=0)
-    
-    #Add title text
-    tk.Label(tsFrame,text="ChromaQuant v"+version,font=title_font).grid(column=0,row=0,pady=10,padx=10)
-    
-    #Add an image for the ChromaQuant logo
-    #Load the image
-    #image = tk.PhotoImage(file=img_Dir+'ChromaQuantIcon.png')
-    image_i = Image.open(os.path.join(img_Dir,'ChromaQuantIcon.png'))
-    #Resize the image
-    resize_image = image_i.resize((100,100))
-    #Redefine the image
-    image = ImageTk.PhotoImage(resize_image)
-    #Add the image to a label
-    image_label = tk.Label(logoFrame, image=image)
-    image_label.grid(column=0,row=0,pady=10,padx=10)
-    
-    #SAMPLE SELECTION
-    #Add a frame for selecting the sample
-    sampleFrame = ttk.Frame(tsFrame)
-    sampleFrame.grid(column=0,row=1,pady=10,padx=10)
-    
-    #Add text to the top of the sample frame
-    tk.Label(sampleFrame,text='Select a sample to analyze:').grid(column=0,row=0)
-    sampleVar = tk.StringVar()
-    sampleBox = ttk.Combobox(sampleFrame,textvariable=sampleVar)
-    sampleBox['values'] = sampleList
-    sampleBox.state(["readonly"])
-    sampleBox.grid(column=0,row=1)
-    
-    #Bind the sampleBox to a function
-    sampleBox.bind("<<ComboboxSelected>>",on_select)
-    
-    #WIDGET FRAME
-    #Add a frame for the fidpms and quantification widgets
-    widgetFrame = ttk.Frame(mainframe)
-    widgetFrame.grid(column=0,row=1)
-    
-    #FIDPMS WIDGET
-    #Add a frame
-    fidpms_content = ttk.LabelFrame(widgetFrame,text='Peak Matching',style='QuantLabelframe.TLabelframe')
-    fidpms_content.grid(column=0,row=0,pady=10,padx=10)
-    
-    #Add text to the top of the frame
-    tk.Label(fidpms_content,text='Please enter all information').grid(column=0,row=0,columnspan=4,padx=20)
-    
-    #Set up a radiobutton for selecting liquid or gas
-    tk.Label(fidpms_content,text='Please select the sample type:').grid(column=0,row=1,padx=10,pady=20,sticky='e')
-    fpmVar = tk.StringVar()
-    Liquid = ttk.Radiobutton(fidpms_content,text='Liquid',variable=fpmVar,value="Liquid",command=fidpms_select)
-    Gas = ttk.Radiobutton(fidpms_content,text='Gas',variable=fpmVar,value="Gas",command=fidpms_select)
-    Liquid.grid(column=1,row=1,padx=1,sticky='w')
-    Gas.grid(column=2,row=1,padx=1,sticky='w')
-    
-    #Initially start with liquid selected
-    fpmVar.set('Liquid')
-    
-    #Set up a radiobutton for selecting the model type
-    tk.Label(fidpms_content,text='Please select the desired matching fit model:').grid(column=0,row=2,padx=10,pady=20,sticky='e')
-    fpmMVar = tk.StringVar()
-    third = ttk.Radiobutton(fidpms_content,text='Third order',variable=fpmMVar,value='Third order',command=fidpms_select_model)
-    first = ttk.Radiobutton(fidpms_content,text='First order (linear)',variable=fpmMVar,value='First order (linear)',command=fidpms_select_model)
-    rt = ttk.Radiobutton(fidpms_content,text='Retention time',variable=fpmMVar,value='Retention time',command=fidpms_select_model)
-    third.grid(column=1,row=2,padx=1,sticky='w')
-    first.grid(column=2,row=2,padx=1,sticky='w')
-    rt.grid(column=3,row=2,padx=1,sticky='w')
-    
-    #Initially start with first order selected and third order disabled
-    fpmMVar.set('First order (linear')
-    third.config(state=tk.DISABLED)
-    
-    #Set up a checkbox for selecting whether or not to perform speculative labeling
-    tk.Label(fidpms_content,text='Perform speculative labeling?').grid(column=0,row=3,padx=10,pady=20,sticky='e')
-    fpm2Var = tk.IntVar()
-    fpm2Box = tk.Checkbutton(fidpms_content,text='',variable=fpm2Var,onvalue=1,offvalue=0,command=fidpms_select2)
-    fpm2Box.grid(column=1,row=3,padx=1,sticky='w')
-    
-    #Add a start button
-    fidpms_sbutton = ttk.Button(fidpms_content,text="\n\n\nRun Script\n\n\n",width=20,style='Accent.TButton',command=lambda: runFIDpMS(sampleVar.get(),fpm2Var.get(),fpmVar.get(),fpmMVar.get()))
-    fidpms_sbutton.grid(column=0,row=4,pady=20,padx=20,columnspan=2)
-    
-    #DISABLING SPECULATIVE LABELING
-    fpm2Box.config(state=tk.DISABLED)
-    
-    #Bind the button to a function to run the appropriate script
-    #fidpms_sbutton.bind("<Button-1>",runFIDpMS)
-    
-    #QUANT WIDGET
-    #Add a frame
-    quant_content = ttk.LabelFrame(widgetFrame,text='Quantification',style='QuantLabelframe.TLabelframe')
-    quant_content.grid(column=1,row=0,pady=10,padx=10,sticky="n")
-    
-    #Add text to the top of the frame
-    tk.Label(quant_content,text='Please enter all information').grid(column=0,row=0,columnspan=2,padx=20)
-    #Set up a combobox for selecting liquid or gas
-    tk.Label(quant_content,text='Does the sample have liquid and/or gas components?').grid(column=0,row=1,padx=10,pady=20)
-    logVar = tk.StringVar()
-    logBox = ttk.Combobox(quant_content,textvariable=logVar)
-    logBox['values'] = ['Liquid','Gas','Liquid and Gas']
-    logBox.state(["readonly"])
-    logBox.grid(column=1,row=1,padx=10)
-    
-    #Bind the combobox to a function
-    logBox.bind("<<ComboboxSelected>>",quant_select)
-    
-    #Add a start button 
-    quant_sbutton = ttk.Button(quant_content,text="\n\n\nRun Script\n\n\n",width=20,style='Accent.TButton',command=lambda: runQuant(sampleVar.get(),logVar.get()))
-    quant_sbutton.grid(column=0,row=2,pady=20,padx=20,columnspan=2)
-    
-    #Bind the start button to a function
-    #quant_sbutton.bind("<Button-1>",runQuant)
-    
-    #var = ""
-    #togglebutton = ttk.Checkbutton(root, text='Switch', style='Switch',variable=var)
-    #togglebutton.grid(row=3,column=0)
-    
-    #Main loop
+        def runHydro(self):
+
+            #Function for running the hydroUI function
+            print("[__main__] Defining HydroUI application...")
+            """ COMMENT OUT FOR NOW, LAGGY
+            self.app = hy.mainHydro(self.var_dict['sampleVar'].get(), self.var_dict['hydro_typevar'].get(), self.var_dict['hydro_matchvar'].get())
+            print("[__main__] Application defined, running...")
+            if __name__ == "__main__":
+                #Define a thread and set as daemon – SCRIPT WILL CONTINUE TO RUN UNTIL CHROMAUI CLOSED
+                hydroThread = threading.Thread(target=lambda: self.app.run(debug=True, use_reloader=False))
+                hydroThread.daemon = True
+                #Start thread
+                hydroThread.start()
+            print("[__main__] HydroUI active")
+            """
+            return None
+
+    root = tk.Tk()
+    my_gui = chromaUI(root,directories)
+
     root.mainloop()
-    
-    #End of runUI function
-    return None
+
+    print('[__main__] Program terminated')
+
 
 """ RUN MAIN FUNCTION """
 print("[__main__] Starting UI...")
 if __name__ == "__main__":
 	runUI()
-