class DAFD_GUI:
"""A class that produces a windowed interface for DAFD"""
def __init__(self):
"""Initialize the GUI components"""
self.root = tkinter.Tk()
self.root.title("DAFD")
#Attach the interpolation model to the GUI
self.di = DAFD_Interface()
self.MH = ModelHelper.get_instance() # type: ModelHelper
# DAFD Logo
img = Image.open(self.MH.resource_path("DAFD_logo.png"))
img = ImageTk.PhotoImage(
img.resize((int(0.1 * img.size[0]), int(0.1 * img.size[1])),
Image.ANTIALIAS))
panel = tkinter.Label(self.root, image=img)
panel.pack(side="top", fill="both")
panel.configure(background="white")
self.root.configure(background="white")
# Pack all input constraint elements together
inputs_frame = tkinter.Frame(self.root)
inputs_frame.pack(side="top")
inputs_frame.configure(background="white")
inputs_header = tkinter.Label(inputs_frame)
inputs_header.pack(side="top")
inputs_header["text"] = "Constraints"
inputs_header.config(font=("Times", 20))
inputs_header.configure(background="white")
self.entries_dict = {}
self.tol_var = 0
for param_name in self.di.input_headers:
param_frame = tkinter.Frame(inputs_frame)
param_frame.pack(side="top")
param_frame.configure(background="white")
param_label = tkinter.Label(param_frame, width=40, anchor="e")
param_label.pack(side="left")
param_label["text"] = param_name + " (" + str(
round(self.di.ranges_dict[param_name][0], 2)) + "-" + str(
round(self.di.ranges_dict[param_name][1], 2)) + ") : "
param_label.configure(background="white")
param_entry = tkinter.Entry(param_frame)
param_entry.pack(side="left")
param_entry.configure(background="white")
self.entries_dict[param_name] = param_entry
regime_frame = tkinter.Frame(inputs_frame)
regime_frame.pack(side="top")
regime_frame.configure(background="white")
regime_label = tkinter.Label(regime_frame, width=40, anchor="e")
regime_label.pack(side="left")
regime_label["text"] = "regime (1-2) : "
regime_label.configure(background="white")
regime_entry = tkinter.Entry(regime_frame)
regime_entry.pack(side="left")
regime_entry.configure(background="white")
self.entries_dict["regime"] = regime_entry
# Pack the desired output elements together
outputs_frame = tkinter.Frame(self.root, pady=20)
outputs_frame.pack(side="top")
outputs_frame.configure(background="white")
outputs_header = tkinter.Label(outputs_frame)
outputs_header.pack(side="top")
outputs_header["text"] = "Desired Values"
outputs_header.config(font=("Times", 20))
outputs_header.configure(background="white")
for param_name in self.di.output_headers:
param_frame = tkinter.Frame(outputs_frame)
param_frame.pack(side="top")
param_frame.configure(background="white")
param_label = tkinter.Label(param_frame, width=40, anchor="e")
param_label.pack(side="left")
param_label["text"] = param_name + " (" + str(
round(self.di.ranges_dict[param_name][0], 2)) + "-" + str(
round(self.di.ranges_dict[param_name][1], 2)) + ") : "
param_label.configure(background="white")
param_entry = tkinter.Entry(param_frame)
param_entry.pack(side="left")
param_entry.configure(background="white")
self.entries_dict[param_name] = param_entry
# Pack Tolerance Study Together
tolerance_frame = tkinter.Frame(self.root, pady=20)
tolerance_frame.pack(side="top")
tolerance_frame.configure(background="white")
tolerance_header = tkinter.Label(tolerance_frame)
tolerance_header.pack(side="top")
tolerance_header["text"] = "Tolerance Options"
tolerance_header.config(font=("Times", 20))
tolerance_header.configure(background="white")
tol_frame = tkinter.Frame(tolerance_frame)
tol_frame.pack(side="top")
tol_frame.configure(background="white")
tol_label = tkinter.Label(tol_frame, width=40, anchor="e")
tol_label.pack(side="left")
tol_label["text"] = "Perform Tolerance Study? "
tol_label.configure(background="white")
check_var = tkinter.IntVar(value=0)
tol_entry = tkinter.Checkbutton(tol_frame, variable=check_var)
tol_entry.pack(side="left")
tol_entry.configure(background="white")
self.entries_dict["tolerance_test"] = tol_entry
tol_frame = tkinter.Frame(tolerance_frame)
tol_frame.pack(side="top")
tol_frame.configure(background="white")
tol_label = tkinter.Label(tol_frame, width=40, anchor="e")
tol_label.pack(side="left")
tol_label["text"] = "Tolerance (1-50, default 10) : "
tol_label.configure(background="white")
tol_entry = tkinter.Entry(tol_frame)
tol_entry.pack(side="left")
tol_entry.configure(background="white")
self.entries_dict["tolerance"] = tol_entry
# Pack the results together
results_frame = tkinter.Frame(self.root, pady=20)
results_frame.pack(side="top")
results_frame.configure(background="white")
submit_dafd_button = ttk.Button(results_frame,
text='Run DAFD',
command=self.runInterp)
submit_dafd_button.pack(side="top")
submit_fwd_button = ttk.Button(results_frame,
text='Run Forward Model',
command=self.runForward)
submit_fwd_button.pack(side="top")
self.results_label = tkinter.Label(results_frame)
self.results_label.pack(side="top")
self.results_label.configure(background="white")
# Start GUI
self.root.mainloop()
def runInterp(self):
"""Suggest design parameters based on given constraints and desired outputs"""
# Get all of our constraints
# It is quite possible to have no constraints if the user does not have a preference
constraints = {}
for param_name in self.di.input_headers:
param_entry = self.entries_dict[param_name].get()
if param_entry != "":
# The constraint can either be a single value or a range
if "-" in param_entry:
# If it is a range x to y, the range is x-y
pair = param_entry.split("-")
wanted_constraint = (float(pair[0]), float(pair[1]))
else:
# If it is a single value x, the range is x-x
wanted_constraint = (float(param_entry),
float(param_entry))
# Make sure that our constraints are in range. Just creates a warning if not.
if wanted_constraint[0] <= self.di.ranges_dict[param_name][0]:
tkinter.messagebox.showwarning(
"Out of range constraint",
param_name + " was too low.")
elif wanted_constraint[1] >= self.di.ranges_dict[param_name][1]:
tkinter.messagebox.showwarning(
"Out of range constraint",
param_name + " was too high.")
constraints[param_name] = wanted_constraint
# Regime must be 1 or 2 (dripping or jetting regime)
regime_entry = self.entries_dict["regime"].get()
if regime_entry != "":
if regime_entry == "1" or regime_entry == "2":
constraints["regime"] = float(regime_entry)
else:
tkinter.messagebox.showwarning(
"Regime must be either 1 or 2. Ignoring.")
# Get the desired outputs
# Note one can be left blank, in which case the interpolation model will simply operate on the other value's model
desired_vals = {}
for param_name in self.di.output_headers:
param_entry = self.entries_dict[param_name].get()
if param_entry != "":
wanted_val = float(param_entry)
if wanted_val >= self.di.ranges_dict[param_name][
0] and wanted_val <= self.di.ranges_dict[param_name][1]:
desired_vals[param_name] = wanted_val
else:
tkinter.messagebox.showwarning(
"Out of range desired value",
param_name + " was out of range.")
desired_vals[param_name] = wanted_val
# Return and display the results
results = self.di.runInterp(desired_vals, constraints)
# Run Tolerance Test if Specified
if bool(self.entries_dict["tolerance_test"].getvar(name="PY_VAR0")):
from DAFD_TolTest import ToleranceHelper
tolerance = self.entries_dict["tolerance"].get()
if tolerance == "":
tolerance = 10
tol_features = results.copy()
del tol_features["point_source"]
TH = ToleranceHelper(tol_features,
di=self.di,
tolerance=float(tolerance))
TH.run_all()
TH.plot_all()
TH.generate_report()
print(self.di.runForward(results))
self.results_label["text"] = "\n".join(
[x + " : " + str(results[x]) for x in self.di.input_headers])
def runForward(self):
"""Predict the outputs based on the chip geometry (Normal feed-forward network) """
# Get all the chip geometry values
features = {
x: float(self.entries_dict[x].get())
for x in self.di.input_headers
}
results = self.di.runForward(features)
self.results_label["text"] = "\n".join(
[x + " : " + str(results[x]) for x in results])
# Run Tolerance Test if Specified
if bool(self.entries_dict["tolerance_test"].getvar(name="PY_VAR0")):
from DAFD_TolTest import ToleranceHelper
tolerance = self.entries_dict["tolerance"].get()
if tolerance == "":
tolerance = 10
TH = ToleranceHelper(features,
di=self.di,
tolerance=float(tolerance))
TH.run_all()
TH.plot_all()
TH.generate_report()
if stage == 2: fwd_results = di.runForward(features) result_str = "BEGIN:" for x in di.MH.get_instance().output_headers: result_str += str(fwd_results[x]) + "|" result_str += str(fwd_results["regime"]) + "|" result_str += str(fwd_results["oil_rate"]) + "|" result_str += str(fwd_results["water_rate"]) + "|" result_str += str(fwd_results["inferred_droplet_size"]) + "|" print(result_str) else: rev_results = di.runInterp(desired_vals, constraints) fwd_results = di.runForward(rev_results) print(rev_results) print(fwd_results) result_str = "BEGIN:" for x in di.MH.get_instance().input_headers: result_str += str(rev_results[x]) + "|" result_str += str(rev_results["point_source"]) + "|" for x in di.MH.get_instance().output_headers: result_str += str(fwd_results[x]) + "|" result_str += str(fwd_results["regime"]) + "|"