Merge pull request #65 from bartekbiz/Fixed-problem-with-flow-calcula…

…tions

Fixed problem with flow calculations

calculations/FlowCalculations.py

@@ -13,36 +13,42 @@ def __init__(self, data):
         self.min_value = 0
         self.max_value = 500
 
-        self.v_average = self.calculate_v_average(data['x'], data['y']) 
+        #self.v_average = self.calculate_v_average(data['x'], data['y']) 
+
 
         self.diameter = 40
         self.cross_section_area = self.calculate_cross_section_area(self.diameter)
-        self.flow=self.v_average*self.cross_section_area
+
+        self.v_average = 40
+        self.flow=self.calculate_flow(self.v_average)
 
     def calculate_cross_section_area(self, diameter) -> float:
         return (pi * pow(diameter, 2)) / 4
 
     def get_value_from_volt(self, volts) -> float:
         return (self.max_value / self.max_voltage) * volts
-
-    def calculate_v_average(self, data_x, data_y) -> float:
-        if data_x and data_y:  # Sprawdzenie, czy dane nie są puste
-            _, velocity_y = PlotCalculations.calc_linear_regression(data_x, data_y,0)
-            velocity_y = self.delete_close_zero_values(velocity_y, 1)
-            return self.calculate_average(velocity_y)
-        else:
-            return 0 
-
-    def delete_close_zero_values(self, data, treshold):
-        result = []
-        for i in range(len(data)):
-            if abs(data[i]) > treshold:
-                result.append(data[i])
-
-        return result
-
-    def calculate_average(self, data):
-        return mean(data)
+
+    def calculate_flow(self,v_average) -> float:
+        return v_average*self.cross_section_area
+
+    # def calculate_v_average(self, data_x, data_y) -> float:
+    #     if data_x and data_y:  # Sprawdzenie, czy dane nie są puste
+    #         _, velocity_y = PlotCalculations.calc_linear_regression(data_x, data_y,0)
+    #         velocity_y = self.delete_close_zero_values(velocity_y, 1)
+    #         return self.calculate_average(velocity_y)
+    #     else:
+    #         return 0 
+
+    # def delete_close_zero_values(self, data, treshold):
+    #     result = []
+    #     for i in range(len(data)):
+    #         if abs(data[i]) > treshold:
+    #             result.append(data[i])
+
+    #     return result
+
+    # def calculate_average(self, data):
+    #     return mean(data)
 
     def set_data(self, data):
         self.data = data

calculations/PlotCalculations.py

@@ -1,19 +1,16 @@
-
 class PlotCalculations:
     @staticmethod
-    def calc_linear_regression(x, y, span=30):
+    def calc_linear_regression(x, y, span):
         result_x = []
         result_dy_dx = []
 
         for i in range(len(x) - span):
-            # Obliczenie przybliżonej pochodnej numerycznej
             dx = x[i + span] - x[i]
             dy = y[i + span] - y[i]
-            dy_dx = dy / dx
 
-            result_x.append(x[i])
-            result_dy_dx.append(dy_dx)
+            if dx != 0:
+                dy_dx = dy / dx
+                result_x.append(x[i])
+                result_dy_dx.append(dy_dx)
 
         return result_x, result_dy_dx
-
-

controls/InputsFrame/FlowModule/VAverageField.py

@@ -1,26 +1,26 @@
+from controls.base.TextEntry import TextEntry
 from controls.base.TextLabel import TextLabel
 
 
 class VAverageField:
     def __init__(self, window, module, row):
-        self.v_average_field_label = VAverageLabel(window, row)
-        self.v_average_field_display = VAverageDisplay(window, row)
-
-    def update_display(self, text):
-        self.v_average_field_display.config(text=text)
+        self.v_average_label = VAverageLabel(window, row)
+        self.v_average_entry = VAverageEntry(window, module, row)
 
     def destroy(self):
-        self.v_average_field_label.destroy()
-        self.v_average_field_display.destroy()
+        self.v_average_label.destroy()
+        self.v_average_entry.destroy()
 
 
 class VAverageLabel(TextLabel):
     def __init__(self, window, row):
-        super().__init__(window, text="V Average", width=12)
+        super().__init__(window, text=" VAverage")
         self.grid(row=row, column=0, padx=10, sticky="nw")
 
 
-class VAverageDisplay(TextLabel):
-    def __init__(self, window, row):
-        super().__init__(window, text="0", width=10)
+class VAverageEntry(TextEntry):
+    def __init__(self, window, module, row):
+        super().__init__(window, module.v_average_entry)
         self.grid(row=row, column=1, padx=10, sticky="ne")
+        self.bind("<FocusOut>", module.update_flow)
+        self.bind("<Return>", module.update_flow)

modules/BaseModule.py

@@ -4,7 +4,7 @@
 from controls.InputsFrame.InputsFrame import InputsFrame
 from controls.PlotManipulationFrame.PlotManipulationFrame import PlotManipulationFrame
 from controls.base.Frame import Frame
-from plots.AnimatedPlot import AnimatedPlot
+from plots.DisplacementPlot import DisplacementPlot
 
 
 class BaseModule:
@@ -17,7 +17,7 @@ def __init__(self, app, plot_values: dict, plot_x_name="t"):
         self.plot_units = list(plot_values.values())
         self.plots_x_name = plot_x_name
         self.plot_frame = Frame(self.app.column_2_frame, row=0)
-        self.plot = AnimatedPlot(
+        self.plot = DisplacementPlot(
             self.plot_frame,
             self.app,
             self.data,

modules/FlowModule/FlowModule.py

@@ -7,40 +7,49 @@
 from controls.InputsFrame.FlowModule.VAverageField import VAverageField
 from enums.ModuleEnum import ModuleEnum
 from modules.BaseModule import BaseModule
+from plots.FlowPlot import FlowPlot
 
 
 class FlowModule(BaseModule):
     def __init__(self, app):
         super().__init__(
             app,
-            plot_values={"U": "V", "v*50": "mm", "a*50": "mm/s*s"}
+            plot_values={"U": "V", "x": "mm", "v": "mm/s"}
         )
-
+        self.plot = FlowPlot(
+            self.plot_frame,
+            self.app,
+            self.data,
+            self.plot_names,
+            self.plot_units,
+            self.plots_x_name,
+        )
+        self.plot.create_empty_plot()
         self.flow_calculations = FlowCalculations(self.data)
 
         self.diameter_entry = DoubleVar()
         self.diameter_field = DiameterField(self.inputs_frame, self, row=10)
+
+        self.v_average_entry = DoubleVar()
+        self.v_average_field = VAverageField(self.inputs_frame, self, row=11)
 
         self.cross_section_field = CrossSectionField(self.inputs_frame, self, row=50)
-        self.v_average_field = VAverageField(self.inputs_frame, self, row=51)
-        self.flow_field = FlowField(self.inputs_frame, self, row=52)
-        self.app.bind("t", self.update_flow_plot_stats)
+        self.flow_field = FlowField(self.inputs_frame, self, row=51)
+        # self.app.bind("t", self.update_flow_plot_stats)
 
     def update_cross_section(self, *event):
         self.cross_section_field.update_display(
             str(round(self.flow_calculations.calculate_cross_section_area(self.get_diameter()), 2)))
 
     def get_diameter(self) -> float:
         return float(self.diameter_field.diameter_entry.get())
-
-    def update_v_average(self, *event):
-        self.v_average_field.update_display(
-            str(round(self.flow_calculations.v_average, 4))
-        )
-
+
+    def get_v_average(self) -> float:
+        return float(self.v_average_field.v_average_entry.get())
+
     def update_flow(self, *event):
         self.flow_field.update_display(
-            str(round(self.flow_calculations.flow, 4))
+            str(round(self.flow_calculations.calculate_flow(self.get_v_average()), 2))
         )
 
     def get_name(self):
@@ -54,6 +63,5 @@ def destroy(self, *event):
         self.v_average_field.destroy()
         self.flow_field.destroy()
 
-    def update_flow_plot_stats(self, *event):
-        self.v_average_field.update_display(self.update_v_average())
-        self.flow_field.update_display(self.update_flow())
+    # def update_flow_plot_stats(self, *event):
+    #     self.flow_field.update_display(self.update_flow())

plots/DisplacementPlot.py

@@ -0,0 +1,28 @@
+from plots.AnimatedPlot import AnimatedPlot
+class DisplacementPlot(AnimatedPlot):
+    def __init__(self, window, app, data, plot_names, plot_units, plot_x_name):
+        super().__init__(window, app, data, plot_names, plot_units, plot_x_name)
+
+    def update_ax2_ax3_data(self):
+        v_len = len(self.velocity_y)
+        v_custom_range_min = v_len - 1 if v_len != 0 else 0
+
+        a_len = len(self.acceleration_y)
+        a_custom_range_min = a_len - 1 if a_len != 0 else 0
+
+        v_x, v_y = self.plot_calculations.calc_linear_regression(self.animated_x, self.animated_y, self.span)
+        a_x, a_y = self.plot_calculations.calc_linear_regression(v_x, v_y, self.span)
+
+        self.ax2.plot(
+            v_x[v_custom_range_min:],
+            v_y[v_custom_range_min:],
+            self.color
+        )
+
+        self.ax3.plot(
+            a_x[a_custom_range_min:],
+            a_y[a_custom_range_min:],
+            self.color
+        )
+        self.velocity_y.extend(v_y[v_len:])
+        self.acceleration_y.extend(a_y[a_len:])

plots/FlowPlot.py

@@ -0,0 +1,29 @@
+from plots.AnimatedPlot import AnimatedPlot
+class FlowPlot(AnimatedPlot):
+    def __init__(self, window, app, data, plot_names, plot_units, plot_x_name):
+        super().__init__(window, app, data, plot_names, plot_units, plot_x_name)
+
+    def update_ax2_ax3_data(self):
+        v_len = len(self.velocity_y)
+        v_custom_range_min = v_len - 1 if v_len != 0 else 0
+
+        a_len = len(self.acceleration_y)
+        a_custom_range_min = a_len - 1 if a_len != 0 else 0
+
+        v_x = self.animated_x
+        v_y = [y * 50 for y in self.animated_y]
+        a_x, a_y = self.plot_calculations.calc_linear_regression(v_x, v_y, self.span)
+
+        self.ax2.plot(
+            v_x[v_custom_range_min:],
+            v_y[v_custom_range_min:],
+            self.color
+        )
+
+        self.ax3.plot(
+            a_x[a_custom_range_min:],
+            a_y[a_custom_range_min:],
+            self.color
+        )
+        self.velocity_y.extend(v_y[v_len:])
+        self.acceleration_y.extend(a_y[a_len:])