From 2348e34d0fe83f520899edfaa3d5782584318a10 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Thu, 10 Apr 2025 12:08:49 +0200
Subject: [PATCH 01/67] new changes for the 3d gui and the fitting panel for
 workable version

---
 src/mpes_tools/Gui_3d.py                      | 405 ++++++--------
 src/mpes_tools/fit_panel.py                   | 525 +++++++++++-------
 src/mpes_tools/graphs.py                      |  95 +++-
 src/mpes_tools/hdf5.py                        |   2 +-
 .../movable_vertical_cursors_graph.py         |   8 +-
 5 files changed, 567 insertions(+), 468 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index 1c8e478..bafdfae 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -6,19 +6,18 @@
 from matplotlib.patches import Circle
 from matplotlib.lines import Line2D
 
-from mpes_tools.fit_panel import MainWindow
+from mpes_tools.fit_panel import fit_panel
 
 import xarray as xr
 
-# %matplotlib qt
 
-class GraphWindow(QMainWindow):
-    def __init__(self,data_array: xr.DataArray,t,dt):
+class GraphWindow(QMainWindow):  #graphic window showing a 2d map controllable with sliders for the third dimension, with cursors showing cuts along the x direction for MDC and y direction for EDC
+    def __init__(self,data_array: xr.DataArray,t,dt,technique):
         global t_final
         super().__init__()
 
         self.setWindowTitle("Graph Window")
-        self.setGeometry(100, 100, 800, 600)
+        self.setGeometry(100, 100, 1200, 1000)
 
         # Create a central widget for the graph
         central_widget = QWidget()
@@ -57,8 +56,8 @@ def __init__(self,data_array: xr.DataArray,t,dt):
         self.slider2.setValue(0)
         self.slider2_label = QLabel("0")
         
-        self.slider1.setFixedSize(200, 12)  # Change the width and height as needed
-        self.slider2.setFixedSize(200, 12)  # Change the width and height as needed
+        # self.slider1.setFixedSize(200, 12)  # Change the width and height as needed
+        # self.slider2.setFixedSize(200, 12)  # Change the width and height as needed
         
         slider_layout.addWidget(self.slider1)
         slider_layout.addWidget(self.slider1_label)
@@ -86,287 +85,244 @@ def __init__(self,data_array: xr.DataArray,t,dt):
 
         # Create a figure and canvas for the graph
         
-        self.data_o=data_array.data
+        self.data=data_array
         self.axis=[data_array.coords[dim].data for dim in data_array.dims]
+        # print(data_array.dims)
+        if technique == 'Phoibos':
+            self.axis[1]=self.axis[1]-21.7
+            self.data = self.data.assign_coords(Ekin=self.data.coords['Ekin'] -21.7)
+        
         self.dt=dt
-        self.datae=np.zeros((len(self.axis[0]),len(self.axis[1])))
+        # self.datae=np.zeros((len(self.axis[0]),len(self.axis[1])))
         # Plot data
-        self.plot_graph(t,dt)
+        self.data_t=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
+        # self.plot_graph(t,dt)
         self.ssshow(t,dt)
         self.slider1.setRange(0,len(self.axis[2])-1)
+        self.slider1_label.setText(self.data.dims[2]+": 0")
+        self.slider2_label.setText("Δ"+self.data.dims[2]+": 0")
         self.plot=np.zeros_like(self.data[1,:])
         
         self.slider1.valueChanged.connect(self.slider1_changed)
         self.slider2.valueChanged.connect(self.slider2_changed)
         t_final=self.axis[2].shape[0]
         
-        
-        fit_panel_action = QAction('Fit_Panel',self)
-        fit_panel_action.triggered.connect(self.fit_panel)
-        
         menu_bar = self.menuBar()
-
-        # Create a 'Graph' menu
-        
         graph_menu1 = menu_bar.addMenu("Fit Panel")
         
-        graph_menu1.addAction(fit_panel_action)
-
-        # Add the actions to the menu
+        energy_panel_action = QAction('EDC',self)
+        energy_panel_action.triggered.connect(self.fit_energy_panel)
+        graph_menu1.addAction(energy_panel_action)
+        
+        momentum_panel_action = QAction('MDC',self)
+        momentum_panel_action.triggered.connect(self.fit_momentum_panel)
+        graph_menu1.addAction(momentum_panel_action)
+        
+        box_panel_action = QAction('box',self)
+        box_panel_action.triggered.connect(self.fit_box_panel)
+        graph_menu1.addAction(box_panel_action)
         
         self.graph_windows=[]
         self.t=t
-        
-    def slider1_changed(self,value):
-        self.slider1_label.setText(str(value))
-        self.plot_graph(self.slider1.value(),self.slider2.value())
-        # print(self.slider1.value(),self.slider2.value())
+        print(data_array.dims)
+        # 
+    def slider1_changed(self,value): # change the slider controlling the third dimension
+        # self.slider1_label.setText(str(value))
+        base = self.slider1_label.text().split(':')[0]
+        self.slider1_label.setText(f"{base}: {self.data[self.data.dims[2]][value].item():.2f}")
         self.update_show(self.slider1.value(),self.slider2.value())
         self.t=self.slider1.value()
-        # self.us()
-        # update_show(self.slider1.value(),self.slider2.value())
-    def slider2_changed(self,value):
-        self.slider2_label.setText(str(value))
-        self.plot_graph(self.slider1.value(),self.slider2.value())
+    def slider2_changed(self,value): # change the slider controlling the third dimension for windowing
+        # self.slider2_label.setText(str(value))
+        base = self.slider2_label.text().split(':')[0]
+        self.slider2_label.setText(f"{base}: {value}")
         self.update_show(self.slider1.value(),self.slider2.value())
         self.dt=self.slider2.value()
-        # self.ssshow(self.slider1.value(),self.slider2.value()).update_show()
-        # self.us()
-        # update_show(self.slider1.value(),self.slider2.value())
     def checkbox_e_changed(self, state):
         if state == Qt.Checked:
-            # print("Checkbox is checked")
             self.integrate_E()
         else:
-            # print("Checkbox is unchecked")
             self.update_show(self.slider1.value(),self.slider2.value())
     def checkbox_k_changed(self, state):
         if state == Qt.Checked:
-            # print("Checkbox is checked")
             self.integrate_k()
         else:
-            # print("Checkbox is unchecked")
             self.update_show(self.slider1.value(),self.slider2.value())
     def checkbox_cursors_changed(self, state):
         if state == Qt.Checked:
             self.put_cursors()
-            # self.integrate_k()
         else:
-            # print("Checkbox is unchecked")
             self.remove_cursors()
-    def plot_graph(self,t,dt):
-        # Plot on the graph
-        x = [1, 2, 3, 4, 5]
-        y = [2, 3, 5, 7, 11]
-        self.data=np.zeros((len(self.axis[0]),len(self.axis[1])))
-        # self.ax.plot(x, y)
-        for i in range (t,t+dt+1):
-            self.data+= self.data_o[:,:,i]
-        
-        self.axs[0,0].imshow(self.data, extent=[self.axis[1][0], self.axis[1][-1], self.axis[0][0], self.axis[0][-1]], origin='lower', cmap='viridis',aspect='auto')
-        self.axs[0,0].set_title('Sample Graph')
-        self.axs[0,0].set_xlabel('X')
-        self.axs[0,0].set_ylabel('Y')
-        self.fig.tight_layout()
-        self.canvas.draw()
+    # def plot_graph(self,t,dt):
+        
+    #     self.data_t=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
+    #     self.axs[0,0].imshow(self.data_t.data, extent=[self.axis[1][0], self.axis[1][-1], self.axis[0][0], self.axis[0][-1]], origin='lower',cmap='terrain',aspect='auto')
+        
+        
+    #     self.axs[0,0].set_title('Sample Graph')
+    #     self.axs[0,0].set_xlabel('E-Ef (eV)')
+    #     self.axs[0,0].set_ylabel('Angle (degrees)')
+    #     self.fig.tight_layout()
+    #     self.canvas.draw()
     
-    def fit_panel(self,event):
-        print('forfit',len(self.plot),'axis',len(self.axis))
-        graph_window=   MainWindow( self.data_o, self.axis,self.square_coords[0][1], self.square_coords[1][1],self.t,self.dt)
+    def fit_energy_panel(self,event): # open up the fit panel for the EDC 
+        graph_window=fit_panel(self.data,self.square_coords[0][1], self.square_coords[1][1], self.t, self.dt, self.data.dims[1])
+        graph_window.show()
+        self.graph_windows.append(graph_window)
+    def fit_momentum_panel(self,event): # open up the fit panel for the MDC
+        graph_window=fit_panel(self.data,self.square_coords[0][0], self.square_coords[1][0], self.t, self.dt, self.data.dims[0])
+        graph_window.show()
+        self.graph_windows.append(graph_window)
+    def fit_box_panel(self,event): # open up the fit panel for the intensity box
+        graph_window=fit_panel(self.int,0,0, self.t, self.dt, 'box')
         graph_window.show()
         self.graph_windows.append(graph_window)
         
-    def lz_fit(self, event):
-        two_lz_fit(self.data_o, self.axis, self.square_coords[0][1], self.square_coords[1][1], 0, t_final, self.v1_pixel, self.v2_pixel,self.dt,self.a).fit()
-    def fit(self, event):
-        fit_4d(self.data_o, self.axis, self.square_coords[0][1], self.square_coords[1][1], 0, t_final, self.v1_pixel, self.v2_pixel,self.dt).fit()
-    def fit_FD(self, event):
-        fit_FD(self.data_o, self.axis, self.square_coords[0][1], self.square_coords[1][1], 0, t_final, self.v1_pixel, self.v2_pixel,self.dt).fit()
-    def fit_FD_conv(self, event):
-        # print('ax0test=',self.ax[0])
-        # print('ax1test=',self.ax[1])
-        
-        fit_FD_lor_conv(self.data_o, self.axis, self.square_coords[0][1], self.square_coords[1][1], 0, t_final, self.v1_pixel, self.v2_pixel,self.dt).fit()
-    def fit_FD_conv_2(self, event):
-        
-        f=fit_FD_conv(self.data_o, self.axis, self.square_coords[0][1], self.square_coords[1][1], 0, t_final, self.v1_pixel, self.v2_pixel,self.dt)
-        f.show()
-    def ssshow(self,t,dt):
-        def test(self):
-            print('whatever test')
-        print('show is running')
-        c= self.data.shape[1]// 10 ** (len(str(self.data.shape[1])) - 1)
-        
-        def put_cursors():
-            self.Line1=axe.axvline(x=self.cursorlinev1, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
-            self.Line2=axe.axvline(x=self.cursorlinev2, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
+    
+    def ssshow(self, t, dt): # This is where the updates after changing the sliders happen
+        
+            
+        
+        # c = self.data.shape[1] // 10 ** (len(str(self.data.shape[1])) - 1)
+        
+        def put_cursors(): # add cursors in the EDC graph
+            # Adjust to use xarray's coords for axis referencing
+            self.Line1 = axe.axvline(x=self.cursorlinev1, color='red', linestyle='--', linewidth=2, label='Vertical Line', picker=10)
+            self.Line2 = axe.axvline(x=self.cursorlinev2, color='red', linestyle='--', linewidth=2, label='Vertical Line', picker=10)
             plt.draw()
             self.fig.canvas.draw()
-        def remove_cursors():
+    
+        def remove_cursors(): # remoe cursors in the EDC graph
             self.Line1.remove()
             self.Line2.remove()
             plt.draw()
             self.fig.canvas.draw()
-                    
-                           
-        def integrate_E():
-                self.plote=np.zeros_like(self.data[1,:])
-                self.axs[1,0].clear()
-                plt.draw()
-                x_min = int(min(self.square_coords[1][1], self.square_coords[0][1]))
-                x_max = int(max(self.square_coords[1][1], self.square_coords[0][1])) + 1
-                for i in range(x_min, x_max):
-                    self.plote += self.data[i, :]
-                # if self.square_coords[1][1]<self.square_coords[0][1]:
-                #     for i in range(self.square_coords[1][1],self.square_coords[0][1]+1):
-                #          self.plot+=self.data[i,:]
-                # elif self.square_coords[1][1]>self.square_coords[0][1]:
-                #     for i in range(self.square_coords[0][1],self.square_coords[1][1]+1):
-                #          self.plot+=self.data[i,:]
-                # else: 
-                #     self.plot+=self.data[self.square_coords[0][1],:]
-                                                       
-                self.axs[1, 0].plot(self.axis[1][:],self.plote/abs(self.square_coords[0][1]-self.square_coords[1][1]),color='red') 
-                
-                # save_data(self.axis[1], plot/abs(self.square_coords[0][1]-self.square_coords[1][1]),"EDC_time="+str(slider_t.val)+"_", [0.42,0.46],self.fig)        
-        def integrate_k():
-                self.plotk=np.zeros_like(self.data[:,1])
-                self.axs[0,1].clear()
-                plt.draw()
-                x_min = int(min(self.square_coords[0][0], self.square_coords[1][0]))
-                x_max = int(max(self.square_coords[0][0], self.square_coords[1][0])) + 1
-                for i in range(x_min, x_max):
-                    self.plotk += self.data[:, i]
-                # if self.square_coords[0][0]<self.square_coords[1][0]:
-                #     for i in range(int(self.square_coords[0][0]),int(self.square_coords[1][0])+1):
-                #         self.plot+=self.data[:,i] 
-                # else:    
-                #     for i in range(int(self.square_coords[1][0]),int(self.square_coords[0][0])+1):
-                #         self.plot+=self.data[:,i]
-                self.axs[0, 1].plot(self.plotk/abs(int(self.square_coords[0][0])-int(self.square_coords[1][0])),self.axis[0][:],color='red')
-                # plt.draw()    
-        def box():
-                self.int=np.zeros_like(self.axis[2])
-                self.axs[1,1].clear()
-                if self.square_coords[1][1]<self.square_coords[0][1]:
-                    if self.square_coords[0][0]<self.square_coords[1][0]:
-                        for i in range(self.square_coords[1][1],self.square_coords[0][1]+1):
-                            for j in range(int(self.square_coords[0][0]),int(self.square_coords[1][0])+1):
-                                self.int+=self.data_o[i,j,:]
-                                
-                    else:
-                        for i in range(self.square_coords[1][1],self.square_coords[0][1]+1):
-                            for j in range(int(self.square_coords[1][0]),int(self.square_coords[0][0])+1):
-                                self.int+=self.data_o[i,j,:]
-                else:
-                    if self.square_coords[0][0]<self.square_coords[1][0]:
-                        for i in range(self.square_coords[0][1],self.square_coords[1][1]+1):
-                            for j in range(int(self.square_coords[0][0]),int(self.square_coords[1][0])+1):
-                                self.int+=self.data_o[i,j,:]
-                    else:
-                        for i in range(self.square_coords[0][1],self.square_coords[1][1]+1):
-                            for j in range(int(self.square_coords[1][0]),int(self.square_coords[0][0])+1):
-                                self.int+=self.data_o[i,j,:]
-                if int(self.square_coords[1][1]) != int(self.square_coords[0][1]) and int(self.square_coords[0][0]) != int(self.square_coords[1][0]):
-                    # self.axs[1,1].plot(plot/np.sqrt((self.square_coords[0][0])-int(self.square_coords[1][0])**2+(self.square_coords[0][1]-self.square_coords[1][1])**2),self.axis[2])
-                    # print(plot)
-                    N=120
-                    self.axs[1,1].plot(self.axis[2][0:N],self.int[0:N])  
-      
-        def us(self):
-            update_show(self.slider1.value(),self.slider2.value())                      
-        def update_show(t,dt):
-            # print(self.data.shape)
-            # print(self.axis[2].shape)
-            # print(self.square_coords)
-            # self.data=np.zeros_like(self.data)
-            print('update_Shopwwww')
-            self.axs[0,1].clear()
-            self.axs[1,0].clear()
-            # if self.cursorlinev1 is not None and self.cursorlinev2 is not None:
-            # if cb_ce.get_status()[0]:
+    
+        def integrate_E(): # integrate EDC between the two cursors in the main graph
+            self.axs[1, 0].clear()
+            plt.draw()
+    
+            x_min = int(min(self.square_coords[1][1], self.square_coords[0][1]))
+            x_max = int(max(self.square_coords[1][1], self.square_coords[0][1])) + 1
+    
+            self.data_t.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0]).plot(ax=self.axs[1,0])
+
+    
+        def integrate_k(): # integrate MDC between the two cursors in the main graph
+            self.axs[0, 1].clear()
+            plt.draw()
+    
+            x_min = int(min(self.square_coords[0][0], self.square_coords[1][0]))
+            x_max = int(max(self.square_coords[0][0], self.square_coords[1][0])) + 1
+    
+            self.data_t.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1]).plot(ax=self.axs[0,1])
+    
+        def box(): # generate the intensity graph between the four cursors in the main graph
+            self.int = np.zeros_like(self.axis[2])
+            self.axs[1, 1].clear()
+            x0, y0 = map(int, self.square_coords[0])
+            x1, y1 = map(int, self.square_coords[1])
+    
+            # Ensure (x0, y0) is the top-left corner and (x1, y1) is the bottom-right
+            x0, x1 = sorted([x0, x1])
+            y0, y1 = sorted([y0, y1])
+    
+            self.int = self.data.isel({self.data.dims[0]: slice(y0, y1), self.data.dims[1]: slice(x0, x1)}).sum(dim=(self.data.dims[0], self.data.dims[1]))
             
-            # for j in range(t, t+dt+1):
-            #     self.data+=self.data_o[:,:,j]
-            im6.set_array(self.data)
-            if self.checkbox_e.isChecked() and self.checkbox_k.isChecked() :
+            if x0 != x1 and y0 != y1:
+                N = -1
+                
+                self.int.plot(ax=self.axs[1,1])
+                self.dot, = self.axs[1, 1].plot([self.axis[2][self.slider1.value()]], [self.int[self.slider1.value()]], 'ro', markersize=8)
+                self.fig.canvas.draw_idle()
+    
+        # def us(self): 
+        #     update_show(self.slider1.value(), self.slider2.value())
+    
+        def update_show(t, dt): # update the main graph as well as the relevant EDC and MDC cuts. Also the box intensity
+            self.axs[0, 1].clear()
+            self.axs[1, 0].clear()
+            self.data_t=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
+            im6.set_array(self.data_t)
+            if self.checkbox_e.isChecked() and self.checkbox_k.isChecked():
                 integrate_E()
                 integrate_k()
             elif self.checkbox_e.isChecked():
                 integrate_E()
-                self.axs[0, 1].plot(self.data[:,int(self.square_coords[0][0])],self.axis[0][:],color='orange') 
-                self.axs[0, 1].plot(self.data[:,int(self.square_coords[1][0])],self.axis[0][:],color='green')
-                # self.axs[0, 1].plot(self.data[:,int(self.square_coords[0][0])],np.arange(self.data[:,self.square_coords[0][0]].shape[0]),color='orange') 
-                # self.axs[0, 1].plot(self.data[:,int(self.square_coords[1][0])],np.arange(self.data[:,self.square_coords[0][0]].shape[0]),color='green')
+                self.data_t.isel({self.data.dims[1]: int(self.square_coords[0][0])}).plot(ax=self.axs[0, 1], color='orange')
+                self.data_t.isel({self.data.dims[1]:int(self.square_coords[1][0])}).plot(ax=self.axs[0, 1], color='green')
+                
             elif self.checkbox_k.isChecked():
                 integrate_k()
-                self.axs[1, 0].plot(self.axis[1][:],self.data[self.square_coords[0][1],:],color='orange')
-                self.axs[1, 0].plot(self.axis[1][:],self.data[self.square_coords[1][1],:],color='green')
+                self.data_t.isel({self.data.dims[0]:self.square_coords[0][1]}).plot(ax=self.axs[1, 0], color='orange')
+                self.data_t.isel({self.data.dims[0]:self.square_coords[1][1]}).plot(ax=self.axs[1, 0], color='green')
+                
             else:
-                self.axs[1, 0].plot(self.axis[1][:],self.data[self.square_coords[0][1],:],color='orange')
-                self.axs[1, 0].plot(self.axis[1][:],self.data[self.square_coords[1][1],:],color='green')
-                # self.axs[0, 1].plot(self.data[:,int(self.square_coords[0][0])],np.arange(self.data[:,int(self.square_coords[0][0])].shape[0]),color='orange') 
-                # self.axs[0, 1].plot(self.data[:,int(self.square_coords[1][0])],np.arange(self.data[:,int(self.square_coords[0][0])].shape[0]),color='green')
-                self.axs[0, 1].plot(self.data[:,int(self.square_coords[0][0])],self.axis[0][:],color='orange') 
-                self.axs[0, 1].plot(self.data[:,int(self.square_coords[1][0])],self.axis[0][:],color='green')
-                # save_data(self.axs[1], plot/abs(self.square_coords[0][1]-self.square_coords[1][1]),"EDC_time="+str(slider_t.val)+"_", [0.42,0.46],self.fig)
-                # save_data(self.axis[1], self.data[self.square_coords[0][1],:],"yellow, EDC_time="+str(slider_t.val)+"_", [0.42,0.46],self.fig)
-                # save_data(self.axis[1], self.data[self.square_coords[1][1],:],"green, EDC_time="+str(slider_t.val)+"_", [0.46,0.46],self.fig)
+                self.data_t.isel({self.data.dims[0]:self.square_coords[0][1]}).plot(ax=self.axs[1,0],color='orange')
+                self.data_t.isel({self.data.dims[0]:self.square_coords[1][1]}).plot(ax=self.axs[1,0],color='green')
+                self.data_t.isel({self.data.dims[1]:int(self.square_coords[0][0])}).plot(ax=self.axs[0,1],color='orange')
+                self.data_t.isel({self.data.dims[1]:int(self.square_coords[1][0])}).plot(ax=self.axs[0,1],color='green')
+                
+                
+    
             if self.checkbox_cursors.isChecked():
-                self.Line1=self.axs[1,0].axvline(x=self.cursorlinev1, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
-                self.Line2=self.axs[1,0].axvline(x=self.cursorlinev2, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
+                self.Line1 = self.axs[1, 0].axvline(x=self.cursorlinev1, color='red', linestyle='--', linewidth=2, label='Vertical Line', picker=10)
+                self.Line2 = self.axs[1, 0].axvline(x=self.cursorlinev2, color='red', linestyle='--', linewidth=2, label='Vertical Line', picker=10)
                 plt.draw()
                 self.fig.canvas.draw()
-            # print("update_show is called")
-            # line_profile(self.data[self.square_coords[0][1],:], self.axis[3][:],self.fig).line_profile()
-            # line_profile(self.data[self.square_coords[0][1],:], self.axis[3][:],self.fig)
+    
             box()
-            time1=self.axis[2][t]
-            timedt1=self.axis[2][t+dt]
-            # print( 'change')
-            self.axs[0,0].set_title(f't: {time1:.2f}, t+dt: {timedt1}')
-            im6.set_clim(vmin=self.data.min(), vmax=self.data.max())
+            time1 = self.axis[2][t]
+            timedt1 = self.axis[2][t + dt]
+            self.axs[0, 0].set_title(f't: {time1:.2f}, t+dt: {timedt1}')
             self.fig.canvas.draw()
-            plt.draw() 
- 
+            plt.draw()
+        
+        self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
+        
+        im6 = self.axs[0, 0].imshow(self.data_t.data, extent=[self.axis[1][0], self.axis[1][-1], self.axis[0][0], self.axis[0][-1]], origin='lower',cmap='terrain', aspect='auto')
+        
+        # define the cursors in the main graph
         
-        im6 = self.axs[0,0].imshow(self.datae, extent=[self.axis[1][0], self.axis[1][-1], self.axis[0][0], self.axis[0][-1]], origin='lower', cmap='viridis',aspect=1)
-       
         initial_x = 0
         initial_y = 0
         initial_x2 = 0.5
         initial_y2 = 0.5
-        ax=self.axs[0,0]
-        axe=self.axs[1,0]
-        # Create cursor lines with larger pick radius
-        cursor_vert1 = Line2D([initial_x, initial_x], [-200, len(self.data)+4000], color='yellow', linewidth=2, picker=10,linestyle='--')
-        cursor_horiz1 = Line2D([-200, len(self.data[0])+4000], [initial_y, initial_y], color='yellow', linewidth=2, picker=10,linestyle='--')
-        cursor_vert2 = Line2D([initial_x2, initial_x2], [-200, len(self.data)+4000], color='green', linewidth=2, picker=10,linestyle='--')
-        cursor_horiz2 = Line2D([-200, len(self.data[0])+4000], [initial_y2, initial_y2], color='green', linewidth=2, picker=10,linestyle='--')
-        # Create draggable dot at the intersection
+        ax = self.axs[0, 0]
+        axe = self.axs[1, 0]
+    
+        ymin, ymax = self.axs[0, 0].get_ylim()
+        xmin, xmax = self.axs[0, 0].get_ylim()
+        ymin, ymax = 5 * ymin, 5 * ymax
+        xmin, xmax = 5 * xmin, 5 * xmax
+        cursor_vert1 = Line2D([initial_x, initial_x], [ymin, ymax], color='yellow', linewidth=2, picker=10, linestyle='--')
+        cursor_horiz1 = Line2D([xmin, xmax], [initial_y, initial_y], color='yellow', linewidth=2, picker=10, linestyle='--')
+        cursor_vert2 = Line2D([initial_x2, initial_x2], [ymin, ymax], color='green', linewidth=2, picker=10, linestyle='--')
+        cursor_horiz2 = Line2D([xmin, xmax], [initial_y2, initial_y2], color='green', linewidth=2, picker=10, linestyle='--')
+        
+        # define the dots that connect the cursors
         dot1 = Circle((initial_x, initial_y), radius=0.05, color='yellow', picker=10)
         dot2 = Circle((initial_x2, initial_y2), radius=0.05, color='green', picker=10)
-        
+    
         if dot1.center[0] is not None and dot1.center[1] is not None and dot2.center[0] is not None and dot2.center[1] is not None:
-            x1_pixel=int((dot1.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            y1_pixel=int((dot1.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            self.square_coords[0]=(x1_pixel,y1_pixel)
-            x2_pixel=int((dot2.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            y2_pixel=int((dot2.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            self.square_coords[1]=(x2_pixel,y2_pixel)
-        # self.square_coords=[dot1.center,dot2.center]
-        # Add cursor lines and dot to the plot
+            x1_pixel = int((dot1.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+            y1_pixel = int((dot1.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
+            self.square_coords[0] = (x1_pixel, y1_pixel)
+            x2_pixel = int((dot2.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+            y2_pixel = int((dot2.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
+            self.square_coords[1] = (x2_pixel, y2_pixel)
+    
         ax.add_line(cursor_vert1)
         ax.add_line(cursor_horiz1)
         ax.add_patch(dot1)
         ax.add_line(cursor_vert2)
         ax.add_line(cursor_horiz2)
         ax.add_patch(dot2)
-        
+    
         ax.set_xlabel('Energy (eV)')
         ax.set_ylabel('Momentum (1/A)')
-        self.axs[0,1].set_xlabel('Energy (eV)')
-        self.axs[0,1].set_ylabel('intensity (a.u.)')
+        self.axs[0, 1].set_xlabel('Energy (eV)')
+        self.axs[0, 1].set_ylabel('intensity (a.u.)')
         initial_xe=1
         
         axe.axvline(x=initial_xe, color='red', linestyle='--',linewidth=2, label='Vertical Line')
@@ -376,10 +332,8 @@ def update_show(t,dt):
         plt.draw()
         update_show(self.slider1.value(),self.slider2.value()) 
         self.fig.canvas.draw()
-        # def update_cursors():
         self.active_cursor = None
-        def on_pick(event):
-            # global self.active_cursor
+        def on_pick(event): # function to pick up the cursors or the dots
             if event.artist == cursor_vert1:
                 self.active_cursor = cursor_vert1
             elif event.artist == cursor_horiz1:
@@ -392,20 +346,17 @@ def on_pick(event):
                 self.active_cursor = cursor_horiz2
             elif event.artist == dot2:
                 self.active_cursor = dot2
-            # elif event.artist == cursor_vert_e1:
-            #     self.active_cursor = cursor_vert_e1
             elif event.artist == self.Line1:
                 self.active_cursor =self. Line1
             elif event.artist == self.Line2:
                 self.active_cursor =self. Line2
         self.active_cursor=None
-        def on_motion(event):
-            # global self.active_cursor
+        def on_motion(event): # function to move the cursors or the dots
             if self.active_cursor is not None and event.inaxes == ax:
                 if self.active_cursor == cursor_vert1:
                     cursor_vert1.set_xdata([event.xdata, event.xdata])
                     dot1.center = (event.xdata, dot1.center[1])
-                    print(False)
+                    # print(False)
                 elif self.active_cursor == cursor_horiz1:
                     cursor_horiz1.set_ydata([event.ydata, event.ydata])
                     dot1.center = (dot1.center[0], event.ydata)
@@ -423,19 +374,18 @@ def on_motion(event):
                     dot2.center = (event.xdata, event.ydata)
                     cursor_vert2.set_xdata([event.xdata, event.xdata])
                     cursor_horiz2.set_ydata([event.ydata, event.ydata])
-                # print(dot1.center) 
                 self.fig.canvas.draw()
                 
                 
                 plt.draw()
-                if dot1.center[0] is not None and dot1.center[1] is not None and dot2.center[0] is not None and dot2.center[1] is not None:
+                if dot1.center[0] is not None and dot1.center[1] is not None and dot2.center[0] is not None and dot2.center[1] is not None: # convert the value of the pixel to the value of the slot in the data
                     x1_pixel=int((dot1.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
                     y1_pixel=int((dot1.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
                     self.square_coords[0]=(x1_pixel,y1_pixel)
                     x2_pixel=int((dot2.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
                     y2_pixel=int((dot2.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
                     self.square_coords[1]=(x2_pixel,y2_pixel)
-                
+                    
                 update_show(self.slider1.value(),self.slider2.value()) 
                
             elif self.active_cursor is not None and event.inaxes == axe:
@@ -445,18 +395,13 @@ def on_motion(event):
                 elif self.active_cursor == self.Line2:
                     self.Line2.set_xdata([event.xdata, event.xdata])
                     self.cursorlinev2= event.xdata
-                # print(dot1.center) 
-                # print(self.cursorlinev1,self.cursorlinev2)
                 self.fig.canvas.draw()
                 plt.draw()
                 self.v1_pixel=int((self.cursorlinev1 - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
                 self.v2_pixel=int((self.cursorlinev2 - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                # print(self.v1_pixel,self.v2_pixel)
-        def on_release(event):
-            # global self.active_cursor
+        def on_release(event):# function to release the selected object
             self.active_cursor = None
             
-        # Connect pick and motion events
         self.fig.canvas.mpl_connect('pick_event', on_pick)
         self.fig.canvas.mpl_connect('motion_notify_event', on_motion)
         self.fig.canvas.mpl_connect('button_release_event', on_release)
diff --git a/src/mpes_tools/fit_panel.py b/src/mpes_tools/fit_panel.py
index 49b7834..2fe0f03 100644
--- a/src/mpes_tools/fit_panel.py
+++ b/src/mpes_tools/fit_panel.py
@@ -1,12 +1,15 @@
 import sys
 from PyQt5.QtGui import QBrush, QColor
-from PyQt5.QtWidgets import QTextEdit, QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, QWidget, QSlider, QLabel, QAction, QCheckBox, QPushButton, QListWidget, QTableWidget, QTableWidgetItem, QTableWidget, QCheckBox, QSplitter
+from PyQt5.QtWidgets import QTextEdit, QLineEdit,QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, QWidget, QSlider, QLabel, QAction, QCheckBox, QPushButton, QListWidget, QTableWidget, QTableWidgetItem, QTableWidget, QCheckBox, QSplitter
 from PyQt5.QtCore import Qt
 from PyQt5.QtWidgets import QTableWidgetItem, QHBoxLayout, QCheckBox, QWidget
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 import matplotlib.pyplot as plt
+from scipy.optimize import curve_fit
 import numpy as np
+from lmfit.models import ExpressionModel,Model
 from lmfit import CompositeModel, Model
+from lmfit.lineshapes import gaussian, step
 import inspect
 from mpes_tools.movable_vertical_cursors_graph import MovableCursors
 from mpes_tools.make_model import make_model
@@ -14,8 +17,8 @@
 
 
 
-class MainWindow(QMainWindow):
-    def __init__(self,data,axis,c1,c2,t,dt):
+class fit_panel(QMainWindow):
+    def __init__(self,data,c1,c2,t,dt,panel):
         super().__init__()
 
         self.setWindowTitle("Main Window")
@@ -68,7 +71,8 @@ def __init__(self,data,axis,c1,c2,t,dt):
         
         self.slider = QSlider(Qt.Horizontal)
         self.slider.setMinimum(0)
-        self.slider.setMaximum(len(axis[2])-1)
+        # self.slider.setMaximum(len(axis[2])-1)
+        self.slider.setMaximum(len(data[data.dims[2]])-1)
         self.slider.setValue(t)
         self.slider.valueChanged.connect(self.update_label)
         self.slider2 = QSlider(Qt.Horizontal)
@@ -77,8 +81,11 @@ def __init__(self,data,axis,c1,c2,t,dt):
         self.slider2.setValue(dt)
         self.slider2.valueChanged.connect(self.update_label2)
  
-        self.label = QLabel("Slider Value: {t}")
-        self.label2 = QLabel("Slider Value: {dt}")
+        # self.label = QLabel("Slider Value: {t}")
+        # self.label2 = QLabel("Slider Value: {dt}")
+        
+        self.label = QLabel(f"{data.dims[2]}: {t}")
+        self.label2 = QLabel("Δ"+f"{data.dims[2]}: {dt}")
 
         # Create two checkboxes
         self.checkbox1 = QCheckBox("Multiply with Fermi Dirac")
@@ -86,7 +93,27 @@ def __init__(self,data,axis,c1,c2,t,dt):
 
         self.checkbox2 = QCheckBox("Convolve with a Gaussian")
         self.checkbox2.stateChanged.connect(self.checkbox2_changed)
-
+        
+        self.checkbox3 = QCheckBox("add background offset")
+        self.checkbox3.stateChanged.connect(self.checkbox3_changed)
+        
+        t0_layout = QHBoxLayout()
+        
+        self.mid_value_input = QLineEdit()
+        self.mid_value_input.setPlaceholderText("Intermediate value t_0")
+        
+        self.checkbox_t0 = QCheckBox("Fix first part before t_0")
+        self.checkbox_t0.stateChanged.connect(self.checkbox_t0_changed)
+        
+        t0_layout.addWidget(self.checkbox_t0)
+        t0_layout.addWidget(self.mid_value_input)
+        
+        self.guess_button = QPushButton("Guess")
+        self.guess_button.clicked.connect(self.button_guess_clicked)
+        
+        bigger_layout = QVBoxLayout()
+        bigger_layout.addLayout(t0_layout)
+        bigger_layout.addWidget(self.guess_button)
         # Create a QListWidget
         self.list_widget = QListWidget()
         self.list_widget.addItems(["linear","Lorentz", "Gauss", "sinusoid","constant","jump"])
@@ -106,6 +133,23 @@ def __init__(self,data,axis,c1,c2,t,dt):
         self.fit_button = QPushButton("Fit")
         self.fit_button.clicked.connect(self.fit)
         
+        # Layout for "Fit between" Button + Input Fields
+        fit_between_layout = QHBoxLayout()
+
+        self.fit_between_button = QPushButton("Fit between")
+        self.fit_between_button.clicked.connect(self.fit_between)
+
+        self.min_value_input = QLineEdit()
+        self.min_value_input.setPlaceholderText("Min value")
+
+        self.max_value_input = QLineEdit()
+        self.max_value_input.setPlaceholderText("Max value")
+
+        # Add widgets to the horizontal layout
+        fit_between_layout.addWidget(self.fit_between_button)
+        fit_between_layout.addWidget(self.min_value_input)
+        fit_between_layout.addWidget(self.max_value_input)
+        
         self.fitall_button = QPushButton("Fit all")
         self.fitall_button.clicked.connect(self.fit_all)
         
@@ -116,6 +160,7 @@ def __init__(self,data,axis,c1,c2,t,dt):
         left_buttons.addWidget(self.remove_button)
         left_buttons.addWidget(self.graph_button)
         left_buttons.addWidget(self.fit_button)
+        left_buttons.addLayout(fit_between_layout)
         left_buttons.addWidget(self.fitall_button)
         
         left_sublayout.addWidget(self.list_widget)
@@ -130,12 +175,6 @@ def __init__(self,data,axis,c1,c2,t,dt):
         left_layout.addWidget(self.label2)
         left_layout.addLayout(left_sublayout) 
         
-        # left_layout.addWidget(self.list_widget)
-        # left_layout.addWidget(self.add_button)
-        # left_layout.addWidget(self.remove_button)
-        # left_layout.addWidget(self.graph_button)
-        # left_layout.addWidget(self.fit_button)
-        # left_layout.addWidget(self.fitall_button)
         
         self.text_equation = QTextEdit()
         # self.text_equation.setMinimumSize(50, 50)  # Set minimum size
@@ -169,11 +208,15 @@ def __init__(self,data,axis,c1,c2,t,dt):
         # Add the table to the right layout
         checkboxes=QVBoxLayout()
         top_lay = QHBoxLayout()
+        above_table=QVBoxLayout()
         checkboxes.addWidget(self.checkbox1)
         checkboxes.addWidget(self.checkbox2)
+        checkboxes.addWidget(self.checkbox3)
         top_lay.addWidget(self.text_equation)
         top_lay.addLayout(checkboxes)
-        right_layout.addLayout(top_lay)
+        above_table.addLayout(top_lay)
+        above_table.addLayout(bigger_layout)
+        right_layout.addLayout(above_table)
         right_layout.addWidget(self.table_widget)
 
         # Add the splitter to the main layout
@@ -190,80 +233,60 @@ def zero(x):
         
         self.function_list=[]
         self.function_names_list=[]
-        # Add a button to activate cursors
-        # self.add_cursors_button = QPushButton("Add Movable Cursors", self)
-        # self.add_cursors_button.clicked.connect(self.add_movable_cursors)
-        # right_layout.addWidget(self.add_cursors_button)
-
-        # To hold the MovableCursors instance
         self.cursor_handler = None
         self.FD_state = False
         self.CV_state = False
-        print('data=',data.shape,'axs',len(axis),'axis1',len(axis[0]),'axis2',len(axis[1]),'axis3',len(axis[2]))
-        self.axs=axis
-        self.data_t=np.zeros((data.shape[1],data.shape[2]))
+        self.t0_state = False
+        self.offset_state = False
+        self.data=data
         x_min = int(min(c1, c2))
         x_max = int(max(c1, c2)) + 1
-        print('xmin=',x_min,'xmax=',x_max)
-        for i in range(x_min, x_max):
-            self.data_t += data[i, :,:]
-        print('data_t',self.data_t.shape)
+        # print('xmin=',x_min,'xmax=',x_max)
+        if panel =='box':
+            self.y=data
+        elif panel == data.dims[1]:
+            self.data_t=data.isel({data.dims[0]:slice(x_min, x_max)}).sum(dim=data.dims[0])
+            self.dim=data.dims[1]
+        elif panel ==data.dims[0]:
+            self.data_t=data.isel({data.dims[1]:slice(x_min, x_max)}).sum(dim=data.dims[1])
+            self.dim=data.dims[0]
+        self.panel=panel
         self.t=t
         self.dt=dt
-        print(t,dt)
+        # print(t,dt)
+        self.data=data
         self.slider.setValue(self.t)
         self.slider2.setValue(self.dt)
+        # self.data_t=self.data
         self.plot_graph(t,dt)
         self.fit_results=[]
-        
-    # def add_movable_cursors(self):
-    #     if self.cursor_handler is None:
-    #         # Initialize and add the cursors to the existing plot
-    #         self.cursor_handler = MovableCursors(self.axis)
-    #         self.canvas.draw()
+        self.axs=data[data.dims[2]].data
 
     def plot_graph(self,t,dt):
-        # Sample data
-        # self.x = np.linspace(-5,5,100)
-        # self.y = np.linspace(10,100,100)
-        self.y=np.zeros((self.data_t.shape[0]))
-        print('thecomp',self.y.shape,self.data_t[:,1].shape)
-        # data = loadtxt('C:/Users/admin-nisel131/Documents/CVS_TR_flatband_fig/EDC_time=0_2024-05-08_093401_6994.txt')
         self.axis.clear()
-        # self.x= data[:,0]   
-        # self.y= data[:,1]
-        self.x=self.axs[1][:]
-        for i in range(0,dt+1):
-            self.y +=self.data_t[:,t+i]
-        
-        
-        self.axis.plot(self.x, self.y, 'bo', label='Data')
 
-        self.axis.set_title('Sample Graph')
-        self.axis.set_xlabel('X')
-        self.axis.set_ylabel('Y')
-        self.axis.legend()
+        if self.panel != 'box':
+            self.y=self.data_t.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
+        self.y.plot(ax=self.axis)
         self.figure.tight_layout()
         self.canvas.draw()
-        print('sliders=',self.slider.value(),self.slider2.value())
     def update_text_edit_boxes(self):
         self.text_equation.setPlaceholderText("Top Right Text Edit Box")
     
-    def constant (self,x,b):
-        return 0*x+b
+    def offset_function (self,x,offset):
+        return 0*x+offset    
+    def constant (self,x,A):
+        return 0*x+A
     def linear (self,x,a,b):
         return a*x+b
     def lorentzian(self,x, A, x0, gamma):
-        c=0.0002
+        c=0.0000
         return A / (1 + ((x - x0) / (gamma+c)) ** 2)
-    # def fermi_dirac(self,x, mu, T,off):
-    #     kb = 8.617333262145 * 10**(-5)  # Boltzmann constant in eV/K
-    #     return 1 / (1 + np.exp((x - mu) / (kb * T)))+off
     def fermi_dirac(self,x, mu, T):
         kb = 8.617333262145 * 10**(-5)  # Boltzmann constant in eV/K
         return 1 / (1 + np.exp((x - mu) / (kb * T)))
-    def gaussian(self,x,A, mu, sigma):
-        return A* np.exp(-(x - mu)**2 / (2 * sigma**2))
+    def gaussian(self,x,A, x0, gamma):
+        return A* np.exp(-(x -x0)**2 / (2 * gamma**2))
     def gaussian_conv(self,x,sigma):
         return  np.exp(-(x)**2 / (2 * sigma**2))
     def jump(self,x, mid):
@@ -278,17 +301,21 @@ def jump2(self,x, mid,Amp):
         imid = max(np.where(x <= mid)[0])
         o[:imid] = Amp
         return o
-    
-    
-    def convolve(self, arr, kernel):
+
+    def centered_kernel(self,x, sigma):
+        mean = x.mean()
+        return np.exp(-(x-mean)**2/(2*sigma/2.3548200)**2)
+
+    def convolve(self,arr, kernel):
         """Simple convolution of two arrays."""
         npts = min(arr.size, kernel.size)
         pad = np.ones(npts)
         tmp = np.concatenate((pad*arr[0], arr, pad*arr[-1]))
-        out = np.convolve(tmp, kernel, mode='valid')
+        out = np.convolve(tmp, kernel/kernel.sum(), mode='valid')
         noff = int((len(out) - npts) / 2)
         return out[noff:noff+npts]
     
+    
     def convolution(x, func, *args, sigma=1.0):
             N = 20  # Assuming N is intended to be a local variable here
             x_step = x[1] - x[0]
@@ -311,55 +338,34 @@ def convolution(x, func, *args, sigma=1.0):
             
             return convolution_result[N-1:-1]
     
-    # def convolution(self,x,sigma,f):
-    #     global N
-    #     xmax=x[-1]
-    #     xmin=x[0]
-    #     N=20
-    #     y=np.zeros(N+len(x))
-    #     x_step=x[1]-x[0]
-    #     for i in range(0,N):
-    #         y[i]=x[0]-(N-i)*x_step
-    #     for i in range(0,len(x)):
-    #         y[i+N]=x[i]
-    #     x_gauss = np.linspace(-0.5, 0.5, len(self.ax))
-    #     gaussian_values = self.gaussian(x_gauss, 0, sigma)
-    #     # function_values = 
-    #     convolution = np.convolve( function_values, gaussian_values, mode='same')
-    #     return convolution[N-1:-1]
-    
+
     def show_graph_window(self):
-        # Create a new graph window and show it
-        # graph_window = GraphWindow()
-        # graph_window.show()
-        
-        # # Store a reference to the window to prevent it from being garbage collected
-        # self.graph_windows.append(graph_window)
         self.axis.clear()
         self.plot_graph(self.t,self.dt)
         
         
     def update_label(self, value):
-        self.label.setText(f"Slider Value: {value}")
+        # self.label.setText(f"Slider Value: {value}")
+        base = self.label.text().split(':')[0]
+        self.label.setText(f"{base}: {value}")
         self.t=self.slider.value()
         self.plot_graph(self.t,self.dt)
     def update_label2(self, value):
-        self.label2.setText(f"Slider Value: {value}")
+        # self.label2.setText(f"Slider Value: {value}")
+        base = self.label2.text().split(':')[0]
+        self.label2.setText(f"{base}: {value}")
         self.dt=self.slider2.value()
         self.plot_graph(self.t,self.dt)
     
     def checkbox0_changed(self, state):
-        # MovableCursors(self.axis)
         if state == Qt.Checked:
             if self.cursor_handler is None:
-                # Initialize and add the cursors to the existing plot
                 self.cursor_handler = MovableCursors(self.axis)
                 self.canvas.draw()
             else:
                 self.cursor_handler.redraw()
         else:
             self.cursor_handler.remove()
-            # self.cursor_handler= None
     
     def checkbox1_changed(self, state):
         if self.CV_state== True:
@@ -369,15 +375,9 @@ def checkbox1_changed(self, state):
         if state == Qt.Checked:
             self.FD_state = True
             self.update_equation()
-            # pos=0
-            
-            print("Checkbox 1 is checked")
-            # new_row_name = QTableWidgetItem('Fermi')
             self.table_widget.insertRow(pos)
             label_item = QTableWidgetItem("Fermi")
-            # label_item.setTextAlignment(0x0004 | 0x0080)  # Align center
             self.table_widget.setVerticalHeaderItem(pos, label_item)
-            # self.table_widget.setVerticalHeaderItem(0, new_row_name)
             for col in range(4):
                 item = QTableWidgetItem('')
                 item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
@@ -386,14 +386,12 @@ def checkbox1_changed(self, state):
             c=self.table_widget.rowCount()
             self.table_widget.insertRow(pos+1)
             label_item1 = QTableWidgetItem("Fermi level")
-            # label_item1.setTextAlignment(0x0004 | 0x0080)  # Align center
             checkbox_widget = QWidget()
             checkbox_layout = QHBoxLayout()
             checkbox_layout.setAlignment(Qt.AlignCenter)
             checkbox = QCheckBox()
-            # checkbox.stateChanged.connect(self.handle_checkbox_state_change)
             checkbox.stateChanged.connect(lambda state, row= pos+1: self.handle_checkbox_state_change(state, row))
-            print('thecount',c+1)
+            # print('thecount',c+1)
             checkbox_layout.addWidget(checkbox)
             checkbox_widget.setLayout(checkbox_layout)
             self.table_widget.setCellWidget(pos+1, 3, checkbox_widget)
@@ -405,20 +403,15 @@ def checkbox1_changed(self, state):
             checkbox_layout = QHBoxLayout()
             checkbox_layout.setAlignment(Qt.AlignCenter)
             checkbox = QCheckBox()
-            # checkbox.stateChanged.connect(self.handle_checkbox_state_change)
             checkbox.stateChanged.connect(lambda state, row= pos+2: self.handle_checkbox_state_change(state, row))
             checkbox_layout.addWidget(checkbox)
             checkbox_widget.setLayout(checkbox_layout)
             self.table_widget.setCellWidget(pos+2, 3, checkbox_widget)
-            # label_item2.setTextAlignment(0x0004 | 0x0080)  # Align center
             self.table_widget.setVerticalHeaderItem(pos+2, label_item2)
-            
-            
-            
         else:
             self.FD_state = False
             self.update_equation()
-            print("Checkbox 1 is unchecked")
+            # print("Checkbox 1 is unchecked")
             
             self.table_widget.removeRow(pos)
             self.table_widget.removeRow(pos)
@@ -429,13 +422,9 @@ def checkbox2_changed(self, state):
             self.CV_state = True
             
             self.update_equation()
-           
-           
-            print("Checkbox 1 is checked")
-            # new_row_name = QTableWidgetItem('Fermi')
+
             self.table_widget.insertRow(0)
             label_item = QTableWidgetItem("Convolution")
-            # label_item.setTextAlignment(0x0004 | 0x0080)  # Align center
             self.table_widget.setVerticalHeaderItem(0, label_item)
             # self.table_widget.setVerticalHeaderItem(0, new_row_name)
             for col in range(4):
@@ -450,32 +439,32 @@ def checkbox2_changed(self, state):
             checkbox_layout = QHBoxLayout()
             checkbox_layout.setAlignment(Qt.AlignCenter)
             checkbox = QCheckBox()
-            # checkbox.stateChanged.connect(self.handle_checkbox_state_change)
             checkbox.stateChanged.connect(lambda state, row= 1: self.handle_checkbox_state_change(state, row))
             checkbox_layout.addWidget(checkbox)
             checkbox_widget.setLayout(checkbox_layout)
             self.table_widget.setCellWidget(1, 3, checkbox_widget)
-            # label_item1.setTextAlignment(0x0004 | 0x0080)  # Align center
             self.table_widget.setVerticalHeaderItem(1, label_item1)
             
-            # self.table_widget.insertRow(2)
-            # label_item2 = QTableWidgetItem("Temperature")
-            # # label_item2.setTextAlignment(0x0004 | 0x0080)  # Align center
-            # self.table_widget.setVerticalHeaderItem(2, label_item2)
-            
-            
-            
         else:
             self.CV_state = False
             self.update_equation()
-            print("Checkbox 1 is unchecked")
+            # print("Checkbox 1 is unchecked")
             
             self.table_widget.removeRow(0)
             self.table_widget.removeRow(0)
-            # self.table_widget.removeRow(0)
-
+    def checkbox3_changed(self, state):
+        if state == Qt.Checked:
+            self.offset_state=True
+        else:
+            self.offset_state=False
+    def checkbox_t0_changed(self, state):
+        if state == Qt.Checked:
+            self.t0_state=True
+        else:
+            self.t0_state=False
+        
     def item_selected(self, item):
-        print(f"Selected: {item.text()}")
+        # print(f"Selected: {item.text()}")
         if item.text() == 'Lorentz':
             self.function_selected = self.lorentzian
         elif item.text() == 'Gauss':
@@ -486,29 +475,52 @@ def item_selected(self, item):
             self.function_selected =self.constant
         elif item.text()=='jump':
             self.function_selected =self.jump2
-        # print(self.list_widget.currentItem().text())
+        
+    def button_guess_clicked(self):
+        cursors= self.cursor_handler.cursors()
+        self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+        self.x_f=self.y_f[self.dim]
+        max_value= self.y_f.data.max()
+        min_value= self.y_f.data.min()
+        mean_value= self.y_f.data.mean()
+        max_arg=self.y_f.data.argmax()
+        # print(self.x_f[max_arg].item())
+        for row in range(self.table_widget.rowCount()):
+            header_item = self.table_widget.verticalHeaderItem(row)
+            if "A" in header_item.text():
+                self.params[header_item.text()].set(value=max_value)
+                item = QTableWidgetItem(str(max_value))
+                self.table_widget.setItem(row, 1, item)
+            elif "x0" in header_item.text():
+                self.params[header_item.text()].set(value=self.x_f[max_arg].item())
+                item = QTableWidgetItem(str(self.x_f[max_arg].item()))
+                self.table_widget.setItem(row, 1, item)
+            elif "gamma" in header_item.text():
+                self.params[header_item.text()].set(value=0.2)
+                item = QTableWidgetItem(str(0.2))
+                self.table_widget.setItem(row, 1, item)
+        
+        
+        # print('the self.params=',self.params)
+            
+            
     
     def button_remove_clicked(self):
         if self.i>0:
             self.i-=1
-        # self.mod=
-        # print('removal')
         current_row_count = self.table_widget.rowCount()
-        print(current_row_count)
         sig = inspect.signature(self.function_list[-1])
         params = sig.parameters
         
         for p in range(len(params)):
-            # print('p=',p)
-            # print('count=',current_row_count-1-p)
             self.table_widget.removeRow(current_row_count-1-p)    
             
         self.function_list.remove(self.function_list[-1])
         self.function_names_list.remove(self.function_names_list[-1])
         self.update_equation()
+        self.create()
 
     def button_add_clicked(self):
-        # print(self.cursor_handler.cursors())
         def zero(x):
             return 0
         
@@ -516,13 +528,8 @@ def zero(x):
         self.i+=1
         self.function_list.append(self.function_selected)
         self.function_names_list.append(self.list_widget.currentItem().text())
-       
-        print('the list=',self.function_list,'iten',self.function_list[0])
-        print('listlength=',len(self.function_list))
         j=0
         for p in self.function_list:
-            # j=0
-            print('j==',j)
             current_function=Model(p,prefix='f'+str(j)+'_')
             j+=1
             
@@ -530,7 +537,6 @@ def zero(x):
         current_row_count = self.table_widget.rowCount()
         
         self.table_widget.insertRow(current_row_count)
-        # self.table_widget.setVerticalHeaderLabels([self.list_widget.currentItem().text()])
         new_row_name = QTableWidgetItem(self.list_widget.currentItem().text())
         self.table_widget.setVerticalHeaderItem(current_row_count, new_row_name)
         for col in range(4):
@@ -539,34 +545,27 @@ def zero(x):
             self.table_widget.setItem(current_row_count, col, item)
             item.setBackground(QBrush(QColor('grey')))
         c=current_row_count
-        # self.table_widget.insertRow(1)
-        # self.table_widget.insertRow(2)
         for p in range(len(current_function.param_names)):
-            # c+=1
-            # print(c+p+1)
+
             self.table_widget.insertRow(c+p+1)
-            print(current_function.param_names[p])
+            # print(current_function.param_names[p])
             new_row_name = QTableWidgetItem(current_function.param_names[p])
             self.table_widget.setVerticalHeaderItem(c+p+1, new_row_name)
             checkbox_widget = QWidget()
             checkbox_layout = QHBoxLayout()
             checkbox_layout.setAlignment(Qt.AlignCenter)
             checkbox = QCheckBox()
-            # checkbox.stateChanged.connect(self.handle_checkbox_state_change)
             checkbox.stateChanged.connect(lambda state, row=c + p + 1: self.handle_checkbox_state_change(state, row))
             checkbox_layout.addWidget(checkbox)
             checkbox_widget.setLayout(checkbox_layout)
             self.table_widget.setCellWidget(c+p+1, 3, checkbox_widget)
-            # self.table_widget.setVerticalHeaderLabels([Model(self.function_selected).param_names[p]])
-        # print(self.Mod.param_names)
-        # params['A'].set(value=1.35, vary=True, expr='')
         
         self.update_equation()
-        # print(self.params)
+        self.create()
         
     def update_equation(self):
         self.equation=''
-        print('names',self.function_names_list)
+        # print('names',self.function_names_list)
         for j,n in enumerate(self.function_names_list):
             if len(self.function_names_list)==1:
                 self.equation= n
@@ -578,31 +577,50 @@ def update_equation(self):
         if self.FD_state:
             self.equation= '('+ self.equation+ ')* Fermi_Dirac'
         self.text_equation.setPlainText(self.equation)
-        print('equation',self.equation)
+        # print('equation',self.equation)
     
 
     def table_item_changed(self, item):
-        print(f"Table cell changed at ({item.row()}, {item.column()}): {item.text()}")
+        # print(f"Table cell changed at ({item.row()}, {item.column()}): {item.text()}")
         header_item = self.table_widget.verticalHeaderItem(item.row())
-        # print(header_item.text())
-        print('theeeeeeitem=',item.text())
+        # print('theeeeeeitem=',item.text())
         
     def handle_checkbox_state_change(self,state,row):
         if state == Qt.Checked:
-            print("Checkbox is checked")
-            print(row)
             header_item = self.table_widget.verticalHeaderItem(row)
-            # self.params[header_item.text()].vary = False
             
         else:
-            print("Checkbox is unchecked")
             header_item = self.table_widget.verticalHeaderItem(row)
-            # self.params[header_item.text()].vary = True
+    def create(self):
+        def zero(x):
+            return 0
+        cursors= self.cursor_handler.cursors()
+        self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+        self.x_f=self.y_f[self.dim]
+        # print(self.y_f)
+        if self.offset_state==True:
+            self.params['offset'].set(value=self.y_f.data.min())
+        list_axis=[[self.y[self.dim]],[self.x_f]]
+        self.mod= Model(zero)
+        j=0
+        for f in self.function_list:
+            self.mod+=Model(f,prefix='f'+str(j)+'_')
+            j+=1
+        if self.FD_state == True:
+            self.mod= self.mod* Model(self.fermi_dirac)
+        if self.CV_state == True:
+            self.mod = CompositeModel(self.mod, Model(self.centered_kernel), self.convolve)
+        if self.offset_state==True:
+            self.mod= self.mod+Model(self.offset_function)
+        m1=make_model(self.mod, self.table_widget)
+        self.mod=m1.current_model()
+        self.params=m1.current_params()
     def fit(self):
         
         def zero(x):
             return 0
         self.mod= Model(zero)
+        cursors= self.cursor_handler.cursors()
         j=0
         for f in self.function_list:
             self.mod+=Model(f,prefix='f'+str(j)+'_')
@@ -610,30 +628,30 @@ def zero(x):
         if self.FD_state == True:
             self.mod= self.mod* Model(self.fermi_dirac)
         if self.CV_state == True:
-            # self.mod=CompositeModel(self.mod, Model(self.gaussian_conv), self.convolve)
-            self.mod=CompositeModel(self.mod, Model(self.gaussian_conv), self.convolve)
-            # self.mod=CompositeModel(Model(self.jump), Model(gaussian), self.convolve)
-            
+            self.mod = CompositeModel(self.mod, Model(self.centered_kernel), self.convolve)
+        if self.offset_state==True:
+            self.mod= self.mod+Model(self.offset_function)
         m1=make_model(self.mod, self.table_widget)
         self.mod=m1.current_model()
-        # self.mod = CompositeModel(m1.current_model(), Model(gaussian), self.convolve)
         self.params=m1.current_params()
-        # self.params=self.mod.make_params()
-        cursors= self.cursor_handler.cursors()
-        self.x_f=self.x[cursors[0]:cursors[1]]
-        self.y_f=self.y[cursors[0]:cursors[1]]
-        print(self.params)
-        # params['b'].set(value=0, vary=True, expr='')
-        # out = mod.fit(self.data[:,1], params, x=self.data[:,0],method='nelder')
+        self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+        self.x_f=self.y_f[self.dim]
+        if self.offset_state==True:
+            self.params['offset'].set(value=self.y_f.data.min())
+        # print(self.params)
         out = self.mod.fit(self.y_f, self.params, x=self.x_f)
-        # dely = out.eval_uncertainty(sigma=3)
         print(out.fit_report(min_correl=0.25))
         self.axis.plot(self.x_f,out.best_fit,color='red',label='fit')
-        # self.axis.plot(self.x_f,1e5*self.gaussian_conv(self.x_f,out.best_values['sigma']))
-    def fit_all(self):
+        self.figure.tight_layout()
+        self.canvas.draw()
+        
+    def fit_between(self):
+        min_val = int(self.min_value_input.text())
+        max_val = int(self.max_value_input.text())
         self.fit_results=[]
         def zero(x):
             return 0
+        cursors= self.cursor_handler.cursors()
         self.mod= Model(zero)
         j=0
         for f in self.function_list:
@@ -642,29 +660,26 @@ def zero(x):
         if self.FD_state == True:
             self.mod= self.mod* Model(self.fermi_dirac)
         if self.CV_state == True:
-            # self.mod=CompositeModel(self.mod, Model(self.gaussian_conv), self.convolve)
-            self.mod=CompositeModel(self.mod, Model(self.gaussian_conv), self.convolve)
+            self.mod = CompositeModel(self.mod, Model(self.centered_kernel), self.convolve)
+        if self.offset_state==True:
+            self.mod= self.mod+Model(self.offset_function)
         m1=make_model(self.mod, self.table_widget)
         self.mod=m1.current_model()
         self.params=m1.current_params()
         for pname, par in self.params.items():
-            print('the paramsnames or',pname, par)
-            setattr(self, pname, np.zeros((len(self.axs[2]))))
-            # self.pname=np.zeros((len(self.axs[2])))
-        cursors= self.cursor_handler.cursors()
-        for i in range(len(self.axs[2])-self.dt):
-            self.y=np.zeros((self.data_t.shape[0]))
-            for j in range (self.dt+1):
-                self.y+= self.data_t[:,i+j]
-            self.x_f=self.x[cursors[0]:cursors[1]]
-            self.y_f=self.y[cursors[0]:cursors[1]]
-            # print(self.params)
-            # params['b'].set(value=0, vary=True, expr='')
-            # out = mod.fit(self.data[:,1], params, x=self.data[:,0],method='nelder')
+            # print('the paramsnames or',pname, par)
+            setattr(self, pname, np.zeros((max_val-self.dt-min_val)))
+        self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+        self.x_f=self.y_f[self.dim]
+        if self.offset_state==True:
+            self.params['offset'].set(value=self.y_f.data.min())
+        
+        for i in range(min_val,max_val-self.dt):
+            self.y=self.data_t.isel({self.data.dims[2]:slice(i, i+self.dt+1)}).sum(dim=self.data.dims[2])
+            self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+            self.x_f=self.y_f[self.dim]
             self.axis.clear()
             out = self.mod.fit(self.y_f, self.params, x=self.x_f)
-            # dely = out.eval_uncertainty(sigma=3)
-            # print(out.fit_report(min_correl=0.25))
             self.axis.plot(self.x,self.y, 'bo', label='Data')
             self.axis.plot(self.x_f,out.best_fit,color='red',label='fit')
             for pname, par in self.params.items():
@@ -672,26 +687,136 @@ def zero(x):
                 array[i]=out.best_values[pname]
                 setattr(self, pname,array)
         if self.dt>0:
-            self.axs[2]=self.axs[2][:-self.dt]
+            self.axs=self.axs[:-self.dt]
             for pname, par in self.params.items():
                 self.fit_results.append(getattr(self, pname)[:-self.dt])
         else:
             for pname, par in self.params.items():
                 self.fit_results.append(getattr(self, pname))
-        print('fit_results',len(self.fit_results))
-        print('thelengthis=',self.fit_results[0].shape)
         
             
-        sg=showgraphs(self.axs[2], self.fit_results)
+        # sg=showgraphs(self.axs[min_val:max_val-self.dt], self.fit_results)
+        sg=showgraphs(self.data[self.data.dims[2]][min_val:max_val-self.dt], self.fit_results)
+        sg.show()
+        self.graph_windows.append(sg)
+        
+    def fit_all(self):
+        # C=False
+        list_plot_fits=[]
+        
+        fixed_list=[]
+        names=[]
+        self.fit_results=[]
+        def zero(x):
+            return 0
+        cursors= self.cursor_handler.cursors()
+        
+        self.mod= Model(zero)
+        j=0
+        for f in self.function_list:
+            self.mod+=Model(f,prefix='f'+str(j)+'_')
+            j+=1
+        if self.FD_state == True:
+            self.mod= self.mod* Model(self.fermi_dirac)
+        if self.CV_state == True:
+            self.mod = CompositeModel(self.mod, Model(self.centered_kernel), self.convolve)
+        if self.offset_state==True:
+            self.mod= self.mod+Model(self.offset_function)
+        m1=make_model(self.mod, self.table_widget)
+        self.mod=m1.current_model()
+        self.params=m1.current_params()
+        
+        self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+        self.x_f=self.y_f[self.dim]
+        if self.offset_state==True:
+            self.params['offset'].set(value=self.y_f.data.min())
+        list_axis=[[self.y[self.dim]],[self.x_f]]
+        # print('the items',self.params.items())
+        for pname, par in self.params.items():
+            if not par.vary:  # Check if vary is False
+                # print(f"Parameter '{pname}' is fixed at {par.value}")
+                fixed_list.append(pname)
+            # print('the paramsnames or',pname, par)
+            setattr(self, pname, np.zeros((len(self.axs))))
+        
+        if self.t0_state==False:
+            for i in range(len(self.axs)-self.dt):
+                self.y=self.data_t.isel({self.data.dims[2]:slice(i, i+self.dt+1)}).sum(dim=self.data.dims[2])
+                self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+                self.x_f=self.y_f[self.dim]
+                self.axis.clear()
+                out = self.mod.fit(self.y_f, self.params, x=self.x_f)
+                self.y.plot(ax=self.axis)
+                self.axis.plot(self.x_f,out.best_fit,color='red',label='fit')
+                list_plot_fits.append([[self.y],[out.best_fit]])
+                for pname, par in self.params.items():
+                    array=getattr(self, pname)
+                    array[i]=out.best_values[pname]
+                    setattr(self, pname,array)
+                    
+        else:
+            if self.mid_value_input.text() is not None:
+                mid_val = int(self.mid_value_input.text())
+            self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+            self.x_f=self.y_f[self.dim]
+            
+            for i in range(0,mid_val-self.dt):
+                self.y=self.data_t.isel({self.data.dims[2]:slice(i, i+self.dt+1)}).sum(dim=self.data.dims[2])
+                self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+                self.x_f=self.y_f[self.dim]
+                self.axis.clear()
+                out = self.mod.fit(self.y_f, self.params, x=self.x_f)
+                self.y.plot(ax=self.axis)
+                self.axis.plot(self.x_f,out.best_fit,color='red',label='fit')
+                list_plot_fits.append([[self.y],[out.best_fit]])
+                for pname, par in self.params.items():
+                    array=getattr(self, pname)
+                    array[i]=out.best_values[pname]
+                    setattr(self, pname,array)
+            sigma_mean= getattr(self, 'sigma')[0:mid_val-self.dt].mean()
+            self.params['sigma'].set(value=sigma_mean, vary=False )
+            # print(sigma_mean)
+            for p in fixed_list:
+                self.params[p].vary=True
+                # print(p)
+            self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+            self.x_f=self.y_f[self.dim]
+            
+            for i in range(mid_val-self.dt,len(self.axs)-self.dt):
+                self.y=self.data_t.isel({self.data.dims[2]:slice(i, i+self.dt+1)}).sum(dim=self.data.dims[2])
+                self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+                self.x_f=self.y_f[self.dim]
+                self.axis.clear()
+                out = self.mod.fit(self.y_f, self.params, x=self.x_f)
+                self.y.plot(ax=self.axis)
+                self.axis.plot(self.x_f,out.best_fit,color='red',label='fit')
+                list_plot_fits.append([[self.y],[out.best_fit]])
+                for pname, par in self.params.items():
+                    array=getattr(self, pname)
+                    array[i]=out.best_values[pname]
+                    setattr(self, pname,array)
+            # print('second T',getattr(self, 'T'))
+        if self.dt>0:
+            # self.axs=self.axs[:-self.dt]
+            for pname, par in self.params.items():
+                self.fit_results.append(getattr(self, pname)[:-self.dt])
+                names.append(pname)
+                print('dt>0')  
+                print(len(getattr(self, pname)))
+        else:
+            for pname, par in self.params.items():
+                self.fit_results.append(getattr(self, pname))
+                names.append(pname)
+                print('dt=0')  
+                print(len(getattr(self, pname)))
+        # print('th dt',self.dt)    
+        print('the xaxis',len(self.data[self.data.dims[2]][:len(self.data[self.data.dims[2]])-self.dt]))
+        sg=showgraphs(self.data[self.data.dims[2]][:len(self.data[self.data.dims[2]])-self.dt], self.fit_results,names,list_axis,list_plot_fits)
         sg.show()
         self.graph_windows.append(sg)
-        # pname='T'
-        # print(getattr(self, pname))
-            # out.best_values['A1']
-            # self.axis.clear()
 
 if __name__ == "__main__":
     app = QApplication(sys.argv)
-    window = MainWindow()
+    window = fit_panel()
     window.show()
     sys.exit(app.exec_())
diff --git a/src/mpes_tools/graphs.py b/src/mpes_tools/graphs.py
index 7b50216..7dcccd2 100644
--- a/src/mpes_tools/graphs.py
+++ b/src/mpes_tools/graphs.py
@@ -1,80 +1,115 @@
 import sys
 import numpy as np
-from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QPushButton, QGridLayout
+from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QPushButton, QGridLayout,QSlider,QLabel
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 import matplotlib.pyplot as plt
 
 class showgraphs(QMainWindow):
-    def __init__(self, x, y_arrays):
+    def __init__(self, x, y_arrays,names,list_axis,list_plot_fits):
         super().__init__()
         self.setWindowTitle("Multiple Array Plots")
         self.setGeometry(100, 100, 800, 600)
 
         # Store x and y data
-        self.x = x
+        self.dim=x.dims[0]
+        self.x = x.data
         self.y_arrays = y_arrays
         self.num_plots = len(y_arrays)
-
+        self.list_plot_fits=list_plot_fits
+        self.list_axis=list_axis
         # Create a central widget and layout
         central_widget = QWidget(self)
         self.setCentralWidget(central_widget)
         layout = QGridLayout(central_widget)
-
+        
+        
+        # print(len(x),len(list_plot_fits))
+        # print(list_plot_fits[0])
+        slider = QSlider()
+        slider.setOrientation(1)  # 1 = Qt.Horizontal
+        slider.setMinimum(0)
+        slider.setMaximum(len(x)-1)  # Adjust as needed
+        slider.setValue(0)  # Default value
+        slider.valueChanged.connect(self.update_parameter)  # Function to update parameter
+        
+        self.slider_label = QLabel(f"{x.dims[0]}:0")
+        
+        self.figure, self.axis = plt.subplots()
+        self.canvas = FigureCanvas(self.figure)
+        
+        vbox = QVBoxLayout()
+        vbox.addWidget(self.canvas)
+        vbox.addWidget(self.slider_label)
+        vbox.addWidget(slider)
+        
+        layout.addLayout(vbox, 0, 0)  # Place in top-left
+        self.update_parameter(0)
         # Create and add buttons and plots for each y array in a 3x3 layout
         for i, y in enumerate(y_arrays):
             # Create a button to show the plot in a new window
             button = QPushButton(f"Show Plot {i+1}")
             button.setFixedSize(80, 30)  # Set a fixed size for the button
-            button.clicked.connect(lambda checked, y=y, index=i+1: self.show_plot(y, index))
+            button.clicked.connect(lambda checked, y=y, index=i+1: self.show_plot(y, index, names[i]))
 
             # Calculate grid position
-            row = (i // 3) * 2  # Each function will take 2 rows: one for the plot, one for the button
-            col = i % 3
+            row = ((i+1) // 3) * 2   # Each function will take 2 rows: one for the plot, one for the button
+            col = (i+1) % 3
 
             # Add the plot canvas to the grid
-            layout.addWidget(self.create_plot_widget(y, f"Plot {i+1}"), row, col)  # Plot in a 3x3 grid
+            layout.addWidget(self.create_plot_widget(y, f"Plot {i+1}_"+names[i]), row, col)  # Plot in a 3x3 grid
             layout.addWidget(button, row + 1, col)  # Button directly below the corresponding plot
-
+        
     def create_plot_widget(self, y, title):
         """Creates a plot widget for displaying a function."""
         figure, ax = plt.subplots()
         ax.plot(self.x, y)
         ax.set_title(title)
         ax.grid(True)
-        ax.set_xlabel('x')
-        ax.set_ylabel('y')
+        ax.set_xlabel(self.dim)
+        # ax.set_ylabel('y')
 
         # Create a FigureCanvas to embed in the Qt layout
         canvas = FigureCanvas(figure)
         return canvas  # Return the canvas so it can be used in the layout
 
-    def show_plot(self, y, index):
+    def show_plot(self, y, index, name):
         """Show the plot in a new window."""
         figure, ax = plt.subplots()
         ax.plot(self.x, y)
-        ax.set_title(f"Plot {index}")
+        ax.set_title(f"Plot {index}_"+ name)
         ax.grid(True)
-        ax.set_xlabel('x')
-        ax.set_ylabel('y')
+        ax.set_xlabel(self.dim)
+        # ax.set_ylabel('y')
         plt.show()  # Show the figure in a new window
+    def update_parameter(self, value):
+        base = self.slider_label.text().split(':')[0]
+        print("self.x:", self.x)
+        print("Slider value:", value)
+        self.slider_label.setText(f"{base}: {self.x[value]:.2f}")
+        self.axis.clear()
+        
+        self.axis.plot(self.list_axis[0][0],self.list_plot_fits[value][0][0],'o', label='data')
+        self.axis.plot(self.list_axis[1][0],self.list_plot_fits[value][1][0],'r--', label='fit')
+        self.axis.legend()
+        self.figure.tight_layout()
+        self.canvas.draw()
+    def create_plot_widget1(self,x_data, y_data, title, return_axes=False):
+        from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+        import matplotlib.pyplot as plt
+    
+        fig, ax = plt.subplots()
+        canvas = FigureCanvas(fig)  
+    
+        ax.plot(x_data,y_data)
+        ax.set_title(title)
+    
+        if return_axes:
+            return canvas, ax  # Allow updating later
+        return canvas
 
 if __name__ == "__main__":
     app = QApplication(sys.argv)
     
-    # # Example data: Define x and multiple y arrays
-    # x = np.linspace(-10, 10, 400)
-    # y_arrays = [
-    #     np.sin(x),
-    #     np.cos(x),
-    #     np.tan(x),
-    #     np.exp(x / 10),
-    #     x**2,
-    #     x**3,
-    #     np.abs(x),
-    #     np.log(x + 11),  # Shift to avoid log(0)
-    #     np.sqrt(x + 11)  # Shift to avoid sqrt of negative
-    # ]
-    
     main_window = showgraphs()
     main_window.show()
     sys.exit(app.exec_())
diff --git a/src/mpes_tools/hdf5.py b/src/mpes_tools/hdf5.py
index 5b133c9..5d4d45d 100644
--- a/src/mpes_tools/hdf5.py
+++ b/src/mpes_tools/hdf5.py
@@ -46,7 +46,7 @@ def recursive_write_metadata(h5group: h5py.Group, node: dict):
             try:
                 h5group.create_dataset(key, data=str(item))
                 print(f"Saved {key} as string.")
-            except Exception as exc:
+            except BaseException as exc:
                 raise ValueError(
                     f"Unknown error occurred, cannot save {item} of type {type(item)}.",
                 ) from exc
diff --git a/src/mpes_tools/movable_vertical_cursors_graph.py b/src/mpes_tools/movable_vertical_cursors_graph.py
index 580f4a8..44dcbf9 100644
--- a/src/mpes_tools/movable_vertical_cursors_graph.py
+++ b/src/mpes_tools/movable_vertical_cursors_graph.py
@@ -13,9 +13,7 @@ def __init__(self, ax):
         
         self.cursorlinev1=self.axis[int(len(self.axis)/4)]
         self.cursorlinev2=self.axis[int(3*len(self.axis)/4)]
-        # Create initial cursors (at the middle of the plot)
-        # self.v1_cursor = self.ax.axvline(x=5, color='r', linestyle='--', label='Cursor X')
-        # self.v2_cursor = self.ax.axhline(y=0, color='g', linestyle='--', label='Cursor Y')
+
         
         self.Line1=self.ax.axvline(x=self.cursorlinev1, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
         self.Line2=self.ax.axvline(x=self.cursorlinev2, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
@@ -51,10 +49,6 @@ def find_nearest_index(array, value):
             self.v1_pixel=find_nearest_index(self.axis, self.cursorlinev1)
             self.v2_pixel=find_nearest_index(self.axis, self.cursorlinev2)
             
-            # self.v1_pixel=int((self.cursorlinev1 - self.axis[0]) / (self.axis[-1] - self.axis[0]) * (self.axis.shape[0] - 1) + 0.5)
-            # self.v2_pixel=int((self.cursorlinev2 - self.axis[0]) / (self.axis[-1] - self.axis[0]) * (self.axis.shape[0] - 1) + 0.5)
-            print(self.v1_pixel,self.v2_pixel)
-            
             # print(self.v1_pixel,self.v2_pixel)
     def on_release(self,event):
         # global self.active_cursor

From 7a33a6a5b02fd0d71bebb6ada75526904cdfa09a Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Thu, 10 Apr 2025 12:11:18 +0200
Subject: [PATCH 02/67] new additions with the main interface and the 4d gui

---
 src/mpes_tools/Drawwindow.py     | 173 +++++++++++++
 src/mpes_tools/METIS.png         | Bin 0 -> 62244 bytes
 src/mpes_tools/Main.py           | 102 ++++++++
 src/mpes_tools/Phoibos.png       | Bin 0 -> 92723 bytes
 src/mpes_tools/call_gui.py       |  14 +
 src/mpes_tools/h5toxarray.py     |  55 ++++
 src/mpes_tools/k_path_4d_4.py    | 422 +++++++++++++++++++++++++++++++
 src/mpes_tools/show_4d_window.py | 151 +++++++----
 8 files changed, 861 insertions(+), 56 deletions(-)
 create mode 100644 src/mpes_tools/Drawwindow.py
 create mode 100644 src/mpes_tools/METIS.png
 create mode 100644 src/mpes_tools/Main.py
 create mode 100644 src/mpes_tools/Phoibos.png
 create mode 100644 src/mpes_tools/call_gui.py
 create mode 100644 src/mpes_tools/h5toxarray.py
 create mode 100644 src/mpes_tools/k_path_4d_4.py

diff --git a/src/mpes_tools/Drawwindow.py b/src/mpes_tools/Drawwindow.py
new file mode 100644
index 0000000..f97c770
--- /dev/null
+++ b/src/mpes_tools/Drawwindow.py
@@ -0,0 +1,173 @@
+import sys
+import numpy as np
+import matplotlib.pyplot as plt
+from PyQt5.QtCore import Qt
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QTextEdit, \
+    QHBoxLayout, QSizePolicy,QSlider,QLabel
+# from k_path_4d_4 import drawKpath
+
+class DrawWindow(QMainWindow):
+    def __init__(self,data,s1,s2,s3,s4):
+        super().__init__()
+
+        # Set the title and size of the main window
+        self.setWindowTitle("PyQt5 Matplotlib Example")
+        self.setGeometry(100, 100, 800, 600)
+        self.data_array=data
+        print(data['E'][0])
+        # Create the main layout
+        main_layout = QVBoxLayout()
+
+        # Create a widget to hold the layout
+        widget = QWidget()
+        widget.setLayout(main_layout)
+        self.setCentralWidget(widget)
+
+        # Create a horizontal layout for the top row
+        top_row_layout = QHBoxLayout()
+
+
+        # Create top left graph
+        self.figure1, self.axis1 = plt.subplots()
+        self.canvas1 = FigureCanvas(self.figure1)
+        top_row_layout.addWidget(self.canvas1)
+
+        # Create bottom right graph
+        self.figure2, self.axis2 = plt.subplots()
+        self.canvas2 = FigureCanvas(self.figure2)
+        top_row_layout.addWidget(self.canvas2)
+        
+        layout = QVBoxLayout()
+        
+        slider_layout= QHBoxLayout()
+        self.slider1 = QSlider(Qt.Horizontal)
+        self.slider1.setRange(0, len(data['E'].data))
+        self.slider1.setValue(s1)
+        self.slider1_label = QLabel("0")
+        
+        self.slider2 = QSlider(Qt.Horizontal)
+        self.slider2.setRange(0, 10)
+        self.slider2.setValue(s2)
+        self.slider2_label = QLabel("0")
+        
+        self.slider1.setFixedSize(200, 12)  # Change the width and height as needed
+        self.slider2.setFixedSize(200, 12)  # Change the width and height as needed
+        
+        slider_layout.addWidget(self.slider1)
+        slider_layout.addWidget(self.slider1_label)
+        slider_layout.addWidget(self.slider2)
+        slider_layout.addWidget(self.slider2_label)
+        # layout.addLayout(slider_layout)
+        slider_layout2= QHBoxLayout()
+        self.slider3 = QSlider(Qt.Horizontal)
+        self.slider3.setRange(0, 100)
+        self.slider3.setValue(s3)
+        self.slider3_label = QLabel("0")
+        
+        self.slider4 = QSlider(Qt.Horizontal)
+        self.slider4.setRange(0, 10)
+        self.slider4.setValue(s4)
+        self.slider4_label = QLabel("0")
+        
+        self.slider3.setFixedSize(200, 12)  # Change the width and height as needed
+        self.slider4.setFixedSize(200, 12)  # Change the width and height as needed
+        
+        slider_layout2.addWidget(self.slider3)
+        slider_layout2.addWidget(self.slider3_label)
+        slider_layout2.addWidget(self.slider4)
+        slider_layout2.addWidget(self.slider4_label)
+        
+        # layout.addLayout(slider_layout2)
+        
+        self.slider1.valueChanged.connect(self.slider1_changed)
+        self.slider2.valueChanged.connect(self.slider2_changed)
+        self.slider3.valueChanged.connect(self.slider3_changed)
+        self.slider4.valueChanged.connect(self.slider4_changed)
+        
+
+        main_layout.addLayout(top_row_layout)
+        main_layout.addLayout(slider_layout)
+        main_layout.addLayout(slider_layout2)
+        
+
+        # Set size policy for the graph widgets
+        self.canvas1.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        self.canvas2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        
+        self.update_energy(s1, s2, s3, s4)
+        # self.d=drawKpath(data, axis, fig, ax, ax2, linewidth, slider, N)
+
+        # Plot data
+        # self.plot_graphs()
+        # self.update_text_edit_boxes()
+        
+    def slider1_changed(self,value):
+        self.slider1_label.setText(str(value))
+        print(value)
+        self.update_energy(self.slider1.value(),self.slider2.value() , self.slider3.value(), self.slider4.value())
+    def slider2_changed(self,value):
+        self.slider2_label.setText(str(value))
+        self.update_energy(self.slider1.value(),self.slider2.value() , self.slider3.value(), self.slider4.value())
+    def slider3_changed(self,value):
+        self.slider3_label.setText(str(value))
+        self.update_energy(self.slider1.value(),self.slider2.value() , self.slider3.value(), self.slider4.value())
+    def slider4_changed(self,value):
+        self.slider4_label.setText(str(value))
+        # self.plot_graph(self.slider1.value(),self.slider2.value())
+        # print(self.slider1.value(),self.slider2.value())
+        # self.update_show(self.slider1.value(),self.slider2.value())
+        self.update_energy(self.slider1.value(),self.slider2.value() , self.slider3.value(), self.slider4.value())
+        
+    def update_energy(self,Energy,dE,te,dte):
+        
+        # self.ce_state=True
+        E1=self.data_array['E'][Energy].item()
+        # print(Energy,E1)
+        E2=self.data_array['E'][Energy+dE].item()
+        te1=self.data_array['dt'][te].item()
+        te2=self.data_array['dt'][te+dte].item()
+        # print(E1,E2,te1)
+        self.figure1.clear()
+        ax = self.figure1.add_subplot(111)  # Recreate the axis on the figure
+        self.im=self.data_array.sel(E=slice(E1,E2), dt=slice(te1,te2)).mean(dim=("E", "dt")).plot(ax=ax)
+        # ax.set_title('Loaded Data')
+        ax.set_xlabel('X')
+        ax.set_ylabel('Y')
+        # self.graphs[0].tight_layout()
+        self.figure1.canvas.draw()
+        # self.ev = self.graphs[0].gca().axvline(x=self.axis[0][self.slider1[1].value()], color='r', linestyle='--')
+        # self.eh = self.graphs[0].gca().axhline(y=self.axis[1][self.slider1[2].value()], color='r', linestyle='--')
+        
+
+    def plot_graphs(self):
+        # Plot on the top left graph
+        x1 = np.linspace(0, 10, 100)
+        y1 = np.sin(x1)
+        self.axis1.plot(x1, y1)
+        self.axis1.set_title('Top Left Graph')
+        self.axis1.set_xlabel('X')
+        self.axis1.set_ylabel('Y')
+
+        # Plot on the bottom right graph
+        x2 = np.linspace(0, 10, 100)
+        y2 = np.cos(x2)
+        self.axis2.plot(x2, y2)
+        self.axis2.set_title('Bottom Right Graph')
+        self.axis2.set_xlabel('X')
+        self.axis2.set_ylabel('Y')
+
+        # Update the canvas
+        self.canvas1.draw()
+        self.canvas2.draw()
+
+    # def update_text_edit_boxes(self):
+    #     # self.text_edit_top_right.setPlaceholderText("Top Right Text Edit Box")
+    #     self.text_edit_bottom_left.setPlaceholderText("Bottom Left Text Edit Box")
+
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    window = DrawWindow()
+    window.show()
+    sys.exit(app.exec_())
diff --git a/src/mpes_tools/METIS.png b/src/mpes_tools/METIS.png
new file mode 100644
index 0000000000000000000000000000000000000000..4311575c7c1cdcac2c916102e206d6d41391b2dd
GIT binary patch
literal 62244
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%0A8aP*crWr2!
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
Z{~sZaTA`s)%?1Df002ovPDHLkV1hom7_I;S

literal 0
HcmV?d00001

diff --git a/src/mpes_tools/Main.py b/src/mpes_tools/Main.py
new file mode 100644
index 0000000..a0c23c5
--- /dev/null
+++ b/src/mpes_tools/Main.py
@@ -0,0 +1,102 @@
+import sys
+from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QAction, QFileDialog, QSlider, QGridLayout,QHBoxLayout, QSizePolicy,QLabel, QGridLayout, QPushButton, QFileDialog
+from PyQt5.QtCore import Qt
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+import matplotlib.pyplot as plt
+import numpy as np
+import h5py
+from additional_window import GraphWindow
+import xarray as xr
+from hdf5 import load_h5
+from show_4d_window import show_4d_window
+import os
+from PyQt5.QtGui import QPixmap
+
+class ARPES_Analyser(QMainWindow):
+    def __init__(self):
+        super().__init__()
+
+        self.setWindowTitle("ARPES_Analyser")
+        self.setGeometry(100, 100, 400, 300)
+
+        # Central widget and main layout
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        layout = QGridLayout()
+        central_widget.setLayout(layout)
+        N=256
+        
+        # Get the directory of the current script
+        base_path = os.path.dirname(os.path.abspath(__file__))
+        
+        # Build full path to image files in the same folder
+        image1_path = os.path.join(base_path, "METIS.png")
+        image2_path = os.path.join(base_path, "Phoibos.png")
+
+        # --- First Button + Image ---
+        vbox1 = QVBoxLayout()
+        label_img1 = QLabel()
+        pixmap1 = QPixmap(image1_path)  # 🔁 Replace with your image path
+        label_img1.setPixmap(pixmap1.scaled(N, N, Qt.KeepAspectRatio, Qt.SmoothTransformation))
+        label_img1.setAlignment(Qt.AlignCenter)
+
+        self.btn_open_h5 = QPushButton("Open File H5")
+        self.btn_open_h5.clicked.connect(self.open_file_dialoge)
+
+        vbox1.addWidget(label_img1)
+        vbox1.addWidget(self.btn_open_h5)
+
+        # --- Second Button + Image ---
+        vbox2 = QVBoxLayout()
+        label_img2 = QLabel()
+        pixmap2 = QPixmap(image2_path)  # 🔁 Replace with your image path
+        label_img2.setPixmap(pixmap2.scaled(N, N, Qt.KeepAspectRatio, Qt.SmoothTransformation))
+        label_img2.setAlignment(Qt.AlignCenter)
+
+        self.btn_open_phoibos = QPushButton("Open File Phoibos")
+        self.btn_open_phoibos.clicked.connect(self.open_file_phoibos)
+
+        vbox2.addWidget(label_img2)
+        vbox2.addWidget(self.btn_open_phoibos)
+
+        # Add the vbox layouts to the main grid layout
+        layout.addLayout(vbox1, 0, 0)
+        layout.addLayout(vbox2, 0, 1)
+
+        self.graph_windows = []
+        self.ce = None
+
+        self.show()
+
+
+    def open_file_phoibos(self):
+        file_path, _ = QFileDialog.getOpenFileName(self, "Open Text File", "", "Text Files (*.npz)")
+        if file_path: 
+            loaded_data = np.load(file_path)  
+        V1 = xr.DataArray(loaded_data['data_array'], dims=['Angle', 'Ekin','delay'], coords={'Angle': loaded_data['Angle'], 'Ekin': loaded_data['Ekin'],'delay': loaded_data['delay']})    
+        axis=[V1['Angle'],V1['Ekin']-21.7,V1['delay']]
+        # print(data.dims)
+        graph_window= GraphWindow(V1,0,0,'Phoibos')
+        
+        graph_window.show()
+        self.graph_windows.append(graph_window)
+        
+    def open_file_dialoge(self):
+        # Open file dialog to select a .h5 file
+        file_path, _ = QFileDialog.getOpenFileName(self, "Open hdf5", "", "h5 Files (*.h5)")
+        print(file_path)
+        if file_path:
+            data_array = load_h5(file_path)
+            graph_4d = show_4d_window(data_array)
+            graph_4d.show()
+            self.graph_windows.append(graph_4d)
+            # self.load_data(data_array)
+
+    
+
+        
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    window = ARPES_Analyser()
+    window.show()
+    sys.exit(app.exec_())
diff --git a/src/mpes_tools/Phoibos.png b/src/mpes_tools/Phoibos.png
new file mode 100644
index 0000000000000000000000000000000000000000..84d3b8ae198864f1ddfdbb7011ddcfe76aea26a8
GIT binary patch
literal 92723
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

literal 0
HcmV?d00001

diff --git a/src/mpes_tools/call_gui.py b/src/mpes_tools/call_gui.py
new file mode 100644
index 0000000..14194a6
--- /dev/null
+++ b/src/mpes_tools/call_gui.py
@@ -0,0 +1,14 @@
+from PyQt5.QtWidgets import QApplication
+from Arpes_gui import MainWindow  # Assuming the first code is saved as main_window.py
+
+import sys
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)  # Initialize the Qt application
+    window = MainWindow()  # Create an instance of your main window
+    window.show()  # Show the window
+    sys.exit(app.exec_())  # Run the Qt event loop
+    
+# if __name__ == "__main__":
+#     window = MainWindow()  # Instantiate the MainWindow
+#     window.show()  # Show the window
\ No newline at end of file
diff --git a/src/mpes_tools/h5toxarray.py b/src/mpes_tools/h5toxarray.py
new file mode 100644
index 0000000..165ddf1
--- /dev/null
+++ b/src/mpes_tools/h5toxarray.py
@@ -0,0 +1,55 @@
+import h5py
+import numpy as np
+import xarray as xr
+
+
+class h5toxarray_loader():
+    def __init__(self, df):
+
+        if len(list(df['binned'].keys()))>1:
+            first_key = sorted(df['binned'].keys(), key=lambda x: int(x[1:]))[0]
+            data_shape = df['binned/' + first_key][:].shape  
+            self.M = np.empty((data_shape[0], data_shape[1], data_shape[2], len(df['binned'])))
+            axis=[]
+            for idx, v in enumerate(sorted(df['binned'].keys(), key=lambda x: int(x[1:]))):
+                self.M[:, :, :, idx] = df['binned/' + v][:]
+        else: 
+            self.M= df['binned/' + list(df['binned'].keys())[0]][:]
+        
+        
+        # Define the desired order lists
+        desired_orders = [
+            ['ax0', 'ax1', 'ax2', 'ax3'],
+            ['kx', 'ky', 'E', 'delay'],
+            ['kx', 'ky', 'E', 'ADC']
+        ]
+        
+        axes_list = []
+      
+        matched_order = None
+        for i, order in enumerate(desired_orders):
+            # Check if all keys in the current order exist in df['axes']
+            if all(f'axes/{axis}' in df for axis in order):
+                # If match is found, generate axes_list based on this order
+                axes_list = [df[f'axes/{axis}'] for axis in order]
+                matched_order = i + 1  # Store which list worked (1-based index)
+                break  # Stop once the first matching list is found
+        
+        if matched_order:
+            print(f"Matched desired list {matched_order}: {desired_orders[matched_order - 1]}")
+        else:
+            print("No matching desired list found.")
+        
+        # print("Axes list:", axes_list)
+        # print(M[12,50,4,20])
+        self.data_array = xr.DataArray(
+            self.M,
+            coords={"kx": axes_list[0], "ky": axes_list[1], "E": axes_list[2], "dt": axes_list[3]},
+            dims=["kx", "ky", "E","dt"]
+        )
+    def get_data_array(self):
+        return self.data_array
+    def get_original_array(self):
+        return self.M
+# df =h5py.File(r'C:\Users\admin-nisel131\Documents\Scan130_scan130_Amine_100x100x300x50_spacecharge4_gamma850_amp_3p3.h5', 'r')
+# test=h5toxarray_loader(df)
diff --git a/src/mpes_tools/k_path_4d_4.py b/src/mpes_tools/k_path_4d_4.py
new file mode 100644
index 0000000..9631edb
--- /dev/null
+++ b/src/mpes_tools/k_path_4d_4.py
@@ -0,0 +1,422 @@
+import numpy as np
+import h5py
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.widgets import CheckButtons, Button
+from scipy.ndimage import rotate
+import h5py
+# import mplcursors
+from matplotlib.widgets import Slider, Cursor, SpanSelector
+from matplotlib.gridspec import GridSpec
+from matplotlib.lines import Line2D
+from matplotlib.patches import Circle
+from AdditionalInterface import AdditionalInterface
+from AxisInteractor import AxisInteractor
+from LinePixelGetter import LinePixelGetter
+from update_plot_cut_4d import update_plot_cut
+import json
+import csv
+from datetime import datetime
+
+class drawKpath:
+    # print(True)
+    def __init__(self, data,axis,fig, ax,ax2,linewidth,slider,N):
+      self.active_cursor=None
+      self.dots_count=0
+      self.ax=ax
+      self.fig=fig
+      self.dot1_x=0
+      self.do1_y=0
+      self.dot2_x=0
+      self.do2_y=0
+      self.cid_press=None
+      self.linewidth=1
+      self.line_artist=None
+      self.cb_line=None
+      self.button_update=None
+      self.dot1=None
+      self.dot2=None
+      self.method_running = False
+      self.pixels_along_line=[]
+      self.number=N
+      self.og_number=N
+      self.dots_list=[]
+      self.line_artist_list=[None]*N
+      self.pixels_along_path=[None]*N
+      # self.number=N
+      self.is_drawn= False
+      self.is_loaded= False
+      self.new=False
+      self.add_pressed=False
+      self.lw=linewidth
+      self.ax2=ax2
+      self.data=data[:,:,:,slider]
+      self.axis=axis
+      self.pixels=[]
+      self.slider=slider
+      self.data2=data
+      self.slider_ax7 = plt.axes([0.55, 0.14, 0.02, 0.3])
+      self.slider_dcut= Slider(self.slider_ax7, 'dcut_kpath', 0, 15, valinit=1, valstep=1, orientation='vertical')
+    # def update_plot_cut(self):
+    #     update_plot_cut.update_plot_cut(self.data2[:,:,:,self.slider],self.ax2,self.pixels,self.lw)
+    def isdrawn(self):
+        return self.is_drawn
+        
+    
+    def get_pixels(self):
+        if self.pixels is not None:
+            return self.pixels
+    def get_pixels_along_line(self):
+        if self.pixels_along_line is not None:
+            return self.pixels_along_line
+   
+    def get_status(self):
+        if self.cb_line is not None:
+            return self.cb_line.get_status()[0]
+        else:
+            return False
+    
+    def draw(self):
+        # print('beginning')
+        def add_path(event):
+            self.add_pressed= True
+            
+            for i in range (self.number):
+                self.line_artist_list.append(None)
+                self.pixels_along_path.append(None)
+                # self.dots_list
+            print('line list=', len(self.line_artist_list))
+            self.number=self.number+self.og_number
+            self.is_drawn=False
+            self.dots_count=0
+            self.cid_press = self.fig.canvas.mpl_connect('button_press_event', drawdots)
+            
+        def drawline(dot1,dot2,pos):
+            self.pixels=[]
+            if self.dots_count ==0 and self.line_artist_list[len(self.dots_list)-2] is not None :
+                if not self.loaded:    
+                    self.line_artist_list[len(self.dots_list)-2].remove()  # Remove the previous line if exists
+                    print('test,code')
+            # if self.dots_count==2:
+            #     line = Line2D([self.dots_list[len(self.dots_list)].center[0], self.dots_list[len(self.dots_list)-1].center[0]], [self.dots_list[len(self.dots_list)].center[1], self.dots_list[len(self.dots_list)-1].center[1]], linewidth=self.linewidth, color='red')
+            if self.dots_count==2 :
+                line = Line2D([dot1.center[0], dot2.center[0]], [dot1.center[1], dot2.center[1]], linewidth=self.linewidth, color='red')
+                
+                self.ax.add_line(line)
+                # print('movement',len(self.line_artist_list))
+                print('currentline=',self.line_artist_list[pos])
+                if self.line_artist_list[pos] is not None:
+                    # print(pos,self.line_artist_list[pos].get_data())
+                    self.line_artist_list[pos].remove()
+                # if self.line_artist is not None:
+                #     self.line_artist.remove()  # Remove the previous line if exists
+                
+                self.line_artist = line
+                # self.line_artist_list.append(line)
+                self.line_artist_list[pos]=line
+                # print(pos,self.line_artist_list[pos].get_data())
+                # x1=self.line_artist_list[pos].get_data()[0][1]
+                # y1=self.line_artist_list[pos].get_data()[1][1]
+                # x2= self.line_artist_list[pos].get_data()[0][0]
+                # y2=self.line_artist_list[pos].get_data()[1][0]
+                x1_pixel=int((self.line_artist_list[pos].get_data()[0][1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
+                y1_pixel=int((self.line_artist_list[pos].get_data()[1][1] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+                x2_pixel=int((self.line_artist_list[pos].get_data()[0][0] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
+                y2_pixel=int((self.line_artist_list[pos].get_data()[1][0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+                
+                self.pixels_along_path[pos] = LinePixelGetter.get_pixels_along_line(x1_pixel, y1_pixel, x2_pixel, y2_pixel, self.linewidth)
+                # print(x1_pixel,y1_pixel)
+                # self.pixels_along_path[pos]=LinePixelGetter.get_pixels_along_line(self.line_artist_list[pos].get_data()[0][1], self.line_artist_list[pos].get_data()[1][1], self.line_artist_list[pos].get_data()[0][0], self.line_artist_list[pos].get_data()[1][0], self.linewidth)
+                # for i in self.pixels_along_path:
+                for i in range (0,self.number):
+                    if self.pixels_along_path[i] is not None:
+                        self.pixels+=self.pixels_along_path[i]
+                        
+        def drawdots(event):
+            # if self.add_pressed:
+                
+                
+            if self.cb_line.get_status()[0] and len(self.dots_list) < self.number and (self.new or not self.is_drawn):
+                x =  event.xdata  # Round the x-coordinate to the nearest integer
+                y =  event.ydata  # Round the y-coordinate to the nearest integer
+                print('you hereeee')
+                print(self.number)
+                # print('line list=', len(self.line_artist_list))
+                if self.dots_count==0:
+                    self.dot= Circle((x, y), radius=0.1, color='yellow', picker=20)
+                    self.ax.add_patch(self.dot)
+                    # self.dot_coords[self.dots_count] = (x, y)
+                    self.dots_list.append(self.dot)
+                    self.dots_count += 1
+                    self.fig.canvas.draw()
+                else:
+                    self.dot= Circle((x, y), radius=0.1, color='yellow', picker=20)
+                    self.ax.add_patch(self.dot)
+                    # self.dot_coords[self.dots_count] = (x, y)
+                    self.dots_count += 1
+                    self.dots_list.append(self.dot)
+                    print('dots list=',len(self.dots_list))
+                    drawline(self.dots_list[len(self.dots_list)-1],self.dots_list[len(self.dots_list)-2],len(self.dots_list)-2)
+                    self.dots_count -= 1
+                    update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
+                    
+                    self.fig.canvas.draw()
+                    if len(self.dots_list)== self.number:
+                        self.is_drawn=True
+                        # print(self.is_drawn)
+        def on_checkbox_change(label):
+                if self.cb_line.get_status()[0]:
+                    if self.is_loaded:
+                        for i in range(len(self.dots_list)):
+                            self.ax.add_patch(self.dots_list[i])
+                            plt.draw()
+                        for i in range(len(self.line_artist_list)):
+                            if self.line_artist_list[i] is not None:
+                                self.ax.add_line(self.line_artist_list[i])
+                                plt.draw()
+                    elif self.is_drawn:
+                        for i in range(len(self.dots_list)):
+                            self.ax.add_patch(self.dots_list[i])
+                            plt.draw()
+                        for i in range(len(self.line_artist_list)):
+                            if self.line_artist_list[i] is not None:
+                                self.ax.add_line(self.line_artist_list[i])
+                                plt.draw()
+                    
+                    else:
+                        self.cid_press = self.fig.canvas.mpl_connect('button_press_event', drawdots)
+                    
+                else:
+                    # Disconnect the click event
+                    self.is_loaded= False
+                    self.fig.canvas.mpl_disconnect(self.cid_press)
+                    for i in range(len(self.dots_list)):
+                        self.dots_list[i].remove()
+                        plt.draw()
+                    for i in range(len(self.line_artist_list)):
+                        if self.line_artist_list[i] is not None:
+                            self.line_artist_list[i].remove()
+                            plt.draw()
+        def new(event):
+            
+            for i in range(len(self.dots_list)):
+                print(i)
+                self.dots_list[i].remove()
+                plt.draw()
+            for i in range(len(self.line_artist_list)):
+                print(i)
+                if self.line_artist_list[i] is not None:
+                    self.line_artist_list[i].remove()
+                    plt.draw()
+            self.new=True
+            self.is_drawn= False
+            self.is_loaded= False
+            self.dots_list=[]
+            self.line_artist_list=[None]*self.number
+            self.pixels_along_path=[None]*self.number
+            self.dots_count=0
+            self.cid_press = self.fig.canvas.mpl_connect('button_press_event', drawdots)
+        def on_pick(event):
+            for i in range(len(self.dots_list)):
+                if event.artist == self.dots_list[i]:
+                    self.active_cursor = self.dots_list[i]
+        def on_motion(event):
+            # global dot1,dot2
+            if self.active_cursor is not None and event.inaxes == self.ax:
+                # Initialize a list of dictionaries to store dot information
+                dot_info_list = [{"dot": dot, "center": dot.center} for dot in self.dots_list]
+                self.dots_count=2
+            
+                # Iterate through the list to find the selected dot
+                selected_dot_index = None
+                for i, dot_info in enumerate(dot_info_list):
+                    dot = dot_info["dot"]
+                    contains, _ = dot.contains(event)
+                    if contains:
+                        selected_dot_index = i
+                        break  # Exit the loop when a matching dot is found
+                
+                if selected_dot_index is not None:
+                    selected_dot_info = dot_info_list[selected_dot_index]
+                    selected_dot = selected_dot_info["dot"]
+                    # print(f"Selected dot index: {selected_dot_index}")
+                    # print(f"Selected dot center: {selected_dot_info['center']}")
+                    selected_dot.center = (event.xdata, event.ydata)
+                    plt.draw()
+                    i=selected_dot_index
+                    if i==len(self.dots_list)-1:
+                        # self.line_artist_list[i-1].remove()
+                        drawline(self.dots_list[i],self.dots_list[i-1],i-1)
+                        update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
+                    elif i==0:
+                        drawline(self.dots_list[i+1],self.dots_list[i],i)
+                        update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
+                    else:
+                        # self.line_artist_list[i-1].remove()
+                        # self.line_artist_list[i].remove()
+                        drawline(self.dots_list[i+1],self.dots_list[i],i)
+                        update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
+                        drawline(self.dots_list[i],self.dots_list[i-1],i-1)
+                        update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
+                    plt.draw()
+                    
+                
+        def on_release(event):
+            self.active_cursor = None
+        def get_status():
+            return self.cb_line.get_status()[0]
+        def dots_coord():
+            return [self.dot1.center, self.dot2.center]
+        
+        def update_dcut(val):
+            self.linewidth=self.slider_dcut.val
+            self.pixels=[]
+            for position, line in enumerate(self.line_artist_list):
+                if line is not None:
+                    line.set_linewidth(self.linewidth+1)
+                    x1_pixel=int((line.get_data()[0][1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
+                    y1_pixel=int((line.get_data()[1][1] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+                    x2_pixel=int((line.get_data()[0][0] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
+                    y2_pixel=int((line.get_data()[1][0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+                    # print(x1_pixel,y1_pixel,x2_pixel,y2_pixel)
+                    self.pixels_along_path[position] = LinePixelGetter.get_pixels_along_line(x1_pixel, y1_pixel, x2_pixel, y2_pixel, self.linewidth)
+                    self.pixels+=self.pixels_along_path[position]
+                    
+            print('before before line')
+            # for pos in range(0,self.number):
+            #     print('before line')
+            #     if self.line_artist_list[pos] is not None:
+            #         x1_pixel=int((self.line_artist_list[pos].get_data()[0][1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
+            #         y1_pixel=int((self.line_artist_list[pos].get_data()[1][1] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+            #         x2_pixel=int((self.line_artist_list[pos].get_data()[0][0] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
+            #         y2_pixel=int((self.line_artist_list[pos].get_data()[1][0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+            #         print(x1_pixel,y1_pixel,x2_pixel,y2_pixel)
+            #         self.pixels_along_path[pos] = LinePixelGetter.get_pixels_along_line(x1_pixel, y1_pixel, x2_pixel, y2_pixel, self.linewidth)
+            #         self.pixels+=self.pixels_along_path[pos]
+            
+            # self.pixels_along_line = LinePixelGetter.get_pixels_along_line(self.dot1_x_pixel, self.dot1_y_pixel, self.dot2_x_pixel, self.dot2_y_pixel, self.linewidth)
+            # update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels_along_line,self.slider_dcut.val)
+            update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
+        def draw_load():
+            if self.is_loaded:
+                for i in range(len(self.dots_list)):
+                    self.ax.add_patch(self.dots_list[i])
+                    plt.draw()
+                for i in range(len(self.line_artist_list)):
+                    if self.line_artist_list[i] is not None:
+                        self.ax.add_line(self.line_artist_list[i])
+                        plt.draw()
+        def save_path(event):
+            def c_to_string(circle):
+                return f"{circle.center[0]}, {circle.center[1]}, {circle.radius}"
+            def l_to_string(line):
+                x_data, y_data = line.get_data()
+                linewidth = line.get_linewidth()
+                return f"{x_data[0]}, {y_data[0]}, {x_data[1]},{y_data[1]},{linewidth}"
+            # self.positions= np.array([[0]*4]*len(self.line_artist_list))
+            # for position, line in enumerate(self.line_artist_list):
+            #     if line is not None:
+            #         line.set_linewidth(self.linewidth+1)
+            #         x1_pixel=int((line.get_data()[0][1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
+            #         y1_pixel=int((line.get_data()[1][1] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+            #         x2_pixel=int((line.get_data()[0][0] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
+            #         y2_pixel=int((line.get_data()[1][0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+            #         self.positions[position][0]
+            output_directory = "C:/Users/admin-nisel131/Documents/CVS_TR_flatband_fig/"
+            current_time = datetime.now()
+            current_time_str = current_time.strftime("%Y-%m-%d_%H%M%S")
+            file_name = "k_path"
+            output_path = f"{output_directory}/{file_name}_{current_time_str}.txt"
+            with open(output_path, "w",newline="") as file:
+                file.write(f"{self.number}" + "\n")
+                for circle in self.dots_list:
+                    file.write(c_to_string(circle) + "\n")
+                for line in self.line_artist_list:
+                    if line is not None:
+                        file.write(l_to_string(line) + "\n")
+        def load_path(event):
+            self.fig.canvas.mpl_disconnect(self.cid_press)
+            circle_list=[]
+            line_list=[]
+            file_path1="C:/Users/admin-nisel131/Documents/CVS_TR_flatband_fig/"
+            # file="k_path_2023-10-06_153243.txt"
+            # file= "k_path_2023-10-10_221437.txt"
+            # file= "k_path_2024-04-03_125248.txt"
+            file= "k_path_2024-04-03_140548.txt"
+            
+            
+            file_path=file_path1+file
+            with open(file_path, "r") as file:
+                lines=file.readlines()
+                # print(lines)
+                # for line_number, line in enumerate(file, start=1):
+                for line_number, line in enumerate(lines, start =1):
+                    # if line_number==2:
+                    #     a,b,c= map(float, line.strip().split(', '))
+                    #     print(a,b,c)
+                    # print(map(float, line.strip().split(', ')))
+                    # print('linenumber=',line_number)
+                    # Split the line into individual values
+                    # if line_number==1:
+                    # print('firstline',line_number)
+                    # number=7
+                    # first_line = file.readline().strip()  # Read and strip whitespace
+                    # print(line)
+                    # first_line = file.readline()
+                    
+                    # number= int(first_line)
+                    # print(number)
+                    # print(first_line)
+                    # print()
+                    if line_number==1:
+                        number= int(line)
+                        # print(number)
+                    elif line_number>=2 and line_number<=number+1:
+                        x, y, radius = map(float, line.strip().split(', '))
+                        # print(x,y,radius)
+                        circle = Circle((x, y), radius=radius, color='yellow', picker=20)
+                        circle_list.append(circle)
+                        self.dots_list=circle_list
+                    else:
+                        x0,y0,x1,y1,lw=map(float, line.strip().split(','))
+                        line1=Line2D([x0,x1], [y0, y1], linewidth=lw, color='red')
+                        line_list.append(line1)
+                        self.line_artist_list=line_list
+                    self.is_loaded= True
+                    self.dots_count=2
+                    # draw_load()
+                    # print(len(self.line_artist_list),len(self.dots_list))
+                    
+                        # print(x0,y0,x1,y1,lw)
+                    # on_checkbox_change('K path')
+                    
+                
+        self.slider_dcut.on_changed(update_dcut)
+        self.fig.canvas.mpl_connect('pick_event', on_pick)
+        self.fig.canvas.mpl_connect('motion_notify_event', on_motion)
+        self.fig.canvas.mpl_connect('button_release_event', on_release)
+    
+        rax_line = self.fig.add_axes([0.45, 0.02, 0.06, 0.03])  # [left, bottom, width, height]
+        self.cb_line = CheckButtons(rax_line, ['K path'], [False])
+        self.cb_line.on_clicked(on_checkbox_change)
+        
+        rax_button = self.fig.add_axes([0.52, 0.02, 0.06, 0.03])
+        self.button_update = Button(rax_button, 'new k')
+        self.button_update.on_clicked(new)
+        
+        savepath_button = self.fig.add_axes([0.52, 0.06, 0.06, 0.03])
+        self.button_save = Button(savepath_button, 'save k-path')
+        self.button_save.on_clicked(save_path)
+        
+        loadpath_button = self.fig.add_axes([0.45, 0.06, 0.06, 0.03])
+        self.button_load = Button(loadpath_button, 'load k-path')
+        self.button_load.on_clicked(load_path)
+        
+        addpath_button = self.fig.add_axes([0.37, 0.06, 0.06, 0.03])
+        self.button_add = Button(addpath_button, 'add k-path')
+        self.button_add.on_clicked(add_path)
+        
+        plt.show()
+        self.fig.canvas.draw()
+        
\ No newline at end of file
diff --git a/src/mpes_tools/show_4d_window.py b/src/mpes_tools/show_4d_window.py
index 6d1f355..69a0a1a 100644
--- a/src/mpes_tools/show_4d_window.py
+++ b/src/mpes_tools/show_4d_window.py
@@ -10,8 +10,8 @@
 from mpes_tools.hdf5 import load_h5
 
 
-class MainWindow(QMainWindow):
-    def __init__(self):
+class show_4d_window(QMainWindow):
+    def __init__(self,data_array: xr.DataArray):
         super().__init__()
 
         self.setWindowTitle("Main Window")
@@ -54,11 +54,6 @@ def __init__(self):
                 slider1.setRange(0, 100)
                 slider1.setValue(0)
                 slider1_label = QLabel("0")
-                # slider.valueChanged.connect(self.slider_changed)
-                # Set the size of the slider
-                
-                # default_size = slider1.sizeHint()
-                # print(f"Default size of the slider: {default_size.width()}x{default_size.height()}")
                 
                 slider2 = QSlider(Qt.Horizontal)
                 slider2.setRange(0, 10)
@@ -120,25 +115,17 @@ def __init__(self):
         self.yv = None
         self.ev = None
         self.eh = None
+        self.ph= None
+        self.pxv=None
+        self.pyh=None
         
-        # print(self.sliders)
-        # Create a menu bar
-        menu_bar = self.menuBar()
-
-        # Create a 'File' menu
-        file_menu = menu_bar.addMenu("File")
-
-        # Create actions for opening a file and exiting
-        open_file_action = QAction("Open File", self)
-        open_file_action.triggered.connect(self.open_file_dialog)
-        file_menu.addAction(open_file_action)
         
         open_graphe_action = QAction("Energy", self)
         open_graphe_action.triggered.connect(self.open_graph_kxkydt)
-        open_graphy_action = QAction("ky_cut", self)
-        open_graphy_action.triggered.connect(self.open_graph_kyedt)
         open_graphx_action = QAction("kx_cut", self)
-        open_graphx_action.triggered.connect(self.open_graph_kxedt)
+        open_graphx_action.triggered.connect(self.open_graph_kyedt)
+        open_graphy_action = QAction("ky_cut", self)
+        open_graphy_action.triggered.connect(self.open_graph_kxedt)
         
         menu_bar = self.menuBar()
 
@@ -154,12 +141,13 @@ def __init__(self):
         self.ce=None
 
         self.show()
+        self.load_data(data_array)
 
     def open_graph_kxkydt(self):
         E1=self.data_array[self.axes[2]][self.slider1[0].value()].item()
         E2=self.data_array[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()+1].item()
         data_kxkydt = self.data_array.loc[{self.axes[2]:slice(E1,E2)}].mean(dim=(self.axes[2]))
-        graph_window=GraphWindow(data_kxkydt, self.slider3[0].value(), self.slider4[0].value())
+        graph_window=GraphWindow(data_kxkydt, self.slider3[0].value(), self.slider4[0].value(),'METIS')
         # Show the graph window
         graph_window.show()
         self.graph_windows.append(graph_window)
@@ -168,7 +156,7 @@ def open_graph_kxedt(self):
         ky1=self.data_array[self.axes[1]][self.slider1[1].value()].item()
         ky2=self.data_array[self.axes[1]][self.slider1[1].value()+self.slider2[1].value()+1].item()
         data_kxedt = self.data_array.loc[{self.axes[1]:slice(ky1,ky2)}].mean(dim=(self.axes[1]))
-        graph_window = GraphWindow(data_kxedt, self.slider3[1].value(), self.slider4[1].value())
+        graph_window = GraphWindow(data_kxedt, self.slider3[1].value(), self.slider4[1].value(),'METIS')
         # Show the graph window
         graph_window.show()
         self.graph_windows.append(graph_window)
@@ -177,24 +165,17 @@ def open_graph_kyedt(self):
         kx1=self.data_array[self.axes[0]][self.slider1[2].value()].item()
         kx2=self.data_array[self.axes[0]][self.slider1[2].value()+self.slider2[2].value()+1].item()
         data_kyedt = self.data_array.loc[{self.axes[0]:slice(kx1,kx2)}].mean(dim=(self.axes[0]))
-        graph_window = GraphWindow(data_kyedt, self.slider3[2].value(), self.slider4[2].value())
+        print(type(data_kyedt))
+        graph_window = GraphWindow(data_kyedt, self.slider3[2].value(), self.slider4[2].value(),'METIS')
         # Show the graph window
+        
         graph_window.show()
         self.graph_windows.append(graph_window)
-
-    def open_file_dialog(self):
-        # Open file dialog to select a .h5 file
-        file_path, _ = QFileDialog.getOpenFileName(self, "Open hdf5", "", "h5 Files (*.h5)")
-        print(file_path)
-        if file_path:
-            data_array = load_h5(file_path)
-
-            self.load_data(data_array)
-
+        
     def load_data(self, data_array: xr.DataArray):
         self.data_array = data_array
         self.axes = data_array.dims
-
+        # print('theaxissss',self.axes)
         self.slider1[0].setRange(0,len(self.data_array.coords[self.axes[2]])-1)
         self.slider1[1].setRange(0,len(self.data_array.coords[self.axes[0]])-1)
         self.slider1[2].setRange(0,len(self.data_array.coords[self.axes[1]])-1)
@@ -203,12 +184,30 @@ def load_data(self, data_array: xr.DataArray):
         self.slider3[0].setRange(0,len(self.data_array.coords[self.axes[3]])-1)
         self.slider3[1].setRange(0,len(self.data_array.coords[self.axes[3]])-1)
         self.slider3[2].setRange(0,len(self.data_array.coords[self.axes[3]])-1)
-
-        self.update_energy(self.slider1[0].value(),self.slider2[0].value() , self.slider1[1].value(), self.slider2[1].value())
         
-        # self.ce= update_color(self.im,self.graphs[0],self.graphs[0].gca())
-        # self.ce.slider_plot.on_changed(self.ce.update)
+        self.slider_labels[0].setText(self.axes[2])
+        self.slider_labels[1].setText("Δ"+self.axes[2])
+        self.slider_labels[2].setText(self.axes[3])
+        self.slider_labels[3].setText("Δ"+self.axes[3])
+        
+        self.slider_labels[4].setText(self.axes[1])
+        self.slider_labels[5].setText("Δ"+self.axes[1])
+        self.slider_labels[6].setText(self.axes[3])
+        self.slider_labels[7].setText("Δ"+self.axes[3])
+
+        self.slider_labels[8].setText(self.axes[0])
+        self.slider_labels[9].setText("Δ"+self.axes[0])
+        self.slider_labels[10].setText(self.axes[3])
+        self.slider_labels[11].setText("Δ"+self.axes[3])
+        
+        self.slider_labels[12].setText(self.axes[1])
+        self.slider_labels[13].setText("Δ"+self.axes[1])
+        self.slider_labels[14].setText(self.axes[0])
+        self.slider_labels[15].setText("Δ"+self.axes[0])
+        
         
+        self.update_energy(self.slider1[0].value(),self.slider2[0].value() , self.slider1[1].value(), self.slider2[1].value())
+
         self.update_ky(self.slider1[2].value(), self.slider2[2].value(), self.slider3[0].value(), self.slider4[0].value())
     
         self.update_kx(self.slider3[1].value(), self.slider4[1].value(), self.slider3[2].value(), self.slider4[2].value())
@@ -225,11 +224,15 @@ def update_energy(self,Energy,dE,te,dte):
         self.graphs[0].clear()
         ax=self.graphs[0].gca()
 
-        self.im=self.data_array.loc[{self.axes[2]:slice(E1,E2), self.axes[3]:slice(te1,te2)}].mean(dim=(self.axes[2], self.axes[3])).T.plot(ax=ax)
-        
-        self.ev = ax.axvline(x=self.data_array.coords[self.axes[0]][self.slider1[1].value()], color='r', linestyle='--')
-        self.eh = ax.axhline(y=self.data_array.coords[self.axes[1]][self.slider1[2].value()], color='r', linestyle='--')
-        
+        data_avg=self.data_array.loc[{self.axes[2]:slice(E1,E2), self.axes[3]:slice(te1,te2)}].mean(dim=(self.axes[2], self.axes[3]))
+        self.im=data_avg.T.plot(ax=ax,cmap='terrain')
+        ax.set_title(f'energy: {E1:.2f}, E+dE: {E2:.2f} , t: {te1:.2f}, t+dt: {te2:.2f}')
+        # print(self.data_array.coords[self.axes[0]][self.slider1[1].value()].item())
+        # self.ev = ax.axvline(x=self.data_array.coords[self.axes[0]][self.slider1[1].value()].item(), color='r', linestyle='--')
+        self.ev = ax.axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
+        self.eh = ax.axhline(y=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
+        self.pxv = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
+        self.pyh = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
         self.graphs[0].tight_layout()
         self.graphs[0].canvas.draw()
         
@@ -242,9 +245,9 @@ def update_ky(self,ypos,dy,ty,dty):
         
         self.graphs[1].clear()
         ax=self.graphs[1].gca()
-        self.data_array.loc[{self.axes[1]:slice(y1,y2), self.axes[3]:slice(ty1,ty2)}].mean(dim=(self.axes[1], self.axes[3])).T.plot(ax=ax)
-        
-        self.yv = ax.axvline(x=self.data_array.coords[self.axes[2]][self.slider1[0].value()], color='r', linestyle='--')
+        self.data_array.loc[{self.axes[1]:slice(y1,y2), self.axes[3]:slice(ty1,ty2)}].mean(dim=(self.axes[1], self.axes[3])).T.plot(ax=ax,cmap='terrain')
+        ax.set_title(f'ky: {y1:.2f}, ky+dky: {y2:.2f} , t: {ty1:.2f}, t+dt: {ty2:.2f}')
+        self.yh = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
 
         self.graphs[1].tight_layout()
         self.graphs[1].canvas.draw()
@@ -258,9 +261,9 @@ def update_kx(self,xpos,dx,tx,dtx):
         
         self.graphs[2].clear()
         ax=self.graphs[2].gca()
-        self.data_array.loc[{self.axes[0]:slice(x1,x2), self.axes[3]:slice(tx1,tx2)}].mean(dim=(self.axes[0], self.axes[3])).T.plot(ax=ax)
-
-        self.xv = ax.axvline(x=self.data_array.coords[self.axes[2]][self.slider1[0].value()], color='r', linestyle='--')
+        self.data_array.loc[{self.axes[0]:slice(x1,x2), self.axes[3]:slice(tx1,tx2)}].mean(dim=(self.axes[0], self.axes[3])).T.plot(ax=ax,cmap='terrain')
+        ax.set_title(f'kx: {x1:.2f}, kx+dkx: {x2:.2f} , t: {tx1:.2f}, t+dt: {tx2:.2f}')
+        self.xh = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
         
         self.graphs[2].tight_layout()
         self.graphs[2].canvas.draw()
@@ -274,31 +277,67 @@ def update_dt(self,yt,xt,dyt,dxt):
         
         self.graphs[3].clear()
         ax=self.graphs[3].gca()
-        self.data_array.loc[{self.axes[1]:slice(yt1,yt2), self.axes[0]:slice(xt1,xt2)}].mean(dim=(self.axes[1], self.axes[0])).plot(ax=ax)
-
+        self.data_array.loc[{self.axes[1]:slice(yt1,yt2), self.axes[0]:slice(xt1,xt2)}].mean(dim=(self.axes[1], self.axes[0])).plot(ax=ax,cmap='terrain')
+        ax.set_title(f'ky: {yt1:.2f}, ky+dky: {yt2:.2f} , kx: {xt1:.2f}, kx+dkx: {xt2:.2f}')
+        self.ph = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
         self.graphs[3].tight_layout()
         self.graphs[3].canvas.draw()
+        
 
     def slider_changed(self, value):
         sender = self.sender()  # Get the slider that emitted the signal
         index = self.sliders.index(sender)  # Find the index of the slider
         
-        self.slider_labels[index].setText(str(value))  # Update the corresponding label text
+        # self.slider_labels[index].setText(str(value))  # Update the corresponding label text
+        base = self.slider_labels[index].text().split(':')[0]
+        self.slider_labels[index].setText(f"{base}: {value}")
 
         if index in range(0,4):
-            # self.ce.slider_plot.on_changed(self.ce.update)
+            # ax = self.graphs[2].gca()
+            if self.xh in self.graphs[2].gca().lines:
+                self.xh.remove()
+            if self.yh in self.graphs[1].gca().lines:
+                self.yh.remove()
+            if self.ph in self.graphs[3].gca().lines:
+                self.ph.remove()
+            self.xh = self.graphs[2].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+            self.yh = self.graphs[1].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+            self.ph = self.graphs[3].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+            # self.graphs[2].tight_layout()
+            self.graphs[2].canvas.draw()
+            self.graphs[1].canvas.draw()
+            self.graphs[3].canvas.draw()
             self.update_energy(self.slider1[0].value(),self.slider2[0].value(),self.slider3[0].value(), self.slider4[0].value())
-            # self.update_line()
+            
         elif index in range(4,8):
+            if self.eh is not None:
+                self.eh.remove()
+           
+            self.eh = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider1[1].value()].item(), color='r', linestyle='--')
+            self.graphs[0].canvas.draw()
             self.update_ky(self.slider1[1].value(), self.slider2[1].value(),self.slider3[1].value(), self.slider4[1].value())
         elif index in range (8,12):
+            ax = self.graphs[0].gca()
+            if self.ev in ax.lines:
+                self.ev.remove()
+            self.ev = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
+            self.graphs[0].canvas.draw()
             self.update_kx(self.slider1[2].value(), self.slider2[2].value(),self.slider3[2].value(), self.slider4[2].value())
         elif index in range (12,16):
+            if self.pxv in self.graphs[0].gca().lines:
+                self.pxv.remove()
+            if self.pyh in self.graphs[0].gca().lines:
+                self.pyh.remove()
+            # self.pxv = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
+            # self.pyh = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
+            self.pyh = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
+            self.pxv = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
+            self.graphs[0].canvas.draw()
             self.update_dt(self.slider1[3].value(), self.slider3[3].value(), self.slider2[3].value(), self.slider4[3].value())
 
         
 if __name__ == "__main__":
     app = QApplication(sys.argv)
-    window = MainWindow()
+    window = show_4d_window()
     window.show()
     sys.exit(app.exec_())

From d175e8558f3bd1e17274f6bf46e453322dc35542 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Thu, 10 Apr 2025 19:55:33 +0200
Subject: [PATCH 03/67] added set points for the cursors and save button to
 extract the relevant results for post processing in Jupyter Notebook

---
 src/mpes_tools/Gui_3d.py | 337 +++++++++++++++++++++++++++------------
 1 file changed, 232 insertions(+), 105 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index bafdfae..aebd37e 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -1,11 +1,13 @@
-from PyQt5.QtWidgets import QMainWindow, QVBoxLayout, QWidget, QCheckBox, QAction, QSlider, QHBoxLayout, QLabel
+import sys
+from PyQt5.QtWidgets import QApplication,QMainWindow, QVBoxLayout, QWidget, QCheckBox, QAction, QSlider, QHBoxLayout, QLabel,QLineEdit,QPushButton
 from PyQt5.QtCore import Qt
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib.patches import Circle
 from matplotlib.lines import Line2D
-
+import json
+import pickle
 from mpes_tools.fit_panel import fit_panel
 
 import xarray as xr
@@ -37,13 +39,37 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         
         self.checkbox_cursors = QCheckBox("energy_cursors")
         self.checkbox_cursors.stateChanged.connect(self.checkbox_cursors_changed)
+
+        self.save_button = QPushButton('Save Results', self)
+        self.save_button.clicked.connect(self.save_results)
+        
+        h_layout = QHBoxLayout()
+        self.cursor_label=[]
+        self.cursor_inputs = []
+        cursors_names=['yellow_vertical', 'yellow_horizontal','green_vertical', 'green_horizontal']
+        for i in range(4):
+            sub_layout = QVBoxLayout()
+            # label = QLabel(f"Cursor {i+1}:")
+            label=QLabel(cursors_names[i])
+            input_field = QLineEdit()
+            input_field.setPlaceholderText("Value")
+            input_field.setFixedWidth(80)
+            input_field.editingFinished.connect(lambda i=i: self.main_graph_cursor_changed(i))
+            self.cursor_inputs.append(input_field)
+            self.cursor_label.append(label)
+            sub_layout.addWidget(label)
+            sub_layout.addWidget(input_field)
+            h_layout.addLayout(sub_layout)
+
         checkbox_layout= QHBoxLayout()
         # Add the canvas to the layout
         checkbox_layout.addWidget(self.checkbox_e)
         checkbox_layout.addWidget(self.checkbox_k)
         layout.addLayout(checkbox_layout)
+        layout.addLayout(h_layout)
         layout.addWidget(self.canvas)
-        layout.addWidget(self.checkbox_cursors)
+        layout.addWidget(self.save_button)
+        # layout.addWidget(self.checkbox_cursors)
         
         slider_layout= QHBoxLayout()
         self.slider1 = QSlider(Qt.Horizontal)
@@ -73,7 +99,7 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         self.Line1=None
         self.Line2=None
         self.square_artists = []  # To store the artists representing the dots
-        self.square_coords = [(0, 0), (0, 0)]  # To store the coordinates of the dots
+        self.square_coords = [[0, 0], [0, 0]]  # To store the coordinates of the dots
         self.square_count = 0  # To keep track of the number of dots drawn
         
         
@@ -92,11 +118,16 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
             self.axis[1]=self.axis[1]-21.7
             self.data = self.data.assign_coords(Ekin=self.data.coords['Ekin'] -21.7)
         
+        self.t=t
         self.dt=dt
-        # self.datae=np.zeros((len(self.axis[0]),len(self.axis[1])))
-        # Plot data
         self.data_t=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
-        # self.plot_graph(t,dt)
+        self.cursor_vert1 = []
+        self.cursor_horiz1 = []
+        self.cursor_vert2 =[]
+        self.cursor_horiz2 = []
+        self.integrated_edc=None
+        self.integrated_mdc=None
+        
         self.ssshow(t,dt)
         self.slider1.setRange(0,len(self.axis[2])-1)
         self.slider1_label.setText(self.data.dims[2]+": 0")
@@ -122,12 +153,106 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         box_panel_action.triggered.connect(self.fit_box_panel)
         graph_menu1.addAction(box_panel_action)
         
+        
         self.graph_windows=[]
-        self.t=t
+        
         print(data_array.dims)
-        # 
+
+    
+
+    def save_results(self):
+        results = {
+            'integrated_edc': self.integrated_edc,
+            'integrated_mdc': self.integrated_mdc,
+            'yellowline_edc': self.data_t.isel({self.data.dims[0]:self.square_coords[0][1]}),
+            'greenline_edc': self.data_t.isel({self.data.dims[0]:self.square_coords[1][1]}),
+            'yellowline_mdc': self.data_t.isel({self.data.dims[1]: int(self.square_coords[0][0])}),
+            'greenline_mdc': self.data_t.isel({self.data.dims[1]: int(self.square_coords[1][0])}),
+            'current_spectra': self.data_t,
+            'intensity_box': self.int,
+            'yellow_vertical': self.dot1.center[0],
+            'yellow_horizontal': self.dot1.center[1],
+            'green_vertical': self.dot2.center[0],
+            'green_horizontal': self.dot2.center[1],
+            'delay1':self.axis[2][self.slider1.value()],
+            'delay2':self.axis[2][self.slider1.value()+self.slider2.value()]
+        }
+        with open('gui_results.pkl', 'wb') as f:
+            pickle.dump(results, f)
+        # with open('gui_results.json', 'w') as f:
+        #     json.dump(results, f)
+        print("Results saved!")
+        
+    def results_3d(self):
+        def integrated_edc(self):
+            return self.integrated_edc
+        def integrated_mdc(self):
+            return self.integrated_mdc
+        def yellowline_edc(self):
+            return self.data_t.isel({self.data.dims[0]:self.square_coords[0][1]})
+        def greenline_edc(self):
+            return self.data_t.isel({self.data.dims[0]:self.square_coords[1][1]})
+        def yellowline_mdc(self):
+            return self.data_t.isel({self.data.dims[1]: int(self.square_coords[0][0])})
+        def greenline_mdc(self):
+            return self.data_t.isel({self.data.dims[1]: int(self.square_coords[1][0])})
+        def current_spectra(self):
+            return self.data_t
+        def intensity_box(self):
+            return self.int
+        def yellow_vertical(self):
+            return self.dot1.center[0]
+        def yellow_horizontal(self):
+            return self.dot1.center[1]
+        def green_vertical(self):
+            return self.dot2.center[0]
+        def green_horizontal(self):
+            return self.dot2.center[1]
+        
+        
+    def main_graph_cursor_changed(self, index):
+        value = self.cursor_inputs[index].text()
+        value=float(value)
+        if index ==0: 
+            self.cursor_vert1.set_xdata([value, value])
+            self.dot1.center = (value,self.dot1.center[1])
+            base = self.cursor_label[0].text().split(':')[0]
+            self.cursor_label[0].setText(f"{base}: {value:.2f}")
+        elif index ==1:
+            self.cursor_horiz1.set_ydata([value, value])
+            self.dot1.center = (self.dot1.center[0], value)
+            base = self.cursor_label[1].text().split(':')[0]
+            self.cursor_label[1].setText(f"{base}: {value:.2f}")
+        elif index ==2: 
+            self.cursor_vert2.set_xdata([value, value])
+            self.dot2.center = (value,self.dot2.center[1])
+            base = self.cursor_label[2].text().split(':')[0]
+            self.cursor_label[2].setText(f"{base}: {value:.2f}")
+        elif index ==3:
+            self.cursor_horiz2.set_ydata([value, value])
+            self.dot2.center = (self.dot2.center[0], value)
+            base = self.cursor_label[3].text().split(':')[0]
+            self.cursor_label[3].setText(f"{base}: {value:.2f}")
+        self.change_pixel_to_arrayslot()
+        self.update_show(self.slider1.value(),self.slider2.value())
+        try:
+            num = float(value)
+            # print(f"Cursor {index+1} changed to: {num}")
+            # Update graph logic here
+        except ValueError:
+            print("Invalid input!")
+    def change_pixel_to_arrayslot(self):# convert the value of the pixel to the value of the slot in the data
+        if self.dot1.center[0] is not None and self.dot1.center[1] is not None and self.dot2.center[0] is not None and self.dot2.center[1] is not None: 
+            x1_pixel=int((self.dot1.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+            y1_pixel=int((self.dot1.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
+            self.square_coords[0]=[x1_pixel,y1_pixel]
+            x2_pixel=int((self.dot2.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+            y2_pixel=int((self.dot2.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
+            self.square_coords[1]=[x2_pixel,y2_pixel]
+        
     def slider1_changed(self,value): # change the slider controlling the third dimension
         # self.slider1_label.setText(str(value))
+        print(value)
         base = self.slider1_label.text().split(':')[0]
         self.slider1_label.setText(f"{base}: {self.data[self.data.dims[2]][value].item():.2f}")
         self.update_show(self.slider1.value(),self.slider2.value())
@@ -139,6 +264,7 @@ def slider2_changed(self,value): # change the slider controlling the third dimen
         self.update_show(self.slider1.value(),self.slider2.value())
         self.dt=self.slider2.value()
     def checkbox_e_changed(self, state):
+        print(state)
         if state == Qt.Checked:
             self.integrate_E()
         else:
@@ -153,17 +279,6 @@ def checkbox_cursors_changed(self, state):
             self.put_cursors()
         else:
             self.remove_cursors()
-    # def plot_graph(self,t,dt):
-        
-    #     self.data_t=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
-    #     self.axs[0,0].imshow(self.data_t.data, extent=[self.axis[1][0], self.axis[1][-1], self.axis[0][0], self.axis[0][-1]], origin='lower',cmap='terrain',aspect='auto')
-        
-        
-    #     self.axs[0,0].set_title('Sample Graph')
-    #     self.axs[0,0].set_xlabel('E-Ef (eV)')
-    #     self.axs[0,0].set_ylabel('Angle (degrees)')
-    #     self.fig.tight_layout()
-    #     self.canvas.draw()
     
     def fit_energy_panel(self,event): # open up the fit panel for the EDC 
         graph_window=fit_panel(self.data,self.square_coords[0][1], self.square_coords[1][1], self.t, self.dt, self.data.dims[1])
@@ -181,10 +296,6 @@ def fit_box_panel(self,event): # open up the fit panel for the intensity box
     
     def ssshow(self, t, dt): # This is where the updates after changing the sliders happen
         
-            
-        
-        # c = self.data.shape[1] // 10 ** (len(str(self.data.shape[1])) - 1)
-        
         def put_cursors(): # add cursors in the EDC graph
             # Adjust to use xarray's coords for axis referencing
             self.Line1 = axe.axvline(x=self.cursorlinev1, color='red', linestyle='--', linewidth=2, label='Vertical Line', picker=10)
@@ -205,8 +316,10 @@ def integrate_E(): # integrate EDC between the two cursors in the main graph
             x_min = int(min(self.square_coords[1][1], self.square_coords[0][1]))
             x_max = int(max(self.square_coords[1][1], self.square_coords[0][1])) + 1
     
-            self.data_t.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0]).plot(ax=self.axs[1,0])
-
+            # self.data_t.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0]).plot(ax=self.axs[1,0])
+            self.integrated_edc=self.data_t.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
+            self.integrated_edc.plot(ax=self.axs[1,0])
+            self.fig.canvas.draw()
     
         def integrate_k(): # integrate MDC between the two cursors in the main graph
             self.axs[0, 1].clear()
@@ -215,7 +328,10 @@ def integrate_k(): # integrate MDC between the two cursors in the main graph
             x_min = int(min(self.square_coords[0][0], self.square_coords[1][0]))
             x_max = int(max(self.square_coords[0][0], self.square_coords[1][0])) + 1
     
-            self.data_t.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1]).plot(ax=self.axs[0,1])
+            # self.data_t.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1]).plot(ax=self.axs[0,1])
+            self.integrated_mdc=self.data_t.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
+            self.integrated_mdc.plot(ax=self.axs[0,1])
+            self.fig.canvas.draw()
     
         def box(): # generate the intensity graph between the four cursors in the main graph
             self.int = np.zeros_like(self.axis[2])
@@ -230,20 +346,16 @@ def box(): # generate the intensity graph between the four cursors in the main g
             self.int = self.data.isel({self.data.dims[0]: slice(y0, y1), self.data.dims[1]: slice(x0, x1)}).sum(dim=(self.data.dims[0], self.data.dims[1]))
             
             if x0 != x1 and y0 != y1:
-                N = -1
                 
                 self.int.plot(ax=self.axs[1,1])
                 self.dot, = self.axs[1, 1].plot([self.axis[2][self.slider1.value()]], [self.int[self.slider1.value()]], 'ro', markersize=8)
                 self.fig.canvas.draw_idle()
     
-        # def us(self): 
-        #     update_show(self.slider1.value(), self.slider2.value())
-    
         def update_show(t, dt): # update the main graph as well as the relevant EDC and MDC cuts. Also the box intensity
             self.axs[0, 1].clear()
             self.axs[1, 0].clear()
             self.data_t=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
-            im6.set_array(self.data_t)
+            im.set_array(self.data_t)
             if self.checkbox_e.isChecked() and self.checkbox_k.isChecked():
                 integrate_E()
                 integrate_k()
@@ -277,10 +389,9 @@ def update_show(t, dt): # update the main graph as well as the relevant EDC and
             self.axs[0, 0].set_title(f't: {time1:.2f}, t+dt: {timedt1}')
             self.fig.canvas.draw()
             plt.draw()
-        
-        self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
-        
-        im6 = self.axs[0, 0].imshow(self.data_t.data, extent=[self.axis[1][0], self.axis[1][-1], self.axis[0][0], self.axis[0][-1]], origin='lower',cmap='terrain', aspect='auto')
+   
+        # im6 = self.axs[0, 0].imshow(self.data_t.data, extent=[self.axis[1][0], self.axis[1][-1], self.axis[0][0], self.axis[0][-1]], origin='lower',cmap='terrain', aspect='auto')
+        im = self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2]).plot(ax=self.axs[0, 0], cmap='terrain', add_colorbar=False)
         
         # define the cursors in the main graph
         
@@ -295,34 +406,39 @@ def update_show(t, dt): # update the main graph as well as the relevant EDC and
         xmin, xmax = self.axs[0, 0].get_ylim()
         ymin, ymax = 5 * ymin, 5 * ymax
         xmin, xmax = 5 * xmin, 5 * xmax
-        cursor_vert1 = Line2D([initial_x, initial_x], [ymin, ymax], color='yellow', linewidth=2, picker=10, linestyle='--')
-        cursor_horiz1 = Line2D([xmin, xmax], [initial_y, initial_y], color='yellow', linewidth=2, picker=10, linestyle='--')
-        cursor_vert2 = Line2D([initial_x2, initial_x2], [ymin, ymax], color='green', linewidth=2, picker=10, linestyle='--')
-        cursor_horiz2 = Line2D([xmin, xmax], [initial_y2, initial_y2], color='green', linewidth=2, picker=10, linestyle='--')
+        self.cursor_vert1 = Line2D([initial_x, initial_x], [ymin, ymax], color='yellow', linewidth=2, picker=10, linestyle='--')
+        self.cursor_horiz1 = Line2D([xmin, xmax], [initial_y, initial_y], color='yellow', linewidth=2, picker=10, linestyle='--')
+        self.cursor_vert2 = Line2D([initial_x2, initial_x2], [ymin, ymax], color='green', linewidth=2, picker=10, linestyle='--')
+        self.cursor_horiz2 = Line2D([xmin, xmax], [initial_y2, initial_y2], color='green', linewidth=2, picker=10, linestyle='--')
+        
+        base = self.cursor_label[0].text().split(':')[0]
+        self.cursor_label[0].setText(f"{base}: {initial_x:.2f}")
+        base = self.cursor_label[1].text().split(':')[0]
+        self.cursor_label[1].setText(f"{base}: {initial_x:.2f}")
+        base = self.cursor_label[2].text().split(':')[0]
+        self.cursor_label[2].setText(f"{base}: {initial_x2:.2f}")
+        base = self.cursor_label[3].text().split(':')[0]
+        self.cursor_label[3].setText(f"{base}: {initial_y2:.2f}")
         
         # define the dots that connect the cursors
-        dot1 = Circle((initial_x, initial_y), radius=0.05, color='yellow', picker=10)
-        dot2 = Circle((initial_x2, initial_y2), radius=0.05, color='green', picker=10)
-    
-        if dot1.center[0] is not None and dot1.center[1] is not None and dot2.center[0] is not None and dot2.center[1] is not None:
-            x1_pixel = int((dot1.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            y1_pixel = int((dot1.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            self.square_coords[0] = (x1_pixel, y1_pixel)
-            x2_pixel = int((dot2.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            y2_pixel = int((dot2.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            self.square_coords[1] = (x2_pixel, y2_pixel)
-    
-        ax.add_line(cursor_vert1)
-        ax.add_line(cursor_horiz1)
-        ax.add_patch(dot1)
-        ax.add_line(cursor_vert2)
-        ax.add_line(cursor_horiz2)
-        ax.add_patch(dot2)
+        self.dot1 = Circle((initial_x, initial_y), radius=0.05, color='yellow', picker=10)
+        self.dot2 = Circle((initial_x2, initial_y2), radius=0.05, color='green', picker=10)
     
-        ax.set_xlabel('Energy (eV)')
-        ax.set_ylabel('Momentum (1/A)')
-        self.axs[0, 1].set_xlabel('Energy (eV)')
-        self.axs[0, 1].set_ylabel('intensity (a.u.)')
+        self.change_pixel_to_arrayslot()
+        
+        x_min = int(min(self.square_coords[1][1], self.square_coords[0][1]))
+        x_max = int(max(self.square_coords[1][1], self.square_coords[0][1])) + 1
+        self.integrated_edc=self.data_t.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
+        x_min = int(min(self.square_coords[0][0], self.square_coords[1][0]))
+        x_max = int(max(self.square_coords[0][0], self.square_coords[1][0])) + 1
+        self.integrated_mdc=self.data_t.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
+        
+        ax.add_line(self.cursor_vert1)
+        ax.add_line(self.cursor_horiz1)
+        ax.add_patch(self.dot1)
+        ax.add_line(self.cursor_vert2)
+        ax.add_line(self.cursor_horiz2)
+        ax.add_patch(self.dot2)
         initial_xe=1
         
         axe.axvline(x=initial_xe, color='red', linestyle='--',linewidth=2, label='Vertical Line')
@@ -334,18 +450,18 @@ def update_show(t, dt): # update the main graph as well as the relevant EDC and
         self.fig.canvas.draw()
         self.active_cursor = None
         def on_pick(event): # function to pick up the cursors or the dots
-            if event.artist == cursor_vert1:
-                self.active_cursor = cursor_vert1
-            elif event.artist == cursor_horiz1:
-                self.active_cursor = cursor_horiz1
-            elif event.artist == dot1:
-                self.active_cursor = dot1
-            elif event.artist == cursor_vert2:
-                self.active_cursor = cursor_vert2
-            elif event.artist == cursor_horiz2:
-                self.active_cursor = cursor_horiz2
-            elif event.artist == dot2:
-                self.active_cursor = dot2
+            if event.artist == self.cursor_vert1:
+                self.active_cursor = self.cursor_vert1
+            elif event.artist == self.cursor_horiz1:
+                self.active_cursor = self.cursor_horiz1
+            elif event.artist == self.dot1:
+                self.active_cursor = self.dot1
+            elif event.artist == self.cursor_vert2:
+                self.active_cursor = self.cursor_vert2
+            elif event.artist == self.cursor_horiz2:
+                self.active_cursor = self.cursor_horiz2
+            elif event.artist == self.dot2:
+                self.active_cursor = self.dot2
             elif event.artist == self.Line1:
                 self.active_cursor =self. Line1
             elif event.artist == self.Line2:
@@ -353,39 +469,46 @@ def on_pick(event): # function to pick up the cursors or the dots
         self.active_cursor=None
         def on_motion(event): # function to move the cursors or the dots
             if self.active_cursor is not None and event.inaxes == ax:
-                if self.active_cursor == cursor_vert1:
-                    cursor_vert1.set_xdata([event.xdata, event.xdata])
-                    dot1.center = (event.xdata, dot1.center[1])
-                    # print(False)
-                elif self.active_cursor == cursor_horiz1:
-                    cursor_horiz1.set_ydata([event.ydata, event.ydata])
-                    dot1.center = (dot1.center[0], event.ydata)
-                elif self.active_cursor == dot1:
-                    dot1.center = (event.xdata, event.ydata)
-                    cursor_vert1.set_xdata([event.xdata, event.xdata])
-                    cursor_horiz1.set_ydata([event.ydata, event.ydata])
-                elif self.active_cursor == cursor_vert2:
-                    cursor_vert2.set_xdata([event.xdata, event.xdata])
-                    dot2.center = (event.xdata, dot2.center[1])
-                elif self.active_cursor == cursor_horiz2:
-                    cursor_horiz2.set_ydata([event.ydata, event.ydata])
-                    dot2.center = (dot2.center[0], event.ydata)
-                elif self.active_cursor == dot2:
-                    dot2.center = (event.xdata, event.ydata)
-                    cursor_vert2.set_xdata([event.xdata, event.xdata])
-                    cursor_horiz2.set_ydata([event.ydata, event.ydata])
+                if self.active_cursor == self.cursor_vert1:
+                    self.cursor_vert1.set_xdata([event.xdata, event.xdata])
+                    self.dot1.center = (event.xdata, self.dot1.center[1])
+                    base = self.cursor_label[0].text().split(':')[0]
+                    self.cursor_label[0].setText(f"{base}: {event.xdata:.2f}")
+                elif self.active_cursor == self.cursor_horiz1:
+                    self.cursor_horiz1.set_ydata([event.ydata, event.ydata])
+                    self.dot1.center = (self.dot1.center[0], event.ydata)
+                    base = self.cursor_label[1].text().split(':')[0]
+                    self.cursor_label[1].setText(f"{base}: {event.ydata:.2f}")
+                elif self.active_cursor == self.dot1:
+                    self.dot1.center = (event.xdata, event.ydata)
+                    self.cursor_vert1.set_xdata([event.xdata, event.xdata])
+                    self.cursor_horiz1.set_ydata([event.ydata, event.ydata])
+                    base = self.cursor_label[0].text().split(':')[0]
+                    self.cursor_label[0].setText(f"{base}: {event.xdata:.2f}")
+                    base = self.cursor_label[1].text().split(':')[0]
+                    self.cursor_label[1].setText(f"{base}: {event.ydata:.2f}")
+                elif self.active_cursor == self.cursor_vert2:
+                    self.cursor_vert2.set_xdata([event.xdata, event.xdata])
+                    self.dot2.center = (event.xdata, self.dot2.center[1])
+                    base = self.cursor_label[2].text().split(':')[0]
+                    self.cursor_label[2].setText(f"{base}: {event.xdata:.2f}")
+                elif self.active_cursor == self.cursor_horiz2:
+                    self.cursor_horiz2.set_ydata([event.ydata, event.ydata])
+                    self.dot2.center = (self.dot2.center[0], event.ydata)
+                    base = self.cursor_label[3].text().split(':')[0]
+                    self.cursor_label[3].setText(f"{base}: {event.ydata:.2f}")
+                elif self.active_cursor == self.dot2:
+                    self.dot2.center = (event.xdata, event.ydata)
+                    self.cursor_vert2.set_xdata([event.xdata, event.xdata])
+                    self.cursor_horiz2.set_ydata([event.ydata, event.ydata])
+                    base = self.cursor_label[2].text().split(':')[0]
+                    self.cursor_label[2].setText(f"{base}: {event.xdata:.2f}")
+                    base = self.cursor_label[3].text().split(':')[0]
+                    self.cursor_label[3].setText(f"{base}: {event.ydata:.2f}")
                 self.fig.canvas.draw()
-                
-                
                 plt.draw()
-                if dot1.center[0] is not None and dot1.center[1] is not None and dot2.center[0] is not None and dot2.center[1] is not None: # convert the value of the pixel to the value of the slot in the data
-                    x1_pixel=int((dot1.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                    y1_pixel=int((dot1.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-                    self.square_coords[0]=(x1_pixel,y1_pixel)
-                    x2_pixel=int((dot2.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                    y2_pixel=int((dot2.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-                    self.square_coords[1]=(x2_pixel,y2_pixel)
-                    
+                
+                self.change_pixel_to_arrayslot()
                 update_show(self.slider1.value(),self.slider2.value()) 
                
             elif self.active_cursor is not None and event.inaxes == axe:
@@ -412,4 +535,8 @@ def on_release(event):# function to release the selected object
         self.integrate_k=integrate_k
         self.put_cursors=put_cursors
         self.remove_cursors=remove_cursors
-   
\ No newline at end of file
+# if __name__ == "__main__":
+#     app = QApplication(sys.argv)
+#     window = GraphWindow()
+#     window.show()
+#     sys.exit(app.exec_()) 
\ No newline at end of file

From 38cc77c6043eb612c3c6fc18c52c4798d88288d0 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Thu, 10 Apr 2025 19:58:44 +0200
Subject: [PATCH 04/67] Changed the name of the class to Gui_3d

---
 src/mpes_tools/Gui_3d.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index aebd37e..6a1bfe8 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -13,7 +13,7 @@
 import xarray as xr
 
 
-class GraphWindow(QMainWindow):  #graphic window showing a 2d map controllable with sliders for the third dimension, with cursors showing cuts along the x direction for MDC and y direction for EDC
+class Gui_3d(QMainWindow):  #graphic window showing a 2d map controllable with sliders for the third dimension, with cursors showing cuts along the x direction for MDC and y direction for EDC
     def __init__(self,data_array: xr.DataArray,t,dt,technique):
         global t_final
         super().__init__()

From edecfcf3bc09fca4e7e05ed22980dec446663898 Mon Sep 17 00:00:00 2001
From: rettigl <l.rettig@web.de>
Date: Fri, 11 Apr 2025 22:19:19 +0200
Subject: [PATCH 05/67] update imports

---
 src/mpes_tools/Main.py           | 8 ++++----
 src/mpes_tools/__init__.py       | 4 ++--
 src/mpes_tools/call_gui.py       | 4 ++--
 src/mpes_tools/show_4d_window.py | 8 ++++----
 4 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/mpes_tools/Main.py b/src/mpes_tools/Main.py
index a0c23c5..eb9f0c0 100644
--- a/src/mpes_tools/Main.py
+++ b/src/mpes_tools/Main.py
@@ -5,10 +5,10 @@
 import matplotlib.pyplot as plt
 import numpy as np
 import h5py
-from additional_window import GraphWindow
+from mpes_tools.Gui_3d import Gui_3d
 import xarray as xr
-from hdf5 import load_h5
-from show_4d_window import show_4d_window
+from mpes_tools.hdf5 import load_h5
+from mpes_tools.show_4d_window import show_4d_window
 import os
 from PyQt5.QtGui import QPixmap
 
@@ -76,7 +76,7 @@ def open_file_phoibos(self):
         V1 = xr.DataArray(loaded_data['data_array'], dims=['Angle', 'Ekin','delay'], coords={'Angle': loaded_data['Angle'], 'Ekin': loaded_data['Ekin'],'delay': loaded_data['delay']})    
         axis=[V1['Angle'],V1['Ekin']-21.7,V1['delay']]
         # print(data.dims)
-        graph_window= GraphWindow(V1,0,0,'Phoibos')
+        graph_window= Gui_3d(V1,0,0,'Phoibos')
         
         graph_window.show()
         self.graph_windows.append(graph_window)
diff --git a/src/mpes_tools/__init__.py b/src/mpes_tools/__init__.py
index ea74086..cb01bcb 100644
--- a/src/mpes_tools/__init__.py
+++ b/src/mpes_tools/__init__.py
@@ -1,7 +1,7 @@
 """mpes-tools module easy access APIs."""
 import importlib.metadata
 
-from mpes_tools.show_4d_window import MainWindow
+from mpes_tools.show_4d_window import show_4d_window
 
 __version__ = importlib.metadata.version("mpes-tools")
-__all__ = ["MainWindow"]
\ No newline at end of file
+__all__ = ["show_4d_window"]
\ No newline at end of file
diff --git a/src/mpes_tools/call_gui.py b/src/mpes_tools/call_gui.py
index 14194a6..89d4c5c 100644
--- a/src/mpes_tools/call_gui.py
+++ b/src/mpes_tools/call_gui.py
@@ -1,11 +1,11 @@
 from PyQt5.QtWidgets import QApplication
-from Arpes_gui import MainWindow  # Assuming the first code is saved as main_window.py
+from mpes_tools.Main import ARPES_Analyser  # Assuming the first code is saved as main_window.py
 
 import sys
 
 if __name__ == "__main__":
     app = QApplication(sys.argv)  # Initialize the Qt application
-    window = MainWindow()  # Create an instance of your main window
+    window = ARPES_Analyser()  # Create an instance of your main window
     window.show()  # Show the window
     sys.exit(app.exec_())  # Run the Qt event loop
     
diff --git a/src/mpes_tools/show_4d_window.py b/src/mpes_tools/show_4d_window.py
index 69a0a1a..6c3bf7f 100644
--- a/src/mpes_tools/show_4d_window.py
+++ b/src/mpes_tools/show_4d_window.py
@@ -5,7 +5,7 @@
 import matplotlib.pyplot as plt
 import numpy as np
 import h5py
-from mpes_tools.Gui_3d import GraphWindow
+from mpes_tools.Gui_3d import Gui_3d
 import xarray as xr
 from mpes_tools.hdf5 import load_h5
 
@@ -147,7 +147,7 @@ def open_graph_kxkydt(self):
         E1=self.data_array[self.axes[2]][self.slider1[0].value()].item()
         E2=self.data_array[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()+1].item()
         data_kxkydt = self.data_array.loc[{self.axes[2]:slice(E1,E2)}].mean(dim=(self.axes[2]))
-        graph_window=GraphWindow(data_kxkydt, self.slider3[0].value(), self.slider4[0].value(),'METIS')
+        graph_window=Gui_3d(data_kxkydt, self.slider3[0].value(), self.slider4[0].value(),'METIS')
         # Show the graph window
         graph_window.show()
         self.graph_windows.append(graph_window)
@@ -156,7 +156,7 @@ def open_graph_kxedt(self):
         ky1=self.data_array[self.axes[1]][self.slider1[1].value()].item()
         ky2=self.data_array[self.axes[1]][self.slider1[1].value()+self.slider2[1].value()+1].item()
         data_kxedt = self.data_array.loc[{self.axes[1]:slice(ky1,ky2)}].mean(dim=(self.axes[1]))
-        graph_window = GraphWindow(data_kxedt, self.slider3[1].value(), self.slider4[1].value(),'METIS')
+        graph_window = Gui_3d(data_kxedt, self.slider3[1].value(), self.slider4[1].value(),'METIS')
         # Show the graph window
         graph_window.show()
         self.graph_windows.append(graph_window)
@@ -166,7 +166,7 @@ def open_graph_kyedt(self):
         kx2=self.data_array[self.axes[0]][self.slider1[2].value()+self.slider2[2].value()+1].item()
         data_kyedt = self.data_array.loc[{self.axes[0]:slice(kx1,kx2)}].mean(dim=(self.axes[0]))
         print(type(data_kyedt))
-        graph_window = GraphWindow(data_kyedt, self.slider3[2].value(), self.slider4[2].value(),'METIS')
+        graph_window = Gui_3d(data_kyedt, self.slider3[2].value(), self.slider4[2].value(),'METIS')
         # Show the graph window
         
         graph_window.show()

From 263c72b3dfde1f48c92c3ec2158ef390d48edcdb Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 11 Apr 2025 14:54:26 +0200
Subject: [PATCH 06/67] Took out the cursors for the EDC graph since it will be
 treated in the fit panel, add more comments to the code

---
 src/mpes_tools/Gui_3d.py | 167 +++++++++++----------------------------
 1 file changed, 46 insertions(+), 121 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index 6a1bfe8..ce4b338 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -12,10 +12,10 @@
 
 import xarray as xr
 
-
-class Gui_3d(QMainWindow):  #graphic window showing a 2d map controllable with sliders for the third dimension, with cursors showing cuts along the x direction for MDC and y direction for EDC
+#graphic window showing a 2d map controllable with sliders for the third dimension, with cursors showing cuts along the x direction for MDC and y direction for EDC
+# Two vertical cursors and two horizontal cursors are defined in the main graph with each same color for the cursors being horizontal and vertical intercept each other in a dot so one can move either each cursor or the dot itself which will move both cursors. 
+class Gui_3d(QMainWindow):  
     def __init__(self,data_array: xr.DataArray,t,dt,technique):
-        global t_final
         super().__init__()
 
         self.setWindowTitle("Graph Window")
@@ -36,9 +36,6 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         
         self.checkbox_k = QCheckBox("Integrate_k")
         self.checkbox_k.stateChanged.connect(self.checkbox_k_changed)
-        
-        self.checkbox_cursors = QCheckBox("energy_cursors")
-        self.checkbox_cursors.stateChanged.connect(self.checkbox_cursors_changed)
 
         self.save_button = QPushButton('Save Results', self)
         self.save_button.clicked.connect(self.save_results)
@@ -85,32 +82,16 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         # self.slider1.setFixedSize(200, 12)  # Change the width and height as needed
         # self.slider2.setFixedSize(200, 12)  # Change the width and height as needed
         
+        # Create a layout for the central widget
         slider_layout.addWidget(self.slider1)
         slider_layout.addWidget(self.slider1_label)
         slider_layout.addWidget(self.slider2)
         slider_layout.addWidget(self.slider2_label)
         layout.addLayout(slider_layout)
-        # Create a layout for the central widget
-        self.active_cursor = None
-        self.cursorlinev1=1
-        self.cursorlinev2=0
-        # self.v1_pixel=None
-        # self.v2_pixel=None
-        self.Line1=None
-        self.Line2=None
-        self.square_artists = []  # To store the artists representing the dots
-        self.square_coords = [[0, 0], [0, 0]]  # To store the coordinates of the dots
-        self.square_count = 0  # To keep track of the number of dots drawn
-        
-        
-        self.cid_press2= None
-        self.line_artists=[]
-        self.cid_press3 = None
-        self.cid_press4 = None
-        self.cid_press = None
 
-        # Create a figure and canvas for the graph
         
+
+
         self.data=data_array
         self.axis=[data_array.coords[dim].data for dim in data_array.dims]
         # print(data_array.dims)
@@ -118,9 +99,19 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
             self.axis[1]=self.axis[1]-21.7
             self.data = self.data.assign_coords(Ekin=self.data.coords['Ekin'] -21.7)
         
+        
+        
+        # define the cut for the spectra of the main graph
+        self.data_t=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
+        
         self.t=t
         self.dt=dt
-        self.data_t=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
+        self.active_cursor = None
+        self.Line1=None
+        self.Line2=None
+        self.square_artists = []  # To store the artists representing the dots
+        self.square_coords = [[0, 0], [0, 0]]  # To store the coordinates of the dots
+        self.square_count = 0  # To keep track of the number of dots drawn
         self.cursor_vert1 = []
         self.cursor_horiz1 = []
         self.cursor_vert2 =[]
@@ -128,15 +119,15 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         self.integrated_edc=None
         self.integrated_mdc=None
         
-        self.ssshow(t,dt)
+        
         self.slider1.setRange(0,len(self.axis[2])-1)
         self.slider1_label.setText(self.data.dims[2]+": 0")
         self.slider2_label.setText("Δ"+self.data.dims[2]+": 0")
-        self.plot=np.zeros_like(self.data[1,:])
         
         self.slider1.valueChanged.connect(self.slider1_changed)
         self.slider2.valueChanged.connect(self.slider2_changed)
-        t_final=self.axis[2].shape[0]
+        
+        self.show(t,dt)
         
         menu_bar = self.menuBar()
         graph_menu1 = menu_bar.addMenu("Fit Panel")
@@ -182,35 +173,8 @@ def save_results(self):
         # with open('gui_results.json', 'w') as f:
         #     json.dump(results, f)
         print("Results saved!")
-        
-    def results_3d(self):
-        def integrated_edc(self):
-            return self.integrated_edc
-        def integrated_mdc(self):
-            return self.integrated_mdc
-        def yellowline_edc(self):
-            return self.data_t.isel({self.data.dims[0]:self.square_coords[0][1]})
-        def greenline_edc(self):
-            return self.data_t.isel({self.data.dims[0]:self.square_coords[1][1]})
-        def yellowline_mdc(self):
-            return self.data_t.isel({self.data.dims[1]: int(self.square_coords[0][0])})
-        def greenline_mdc(self):
-            return self.data_t.isel({self.data.dims[1]: int(self.square_coords[1][0])})
-        def current_spectra(self):
-            return self.data_t
-        def intensity_box(self):
-            return self.int
-        def yellow_vertical(self):
-            return self.dot1.center[0]
-        def yellow_horizontal(self):
-            return self.dot1.center[1]
-        def green_vertical(self):
-            return self.dot2.center[0]
-        def green_horizontal(self):
-            return self.dot2.center[1]
-        
-        
-    def main_graph_cursor_changed(self, index):
+                  
+    def main_graph_cursor_changed(self, index): #set manually the values for the cursors in the main graph
         value = self.cursor_inputs[index].text()
         value=float(value)
         if index ==0: 
@@ -252,7 +216,6 @@ def change_pixel_to_arrayslot(self):# convert the value of the pixel to the valu
         
     def slider1_changed(self,value): # change the slider controlling the third dimension
         # self.slider1_label.setText(str(value))
-        print(value)
         base = self.slider1_label.text().split(':')[0]
         self.slider1_label.setText(f"{base}: {self.data[self.data.dims[2]][value].item():.2f}")
         self.update_show(self.slider1.value(),self.slider2.value())
@@ -263,22 +226,17 @@ def slider2_changed(self,value): # change the slider controlling the third dimen
         self.slider2_label.setText(f"{base}: {value}")
         self.update_show(self.slider1.value(),self.slider2.value())
         self.dt=self.slider2.value()
-    def checkbox_e_changed(self, state):
-        print(state)
+    def checkbox_e_changed(self, state): # Checkbox for integrating the EDC between the cursors
         if state == Qt.Checked:
             self.integrate_E()
         else:
             self.update_show(self.slider1.value(),self.slider2.value())
-    def checkbox_k_changed(self, state):
+    def checkbox_k_changed(self, state): # Checkbox for integrating the MDC between the cursors
         if state == Qt.Checked:
             self.integrate_k()
         else:
             self.update_show(self.slider1.value(),self.slider2.value())
-    def checkbox_cursors_changed(self, state):
-        if state == Qt.Checked:
-            self.put_cursors()
-        else:
-            self.remove_cursors()
+
     
     def fit_energy_panel(self,event): # open up the fit panel for the EDC 
         graph_window=fit_panel(self.data,self.square_coords[0][1], self.square_coords[1][1], self.t, self.dt, self.data.dims[1])
@@ -294,20 +252,7 @@ def fit_box_panel(self,event): # open up the fit panel for the intensity box
         self.graph_windows.append(graph_window)
         
     
-    def ssshow(self, t, dt): # This is where the updates after changing the sliders happen
-        
-        def put_cursors(): # add cursors in the EDC graph
-            # Adjust to use xarray's coords for axis referencing
-            self.Line1 = axe.axvline(x=self.cursorlinev1, color='red', linestyle='--', linewidth=2, label='Vertical Line', picker=10)
-            self.Line2 = axe.axvline(x=self.cursorlinev2, color='red', linestyle='--', linewidth=2, label='Vertical Line', picker=10)
-            plt.draw()
-            self.fig.canvas.draw()
-    
-        def remove_cursors(): # remoe cursors in the EDC graph
-            self.Line1.remove()
-            self.Line2.remove()
-            plt.draw()
-            self.fig.canvas.draw()
+    def show(self, t, dt): # This is where the updates after changing the sliders happen
     
         def integrate_E(): # integrate EDC between the two cursors in the main graph
             self.axs[1, 0].clear()
@@ -374,34 +319,27 @@ def update_show(t, dt): # update the main graph as well as the relevant EDC and
                 self.data_t.isel({self.data.dims[0]:self.square_coords[1][1]}).plot(ax=self.axs[1,0],color='green')
                 self.data_t.isel({self.data.dims[1]:int(self.square_coords[0][0])}).plot(ax=self.axs[0,1],color='orange')
                 self.data_t.isel({self.data.dims[1]:int(self.square_coords[1][0])}).plot(ax=self.axs[0,1],color='green')
-                
-                
-    
-            if self.checkbox_cursors.isChecked():
-                self.Line1 = self.axs[1, 0].axvline(x=self.cursorlinev1, color='red', linestyle='--', linewidth=2, label='Vertical Line', picker=10)
-                self.Line2 = self.axs[1, 0].axvline(x=self.cursorlinev2, color='red', linestyle='--', linewidth=2, label='Vertical Line', picker=10)
-                plt.draw()
-                self.fig.canvas.draw()
-    
-            box()
+            
+            box() # update the intensity box graph
             time1 = self.axis[2][t]
             timedt1 = self.axis[2][t + dt]
-            self.axs[0, 0].set_title(f't: {time1:.2f}, t+dt: {timedt1}')
+            self.axs[0, 0].set_title(f't: {time1:.2f}, t+dt: {timedt1:.2f}')
             self.fig.canvas.draw()
             plt.draw()
    
         # im6 = self.axs[0, 0].imshow(self.data_t.data, extent=[self.axis[1][0], self.axis[1][-1], self.axis[0][0], self.axis[0][-1]], origin='lower',cmap='terrain', aspect='auto')
+        
+        # plot the main graph
         im = self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2]).plot(ax=self.axs[0, 0], cmap='terrain', add_colorbar=False)
         
-        # define the cursors in the main graph
+        # define the initial positions of the cursors in the main graph
         
         initial_x = 0
         initial_y = 0
         initial_x2 = 0.5
         initial_y2 = 0.5
         ax = self.axs[0, 0]
-        axe = self.axs[1, 0]
-    
+        # define the lines for the cursors
         ymin, ymax = self.axs[0, 0].get_ylim()
         xmin, xmax = self.axs[0, 0].get_ylim()
         ymin, ymax = 5 * ymin, 5 * ymax
@@ -411,6 +349,7 @@ def update_show(t, dt): # update the main graph as well as the relevant EDC and
         self.cursor_vert2 = Line2D([initial_x2, initial_x2], [ymin, ymax], color='green', linewidth=2, picker=10, linestyle='--')
         self.cursor_horiz2 = Line2D([xmin, xmax], [initial_y2, initial_y2], color='green', linewidth=2, picker=10, linestyle='--')
         
+        # show the initial values of the cursors 
         base = self.cursor_label[0].text().split(':')[0]
         self.cursor_label[0].setText(f"{base}: {initial_x:.2f}")
         base = self.cursor_label[1].text().split(':')[0]
@@ -423,28 +362,25 @@ def update_show(t, dt): # update the main graph as well as the relevant EDC and
         # define the dots that connect the cursors
         self.dot1 = Circle((initial_x, initial_y), radius=0.05, color='yellow', picker=10)
         self.dot2 = Circle((initial_x2, initial_y2), radius=0.05, color='green', picker=10)
+        
+        # add the lines and the cursors to the main graph
+        ax.add_line(self.cursor_vert1)
+        ax.add_line(self.cursor_horiz1)
+        ax.add_patch(self.dot1)
+        ax.add_line(self.cursor_vert2)
+        ax.add_line(self.cursor_horiz2)
+        ax.add_patch(self.dot2)
     
         self.change_pixel_to_arrayslot()
         
+        # define the integrated EDC and MDC 
         x_min = int(min(self.square_coords[1][1], self.square_coords[0][1]))
         x_max = int(max(self.square_coords[1][1], self.square_coords[0][1])) + 1
         self.integrated_edc=self.data_t.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
         x_min = int(min(self.square_coords[0][0], self.square_coords[1][0]))
         x_max = int(max(self.square_coords[0][0], self.square_coords[1][0])) + 1
         self.integrated_mdc=self.data_t.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
-        
-        ax.add_line(self.cursor_vert1)
-        ax.add_line(self.cursor_horiz1)
-        ax.add_patch(self.dot1)
-        ax.add_line(self.cursor_vert2)
-        ax.add_line(self.cursor_horiz2)
-        ax.add_patch(self.dot2)
-        initial_xe=1
-        
-        axe.axvline(x=initial_xe, color='red', linestyle='--',linewidth=2, label='Vertical Line')
-        axe.axvline(x=100, color='red', linestyle='--',linewidth=2, label='Vertical Line')
-        axe.axhline(y=0, color='red', linestyle='--',linewidth=2, label='Horizontal Line')
-        axe.axhline(y=100, color='red', linestyle='--',linewidth=2, label='Horizontal Line')
+
         plt.draw()
         update_show(self.slider1.value(),self.slider2.value()) 
         self.fig.canvas.draw()
@@ -511,17 +447,7 @@ def on_motion(event): # function to move the cursors or the dots
                 self.change_pixel_to_arrayslot()
                 update_show(self.slider1.value(),self.slider2.value()) 
                
-            elif self.active_cursor is not None and event.inaxes == axe:
-                if self.active_cursor == self.Line1:
-                    self.Line1.set_xdata([event.xdata, event.xdata])
-                    self.cursorlinev1= event.xdata
-                elif self.active_cursor == self.Line2:
-                    self.Line2.set_xdata([event.xdata, event.xdata])
-                    self.cursorlinev2= event.xdata
-                self.fig.canvas.draw()
-                plt.draw()
-                self.v1_pixel=int((self.cursorlinev1 - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                self.v2_pixel=int((self.cursorlinev2 - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+            
         def on_release(event):# function to release the selected object
             self.active_cursor = None
             
@@ -533,8 +459,7 @@ def on_release(event):# function to release the selected object
         self.update_show=update_show
         self.integrate_E=integrate_E
         self.integrate_k=integrate_k
-        self.put_cursors=put_cursors
-        self.remove_cursors=remove_cursors
+
 # if __name__ == "__main__":
 #     app = QApplication(sys.argv)
 #     window = GraphWindow()

From 82bac6e0891ff1042ee514a1623b37b8c3fe387c Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 11 Apr 2025 15:39:41 +0200
Subject: [PATCH 07/67] changed the method of plotting the xaarays

---
 src/mpes_tools/Gui_3d.py | 81 +++++++++++++++++++++-------------------
 1 file changed, 42 insertions(+), 39 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index ce4b338..eba988a 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -127,7 +127,7 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         self.slider1.valueChanged.connect(self.slider1_changed)
         self.slider2.valueChanged.connect(self.slider2_changed)
         
-        self.show(t,dt)
+        self.show_graphs(t,dt)
         
         menu_bar = self.menuBar()
         graph_menu1 = menu_bar.addMenu("Fit Panel")
@@ -197,7 +197,7 @@ def main_graph_cursor_changed(self, index): #set manually the values for the cur
             self.dot2.center = (self.dot2.center[0], value)
             base = self.cursor_label[3].text().split(':')[0]
             self.cursor_label[3].setText(f"{base}: {value:.2f}")
-        self.change_pixel_to_arrayslot()
+        # self.change_pixel_to_arrayslot()
         self.update_show(self.slider1.value(),self.slider2.value())
         try:
             num = float(value)
@@ -205,14 +205,14 @@ def main_graph_cursor_changed(self, index): #set manually the values for the cur
             # Update graph logic here
         except ValueError:
             print("Invalid input!")
-    def change_pixel_to_arrayslot(self):# convert the value of the pixel to the value of the slot in the data
-        if self.dot1.center[0] is not None and self.dot1.center[1] is not None and self.dot2.center[0] is not None and self.dot2.center[1] is not None: 
-            x1_pixel=int((self.dot1.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            y1_pixel=int((self.dot1.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            self.square_coords[0]=[x1_pixel,y1_pixel]
-            x2_pixel=int((self.dot2.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            y2_pixel=int((self.dot2.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            self.square_coords[1]=[x2_pixel,y2_pixel]
+    # def change_pixel_to_arrayslot(self):# convert the value of the pixel to the value of the slot in the data
+    #     if self.dot1.center[0] is not None and self.dot1.center[1] is not None and self.dot2.center[0] is not None and self.dot2.center[1] is not None: 
+    #         x1_pixel=int((self.dot1.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+    #         y1_pixel=int((self.dot1.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
+    #         self.square_coords[0]=[x1_pixel,y1_pixel]
+    #         x2_pixel=int((self.dot2.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
+    #         y2_pixel=int((self.dot2.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
+    #         self.square_coords[1]=[x2_pixel,y2_pixel]
         
     def slider1_changed(self,value): # change the slider controlling the third dimension
         # self.slider1_label.setText(str(value))
@@ -252,17 +252,17 @@ def fit_box_panel(self,event): # open up the fit panel for the intensity box
         self.graph_windows.append(graph_window)
         
     
-    def show(self, t, dt): # This is where the updates after changing the sliders happen
+    def show_graphs(self, t, dt): # This is where the updates after changing the sliders happen
     
         def integrate_E(): # integrate EDC between the two cursors in the main graph
             self.axs[1, 0].clear()
             plt.draw()
     
-            x_min = int(min(self.square_coords[1][1], self.square_coords[0][1]))
-            x_max = int(max(self.square_coords[1][1], self.square_coords[0][1])) + 1
+            x_min = int(min(self.dot2.center[1], self.dot1.center[1]))
+            x_max = int(max(self.dot2.center[1], self.dot1.center[1])) + 1
     
             # self.data_t.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0]).plot(ax=self.axs[1,0])
-            self.integrated_edc=self.data_t.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
+            self.integrated_edc=self.data_t.sel({self.data.dims[0]:slice(x_min, x_max)}, method='nearest').sum(dim=self.data.dims[0])
             self.integrated_edc.plot(ax=self.axs[1,0])
             self.fig.canvas.draw()
     
@@ -270,26 +270,28 @@ def integrate_k(): # integrate MDC between the two cursors in the main graph
             self.axs[0, 1].clear()
             plt.draw()
     
-            x_min = int(min(self.square_coords[0][0], self.square_coords[1][0]))
-            x_max = int(max(self.square_coords[0][0], self.square_coords[1][0])) + 1
+            x_min = int(min(self.dot1.center[0], self.dot2.center[0]))
+            x_max = int(max(self.dot1.center[0], self.dot2.center[0])) + 1
     
             # self.data_t.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1]).plot(ax=self.axs[0,1])
-            self.integrated_mdc=self.data_t.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
+            self.integrated_mdc=self.data_t.sel({self.data.dims[1]:slice(x_min, x_max)}, method='nearest').sum(dim=self.data.dims[1])
             self.integrated_mdc.plot(ax=self.axs[0,1])
             self.fig.canvas.draw()
     
         def box(): # generate the intensity graph between the four cursors in the main graph
-            self.int = np.zeros_like(self.axis[2])
             self.axs[1, 1].clear()
-            x0, y0 = map(int, self.square_coords[0])
-            x1, y1 = map(int, self.square_coords[1])
+            
+            x0,y0=self.dot1.center
+            x1,y1=self.dot2.center
     
             # Ensure (x0, y0) is the top-left corner and (x1, y1) is the bottom-right
             x0, x1 = sorted([x0, x1])
             y0, y1 = sorted([y0, y1])
-    
-            self.int = self.data.isel({self.data.dims[0]: slice(y0, y1), self.data.dims[1]: slice(x0, x1)}).sum(dim=(self.data.dims[0], self.data.dims[1]))
             
+            print (x0,x1,y0,y1)
+    
+            self.int = self.data.loc[{self.data.dims[0]: slice(y0, y1), self.data.dims[1]: slice(x0, x1)}].sum(dim=(self.data.dims[0], self.data.dims[1]))
+            print (self.int)
             if x0 != x1 and y0 != y1:
                 
                 self.int.plot(ax=self.axs[1,1])
@@ -299,26 +301,29 @@ def box(): # generate the intensity graph between the four cursors in the main g
         def update_show(t, dt): # update the main graph as well as the relevant EDC and MDC cuts. Also the box intensity
             self.axs[0, 1].clear()
             self.axs[1, 0].clear()
+            #update the main graph/ spectra
             self.data_t=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
             im.set_array(self.data_t)
+            # show the cuts for the EDC and MDC
             if self.checkbox_e.isChecked() and self.checkbox_k.isChecked():
                 integrate_E()
                 integrate_k()
             elif self.checkbox_e.isChecked():
                 integrate_E()
-                self.data_t.isel({self.data.dims[1]: int(self.square_coords[0][0])}).plot(ax=self.axs[0, 1], color='orange')
-                self.data_t.isel({self.data.dims[1]:int(self.square_coords[1][0])}).plot(ax=self.axs[0, 1], color='green')
+                self.data_t.sel({self.data.dims[1]:self.dot1.center[0]}, method='nearest').plot(ax=self.axs[0, 1], color='orange')
+                self.data_t.sel({self.data.dims[1]:self.dot2.center[0]}, method='nearest').plot(ax=self.axs[0, 1], color='green')
                 
             elif self.checkbox_k.isChecked():
                 integrate_k()
-                self.data_t.isel({self.data.dims[0]:self.square_coords[0][1]}).plot(ax=self.axs[1, 0], color='orange')
-                self.data_t.isel({self.data.dims[0]:self.square_coords[1][1]}).plot(ax=self.axs[1, 0], color='green')
+                self.data_t.sel({self.data.dims[0]:self.dot1.center[1]}, method='nearest').plot(ax=self.axs[1, 0], color='orange')
+                self.data_t.sel({self.data.dims[0]:self.dot2.center[1]}, method='nearest').plot(ax=self.axs[1, 0], color='green')
                 
-            else:
-                self.data_t.isel({self.data.dims[0]:self.square_coords[0][1]}).plot(ax=self.axs[1,0],color='orange')
-                self.data_t.isel({self.data.dims[0]:self.square_coords[1][1]}).plot(ax=self.axs[1,0],color='green')
-                self.data_t.isel({self.data.dims[1]:int(self.square_coords[0][0])}).plot(ax=self.axs[0,1],color='orange')
-                self.data_t.isel({self.data.dims[1]:int(self.square_coords[1][0])}).plot(ax=self.axs[0,1],color='green')
+            else: 
+                self.data_t.sel({self.data.dims[0]:self.dot1.center[1]}, method='nearest').plot(ax=self.axs[1,0],color='orange')
+                self.data_t.sel({self.data.dims[0]:self.dot2.center[1]}, method='nearest').plot(ax=self.axs[1,0],color='green')
+                self.data_t.sel({self.data.dims[1]:self.dot1.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='orange')
+                self.data_t.sel({self.data.dims[1]:self.dot2.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='green')
+
             
             box() # update the intensity box graph
             time1 = self.axis[2][t]
@@ -326,8 +331,6 @@ def update_show(t, dt): # update the main graph as well as the relevant EDC and
             self.axs[0, 0].set_title(f't: {time1:.2f}, t+dt: {timedt1:.2f}')
             self.fig.canvas.draw()
             plt.draw()
-   
-        # im6 = self.axs[0, 0].imshow(self.data_t.data, extent=[self.axis[1][0], self.axis[1][-1], self.axis[0][0], self.axis[0][-1]], origin='lower',cmap='terrain', aspect='auto')
         
         # plot the main graph
         im = self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2]).plot(ax=self.axs[0, 0], cmap='terrain', add_colorbar=False)
@@ -371,14 +374,14 @@ def update_show(t, dt): # update the main graph as well as the relevant EDC and
         ax.add_line(self.cursor_horiz2)
         ax.add_patch(self.dot2)
     
-        self.change_pixel_to_arrayslot()
+        # self.change_pixel_to_arrayslot()
         
         # define the integrated EDC and MDC 
-        x_min = int(min(self.square_coords[1][1], self.square_coords[0][1]))
-        x_max = int(max(self.square_coords[1][1], self.square_coords[0][1])) + 1
+        x_min = int(min(self.dot2.center[1], self.dot1.center[1]))
+        x_max = int(max(self.dot2.center[1], self.dot1.center[1])) + 1
         self.integrated_edc=self.data_t.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
-        x_min = int(min(self.square_coords[0][0], self.square_coords[1][0]))
-        x_max = int(max(self.square_coords[0][0], self.square_coords[1][0])) + 1
+        x_min = int(min(self.dot1.center[0], self.dot2.center[0]))
+        x_max = int(max(self.dot1.center[0], self.dot2.center[0])) + 1
         self.integrated_mdc=self.data_t.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
 
         plt.draw()
@@ -444,7 +447,7 @@ def on_motion(event): # function to move the cursors or the dots
                 self.fig.canvas.draw()
                 plt.draw()
                 
-                self.change_pixel_to_arrayslot()
+                # self.change_pixel_to_arrayslot()
                 update_show(self.slider1.value(),self.slider2.value()) 
                
             

From c690b4a197ecabc300bc41581cb46518f33d2f8d Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 11 Apr 2025 15:47:44 +0200
Subject: [PATCH 08/67] added small comments

---
 src/mpes_tools/Gui_3d.py | 28 +++++++++-------------------
 1 file changed, 9 insertions(+), 19 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index eba988a..691e698 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -30,7 +30,7 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         
         self.fig, self.axs = plt.subplots(2,2,figsize=(20,16))
         self.canvas = FigureCanvas(self.fig)
-        
+        # add the checkboxes for EDC and MDC integration and the button to save the results
         self.checkbox_e = QCheckBox("Integrate_energy")
         self.checkbox_e.stateChanged.connect(self.checkbox_e_changed)
         
@@ -40,6 +40,7 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         self.save_button = QPushButton('Save Results', self)
         self.save_button.clicked.connect(self.save_results)
         
+        #create the layout
         h_layout = QHBoxLayout()
         self.cursor_label=[]
         self.cursor_inputs = []
@@ -66,7 +67,6 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         layout.addLayout(h_layout)
         layout.addWidget(self.canvas)
         layout.addWidget(self.save_button)
-        # layout.addWidget(self.checkbox_cursors)
         
         slider_layout= QHBoxLayout()
         self.slider1 = QSlider(Qt.Horizontal)
@@ -89,21 +89,17 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         slider_layout.addWidget(self.slider2_label)
         layout.addLayout(slider_layout)
 
-        
-
-
+        #define the data_array
         self.data=data_array
         self.axis=[data_array.coords[dim].data for dim in data_array.dims]
-        # print(data_array.dims)
         if technique == 'Phoibos':
             self.axis[1]=self.axis[1]-21.7
             self.data = self.data.assign_coords(Ekin=self.data.coords['Ekin'] -21.7)
-        
-        
-        
+
         # define the cut for the spectra of the main graph
         self.data_t=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
         
+        #Initialize the relevant prameters
         self.t=t
         self.dt=dt
         self.active_cursor = None
@@ -119,7 +115,7 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         self.integrated_edc=None
         self.integrated_mdc=None
         
-        
+        # sliders for the delay
         self.slider1.setRange(0,len(self.axis[2])-1)
         self.slider1_label.setText(self.data.dims[2]+": 0")
         self.slider2_label.setText("Δ"+self.data.dims[2]+": 0")
@@ -127,8 +123,10 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         self.slider1.valueChanged.connect(self.slider1_changed)
         self.slider2.valueChanged.connect(self.slider2_changed)
         
+        #run the main code to show the graphs and cursors
         self.show_graphs(t,dt)
         
+        #create a menu for the fit panel
         menu_bar = self.menuBar()
         graph_menu1 = menu_bar.addMenu("Fit Panel")
         
@@ -151,7 +149,7 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
 
     
 
-    def save_results(self):
+    def save_results(self):#save the relevant results in a .pkl file which can be accessed easily for Jupyter Notebook workflow
         results = {
             'integrated_edc': self.integrated_edc,
             'integrated_mdc': self.integrated_mdc,
@@ -205,14 +203,6 @@ def main_graph_cursor_changed(self, index): #set manually the values for the cur
             # Update graph logic here
         except ValueError:
             print("Invalid input!")
-    # def change_pixel_to_arrayslot(self):# convert the value of the pixel to the value of the slot in the data
-    #     if self.dot1.center[0] is not None and self.dot1.center[1] is not None and self.dot2.center[0] is not None and self.dot2.center[1] is not None: 
-    #         x1_pixel=int((self.dot1.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-    #         y1_pixel=int((self.dot1.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-    #         self.square_coords[0]=[x1_pixel,y1_pixel]
-    #         x2_pixel=int((self.dot2.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-    #         y2_pixel=int((self.dot2.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-    #         self.square_coords[1]=[x2_pixel,y2_pixel]
         
     def slider1_changed(self,value): # change the slider controlling the third dimension
         # self.slider1_label.setText(str(value))

From e993b0eabf926f651c6a252fb5449947e83f1419 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 11 Apr 2025 16:58:55 +0200
Subject: [PATCH 09/67] small change

---
 src/mpes_tools/show_4d_window.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/mpes_tools/show_4d_window.py b/src/mpes_tools/show_4d_window.py
index 6c3bf7f..029c822 100644
--- a/src/mpes_tools/show_4d_window.py
+++ b/src/mpes_tools/show_4d_window.py
@@ -227,8 +227,7 @@ def update_energy(self,Energy,dE,te,dte):
         data_avg=self.data_array.loc[{self.axes[2]:slice(E1,E2), self.axes[3]:slice(te1,te2)}].mean(dim=(self.axes[2], self.axes[3]))
         self.im=data_avg.T.plot(ax=ax,cmap='terrain')
         ax.set_title(f'energy: {E1:.2f}, E+dE: {E2:.2f} , t: {te1:.2f}, t+dt: {te2:.2f}')
-        # print(self.data_array.coords[self.axes[0]][self.slider1[1].value()].item())
-        # self.ev = ax.axvline(x=self.data_array.coords[self.axes[0]][self.slider1[1].value()].item(), color='r', linestyle='--')
+        
         self.ev = ax.axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
         self.eh = ax.axhline(y=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
         self.pxv = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')

From c8d649725c1f7c662d47a79901ff5c454b63e99f Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Sat, 12 Apr 2025 18:07:58 +0200
Subject: [PATCH 10/67] add extraction result button for the Jupyter Notebook
 and corrected small bug the fit panel

---
 src/mpes_tools/Gui_3d.py         | 150 ++++++++++++++++++++-----------
 src/mpes_tools/fit_panel.py      |   8 +-
 src/mpes_tools/graphs.py         |   2 -
 src/mpes_tools/show_4d_window.py |  22 ++---
 4 files changed, 114 insertions(+), 68 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index 691e698..c053588 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -9,6 +9,7 @@
 import json
 import pickle
 from mpes_tools.fit_panel import fit_panel
+from IPython.core.getipython import get_ipython
 
 import xarray as xr
 
@@ -28,8 +29,10 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         layout = QVBoxLayout()
         central_widget.setLayout(layout)
         
+        
         self.fig, self.axs = plt.subplots(2,2,figsize=(20,16))
         self.canvas = FigureCanvas(self.fig)
+        # plt.ioff()
         # add the checkboxes for EDC and MDC integration and the button to save the results
         self.checkbox_e = QCheckBox("Integrate_energy")
         self.checkbox_e.stateChanged.connect(self.checkbox_e_changed)
@@ -37,8 +40,9 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         self.checkbox_k = QCheckBox("Integrate_k")
         self.checkbox_k.stateChanged.connect(self.checkbox_k_changed)
 
-        self.save_button = QPushButton('Save Results', self)
-        self.save_button.clicked.connect(self.save_results)
+        self.save_button = QPushButton('Extract results', self)
+        self.save_button.clicked.connect(self.create_new_cell)
+        # self.save_button.clicked.connect(self.save_results)
         
         #create the layout
         h_layout = QHBoxLayout()
@@ -97,7 +101,7 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
             self.data = self.data.assign_coords(Ekin=self.data.coords['Ekin'] -21.7)
 
         # define the cut for the spectra of the main graph
-        self.data_t=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
+        self.data2D_plot=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
         
         #Initialize the relevant prameters
         self.t=t
@@ -105,9 +109,6 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         self.active_cursor = None
         self.Line1=None
         self.Line2=None
-        self.square_artists = []  # To store the artists representing the dots
-        self.square_coords = [[0, 0], [0, 0]]  # To store the coordinates of the dots
-        self.square_count = 0  # To keep track of the number of dots drawn
         self.cursor_vert1 = []
         self.cursor_horiz1 = []
         self.cursor_vert2 =[]
@@ -147,17 +148,67 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         
         print(data_array.dims)
 
-    
+    def create_new_cell(self):
+        content = f"""
+# Code generated by GUI for the following parameters:
+import matplotlib.pyplot as plt
 
+# data= 'your data_array'
+data=V1
+data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)
+time1={self.axis[2][self.slider1.value()]}
+time2={self.axis[2][self.slider1.value()+self.slider2.value()]}
+t={self.slider1.value()}
+dt={self.slider2.value()}
+data2D_plot=data.isel({{data.dims[2]:slice(t, t+dt+1)}}).sum(dim=data.dims[2])
+yellowline_edc_energy={self.dot1.center[1]}
+greenline_edc_energy={self.dot2.center[1]}
+yellowline_mdc_momentum={self.dot1.center[0]}
+greenline_mdc_momentum={self.dot2.center[0]}
+#plot Data_2d between t and t+dt
+fig,ax=plt.subplots(1,1,figsize=(12,8))
+data2D_plot.plot(ax=ax, cmap='terrain', add_colorbar=False)
+#plot EDC yellow and green
+fig,ax=plt.subplots(1,1,figsize=(12,8))
+data2D_plot.sel({{data.dims[0]:yellowline_edc_energy}}, method='nearest').plot(ax=ax,color='orange')
+data2D_plot.sel({{data.dims[0]:greenline_edc_energy}}, method='nearest').plot(ax=ax,color='green')
+#plot integrated EDC
+fig,ax=plt.subplots(1,1,figsize=(12,8))
+data2D_plot.sel({{data.dims[0]:slice(min(greenline_edc_energy,yellowline_edc_energy), max(greenline_edc_energy,yellowline_edc_energy))}}).sum(dim=data.dims[0]).plot(ax=ax)
+#plot MDC yellow and green
+fig,ax=plt.subplots(1,1,figsize=(12,8))
+data2D_plot.sel({{data.dims[1]:yellowline_mdc_momentum}}, method='nearest').plot(ax=ax,color='orange')
+data2D_plot.sel({{data.dims[1]:greenline_mdc_momentum}}, method='nearest').plot(ax=ax,color='green')
+#plot integrated MDC
+fig,ax=plt.subplots(1,1,figsize=(12,8))
+data2D_plot.sel({{data.dims[1]:slice(min(greenline_mdc_momentum,yellowline_mdc_momentum), max(greenline_mdc_momentum,yellowline_mdc_momentum))}}).sum(dim=data.dims[1]).plot(ax=ax)
+#plot integrated intensity in the box between the cursors
+fig,ax=plt.subplots(1,1,figsize=(12,8))
+x0,y0=({self.dot1.center[0]},{self.dot1.center[1]})
+x1,y1=({self.dot2.center[0]},{self.dot2.center[1]})
+x0, x1 = sorted([x0, x1])
+y0, y1 = sorted([y0, y1])
+data.loc[{{data.dims[0]: slice(y0, y1), data.dims[1]: slice(x0, x1)}}].sum(dim=(data.dims[0], data.dims[1])).plot(ax=ax)
+
+        """
+        shell = get_ipython()
+        payload = dict(
+            source='set_next_input',
+            text=content,
+            replace=False,
+        )
+        shell.payload_manager.write_payload(payload, single=False)
+        print('results extracted!')
     def save_results(self):#save the relevant results in a .pkl file which can be accessed easily for Jupyter Notebook workflow
+        print('res')
         results = {
             'integrated_edc': self.integrated_edc,
             'integrated_mdc': self.integrated_mdc,
-            'yellowline_edc': self.data_t.isel({self.data.dims[0]:self.square_coords[0][1]}),
-            'greenline_edc': self.data_t.isel({self.data.dims[0]:self.square_coords[1][1]}),
-            'yellowline_mdc': self.data_t.isel({self.data.dims[1]: int(self.square_coords[0][0])}),
-            'greenline_mdc': self.data_t.isel({self.data.dims[1]: int(self.square_coords[1][0])}),
-            'current_spectra': self.data_t,
+            'yellowline_edc': self.data2D_plot.sel({self.data.dims[0]:self.dot1.center[1]}, method='nearest'), 
+            'greenline_edc': self.data2D_plot.sel({self.data.dims[0]:self.dot2.center[1]}, method='nearest'),
+            'yellowline_mdc': self.data2D_plot.sel({self.data.dims[1]: self.dot1.center[0]}, method='nearest'),
+            'greenline_mdc': self.data2D_plot.sel({self.data.dims[1]: self.dot2.center[0]}, method='nearest'),
+            'current_spectra': self.data2D_plot,
             'intensity_box': self.int,
             'yellow_vertical': self.dot1.center[0],
             'yellow_horizontal': self.dot1.center[1],
@@ -229,11 +280,11 @@ def checkbox_k_changed(self, state): # Checkbox for integrating the MDC between
 
     
     def fit_energy_panel(self,event): # open up the fit panel for the EDC 
-        graph_window=fit_panel(self.data,self.square_coords[0][1], self.square_coords[1][1], self.t, self.dt, self.data.dims[1])
+        graph_window=fit_panel(self.data,self.dot1.center[1], self.dot2.center[1], self.t, self.dt, self.data.dims[1])
         graph_window.show()
         self.graph_windows.append(graph_window)
     def fit_momentum_panel(self,event): # open up the fit panel for the MDC
-        graph_window=fit_panel(self.data,self.square_coords[0][0], self.square_coords[1][0], self.t, self.dt, self.data.dims[0])
+        graph_window=fit_panel(self.data,self.dot1.center[0], self.dot2.center[0], self.t, self.dt, self.data.dims[0])
         graph_window.show()
         self.graph_windows.append(graph_window)
     def fit_box_panel(self,event): # open up the fit panel for the intensity box
@@ -246,27 +297,27 @@ def show_graphs(self, t, dt): # This is where the updates after changing the sli
     
         def integrate_E(): # integrate EDC between the two cursors in the main graph
             self.axs[1, 0].clear()
-            plt.draw()
-    
-            x_min = int(min(self.dot2.center[1], self.dot1.center[1]))
-            x_max = int(max(self.dot2.center[1], self.dot1.center[1])) + 1
+            # plt.draw()
     
-            # self.data_t.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0]).plot(ax=self.axs[1,0])
-            self.integrated_edc=self.data_t.sel({self.data.dims[0]:slice(x_min, x_max)}, method='nearest').sum(dim=self.data.dims[0])
+            x_min = min(self.dot2.center[1], self.dot1.center[1])
+            x_max = max(self.dot2.center[1], self.dot1.center[1])
+            
+            # self.data2D_plot.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0]).plot(ax=self.axs[1,0])
+            self.integrated_edc=self.data2D_plot.sel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
             self.integrated_edc.plot(ax=self.axs[1,0])
-            self.fig.canvas.draw()
+            self.fig.canvas.draw_idle()
     
         def integrate_k(): # integrate MDC between the two cursors in the main graph
             self.axs[0, 1].clear()
-            plt.draw()
-    
-            x_min = int(min(self.dot1.center[0], self.dot2.center[0]))
-            x_max = int(max(self.dot1.center[0], self.dot2.center[0])) + 1
+            # plt.draw()
     
-            # self.data_t.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1]).plot(ax=self.axs[0,1])
-            self.integrated_mdc=self.data_t.sel({self.data.dims[1]:slice(x_min, x_max)}, method='nearest').sum(dim=self.data.dims[1])
+            x_min = min(self.dot1.center[0], self.dot2.center[0])
+            x_max = max(self.dot1.center[0], self.dot2.center[0])
+            print (x_min, x_max)
+            # self.data2D_plot.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1]).plot(ax=self.axs[0,1])
+            self.integrated_mdc=self.data2D_plot.sel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
             self.integrated_mdc.plot(ax=self.axs[0,1])
-            self.fig.canvas.draw()
+            self.fig.canvas.draw_idle()
     
         def box(): # generate the intensity graph between the four cursors in the main graph
             self.axs[1, 1].clear()
@@ -277,11 +328,8 @@ def box(): # generate the intensity graph between the four cursors in the main g
             # Ensure (x0, y0) is the top-left corner and (x1, y1) is the bottom-right
             x0, x1 = sorted([x0, x1])
             y0, y1 = sorted([y0, y1])
-            
-            print (x0,x1,y0,y1)
     
             self.int = self.data.loc[{self.data.dims[0]: slice(y0, y1), self.data.dims[1]: slice(x0, x1)}].sum(dim=(self.data.dims[0], self.data.dims[1]))
-            print (self.int)
             if x0 != x1 and y0 != y1:
                 
                 self.int.plot(ax=self.axs[1,1])
@@ -292,38 +340,38 @@ def update_show(t, dt): # update the main graph as well as the relevant EDC and
             self.axs[0, 1].clear()
             self.axs[1, 0].clear()
             #update the main graph/ spectra
-            self.data_t=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
-            im.set_array(self.data_t)
+            self.data2D_plot=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
+            im.set_array(self.data2D_plot)
             # show the cuts for the EDC and MDC
             if self.checkbox_e.isChecked() and self.checkbox_k.isChecked():
                 integrate_E()
                 integrate_k()
             elif self.checkbox_e.isChecked():
                 integrate_E()
-                self.data_t.sel({self.data.dims[1]:self.dot1.center[0]}, method='nearest').plot(ax=self.axs[0, 1], color='orange')
-                self.data_t.sel({self.data.dims[1]:self.dot2.center[0]}, method='nearest').plot(ax=self.axs[0, 1], color='green')
+                self.data2D_plot.sel({self.data.dims[1]:self.dot1.center[0]}, method='nearest').plot(ax=self.axs[0, 1], color='orange')
+                self.data2D_plot.sel({self.data.dims[1]:self.dot2.center[0]}, method='nearest').plot(ax=self.axs[0, 1], color='green')
                 
             elif self.checkbox_k.isChecked():
                 integrate_k()
-                self.data_t.sel({self.data.dims[0]:self.dot1.center[1]}, method='nearest').plot(ax=self.axs[1, 0], color='orange')
-                self.data_t.sel({self.data.dims[0]:self.dot2.center[1]}, method='nearest').plot(ax=self.axs[1, 0], color='green')
+                self.data2D_plot.sel({self.data.dims[0]:self.dot1.center[1]}, method='nearest').plot(ax=self.axs[1, 0], color='orange')
+                self.data2D_plot.sel({self.data.dims[0]:self.dot2.center[1]}, method='nearest').plot(ax=self.axs[1, 0], color='green')
                 
             else: 
-                self.data_t.sel({self.data.dims[0]:self.dot1.center[1]}, method='nearest').plot(ax=self.axs[1,0],color='orange')
-                self.data_t.sel({self.data.dims[0]:self.dot2.center[1]}, method='nearest').plot(ax=self.axs[1,0],color='green')
-                self.data_t.sel({self.data.dims[1]:self.dot1.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='orange')
-                self.data_t.sel({self.data.dims[1]:self.dot2.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='green')
+                self.data2D_plot.sel({self.data.dims[0]:self.dot1.center[1]}, method='nearest').plot(ax=self.axs[1,0],color='orange')
+                self.data2D_plot.sel({self.data.dims[0]:self.dot2.center[1]}, method='nearest').plot(ax=self.axs[1,0],color='green')
+                self.data2D_plot.sel({self.data.dims[1]:self.dot1.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='orange')
+                self.data2D_plot.sel({self.data.dims[1]:self.dot2.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='green')
 
             
             box() # update the intensity box graph
             time1 = self.axis[2][t]
             timedt1 = self.axis[2][t + dt]
             self.axs[0, 0].set_title(f't: {time1:.2f}, t+dt: {timedt1:.2f}')
-            self.fig.canvas.draw()
+            self.fig.canvas.draw_idle()
             plt.draw()
         
         # plot the main graph
-        im = self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2]).plot(ax=self.axs[0, 0], cmap='terrain', add_colorbar=False)
+        im = self.data2D_plot.plot(ax=self.axs[0, 0], cmap='terrain', add_colorbar=False)
         
         # define the initial positions of the cursors in the main graph
         
@@ -367,16 +415,16 @@ def update_show(t, dt): # update the main graph as well as the relevant EDC and
         # self.change_pixel_to_arrayslot()
         
         # define the integrated EDC and MDC 
-        x_min = int(min(self.dot2.center[1], self.dot1.center[1]))
-        x_max = int(max(self.dot2.center[1], self.dot1.center[1])) + 1
-        self.integrated_edc=self.data_t.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
-        x_min = int(min(self.dot1.center[0], self.dot2.center[0]))
-        x_max = int(max(self.dot1.center[0], self.dot2.center[0])) + 1
-        self.integrated_mdc=self.data_t.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
+        x_min = min(self.dot2.center[1], self.dot1.center[1])
+        x_max = max(self.dot2.center[1], self.dot1.center[1])
+        self.integrated_edc=self.data2D_plot.sel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
+        x_min = min(self.dot1.center[0], self.dot2.center[0])
+        x_max = max(self.dot1.center[0], self.dot2.center[0])
+        self.integrated_mdc=self.data2D_plot.sel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
 
         plt.draw()
         update_show(self.slider1.value(),self.slider2.value()) 
-        self.fig.canvas.draw()
+        self.fig.canvas.draw_idle()
         self.active_cursor = None
         def on_pick(event): # function to pick up the cursors or the dots
             if event.artist == self.cursor_vert1:
@@ -434,7 +482,7 @@ def on_motion(event): # function to move the cursors or the dots
                     self.cursor_label[2].setText(f"{base}: {event.xdata:.2f}")
                     base = self.cursor_label[3].text().split(':')[0]
                     self.cursor_label[3].setText(f"{base}: {event.ydata:.2f}")
-                self.fig.canvas.draw()
+                self.fig.canvas.draw_idle()
                 plt.draw()
                 
                 # self.change_pixel_to_arrayslot()
diff --git a/src/mpes_tools/fit_panel.py b/src/mpes_tools/fit_panel.py
index 2fe0f03..b76bf07 100644
--- a/src/mpes_tools/fit_panel.py
+++ b/src/mpes_tools/fit_panel.py
@@ -239,16 +239,16 @@ def zero(x):
         self.t0_state = False
         self.offset_state = False
         self.data=data
-        x_min = int(min(c1, c2))
-        x_max = int(max(c1, c2)) + 1
+        x_min = min(c1, c2)
+        x_max = max(c1, c2)
         # print('xmin=',x_min,'xmax=',x_max)
         if panel =='box':
             self.y=data
         elif panel == data.dims[1]:
-            self.data_t=data.isel({data.dims[0]:slice(x_min, x_max)}).sum(dim=data.dims[0])
+            self.data_t=data.sel({data.dims[0]:slice(x_min, x_max)}).sum(dim=data.dims[0])
             self.dim=data.dims[1]
         elif panel ==data.dims[0]:
-            self.data_t=data.isel({data.dims[1]:slice(x_min, x_max)}).sum(dim=data.dims[1])
+            self.data_t=data.sel({data.dims[1]:slice(x_min, x_max)}).sum(dim=data.dims[1])
             self.dim=data.dims[0]
         self.panel=panel
         self.t=t
diff --git a/src/mpes_tools/graphs.py b/src/mpes_tools/graphs.py
index 7dcccd2..27a1196 100644
--- a/src/mpes_tools/graphs.py
+++ b/src/mpes_tools/graphs.py
@@ -83,8 +83,6 @@ def show_plot(self, y, index, name):
         plt.show()  # Show the figure in a new window
     def update_parameter(self, value):
         base = self.slider_label.text().split(':')[0]
-        print("self.x:", self.x)
-        print("Slider value:", value)
         self.slider_label.setText(f"{base}: {self.x[value]:.2f}")
         self.axis.clear()
         
diff --git a/src/mpes_tools/show_4d_window.py b/src/mpes_tools/show_4d_window.py
index 029c822..456148d 100644
--- a/src/mpes_tools/show_4d_window.py
+++ b/src/mpes_tools/show_4d_window.py
@@ -229,11 +229,11 @@ def update_energy(self,Energy,dE,te,dte):
         ax.set_title(f'energy: {E1:.2f}, E+dE: {E2:.2f} , t: {te1:.2f}, t+dt: {te2:.2f}')
         
         self.ev = ax.axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
-        self.eh = ax.axhline(y=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
+        self.eh = ax.axhline(y=self.data_array.coords[self.axes[1]][self.slider1[1].value()].item(), color='r', linestyle='--')
         self.pxv = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
         self.pyh = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
         self.graphs[0].tight_layout()
-        self.graphs[0].canvas.draw()
+        self.graphs[0].canvas.draw_idle()
         
     def update_ky(self,ypos,dy,ty,dty):
         
@@ -249,7 +249,7 @@ def update_ky(self,ypos,dy,ty,dty):
         self.yh = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
 
         self.graphs[1].tight_layout()
-        self.graphs[1].canvas.draw()
+        self.graphs[1].canvas.draw_idle()
         
         
     def update_kx(self,xpos,dx,tx,dtx):
@@ -265,7 +265,7 @@ def update_kx(self,xpos,dx,tx,dtx):
         self.xh = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
         
         self.graphs[2].tight_layout()
-        self.graphs[2].canvas.draw()
+        self.graphs[2].canvas.draw_idle()
     
     
     def update_dt(self,yt,xt,dyt,dxt):
@@ -280,7 +280,7 @@ def update_dt(self,yt,xt,dyt,dxt):
         ax.set_title(f'ky: {yt1:.2f}, ky+dky: {yt2:.2f} , kx: {xt1:.2f}, kx+dkx: {xt2:.2f}')
         self.ph = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
         self.graphs[3].tight_layout()
-        self.graphs[3].canvas.draw()
+        self.graphs[3].canvas.draw_idle()
         
 
     def slider_changed(self, value):
@@ -303,9 +303,9 @@ def slider_changed(self, value):
             self.yh = self.graphs[1].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
             self.ph = self.graphs[3].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
             # self.graphs[2].tight_layout()
-            self.graphs[2].canvas.draw()
-            self.graphs[1].canvas.draw()
-            self.graphs[3].canvas.draw()
+            self.graphs[2].canvas.draw_idle()
+            self.graphs[1].canvas.draw_idle()
+            self.graphs[3].canvas.draw_idle()
             self.update_energy(self.slider1[0].value(),self.slider2[0].value(),self.slider3[0].value(), self.slider4[0].value())
             
         elif index in range(4,8):
@@ -313,14 +313,14 @@ def slider_changed(self, value):
                 self.eh.remove()
            
             self.eh = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider1[1].value()].item(), color='r', linestyle='--')
-            self.graphs[0].canvas.draw()
+            self.graphs[0].canvas.draw_idle()
             self.update_ky(self.slider1[1].value(), self.slider2[1].value(),self.slider3[1].value(), self.slider4[1].value())
         elif index in range (8,12):
             ax = self.graphs[0].gca()
             if self.ev in ax.lines:
                 self.ev.remove()
             self.ev = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
-            self.graphs[0].canvas.draw()
+            self.graphs[0].canvas.draw_idle()
             self.update_kx(self.slider1[2].value(), self.slider2[2].value(),self.slider3[2].value(), self.slider4[2].value())
         elif index in range (12,16):
             if self.pxv in self.graphs[0].gca().lines:
@@ -331,7 +331,7 @@ def slider_changed(self, value):
             # self.pyh = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
             self.pyh = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
             self.pxv = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
-            self.graphs[0].canvas.draw()
+            self.graphs[0].canvas.draw_idle()
             self.update_dt(self.slider1[3].value(), self.slider3[3].value(), self.slider2[3].value(), self.slider4[3].value())
 
         

From ab5c98a65be930082632be5e07a0dc463e5bdaf5 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 15 Apr 2025 19:31:32 +0200
Subject: [PATCH 11/67] Created a method for double clicking on the graph and
 relate it to a function (to extract the data of the graph)

---
 src/mpes_tools/double_click_handler.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 src/mpes_tools/double_click_handler.py

diff --git a/src/mpes_tools/double_click_handler.py b/src/mpes_tools/double_click_handler.py
new file mode 100644
index 0000000..f187dca
--- /dev/null
+++ b/src/mpes_tools/double_click_handler.py
@@ -0,0 +1,12 @@
+class SubplotClickHandler:
+    def __init__(self, ax, on_subplot_click=None):
+        self.ax = ax
+        self.on_subplot_click = on_subplot_click
+
+    def handle_double_click(self, event):
+        # print(f"event.inaxes id: {id(event.inaxes)}, self.ax id: {id(self.ax)}")
+        if not event.dblclick or event.inaxes != self.ax:
+            return
+        # self.ax.set_title("Clicked", color='red')
+        if self.on_subplot_click:
+            self.on_subplot_click(self.ax)

From e32c1f5033cefa7cf57881d77e5808ec1a066ca5 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 15 Apr 2025 19:32:17 +0200
Subject: [PATCH 12/67] added the new clicking feature to Gui_3d

---
 src/mpes_tools/Gui_3d.py | 70 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 67 insertions(+), 3 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index c053588..6e650fb 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -10,7 +10,7 @@
 import pickle
 from mpes_tools.fit_panel import fit_panel
 from IPython.core.getipython import get_ipython
-
+from mpes_tools.double_click_handler import SubplotClickHandler
 import xarray as xr
 
 #graphic window showing a 2d map controllable with sliders for the third dimension, with cursors showing cuts along the x direction for MDC and y direction for EDC
@@ -31,7 +31,14 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         
         
         self.fig, self.axs = plt.subplots(2,2,figsize=(20,16))
+        plt.close(self.fig)
         self.canvas = FigureCanvas(self.fig)
+        self.click_handlers = []
+            
+        for idx, ax in enumerate(self.axs.flatten()):
+            handler = SubplotClickHandler(ax, self.external_callback)
+            ax.figure.canvas.mpl_connect("button_press_event", handler.handle_double_click)
+            self.click_handlers.append(handler)
         # plt.ioff()
         # add the checkboxes for EDC and MDC integration and the button to save the results
         self.checkbox_e = QCheckBox("Integrate_energy")
@@ -147,7 +154,64 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         self.graph_windows=[]
         
         print(data_array.dims)
+    def external_callback(self,ax):
+        # print(f"External callback: clicked subplot ({i},{j})")
+        if ax==self.axs[0,0]:
+            content= f"""
+data='your data_array'
+data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)
+#the 2D plot data
+data2D_plot=data.isel({{data.dims[2]:slice({self.slider1.value()}, {self.slider1.value()+self.slider2.value()+1})}}).sum(dim=data.dims[2])   
+
+            """
+        elif ax==self.axs[1,0]:
+            content= f"""
+data='your data_array'
+data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)
+#the 2D plot data
+data2D_plot=data.isel({{data.dims[2]:slice({self.slider1.value()}, {self.slider1.value()+self.slider2.value()+1})}}).sum(dim=data.dims[2])   
+# The yellow EDC
+data2D_plot.sel({{data.dims[0]:{self.dot1.center[1]}}}, method='nearest')
+# The green EDC
+data2D_plot.sel({{data.dims[0]:{self.dot2.center[1]}}}, method='nearest')
+# the integrated EDC
+data2D_plot.sel({{data.dims[0]:slice(min({self.dot2.center[1]},{self.dot1.center[1]}), max({self.dot2.center[1]},{self.dot1.center[1]}))}}).sum(dim=data.dims[0])
 
+            """
+        elif ax==self.axs[0,1]:
+            content= f"""
+data='your data_array'
+data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)
+#the 2D plot data
+data2D_plot=data.isel({{data.dims[2]:slice({self.slider1.value()}, {self.slider1.value()+self.slider2.value()+1})}}).sum(dim=data.dims[2])   
+# The yellow MDC
+data2D_plot.sel({{data.dims[1]:{self.dot1.center[0]}}}, method='nearest')
+# The green MDC
+data2D_plot.sel({{data.dims[1]:{self.dot2.center[0]}}}, method='nearest')
+# the integrated MDC
+data2D_plot.sel({{data.dims[1]:slice(min({self.dot2.center[0]},{self.dot1.center[0]}), max({self.dot2.center[0]},{self.dot1.center[0]}))}}).sum(dim=data.dims[1])
+
+            """
+        elif ax==self.axs[1,1]:
+            content= f"""
+data='your data_array'
+data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)
+#the intensity box data
+data.loc[{{data.dims[0]: slice(*sorted([{self.dot1.center[1]}, {self.dot2.center[1]}])), 
+           data.dims[1]: slice(*sorted([{self.dot1.center[0]}, {self.dot2.center[0]}]))}}].sum(dim=(data.dims[0], data.dims[1]))
+
+            """
+        shell = get_ipython()
+        payload = dict(
+            source='set_next_input',
+            text=content,
+            replace=False,
+        )
+        shell.payload_manager.write_payload(payload, single=False)
+        # shell.run_cell("%gui qt")
+        QApplication.processEvents()
+        print('results extracted!')
+        
     def create_new_cell(self):
         content = f"""
 # Code generated by GUI for the following parameters:
@@ -198,9 +262,9 @@ def create_new_cell(self):
             replace=False,
         )
         shell.payload_manager.write_payload(payload, single=False)
+        shell.run_cell('pass')
         print('results extracted!')
     def save_results(self):#save the relevant results in a .pkl file which can be accessed easily for Jupyter Notebook workflow
-        print('res')
         results = {
             'integrated_edc': self.integrated_edc,
             'integrated_mdc': self.integrated_mdc,
@@ -313,7 +377,7 @@ def integrate_k(): # integrate MDC between the two cursors in the main graph
     
             x_min = min(self.dot1.center[0], self.dot2.center[0])
             x_max = max(self.dot1.center[0], self.dot2.center[0])
-            print (x_min, x_max)
+
             # self.data2D_plot.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1]).plot(ax=self.axs[0,1])
             self.integrated_mdc=self.data2D_plot.sel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
             self.integrated_mdc.plot(ax=self.axs[0,1])

From 35a867cc9b114fa2920d49d40d248d5a2ae26f8e Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 15 Apr 2025 19:32:44 +0200
Subject: [PATCH 13/67] added the new clicking feature to show_window_4d

---
 src/mpes_tools/show_4d_window.py | 146 ++++++++++++++++++++++++++-----
 1 file changed, 122 insertions(+), 24 deletions(-)

diff --git a/src/mpes_tools/show_4d_window.py b/src/mpes_tools/show_4d_window.py
index 456148d..7b50b30 100644
--- a/src/mpes_tools/show_4d_window.py
+++ b/src/mpes_tools/show_4d_window.py
@@ -8,7 +8,8 @@
 from mpes_tools.Gui_3d import Gui_3d
 import xarray as xr
 from mpes_tools.hdf5 import load_h5
-
+from IPython.core.getipython import get_ipython
+from mpes_tools.double_click_handler import SubplotClickHandler
 
 class show_4d_window(QMainWindow):
     def __init__(self,data_array: xr.DataArray):
@@ -20,11 +21,10 @@ def __init__(self,data_array: xr.DataArray):
         # Create a central widget for the graph and slider
         central_widget = QWidget()
         self.setCentralWidget(central_widget)
-
+        
         # Create a layout for the central widget
         layout = QGridLayout()
         central_widget.setLayout(layout)
-
         # Create four graphs and sliders
         self.graphs = []
         self.slider1 = []
@@ -33,9 +33,10 @@ def __init__(self,data_array: xr.DataArray):
         self.slider4 = []
         self.sliders = []
         self.slider_labels = []
-
+        self.canvases = []
+        self.click_handlers=[]
+        self.axis_list=[]
         plt.ioff()
-
         for i in range(2):
             for j in range(2):
                 graph_window = QWidget()
@@ -43,10 +44,17 @@ def __init__(self,data_array: xr.DataArray):
                 graph_window.setLayout(graph_layout)
 
                 # Create a figure and canvas for the graph
-                figure, axis = plt.subplots(figsize=(20, 20))
+                figure, axis = plt.subplots(figsize=(10, 10))
+                plt.close(figure)
                 canvas = FigureCanvas(figure)
+                handler = SubplotClickHandler(axis, self.external_callback)
+                canvas.mpl_connect("button_press_event", handler.handle_double_click)
+                self.click_handlers.append(handler)
                 graph_layout.addWidget(canvas)
-
+                self.axis_list.append(axis)
+                self.canvases.append(canvas)
+                
+                
                 slider_layout= QHBoxLayout()
                 slider_layout_2= QHBoxLayout()
                 # Create a slider widget
@@ -102,6 +110,7 @@ def __init__(self,data_array: xr.DataArray):
                 self.slider4.append(slider4)
                 self.sliders.extend([slider1, slider2,slider3, slider4])
                 self.slider_labels.extend([slider1_label, slider2_label,slider3_label, slider4_label])
+
         for slider in self.slider1:   
             slider.valueChanged.connect(self.slider_changed)
         for slider in self.slider2:   
@@ -143,6 +152,97 @@ def __init__(self,data_array: xr.DataArray):
         self.show()
         self.load_data(data_array)
 
+    def closeEvent(self, event):
+        # Remove references to graphs and canvases to prevent lingering objects
+        self.graphs = []
+        self.canvases = []
+        self.axis_list = []
+        
+        # Update window state
+        self.window_open = False
+        event.accept()
+
+    def external_callback(self, ax):
+        # print(f"External callback: clicked subplot ({i},{j})")
+        if ax==self.graphs[0].gca():
+            content= f"""
+data='your data_array'
+#the energy plot
+data.loc[
+    {{
+        '{self.axes[2]}': slice(
+            {self.data_array[self.axes[2]][self.slider1[0].value()].item()},
+            {self.data_array[self.axes[2]][self.slider1[0].value() + self.slider2[0].value()].item()}
+        ),
+        '{self.axes[3]}': slice(
+            {self.data_array[self.axes[3]][self.slider3[0].value()].item()},
+            {self.data_array[self.axes[3]][self.slider3[0].value() + self.slider4[0].value()].item()}
+        )
+    }}
+].mean(dim=('{self.axes[2]}', '{self.axes[3]}')).T
+
+            """
+        elif ax==self.graphs[1].gca():
+            content= f"""
+data='your data_array'
+#the ky plot
+data.loc[
+    {{
+        '{self.axes[1]}': slice(
+            {self.data_array[self.axes[1]][self.slider1[1].value()].item()},
+            {self.data_array[self.axes[1]][self.slider1[1].value() + self.slider2[1].value()].item()}
+        ),
+        '{self.axes[3]}': slice(
+            {self.data_array[self.axes[3]][self.slider3[1].value()].item()},
+            {self.data_array[self.axes[3]][self.slider3[1].value() + self.slider4[1].value()].item()}
+        )
+    }}
+].mean(dim=('{self.axes[1]}', '{self.axes[3]}')).T
+            """
+        elif ax==self.axis_list[2]:
+            content= f"""
+data='your data_array'
+#the kx plot
+data.loc[
+    {{
+        '{self.axes[0]}': slice(
+            {self.data_array[self.axes[0]][self.slider1[2].value()].item()},
+            {self.data_array[self.axes[0]][self.slider1[2].value() + self.slider2[2].value()].item()}
+        ),
+        '{self.axes[3]}': slice(
+            {self.data_array[self.axes[3]][self.slider3[2].value()].item()},
+            {self.data_array[self.axes[3]][self.slider3[2].value() + self.slider4[2].value()].item()}
+        )
+    }}
+].mean(dim=('{self.axes[0]}', '{self.axes[3]}')).T
+            """
+        elif ax==self.axis_list[3]:
+            content= f"""
+data='your data_array'
+#the kx,ky plot
+data.loc[
+    {{
+        '{self.axes[1]}': slice(
+            {self.data_array[self.axes[1]][self.slider1[3].value()].item()},
+            {self.data_array[self.axes[1]][self.slider1[3].value() + self.slider2[3].value()].item()}
+        ),
+        '{self.axes[0]}': slice(
+            {self.data_array[self.axes[0]][self.slider3[3].value()].item()},
+            {self.data_array[self.axes[0]][self.slider3[3].value()+ self.slider4[3].value()].item()}
+        )
+    }}
+].mean(dim=('{self.axes[1]}', '{self.axes[0]}'))
+            """
+        shell = get_ipython()
+        payload = dict(
+            source='set_next_input',
+            text=content,
+            replace=False,
+        )
+        shell.payload_manager.write_payload(payload, single=False)
+        shell.run_cell('pass')
+        print('results extracted!')
+
     def open_graph_kxkydt(self):
         E1=self.data_array[self.axes[2]][self.slider1[0].value()].item()
         E2=self.data_array[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()+1].item()
@@ -206,13 +306,14 @@ def load_data(self, data_array: xr.DataArray):
         self.slider_labels[15].setText("Δ"+self.axes[0])
         
         
-        self.update_energy(self.slider1[0].value(),self.slider2[0].value() , self.slider1[1].value(), self.slider2[1].value())
+        self.update_energy(self.slider1[0].value(),self.slider2[0].value(),self.slider3[0].value(), self.slider4[0].value())
 
-        self.update_ky(self.slider1[2].value(), self.slider2[2].value(), self.slider3[0].value(), self.slider4[0].value())
+        self.update_ky(self.slider1[1].value(), self.slider2[1].value(),self.slider3[1].value(), self.slider4[1].value())
     
-        self.update_kx(self.slider3[1].value(), self.slider4[1].value(), self.slider3[2].value(), self.slider4[2].value())
+        self.update_kx(self.slider1[2].value(), self.slider2[2].value(),self.slider3[2].value(), self.slider4[2].value())
         
-        self.update_dt(self.slider1[3].value(), self.slider3[3].value(), self.slider2[3].value(), self.slider4[3].value())
+        self.update_dt(self.slider1[3].value(), self.slider2[3].value(), self.slider3[3].value(), self.slider4[3].value())
+    
     
     def update_energy(self,Energy,dE,te,dte):
         self.ce_state=True
@@ -221,11 +322,10 @@ def update_energy(self,Energy,dE,te,dte):
         te1=self.data_array[self.axes[3]][te].item()
         te2=self.data_array[self.axes[3]][te+dte].item()
 
-        self.graphs[0].clear()
         ax=self.graphs[0].gca()
-
+        ax.cla() 
         data_avg=self.data_array.loc[{self.axes[2]:slice(E1,E2), self.axes[3]:slice(te1,te2)}].mean(dim=(self.axes[2], self.axes[3]))
-        self.im=data_avg.T.plot(ax=ax,cmap='terrain')
+        self.im=data_avg.T.plot(ax=ax,cmap='terrain', add_colorbar=False)
         ax.set_title(f'energy: {E1:.2f}, E+dE: {E2:.2f} , t: {te1:.2f}, t+dt: {te2:.2f}')
         
         self.ev = ax.axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
@@ -242,9 +342,9 @@ def update_ky(self,ypos,dy,ty,dty):
         ty1=self.data_array[self.axes[3]][ty].item()
         ty2=self.data_array[self.axes[3]][ty+dty].item()
         
-        self.graphs[1].clear()
         ax=self.graphs[1].gca()
-        self.data_array.loc[{self.axes[1]:slice(y1,y2), self.axes[3]:slice(ty1,ty2)}].mean(dim=(self.axes[1], self.axes[3])).T.plot(ax=ax,cmap='terrain')
+        ax.cla() 
+        self.data_array.loc[{self.axes[1]:slice(y1,y2), self.axes[3]:slice(ty1,ty2)}].mean(dim=(self.axes[1], self.axes[3])).T.plot(ax=ax,cmap='terrain', add_colorbar=False)
         ax.set_title(f'ky: {y1:.2f}, ky+dky: {y2:.2f} , t: {ty1:.2f}, t+dt: {ty2:.2f}')
         self.yh = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
 
@@ -258,9 +358,9 @@ def update_kx(self,xpos,dx,tx,dtx):
         tx1=self.data_array[self.axes[3]][tx].item()
         tx2=self.data_array[self.axes[3]][tx+dtx].item()
         
-        self.graphs[2].clear()
         ax=self.graphs[2].gca()
-        self.data_array.loc[{self.axes[0]:slice(x1,x2), self.axes[3]:slice(tx1,tx2)}].mean(dim=(self.axes[0], self.axes[3])).T.plot(ax=ax,cmap='terrain')
+        ax.cla() 
+        self.data_array.loc[{self.axes[0]:slice(x1,x2), self.axes[3]:slice(tx1,tx2)}].mean(dim=(self.axes[0], self.axes[3])).T.plot(ax=ax,cmap='terrain', add_colorbar=False)
         ax.set_title(f'kx: {x1:.2f}, kx+dkx: {x2:.2f} , t: {tx1:.2f}, t+dt: {tx2:.2f}')
         self.xh = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
         
@@ -268,15 +368,15 @@ def update_kx(self,xpos,dx,tx,dtx):
         self.graphs[2].canvas.draw_idle()
     
     
-    def update_dt(self,yt,xt,dyt,dxt):
+    def update_dt(self,yt,dyt,xt,dxt):
         yt1=self.data_array[self.axes[1]][yt].item()
         yt2=self.data_array[self.axes[1]][yt+dyt].item()
         xt1=self.data_array[self.axes[0]][xt].item()
         xt2=self.data_array[self.axes[0]][xt+dxt].item()
         
-        self.graphs[3].clear()
         ax=self.graphs[3].gca()
-        self.data_array.loc[{self.axes[1]:slice(yt1,yt2), self.axes[0]:slice(xt1,xt2)}].mean(dim=(self.axes[1], self.axes[0])).plot(ax=ax,cmap='terrain')
+        ax.cla() 
+        self.data_array.loc[{self.axes[1]:slice(yt1,yt2), self.axes[0]:slice(xt1,xt2)}].mean(dim=(self.axes[1], self.axes[0])).plot(ax=ax,cmap='terrain', add_colorbar=False)
         ax.set_title(f'ky: {yt1:.2f}, ky+dky: {yt2:.2f} , kx: {xt1:.2f}, kx+dkx: {xt2:.2f}')
         self.ph = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
         self.graphs[3].tight_layout()
@@ -327,12 +427,10 @@ def slider_changed(self, value):
                 self.pxv.remove()
             if self.pyh in self.graphs[0].gca().lines:
                 self.pyh.remove()
-            # self.pxv = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
-            # self.pyh = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
             self.pyh = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
             self.pxv = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
             self.graphs[0].canvas.draw_idle()
-            self.update_dt(self.slider1[3].value(), self.slider3[3].value(), self.slider2[3].value(), self.slider4[3].value())
+            self.update_dt(self.slider1[3].value(), self.slider2[3].value(), self.slider3[3].value(), self.slider4[3].value())
 
         
 if __name__ == "__main__":

From f66ca0674d05670f05ddc0c091a956e7045ffd71 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 15 Apr 2025 19:36:54 +0200
Subject: [PATCH 14/67] basically no modification here

---
 src/mpes_tools/fit_panel.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/mpes_tools/fit_panel.py b/src/mpes_tools/fit_panel.py
index b76bf07..50b5be0 100644
--- a/src/mpes_tools/fit_panel.py
+++ b/src/mpes_tools/fit_panel.py
@@ -17,6 +17,7 @@
 
 
 
+
 class fit_panel(QMainWindow):
     def __init__(self,data,c1,c2,t,dt,panel):
         super().__init__()

From 4eef8ddbff4c66887496628bb1377ec1921b7a50 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 15 Apr 2025 19:37:46 +0200
Subject: [PATCH 15/67] added the new clicking feature to graphs

---
 src/mpes_tools/graphs.py | 86 ++++++++++++++++++++++++++++++++++------
 1 file changed, 73 insertions(+), 13 deletions(-)

diff --git a/src/mpes_tools/graphs.py b/src/mpes_tools/graphs.py
index 27a1196..214cc06 100644
--- a/src/mpes_tools/graphs.py
+++ b/src/mpes_tools/graphs.py
@@ -3,7 +3,10 @@
 from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QPushButton, QGridLayout,QSlider,QLabel
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 import matplotlib.pyplot as plt
-
+from IPython.core.getipython import get_ipython
+from mpes_tools.double_click_handler import SubplotClickHandler
+from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
+import xarray as xr
 class showgraphs(QMainWindow):
     def __init__(self, x, y_arrays,names,list_axis,list_plot_fits):
         super().__init__()
@@ -15,13 +18,13 @@ def __init__(self, x, y_arrays,names,list_axis,list_plot_fits):
         self.x = x.data
         self.y_arrays = y_arrays
         self.num_plots = len(y_arrays)
-        self.list_plot_fits=list_plot_fits
+        self.list_plot_fits=list_plot_fits 
         self.list_axis=list_axis
         # Create a central widget and layout
         central_widget = QWidget(self)
         self.setCentralWidget(central_widget)
         layout = QGridLayout(central_widget)
-        
+        print('boo')
         
         # print(len(x),len(list_plot_fits))
         # print(list_plot_fits[0])
@@ -36,7 +39,7 @@ def __init__(self, x, y_arrays,names,list_axis,list_plot_fits):
         
         self.figure, self.axis = plt.subplots()
         self.canvas = FigureCanvas(self.figure)
-        
+        plt.close(self.figure)
         vbox = QVBoxLayout()
         vbox.addWidget(self.canvas)
         vbox.addWidget(self.slider_label)
@@ -44,33 +47,90 @@ def __init__(self, x, y_arrays,names,list_axis,list_plot_fits):
         
         layout.addLayout(vbox, 0, 0)  # Place in top-left
         self.update_parameter(0)
+        self.click_handlers=[]
+        self.ax_list=[]
+        self.data_list=[]
         # Create and add buttons and plots for each y array in a 3x3 layout
         for i, y in enumerate(y_arrays):
             # Create a button to show the plot in a new window
             button = QPushButton(f"Show Plot {i+1}")
             button.setFixedSize(80, 30)  # Set a fixed size for the button
             button.clicked.connect(lambda checked, y=y, index=i+1: self.show_plot(y, index, names[i]))
-
+            data_array = xr.DataArray(
+                data=y,
+                dims=[self.dim],                # e.g., 'energy', 'time', etc.
+                coords={self.dim: self.x},
+                name=names[i]                      # Optional: give it a name (like the plot title)
+            )
+            self.data_list.append(data_array)
             # Calculate grid position
             row = ((i+1) // 3) * 2   # Each function will take 2 rows: one for the plot, one for the button
             col = (i+1) % 3
-
+            widget,canvas,ax=self.create_plot_widget(data_array, f"Plot {i+1}_"+names[i])
             # Add the plot canvas to the grid
-            layout.addWidget(self.create_plot_widget(y, f"Plot {i+1}_"+names[i]), row, col)  # Plot in a 3x3 grid
+            
+            layout.addWidget(widget, row, col)  # Plot in a 3x3 grid
+            # layout.addWidget(self.create_plot_widget(y, f"Plot {i+1}_"+names[i]), row, col)  # Plot in a 3x3 grid
             layout.addWidget(button, row + 1, col)  # Button directly below the corresponding plot
+            handler = SubplotClickHandler(ax, self.external_callback)
+            canvas.mpl_connect("button_press_event", handler.handle_double_click)
+            self.click_handlers.append(handler)
+            self.ax_list.append(ax)
+            print('in the main code'+f"self.ax id: {id(ax)}")
+    def external_callback(self,ax):
+        # print(f"External callback: clicked subplot ({i},{j})")
+        for i, ax_item in enumerate(self.ax_list):
+            if ax == ax_item:
+                data = self.data_list[i]
+                coords = {k: data.coords[k].values.tolist() for k in data.coords}
+                dims = data.dims
+                name = data.name if data.name else f"data_{i}"
+                content = f"""
+import xarray as xr
+import numpy as np
+
+data_array = xr.DataArray(
+    data=np.array({data.values.tolist()}),
+    dims={dims},
+    coords={coords},
+    name="{name}"
+)
+"""
+                break
+        shell = get_ipython()
+        payload = dict(
+            source='set_next_input',
+            text=content,
+            replace=False,
+        )
+        shell.payload_manager.write_payload(payload, single=False)
+        # shell.run_cell("%gui qt")
+        QApplication.processEvents()
+        print('results extracted!')
         
-    def create_plot_widget(self, y, title):
+    def create_plot_widget(self, data_array, title):
         """Creates a plot widget for displaying a function."""
+        
         figure, ax = plt.subplots()
-        ax.plot(self.x, y)
+        plt.close(figure)
+        data_array.plot(ax=ax)
         ax.set_title(title)
-        ax.grid(True)
-        ax.set_xlabel(self.dim)
+        # ax.grid(True)
+        # ax.set_xlabel(self.dim)
         # ax.set_ylabel('y')
-
+        print('create_plot'+f"self.ax id: {id(ax)}")
         # Create a FigureCanvas to embed in the Qt layout
         canvas = FigureCanvas(figure)
-        return canvas  # Return the canvas so it can be used in the layout
+        toolbar = NavigationToolbar(canvas, self)
+
+        # Wrap canvas and toolbar in a widget with a layout
+        widget = QWidget()
+        layout = QVBoxLayout()
+        widget.setLayout(layout)
+    
+        layout.addWidget(toolbar)
+        layout.addWidget(canvas)
+        return widget,canvas,ax  # Return the canvas so it can be used in the layout
 
     def show_plot(self, y, index, name):
         """Show the plot in a new window."""

From 2bc526533e50a3d79c90a5194764af5ce6bd2819 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 15 Apr 2025 19:42:19 +0200
Subject: [PATCH 16/67] added a template file for Jupyter Notebook

---
 tutorials/template.ipynb | 340 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 340 insertions(+)
 create mode 100644 tutorials/template.ipynb

diff --git a/tutorials/template.ipynb b/tutorials/template.ipynb
new file mode 100644
index 0000000..1dca783
--- /dev/null
+++ b/tutorials/template.ipynb
@@ -0,0 +1,340 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6d2e0046",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import the 4D data\n",
+    "import numpy as np\n",
+    "from mpes_tools.hdf5 import load_h5\n",
+    "\n",
+    "data_array= load_h5('//nap33/wahada/Scan130_scan130_Amine_100x100x300x50.h5')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5aeb6fe2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "results extracted!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use the 4D Gui\n",
+    "from mpes_tools.show_4d_window import show_4d_window\n",
+    "%gui qt\n",
+    "graph_4d = show_4d_window(data_array)\n",
+    "graph_4d.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b44542de",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "5"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "805bb93c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data='your data_array'\n",
+    "#the kx plot\n",
+    "data.loc[\n",
+    "    {\n",
+    "        'kx': slice(\n",
+    "            1.0800000000000003,\n",
+    "            1.0800000000000003\n",
+    "        ),\n",
+    "        'ADC': slice(\n",
+    "            590.0,\n",
+    "            590.0\n",
+    "        )\n",
+    "    }\n",
+    "].mean(dim=('kx', 'ADC')).T            "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f416bc6e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "data=data_array\n",
+    "#the energy plot\n",
+    "\n",
+    "en=data.loc[\n",
+    "    {\n",
+    "        'energy': slice(\n",
+    "            0.4333333333333331,\n",
+    "            0.4333333333333331\n",
+    "        ),\n",
+    "        'ADC': slice(\n",
+    "            590.0,\n",
+    "            590.0\n",
+    "        )\n",
+    "    }\n",
+    "].mean(dim=('energy', 'ADC'))\n",
+    "fig,ax=plt.subplots(1,1,figsize=(12,8),cmap='terrain')\n",
+    "en.plot(ax=ax)\n",
+    "plt.show()\n",
+    "            "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a6a92293",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "('Angle', 'Ekin', 'delay')\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Use the 3D Gui\n",
+    "\n",
+    "import numpy as np\n",
+    "import xarray as xr\n",
+    "from mpes_tools.Gui_3d import Gui_3d\n",
+    "%gui qt\n",
+    "\n",
+    "# import the 3D data\n",
+    "loaded_data= np.load('//nap33/wahada/Phoibospython/scan11443_filtered.npz')\n",
+    "\n",
+    "V1= xr.DataArray(loaded_data['data_array'], dims=['Angle', 'Ekin','delay'], coords={'Angle': loaded_data['Angle'], 'Ekin': loaded_data['Ekin'],'delay': loaded_data['delay']})    \n",
+    "axis=[V1['Angle'],V1['Ekin']-21.7,V1['delay']]\n",
+    "# print(data.dims)\n",
+    "graph_window= Gui_3d(V1,0,0,'Phoibos')\n",
+    "graph_window.show()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "fe4ced28",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "5"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "28173036",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "data=V1\n",
+    "data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)\n",
+    "#the 2D plot data\n",
+    "data2D_plot=data.isel({data.dims[2]:slice(0, 1)}).sum(dim=data.dims[2])   \n",
+    "\n",
+    "            "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "5c78b3de",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'data' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[1], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m#Use the fit panel on the extracted data\u001b[39;00m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mmpes_tools\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mfit_panel\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m fit_panel\n\u001b[1;32m----> 3\u001b[0m graph_window\u001b[38;5;241m=\u001b[39mfit_panel(\u001b[43mdata\u001b[49m,\u001b[38;5;241m7.26502584586467\u001b[39m,\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m0\u001b[39m, data\u001b[38;5;241m.\u001b[39mdims[\u001b[38;5;241m1\u001b[39m])\n\u001b[0;32m      4\u001b[0m graph_window\u001b[38;5;241m.\u001b[39mshow()\n",
+      "\u001b[1;31mNameError\u001b[0m: name 'data' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "#Use the fit panel on the extracted data\n",
+    "from mpes_tools.fit_panel import fit_panel\n",
+    "graph_window=fit_panel(data,7.26502584586467,0, 0,0, data.dims[1])\n",
+    "graph_window.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "fa77e9ea",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "5"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "e74ff8ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "import xarray as xr\n",
+    "import numpy as np\n",
+    "\n",
+    "data_array = xr.DataArray(\n",
+    "    data=np.array([72454952.77813482, 74319394.28211385, 73902532.98867458, 71794649.12762325, 69014759.66859658, 64599615.499209926, 60882255.5172165, 58062323.58021691, 56750480.96430322, 56591974.51984634, 57053402.50227239, 58778077.13226885, 59581963.89421518, 62141887.68747307, 62140060.63846748, 63885922.12931153, 64763429.65702102, 65304896.7568378, 65599500.53851978, 67176412.11176091, 67299577.25888413, 67704501.05965017, 67746919.56904675, 67477095.46338437, 68109844.82892786, 68152383.42887904, 68101379.96762604, 68354705.80635957, 68622612.31118561, 68693658.6672469, 68949276.09725638, 68464478.46383135, 68297500.8992677, 68581073.5576817, 69156170.4879223, 68784956.93797548, 68601158.52842137, 68982572.6141164, 70068112.8320306, 69431684.97362354, 70064932.14450617, 69014533.06417881, 69112771.21447168, 69085856.65415049, 68686796.79644686, 69635436.53035763, 70133547.77226815, 70765222.3548185, 69798788.24872309, 70365060.35463753, 69805831.4598499, 70565982.03507684, 70761296.45137312, 70079495.2628483, 71242645.59718813, 71227586.09940824, 70449179.10912453, 69801265.3630908, 71011537.35769275, 70572296.99510731, 69851458.57252772, 70041990.79150626, 70929439.1441927, 70376205.0775435, 69823762.39368734, 70497642.1116163, 70653051.51037209, 70691808.57159007, 70598843.36181132, 70560704.38856414, 71101037.98545931, 70926537.33602336, 70388372.96071577, 70458144.73793708, 70415826.91751112, 71362907.81362744, 70449584.87394847, 70543133.37354767, 71670780.93813168, 70373590.28219332, 70527269.34599042, 69911586.02810569]),\n",
+    "    dims=('delay',),\n",
+    "    coords={'delay': [-799.4466666666729, -499.65333333337486, -199.86000000002943, -99.93333333336332, -74.94666666668573, -49.96666666670534, -24.980000000027754, 0.0, 24.979999999980386, 49.96666666665798, 74.94666666663836, 99.93333333331596, 124.91333333329634, 149.8933333333241, 174.88000000000167, 199.85999999998208, 224.84666666665967, 249.82666666664005, 274.8066666666678, 299.79333333329805, 324.77333333332575, 349.76000000000334, 374.73999999998375, 399.71999999996416, 424.70666666664175, 449.6866666666695, 474.6733333332997, 499.65333333332745, 524.6399999999577, 549.6199999999855, 574.5999999999658, 599.5866666666434, 624.5666666666239, 649.5533333333013, 674.5333333333291, 699.5133333333096, 724.4999999999872, 749.4799999999675, 774.4666666666451, 799.4466666666254, 899.3799999999889, 999.3066666666549, 1099.239999999971, 1199.166666666637, 1299.1000000000004, 1399.0333333333162, 1498.9599999999823, 1598.8933333332984, 1698.8266666666616, 1798.7533333333279, 1898.6866666666438, 1998.6133333333098, 2098.5466666666257, 2198.479999999989, 2298.4066666666554, 2398.339999999971, 2498.2733333333344, 2598.2000000000007, 2698.1333333333164, 2798.0599999999827, 2897.993333333299, 2997.926666666662, 3097.853333333328, 3197.786666666644, 3297.7199999999602, 3397.646666666626, 3497.5799999999895, 3597.5066666666557, 3697.4399999999714, 3797.373333333335, 3897.300000000001, 3997.2333333333168, 4097.166666666633, 4197.093333333299, 4297.026666666662, 4396.953333333328, 4496.8866666666445, 4596.819999999961, 4696.746666666627, 4796.679999999989, 4896.6133333333055, 4996.539999999972]},\n",
+    "    name=\"f0_A\"\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "2c6bc231",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x2abab3616a0>]"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "fig,ax=plt.subplots(1,1,figsize=(12,8))\n",
+    "data_array.plot(ax=ax)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08f327a9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From b936f0519341f299ed1e6eee88c5920848ee1da5 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 15 Apr 2025 20:30:14 +0200
Subject: [PATCH 17/67] corrected a small bug related to clearing the graph and
 leaving the cursors

---
 src/mpes_tools/fit_panel.py | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/mpes_tools/fit_panel.py b/src/mpes_tools/fit_panel.py
index 50b5be0..1f2d292 100644
--- a/src/mpes_tools/fit_panel.py
+++ b/src/mpes_tools/fit_panel.py
@@ -32,9 +32,9 @@ def __init__(self,data,c1,c2,t,dt,panel):
         view_menu = menu_bar.addMenu("View")
 
         # Create actions for showing and hiding the graph window
-        show_graph_action = QAction("Show Graph", self)
-        show_graph_action.triggered.connect(self.show_graph_window)
-        view_menu.addAction(show_graph_action)
+        clear_graph_action = QAction("Show Graph", self)
+        clear_graph_action.triggered.connect(self.clear_graph_window)
+        view_menu.addAction(clear_graph_action)
 
         # Store references to graph windows to prevent garbage collection
         self.graph_windows = []
@@ -65,6 +65,7 @@ def __init__(self,data,c1,c2,t,dt,panel):
         splitter.addWidget(right_panel)
         
         self.figure, self.axis = plt.subplots()
+        plt.close(self.figure)
         self.canvas = FigureCanvas(self.figure)
         # Create two checkboxes
         self.checkbox0 = QCheckBox("Cursors")
@@ -129,7 +130,7 @@ def __init__(self,data,c1,c2,t,dt,panel):
         
 
         self.graph_button = QPushButton("clear graph")
-        self.graph_button.clicked.connect(self.show_graph_window)
+        self.graph_button.clicked.connect(self.clear_graph_window)
         
         self.fit_button = QPushButton("Fit")
         self.fit_button.clicked.connect(self.fit)
@@ -269,6 +270,11 @@ def plot_graph(self,t,dt):
         if self.panel != 'box':
             self.y=self.data_t.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
         self.y.plot(ax=self.axis)
+        if self.checkbox0.isChecked():
+            if self.cursor_handler is None:
+                self.cursor_handler = MovableCursors(self.axis)
+            else:
+                self.cursor_handler.redraw()
         self.figure.tight_layout()
         self.canvas.draw()
     def update_text_edit_boxes(self):
@@ -340,7 +346,7 @@ def convolution(x, func, *args, sigma=1.0):
             return convolution_result[N-1:-1]
     
 
-    def show_graph_window(self):
+    def clear_graph_window(self):
         self.axis.clear()
         self.plot_graph(self.t,self.dt)
         

From 381f9ca7f44e288987a450b1ae38b08f5d08459d Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 15 Apr 2025 20:31:10 +0200
Subject: [PATCH 18/67] created a fit panel for a single 1D xarray data

---
 src/mpes_tools/fit_panel_single.py | 566 +++++++++++++++++++++++++++++
 1 file changed, 566 insertions(+)
 create mode 100644 src/mpes_tools/fit_panel_single.py

diff --git a/src/mpes_tools/fit_panel_single.py b/src/mpes_tools/fit_panel_single.py
new file mode 100644
index 0000000..63d3235
--- /dev/null
+++ b/src/mpes_tools/fit_panel_single.py
@@ -0,0 +1,566 @@
+import sys
+from PyQt5.QtGui import QBrush, QColor
+from PyQt5.QtWidgets import QTextEdit, QLineEdit,QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, QWidget, QSlider, QLabel, QAction, QCheckBox, QPushButton, QListWidget, QTableWidget, QTableWidgetItem, QTableWidget, QCheckBox, QSplitter
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import QTableWidgetItem, QHBoxLayout, QCheckBox, QWidget
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+import matplotlib.pyplot as plt
+from scipy.optimize import curve_fit
+import numpy as np
+from lmfit.models import ExpressionModel,Model
+from lmfit import CompositeModel, Model
+from lmfit.lineshapes import gaussian, step
+import inspect
+from mpes_tools.movable_vertical_cursors_graph import MovableCursors
+from mpes_tools.make_model import make_model
+from mpes_tools.graphs import showgraphs
+
+
+
+
+class fit_panel_single(QMainWindow):
+    def __init__(self,data):
+        super().__init__()
+
+        self.setWindowTitle("Main Window")
+        self.setGeometry(100, 100, 1500, 800)
+        
+        # Create a menu bar
+        menu_bar = self.menuBar()
+
+        # Create a 'View' menu
+        view_menu = menu_bar.addMenu("View")
+
+        # Create actions for showing and hiding the graph window
+        clear_graph_action = QAction("Show Graph", self)
+        clear_graph_action.triggered.connect(self.clear_graph_window)
+        view_menu.addAction(clear_graph_action)
+
+        # Store references to graph windows to prevent garbage collection
+        self.graph_windows = []
+
+        # Create a central widget
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+
+        # Create a layout for the central widget
+        layout = QHBoxLayout()
+        central_widget.setLayout(layout)
+
+        # Create a splitter for two panels
+        splitter = QSplitter(Qt.Horizontal)
+
+        # Create a left panel widget and its layout
+        left_panel = QWidget()
+        left_layout = QVBoxLayout()
+        left_panel.setLayout(left_layout)
+
+        # Create a right panel widget and its layout
+        right_panel = QWidget()
+        right_layout = QVBoxLayout()
+        right_panel.setLayout(right_layout)
+
+        # Add the panels to the splitter
+        splitter.addWidget(left_panel)
+        splitter.addWidget(right_panel)
+        
+        self.figure, self.axis = plt.subplots()
+        plt.close(self.figure)
+        self.canvas = FigureCanvas(self.figure)
+        # Create two checkboxes
+        self.checkbox0 = QCheckBox("Cursors")
+        self.checkbox0.stateChanged.connect(self.checkbox0_changed)
+        
+
+        # Create two checkboxes
+        self.checkbox1 = QCheckBox("Multiply with Fermi Dirac")
+        self.checkbox1.stateChanged.connect(self.checkbox1_changed)
+
+        self.checkbox2 = QCheckBox("Convolve with a Gaussian")
+        self.checkbox2.stateChanged.connect(self.checkbox2_changed)
+        
+        self.checkbox3 = QCheckBox("add background offset")
+        self.checkbox3.stateChanged.connect(self.checkbox3_changed)
+
+        
+        self.guess_button = QPushButton("Guess")
+        self.guess_button.clicked.connect(self.button_guess_clicked)
+        
+        bigger_layout = QVBoxLayout()
+        bigger_layout.addWidget(self.guess_button)
+        # Create a QListWidget
+        self.list_widget = QListWidget()
+        self.list_widget.addItems(["linear","Lorentz", "Gauss", "sinusoid","constant","jump"])
+        self.list_widget.setMaximumSize(120,150)
+        self.list_widget.itemClicked.connect(self.item_selected)
+
+        self.add_button = QPushButton("add")
+        self.add_button.clicked.connect(self.button_add_clicked)
+        
+        self.remove_button = QPushButton("remove")
+        self.remove_button.clicked.connect(self.button_remove_clicked)
+        
+
+        self.graph_button = QPushButton("clear graph")
+        self.graph_button.clicked.connect(self.clear_graph_window)
+        
+        self.fit_button = QPushButton("Fit")
+        self.fit_button.clicked.connect(self.fit)
+
+
+        
+        left_buttons=QVBoxLayout()
+        left_sublayout=QHBoxLayout()
+        
+        left_buttons.addWidget(self.add_button)
+        left_buttons.addWidget(self.remove_button)
+        left_buttons.addWidget(self.graph_button)
+        left_buttons.addWidget(self.fit_button)
+
+        
+        left_sublayout.addWidget(self.list_widget)
+        left_sublayout.addLayout(left_buttons) 
+
+        # Add widgets to the left layout
+        left_layout.addWidget(self.canvas)
+        left_layout.addWidget(self.checkbox0)
+        left_layout.addLayout(left_sublayout) 
+        
+        
+        self.text_equation = QTextEdit()
+        # self.text_equation.setMinimumSize(50, 50)  # Set minimum size
+        self.text_equation.setMaximumSize(500, 30)  # Set maximum size
+        
+        # Create a table widget for the right panel
+        self.table_widget = QTableWidget(0, 4)  # 6 rows and 4 columns (including the special row)
+        self.table_widget.setHorizontalHeaderLabels(['min', 'value', 'max', 'fix'])
+        # self.table_widget.setVerticalHeaderLabels(['Row 1', 'The ROW', 'Row 2', 'Row 3', 'Row 4', 'Row 5'])
+        self.table_widget.itemChanged.connect(self.table_item_changed)
+        self.table_widget.setMaximumSize(700,500)
+        # Add checkboxes to the last column of the table, except for the special row
+        for row in range(6):
+            if row != 1:  # Skip 'The ROW'
+                checkbox_widget = QWidget()
+                checkbox_layout = QHBoxLayout()
+                checkbox_layout.setAlignment(Qt.AlignCenter)
+                checkbox = QCheckBox()
+                checkbox_layout.addWidget(checkbox)
+                checkbox_widget.setLayout(checkbox_layout)
+                self.table_widget.setCellWidget(row, 3, checkbox_widget)
+
+        # Set 'The ROW' with uneditable empty cells
+        for col in range(4):
+            # if col == 3:  # Skip the checkbox column for 'The ROW'
+            #     continue
+            item = QTableWidgetItem('')
+            item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
+            self.table_widget.setItem(1, col, item)
+
+        # Add the table to the right layout
+        checkboxes=QVBoxLayout()
+        top_lay = QHBoxLayout()
+        above_table=QVBoxLayout()
+        checkboxes.addWidget(self.checkbox1)
+        checkboxes.addWidget(self.checkbox2)
+        checkboxes.addWidget(self.checkbox3)
+        top_lay.addWidget(self.text_equation)
+        top_lay.addLayout(checkboxes)
+        above_table.addLayout(top_lay)
+        above_table.addLayout(bigger_layout)
+        right_layout.addLayout(above_table)
+        right_layout.addWidget(self.table_widget)
+
+        # Add the splitter to the main layout
+        layout.addWidget(splitter)
+        def zero(x):
+            return 0
+        self.equation= None
+        self.mod= Model(zero)
+        self.total_function=zero
+        self.function_before_Fermi= zero
+        self.function_before_convoluted= zero
+        self.update_text_edit_boxes()
+        self.i=0
+        
+        self.function_list=[]
+        self.function_names_list=[]
+        self.cursor_handler = None
+        self.FD_state = False
+        self.CV_state = False
+        self.t0_state = False
+        self.offset_state = False
+        self.data=data
+        self.y=data
+        self.dim=data.dims[0]
+        self.plot_graph()
+
+    def plot_graph(self):
+        self.axis.clear()
+        self.y.plot(ax=self.axis)
+        if self.checkbox0.isChecked():
+            if self.cursor_handler is None:
+                self.cursor_handler = MovableCursors(self.axis)
+            else:
+                self.cursor_handler.redraw()
+        self.figure.tight_layout()
+        self.canvas.draw()
+    def update_text_edit_boxes(self):
+        self.text_equation.setPlaceholderText("Top Right Text Edit Box")
+    
+    def offset_function (self,x,offset):
+        return 0*x+offset    
+    def constant (self,x,A):
+        return 0*x+A
+    def linear (self,x,a,b):
+        return a*x+b
+    def lorentzian(self,x, A, x0, gamma):
+        c=0.0000
+        return A / (1 + ((x - x0) / (gamma+c)) ** 2)
+    def fermi_dirac(self,x, mu, T):
+        kb = 8.617333262145 * 10**(-5)  # Boltzmann constant in eV/K
+        return 1 / (1 + np.exp((x - mu) / (kb * T)))
+    def gaussian(self,x,A, x0, gamma):
+        return A* np.exp(-(x -x0)**2 / (2 * gamma**2))
+    def gaussian_conv(self,x,sigma):
+        return  np.exp(-(x)**2 / (2 * sigma**2))
+    def jump(self,x, mid):
+        """Heaviside step function."""
+        o = np.zeros(x.size)
+        imid = max(np.where(x <= mid)[0])
+        o[imid:] = 1.0
+        return o
+    def jump2(self,x, mid,Amp):
+        """Heaviside step function."""
+        o = np.zeros(x.size)
+        imid = max(np.where(x <= mid)[0])
+        o[:imid] = Amp
+        return o
+
+    def centered_kernel(self,x, sigma):
+        mean = x.mean()
+        return np.exp(-(x-mean)**2/(2*sigma/2.3548200)**2)
+
+    def convolve(self,arr, kernel):
+        """Simple convolution of two arrays."""
+        npts = min(arr.size, kernel.size)
+        pad = np.ones(npts)
+        tmp = np.concatenate((pad*arr[0], arr, pad*arr[-1]))
+        out = np.convolve(tmp, kernel/kernel.sum(), mode='valid')
+        noff = int((len(out) - npts) / 2)
+        return out[noff:noff+npts]
+    
+    
+    def convolution(x, func, *args, sigma=1.0):
+            N = 20  # Assuming N is intended to be a local variable here
+            x_step = x[1] - x[0]
+            
+            # Create the shifted input signal 'y' for convolution
+            y = np.zeros(N + len(x))
+            for i in range(N):
+                y[i] = x[0] - (N - i) * x_step
+            y[N:] = x  # Append the original signal x to y
+            
+            # Create the Gaussian kernel
+            x_gauss = np.linspace(-0.5, 0.5, len(x))
+            gaussian_values = np.exp(-0.5 * (x_gauss / sigma)**2) / (sigma * np.sqrt(2 * np.pi))
+            
+            # Evaluate the function values with parameters
+            function_values = func(x, *args)
+            
+            # Perform convolution
+            convolution_result = np.convolve(function_values, gaussian_values, mode='same')
+            
+            return convolution_result[N-1:-1]
+    
+
+    def clear_graph_window(self):
+        self.axis.clear()
+        self.plot_graph()
+        
+    def checkbox0_changed(self, state):
+        if state == Qt.Checked:
+            if self.cursor_handler is None:
+                self.cursor_handler = MovableCursors(self.axis)
+                self.canvas.draw()
+            else:
+                self.cursor_handler.redraw()
+        else:
+            self.cursor_handler.remove()
+    
+    def checkbox1_changed(self, state):
+        if self.CV_state== True:
+            pos=2
+        else:
+            pos=0
+        if state == Qt.Checked:
+            self.FD_state = True
+            self.update_equation()
+            self.table_widget.insertRow(pos)
+            label_item = QTableWidgetItem("Fermi")
+            self.table_widget.setVerticalHeaderItem(pos, label_item)
+            for col in range(4):
+                item = QTableWidgetItem('')
+                item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
+                self.table_widget.setItem(pos, col, item)
+                item.setBackground(QBrush(QColor('grey')))
+            c=self.table_widget.rowCount()
+            self.table_widget.insertRow(pos+1)
+            label_item1 = QTableWidgetItem("Fermi level")
+            checkbox_widget = QWidget()
+            checkbox_layout = QHBoxLayout()
+            checkbox_layout.setAlignment(Qt.AlignCenter)
+            checkbox = QCheckBox()
+            checkbox.stateChanged.connect(lambda state, row= pos+1: self.handle_checkbox_state_change(state, row))
+            # print('thecount',c+1)
+            checkbox_layout.addWidget(checkbox)
+            checkbox_widget.setLayout(checkbox_layout)
+            self.table_widget.setCellWidget(pos+1, 3, checkbox_widget)
+            self.table_widget.setVerticalHeaderItem(pos+1, label_item1)
+            
+            self.table_widget.insertRow(pos+2)
+            label_item2 = QTableWidgetItem("Temperature")
+            checkbox_widget = QWidget()
+            checkbox_layout = QHBoxLayout()
+            checkbox_layout.setAlignment(Qt.AlignCenter)
+            checkbox = QCheckBox()
+            checkbox.stateChanged.connect(lambda state, row= pos+2: self.handle_checkbox_state_change(state, row))
+            checkbox_layout.addWidget(checkbox)
+            checkbox_widget.setLayout(checkbox_layout)
+            self.table_widget.setCellWidget(pos+2, 3, checkbox_widget)
+            self.table_widget.setVerticalHeaderItem(pos+2, label_item2)
+        else:
+            self.FD_state = False
+            self.update_equation()
+            # print("Checkbox 1 is unchecked")
+            
+            self.table_widget.removeRow(pos)
+            self.table_widget.removeRow(pos)
+            self.table_widget.removeRow(pos)
+            
+    def checkbox2_changed(self, state):
+        if state == Qt.Checked:
+            self.CV_state = True
+            
+            self.update_equation()
+
+            self.table_widget.insertRow(0)
+            label_item = QTableWidgetItem("Convolution")
+            self.table_widget.setVerticalHeaderItem(0, label_item)
+            # self.table_widget.setVerticalHeaderItem(0, new_row_name)
+            for col in range(4):
+                item = QTableWidgetItem('')
+                item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
+                self.table_widget.setItem(0, col, item)
+                item.setBackground(QBrush(QColor('grey')))
+                
+            self.table_widget.insertRow(1)
+            label_item1 = QTableWidgetItem("sigma")
+            checkbox_widget = QWidget()
+            checkbox_layout = QHBoxLayout()
+            checkbox_layout.setAlignment(Qt.AlignCenter)
+            checkbox = QCheckBox()
+            checkbox.stateChanged.connect(lambda state, row= 1: self.handle_checkbox_state_change(state, row))
+            checkbox_layout.addWidget(checkbox)
+            checkbox_widget.setLayout(checkbox_layout)
+            self.table_widget.setCellWidget(1, 3, checkbox_widget)
+            self.table_widget.setVerticalHeaderItem(1, label_item1)
+            
+        else:
+            self.CV_state = False
+            self.update_equation()
+            # print("Checkbox 1 is unchecked")
+            
+            self.table_widget.removeRow(0)
+            self.table_widget.removeRow(0)
+    def checkbox3_changed(self, state):
+        if state == Qt.Checked:
+            self.offset_state=True
+        else:
+            self.offset_state=False
+        
+    def item_selected(self, item):
+        # print(f"Selected: {item.text()}")
+        if item.text() == 'Lorentz':
+            self.function_selected = self.lorentzian
+        elif item.text() == 'Gauss':
+            self.function_selected = self.gaussian 
+        elif item.text()=='linear':
+            self.function_selected =self.linear
+        elif item.text()=='constant':
+            self.function_selected =self.constant
+        elif item.text()=='jump':
+            self.function_selected =self.jump2
+        
+    def button_guess_clicked(self):
+        cursors= self.cursor_handler.cursors()
+        self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+        self.x_f=self.y_f[self.dim]
+        max_value= self.y_f.data.max()
+        min_value= self.y_f.data.min()
+        mean_value= self.y_f.data.mean()
+        max_arg=self.y_f.data.argmax()
+        # print(self.x_f[max_arg].item())
+        for row in range(self.table_widget.rowCount()):
+            header_item = self.table_widget.verticalHeaderItem(row)
+            if "A" in header_item.text():
+                self.params[header_item.text()].set(value=max_value)
+                item = QTableWidgetItem(str(max_value))
+                self.table_widget.setItem(row, 1, item)
+            elif "x0" in header_item.text():
+                self.params[header_item.text()].set(value=self.x_f[max_arg].item())
+                item = QTableWidgetItem(str(self.x_f[max_arg].item()))
+                self.table_widget.setItem(row, 1, item)
+            elif "gamma" in header_item.text():
+                self.params[header_item.text()].set(value=0.2)
+                item = QTableWidgetItem(str(0.2))
+                self.table_widget.setItem(row, 1, item)
+
+            
+    
+    def button_remove_clicked(self):
+        if self.i>0:
+            self.i-=1
+        current_row_count = self.table_widget.rowCount()
+        sig = inspect.signature(self.function_list[-1])
+        params = sig.parameters
+        
+        for p in range(len(params)):
+            self.table_widget.removeRow(current_row_count-1-p)    
+            
+        self.function_list.remove(self.function_list[-1])
+        self.function_names_list.remove(self.function_names_list[-1])
+        self.update_equation()
+        self.create()
+
+    def button_add_clicked(self):
+        def zero(x):
+            return 0
+        
+        
+        self.i+=1
+        self.function_list.append(self.function_selected)
+        self.function_names_list.append(self.list_widget.currentItem().text())
+        j=0
+        for p in self.function_list:
+            current_function=Model(p,prefix='f'+str(j)+'_')
+            j+=1
+            
+        
+        current_row_count = self.table_widget.rowCount()
+        
+        self.table_widget.insertRow(current_row_count)
+        new_row_name = QTableWidgetItem(self.list_widget.currentItem().text())
+        self.table_widget.setVerticalHeaderItem(current_row_count, new_row_name)
+        for col in range(4):
+            item = QTableWidgetItem('')
+            item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
+            self.table_widget.setItem(current_row_count, col, item)
+            item.setBackground(QBrush(QColor('grey')))
+        c=current_row_count
+        for p in range(len(current_function.param_names)):
+
+            self.table_widget.insertRow(c+p+1)
+            # print(current_function.param_names[p])
+            new_row_name = QTableWidgetItem(current_function.param_names[p])
+            self.table_widget.setVerticalHeaderItem(c+p+1, new_row_name)
+            checkbox_widget = QWidget()
+            checkbox_layout = QHBoxLayout()
+            checkbox_layout.setAlignment(Qt.AlignCenter)
+            checkbox = QCheckBox()
+            checkbox.stateChanged.connect(lambda state, row=c + p + 1: self.handle_checkbox_state_change(state, row))
+            checkbox_layout.addWidget(checkbox)
+            checkbox_widget.setLayout(checkbox_layout)
+            self.table_widget.setCellWidget(c+p+1, 3, checkbox_widget)
+        
+        self.update_equation()
+        self.create()
+        
+    def update_equation(self):
+        self.equation=''
+        # print('names',self.function_names_list)
+        for j,n in enumerate(self.function_names_list):
+            if len(self.function_names_list)==1:
+                self.equation= n
+            else:
+                if j==0:
+                    self.equation= n
+                else:
+                    self.equation+= '+' + n
+        if self.FD_state:
+            self.equation= '('+ self.equation+ ')* Fermi_Dirac'
+        self.text_equation.setPlainText(self.equation)
+        # print('equation',self.equation)
+    
+
+    def table_item_changed(self, item):
+        # print(f"Table cell changed at ({item.row()}, {item.column()}): {item.text()}")
+        header_item = self.table_widget.verticalHeaderItem(item.row())
+        # print('theeeeeeitem=',item.text())
+        
+    def handle_checkbox_state_change(self,state,row):
+        if state == Qt.Checked:
+            header_item = self.table_widget.verticalHeaderItem(row)
+            
+        else:
+            header_item = self.table_widget.verticalHeaderItem(row)
+    def create(self):
+        def zero(x):
+            return 0
+        cursors= self.cursor_handler.cursors()
+        self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+        self.x_f=self.y_f[self.dim]
+        # print(self.y_f)
+        if self.offset_state==True:
+            self.params['offset'].set(value=self.y_f.data.min())
+        list_axis=[[self.y[self.dim]],[self.x_f]]
+        self.mod= Model(zero)
+        j=0
+        for f in self.function_list:
+            self.mod+=Model(f,prefix='f'+str(j)+'_')
+            j+=1
+        if self.FD_state == True:
+            self.mod= self.mod* Model(self.fermi_dirac)
+        if self.CV_state == True:
+            self.mod = CompositeModel(self.mod, Model(self.centered_kernel), self.convolve)
+        if self.offset_state==True:
+            self.mod= self.mod+Model(self.offset_function)
+        m1=make_model(self.mod, self.table_widget)
+        self.mod=m1.current_model()
+        self.params=m1.current_params()
+    def fit(self):
+        
+        def zero(x):
+            return 0
+        self.mod= Model(zero)
+        cursors= self.cursor_handler.cursors()
+        j=0
+        for f in self.function_list:
+            self.mod+=Model(f,prefix='f'+str(j)+'_')
+            j+=1
+        if self.FD_state == True:
+            self.mod= self.mod* Model(self.fermi_dirac)
+        if self.CV_state == True:
+            self.mod = CompositeModel(self.mod, Model(self.centered_kernel), self.convolve)
+        if self.offset_state==True:
+            self.mod= self.mod+Model(self.offset_function)
+        m1=make_model(self.mod, self.table_widget)
+        self.mod=m1.current_model()
+        self.params=m1.current_params()
+        self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+        self.x_f=self.y_f[self.dim]
+        if self.offset_state==True:
+            self.params['offset'].set(value=self.y_f.data.min())
+        # print(self.params)
+        out = self.mod.fit(self.y_f, self.params, x=self.x_f)
+        print(out.fit_report(min_correl=0.25))
+        self.axis.plot(self.x_f,out.best_fit,color='red',label='fit')
+        self.figure.tight_layout()
+        self.canvas.draw()
+        
+    
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    window = fit_panel_single()
+    window.show()
+    sys.exit(app.exec_())

From f5db38b20619741e8db48c9e28423b8f0d155f3a Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 15 Apr 2025 20:31:51 +0200
Subject: [PATCH 19/67] added an example for the fit panel single

---
 tutorials/template.ipynb | 187 +++++++++++++++++++++++++++++++++------
 1 file changed, 160 insertions(+), 27 deletions(-)

diff --git a/tutorials/template.ipynb b/tutorials/template.ipynb
index 1dca783..cf8de32 100644
--- a/tutorials/template.ipynb
+++ b/tutorials/template.ipynb
@@ -122,7 +122,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "a6a92293",
    "metadata": {},
    "outputs": [
@@ -141,6 +141,13 @@
      },
      "metadata": {},
      "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "results extracted!\n"
+     ]
     }
    ],
    "source": [
@@ -164,7 +171,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 6,
    "id": "fe4ced28",
    "metadata": {},
    "outputs": [
@@ -174,7 +181,7 @@
        "5"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -194,13 +201,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "id": "28173036",
+   "execution_count": null,
+   "id": "8156e845",
    "metadata": {},
    "outputs": [],
    "source": [
     "\n",
-    "data=V1\n",
+    "data='your data_array'\n",
     "data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)\n",
     "#the 2D plot data\n",
     "data2D_plot=data.isel({data.dims[2]:slice(0, 1)}).sum(dim=data.dims[2])   \n",
@@ -210,32 +217,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "5c78b3de",
    "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'data' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "Cell \u001b[1;32mIn[1], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m#Use the fit panel on the extracted data\u001b[39;00m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mmpes_tools\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mfit_panel\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m fit_panel\n\u001b[1;32m----> 3\u001b[0m graph_window\u001b[38;5;241m=\u001b[39mfit_panel(\u001b[43mdata\u001b[49m,\u001b[38;5;241m7.26502584586467\u001b[39m,\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m0\u001b[39m, data\u001b[38;5;241m.\u001b[39mdims[\u001b[38;5;241m1\u001b[39m])\n\u001b[0;32m      4\u001b[0m graph_window\u001b[38;5;241m.\u001b[39mshow()\n",
-      "\u001b[1;31mNameError\u001b[0m: name 'data' is not defined"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "#Use the fit panel on the extracted data\n",
     "from mpes_tools.fit_panel import fit_panel\n",
+    "%gui qt\n",
     "graph_window=fit_panel(data,7.26502584586467,0, 0,0, data.dims[1])\n",
     "graph_window.show()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 9,
    "id": "fa77e9ea",
    "metadata": {},
    "outputs": [
@@ -245,9 +241,18 @@
        "5"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -256,7 +261,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 1,
    "id": "e74ff8ab",
    "metadata": {},
    "outputs": [],
@@ -275,23 +280,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 2,
    "id": "2c6bc231",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x2abab3616a0>]"
+       "[<matplotlib.lines.Line2D at 0x2c1e2170ad0>]"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x800 with 1 Axes>"
       ]
@@ -312,6 +317,134 @@
    "execution_count": null,
    "id": "08f327a9",
    "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "otherpalce Parameters([('f0_A', <Parameter 'f0_A', value=-inf, bounds=[-inf:inf]>), ('f0_x0', <Parameter 'f0_x0', value=-inf, bounds=[-inf:inf]>), ('f0_gamma', <Parameter 'f0_gamma', value=-inf, bounds=[-inf:inf]>), ('f1_A', <Parameter 'f1_A', value=-inf, bounds=[-inf:inf]>)])\n",
+      "thefuuuuTable <PyQt5.QtWidgets.QTableWidget object at 0x000002C1F4C97770>\n",
+      "count 6\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20D40>\n",
+      "tableitenm= None\n",
+      "tableitenm= None\n",
+      "tableitenm= None\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D23BF0>\n",
+      "tableitenm= None\n",
+      "otherpalce Parameters([('f0_A', <Parameter 'f0_A', value=-inf, bounds=[-inf:inf]>), ('f0_x0', <Parameter 'f0_x0', value=-inf, bounds=[-inf:inf]>), ('f0_gamma', <Parameter 'f0_gamma', value=-inf, bounds=[-inf:inf]>), ('f1_A', <Parameter 'f1_A', value=-inf, bounds=[-inf:inf]>)])\n",
+      "thefuuuuTable <PyQt5.QtWidgets.QTableWidget object at 0x000002C1F4C97770>\n",
+      "count 6\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20D40>\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D21E20>\n",
+      "f0_A -56591974.51984634\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20DD0>\n",
+      "f0_x0 49.96666666665798\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20EF0>\n",
+      "f0_gamma 0.2\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D23BF0>\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20E60>\n",
+      "f1_A -56591974.51984634\n",
+      "[[Model]]\n",
+      "    ((Model(zero) + Model(lorentzian, prefix='f0_')) + Model(constant, prefix='f1_'))\n",
+      "[[Fit Statistics]]\n",
+      "    # fitting method   = leastsq\n",
+      "    # function evals   = 55\n",
+      "    # data points      = 19\n",
+      "    # variables        = 4\n",
+      "    chi-square         = 3.6520e+14\n",
+      "    reduced chi-square = 2.4347e+13\n",
+      "    Akaike info crit   = 589.153518\n",
+      "    Bayesian info crit = 592.931274\n",
+      "    R-squared          = -6.2400e-09\n",
+      "##  Warning: uncertainties could not be estimated:\n",
+      "[[Variables]]\n",
+      "    f0_A:     -39908756.3 (init = -5.659197e+07)\n",
+      "    f0_x0:     67.0313375 (init = 49.96667)\n",
+      "    f0_gamma: -2.0575e-05 (init = 0.2)\n",
+      "    f1_A:     -63112224.4 (init = -5.659197e+07)\n",
+      "otherpalce Parameters([('f0_A', <Parameter 'f0_A', value=-inf, bounds=[-inf:inf]>), ('f0_x0', <Parameter 'f0_x0', value=-inf, bounds=[-inf:inf]>), ('f0_gamma', <Parameter 'f0_gamma', value=-inf, bounds=[-inf:inf]>), ('f1_A', <Parameter 'f1_A', value=-inf, bounds=[-inf:inf]>)])\n",
+      "thefuuuuTable <PyQt5.QtWidgets.QTableWidget object at 0x000002C1F4C97770>\n",
+      "count 6\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20D40>\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D21E20>\n",
+      "f0_A -56591974.51984634\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20DD0>\n",
+      "f0_x0 49.96666666665798\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20EF0>\n",
+      "f0_gamma 0.2\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D23BF0>\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20E60>\n",
+      "f1_A -56591974.51984634\n",
+      "[[Model]]\n",
+      "    ((Model(zero) + Model(lorentzian, prefix='f0_')) + Model(constant, prefix='f1_'))\n",
+      "[[Fit Statistics]]\n",
+      "    # fitting method   = leastsq\n",
+      "    # function evals   = 157\n",
+      "    # data points      = 20\n",
+      "    # variables        = 4\n",
+      "    chi-square         = 8.9082e+13\n",
+      "    reduced chi-square = 5.5676e+12\n",
+      "    Akaike info crit   = 590.496992\n",
+      "    Bayesian info crit = 594.479921\n",
+      "    R-squared          = 0.81278004\n",
+      "[[Variables]]\n",
+      "    f0_A:      17291184.6 +/- 3177500.66 (18.38%) (init = -5.659197e+07)\n",
+      "    f0_x0:     80.6176787 +/- 10.0409995 (12.46%) (init = 49.96667)\n",
+      "    f0_gamma:  151.821274 +/- 43.9700666 (28.96%) (init = 0.2)\n",
+      "    f1_A:     -74257366.0 +/- 3488149.25 (4.70%) (init = -5.659197e+07)\n",
+      "[[Correlations]] (unreported correlations are < 0.250)\n",
+      "    C(f0_A, f1_A)     = -0.9337\n",
+      "    C(f0_gamma, f1_A) = -0.9175\n",
+      "    C(f0_A, f0_gamma) = +0.7549\n",
+      "otherpalce Parameters([('f0_A', <Parameter 'f0_A', value=-inf, bounds=[-inf:inf]>), ('f0_x0', <Parameter 'f0_x0', value=-inf, bounds=[-inf:inf]>), ('f0_gamma', <Parameter 'f0_gamma', value=-inf, bounds=[-inf:inf]>), ('f1_A', <Parameter 'f1_A', value=-inf, bounds=[-inf:inf]>)])\n",
+      "thefuuuuTable <PyQt5.QtWidgets.QTableWidget object at 0x000002C1F4C97770>\n",
+      "count 6\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20D40>\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D21E20>\n",
+      "f0_A -56591974.51984634\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20DD0>\n",
+      "f0_x0 49.96666666665798\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20EF0>\n",
+      "f0_gamma 0.2\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D23BF0>\n",
+      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20E60>\n",
+      "f1_A -56591974.51984634\n",
+      "[[Model]]\n",
+      "    ((Model(zero) + Model(lorentzian, prefix='f0_')) + Model(constant, prefix='f1_'))\n",
+      "[[Fit Statistics]]\n",
+      "    # fitting method   = leastsq\n",
+      "    # function evals   = 157\n",
+      "    # data points      = 20\n",
+      "    # variables        = 4\n",
+      "    chi-square         = 8.9082e+13\n",
+      "    reduced chi-square = 5.5676e+12\n",
+      "    Akaike info crit   = 590.496992\n",
+      "    Bayesian info crit = 594.479921\n",
+      "    R-squared          = 0.81278004\n",
+      "[[Variables]]\n",
+      "    f0_A:      17291184.6 +/- 3177500.66 (18.38%) (init = -5.659197e+07)\n",
+      "    f0_x0:     80.6176787 +/- 10.0409995 (12.46%) (init = 49.96667)\n",
+      "    f0_gamma:  151.821274 +/- 43.9700666 (28.96%) (init = 0.2)\n",
+      "    f1_A:     -74257366.0 +/- 3488149.25 (4.70%) (init = -5.659197e+07)\n",
+      "[[Correlations]] (unreported correlations are < 0.250)\n",
+      "    C(f0_A, f1_A)     = -0.9337\n",
+      "    C(f0_gamma, f1_A) = -0.9175\n",
+      "    C(f0_A, f0_gamma) = +0.7549\n"
+     ]
+    }
+   ],
+   "source": [
+    "from mpes_tools.fit_panel_single import fit_panel_single\n",
+    "%gui qt\n",
+    "graph_window=fit_panel_single(-data_array)\n",
+    "graph_window.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "721a63f3",
+   "metadata": {},
    "outputs": [],
    "source": []
   }

From c688ac184153582b2b4f1e3f895a45f13d9dcc85 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 15 Apr 2025 20:32:19 +0200
Subject: [PATCH 20/67] added a test file for fit panel single

---
 tests/fit_panel_signle_test.py | 576 +++++++++++++++++++++++++++++++++
 1 file changed, 576 insertions(+)
 create mode 100644 tests/fit_panel_signle_test.py

diff --git a/tests/fit_panel_signle_test.py b/tests/fit_panel_signle_test.py
new file mode 100644
index 0000000..4d828fb
--- /dev/null
+++ b/tests/fit_panel_signle_test.py
@@ -0,0 +1,576 @@
+import sys
+from PyQt5.QtGui import QBrush, QColor
+from PyQt5.QtWidgets import QTextEdit, QLineEdit,QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, QWidget, QSlider, QLabel, QAction, QCheckBox, QPushButton, QListWidget, QTableWidget, QTableWidgetItem, QTableWidget, QCheckBox, QSplitter
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import QTableWidgetItem, QHBoxLayout, QCheckBox, QWidget
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+import matplotlib.pyplot as plt
+from scipy.optimize import curve_fit
+import numpy as np
+from lmfit.models import ExpressionModel,Model
+from lmfit import CompositeModel, Model
+from lmfit.lineshapes import gaussian, step
+import inspect
+from mpes_tools.movable_vertical_cursors_graph import MovableCursors
+from mpes_tools.make_model import make_model
+from mpes_tools.graphs import showgraphs
+from numpy import loadtxt
+import xarray as xr
+
+
+class fit_panel_single(QMainWindow):
+    def __init__(self):
+        super().__init__()
+
+        self.setWindowTitle("Main Window")
+        self.setGeometry(100, 100, 1500, 800)
+        
+        # Create a menu bar
+        menu_bar = self.menuBar()
+
+        # Create a 'View' menu
+        view_menu = menu_bar.addMenu("View")
+
+        # Create actions for showing and hiding the graph window
+        clear_graph_action = QAction("Show Graph", self)
+        clear_graph_action.triggered.connect(self.clear_graph_window)
+        view_menu.addAction(clear_graph_action)
+
+        # Store references to graph windows to prevent garbage collection
+        self.graph_windows = []
+
+        # Create a central widget
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+
+        # Create a layout for the central widget
+        layout = QHBoxLayout()
+        central_widget.setLayout(layout)
+
+        # Create a splitter for two panels
+        splitter = QSplitter(Qt.Horizontal)
+
+        # Create a left panel widget and its layout
+        left_panel = QWidget()
+        left_layout = QVBoxLayout()
+        left_panel.setLayout(left_layout)
+
+        # Create a right panel widget and its layout
+        right_panel = QWidget()
+        right_layout = QVBoxLayout()
+        right_panel.setLayout(right_layout)
+
+        # Add the panels to the splitter
+        splitter.addWidget(left_panel)
+        splitter.addWidget(right_panel)
+        
+        self.figure, self.axis = plt.subplots()
+        plt.close(self.figure)
+        self.canvas = FigureCanvas(self.figure)
+        # Create two checkboxes
+        self.checkbox0 = QCheckBox("Cursors")
+        self.checkbox0.stateChanged.connect(self.checkbox0_changed)
+        
+
+        # Create two checkboxes
+        self.checkbox1 = QCheckBox("Multiply with Fermi Dirac")
+        self.checkbox1.stateChanged.connect(self.checkbox1_changed)
+
+        self.checkbox2 = QCheckBox("Convolve with a Gaussian")
+        self.checkbox2.stateChanged.connect(self.checkbox2_changed)
+        
+        self.checkbox3 = QCheckBox("add background offset")
+        self.checkbox3.stateChanged.connect(self.checkbox3_changed)
+
+        
+        self.guess_button = QPushButton("Guess")
+        self.guess_button.clicked.connect(self.button_guess_clicked)
+        
+        bigger_layout = QVBoxLayout()
+        bigger_layout.addWidget(self.guess_button)
+        # Create a QListWidget
+        self.list_widget = QListWidget()
+        self.list_widget.addItems(["linear","Lorentz", "Gauss", "sinusoid","constant","jump"])
+        self.list_widget.setMaximumSize(120,150)
+        self.list_widget.itemClicked.connect(self.item_selected)
+
+        self.add_button = QPushButton("add")
+        self.add_button.clicked.connect(self.button_add_clicked)
+        
+        self.remove_button = QPushButton("remove")
+        self.remove_button.clicked.connect(self.button_remove_clicked)
+        
+
+        self.graph_button = QPushButton("clear graph")
+        self.graph_button.clicked.connect(self.clear_graph_window)
+        
+        self.fit_button = QPushButton("Fit")
+        self.fit_button.clicked.connect(self.fit)
+
+
+        
+        left_buttons=QVBoxLayout()
+        left_sublayout=QHBoxLayout()
+        
+        left_buttons.addWidget(self.add_button)
+        left_buttons.addWidget(self.remove_button)
+        left_buttons.addWidget(self.graph_button)
+        left_buttons.addWidget(self.fit_button)
+
+        
+        left_sublayout.addWidget(self.list_widget)
+        left_sublayout.addLayout(left_buttons) 
+
+        # Add widgets to the left layout
+        left_layout.addWidget(self.canvas)
+        left_layout.addWidget(self.checkbox0)
+        left_layout.addLayout(left_sublayout) 
+        
+        
+        self.text_equation = QTextEdit()
+        # self.text_equation.setMinimumSize(50, 50)  # Set minimum size
+        self.text_equation.setMaximumSize(500, 30)  # Set maximum size
+        
+        # Create a table widget for the right panel
+        self.table_widget = QTableWidget(0, 4)  # 6 rows and 4 columns (including the special row)
+        self.table_widget.setHorizontalHeaderLabels(['min', 'value', 'max', 'fix'])
+        # self.table_widget.setVerticalHeaderLabels(['Row 1', 'The ROW', 'Row 2', 'Row 3', 'Row 4', 'Row 5'])
+        self.table_widget.itemChanged.connect(self.table_item_changed)
+        self.table_widget.setMaximumSize(700,500)
+        # Add checkboxes to the last column of the table, except for the special row
+        for row in range(6):
+            if row != 1:  # Skip 'The ROW'
+                checkbox_widget = QWidget()
+                checkbox_layout = QHBoxLayout()
+                checkbox_layout.setAlignment(Qt.AlignCenter)
+                checkbox = QCheckBox()
+                checkbox_layout.addWidget(checkbox)
+                checkbox_widget.setLayout(checkbox_layout)
+                self.table_widget.setCellWidget(row, 3, checkbox_widget)
+
+        # Set 'The ROW' with uneditable empty cells
+        for col in range(4):
+            # if col == 3:  # Skip the checkbox column for 'The ROW'
+            #     continue
+            item = QTableWidgetItem('')
+            item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
+            self.table_widget.setItem(1, col, item)
+
+        # Add the table to the right layout
+        checkboxes=QVBoxLayout()
+        top_lay = QHBoxLayout()
+        above_table=QVBoxLayout()
+        checkboxes.addWidget(self.checkbox1)
+        checkboxes.addWidget(self.checkbox2)
+        checkboxes.addWidget(self.checkbox3)
+        top_lay.addWidget(self.text_equation)
+        top_lay.addLayout(checkboxes)
+        above_table.addLayout(top_lay)
+        above_table.addLayout(bigger_layout)
+        right_layout.addLayout(above_table)
+        right_layout.addWidget(self.table_widget)
+
+        # Add the splitter to the main layout
+        layout.addWidget(splitter)
+        def zero(x):
+            return 0
+        self.equation= None
+        self.mod= Model(zero)
+        self.total_function=zero
+        self.function_before_Fermi= zero
+        self.function_before_convoluted= zero
+        self.update_text_edit_boxes()
+        self.i=0
+        
+        self.function_list=[]
+        self.function_names_list=[]
+        self.cursor_handler = None
+        self.FD_state = False
+        self.CV_state = False
+        self.t0_state = False
+        self.offset_state = False
+        self.dim='delay'
+        # self.data=data
+        # self.y=data
+        # self.dim=self.data.dims[0]
+        self.plot_graph()
+
+    def plot_graph(self):
+        self.axis.clear()
+        data= loadtxt('//nap33/wahada/data_CVS_new/11626/vhs3/position2025-03-13_173331.txt')
+        dim='delay'
+        title='peak'
+        self.y = xr.DataArray(
+            data=data[:,1],
+            dims=[dim],                # e.g., 'energy', 'time', etc.
+            coords={dim: data[:,0]},
+            name=title                      # Optional: give it a name (like the plot title)
+        )
+        self.y.plot(ax=self.axis)
+        if self.checkbox0.isChecked():
+            if self.cursor_handler is None:
+                self.cursor_handler = MovableCursors(self.axis)
+            else:
+                self.cursor_handler.redraw()
+        self.figure.tight_layout()
+        self.canvas.draw()
+    def update_text_edit_boxes(self):
+        self.text_equation.setPlaceholderText("Top Right Text Edit Box")
+    
+    def offset_function (self,x,offset):
+        return 0*x+offset    
+    def constant (self,x,A):
+        return 0*x+A
+    def linear (self,x,a,b):
+        return a*x+b
+    def lorentzian(self,x, A, x0, gamma):
+        c=0.0000
+        return A / (1 + ((x - x0) / (gamma+c)) ** 2)
+    def fermi_dirac(self,x, mu, T):
+        kb = 8.617333262145 * 10**(-5)  # Boltzmann constant in eV/K
+        return 1 / (1 + np.exp((x - mu) / (kb * T)))
+    def gaussian(self,x,A, x0, gamma):
+        return A* np.exp(-(x -x0)**2 / (2 * gamma**2))
+    def gaussian_conv(self,x,sigma):
+        return  np.exp(-(x)**2 / (2 * sigma**2))
+    def jump(self,x, mid):
+        """Heaviside step function."""
+        o = np.zeros(x.size)
+        imid = max(np.where(x <= mid)[0])
+        o[imid:] = 1.0
+        return o
+    def jump2(self,x, mid,Amp):
+        """Heaviside step function."""
+        o = np.zeros(x.size)
+        imid = max(np.where(x <= mid)[0])
+        o[:imid] = Amp
+        return o
+
+    def centered_kernel(self,x, sigma):
+        mean = x.mean()
+        return np.exp(-(x-mean)**2/(2*sigma/2.3548200)**2)
+
+    def convolve(self,arr, kernel):
+        """Simple convolution of two arrays."""
+        npts = min(arr.size, kernel.size)
+        pad = np.ones(npts)
+        tmp = np.concatenate((pad*arr[0], arr, pad*arr[-1]))
+        out = np.convolve(tmp, kernel/kernel.sum(), mode='valid')
+        noff = int((len(out) - npts) / 2)
+        return out[noff:noff+npts]
+    
+    
+    def convolution(x, func, *args, sigma=1.0):
+            N = 20  # Assuming N is intended to be a local variable here
+            x_step = x[1] - x[0]
+            
+            # Create the shifted input signal 'y' for convolution
+            y = np.zeros(N + len(x))
+            for i in range(N):
+                y[i] = x[0] - (N - i) * x_step
+            y[N:] = x  # Append the original signal x to y
+            
+            # Create the Gaussian kernel
+            x_gauss = np.linspace(-0.5, 0.5, len(x))
+            gaussian_values = np.exp(-0.5 * (x_gauss / sigma)**2) / (sigma * np.sqrt(2 * np.pi))
+            
+            # Evaluate the function values with parameters
+            function_values = func(x, *args)
+            
+            # Perform convolution
+            convolution_result = np.convolve(function_values, gaussian_values, mode='same')
+            
+            return convolution_result[N-1:-1]
+    
+
+    def clear_graph_window(self):
+        self.axis.clear()
+        self.plot_graph()
+        
+    def checkbox0_changed(self, state):
+        if state == Qt.Checked:
+            if self.cursor_handler is None:
+                self.cursor_handler = MovableCursors(self.axis)
+                self.canvas.draw()
+            else:
+                self.cursor_handler.redraw()
+        else:
+            self.cursor_handler.remove()
+    
+    def checkbox1_changed(self, state):
+        if self.CV_state== True:
+            pos=2
+        else:
+            pos=0
+        if state == Qt.Checked:
+            self.FD_state = True
+            self.update_equation()
+            self.table_widget.insertRow(pos)
+            label_item = QTableWidgetItem("Fermi")
+            self.table_widget.setVerticalHeaderItem(pos, label_item)
+            for col in range(4):
+                item = QTableWidgetItem('')
+                item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
+                self.table_widget.setItem(pos, col, item)
+                item.setBackground(QBrush(QColor('grey')))
+            c=self.table_widget.rowCount()
+            self.table_widget.insertRow(pos+1)
+            label_item1 = QTableWidgetItem("Fermi level")
+            checkbox_widget = QWidget()
+            checkbox_layout = QHBoxLayout()
+            checkbox_layout.setAlignment(Qt.AlignCenter)
+            checkbox = QCheckBox()
+            checkbox.stateChanged.connect(lambda state, row= pos+1: self.handle_checkbox_state_change(state, row))
+            # print('thecount',c+1)
+            checkbox_layout.addWidget(checkbox)
+            checkbox_widget.setLayout(checkbox_layout)
+            self.table_widget.setCellWidget(pos+1, 3, checkbox_widget)
+            self.table_widget.setVerticalHeaderItem(pos+1, label_item1)
+            
+            self.table_widget.insertRow(pos+2)
+            label_item2 = QTableWidgetItem("Temperature")
+            checkbox_widget = QWidget()
+            checkbox_layout = QHBoxLayout()
+            checkbox_layout.setAlignment(Qt.AlignCenter)
+            checkbox = QCheckBox()
+            checkbox.stateChanged.connect(lambda state, row= pos+2: self.handle_checkbox_state_change(state, row))
+            checkbox_layout.addWidget(checkbox)
+            checkbox_widget.setLayout(checkbox_layout)
+            self.table_widget.setCellWidget(pos+2, 3, checkbox_widget)
+            self.table_widget.setVerticalHeaderItem(pos+2, label_item2)
+        else:
+            self.FD_state = False
+            self.update_equation()
+            # print("Checkbox 1 is unchecked")
+            
+            self.table_widget.removeRow(pos)
+            self.table_widget.removeRow(pos)
+            self.table_widget.removeRow(pos)
+            
+    def checkbox2_changed(self, state):
+        if state == Qt.Checked:
+            self.CV_state = True
+            
+            self.update_equation()
+
+            self.table_widget.insertRow(0)
+            label_item = QTableWidgetItem("Convolution")
+            self.table_widget.setVerticalHeaderItem(0, label_item)
+            # self.table_widget.setVerticalHeaderItem(0, new_row_name)
+            for col in range(4):
+                item = QTableWidgetItem('')
+                item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
+                self.table_widget.setItem(0, col, item)
+                item.setBackground(QBrush(QColor('grey')))
+                
+            self.table_widget.insertRow(1)
+            label_item1 = QTableWidgetItem("sigma")
+            checkbox_widget = QWidget()
+            checkbox_layout = QHBoxLayout()
+            checkbox_layout.setAlignment(Qt.AlignCenter)
+            checkbox = QCheckBox()
+            checkbox.stateChanged.connect(lambda state, row= 1: self.handle_checkbox_state_change(state, row))
+            checkbox_layout.addWidget(checkbox)
+            checkbox_widget.setLayout(checkbox_layout)
+            self.table_widget.setCellWidget(1, 3, checkbox_widget)
+            self.table_widget.setVerticalHeaderItem(1, label_item1)
+            
+        else:
+            self.CV_state = False
+            self.update_equation()
+            # print("Checkbox 1 is unchecked")
+            
+            self.table_widget.removeRow(0)
+            self.table_widget.removeRow(0)
+    def checkbox3_changed(self, state):
+        if state == Qt.Checked:
+            self.offset_state=True
+        else:
+            self.offset_state=False
+        
+    def item_selected(self, item):
+        # print(f"Selected: {item.text()}")
+        if item.text() == 'Lorentz':
+            self.function_selected = self.lorentzian
+        elif item.text() == 'Gauss':
+            self.function_selected = self.gaussian 
+        elif item.text()=='linear':
+            self.function_selected =self.linear
+        elif item.text()=='constant':
+            self.function_selected =self.constant
+        elif item.text()=='jump':
+            self.function_selected =self.jump2
+        
+    def button_guess_clicked(self):
+        cursors= self.cursor_handler.cursors()
+        self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+        self.x_f=self.y_f[self.dim]
+        max_value= self.y_f.data.max()
+        min_value= self.y_f.data.min()
+        mean_value= self.y_f.data.mean()
+        max_arg=self.y_f.data.argmax()
+        # print(self.x_f[max_arg].item())
+        for row in range(self.table_widget.rowCount()):
+            header_item = self.table_widget.verticalHeaderItem(row)
+            if "A" in header_item.text():
+                self.params[header_item.text()].set(value=max_value)
+                item = QTableWidgetItem(str(max_value))
+                self.table_widget.setItem(row, 1, item)
+            elif "x0" in header_item.text():
+                self.params[header_item.text()].set(value=self.x_f[max_arg].item())
+                item = QTableWidgetItem(str(self.x_f[max_arg].item()))
+                self.table_widget.setItem(row, 1, item)
+            elif "gamma" in header_item.text():
+                self.params[header_item.text()].set(value=0.2)
+                item = QTableWidgetItem(str(0.2))
+                self.table_widget.setItem(row, 1, item)
+
+            
+    
+    def button_remove_clicked(self):
+        if self.i>0:
+            self.i-=1
+        current_row_count = self.table_widget.rowCount()
+        sig = inspect.signature(self.function_list[-1])
+        params = sig.parameters
+        
+        for p in range(len(params)):
+            self.table_widget.removeRow(current_row_count-1-p)    
+            
+        self.function_list.remove(self.function_list[-1])
+        self.function_names_list.remove(self.function_names_list[-1])
+        self.update_equation()
+        self.create()
+
+    def button_add_clicked(self):
+        def zero(x):
+            return 0
+        
+        
+        self.i+=1
+        self.function_list.append(self.function_selected)
+        self.function_names_list.append(self.list_widget.currentItem().text())
+        j=0
+        for p in self.function_list:
+            current_function=Model(p,prefix='f'+str(j)+'_')
+            j+=1
+            
+        
+        current_row_count = self.table_widget.rowCount()
+        
+        self.table_widget.insertRow(current_row_count)
+        new_row_name = QTableWidgetItem(self.list_widget.currentItem().text())
+        self.table_widget.setVerticalHeaderItem(current_row_count, new_row_name)
+        for col in range(4):
+            item = QTableWidgetItem('')
+            item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
+            self.table_widget.setItem(current_row_count, col, item)
+            item.setBackground(QBrush(QColor('grey')))
+        c=current_row_count
+        for p in range(len(current_function.param_names)):
+
+            self.table_widget.insertRow(c+p+1)
+            # print(current_function.param_names[p])
+            new_row_name = QTableWidgetItem(current_function.param_names[p])
+            self.table_widget.setVerticalHeaderItem(c+p+1, new_row_name)
+            checkbox_widget = QWidget()
+            checkbox_layout = QHBoxLayout()
+            checkbox_layout.setAlignment(Qt.AlignCenter)
+            checkbox = QCheckBox()
+            checkbox.stateChanged.connect(lambda state, row=c + p + 1: self.handle_checkbox_state_change(state, row))
+            checkbox_layout.addWidget(checkbox)
+            checkbox_widget.setLayout(checkbox_layout)
+            self.table_widget.setCellWidget(c+p+1, 3, checkbox_widget)
+        
+        self.update_equation()
+        self.create()
+        
+    def update_equation(self):
+        self.equation=''
+        # print('names',self.function_names_list)
+        for j,n in enumerate(self.function_names_list):
+            if len(self.function_names_list)==1:
+                self.equation= n
+            else:
+                if j==0:
+                    self.equation= n
+                else:
+                    self.equation+= '+' + n
+        if self.FD_state:
+            self.equation= '('+ self.equation+ ')* Fermi_Dirac'
+        self.text_equation.setPlainText(self.equation)
+        # print('equation',self.equation)
+    
+
+    def table_item_changed(self, item):
+        # print(f"Table cell changed at ({item.row()}, {item.column()}): {item.text()}")
+        header_item = self.table_widget.verticalHeaderItem(item.row())
+        # print('theeeeeeitem=',item.text())
+        
+    def handle_checkbox_state_change(self,state,row):
+        if state == Qt.Checked:
+            header_item = self.table_widget.verticalHeaderItem(row)
+            
+        else:
+            header_item = self.table_widget.verticalHeaderItem(row)
+    def create(self):
+        def zero(x):
+            return 0
+        cursors= self.cursor_handler.cursors()
+        self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+        self.x_f=self.y_f[self.dim]
+        # print(self.y_f)
+        if self.offset_state==True:
+            self.params['offset'].set(value=self.y_f.data.min())
+        list_axis=[[self.y[self.dim]],[self.x_f]]
+        self.mod= Model(zero)
+        j=0
+        for f in self.function_list:
+            self.mod+=Model(f,prefix='f'+str(j)+'_')
+            j+=1
+        if self.FD_state == True:
+            self.mod= self.mod* Model(self.fermi_dirac)
+        if self.CV_state == True:
+            self.mod = CompositeModel(self.mod, Model(self.centered_kernel), self.convolve)
+        if self.offset_state==True:
+            self.mod= self.mod+Model(self.offset_function)
+        m1=make_model(self.mod, self.table_widget)
+        self.mod=m1.current_model()
+        self.params=m1.current_params()
+    def fit(self):
+        
+        def zero(x):
+            return 0
+        self.mod= Model(zero)
+        cursors= self.cursor_handler.cursors()
+        j=0
+        for f in self.function_list:
+            self.mod+=Model(f,prefix='f'+str(j)+'_')
+            j+=1
+        if self.FD_state == True:
+            self.mod= self.mod* Model(self.fermi_dirac)
+        if self.CV_state == True:
+            self.mod = CompositeModel(self.mod, Model(self.centered_kernel), self.convolve)
+        if self.offset_state==True:
+            self.mod= self.mod+Model(self.offset_function)
+        m1=make_model(self.mod, self.table_widget)
+        self.mod=m1.current_model()
+        self.params=m1.current_params()
+        self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
+        self.x_f=self.y_f[self.dim]
+        if self.offset_state==True:
+            self.params['offset'].set(value=self.y_f.data.min())
+        # print(self.params)
+        out = self.mod.fit(self.y_f, self.params, x=self.x_f)
+        print(out.fit_report(min_correl=0.25))
+        self.axis.plot(self.x_f,out.best_fit,color='red',label='fit')
+        self.figure.tight_layout()
+        self.canvas.draw()
+        
+    
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    window = fit_panel_single()
+    window.show()
+    sys.exit(app.exec_())

From f29c4527b63bda68ac7aeec9268d35a2f05edb8d Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Wed, 16 Apr 2025 11:05:40 +0200
Subject: [PATCH 21/67] cleaned up a bit

---
 src/mpes_tools/make_model.py | 20 +++++---------------
 1 file changed, 5 insertions(+), 15 deletions(-)

diff --git a/src/mpes_tools/make_model.py b/src/mpes_tools/make_model.py
index 940b1e2..c88353b 100644
--- a/src/mpes_tools/make_model.py
+++ b/src/mpes_tools/make_model.py
@@ -1,28 +1,18 @@
-import sys
-from PyQt5.QtGui import QBrush, QColor
-from PyQt5.QtWidgets import QTextEdit, QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, QWidget, QSlider, QLabel, QAction, QCheckBox, QPushButton, QListWidget, QTableWidget, QTableWidgetItem, QTableWidget, QCheckBox, QSplitter
-from PyQt5.QtCore import Qt
-from PyQt5.QtWidgets import QTableWidgetItem, QHBoxLayout, QCheckBox, QWidget
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
-import matplotlib.pyplot as plt
-
 
+from PyQt5.QtWidgets import  QCheckBox
 
 class make_model:
-    # from matplotlib.widgets import CheckButtons, Button
-    # %matplotlib qt
-    
     def __init__(self,mod,table_widget):
         
         self.mod=mod
         self.params=mod.make_params()
-        print('otherpalce',self.params)
-        print('thefuuuuTable',table_widget)
-        print('count',table_widget.rowCount())
+        # print('otherpalce',self.params)
+        # print('thefuuuuTable',table_widget)
+        # print('count',table_widget.rowCount())
         for row in range(table_widget.rowCount()):
             item = table_widget.item(row, 1)
             checkbox_widget = table_widget.cellWidget(row, 3)
-            print('tableitenm=',item)
+            # print('tableitenm=',item)
             if item is not None and item.text().strip():
                 header_item = table_widget.verticalHeaderItem(item.row())
                 checkbox=checkbox_widget.findChild(QCheckBox)

From 9a5f4cddc2245def54d4d89ec9597da17c25f8a5 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Wed, 16 Apr 2025 11:06:18 +0200
Subject: [PATCH 22/67] cleaned up tutorial

---
 tutorials/template.ipynb | 129 ++++++---------------------------------
 1 file changed, 19 insertions(+), 110 deletions(-)

diff --git a/tutorials/template.ipynb b/tutorials/template.ipynb
index cf8de32..3fbe5d4 100644
--- a/tutorials/template.ipynb
+++ b/tutorials/template.ipynb
@@ -122,7 +122,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 1,
    "id": "a6a92293",
    "metadata": {},
    "outputs": [
@@ -141,13 +141,6 @@
      },
      "metadata": {},
      "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "results extracted!\n"
-     ]
     }
    ],
    "source": [
@@ -261,7 +254,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "id": "e74ff8ab",
    "metadata": {},
    "outputs": [],
@@ -280,17 +273,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "id": "2c6bc231",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x2c1e2170ad0>]"
+       "[<matplotlib.lines.Line2D at 0x1f9feb27b90>]"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -314,7 +307,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "08f327a9",
    "metadata": {},
    "outputs": [
@@ -322,114 +315,30 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "otherpalce Parameters([('f0_A', <Parameter 'f0_A', value=-inf, bounds=[-inf:inf]>), ('f0_x0', <Parameter 'f0_x0', value=-inf, bounds=[-inf:inf]>), ('f0_gamma', <Parameter 'f0_gamma', value=-inf, bounds=[-inf:inf]>), ('f1_A', <Parameter 'f1_A', value=-inf, bounds=[-inf:inf]>)])\n",
-      "thefuuuuTable <PyQt5.QtWidgets.QTableWidget object at 0x000002C1F4C97770>\n",
-      "count 6\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20D40>\n",
-      "tableitenm= None\n",
-      "tableitenm= None\n",
-      "tableitenm= None\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D23BF0>\n",
-      "tableitenm= None\n",
-      "otherpalce Parameters([('f0_A', <Parameter 'f0_A', value=-inf, bounds=[-inf:inf]>), ('f0_x0', <Parameter 'f0_x0', value=-inf, bounds=[-inf:inf]>), ('f0_gamma', <Parameter 'f0_gamma', value=-inf, bounds=[-inf:inf]>), ('f1_A', <Parameter 'f1_A', value=-inf, bounds=[-inf:inf]>)])\n",
-      "thefuuuuTable <PyQt5.QtWidgets.QTableWidget object at 0x000002C1F4C97770>\n",
-      "count 6\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20D40>\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D21E20>\n",
-      "f0_A -56591974.51984634\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20DD0>\n",
-      "f0_x0 49.96666666665798\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20EF0>\n",
-      "f0_gamma 0.2\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D23BF0>\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20E60>\n",
-      "f1_A -56591974.51984634\n",
-      "[[Model]]\n",
-      "    ((Model(zero) + Model(lorentzian, prefix='f0_')) + Model(constant, prefix='f1_'))\n",
-      "[[Fit Statistics]]\n",
-      "    # fitting method   = leastsq\n",
-      "    # function evals   = 55\n",
-      "    # data points      = 19\n",
-      "    # variables        = 4\n",
-      "    chi-square         = 3.6520e+14\n",
-      "    reduced chi-square = 2.4347e+13\n",
-      "    Akaike info crit   = 589.153518\n",
-      "    Bayesian info crit = 592.931274\n",
-      "    R-squared          = -6.2400e-09\n",
-      "##  Warning: uncertainties could not be estimated:\n",
-      "[[Variables]]\n",
-      "    f0_A:     -39908756.3 (init = -5.659197e+07)\n",
-      "    f0_x0:     67.0313375 (init = 49.96667)\n",
-      "    f0_gamma: -2.0575e-05 (init = 0.2)\n",
-      "    f1_A:     -63112224.4 (init = -5.659197e+07)\n",
-      "otherpalce Parameters([('f0_A', <Parameter 'f0_A', value=-inf, bounds=[-inf:inf]>), ('f0_x0', <Parameter 'f0_x0', value=-inf, bounds=[-inf:inf]>), ('f0_gamma', <Parameter 'f0_gamma', value=-inf, bounds=[-inf:inf]>), ('f1_A', <Parameter 'f1_A', value=-inf, bounds=[-inf:inf]>)])\n",
-      "thefuuuuTable <PyQt5.QtWidgets.QTableWidget object at 0x000002C1F4C97770>\n",
-      "count 6\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20D40>\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D21E20>\n",
-      "f0_A -56591974.51984634\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20DD0>\n",
-      "f0_x0 49.96666666665798\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20EF0>\n",
-      "f0_gamma 0.2\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D23BF0>\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20E60>\n",
-      "f1_A -56591974.51984634\n",
-      "[[Model]]\n",
-      "    ((Model(zero) + Model(lorentzian, prefix='f0_')) + Model(constant, prefix='f1_'))\n",
-      "[[Fit Statistics]]\n",
-      "    # fitting method   = leastsq\n",
-      "    # function evals   = 157\n",
-      "    # data points      = 20\n",
-      "    # variables        = 4\n",
-      "    chi-square         = 8.9082e+13\n",
-      "    reduced chi-square = 5.5676e+12\n",
-      "    Akaike info crit   = 590.496992\n",
-      "    Bayesian info crit = 594.479921\n",
-      "    R-squared          = 0.81278004\n",
-      "[[Variables]]\n",
-      "    f0_A:      17291184.6 +/- 3177500.66 (18.38%) (init = -5.659197e+07)\n",
-      "    f0_x0:     80.6176787 +/- 10.0409995 (12.46%) (init = 49.96667)\n",
-      "    f0_gamma:  151.821274 +/- 43.9700666 (28.96%) (init = 0.2)\n",
-      "    f1_A:     -74257366.0 +/- 3488149.25 (4.70%) (init = -5.659197e+07)\n",
-      "[[Correlations]] (unreported correlations are < 0.250)\n",
-      "    C(f0_A, f1_A)     = -0.9337\n",
-      "    C(f0_gamma, f1_A) = -0.9175\n",
-      "    C(f0_A, f0_gamma) = +0.7549\n",
-      "otherpalce Parameters([('f0_A', <Parameter 'f0_A', value=-inf, bounds=[-inf:inf]>), ('f0_x0', <Parameter 'f0_x0', value=-inf, bounds=[-inf:inf]>), ('f0_gamma', <Parameter 'f0_gamma', value=-inf, bounds=[-inf:inf]>), ('f1_A', <Parameter 'f1_A', value=-inf, bounds=[-inf:inf]>)])\n",
-      "thefuuuuTable <PyQt5.QtWidgets.QTableWidget object at 0x000002C1F4C97770>\n",
-      "count 6\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20D40>\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D21E20>\n",
       "f0_A -56591974.51984634\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20DD0>\n",
       "f0_x0 49.96666666665798\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20EF0>\n",
       "f0_gamma 0.2\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D23BF0>\n",
-      "tableitenm= <PyQt5.QtWidgets.QTableWidgetItem object at 0x000002C1F4D20E60>\n",
       "f1_A -56591974.51984634\n",
       "[[Model]]\n",
       "    ((Model(zero) + Model(lorentzian, prefix='f0_')) + Model(constant, prefix='f1_'))\n",
       "[[Fit Statistics]]\n",
       "    # fitting method   = leastsq\n",
-      "    # function evals   = 157\n",
-      "    # data points      = 20\n",
+      "    # function evals   = 153\n",
+      "    # data points      = 23\n",
       "    # variables        = 4\n",
-      "    chi-square         = 8.9082e+13\n",
-      "    reduced chi-square = 5.5676e+12\n",
-      "    Akaike info crit   = 590.496992\n",
-      "    Bayesian info crit = 594.479921\n",
-      "    R-squared          = 0.81278004\n",
+      "    chi-square         = 1.0164e+14\n",
+      "    reduced chi-square = 5.3495e+12\n",
+      "    Akaike info crit   = 677.690125\n",
+      "    Bayesian info crit = 682.232101\n",
+      "    R-squared          = 0.80470402\n",
       "[[Variables]]\n",
-      "    f0_A:      17291184.6 +/- 3177500.66 (18.38%) (init = -5.659197e+07)\n",
-      "    f0_x0:     80.6176787 +/- 10.0409995 (12.46%) (init = 49.96667)\n",
-      "    f0_gamma:  151.821274 +/- 43.9700666 (28.96%) (init = 0.2)\n",
-      "    f1_A:     -74257366.0 +/- 3488149.25 (4.70%) (init = -5.659197e+07)\n",
+      "    f0_A:      14279264.8 +/- 1652731.37 (11.57%) (init = -5.659197e+07)\n",
+      "    f0_x0:     72.1795700 +/- 9.80553399 (13.58%) (init = 49.96667)\n",
+      "    f0_gamma:  110.232241 +/- 26.3443714 (23.90%) (init = 0.2)\n",
+      "    f1_A:     -70606735.7 +/- 1511483.05 (2.14%) (init = -5.659197e+07)\n",
       "[[Correlations]] (unreported correlations are < 0.250)\n",
-      "    C(f0_A, f1_A)     = -0.9337\n",
-      "    C(f0_gamma, f1_A) = -0.9175\n",
-      "    C(f0_A, f0_gamma) = +0.7549\n"
+      "    C(f0_gamma, f1_A) = -0.8151\n",
+      "    C(f0_A, f1_A)     = -0.6389\n"
      ]
     }
    ],

From 8dea3c8c8d2ce2a3f535819d13ad1b86ad4924d9 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Wed, 16 Apr 2025 11:27:29 +0200
Subject: [PATCH 23/67] cleaning up additional prints and so on

---
 src/mpes_tools/fit_panel.py    |  6 +--
 src/mpes_tools/graphs.py       |  7 +---
 tests/fit_panel_signle_test.py |  7 ++--
 tutorials/template.ipynb       | 75 +++++++++++++++++++---------------
 4 files changed, 49 insertions(+), 46 deletions(-)

diff --git a/src/mpes_tools/fit_panel.py b/src/mpes_tools/fit_panel.py
index 1f2d292..4787487 100644
--- a/src/mpes_tools/fit_panel.py
+++ b/src/mpes_tools/fit_panel.py
@@ -808,16 +808,12 @@ def zero(x):
             for pname, par in self.params.items():
                 self.fit_results.append(getattr(self, pname)[:-self.dt])
                 names.append(pname)
-                print('dt>0')  
-                print(len(getattr(self, pname)))
         else:
             for pname, par in self.params.items():
                 self.fit_results.append(getattr(self, pname))
                 names.append(pname)
-                print('dt=0')  
-                print(len(getattr(self, pname)))
         # print('th dt',self.dt)    
-        print('the xaxis',len(self.data[self.data.dims[2]][:len(self.data[self.data.dims[2]])-self.dt]))
+        # print('the xaxis',len(self.data[self.data.dims[2]][:len(self.data[self.data.dims[2]])-self.dt]))
         sg=showgraphs(self.data[self.data.dims[2]][:len(self.data[self.data.dims[2]])-self.dt], self.fit_results,names,list_axis,list_plot_fits)
         sg.show()
         self.graph_windows.append(sg)
diff --git a/src/mpes_tools/graphs.py b/src/mpes_tools/graphs.py
index 214cc06..2bef341 100644
--- a/src/mpes_tools/graphs.py
+++ b/src/mpes_tools/graphs.py
@@ -24,7 +24,6 @@ def __init__(self, x, y_arrays,names,list_axis,list_plot_fits):
         central_widget = QWidget(self)
         self.setCentralWidget(central_widget)
         layout = QGridLayout(central_widget)
-        print('boo')
         
         # print(len(x),len(list_plot_fits))
         # print(list_plot_fits[0])
@@ -76,7 +75,6 @@ def __init__(self, x, y_arrays,names,list_axis,list_plot_fits):
             canvas.mpl_connect("button_press_event", handler.handle_double_click)
             self.click_handlers.append(handler)
             self.ax_list.append(ax)
-            print('in the main code'+f"self.ax id: {id(ax)}")
     def external_callback(self,ax):
         # print(f"External callback: clicked subplot ({i},{j})")
         for i, ax_item in enumerate(self.ax_list):
@@ -115,10 +113,7 @@ def create_plot_widget(self, data_array, title):
         plt.close(figure)
         data_array.plot(ax=ax)
         ax.set_title(title)
-        # ax.grid(True)
-        # ax.set_xlabel(self.dim)
-        # ax.set_ylabel('y')
-        print('create_plot'+f"self.ax id: {id(ax)}")
+        # print('create_plot'+f"self.ax id: {id(ax)}")
         # Create a FigureCanvas to embed in the Qt layout
         canvas = FigureCanvas(figure)
         toolbar = NavigationToolbar(canvas, self)
diff --git a/tests/fit_panel_signle_test.py b/tests/fit_panel_signle_test.py
index 4d828fb..1213d66 100644
--- a/tests/fit_panel_signle_test.py
+++ b/tests/fit_panel_signle_test.py
@@ -189,16 +189,17 @@ def zero(x):
         self.CV_state = False
         self.t0_state = False
         self.offset_state = False
-        self.dim='delay'
         # self.data=data
         # self.y=data
         # self.dim=self.data.dims[0]
+        self.dim='delay'
         self.plot_graph()
-
+        
+        
     def plot_graph(self):
         self.axis.clear()
         data= loadtxt('//nap33/wahada/data_CVS_new/11626/vhs3/position2025-03-13_173331.txt')
-        dim='delay'
+        dim= self.dim
         title='peak'
         self.y = xr.DataArray(
             data=data[:,1],
diff --git a/tutorials/template.ipynb b/tutorials/template.ipynb
index 3fbe5d4..301403c 100644
--- a/tutorials/template.ipynb
+++ b/tutorials/template.ipynb
@@ -164,7 +164,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 2,
    "id": "fe4ced28",
    "metadata": {},
    "outputs": [
@@ -174,18 +174,9 @@
        "5"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<Figure size 640x480 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -210,10 +201,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "5c78b3de",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "f0_A 68594891.74885073\n",
+      "f0_x0 -0.04113953488371891\n",
+      "f0_gamma 0.2\n"
+     ]
+    }
+   ],
    "source": [
     "#Use the fit panel on the extracted data\n",
     "from mpes_tools.fit_panel import fit_panel\n",
@@ -254,10 +255,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 4,
    "id": "e74ff8ab",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "\n",
     "import xarray as xr\n",
@@ -273,17 +284,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 5,
    "id": "2c6bc231",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1f9feb27b90>]"
+       "[<matplotlib.lines.Line2D at 0x2547aabe120>]"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -307,7 +318,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 6,
    "id": "08f327a9",
    "metadata": {},
    "outputs": [
@@ -323,22 +334,22 @@
       "    ((Model(zero) + Model(lorentzian, prefix='f0_')) + Model(constant, prefix='f1_'))\n",
       "[[Fit Statistics]]\n",
       "    # fitting method   = leastsq\n",
-      "    # function evals   = 153\n",
-      "    # data points      = 23\n",
+      "    # function evals   = 138\n",
+      "    # data points      = 25\n",
       "    # variables        = 4\n",
-      "    chi-square         = 1.0164e+14\n",
-      "    reduced chi-square = 5.3495e+12\n",
-      "    Akaike info crit   = 677.690125\n",
-      "    Bayesian info crit = 682.232101\n",
-      "    R-squared          = 0.80470402\n",
+      "    chi-square         = 1.0446e+14\n",
+      "    reduced chi-square = 4.9745e+12\n",
+      "    Akaike info crit   = 734.524718\n",
+      "    Bayesian info crit = 739.400221\n",
+      "    R-squared          = 0.80970692\n",
       "[[Variables]]\n",
-      "    f0_A:      14279264.8 +/- 1652731.37 (11.57%) (init = -5.659197e+07)\n",
-      "    f0_x0:     72.1795700 +/- 9.80553399 (13.58%) (init = 49.96667)\n",
-      "    f0_gamma:  110.232241 +/- 26.3443714 (23.90%) (init = 0.2)\n",
-      "    f1_A:     -70606735.7 +/- 1511483.05 (2.14%) (init = -5.659197e+07)\n",
+      "    f0_A:      13829756.4 +/- 1465794.12 (10.60%) (init = -5.659197e+07)\n",
+      "    f0_x0:     70.3869880 +/- 9.39332978 (13.35%) (init = 49.96667)\n",
+      "    f0_gamma:  103.001516 +/- 22.4624155 (21.81%) (init = 0.2)\n",
+      "    f1_A:     -70018457.3 +/- 1151952.86 (1.65%) (init = -5.659197e+07)\n",
       "[[Correlations]] (unreported correlations are < 0.250)\n",
-      "    C(f0_gamma, f1_A) = -0.8151\n",
-      "    C(f0_A, f1_A)     = -0.6389\n"
+      "    C(f0_gamma, f1_A) = -0.7681\n",
+      "    C(f0_A, f1_A)     = -0.5074\n"
      ]
     }
    ],

From ece76042acae0cbef3b2afe882ed0447999b8716 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?T=C3=BAlio=20de=20Castro?= <decastro@FHI.MPG.DE>
Date: Wed, 16 Apr 2025 11:45:11 +0200
Subject: [PATCH 24/67] I add a loading function for nexus files on Main.py

---
 src/mpes_tools/Main.py | 34 +++++++++++++++++++++++++++-------
 1 file changed, 27 insertions(+), 7 deletions(-)

diff --git a/src/mpes_tools/Main.py b/src/mpes_tools/Main.py
index eb9f0c0..74a7fbc 100644
--- a/src/mpes_tools/Main.py
+++ b/src/mpes_tools/Main.py
@@ -69,18 +69,38 @@ def __init__(self):
         self.show()
 
 
+        
     def open_file_phoibos(self):
-        file_path, _ = QFileDialog.getOpenFileName(self, "Open Text File", "", "Text Files (*.npz)")
-        if file_path: 
-            loaded_data = np.load(file_path)  
-        V1 = xr.DataArray(loaded_data['data_array'], dims=['Angle', 'Ekin','delay'], coords={'Angle': loaded_data['Angle'], 'Ekin': loaded_data['Ekin'],'delay': loaded_data['delay']})    
+        # ... existing code ...
+        file_path, _ = QFileDialog.getOpenFileName(self, "Open File", "", "Data Files (*.npz *.nxs)")
+        if file_path:
+            if file_path.endswith('.npz'):
+                loaded_data = np.load(file_path)
+                V1 = xr.DataArray(loaded_data['data_array'], 
+                                dims=['Angle', 'Ekin','delay'], 
+                                coords={'Angle': loaded_data['Angle'], 
+                                       'Ekin': loaded_data['Ekin'],
+                                       'delay': loaded_data['delay']})
+            elif file_path.endswith('.nxs'):
+                with h5py.File(file_path, 'r') as f:
+                    # Ajuste os caminhos dos dados de acordo com a estrutura do seu arquivo NeXus
+                    # Isso é um exemplo - você precisa adaptar para a estrutura específica do seu arquivo
+                    data_array = f['/entry/data/data'][:]  # Ajuste o caminho conforme necessário
+                    angle = f['/entry/data/angular0'][:]      # Ajuste o caminho conforme necessário
+                    energy = f['/entry/data/energy'][:]    # Ajuste o caminho conforme necessário
+                    delay = f['/entry/data/delay'][:]      # Ajuste o caminho conforme necessário
+                    
+                    V1 = xr.DataArray(data_array,
+                                    dims=['Angle', 'Ekin', 'delay'],
+                                    coords={'Angle': angle,
+                                           'Ekin': energy,
+                                           'delay': delay})
+
         axis=[V1['Angle'],V1['Ekin']-21.7,V1['delay']]
-        # print(data.dims)
         graph_window= Gui_3d(V1,0,0,'Phoibos')
-        
         graph_window.show()
         self.graph_windows.append(graph_window)
-        
+
     def open_file_dialoge(self):
         # Open file dialog to select a .h5 file
         file_path, _ = QFileDialog.getOpenFileName(self, "Open hdf5", "", "h5 Files (*.h5)")

From c87fc1ba6fb01a2e2b740b5f7ea67b832da35c64 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Wed, 16 Apr 2025 11:58:40 +0200
Subject: [PATCH 25/67] fixed the sinusoid fit function

---
 src/mpes_tools/fit_panel.py        | 7 ++++++-
 src/mpes_tools/fit_panel_single.py | 4 ++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/mpes_tools/fit_panel.py b/src/mpes_tools/fit_panel.py
index 4787487..e38e552 100644
--- a/src/mpes_tools/fit_panel.py
+++ b/src/mpes_tools/fit_panel.py
@@ -308,7 +308,10 @@ def jump2(self,x, mid,Amp):
         imid = max(np.where(x <= mid)[0])
         o[:imid] = Amp
         return o
-
+    
+    def sinusoid(self,x,A,omega,phi):
+        return  A* np.sin(omega*x+phi)
+    
     def centered_kernel(self,x, sigma):
         mean = x.mean()
         return np.exp(-(x-mean)**2/(2*sigma/2.3548200)**2)
@@ -482,6 +485,8 @@ def item_selected(self, item):
             self.function_selected =self.constant
         elif item.text()=='jump':
             self.function_selected =self.jump2
+        elif item.text()=='sinusoid':
+            self.function_selected =self.sinusoid
         
     def button_guess_clicked(self):
         cursors= self.cursor_handler.cursors()
diff --git a/src/mpes_tools/fit_panel_single.py b/src/mpes_tools/fit_panel_single.py
index 63d3235..0041491 100644
--- a/src/mpes_tools/fit_panel_single.py
+++ b/src/mpes_tools/fit_panel_single.py
@@ -235,6 +235,8 @@ def jump2(self,x, mid,Amp):
         imid = max(np.where(x <= mid)[0])
         o[:imid] = Amp
         return o
+    def sinusoid(self,x,A,omega,phi):
+        return  A* np.sin(omega*x+phi)
 
     def centered_kernel(self,x, sigma):
         mean = x.mean()
@@ -390,6 +392,8 @@ def item_selected(self, item):
             self.function_selected =self.constant
         elif item.text()=='jump':
             self.function_selected =self.jump2
+        elif item.text()=='sinusoid':
+            self.function_selected =self.sinusoid
         
     def button_guess_clicked(self):
         cursors= self.cursor_handler.cursors()

From 495a09d0381e200dc46bd981bb6062577533fa6e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?T=C3=BAlio=20de=20Castro?= <decastro@FHI.MPG.DE>
Date: Thu, 17 Apr 2025 13:55:41 +0200
Subject: [PATCH 26/67] I change the loading function for nexus files to use
 nxarray

---
 src/mpes_tools/Main.py | 17 ++++-------------
 1 file changed, 4 insertions(+), 13 deletions(-)

diff --git a/src/mpes_tools/Main.py b/src/mpes_tools/Main.py
index 74a7fbc..5bc2bf7 100644
--- a/src/mpes_tools/Main.py
+++ b/src/mpes_tools/Main.py
@@ -11,6 +11,7 @@
 from mpes_tools.show_4d_window import show_4d_window
 import os
 from PyQt5.QtGui import QPixmap
+import nxarray
 
 class ARPES_Analyser(QMainWindow):
     def __init__(self):
@@ -82,19 +83,9 @@ def open_file_phoibos(self):
                                        'Ekin': loaded_data['Ekin'],
                                        'delay': loaded_data['delay']})
             elif file_path.endswith('.nxs'):
-                with h5py.File(file_path, 'r') as f:
-                    # Ajuste os caminhos dos dados de acordo com a estrutura do seu arquivo NeXus
-                    # Isso é um exemplo - você precisa adaptar para a estrutura específica do seu arquivo
-                    data_array = f['/entry/data/data'][:]  # Ajuste o caminho conforme necessário
-                    angle = f['/entry/data/angular0'][:]      # Ajuste o caminho conforme necessário
-                    energy = f['/entry/data/energy'][:]    # Ajuste o caminho conforme necessário
-                    delay = f['/entry/data/delay'][:]      # Ajuste o caminho conforme necessário
-                    
-                    V1 = xr.DataArray(data_array,
-                                    dims=['Angle', 'Ekin', 'delay'],
-                                    coords={'Angle': angle,
-                                           'Ekin': energy,
-                                           'delay': delay})
+                V1=nxarray.load(file_path)
+                V1=V1.rename({'angular0':'Angle','energy':'Ekin','delay':'delay'})
+                V1=V1[list(V1.data_vars)[0]]
 
         axis=[V1['Angle'],V1['Ekin']-21.7,V1['delay']]
         graph_window= Gui_3d(V1,0,0,'Phoibos')

From 9c8b12b9dda76c61aa157bf5e03968360d1e1615 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Thu, 17 Apr 2025 14:46:00 +0200
Subject: [PATCH 27/67] added the feature to extract results by right clicking

---
 src/mpes_tools/Gui_3d.py | 111 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 106 insertions(+), 5 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index 6e650fb..5ab6647 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -12,6 +12,9 @@
 from IPython.core.getipython import get_ipython
 from mpes_tools.double_click_handler import SubplotClickHandler
 import xarray as xr
+from mpes_tools.right_click_handler import RightClickHandler
+from PyQt5.QtWidgets import QMenu
+from PyQt5.QtGui import QCursor
 
 #graphic window showing a 2d map controllable with sliders for the third dimension, with cursors showing cuts along the x direction for MDC and y direction for EDC
 # Two vertical cursors and two horizontal cursors are defined in the main graph with each same color for the cursors being horizontal and vertical intercept each other in a dot so one can move either each cursor or the dot itself which will move both cursors. 
@@ -34,11 +37,17 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         plt.close(self.fig)
         self.canvas = FigureCanvas(self.fig)
         self.click_handlers = []
+        self.handler_list = []
+            
+        # for idx, ax in enumerate(self.axs.flatten()):
+        #     handler = SubplotClickHandler(ax, self.external_callback)
+        #     ax.figure.canvas.mpl_connect("button_press_event", handler.handle_double_click)
+        #     self.click_handlers.append(handler)
             
         for idx, ax in enumerate(self.axs.flatten()):
-            handler = SubplotClickHandler(ax, self.external_callback)
-            ax.figure.canvas.mpl_connect("button_press_event", handler.handle_double_click)
-            self.click_handlers.append(handler)
+            handler = RightClickHandler(self.canvas, ax,self.show_pupup_window)
+            self.canvas.mpl_connect("button_press_event", handler.on_right_click)
+            self.handler_list.append(handler)
         # plt.ioff()
         # add the checkboxes for EDC and MDC integration and the button to save the results
         self.checkbox_e = QCheckBox("Integrate_energy")
@@ -108,7 +117,8 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
             self.data = self.data.assign_coords(Ekin=self.data.coords['Ekin'] -21.7)
 
         # define the cut for the spectra of the main graph
-        self.data2D_plot=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
+        # self.data2D_plot=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
+        self.data2D_plot=self.data.sel({self.data.dims[2]:slice(self.axis[2][t], self.axis[2][t + dt])}).sum(dim=self.data.dims[2])
         
         #Initialize the relevant prameters
         self.t=t
@@ -154,6 +164,96 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         self.graph_windows=[]
         
         print(data_array.dims)
+        
+    def show_pupup_window(self,canvas,ax):
+        if ax==self.axs[0,0]:
+            menu = QMenu(canvas)
+            action1 = menu.addAction("data_2D")
+            action2 = menu.addAction("cursors")
+    
+            action = menu.exec_(QCursor.pos())
+    
+            if action == action1:
+                print('data2D_plot=data.sel({data.dims[2]:slice('+f"{self.axis[2][self.slider1.value()]:.2f}"+', '+f"{self.axis[2][self.slider1.value()+self.slider2.value()+1]:.2f}"+')}).sum(dim=data.dims[2])' )
+            elif action == action2:
+                print('yellow_vertical,yellow_horizontal,green_vertical,green_horizontal= '+ f"{self.dot1.center[0]:.2f} ,{self.dot1.center[1]:.2f},{self.dot2.center[0]:.2f},{self.dot2.center[1]:.2f}")
+
+        elif ax==self.axs[1,0]:
+            menu = QMenu(canvas)
+            action1 = menu.addAction("yellow_EDC")
+            action2 = menu.addAction("green_EDC")
+            action3 = menu.addAction("integrated_EDC")
+    
+            action = menu.exec_(QCursor.pos())
+    
+            if action == action1:
+                print("data.sel({data.dims[2]: slice(" +
+              f"{self.axis[2][self.slider1.value()]:.2f}, " +
+              f"{self.axis[2][self.slider1.value() + self.slider2.value() + 1]:.2f}" +
+              ")}).sum(dim=data.dims[2]).sel({data.dims[0]: " +
+              f"{self.dot1.center[1]:.2f}" +
+              "}, method='nearest')  # Yellow EDC")
+            elif action == action2: 
+                print("data.sel({data.dims[2]: slice(" +
+              f"{self.axis[2][self.slider1.value()]:.2f}, " +
+              f"{self.axis[2][self.slider1.value() + self.slider2.value() + 1]:.2f}" +
+              ")}).sum(dim=data.dims[2]).sel({data.dims[0]: " +
+              f"{self.dot2.center[1]:.2f}" +
+              "}, method='nearest')  # Green EDC")
+            elif action == action3: 
+                print("data.sel({data.dims[2]: slice(" +
+              f"{self.axis[2][self.slider1.value()]:.2f}, " +
+              f"{self.axis[2][self.slider1.value() + self.slider2.value() + 1]:.2f}" +
+              ")}).sum(dim=data.dims[2]).sel({data.dims[0]: slice(" +
+              f"{min(self.dot1.center[1], self.dot2.center[1]):.2f}, " +
+              f"{max(self.dot1.center[1], self.dot2.center[1]):.2f}" +
+              ")}).sum(dim=data.dims[0])  # Integrated EDC")
+        elif ax==self.axs[0,1]:
+            menu = QMenu(canvas)
+            action1 = menu.addAction("yellow_MDC")
+            action2 = menu.addAction("green_MDC")
+            action3 = menu.addAction("integrated_MDC")
+    
+            action = menu.exec_(QCursor.pos())
+    
+            if action == action1:
+                print("data.sel({data.dims[2]: slice(" +
+              f"{self.axis[2][self.slider1.value()]:.2f}, " +
+              f"{self.axis[2][self.slider1.value() + self.slider2.value() + 1]:.2f}" +
+              ")}).sum(dim=data.dims[2]).sel({data.dims[1]: " +
+              f"{self.dot1.center[0]:.2f}" +
+              "}, method='nearest')  # Yellow MDC")
+            elif action == action2: 
+                print("data.sel({data.dims[2]: slice(" +
+              f"{self.axis[2][self.slider1.value()]:.2f}, " +
+              f"{self.axis[2][self.slider1.value() + self.slider2.value() + 1]:.2f}" +
+              ")}).sum(dim=data.dims[2]).sel({data.dims[1]: " +
+              f"{self.dot2.center[0]:.2f}" +
+              "}, method='nearest')  # Green MDC")
+
+            elif action == action3: 
+                print("data.sel({data.dims[2]: slice(" +
+              f"{self.axis[2][self.slider1.value()]:.2f}, " +
+              f"{self.axis[2][self.slider1.value() + self.slider2.value() + 1]:.2f}" +
+              ")}).sum(dim=data.dims[2]).sel({data.dims[1]: slice(" +
+              f"{min(self.dot1.center[0], self.dot2.center[0]):.2f}, " +
+              f"{max(self.dot1.center[0], self.dot2.center[0]):.2f}" +
+              ")}).sum(dim=data.dims[1])  # Integrated MDC")
+        elif ax==self.axs[1,1]:
+            menu = QMenu(canvas)
+            action1 = menu.addAction("intensity box")
+            action = menu.exec_(QCursor.pos())
+    
+            if action == action1:
+                # Integrated intensity box
+                print("data.loc[{data.dims[0]: slice(" +
+              f"{min(self.dot1.center[1], self.dot2.center[1]):.2f}, " +
+              f"{max(self.dot1.center[1], self.dot2.center[1]):.2f}" +
+              "), data.dims[1]: slice(" +
+              f"{min(self.dot1.center[0], self.dot2.center[0]):.2f}, " +
+              f"{max(self.dot1.center[0], self.dot2.center[0]):.2f}" +
+              ")}].sum(dim=(data.dims[0], data.dims[1]))  # Box integration")
+                
     def external_callback(self,ax):
         # print(f"External callback: clicked subplot ({i},{j})")
         if ax==self.axs[0,0]:
@@ -404,7 +504,8 @@ def update_show(t, dt): # update the main graph as well as the relevant EDC and
             self.axs[0, 1].clear()
             self.axs[1, 0].clear()
             #update the main graph/ spectra
-            self.data2D_plot=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
+            # self.data2D_plot=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
+            self.data2D_plot=self.data.sel({self.data.dims[2]:slice(self.axis[2][t], self.axis[2][t + dt])}).sum(dim=self.data.dims[2])
             im.set_array(self.data2D_plot)
             # show the cuts for the EDC and MDC
             if self.checkbox_e.isChecked() and self.checkbox_k.isChecked():

From c9b807961456716bcb3403a9afcde91fbb68f0e7 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Thu, 17 Apr 2025 14:46:22 +0200
Subject: [PATCH 28/67] added the feature to extract results by right clicking
 and added extra cursors for the integration range

---
 src/mpes_tools/show_4d_window.py | 172 +++++++++++++++++++++++--------
 1 file changed, 130 insertions(+), 42 deletions(-)

diff --git a/src/mpes_tools/show_4d_window.py b/src/mpes_tools/show_4d_window.py
index 7b50b30..78376e0 100644
--- a/src/mpes_tools/show_4d_window.py
+++ b/src/mpes_tools/show_4d_window.py
@@ -10,6 +10,9 @@
 from mpes_tools.hdf5 import load_h5
 from IPython.core.getipython import get_ipython
 from mpes_tools.double_click_handler import SubplotClickHandler
+from mpes_tools.right_click_handler import RightClickHandler
+from PyQt5.QtWidgets import QMenu
+from PyQt5.QtGui import QCursor
 
 class show_4d_window(QMainWindow):
     def __init__(self,data_array: xr.DataArray):
@@ -35,6 +38,7 @@ def __init__(self,data_array: xr.DataArray):
         self.slider_labels = []
         self.canvases = []
         self.click_handlers=[]
+        self.handler_list=[]
         self.axis_list=[]
         plt.ioff()
         for i in range(2):
@@ -47,9 +51,13 @@ def __init__(self,data_array: xr.DataArray):
                 figure, axis = plt.subplots(figsize=(10, 10))
                 plt.close(figure)
                 canvas = FigureCanvas(figure)
-                handler = SubplotClickHandler(axis, self.external_callback)
-                canvas.mpl_connect("button_press_event", handler.handle_double_click)
-                self.click_handlers.append(handler)
+                # handler = SubplotClickHandler(axis, self.external_callback)
+                # canvas.mpl_connect("button_press_event", handler.handle_double_click)
+                # self.click_handlers.append(handler)
+                handler = RightClickHandler(canvas, axis,self.show_pupup_window)
+                canvas.mpl_connect("button_press_event", handler.on_right_click)
+                self.handler_list.append(handler)
+                
                 graph_layout.addWidget(canvas)
                 self.axis_list.append(axis)
                 self.canvases.append(canvas)
@@ -110,6 +118,14 @@ def __init__(self,data_array: xr.DataArray):
                 self.slider4.append(slider4)
                 self.sliders.extend([slider1, slider2,slider3, slider4])
                 self.slider_labels.extend([slider1_label, slider2_label,slider3_label, slider4_label])
+                
+        # self.xv = None
+        # self.yv = None
+        # self.energy_kx_cursor = None
+        # self.energy_ky_cursor = None
+        # self.kx_ky_energy_cursor= None
+        # self.energy_kxky_x=None
+        # self.energy_kxky_y=None
 
         for slider in self.slider1:   
             slider.valueChanged.connect(self.slider_changed)
@@ -119,15 +135,7 @@ def __init__(self,data_array: xr.DataArray):
             slider.valueChanged.connect(self.slider_changed)
         for slider in self.slider4:   
             slider.valueChanged.connect(self.slider_changed)
-            
-        self.xv = None
-        self.yv = None
-        self.ev = None
-        self.eh = None
-        self.ph= None
-        self.pxv=None
-        self.pyh=None
-        
+
         
         open_graphe_action = QAction("Energy", self)
         open_graphe_action.triggered.connect(self.open_graph_kxkydt)
@@ -161,7 +169,60 @@ def closeEvent(self, event):
         # Update window state
         self.window_open = False
         event.accept()
+    def show_pupup_window(self,canvas,ax):
+        if ax==self.axis_list[0]:
+            menu = QMenu(canvas)
+            action1 = menu.addAction("energy plot")
+            action = menu.exec_(QCursor.pos())
+    
+            if action == action1:
+                print(f"""# ENERGY plot
+data.loc[{{
+    '{self.axes[2]}': slice({self.data_array[self.axes[2]][self.slider1[0].value()].item()}, {self.data_array[self.axes[2]][self.slider1[0].value() + self.slider2[0].value()].item()}),
+    '{self.axes[3]}': slice({self.data_array[self.axes[3]][self.slider3[0].value()].item()}, {self.data_array[self.axes[3]][self.slider3[0].value() + self.slider4[0].value()].item()})
+}}].mean(dim=('{self.axes[2]}', '{self.axes[3]}')).T  
+""")
+
+        elif ax==self.axis_list[1]:
+            menu = QMenu(canvas)
+            action1 = menu.addAction("ky plot")
+            action = menu.exec_(QCursor.pos())
+    
+            if action == action1:
+                print(f"""# KY plot
+data.loc[{{
+    '{self.axes[1]}': slice({self.data_array[self.axes[1]][self.slider1[1].value()].item()}, {self.data_array[self.axes[1]][self.slider1[1].value() + self.slider2[1].value()].item()}),
+    '{self.axes[3]}': slice({self.data_array[self.axes[3]][self.slider3[1].value()].item()}, {self.data_array[self.axes[3]][self.slider3[1].value() + self.slider4[1].value()].item()})
+}}].mean(dim=('{self.axes[1]}', '{self.axes[3]}')).T 
+""")
+
 
+        elif ax==self.axis_list[2]:
+            menu = QMenu(canvas)
+            action1 = menu.addAction("kx plot")
+            action = menu.exec_(QCursor.pos())
+    
+            if action == action1:
+                print(f"""# KX plot
+data.loc[{{
+    '{self.axes[0]}': slice({self.data_array[self.axes[0]][self.slider1[2].value()].item()}, {self.data_array[self.axes[0]][self.slider1[2].value() + self.slider2[2].value()].item()}),
+    '{self.axes[3]}': slice({self.data_array[self.axes[3]][self.slider3[2].value()].item()}, {self.data_array[self.axes[3]][self.slider3[2].value() + self.slider4[2].value()].item()})
+}}].mean(dim=('{self.axes[0]}', '{self.axes[3]}')).T  
+""")
+
+            
+        elif ax==self.axis_list[3]:
+            menu = QMenu(canvas)
+            action1 = menu.addAction("kx ky plot")
+            action = menu.exec_(QCursor.pos())
+    
+            if action == action1:
+                print(f"""# KX-KY plot
+data.loc[{{
+    '{self.axes[1]}': slice({self.data_array[self.axes[1]][self.slider1[3].value()].item()}, {self.data_array[self.axes[1]][self.slider1[3].value() + self.slider2[3].value()].item()}),
+    '{self.axes[0]}': slice({self.data_array[self.axes[0]][self.slider3[3].value()].item()}, {self.data_array[self.axes[0]][self.slider3[3].value() + self.slider4[3].value()].item()})
+}}].mean(dim=('{self.axes[1]}', '{self.axes[0]}')) 
+""")
     def external_callback(self, ax):
         # print(f"External callback: clicked subplot ({i},{j})")
         if ax==self.graphs[0].gca():
@@ -328,10 +389,14 @@ def update_energy(self,Energy,dE,te,dte):
         self.im=data_avg.T.plot(ax=ax,cmap='terrain', add_colorbar=False)
         ax.set_title(f'energy: {E1:.2f}, E+dE: {E2:.2f} , t: {te1:.2f}, t+dt: {te2:.2f}')
         
-        self.ev = ax.axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
-        self.eh = ax.axhline(y=self.data_array.coords[self.axes[1]][self.slider1[1].value()].item(), color='r', linestyle='--')
-        self.pxv = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
-        self.pyh = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
+        self.energy_kx_cursor = ax.axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
+        self.energy_ky_cursor = ax.axhline(y=self.data_array.coords[self.axes[1]][self.slider1[1].value()].item(), color='r', linestyle='--')
+        self.energy_kxky_x = ax.axvline(x=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
+        self.energy_kxky_y = ax.axhline(y=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
+        self.energy_delta_kx_cursor = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()+self.slider2[2].value()].item(), color='r', linestyle='--')
+        self.energy_delta_ky_cursor = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider1[1].value()+self.slider2[1].value()].item(), color='r', linestyle='--')
+        self.energy_delta_kxky_y = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[1]][self.slider1[3].value()+self.slider2[3].value()].item(), color='b', linestyle='--')
+        self.energy_delta_kxky_x = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[0]][self.slider3[3].value()+self.slider4[3].value()].item(), color='b', linestyle='--')
         self.graphs[0].tight_layout()
         self.graphs[0].canvas.draw_idle()
         
@@ -346,8 +411,8 @@ def update_ky(self,ypos,dy,ty,dty):
         ax.cla() 
         self.data_array.loc[{self.axes[1]:slice(y1,y2), self.axes[3]:slice(ty1,ty2)}].mean(dim=(self.axes[1], self.axes[3])).T.plot(ax=ax,cmap='terrain', add_colorbar=False)
         ax.set_title(f'ky: {y1:.2f}, ky+dky: {y2:.2f} , t: {ty1:.2f}, t+dt: {ty2:.2f}')
-        self.yh = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
-
+        self.ky_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+        self.ky_delta_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
         self.graphs[1].tight_layout()
         self.graphs[1].canvas.draw_idle()
         
@@ -362,8 +427,8 @@ def update_kx(self,xpos,dx,tx,dtx):
         ax.cla() 
         self.data_array.loc[{self.axes[0]:slice(x1,x2), self.axes[3]:slice(tx1,tx2)}].mean(dim=(self.axes[0], self.axes[3])).T.plot(ax=ax,cmap='terrain', add_colorbar=False)
         ax.set_title(f'kx: {x1:.2f}, kx+dkx: {x2:.2f} , t: {tx1:.2f}, t+dt: {tx2:.2f}')
-        self.xh = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
-        
+        self.kx_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+        self.kx_delta_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
         self.graphs[2].tight_layout()
         self.graphs[2].canvas.draw_idle()
     
@@ -378,7 +443,8 @@ def update_dt(self,yt,dyt,xt,dxt):
         ax.cla() 
         self.data_array.loc[{self.axes[1]:slice(yt1,yt2), self.axes[0]:slice(xt1,xt2)}].mean(dim=(self.axes[1], self.axes[0])).plot(ax=ax,cmap='terrain', add_colorbar=False)
         ax.set_title(f'ky: {yt1:.2f}, ky+dky: {yt2:.2f} , kx: {xt1:.2f}, kx+dkx: {xt2:.2f}')
-        self.ph = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+        self.kx_ky_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+        self.kx_ky_delta_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
         self.graphs[3].tight_layout()
         self.graphs[3].canvas.draw_idle()
         
@@ -393,15 +459,25 @@ def slider_changed(self, value):
 
         if index in range(0,4):
             # ax = self.graphs[2].gca()
-            if self.xh in self.graphs[2].gca().lines:
-                self.xh.remove()
-            if self.yh in self.graphs[1].gca().lines:
-                self.yh.remove()
-            if self.ph in self.graphs[3].gca().lines:
-                self.ph.remove()
-            self.xh = self.graphs[2].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
-            self.yh = self.graphs[1].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
-            self.ph = self.graphs[3].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+            if self.kx_energy_cursor in self.graphs[2].gca().lines:
+                self.kx_energy_cursor.remove()
+            if self.ky_energy_cursor in self.graphs[1].gca().lines:
+                self.ky_energy_cursor.remove()
+            if self.kx_ky_energy_cursor in self.graphs[3].gca().lines:
+                self.kx_ky_energy_cursor.remove()
+            if self.kx_delta_energy_cursor in self.graphs[2].gca().lines:
+                self.kx_delta_energy_cursor.remove()
+            if self.ky_delta_energy_cursor in self.graphs[1].gca().lines:
+                self.ky_delta_energy_cursor.remove()
+            if self.kx_ky_delta_energy_cursor in self.graphs[3].gca().lines:
+                self.kx_ky_delta_energy_cursor.remove()
+            self.kx_energy_cursor = self.graphs[2].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+            self.ky_energy_cursor = self.graphs[1].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+            self.kx_ky_energy_cursor = self.graphs[3].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+            
+            self.kx_delta_energy_cursor = self.graphs[2].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
+            self.ky_delta_energy_cursor = self.graphs[1].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
+            self.kx_ky_delta_energy_cursor = self.graphs[3].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
             # self.graphs[2].tight_layout()
             self.graphs[2].canvas.draw_idle()
             self.graphs[1].canvas.draw_idle()
@@ -409,26 +485,38 @@ def slider_changed(self, value):
             self.update_energy(self.slider1[0].value(),self.slider2[0].value(),self.slider3[0].value(), self.slider4[0].value())
             
         elif index in range(4,8):
-            if self.eh is not None:
-                self.eh.remove()
+            if self.energy_ky_cursor is not None:
+                self.energy_ky_cursor.remove()
+            if self.energy_delta_ky_cursor is not None:
+                self.energy_delta_ky_cursor.remove()
            
-            self.eh = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider1[1].value()].item(), color='r', linestyle='--')
+            self.energy_ky_cursor = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider1[1].value()].item(), color='r', linestyle='--')
+            self.energy_delta_ky_cursor = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider1[1].value()+self.slider2[1].value()].item(), color='r', linestyle='--')
             self.graphs[0].canvas.draw_idle()
             self.update_ky(self.slider1[1].value(), self.slider2[1].value(),self.slider3[1].value(), self.slider4[1].value())
         elif index in range (8,12):
             ax = self.graphs[0].gca()
-            if self.ev in ax.lines:
-                self.ev.remove()
-            self.ev = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
+            if self.energy_kx_cursor in ax.lines:
+                self.energy_kx_cursor.remove()
+            if self.energy_delta_kx_cursor in ax.lines:
+                self.energy_delta_kx_cursor.remove()
+            self.energy_kx_cursor = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
+            self.energy_delta_kx_cursor = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()+self.slider2[2].value()].item(), color='r', linestyle='--')
             self.graphs[0].canvas.draw_idle()
             self.update_kx(self.slider1[2].value(), self.slider2[2].value(),self.slider3[2].value(), self.slider4[2].value())
         elif index in range (12,16):
-            if self.pxv in self.graphs[0].gca().lines:
-                self.pxv.remove()
-            if self.pyh in self.graphs[0].gca().lines:
-                self.pyh.remove()
-            self.pyh = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
-            self.pxv = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
+            if self.energy_kxky_x in self.graphs[0].gca().lines:
+                self.energy_kxky_x.remove()
+            if self.energy_kxky_y in self.graphs[0].gca().lines:
+                self.energy_kxky_y.remove()
+            if self.energy_delta_kxky_x in self.graphs[0].gca().lines:
+                self.energy_delta_kxky_x.remove()
+            if self.energy_delta_kxky_y in self.graphs[0].gca().lines:
+                self.energy_delta_kxky_y.remove()
+            self.energy_kxky_y = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
+            self.energy_kxky_x = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
+            self.energy_delta_kxky_y = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[1]][self.slider1[3].value()+self.slider2[3].value()].item(), color='b', linestyle='--')
+            self.energy_delta_kxky_x = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[0]][self.slider3[3].value()+self.slider4[3].value()].item(), color='b', linestyle='--')
             self.graphs[0].canvas.draw_idle()
             self.update_dt(self.slider1[3].value(), self.slider2[3].value(), self.slider3[3].value(), self.slider4[3].value())
 

From 2f8da32bdeef4b3b9868e63583421d85e074a4af Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Thu, 17 Apr 2025 14:47:32 +0200
Subject: [PATCH 29/67] function for the right click feature

---
 src/mpes_tools/right_click_handler.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 src/mpes_tools/right_click_handler.py

diff --git a/src/mpes_tools/right_click_handler.py b/src/mpes_tools/right_click_handler.py
new file mode 100644
index 0000000..8b54ddd
--- /dev/null
+++ b/src/mpes_tools/right_click_handler.py
@@ -0,0 +1,14 @@
+from PyQt5.QtWidgets import QMenu
+from matplotlib.backend_bases import MouseButton
+from PyQt5.QtGui import QCursor
+
+class RightClickHandler:
+    def __init__(self, canvas, ax, show_popup=None):
+        self.canvas = canvas
+        self.ax = ax
+        self.show_popup=show_popup
+
+    def on_right_click(self, event):
+        if event.button == MouseButton.RIGHT and event.inaxes == self.ax:
+            if self.show_popup:
+                self.show_popup(self.canvas,self.ax)
\ No newline at end of file

From 37a577d40a11a8b8ab5c19cdc34a28801dbae420 Mon Sep 17 00:00:00 2001
From: Arora0 <abeer.arora.13@gmail.com>
Date: Thu, 17 Apr 2025 14:52:28 +0200
Subject: [PATCH 30/67] add nxarray dependency

---
 pyproject.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pyproject.toml b/pyproject.toml
index cb04945..cf69b08 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -35,6 +35,7 @@ dependencies = [
     "numpy>=1.26.1,<2.0",
     "PyQt5>=5.0.0",
     "xarray>=0.20.2",
+    "nxarray>=0.4.4",
 ]
 
 [project.urls]

From e6995dea0283fb5000d2e36974c4d565da5f1b38 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 18 Apr 2025 15:49:46 +0200
Subject: [PATCH 31/67] modified the whole structure and separated the cursors
 and dots in another file as a function that is called. Modified also the data
 that is fed to the fit function

---
 src/mpes_tools/Gui_3d.py | 421 ++++++++++++++++++++-------------------
 1 file changed, 211 insertions(+), 210 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index 5ab6647..f54db8c 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -9,13 +9,16 @@
 import json
 import pickle
 from mpes_tools.fit_panel import fit_panel
+from mpes_tools.fit_panel_single import fit_panel_single
 from IPython.core.getipython import get_ipython
 from mpes_tools.double_click_handler import SubplotClickHandler
 import xarray as xr
 from mpes_tools.right_click_handler import RightClickHandler
 from PyQt5.QtWidgets import QMenu
 from PyQt5.QtGui import QCursor
-
+from mpes_tools.cursor_dot_handler import Cursor_dot_handler
+from cursor_handler import Cursor_handler
+from dot_handler import Dot_handler
 #graphic window showing a 2d map controllable with sliders for the third dimension, with cursors showing cuts along the x direction for MDC and y direction for EDC
 # Two vertical cursors and two horizontal cursors are defined in the main graph with each same color for the cursors being horizontal and vertical intercept each other in a dot so one can move either each cursor or the dot itself which will move both cursors. 
 class Gui_3d(QMainWindow):  
@@ -142,7 +145,7 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         self.slider2.valueChanged.connect(self.slider2_changed)
         
         #run the main code to show the graphs and cursors
-        self.show_graphs(t,dt)
+        # self.show_graphs(t,dt)
         
         #create a menu for the fit panel
         menu_bar = self.menuBar()
@@ -165,6 +168,132 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         
         print(data_array.dims)
         
+        # plot the main graph
+        self.im = self.data2D_plot.plot(ax=self.axs[0, 0], cmap='terrain', add_colorbar=False)
+        
+        # define the initial positions of the cursors in the main graph
+        
+        initial_x = 0
+        initial_y = 0
+        initial_x2 = 0.5
+        initial_y2 = 0.5
+        ax = self.axs[0, 0]
+        # define the lines for the cursors
+        ymin, ymax = self.axs[0, 0].get_ylim()
+        xmin, xmax = self.axs[0, 0].get_ylim()
+        ymin, ymax = 5 * ymin, 5 * ymax
+        xmin, xmax = 5 * xmin, 5 * xmax
+        self.cursor_vert1 = Line2D([initial_x, initial_x], [ymin, ymax], color='yellow', linewidth=2, picker=10, linestyle='--')
+        self.cursor_horiz1 = Line2D([xmin, xmax], [initial_y, initial_y], color='yellow', linewidth=2, picker=10, linestyle='--')
+        self.cursor_vert2 = Line2D([initial_x2, initial_x2], [ymin, ymax], color='green', linewidth=2, picker=10, linestyle='--')
+        self.cursor_horiz2 = Line2D([xmin, xmax], [initial_y2, initial_y2], color='green', linewidth=2, picker=10, linestyle='--')
+        
+        # show the initial values of the cursors 
+        base = self.cursor_label[0].text().split(':')[0]
+        self.cursor_label[0].setText(f"{base}: {initial_x:.2f}")
+        base = self.cursor_label[1].text().split(':')[0]
+        self.cursor_label[1].setText(f"{base}: {initial_x:.2f}")
+        base = self.cursor_label[2].text().split(':')[0]
+        self.cursor_label[2].setText(f"{base}: {initial_x2:.2f}")
+        base = self.cursor_label[3].text().split(':')[0]
+        self.cursor_label[3].setText(f"{base}: {initial_y2:.2f}")
+        
+        # define the dots that connect the cursors
+        self.dot1 = Circle((initial_x, initial_y), radius=0.05, color='yellow', picker=10)
+        self.dot2 = Circle((initial_x2, initial_y2), radius=0.05, color='green', picker=10)
+        
+        
+        # add the lines and the cursors to the main graph
+        ax.add_line(self.cursor_vert1)
+        ax.add_line(self.cursor_horiz1)
+        ax.add_patch(self.dot1)
+        ax.add_line(self.cursor_vert2)
+        ax.add_line(self.cursor_horiz2)
+        ax.add_patch(self.dot2)
+
+        # self.change_pixel_to_arrayslot()
+        
+        # define the integrated EDC and MDC 
+        x_min = min(self.dot2.center[1], self.dot1.center[1])
+        x_max = max(self.dot2.center[1], self.dot1.center[1])
+        self.integrated_edc=self.data2D_plot.sel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
+        x_min = min(self.dot1.center[0], self.dot2.center[0])
+        x_max = max(self.dot1.center[0], self.dot2.center[0])
+        self.integrated_mdc=self.data2D_plot.sel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
+        self.active_handler = None
+        self.edc_yellow, = self.axs[1, 0].plot([], [], color='orange')
+        self.edc_green, = self.axs[1, 0].plot([], [], color='green')
+        self.update_show() 
+        self.fig.canvas.draw_idle()
+        self.cursor_dot_handler=[]
+        self.cursors_list=[self.cursor_vert1, self.cursor_horiz1,self.cursor_vert2, self.cursor_horiz2]
+        self.cursors_functions=[lambda:  self.changes_cursor_vertical_1(),lambda: self.changes_cursor_horizontal_1(), lambda: self.changes_cursor_vertical_2(),lambda: self.changes_cursor_horizontal_2()]
+        self.dots_list=[self.dot1,self.dot2]
+        self.dots_function=[lambda: self.changes_dot1(), lambda: self.changes_dot2()]
+        for idx, c in enumerate(self.cursors_list):
+            c_handler = Cursor_handler(self.fig,self.axs[0,0],c, self.cursors_functions[idx],parent=self)
+            self.cursor_dot_handler.append(c_handler)
+        for idx, d in enumerate(self.dots_list):
+            d_handler = Dot_handler(self.fig,self.axs[0,0], d, self.dots_function[idx])
+            self.cursor_dot_handler.append(d_handler)
+
+    def changes_cursor_vertical_1(self):
+        x_val= self.cursor_vert1.get_xdata()[0]
+        self.dot1.center = (x_val, self.dot1.center[1])
+        base = self.cursor_label[0].text().split(':')[0]
+        self.cursor_label[0].setText(f"{base}: {x_val:.2f}")
+        self.fig.canvas.draw_idle()
+        self.update_mdc()
+        self.box()
+    def changes_cursor_horizontal_1(self):
+        y_val= self.cursor_horiz1.get_ydata()[0]
+        self.dot1.center = (self.dot1.center[0],y_val)
+        base = self.cursor_label[1].text().split(':')[0]
+        self.cursor_label[1].setText(f"{base}: {y_val:.2f}")
+        self.fig.canvas.draw_idle()
+        self.update_edc()
+        self.box()
+    def changes_cursor_vertical_2(self):
+        x_val= self.cursor_vert2.get_xdata()[0]
+        self.dot2.center = (x_val, self.dot2.center[1])
+        base = self.cursor_label[2].text().split(':')[0]
+        self.cursor_label[2].setText(f"{base}: {x_val:.2f}")
+        self.fig.canvas.draw_idle()
+        self.update_mdc()
+        self.box()
+    def changes_cursor_horizontal_2(self):
+        y_val= self.cursor_horiz2.get_ydata()[0]
+        self.dot2.center = (self.dot2.center[0], y_val)
+        base = self.cursor_label[3].text().split(':')[0]
+        self.cursor_label[3].setText(f"{base}: {y_val:.2f}")
+        self.fig.canvas.draw_idle()
+        self.update_edc()
+        self.box()
+    def changes_dot1(self):
+        x_val,y_val= self.dot1.center
+        self.cursor_vert1.set_xdata([x_val,x_val])
+        self.cursor_horiz1.set_ydata([y_val,y_val])
+        base = self.cursor_label[0].text().split(':')[0]
+        self.cursor_label[0].setText(f"{base}: {x_val:.2f}")
+        base = self.cursor_label[1].text().split(':')[0]
+        self.cursor_label[1].setText(f"{base}: {y_val:.2f}")
+        self.fig.canvas.draw_idle()
+        self.update_edc()
+        self.update_mdc()
+        self.box()
+    def changes_dot2(self):
+        x_val,y_val= self.dot2.center
+        self.cursor_vert2.set_xdata([x_val,x_val])
+        self.cursor_horiz2.set_ydata([y_val,y_val])
+        base = self.cursor_label[2].text().split(':')[0]
+        self.cursor_label[2].setText(f"{base}: {x_val:.2f}")
+        base = self.cursor_label[3].text().split(':')[0]
+        self.cursor_label[3].setText(f"{base}: {y_val:.2f}")
+        self.fig.canvas.draw_idle() 
+        self.update_edc()
+        self.update_mdc()
+        self.box()
+   
     def show_pupup_window(self,canvas,ax):
         if ax==self.axs[0,0]:
             menu = QMenu(canvas)
@@ -411,7 +540,7 @@ def main_graph_cursor_changed(self, index): #set manually the values for the cur
             base = self.cursor_label[3].text().split(':')[0]
             self.cursor_label[3].setText(f"{base}: {value:.2f}")
         # self.change_pixel_to_arrayslot()
-        self.update_show(self.slider1.value(),self.slider2.value())
+        self.update_show()
         try:
             num = float(value)
             # print(f"Cursor {index+1} changed to: {num}")
@@ -423,248 +552,120 @@ def slider1_changed(self,value): # change the slider controlling the third dimen
         # self.slider1_label.setText(str(value))
         base = self.slider1_label.text().split(':')[0]
         self.slider1_label.setText(f"{base}: {self.data[self.data.dims[2]][value].item():.2f}")
-        self.update_show(self.slider1.value(),self.slider2.value())
+        self.data2D_plot=self.data.sel({self.data.dims[2]:slice(self.axis[2][self.slider1.value()], self.axis[2][self.slider1.value() + self.slider2.value()])}).sum(dim=self.data.dims[2])
+        self.update_show()
         self.t=self.slider1.value()
     def slider2_changed(self,value): # change the slider controlling the third dimension for windowing
         # self.slider2_label.setText(str(value))
         base = self.slider2_label.text().split(':')[0]
         self.slider2_label.setText(f"{base}: {value}")
-        self.update_show(self.slider1.value(),self.slider2.value())
+        self.data2D_plot=self.data.sel({self.data.dims[2]:slice(self.axis[2][self.slider1.value()], self.axis[2][self.slider1.value() + self.slider2.value()])}).sum(dim=self.data.dims[2])
+        self.update_show()
         self.dt=self.slider2.value()
     def checkbox_e_changed(self, state): # Checkbox for integrating the EDC between the cursors
         if state == Qt.Checked:
             self.integrate_E()
         else:
-            self.update_show(self.slider1.value(),self.slider2.value())
+            self.data2D_plot.sel({self.data.dims[0]:self.dot1.center[1]}, method='nearest').plot(ax=self.axs[1,0],color='orange')
+            self.data2D_plot.sel({self.data.dims[0]:self.dot2.center[1]}, method='nearest').plot(ax=self.axs[1,0],color='green')
+            # self.update_show(self.slider1.value(),self.slider2.value())
     def checkbox_k_changed(self, state): # Checkbox for integrating the MDC between the cursors
         if state == Qt.Checked:
             self.integrate_k()
         else:
-            self.update_show(self.slider1.value(),self.slider2.value())
+            self.data2D_plot.sel({self.data.dims[1]:self.dot1.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='orange')
+            self.data2D_plot.sel({self.data.dims[1]:self.dot2.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='green')
+            # self.update_show(self.slider1.value(),self.slider2.value())
 
     
     def fit_energy_panel(self,event): # open up the fit panel for the EDC 
-        graph_window=fit_panel(self.data,self.dot1.center[1], self.dot2.center[1], self.t, self.dt, self.data.dims[1])
+        x_min = min(self.dot2.center[1], self.dot1.center[1])
+        x_max = max(self.dot2.center[1], self.dot1.center[1])
+        data_fit=self.data.sel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
+        graph_window=fit_panel(data_fit, self.t, self.dt, self.data.dims[1])
         graph_window.show()
         self.graph_windows.append(graph_window)
     def fit_momentum_panel(self,event): # open up the fit panel for the MDC
-        graph_window=fit_panel(self.data,self.dot1.center[0], self.dot2.center[0], self.t, self.dt, self.data.dims[0])
+        x_min = min(self.dot1.center[0], self.dot2.center[0])
+        x_max = max(self.dot1.center[0], self.dot2.center[0])
+        data_fit=self.data.sel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
+        graph_window=fit_panel(data_fit, self.t, self.dt, self.data.dims[0])
         graph_window.show()
         self.graph_windows.append(graph_window)
     def fit_box_panel(self,event): # open up the fit panel for the intensity box
-        graph_window=fit_panel(self.int,0,0, self.t, self.dt, 'box')
+        graph_window=fit_panel_single(self.int)
         graph_window.show()
         self.graph_windows.append(graph_window)
-        
-    
-    def show_graphs(self, t, dt): # This is where the updates after changing the sliders happen
-    
-        def integrate_E(): # integrate EDC between the two cursors in the main graph
-            self.axs[1, 0].clear()
-            # plt.draw()
-    
-            x_min = min(self.dot2.center[1], self.dot1.center[1])
-            x_max = max(self.dot2.center[1], self.dot1.center[1])
-            
-            # self.data2D_plot.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0]).plot(ax=self.axs[1,0])
-            self.integrated_edc=self.data2D_plot.sel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
-            self.integrated_edc.plot(ax=self.axs[1,0])
-            self.fig.canvas.draw_idle()
-    
-        def integrate_k(): # integrate MDC between the two cursors in the main graph
-            self.axs[0, 1].clear()
-            # plt.draw()
-    
-            x_min = min(self.dot1.center[0], self.dot2.center[0])
-            x_max = max(self.dot1.center[0], self.dot2.center[0])
-
-            # self.data2D_plot.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1]).plot(ax=self.axs[0,1])
-            self.integrated_mdc=self.data2D_plot.sel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
-            self.integrated_mdc.plot(ax=self.axs[0,1])
-            self.fig.canvas.draw_idle()
-    
-        def box(): # generate the intensity graph between the four cursors in the main graph
-            self.axs[1, 1].clear()
-            
-            x0,y0=self.dot1.center
-            x1,y1=self.dot2.center
-    
-            # Ensure (x0, y0) is the top-left corner and (x1, y1) is the bottom-right
-            x0, x1 = sorted([x0, x1])
-            y0, y1 = sorted([y0, y1])
-    
-            self.int = self.data.loc[{self.data.dims[0]: slice(y0, y1), self.data.dims[1]: slice(x0, x1)}].sum(dim=(self.data.dims[0], self.data.dims[1]))
-            if x0 != x1 and y0 != y1:
-                
-                self.int.plot(ax=self.axs[1,1])
-                self.dot, = self.axs[1, 1].plot([self.axis[2][self.slider1.value()]], [self.int[self.slider1.value()]], 'ro', markersize=8)
-                self.fig.canvas.draw_idle()
+    def update_edc(self):
+        self.axs[1, 0].clear()
+        if self.checkbox_e.isChecked():
+            self.integrate_E()
+        else:
+            self.edc_yellow=self.data2D_plot.sel({self.data.dims[0]:self.dot1.center[1]}, method='nearest')
+            self.edc_green=self.data2D_plot.sel({self.data.dims[0]:self.dot2.center[1]}, method='nearest')
+            self.edc_yellow.plot(ax=self.axs[1,0],color='orange')
+            self.edc_green.plot(ax=self.axs[1,0],color='green')
+    def update_mdc(self):
+        self.axs[0, 1].clear()
+        if self.checkbox_k.isChecked():
+            self.integrate_k()
+        else:
+            self.data2D_plot.sel({self.data.dims[1]:self.dot1.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='orange')
+            self.data2D_plot.sel({self.data.dims[1]:self.dot2.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='green')
     
-        def update_show(t, dt): # update the main graph as well as the relevant EDC and MDC cuts. Also the box intensity
-            self.axs[0, 1].clear()
-            self.axs[1, 0].clear()
-            #update the main graph/ spectra
-            # self.data2D_plot=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
-            self.data2D_plot=self.data.sel({self.data.dims[2]:slice(self.axis[2][t], self.axis[2][t + dt])}).sum(dim=self.data.dims[2])
-            im.set_array(self.data2D_plot)
-            # show the cuts for the EDC and MDC
-            if self.checkbox_e.isChecked() and self.checkbox_k.isChecked():
-                integrate_E()
-                integrate_k()
-            elif self.checkbox_e.isChecked():
-                integrate_E()
-                self.data2D_plot.sel({self.data.dims[1]:self.dot1.center[0]}, method='nearest').plot(ax=self.axs[0, 1], color='orange')
-                self.data2D_plot.sel({self.data.dims[1]:self.dot2.center[0]}, method='nearest').plot(ax=self.axs[0, 1], color='green')
-                
-            elif self.checkbox_k.isChecked():
-                integrate_k()
-                self.data2D_plot.sel({self.data.dims[0]:self.dot1.center[1]}, method='nearest').plot(ax=self.axs[1, 0], color='orange')
-                self.data2D_plot.sel({self.data.dims[0]:self.dot2.center[1]}, method='nearest').plot(ax=self.axs[1, 0], color='green')
-                
-            else: 
-                self.data2D_plot.sel({self.data.dims[0]:self.dot1.center[1]}, method='nearest').plot(ax=self.axs[1,0],color='orange')
-                self.data2D_plot.sel({self.data.dims[0]:self.dot2.center[1]}, method='nearest').plot(ax=self.axs[1,0],color='green')
-                self.data2D_plot.sel({self.data.dims[1]:self.dot1.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='orange')
-                self.data2D_plot.sel({self.data.dims[1]:self.dot2.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='green')
+    def integrate_E(self): # integrate EDC between the two cursors in the main graph
+        self.axs[1, 0].clear()
 
-            
-            box() # update the intensity box graph
-            time1 = self.axis[2][t]
-            timedt1 = self.axis[2][t + dt]
-            self.axs[0, 0].set_title(f't: {time1:.2f}, t+dt: {timedt1:.2f}')
-            self.fig.canvas.draw_idle()
-            plt.draw()
-        
-        # plot the main graph
-        im = self.data2D_plot.plot(ax=self.axs[0, 0], cmap='terrain', add_colorbar=False)
-        
-        # define the initial positions of the cursors in the main graph
-        
-        initial_x = 0
-        initial_y = 0
-        initial_x2 = 0.5
-        initial_y2 = 0.5
-        ax = self.axs[0, 0]
-        # define the lines for the cursors
-        ymin, ymax = self.axs[0, 0].get_ylim()
-        xmin, xmax = self.axs[0, 0].get_ylim()
-        ymin, ymax = 5 * ymin, 5 * ymax
-        xmin, xmax = 5 * xmin, 5 * xmax
-        self.cursor_vert1 = Line2D([initial_x, initial_x], [ymin, ymax], color='yellow', linewidth=2, picker=10, linestyle='--')
-        self.cursor_horiz1 = Line2D([xmin, xmax], [initial_y, initial_y], color='yellow', linewidth=2, picker=10, linestyle='--')
-        self.cursor_vert2 = Line2D([initial_x2, initial_x2], [ymin, ymax], color='green', linewidth=2, picker=10, linestyle='--')
-        self.cursor_horiz2 = Line2D([xmin, xmax], [initial_y2, initial_y2], color='green', linewidth=2, picker=10, linestyle='--')
-        
-        # show the initial values of the cursors 
-        base = self.cursor_label[0].text().split(':')[0]
-        self.cursor_label[0].setText(f"{base}: {initial_x:.2f}")
-        base = self.cursor_label[1].text().split(':')[0]
-        self.cursor_label[1].setText(f"{base}: {initial_x:.2f}")
-        base = self.cursor_label[2].text().split(':')[0]
-        self.cursor_label[2].setText(f"{base}: {initial_x2:.2f}")
-        base = self.cursor_label[3].text().split(':')[0]
-        self.cursor_label[3].setText(f"{base}: {initial_y2:.2f}")
-        
-        # define the dots that connect the cursors
-        self.dot1 = Circle((initial_x, initial_y), radius=0.05, color='yellow', picker=10)
-        self.dot2 = Circle((initial_x2, initial_y2), radius=0.05, color='green', picker=10)
-        
-        # add the lines and the cursors to the main graph
-        ax.add_line(self.cursor_vert1)
-        ax.add_line(self.cursor_horiz1)
-        ax.add_patch(self.dot1)
-        ax.add_line(self.cursor_vert2)
-        ax.add_line(self.cursor_horiz2)
-        ax.add_patch(self.dot2)
-    
-        # self.change_pixel_to_arrayslot()
-        
-        # define the integrated EDC and MDC 
         x_min = min(self.dot2.center[1], self.dot1.center[1])
         x_max = max(self.dot2.center[1], self.dot1.center[1])
+        
+        # self.data2D_plot.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0]).plot(ax=self.axs[1,0])
         self.integrated_edc=self.data2D_plot.sel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
+        self.integrated_edc.plot(ax=self.axs[1,0])
+        self.fig.canvas.draw_idle()
+
+    def integrate_k(self): # integrate MDC between the two cursors in the main graph
+        self.axs[0, 1].clear()
+
         x_min = min(self.dot1.center[0], self.dot2.center[0])
         x_max = max(self.dot1.center[0], self.dot2.center[0])
-        self.integrated_mdc=self.data2D_plot.sel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
 
-        plt.draw()
-        update_show(self.slider1.value(),self.slider2.value()) 
+        # self.data2D_plot.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1]).plot(ax=self.axs[0,1])
+        self.integrated_mdc=self.data2D_plot.sel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
+        self.integrated_mdc.plot(ax=self.axs[0,1])
         self.fig.canvas.draw_idle()
-        self.active_cursor = None
-        def on_pick(event): # function to pick up the cursors or the dots
-            if event.artist == self.cursor_vert1:
-                self.active_cursor = self.cursor_vert1
-            elif event.artist == self.cursor_horiz1:
-                self.active_cursor = self.cursor_horiz1
-            elif event.artist == self.dot1:
-                self.active_cursor = self.dot1
-            elif event.artist == self.cursor_vert2:
-                self.active_cursor = self.cursor_vert2
-            elif event.artist == self.cursor_horiz2:
-                self.active_cursor = self.cursor_horiz2
-            elif event.artist == self.dot2:
-                self.active_cursor = self.dot2
-            elif event.artist == self.Line1:
-                self.active_cursor =self. Line1
-            elif event.artist == self.Line2:
-                self.active_cursor =self. Line2
-        self.active_cursor=None
-        def on_motion(event): # function to move the cursors or the dots
-            if self.active_cursor is not None and event.inaxes == ax:
-                if self.active_cursor == self.cursor_vert1:
-                    self.cursor_vert1.set_xdata([event.xdata, event.xdata])
-                    self.dot1.center = (event.xdata, self.dot1.center[1])
-                    base = self.cursor_label[0].text().split(':')[0]
-                    self.cursor_label[0].setText(f"{base}: {event.xdata:.2f}")
-                elif self.active_cursor == self.cursor_horiz1:
-                    self.cursor_horiz1.set_ydata([event.ydata, event.ydata])
-                    self.dot1.center = (self.dot1.center[0], event.ydata)
-                    base = self.cursor_label[1].text().split(':')[0]
-                    self.cursor_label[1].setText(f"{base}: {event.ydata:.2f}")
-                elif self.active_cursor == self.dot1:
-                    self.dot1.center = (event.xdata, event.ydata)
-                    self.cursor_vert1.set_xdata([event.xdata, event.xdata])
-                    self.cursor_horiz1.set_ydata([event.ydata, event.ydata])
-                    base = self.cursor_label[0].text().split(':')[0]
-                    self.cursor_label[0].setText(f"{base}: {event.xdata:.2f}")
-                    base = self.cursor_label[1].text().split(':')[0]
-                    self.cursor_label[1].setText(f"{base}: {event.ydata:.2f}")
-                elif self.active_cursor == self.cursor_vert2:
-                    self.cursor_vert2.set_xdata([event.xdata, event.xdata])
-                    self.dot2.center = (event.xdata, self.dot2.center[1])
-                    base = self.cursor_label[2].text().split(':')[0]
-                    self.cursor_label[2].setText(f"{base}: {event.xdata:.2f}")
-                elif self.active_cursor == self.cursor_horiz2:
-                    self.cursor_horiz2.set_ydata([event.ydata, event.ydata])
-                    self.dot2.center = (self.dot2.center[0], event.ydata)
-                    base = self.cursor_label[3].text().split(':')[0]
-                    self.cursor_label[3].setText(f"{base}: {event.ydata:.2f}")
-                elif self.active_cursor == self.dot2:
-                    self.dot2.center = (event.xdata, event.ydata)
-                    self.cursor_vert2.set_xdata([event.xdata, event.xdata])
-                    self.cursor_horiz2.set_ydata([event.ydata, event.ydata])
-                    base = self.cursor_label[2].text().split(':')[0]
-                    self.cursor_label[2].setText(f"{base}: {event.xdata:.2f}")
-                    base = self.cursor_label[3].text().split(':')[0]
-                    self.cursor_label[3].setText(f"{base}: {event.ydata:.2f}")
-                self.fig.canvas.draw_idle()
-                plt.draw()
-                
-                # self.change_pixel_to_arrayslot()
-                update_show(self.slider1.value(),self.slider2.value()) 
-               
-            
-        def on_release(event):# function to release the selected object
-            self.active_cursor = None
+
+    def box(self): # generate the intensity graph between the four cursors in the main graph
+        self.axs[1, 1].clear()
+        
+        x0,y0=self.dot1.center
+        x1,y1=self.dot2.center
+
+        # Ensure (x0, y0) is the top-left corner and (x1, y1) is the bottom-right
+        x0, x1 = sorted([x0, x1])
+        y0, y1 = sorted([y0, y1])
+
+        self.int = self.data.loc[{self.data.dims[0]: slice(y0, y1), self.data.dims[1]: slice(x0, x1)}].sum(dim=(self.data.dims[0], self.data.dims[1]))
+        if x0 != x1 and y0 != y1:
             
-        self.fig.canvas.mpl_connect('pick_event', on_pick)
-        self.fig.canvas.mpl_connect('motion_notify_event', on_motion)
-        self.fig.canvas.mpl_connect('button_release_event', on_release)
-       
-        
-        self.update_show=update_show
-        self.integrate_E=integrate_E
-        self.integrate_k=integrate_k
+            self.int.plot(ax=self.axs[1,1])
+            self.dot, = self.axs[1, 1].plot([self.axis[2][self.slider1.value()]], [self.int[self.slider1.value()]], 'ro', markersize=8)
+            self.fig.canvas.draw_idle()
+
+    def update_show(self): # update the main graph as well as the relevant EDC and MDC cuts. Also the box intensity
+        self.update_edc()
+        self.update_mdc()
+        self.im.set_array(self.data2D_plot)
+        self.box() # update the intensity box graph
+        time1 = self.axis[2][self.slider1.value()]
+        timedt1 = self.axis[2][self.slider1.value() + self.slider2.value()]
+        self.axs[0, 0].set_title(f't: {time1:.2f}, t+dt: {timedt1:.2f}')
+        self.fig.canvas.draw_idle()
+
+
+   
+    
+
 
 # if __name__ == "__main__":
 #     app = QApplication(sys.argv)

From 60a85a3e6ebc15a7f15779a57bb82c1ea83e259f Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 18 Apr 2025 15:50:36 +0200
Subject: [PATCH 32/67] the cursor and dot handlers

---
 src/mpes_tools/cursor_handler.py | 29 +++++++++++++++++++++++++++++
 src/mpes_tools/dot_handler.py    | 22 ++++++++++++++++++++++
 2 files changed, 51 insertions(+)
 create mode 100644 src/mpes_tools/cursor_handler.py
 create mode 100644 src/mpes_tools/dot_handler.py

diff --git a/src/mpes_tools/cursor_handler.py b/src/mpes_tools/cursor_handler.py
new file mode 100644
index 0000000..d743bb8
--- /dev/null
+++ b/src/mpes_tools/cursor_handler.py
@@ -0,0 +1,29 @@
+class Cursor_handler:
+    def __init__(self,fig,ax, artist, changes=None,parent=None):
+        self.artist=artist
+        self.active_cursor=None
+        self.changes=changes
+        self.parent = parent
+        self.ax=ax
+        self.fig=fig
+        self.fig.canvas.mpl_connect('pick_event', self.on_pick)
+        self.fig.canvas.mpl_connect('motion_notify_event', self.on_motion)
+        self.fig.canvas.mpl_connect('button_release_event', self.on_release)
+    def on_pick(self,event): # function to pick up the cursors or the dots
+        if event.artist == self.artist and self.parent.active_handler is None:
+            self.active_cursor = self.artist
+            self.parent.active_handler = self 
+    def on_motion(self,event): # function to move the cursors or the dots
+        if self.active_cursor is not None and event.inaxes == self.ax:
+            if self.active_cursor == self.artist:
+                if self.artist.get_xdata()[0]==self.artist.get_xdata()[1]:
+                    self.artist.set_xdata([event.xdata, event.xdata])
+                    self.changes()
+                else :
+                    self.artist.set_ydata([event.ydata, event.ydata])
+                    self.changes()
+    def on_release(self,event):
+        self.active_cursor = None  
+        self.parent.active_handler = None
+ 
+                
diff --git a/src/mpes_tools/dot_handler.py b/src/mpes_tools/dot_handler.py
new file mode 100644
index 0000000..1405e6e
--- /dev/null
+++ b/src/mpes_tools/dot_handler.py
@@ -0,0 +1,22 @@
+class Dot_handler:
+    def __init__(self,fig,ax, artist, changes=None):
+        self.artist=artist
+        self.active_cursor=None
+        self.changes=changes
+        self.ax=ax
+        self.fig=fig
+        self.fig.canvas.mpl_connect('pick_event', self.on_pick)
+        self.fig.canvas.mpl_connect('motion_notify_event', self.on_motion)
+        self.fig.canvas.mpl_connect('button_release_event', self.on_release)
+    def on_pick(self,event): # function to pick up the cursors or the dots
+        if event.artist == self.artist:
+            self.active_cursor = self.artist
+    def on_motion(self,event): # function to move the cursors or the dots
+        if self.active_cursor is not None and event.inaxes == self.ax:
+            if self.active_cursor == self.artist:
+                self.artist.center= (event.xdata, event.ydata)
+                self.changes()
+    def on_release(self,event):
+        self.active_cursor = None  
+        
+                

From 15c8af71afeabcd6f13469af7ec552dbff766d90 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 18 Apr 2025 15:52:04 +0200
Subject: [PATCH 33/67] modified accordingly the fit panel since the input
 array got modified

---
 src/mpes_tools/fit_panel.py | 47 ++++++++++++++-----------------------
 1 file changed, 17 insertions(+), 30 deletions(-)

diff --git a/src/mpes_tools/fit_panel.py b/src/mpes_tools/fit_panel.py
index e38e552..a654799 100644
--- a/src/mpes_tools/fit_panel.py
+++ b/src/mpes_tools/fit_panel.py
@@ -19,7 +19,7 @@
 
 
 class fit_panel(QMainWindow):
-    def __init__(self,data,c1,c2,t,dt,panel):
+    def __init__(self,data,t,dt,panel):
         super().__init__()
 
         self.setWindowTitle("Main Window")
@@ -74,7 +74,7 @@ def __init__(self,data,c1,c2,t,dt,panel):
         self.slider = QSlider(Qt.Horizontal)
         self.slider.setMinimum(0)
         # self.slider.setMaximum(len(axis[2])-1)
-        self.slider.setMaximum(len(data[data.dims[2]])-1)
+        self.slider.setMaximum(len(data[data.dims[1]])-1)
         self.slider.setValue(t)
         self.slider.valueChanged.connect(self.update_label)
         self.slider2 = QSlider(Qt.Horizontal)
@@ -86,8 +86,8 @@ def __init__(self,data,c1,c2,t,dt,panel):
         # self.label = QLabel("Slider Value: {t}")
         # self.label2 = QLabel("Slider Value: {dt}")
         
-        self.label = QLabel(f"{data.dims[2]}: {t}")
-        self.label2 = QLabel("Δ"+f"{data.dims[2]}: {dt}")
+        self.label = QLabel(f"{data.dims[1]}: {t}")
+        self.label2 = QLabel("Δ"+f"{data.dims[1]}: {dt}")
 
         # Create two checkboxes
         self.checkbox1 = QCheckBox("Multiply with Fermi Dirac")
@@ -241,34 +241,22 @@ def zero(x):
         self.t0_state = False
         self.offset_state = False
         self.data=data
-        x_min = min(c1, c2)
-        x_max = max(c1, c2)
-        # print('xmin=',x_min,'xmax=',x_max)
-        if panel =='box':
-            self.y=data
-        elif panel == data.dims[1]:
-            self.data_t=data.sel({data.dims[0]:slice(x_min, x_max)}).sum(dim=data.dims[0])
-            self.dim=data.dims[1]
-        elif panel ==data.dims[0]:
-            self.data_t=data.sel({data.dims[1]:slice(x_min, x_max)}).sum(dim=data.dims[1])
-            self.dim=data.dims[0]
-        self.panel=panel
         self.t=t
         self.dt=dt
-        # print(t,dt)
-        self.data=data
+        self.dim=data.dims[0]
+        self.panel=panel
         self.slider.setValue(self.t)
         self.slider2.setValue(self.dt)
-        # self.data_t=self.data
         self.plot_graph(t,dt)
         self.fit_results=[]
-        self.axs=data[data.dims[2]].data
+        self.axs=data[data.dims[1]].data
 
     def plot_graph(self,t,dt):
         self.axis.clear()
 
         if self.panel != 'box':
-            self.y=self.data_t.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
+            self.y=self.data.isel({self.data.dims[1]:slice(t, t+dt+1)}).sum(dim=self.data.dims[1])
+        
         self.y.plot(ax=self.axis)
         if self.checkbox0.isChecked():
             if self.cursor_handler is None:
@@ -287,8 +275,7 @@ def constant (self,x,A):
     def linear (self,x,a,b):
         return a*x+b
     def lorentzian(self,x, A, x0, gamma):
-        c=0.0000
-        return A / (1 + ((x - x0) / (gamma+c)) ** 2)
+        return A / (1 + ((x - x0) / (gamma)) ** 2)
     def fermi_dirac(self,x, mu, T):
         kb = 8.617333262145 * 10**(-5)  # Boltzmann constant in eV/K
         return 1 / (1 + np.exp((x - mu) / (kb * T)))
@@ -687,7 +674,7 @@ def zero(x):
             self.params['offset'].set(value=self.y_f.data.min())
         
         for i in range(min_val,max_val-self.dt):
-            self.y=self.data_t.isel({self.data.dims[2]:slice(i, i+self.dt+1)}).sum(dim=self.data.dims[2])
+            self.y=self.data.isel({self.data.dims[1]:slice(i, i+self.dt+1)}).sum(dim=self.data.dims[1])
             self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
             self.x_f=self.y_f[self.dim]
             self.axis.clear()
@@ -708,7 +695,7 @@ def zero(x):
         
             
         # sg=showgraphs(self.axs[min_val:max_val-self.dt], self.fit_results)
-        sg=showgraphs(self.data[self.data.dims[2]][min_val:max_val-self.dt], self.fit_results)
+        sg=showgraphs(self.data[self.data.dims[1]][min_val:max_val-self.dt], self.fit_results)
         sg.show()
         self.graph_windows.append(sg)
         
@@ -753,7 +740,7 @@ def zero(x):
         
         if self.t0_state==False:
             for i in range(len(self.axs)-self.dt):
-                self.y=self.data_t.isel({self.data.dims[2]:slice(i, i+self.dt+1)}).sum(dim=self.data.dims[2])
+                self.y=self.data.isel({self.data.dims[1]:slice(i, i+self.dt+1)}).sum(dim=self.data.dims[1])
                 self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
                 self.x_f=self.y_f[self.dim]
                 self.axis.clear()
@@ -773,7 +760,7 @@ def zero(x):
             self.x_f=self.y_f[self.dim]
             
             for i in range(0,mid_val-self.dt):
-                self.y=self.data_t.isel({self.data.dims[2]:slice(i, i+self.dt+1)}).sum(dim=self.data.dims[2])
+                self.y=self.data.isel({self.data.dims[1]:slice(i, i+self.dt+1)}).sum(dim=self.data.dims[1])
                 self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
                 self.x_f=self.y_f[self.dim]
                 self.axis.clear()
@@ -795,7 +782,7 @@ def zero(x):
             self.x_f=self.y_f[self.dim]
             
             for i in range(mid_val-self.dt,len(self.axs)-self.dt):
-                self.y=self.data_t.isel({self.data.dims[2]:slice(i, i+self.dt+1)}).sum(dim=self.data.dims[2])
+                self.y=self.data.isel({self.data.dims[1]:slice(i, i+self.dt+1)}).sum(dim=self.data.dims[1])
                 self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
                 self.x_f=self.y_f[self.dim]
                 self.axis.clear()
@@ -818,8 +805,8 @@ def zero(x):
                 self.fit_results.append(getattr(self, pname))
                 names.append(pname)
         # print('th dt',self.dt)    
-        # print('the xaxis',len(self.data[self.data.dims[2]][:len(self.data[self.data.dims[2]])-self.dt]))
-        sg=showgraphs(self.data[self.data.dims[2]][:len(self.data[self.data.dims[2]])-self.dt], self.fit_results,names,list_axis,list_plot_fits)
+        # print('the xaxis',len(self.data[self.data.dims[1]][:len(self.data[self.data.dims[1]])-self.dt]))
+        sg=showgraphs(self.data[self.data.dims[1]][:len(self.data[self.data.dims[1]])-self.dt], self.fit_results,names,list_axis,list_plot_fits)
         sg.show()
         self.graph_windows.append(sg)
 

From 14306e8b34552579f92155f11edb884babd41dc1 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Wed, 23 Apr 2025 18:52:30 +0200
Subject: [PATCH 34/67] added the error bars which is fed to graphs

---
 src/mpes_tools/fit_panel.py | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/src/mpes_tools/fit_panel.py b/src/mpes_tools/fit_panel.py
index a654799..f0e3d2c 100644
--- a/src/mpes_tools/fit_panel.py
+++ b/src/mpes_tools/fit_panel.py
@@ -249,6 +249,7 @@ def zero(x):
         self.slider2.setValue(self.dt)
         self.plot_graph(t,dt)
         self.fit_results=[]
+        self.fit_results_err=[]
         self.axs=data[data.dims[1]].data
 
     def plot_graph(self,t,dt):
@@ -706,6 +707,7 @@ def fit_all(self):
         fixed_list=[]
         names=[]
         self.fit_results=[]
+        self.fit_results_err=[]
         def zero(x):
             return 0
         cursors= self.cursor_handler.cursors()
@@ -753,6 +755,11 @@ def zero(x):
                     array[i]=out.best_values[pname]
                     setattr(self, pname,array)
                     
+                    err_array = getattr(self, f"{pname}_err",np.zeros_like(array))
+                    stderr = out.params[pname].stderr
+                    err_array[i] = stderr
+                    setattr(self, f"{pname}_err", err_array)
+                    
         else:
             if self.mid_value_input.text() is not None:
                 mid_val = int(self.mid_value_input.text())
@@ -772,6 +779,11 @@ def zero(x):
                     array=getattr(self, pname)
                     array[i]=out.best_values[pname]
                     setattr(self, pname,array)
+                    
+                    err_array = getattr(self, f"{pname}_err",np.zeros_like(array))
+                    stderr = out.params[pname].stderr
+                    err_array[i] = stderr
+                    setattr(self, f"{pname}_err", err_array)
             sigma_mean= getattr(self, 'sigma')[0:mid_val-self.dt].mean()
             self.params['sigma'].set(value=sigma_mean, vary=False )
             # print(sigma_mean)
@@ -781,6 +793,7 @@ def zero(x):
             self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
             self.x_f=self.y_f[self.dim]
             
+            
             for i in range(mid_val-self.dt,len(self.axs)-self.dt):
                 self.y=self.data.isel({self.data.dims[1]:slice(i, i+self.dt+1)}).sum(dim=self.data.dims[1])
                 self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
@@ -794,19 +807,26 @@ def zero(x):
                     array=getattr(self, pname)
                     array[i]=out.best_values[pname]
                     setattr(self, pname,array)
+                    
+                    err_array = getattr(self, f"{pname}_err",np.zeros_like(array))
+                    stderr = out.params[pname].stderr
+                    err_array[i] = stderr
+                    setattr(self, f"{pname}_err", err_array)
             # print('second T',getattr(self, 'T'))
         if self.dt>0:
             # self.axs=self.axs[:-self.dt]
             for pname, par in self.params.items():
                 self.fit_results.append(getattr(self, pname)[:-self.dt])
+                self.fit_results_err.append(getattr(self, f"{pname}_err")[:-self.dt]) 
                 names.append(pname)
         else:
             for pname, par in self.params.items():
                 self.fit_results.append(getattr(self, pname))
+                self.fit_results_err.append(getattr(self, f"{pname}_err"))
                 names.append(pname)
         # print('th dt',self.dt)    
         # print('the xaxis',len(self.data[self.data.dims[1]][:len(self.data[self.data.dims[1]])-self.dt]))
-        sg=showgraphs(self.data[self.data.dims[1]][:len(self.data[self.data.dims[1]])-self.dt], self.fit_results,names,list_axis,list_plot_fits)
+        sg=showgraphs(self.data[self.data.dims[1]][:len(self.data[self.data.dims[1]])-self.dt], self.fit_results,self.fit_results_err,names,list_axis,list_plot_fits)
         sg.show()
         self.graph_windows.append(sg)
 

From 08120d6919259c856c46e510c731a13b596bb849 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Wed, 23 Apr 2025 18:53:17 +0200
Subject: [PATCH 35/67] added the error bars and checkboxes to show them, added
 a cursor for the delays and configured the right click button to extract the
 data

---
 src/mpes_tools/graphs.py | 145 ++++++++++++++++++++++++++++-----------
 1 file changed, 105 insertions(+), 40 deletions(-)

diff --git a/src/mpes_tools/graphs.py b/src/mpes_tools/graphs.py
index 2bef341..1efc59d 100644
--- a/src/mpes_tools/graphs.py
+++ b/src/mpes_tools/graphs.py
@@ -1,14 +1,18 @@
 import sys
 import numpy as np
-from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QPushButton, QGridLayout,QSlider,QLabel
+from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QPushButton, QGridLayout,QSlider,QLabel,QCheckBox
+from PyQt5.QtCore import Qt
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 import matplotlib.pyplot as plt
 from IPython.core.getipython import get_ipython
 from mpes_tools.double_click_handler import SubplotClickHandler
 from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
 import xarray as xr
+from mpes_tools.right_click_handler import RightClickHandler
+from PyQt5.QtWidgets import QMenu
+from PyQt5.QtGui import QCursor
 class showgraphs(QMainWindow):
-    def __init__(self, x, y_arrays,names,list_axis,list_plot_fits):
+    def __init__(self, x, y_arrays,y_arrays_err,names,list_axis,list_plot_fits):
         super().__init__()
         self.setWindowTitle("Multiple Array Plots")
         self.setGeometry(100, 100, 800, 600)
@@ -17,6 +21,7 @@ def __init__(self, x, y_arrays,names,list_axis,list_plot_fits):
         self.dim=x.dims[0]
         self.x = x.data
         self.y_arrays = y_arrays
+        self.y_arrays_err = y_arrays_err
         self.num_plots = len(y_arrays)
         self.list_plot_fits=list_plot_fits 
         self.list_axis=list_axis
@@ -27,34 +32,45 @@ def __init__(self, x, y_arrays,names,list_axis,list_plot_fits):
         
         # print(len(x),len(list_plot_fits))
         # print(list_plot_fits[0])
-        slider = QSlider()
-        slider.setOrientation(1)  # 1 = Qt.Horizontal
-        slider.setMinimum(0)
-        slider.setMaximum(len(x)-1)  # Adjust as needed
-        slider.setValue(0)  # Default value
-        slider.valueChanged.connect(self.update_parameter)  # Function to update parameter
+        self.slider = QSlider()
+        self.slider.setOrientation(1)  # 1 = Qt.Horizontal
+        self.slider.setMinimum(0)
+        self.slider.setMaximum(len(x)-1)  # Adjust as needed
+        self.slider.setValue(0)  # Default value
+          # Function to update parameter
         
         self.slider_label = QLabel(f"{x.dims[0]}:0")
         
         self.figure, self.axis = plt.subplots()
         self.canvas = FigureCanvas(self.figure)
         plt.close(self.figure)
+        
+        self.toolbar = NavigationToolbar(self.canvas, self)
+        
+        
+        layout_plot = QVBoxLayout()
+        layout_plot.addWidget(self.toolbar)  # assuming `layout` is your QVBoxLayout or similar
+        layout_plot.addWidget(self.canvas) 
+        
+        widget_plot = QWidget()
+        widget_plot.setLayout(layout_plot)
+        
         vbox = QVBoxLayout()
-        vbox.addWidget(self.canvas)
+        vbox.addWidget(widget_plot)
         vbox.addWidget(self.slider_label)
-        vbox.addWidget(slider)
+        vbox.addWidget(self.slider)
         
         layout.addLayout(vbox, 0, 0)  # Place in top-left
-        self.update_parameter(0)
+        
         self.click_handlers=[]
+        self.handler_list=[]
         self.ax_list=[]
         self.data_list=[]
+        self.cursor_list=[]
         # Create and add buttons and plots for each y array in a 3x3 layout
         for i, y in enumerate(y_arrays):
             # Create a button to show the plot in a new window
-            button = QPushButton(f"Show Plot {i+1}")
-            button.setFixedSize(80, 30)  # Set a fixed size for the button
-            button.clicked.connect(lambda checked, y=y, index=i+1: self.show_plot(y, index, names[i]))
+            
             data_array = xr.DataArray(
                 data=y,
                 dims=[self.dim],                # e.g., 'energy', 'time', etc.
@@ -62,19 +78,58 @@ def __init__(self, x, y_arrays,names,list_axis,list_plot_fits):
                 name=names[i]                      # Optional: give it a name (like the plot title)
             )
             self.data_list.append(data_array)
+            
             # Calculate grid position
             row = ((i+1) // 3) * 2   # Each function will take 2 rows: one for the plot, one for the button
             col = (i+1) % 3
-            widget,canvas,ax=self.create_plot_widget(data_array, f"Plot {i+1}_"+names[i])
+            widget,canvas,ax=self.create_plot_widget(data_array,y_arrays_err[i], names[i])
             # Add the plot canvas to the grid
+            checkbox = QCheckBox(f"Show error bars {i+1}")
+            checkbox.setFixedSize(120, 30)  # Adjust size if needed
+            checkbox.stateChanged.connect(lambda state, data_array=data_array, y_err=y_arrays_err[i], index=i: self.show_err(state, data_array, y_err, index))
             
             layout.addWidget(widget, row, col)  # Plot in a 3x3 grid
             # layout.addWidget(self.create_plot_widget(y, f"Plot {i+1}_"+names[i]), row, col)  # Plot in a 3x3 grid
-            layout.addWidget(button, row + 1, col)  # Button directly below the corresponding plot
-            handler = SubplotClickHandler(ax, self.external_callback)
-            canvas.mpl_connect("button_press_event", handler.handle_double_click)
-            self.click_handlers.append(handler)
+            layout.addWidget(checkbox, row + 1, col)  # Button directly below the corresponding plot
+            handler = RightClickHandler(canvas, ax,self.show_pupup_window)
+            canvas.mpl_connect("button_press_event", handler.on_right_click)
+            self.handler_list.append(handler)
+            # handler = SubplotClickHandler(ax, self.external_callback)
+            # canvas.mpl_connect("button_press_event", handler.handle_double_click)
+            # self.click_handlers.append(handler)
             self.ax_list.append(ax)
+            self.cursor=ax.axvline(x=self.x[0], color='r', linestyle='--')
+            self.cursor_list.append(self.cursor)
+        self.update_parameter(0)
+        self.slider.valueChanged.connect(self.update_parameter)
+        
+    def show_pupup_window(self,canvas,ax):
+        # print(f"External callback: clicked subplot ({i},{j})")
+        for i, ax_item in enumerate(self.ax_list):
+            if ax == ax_item:
+                data = self.data_list[i]
+                coords = {k: data.coords[k].values.tolist() for k in data.coords}
+                dims = data.dims
+                name = data.name if data.name else f"data_{i}"
+                menu = QMenu(canvas)
+                action1 = menu.addAction(f"{data.name} plot")
+                action = menu.exec_(QCursor.pos())
+        
+                if action == action1:
+                    print(f'''
+import xarray as xr
+import numpy as np
+
+data_array = xr.DataArray(
+    data=np.array({data.values.tolist()}),
+    dims={dims},
+    coords={coords},
+    name="{name}"
+)
+''')
+                
+
+        
     def external_callback(self,ax):
         # print(f"External callback: clicked subplot ({i},{j})")
         for i, ax_item in enumerate(self.ax_list):
@@ -106,12 +161,15 @@ def external_callback(self,ax):
         QApplication.processEvents()
         print('results extracted!')
         
-    def create_plot_widget(self, data_array, title):
+    def create_plot_widget(self, data_array, y_err , title):
         """Creates a plot widget for displaying a function."""
         
         figure, ax = plt.subplots()
         plt.close(figure)
-        data_array.plot(ax=ax)
+        
+        # ax.errorbar(data_array[data_array.dims[0]].values, data_array.values, yerr=y_err, fmt='o', capsize=3)
+        ax.plot(data_array[data_array.dims[0]].values, data_array.values,'o')
+        # data_array.plot(ax=ax,fmt='o', capsize=3)
         ax.set_title(title)
         # print('create_plot'+f"self.ax id: {id(ax)}")
         # Create a FigureCanvas to embed in the Qt layout
@@ -127,16 +185,23 @@ def create_plot_widget(self, data_array, title):
         layout.addWidget(canvas)
         return widget,canvas,ax  # Return the canvas so it can be used in the layout
 
-    def show_plot(self, y, index, name):
-        """Show the plot in a new window."""
-        figure, ax = plt.subplots()
-        ax.plot(self.x, y)
-        ax.set_title(f"Plot {index}_"+ name)
-        ax.grid(True)
-        ax.set_xlabel(self.dim)
-        # ax.set_ylabel('y')
-        plt.show()  # Show the figure in a new window
+    def show_err(self,state,data_array,y_err,i):
+        self.ax_list[i].clear()
+        if state == Qt.Checked:
+            self.ax_list[i].errorbar(data_array[data_array.dims[0]].values, data_array.values, yerr=y_err, fmt='o', capsize=3)
+        else:
+            self.ax_list[i].plot(data_array[data_array.dims[0]].values, data_array.values,'o')
+            # data_array.plot(ax=self.ax_list[i], fmt='o', capsize=3)
+        self.ax_list[i].set_title(data_array.name)
+        self.cursor_list[i]=self.ax_list[i].axvline(x=self.x[self.slider.value()], color='r', linestyle='--')
+        self.ax_list[i].figure.canvas.draw_idle()
+            
     def update_parameter(self, value):
+        for i, c in enumerate(self.cursor_list):
+            if c is not None:
+                c.remove()
+            self.cursor_list[i]=self.ax_list[i].axvline(x=self.x[value], color='r', linestyle='--')
+            self.ax_list[i].figure.canvas.draw_idle()
         base = self.slider_label.text().split(':')[0]
         self.slider_label.setText(f"{base}: {self.x[value]:.2f}")
         self.axis.clear()
@@ -146,19 +211,19 @@ def update_parameter(self, value):
         self.axis.legend()
         self.figure.tight_layout()
         self.canvas.draw()
-    def create_plot_widget1(self,x_data, y_data, title, return_axes=False):
-        from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
-        import matplotlib.pyplot as plt
+    # def create_plot_widget1(self,x_data, y_data, title, return_axes=False):
+    #     from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+    #     import matplotlib.pyplot as plt
     
-        fig, ax = plt.subplots()
-        canvas = FigureCanvas(fig)  
+    #     fig, ax = plt.subplots()
+    #     canvas = FigureCanvas(fig)  
     
-        ax.plot(x_data,y_data)
-        ax.set_title(title)
+    #     ax.plot(x_data,y_data)
+    #     ax.set_title(title)
     
-        if return_axes:
-            return canvas, ax  # Allow updating later
-        return canvas
+    #     if return_axes:
+    #         return canvas, ax  # Allow updating later
+    #     return canvas
 
 if __name__ == "__main__":
     app = QApplication(sys.argv)

From 72a07a5251474677c1b7c2b4fc0aa22573e18c61 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Wed, 23 Apr 2025 18:54:29 +0200
Subject: [PATCH 36/67] removed an usued block

---
 src/mpes_tools/Gui_3d.py | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index f54db8c..064e846 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -42,11 +42,6 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         self.click_handlers = []
         self.handler_list = []
             
-        # for idx, ax in enumerate(self.axs.flatten()):
-        #     handler = SubplotClickHandler(ax, self.external_callback)
-        #     ax.figure.canvas.mpl_connect("button_press_event", handler.handle_double_click)
-        #     self.click_handlers.append(handler)
-            
         for idx, ax in enumerate(self.axs.flatten()):
             handler = RightClickHandler(self.canvas, ax,self.show_pupup_window)
             self.canvas.mpl_connect("button_press_event", handler.on_right_click)

From eee3402d8bf3622a880a3a7c43f99326a832d9f4 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Wed, 23 Apr 2025 18:55:06 +0200
Subject: [PATCH 37/67] added cursors for the delay in the energy_time plot
 from all the time/delay sliders

---
 src/mpes_tools/show_4d_window.py | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/src/mpes_tools/show_4d_window.py b/src/mpes_tools/show_4d_window.py
index 78376e0..501f1a4 100644
--- a/src/mpes_tools/show_4d_window.py
+++ b/src/mpes_tools/show_4d_window.py
@@ -445,6 +445,12 @@ def update_dt(self,yt,dyt,xt,dxt):
         ax.set_title(f'ky: {yt1:.2f}, ky+dky: {yt2:.2f} , kx: {xt1:.2f}, kx+dkx: {xt2:.2f}')
         self.kx_ky_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
         self.kx_ky_delta_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
+        self.energy_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[0].value()].item(), color='r', linestyle='--')
+        self.delta_energy_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[0].value()+self.slider4[0].value()].item(), color='r', linestyle='--')
+        self.ky_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[1].value()].item(), color='b', linestyle='--')
+        self.delta_ky_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[1].value()+self.slider4[1].value()].item(), color='b', linestyle='--')
+        self.kx_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[2].value()].item(), color='g', linestyle='--')
+        self.delta_kx_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[2].value()+self.slider4[2].value()].item(), color='g', linestyle='--')
         self.graphs[3].tight_layout()
         self.graphs[3].canvas.draw_idle()
         
@@ -471,6 +477,10 @@ def slider_changed(self, value):
                 self.ky_delta_energy_cursor.remove()
             if self.kx_ky_delta_energy_cursor in self.graphs[3].gca().lines:
                 self.kx_ky_delta_energy_cursor.remove()
+            if self.energy_time_cursor in self.graphs[3].gca().lines:
+                self.energy_time_cursor.remove()
+            if self.delta_energy_time_cursor in self.graphs[3].gca().lines:
+                self.delta_energy_time_cursor.remove()
             self.kx_energy_cursor = self.graphs[2].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
             self.ky_energy_cursor = self.graphs[1].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
             self.kx_ky_energy_cursor = self.graphs[3].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
@@ -478,7 +488,8 @@ def slider_changed(self, value):
             self.kx_delta_energy_cursor = self.graphs[2].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
             self.ky_delta_energy_cursor = self.graphs[1].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
             self.kx_ky_delta_energy_cursor = self.graphs[3].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
-            # self.graphs[2].tight_layout()
+            self.energy_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[0].value()].item(), color='r', linestyle='--')
+            self.delta_energy_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[0].value()+self.slider4[0].value()].item(), color='r', linestyle='--')
             self.graphs[2].canvas.draw_idle()
             self.graphs[1].canvas.draw_idle()
             self.graphs[3].canvas.draw_idle()
@@ -489,10 +500,17 @@ def slider_changed(self, value):
                 self.energy_ky_cursor.remove()
             if self.energy_delta_ky_cursor is not None:
                 self.energy_delta_ky_cursor.remove()
+            if self.ky_time_cursor in self.graphs[3].gca().lines:
+                self.ky_time_cursor.remove()
+            if self.delta_ky_time_cursor in self.graphs[3].gca().lines:
+                self.delta_ky_time_cursor.remove()
            
             self.energy_ky_cursor = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider1[1].value()].item(), color='r', linestyle='--')
             self.energy_delta_ky_cursor = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider1[1].value()+self.slider2[1].value()].item(), color='r', linestyle='--')
+            self.ky_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[1].value()].item(), color='b', linestyle='--')
+            self.delta_ky_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[1].value()+self.slider4[1].value()].item(), color='b', linestyle='--')
             self.graphs[0].canvas.draw_idle()
+            self.graphs[3].canvas.draw_idle()
             self.update_ky(self.slider1[1].value(), self.slider2[1].value(),self.slider3[1].value(), self.slider4[1].value())
         elif index in range (8,12):
             ax = self.graphs[0].gca()
@@ -500,8 +518,15 @@ def slider_changed(self, value):
                 self.energy_kx_cursor.remove()
             if self.energy_delta_kx_cursor in ax.lines:
                 self.energy_delta_kx_cursor.remove()
+            if self.kx_time_cursor in self.graphs[3].gca().lines:
+                self.kx_time_cursor.remove()
+            if self.delta_kx_time_cursor in self.graphs[3].gca().lines:
+                self.delta_kx_time_cursor.remove()
             self.energy_kx_cursor = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
             self.energy_delta_kx_cursor = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()+self.slider2[2].value()].item(), color='r', linestyle='--')
+            self.kx_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[2].value()].item(), color='g', linestyle='--')
+            self.delta_kx_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[2].value()+self.slider4[2].value()].item(), color='g', linestyle='--')
+            self.graphs[3].canvas.draw_idle()
             self.graphs[0].canvas.draw_idle()
             self.update_kx(self.slider1[2].value(), self.slider2[2].value(),self.slider3[2].value(), self.slider4[2].value())
         elif index in range (12,16):

From f955c1c770bf75b85b020713cbdcd2a2ca499565 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Wed, 23 Apr 2025 19:15:03 +0200
Subject: [PATCH 38/67] modified the logic a bit by changing the
 checkbox_changed and deleted the old code for saving the data

---
 src/mpes_tools/Gui_3d.py | 172 +++------------------------------------
 1 file changed, 13 insertions(+), 159 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index 064e846..d1f24dc 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -54,9 +54,6 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         self.checkbox_k = QCheckBox("Integrate_k")
         self.checkbox_k.stateChanged.connect(self.checkbox_k_changed)
 
-        self.save_button = QPushButton('Extract results', self)
-        self.save_button.clicked.connect(self.create_new_cell)
-        # self.save_button.clicked.connect(self.save_results)
         
         #create the layout
         h_layout = QHBoxLayout()
@@ -84,7 +81,6 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         layout.addLayout(checkbox_layout)
         layout.addLayout(h_layout)
         layout.addWidget(self.canvas)
-        layout.addWidget(self.save_button)
         
         slider_layout= QHBoxLayout()
         self.slider1 = QSlider(Qt.Horizontal)
@@ -139,8 +135,6 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         self.slider1.valueChanged.connect(self.slider1_changed)
         self.slider2.valueChanged.connect(self.slider2_changed)
         
-        #run the main code to show the graphs and cursors
-        # self.show_graphs(t,dt)
         
         #create a menu for the fit panel
         menu_bar = self.menuBar()
@@ -237,33 +231,33 @@ def changes_cursor_vertical_1(self):
         self.dot1.center = (x_val, self.dot1.center[1])
         base = self.cursor_label[0].text().split(':')[0]
         self.cursor_label[0].setText(f"{base}: {x_val:.2f}")
-        self.fig.canvas.draw_idle()
         self.update_mdc()
         self.box()
+        self.fig.canvas.draw_idle() 
     def changes_cursor_horizontal_1(self):
         y_val= self.cursor_horiz1.get_ydata()[0]
         self.dot1.center = (self.dot1.center[0],y_val)
         base = self.cursor_label[1].text().split(':')[0]
         self.cursor_label[1].setText(f"{base}: {y_val:.2f}")
-        self.fig.canvas.draw_idle()
         self.update_edc()
         self.box()
+        self.fig.canvas.draw_idle() 
     def changes_cursor_vertical_2(self):
         x_val= self.cursor_vert2.get_xdata()[0]
         self.dot2.center = (x_val, self.dot2.center[1])
         base = self.cursor_label[2].text().split(':')[0]
         self.cursor_label[2].setText(f"{base}: {x_val:.2f}")
-        self.fig.canvas.draw_idle()
         self.update_mdc()
         self.box()
+        self.fig.canvas.draw_idle() 
     def changes_cursor_horizontal_2(self):
         y_val= self.cursor_horiz2.get_ydata()[0]
         self.dot2.center = (self.dot2.center[0], y_val)
         base = self.cursor_label[3].text().split(':')[0]
         self.cursor_label[3].setText(f"{base}: {y_val:.2f}")
-        self.fig.canvas.draw_idle()
         self.update_edc()
         self.box()
+        self.fig.canvas.draw_idle() 
     def changes_dot1(self):
         x_val,y_val= self.dot1.center
         self.cursor_vert1.set_xdata([x_val,x_val])
@@ -272,10 +266,10 @@ def changes_dot1(self):
         self.cursor_label[0].setText(f"{base}: {x_val:.2f}")
         base = self.cursor_label[1].text().split(':')[0]
         self.cursor_label[1].setText(f"{base}: {y_val:.2f}")
-        self.fig.canvas.draw_idle()
         self.update_edc()
         self.update_mdc()
         self.box()
+        self.fig.canvas.draw_idle() 
     def changes_dot2(self):
         x_val,y_val= self.dot2.center
         self.cursor_vert2.set_xdata([x_val,x_val])
@@ -284,10 +278,10 @@ def changes_dot2(self):
         self.cursor_label[2].setText(f"{base}: {x_val:.2f}")
         base = self.cursor_label[3].text().split(':')[0]
         self.cursor_label[3].setText(f"{base}: {y_val:.2f}")
-        self.fig.canvas.draw_idle() 
         self.update_edc()
         self.update_mdc()
         self.box()
+        self.fig.canvas.draw_idle() 
    
     def show_pupup_window(self,canvas,ax):
         if ax==self.axs[0,0]:
@@ -378,138 +372,7 @@ def show_pupup_window(self,canvas,ax):
               f"{max(self.dot1.center[0], self.dot2.center[0]):.2f}" +
               ")}].sum(dim=(data.dims[0], data.dims[1]))  # Box integration")
                 
-    def external_callback(self,ax):
-        # print(f"External callback: clicked subplot ({i},{j})")
-        if ax==self.axs[0,0]:
-            content= f"""
-data='your data_array'
-data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)
-#the 2D plot data
-data2D_plot=data.isel({{data.dims[2]:slice({self.slider1.value()}, {self.slider1.value()+self.slider2.value()+1})}}).sum(dim=data.dims[2])   
-
-            """
-        elif ax==self.axs[1,0]:
-            content= f"""
-data='your data_array'
-data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)
-#the 2D plot data
-data2D_plot=data.isel({{data.dims[2]:slice({self.slider1.value()}, {self.slider1.value()+self.slider2.value()+1})}}).sum(dim=data.dims[2])   
-# The yellow EDC
-data2D_plot.sel({{data.dims[0]:{self.dot1.center[1]}}}, method='nearest')
-# The green EDC
-data2D_plot.sel({{data.dims[0]:{self.dot2.center[1]}}}, method='nearest')
-# the integrated EDC
-data2D_plot.sel({{data.dims[0]:slice(min({self.dot2.center[1]},{self.dot1.center[1]}), max({self.dot2.center[1]},{self.dot1.center[1]}))}}).sum(dim=data.dims[0])
-
-            """
-        elif ax==self.axs[0,1]:
-            content= f"""
-data='your data_array'
-data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)
-#the 2D plot data
-data2D_plot=data.isel({{data.dims[2]:slice({self.slider1.value()}, {self.slider1.value()+self.slider2.value()+1})}}).sum(dim=data.dims[2])   
-# The yellow MDC
-data2D_plot.sel({{data.dims[1]:{self.dot1.center[0]}}}, method='nearest')
-# The green MDC
-data2D_plot.sel({{data.dims[1]:{self.dot2.center[0]}}}, method='nearest')
-# the integrated MDC
-data2D_plot.sel({{data.dims[1]:slice(min({self.dot2.center[0]},{self.dot1.center[0]}), max({self.dot2.center[0]},{self.dot1.center[0]}))}}).sum(dim=data.dims[1])
-
-            """
-        elif ax==self.axs[1,1]:
-            content= f"""
-data='your data_array'
-data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)
-#the intensity box data
-data.loc[{{data.dims[0]: slice(*sorted([{self.dot1.center[1]}, {self.dot2.center[1]}])), 
-           data.dims[1]: slice(*sorted([{self.dot1.center[0]}, {self.dot2.center[0]}]))}}].sum(dim=(data.dims[0], data.dims[1]))
-
-            """
-        shell = get_ipython()
-        payload = dict(
-            source='set_next_input',
-            text=content,
-            replace=False,
-        )
-        shell.payload_manager.write_payload(payload, single=False)
-        # shell.run_cell("%gui qt")
-        QApplication.processEvents()
-        print('results extracted!')
-        
-    def create_new_cell(self):
-        content = f"""
-# Code generated by GUI for the following parameters:
-import matplotlib.pyplot as plt
-
-# data= 'your data_array'
-data=V1
-data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)
-time1={self.axis[2][self.slider1.value()]}
-time2={self.axis[2][self.slider1.value()+self.slider2.value()]}
-t={self.slider1.value()}
-dt={self.slider2.value()}
-data2D_plot=data.isel({{data.dims[2]:slice(t, t+dt+1)}}).sum(dim=data.dims[2])
-yellowline_edc_energy={self.dot1.center[1]}
-greenline_edc_energy={self.dot2.center[1]}
-yellowline_mdc_momentum={self.dot1.center[0]}
-greenline_mdc_momentum={self.dot2.center[0]}
-#plot Data_2d between t and t+dt
-fig,ax=plt.subplots(1,1,figsize=(12,8))
-data2D_plot.plot(ax=ax, cmap='terrain', add_colorbar=False)
-#plot EDC yellow and green
-fig,ax=plt.subplots(1,1,figsize=(12,8))
-data2D_plot.sel({{data.dims[0]:yellowline_edc_energy}}, method='nearest').plot(ax=ax,color='orange')
-data2D_plot.sel({{data.dims[0]:greenline_edc_energy}}, method='nearest').plot(ax=ax,color='green')
-#plot integrated EDC
-fig,ax=plt.subplots(1,1,figsize=(12,8))
-data2D_plot.sel({{data.dims[0]:slice(min(greenline_edc_energy,yellowline_edc_energy), max(greenline_edc_energy,yellowline_edc_energy))}}).sum(dim=data.dims[0]).plot(ax=ax)
-#plot MDC yellow and green
-fig,ax=plt.subplots(1,1,figsize=(12,8))
-data2D_plot.sel({{data.dims[1]:yellowline_mdc_momentum}}, method='nearest').plot(ax=ax,color='orange')
-data2D_plot.sel({{data.dims[1]:greenline_mdc_momentum}}, method='nearest').plot(ax=ax,color='green')
-#plot integrated MDC
-fig,ax=plt.subplots(1,1,figsize=(12,8))
-data2D_plot.sel({{data.dims[1]:slice(min(greenline_mdc_momentum,yellowline_mdc_momentum), max(greenline_mdc_momentum,yellowline_mdc_momentum))}}).sum(dim=data.dims[1]).plot(ax=ax)
-#plot integrated intensity in the box between the cursors
-fig,ax=plt.subplots(1,1,figsize=(12,8))
-x0,y0=({self.dot1.center[0]},{self.dot1.center[1]})
-x1,y1=({self.dot2.center[0]},{self.dot2.center[1]})
-x0, x1 = sorted([x0, x1])
-y0, y1 = sorted([y0, y1])
-data.loc[{{data.dims[0]: slice(y0, y1), data.dims[1]: slice(x0, x1)}}].sum(dim=(data.dims[0], data.dims[1])).plot(ax=ax)
-
-        """
-        shell = get_ipython()
-        payload = dict(
-            source='set_next_input',
-            text=content,
-            replace=False,
-        )
-        shell.payload_manager.write_payload(payload, single=False)
-        shell.run_cell('pass')
-        print('results extracted!')
-    def save_results(self):#save the relevant results in a .pkl file which can be accessed easily for Jupyter Notebook workflow
-        results = {
-            'integrated_edc': self.integrated_edc,
-            'integrated_mdc': self.integrated_mdc,
-            'yellowline_edc': self.data2D_plot.sel({self.data.dims[0]:self.dot1.center[1]}, method='nearest'), 
-            'greenline_edc': self.data2D_plot.sel({self.data.dims[0]:self.dot2.center[1]}, method='nearest'),
-            'yellowline_mdc': self.data2D_plot.sel({self.data.dims[1]: self.dot1.center[0]}, method='nearest'),
-            'greenline_mdc': self.data2D_plot.sel({self.data.dims[1]: self.dot2.center[0]}, method='nearest'),
-            'current_spectra': self.data2D_plot,
-            'intensity_box': self.int,
-            'yellow_vertical': self.dot1.center[0],
-            'yellow_horizontal': self.dot1.center[1],
-            'green_vertical': self.dot2.center[0],
-            'green_horizontal': self.dot2.center[1],
-            'delay1':self.axis[2][self.slider1.value()],
-            'delay2':self.axis[2][self.slider1.value()+self.slider2.value()]
-        }
-        with open('gui_results.pkl', 'wb') as f:
-            pickle.dump(results, f)
-        # with open('gui_results.json', 'w') as f:
-        #     json.dump(results, f)
-        print("Results saved!")
+   
                   
     def main_graph_cursor_changed(self, index): #set manually the values for the cursors in the main graph
         value = self.cursor_inputs[index].text()
@@ -558,21 +421,12 @@ def slider2_changed(self,value): # change the slider controlling the third dimen
         self.update_show()
         self.dt=self.slider2.value()
     def checkbox_e_changed(self, state): # Checkbox for integrating the EDC between the cursors
-        if state == Qt.Checked:
-            self.integrate_E()
-        else:
-            self.data2D_plot.sel({self.data.dims[0]:self.dot1.center[1]}, method='nearest').plot(ax=self.axs[1,0],color='orange')
-            self.data2D_plot.sel({self.data.dims[0]:self.dot2.center[1]}, method='nearest').plot(ax=self.axs[1,0],color='green')
-            # self.update_show(self.slider1.value(),self.slider2.value())
+        self.update_edc()
+        self.fig.canvas.draw_idle()
     def checkbox_k_changed(self, state): # Checkbox for integrating the MDC between the cursors
-        if state == Qt.Checked:
-            self.integrate_k()
-        else:
-            self.data2D_plot.sel({self.data.dims[1]:self.dot1.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='orange')
-            self.data2D_plot.sel({self.data.dims[1]:self.dot2.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='green')
-            # self.update_show(self.slider1.value(),self.slider2.value())
+        self.update_mdc()
+        self.fig.canvas.draw_idle()
 
-    
     def fit_energy_panel(self,event): # open up the fit panel for the EDC 
         x_min = min(self.dot2.center[1], self.dot1.center[1])
         x_max = max(self.dot2.center[1], self.dot1.center[1])
@@ -617,7 +471,7 @@ def integrate_E(self): # integrate EDC between the two cursors in the main graph
         # self.data2D_plot.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0]).plot(ax=self.axs[1,0])
         self.integrated_edc=self.data2D_plot.sel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
         self.integrated_edc.plot(ax=self.axs[1,0])
-        self.fig.canvas.draw_idle()
+        # self.fig.canvas.draw_idle()
 
     def integrate_k(self): # integrate MDC between the two cursors in the main graph
         self.axs[0, 1].clear()
@@ -628,7 +482,7 @@ def integrate_k(self): # integrate MDC between the two cursors in the main graph
         # self.data2D_plot.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1]).plot(ax=self.axs[0,1])
         self.integrated_mdc=self.data2D_plot.sel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
         self.integrated_mdc.plot(ax=self.axs[0,1])
-        self.fig.canvas.draw_idle()
+        # self.fig.canvas.draw_idle()
 
     def box(self): # generate the intensity graph between the four cursors in the main graph
         self.axs[1, 1].clear()

From 5818cb70c2e1aea5c1c60c28791aa62df856a9bf Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Thu, 24 Apr 2025 19:02:12 +0200
Subject: [PATCH 39/67] added colorscale sliders to the show_4d_window

---
 src/mpes_tools/show_4d_window.py | 94 +++++++++++++++++++++-----------
 1 file changed, 63 insertions(+), 31 deletions(-)

diff --git a/src/mpes_tools/show_4d_window.py b/src/mpes_tools/show_4d_window.py
index 501f1a4..baab5de 100644
--- a/src/mpes_tools/show_4d_window.py
+++ b/src/mpes_tools/show_4d_window.py
@@ -13,6 +13,7 @@
 from mpes_tools.right_click_handler import RightClickHandler
 from PyQt5.QtWidgets import QMenu
 from PyQt5.QtGui import QCursor
+from colorscale_slider_handler import colorscale_slider
 
 class show_4d_window(QMainWindow):
     def __init__(self,data_array: xr.DataArray):
@@ -40,28 +41,35 @@ def __init__(self,data_array: xr.DataArray):
         self.click_handlers=[]
         self.handler_list=[]
         self.axis_list=[]
+        self.graph_layout_list=[]
+        self.color_graph_list=[]
+        self.list=[]
         plt.ioff()
         for i in range(2):
             for j in range(2):
-                graph_window = QWidget()
-                graph_layout = QVBoxLayout()
-                graph_window.setLayout(graph_layout)
+                self.graph_window = QWidget()
+                self.graph_layout = QVBoxLayout()
+                self.graph_window.setLayout(self.graph_layout)
 
                 # Create a figure and canvas for the graph
                 figure, axis = plt.subplots(figsize=(10, 10))
                 plt.close(figure)
                 canvas = FigureCanvas(figure)
-                # handler = SubplotClickHandler(axis, self.external_callback)
-                # canvas.mpl_connect("button_press_event", handler.handle_double_click)
-                # self.click_handlers.append(handler)
+
                 handler = RightClickHandler(canvas, axis,self.show_pupup_window)
                 canvas.mpl_connect("button_press_event", handler.on_right_click)
                 self.handler_list.append(handler)
                 
-                graph_layout.addWidget(canvas)
+                # self.color_graph=QHBoxLayout()
+                # self.color_graph.addWidget(canvas)
+                
+                self.graph_layout.addWidget(canvas)
+                # self.graph_layout.addWidget(self.color_graph)
                 self.axis_list.append(axis)
                 self.canvases.append(canvas)
                 
+                # self.color_graph_list.append(self.color_graph)
+                
                 
                 slider_layout= QHBoxLayout()
                 slider_layout_2= QHBoxLayout()
@@ -105,12 +113,12 @@ def __init__(self,data_array: xr.DataArray):
                 # slider2.valueChanged.connect(self.slider_changed)
 
                 # Add the slider to the layout
-                graph_layout.addLayout(slider_layout)
-                graph_layout.addLayout(slider_layout_2)
+                self.graph_layout.addLayout(slider_layout)
+                self.graph_layout.addLayout(slider_layout_2)
                 # graph_layout.addWidget(slider3)
                 # graph_layout.addWidget(slider2)
 
-                layout.addWidget(graph_window, i, j)
+                layout.addWidget(self.graph_window, i, j)
                 self.graphs.append(figure)
                 self.slider1.append(slider1)
                 self.slider2.append(slider2)
@@ -118,14 +126,8 @@ def __init__(self,data_array: xr.DataArray):
                 self.slider4.append(slider4)
                 self.sliders.extend([slider1, slider2,slider3, slider4])
                 self.slider_labels.extend([slider1_label, slider2_label,slider3_label, slider4_label])
-                
-        # self.xv = None
-        # self.yv = None
-        # self.energy_kx_cursor = None
-        # self.energy_ky_cursor = None
-        # self.kx_ky_energy_cursor= None
-        # self.energy_kxky_x=None
-        # self.energy_kxky_y=None
+                self.graph_layout_list.append(self.graph_layout)
+
 
         for slider in self.slider1:   
             slider.valueChanged.connect(self.slider_changed)
@@ -155,7 +157,6 @@ def __init__(self,data_array: xr.DataArray):
         graph_menu.addAction(open_graphy_action)
         # file_menu.addAction(open_graph_action)
         self.graph_windows = []
-        self.ce=None
 
         self.show()
         self.load_data(data_array)
@@ -367,28 +368,55 @@ def load_data(self, data_array: xr.DataArray):
         self.slider_labels[15].setText("Δ"+self.axes[0])
         
         
+        # data_avg=self.data_array.loc[{self.axes[2]:slice(self.data_array[self.axes[2]][self.slider1[0].value()].item(),self.data_array[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item()),
+        #                               self.axes[3]:slice(self.data_array[self.axes[3]][self.slider3[0].value()].item(),self.data_array[self.axes[3]][self.slider3[0].value()+self.slider4[0].value()].item())}].mean(dim=(self.axes[2], self.axes[3]))
+        
+        data_avg=self.data_array.isel({self.axes[2]:slice(0,0), self.axes[3]:slice(0,0)}).mean(dim=(self.axes[2], self.axes[3]))
+        self.im0=data_avg.T.plot(ax=self.graphs[0].gca(),cmap='terrain', add_colorbar=False)
+        
+        data_avg=self.data_array.isel({self.axes[1]:slice(0,0), self.axes[3]:slice(0,0)}).mean(dim=(self.axes[1], self.axes[3]))
+        self.im1=data_avg.T.plot(ax=self.graphs[1].gca(),cmap='terrain', add_colorbar=False)
+        
+        data_avg=self.data_array.isel({self.axes[0]:slice(0,0), self.axes[3]:slice(0,0)}).mean(dim=(self.axes[0], self.axes[3]))
+        self.im2=data_avg.T.plot(ax=self.graphs[2].gca(),cmap='terrain', add_colorbar=False)
+        
+        data_avg=self.data_array.isel({self.axes[1]:slice(0,0), self.axes[0]:slice(0,0)}).mean(dim=(self.axes[1], self.axes[0]))
+        self.im3=data_avg.plot(ax=self.graphs[3].gca(),cmap='terrain', add_colorbar=False)
+        
         self.update_energy(self.slider1[0].value(),self.slider2[0].value(),self.slider3[0].value(), self.slider4[0].value())
-
+        
         self.update_ky(self.slider1[1].value(), self.slider2[1].value(),self.slider3[1].value(), self.slider4[1].value())
     
         self.update_kx(self.slider1[2].value(), self.slider2[2].value(),self.slider3[2].value(), self.slider4[2].value())
         
         self.update_dt(self.slider1[3].value(), self.slider2[3].value(), self.slider3[3].value(), self.slider4[3].value())
+        
+        self.graphs[0].gca().figure.colorbar(self.im0, ax=self.graphs[0].gca())
     
+        print('the limits=',[self.data_array.min(),self.data_array.max()])
+        
+        self.im0.set_clim([self.data_array.min(),self.data_array.max()])
+        self.im1.set_clim([self.data_array.min(),self.data_array.max()])
+        self.im2.set_clim([self.data_array.min(),self.data_array.max()])
+        self.im3.set_clim([self.data_array.min(),self.data_array.max()])
     
+        colorscale_slider(self.graph_layout_list[0], self.im0, self.canvases[0], [self.data_array.min(),self.data_array.max()])
+        colorscale_slider(self.graph_layout_list[1], self.im1, self.canvases[1], [self.data_array.min(),self.data_array.max()])
+        colorscale_slider(self.graph_layout_list[2], self.im2, self.canvases[2], [self.data_array.min(),self.data_array.max()])
+        colorscale_slider(self.graph_layout_list[3], self.im3, self.canvases[3], [self.data_array.min(),self.data_array.max()])
     def update_energy(self,Energy,dE,te,dte):
-        self.ce_state=True
         E1=self.data_array[self.axes[2]][Energy].item()
         E2=self.data_array[self.axes[2]][Energy+dE].item()
         te1=self.data_array[self.axes[3]][te].item()
         te2=self.data_array[self.axes[3]][te+dte].item()
-
         ax=self.graphs[0].gca()
-        ax.cla() 
+        
         data_avg=self.data_array.loc[{self.axes[2]:slice(E1,E2), self.axes[3]:slice(te1,te2)}].mean(dim=(self.axes[2], self.axes[3]))
-        self.im=data_avg.T.plot(ax=ax,cmap='terrain', add_colorbar=False)
+        self.im0.set_array(data_avg.T.values) 
+        # vmin, vmax = np.min(data_avg), np.max(data_avg)
+        # self.im0.set_clim(vmin, vmax)  # Update the limits of the colormap
+        ax.set_aspect('auto')
         ax.set_title(f'energy: {E1:.2f}, E+dE: {E2:.2f} , t: {te1:.2f}, t+dt: {te2:.2f}')
-        
         self.energy_kx_cursor = ax.axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
         self.energy_ky_cursor = ax.axhline(y=self.data_array.coords[self.axes[1]][self.slider1[1].value()].item(), color='r', linestyle='--')
         self.energy_kxky_x = ax.axvline(x=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
@@ -408,8 +436,9 @@ def update_ky(self,ypos,dy,ty,dty):
         ty2=self.data_array[self.axes[3]][ty+dty].item()
         
         ax=self.graphs[1].gca()
-        ax.cla() 
-        self.data_array.loc[{self.axes[1]:slice(y1,y2), self.axes[3]:slice(ty1,ty2)}].mean(dim=(self.axes[1], self.axes[3])).T.plot(ax=ax,cmap='terrain', add_colorbar=False)
+        data_avg=self.data_array.loc[{self.axes[1]:slice(y1,y2), self.axes[3]:slice(ty1,ty2)}].mean(dim=(self.axes[1], self.axes[3]))
+        self.im1.set_array(data_avg.T.values) 
+        ax.set_aspect('auto')
         ax.set_title(f'ky: {y1:.2f}, ky+dky: {y2:.2f} , t: {ty1:.2f}, t+dt: {ty2:.2f}')
         self.ky_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
         self.ky_delta_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
@@ -424,8 +453,9 @@ def update_kx(self,xpos,dx,tx,dtx):
         tx2=self.data_array[self.axes[3]][tx+dtx].item()
         
         ax=self.graphs[2].gca()
-        ax.cla() 
-        self.data_array.loc[{self.axes[0]:slice(x1,x2), self.axes[3]:slice(tx1,tx2)}].mean(dim=(self.axes[0], self.axes[3])).T.plot(ax=ax,cmap='terrain', add_colorbar=False)
+        data_avg=self.data_array.loc[{self.axes[0]:slice(x1,x2), self.axes[3]:slice(tx1,tx2)}].mean(dim=(self.axes[0], self.axes[3]))
+        self.im2.set_array(data_avg.T.values) 
+        ax.set_aspect('auto')
         ax.set_title(f'kx: {x1:.2f}, kx+dkx: {x2:.2f} , t: {tx1:.2f}, t+dt: {tx2:.2f}')
         self.kx_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
         self.kx_delta_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
@@ -440,8 +470,10 @@ def update_dt(self,yt,dyt,xt,dxt):
         xt2=self.data_array[self.axes[0]][xt+dxt].item()
         
         ax=self.graphs[3].gca()
-        ax.cla() 
-        self.data_array.loc[{self.axes[1]:slice(yt1,yt2), self.axes[0]:slice(xt1,xt2)}].mean(dim=(self.axes[1], self.axes[0])).plot(ax=ax,cmap='terrain', add_colorbar=False)
+  
+        data_avg=self.data_array.loc[{self.axes[1]:slice(yt1,yt2), self.axes[0]:slice(xt1,xt2)}].mean(dim=(self.axes[1], self.axes[0]))
+        self.im3.set_array(data_avg.values) 
+        ax.set_aspect('auto')
         ax.set_title(f'ky: {yt1:.2f}, ky+dky: {yt2:.2f} , kx: {xt1:.2f}, kx+dkx: {xt2:.2f}')
         self.kx_ky_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
         self.kx_ky_delta_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')

From 72274465d3b72012453221f55fb5b4559eb08bf9 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Thu, 24 Apr 2025 19:03:08 +0200
Subject: [PATCH 40/67] the function for adding a colorscale slider with two
 handlers for min and max

---
 src/mpes_tools/colorscale_slider_handler.py | 69 +++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 src/mpes_tools/colorscale_slider_handler.py

diff --git a/src/mpes_tools/colorscale_slider_handler.py b/src/mpes_tools/colorscale_slider_handler.py
new file mode 100644
index 0000000..e2a0649
--- /dev/null
+++ b/src/mpes_tools/colorscale_slider_handler.py
@@ -0,0 +1,69 @@
+from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QLabel,QHBoxLayout
+from superqt import QRangeSlider
+from PyQt5.QtCore import Qt
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+import sys
+
+class colorscale_slider(QWidget):
+    def __init__(self, layout, imshow_artist,canvas, limits=None):
+        super().__init__()
+
+        self.im = imshow_artist
+        self.canvas = canvas
+        self.colorbar = None  # Optional: set this externally if you want to update a colorbar
+        if limits is None:
+            self.data = imshow_artist.get_array().data
+            self.vmin, self.vmax = float(np.min(self.data)), float(np.max(self.data))
+        else: 
+            self.vmin,self.vmax= limits
+        if self.vmin==self.vmax:
+            self.vmax += 0.1
+        self.cmin, self.cmax = 10, 1e5
+
+        # Slider Widget
+        slider_widget = QWidget()
+        slider_layout = QVBoxLayout(slider_widget)
+
+        self.slider = QRangeSlider(Qt.Vertical)
+        self.slider.setFixedWidth(15)
+        self.slider.setMinimum(int(1 * self.cmin))
+        self.slider.setMaximum(int(1* self.cmax))
+        print('new_values',[self.new_values(self.vmin), self.new_values(self.vmax)])
+        self.slider.setValue([self.new_values(self.vmin), self.new_values(self.vmax)])
+        # self.slider.valueChanged.connect(self.update_clim)
+        self.slider.valueChanged.connect(lambda value: self.update_clim(value))
+
+        self.label = QLabel(f"{self.vmin:.2f} to {self.vmax:.2f}")
+        # self.label = QLabel(' ')
+        slider_layout.addWidget(self.label)
+        slider_layout.addWidget(self.slider)
+
+        # New horizontal layout: slider left, canvas right
+        h_container = QWidget()
+        h_layout = QHBoxLayout(h_container)
+        h_layout.addWidget(slider_widget)
+        h_layout.addWidget(self.canvas)
+        h_layout.addWidget(self.canvas, stretch=1)
+
+        layout.insertWidget(0, h_container)
+
+    def new_values(self, x):
+        a = (self.cmax - self.cmin) / (self.vmax - self.vmin)
+        b = self.vmax * self.cmin - self.vmin * self.cmax
+        return int(a * x + b)
+
+    def inverse(self, x):
+        a = (self.cmax - self.cmin) / (self.vmax - self.vmin)
+        b = self.vmax * self.cmin - self.vmin * self.cmax
+        return (x - b) / a
+
+    def update_clim(self, value):
+        vmin, vmax = self.inverse(value[0]), self.inverse(value[1])
+        print('theinverse,',value)
+        self.im.set_clim(vmin, vmax)
+        self.label.setText(f" {vmin:.2f} to {vmax:.2f}")
+        if self.colorbar:
+            self.colorbar.update_normal(self.im)
+        self.canvas.draw_idle()

From 3e31a2226d9c611a1942cdb0a6771a1a8585c3d6 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 11:43:57 +0200
Subject: [PATCH 41/67] changed the initialization of the cursors and how they
 are updated

---
 src/mpes_tools/show_4d_window.py | 171 +++++++++++++------------------
 1 file changed, 74 insertions(+), 97 deletions(-)

diff --git a/src/mpes_tools/show_4d_window.py b/src/mpes_tools/show_4d_window.py
index baab5de..4a6a5ef 100644
--- a/src/mpes_tools/show_4d_window.py
+++ b/src/mpes_tools/show_4d_window.py
@@ -368,9 +368,21 @@ def load_data(self, data_array: xr.DataArray):
         self.slider_labels[15].setText("Δ"+self.axes[0])
         
         
-        # data_avg=self.data_array.loc[{self.axes[2]:slice(self.data_array[self.axes[2]][self.slider1[0].value()].item(),self.data_array[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item()),
-        #                               self.axes[3]:slice(self.data_array[self.axes[3]][self.slider3[0].value()].item(),self.data_array[self.axes[3]][self.slider3[0].value()+self.slider4[0].value()].item())}].mean(dim=(self.axes[2], self.axes[3]))
         
+        self.initialize_plots()
+        self.initialize_cursors()
+        
+        self.update_energy(self.slider1[0].value(),self.slider2[0].value(),self.slider3[0].value(), self.slider4[0].value())
+        
+        self.update_ky(self.slider1[1].value(), self.slider2[1].value(),self.slider3[1].value(), self.slider4[1].value())
+    
+        self.update_kx(self.slider1[2].value(), self.slider2[2].value(),self.slider3[2].value(), self.slider4[2].value())
+        
+        self.update_dt(self.slider1[3].value(), self.slider2[3].value(), self.slider3[3].value(), self.slider4[3].value())
+        
+        
+        
+    def initialize_plots(self): 
         data_avg=self.data_array.isel({self.axes[2]:slice(0,0), self.axes[3]:slice(0,0)}).mean(dim=(self.axes[2], self.axes[3]))
         self.im0=data_avg.T.plot(ax=self.graphs[0].gca(),cmap='terrain', add_colorbar=False)
         
@@ -383,17 +395,10 @@ def load_data(self, data_array: xr.DataArray):
         data_avg=self.data_array.isel({self.axes[1]:slice(0,0), self.axes[0]:slice(0,0)}).mean(dim=(self.axes[1], self.axes[0]))
         self.im3=data_avg.plot(ax=self.graphs[3].gca(),cmap='terrain', add_colorbar=False)
         
-        self.update_energy(self.slider1[0].value(),self.slider2[0].value(),self.slider3[0].value(), self.slider4[0].value())
-        
-        self.update_ky(self.slider1[1].value(), self.slider2[1].value(),self.slider3[1].value(), self.slider4[1].value())
-    
-        self.update_kx(self.slider1[2].value(), self.slider2[2].value(),self.slider3[2].value(), self.slider4[2].value())
-        
-        self.update_dt(self.slider1[3].value(), self.slider2[3].value(), self.slider3[3].value(), self.slider4[3].value())
-        
         self.graphs[0].gca().figure.colorbar(self.im0, ax=self.graphs[0].gca())
-    
-        print('the limits=',[self.data_array.min(),self.data_array.max()])
+        self.graphs[1].gca().figure.colorbar(self.im1, ax=self.graphs[1].gca())
+        self.graphs[2].gca().figure.colorbar(self.im2, ax=self.graphs[2].gca())
+        self.graphs[3].gca().figure.colorbar(self.im3, ax=self.graphs[3].gca())
         
         self.im0.set_clim([self.data_array.min(),self.data_array.max()])
         self.im1.set_clim([self.data_array.min(),self.data_array.max()])
@@ -404,6 +409,34 @@ def load_data(self, data_array: xr.DataArray):
         colorscale_slider(self.graph_layout_list[1], self.im1, self.canvases[1], [self.data_array.min(),self.data_array.max()])
         colorscale_slider(self.graph_layout_list[2], self.im2, self.canvases[2], [self.data_array.min(),self.data_array.max()])
         colorscale_slider(self.graph_layout_list[3], self.im3, self.canvases[3], [self.data_array.min(),self.data_array.max()])
+        
+    def initialize_cursors(self):
+        
+        ax=self.graphs[0].gca()
+        self.energy_kx_cursor = ax.axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
+        self.energy_ky_cursor = ax.axhline(y=self.data_array.coords[self.axes[1]][self.slider1[1].value()].item(), color='r', linestyle='--')
+        self.energy_kxky_x = ax.axvline(x=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
+        self.energy_kxky_y = ax.axhline(y=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
+        self.energy_delta_kx_cursor = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()+self.slider2[2].value()].item(), color='r', linestyle='--')
+        self.energy_delta_ky_cursor = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider1[1].value()+self.slider2[1].value()].item(), color='r', linestyle='--')
+        self.energy_delta_kxky_y = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[1]][self.slider1[3].value()+self.slider2[3].value()].item(), color='b', linestyle='--')
+        self.energy_delta_kxky_x = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[0]][self.slider3[3].value()+self.slider4[3].value()].item(), color='b', linestyle='--')
+        ax=self.graphs[1].gca()
+        self.ky_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+        self.ky_delta_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
+        ax=self.graphs[2].gca()
+        self.kx_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+        self.kx_delta_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
+        ax=self.graphs[3].gca()
+        self.kx_ky_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+        self.kx_ky_delta_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
+        self.energy_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[0].value()].item(), color='r', linestyle='--')
+        self.delta_energy_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[0].value()+self.slider4[0].value()].item(), color='r', linestyle='--')
+        self.ky_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[1].value()].item(), color='b', linestyle='--')
+        self.delta_ky_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[1].value()+self.slider4[1].value()].item(), color='b', linestyle='--')
+        self.kx_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[2].value()].item(), color='g', linestyle='--')
+        self.delta_kx_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[2].value()+self.slider4[2].value()].item(), color='g', linestyle='--')
+        
     def update_energy(self,Energy,dE,te,dte):
         E1=self.data_array[self.axes[2]][Energy].item()
         E2=self.data_array[self.axes[2]][Energy+dE].item()
@@ -413,18 +446,8 @@ def update_energy(self,Energy,dE,te,dte):
         
         data_avg=self.data_array.loc[{self.axes[2]:slice(E1,E2), self.axes[3]:slice(te1,te2)}].mean(dim=(self.axes[2], self.axes[3]))
         self.im0.set_array(data_avg.T.values) 
-        # vmin, vmax = np.min(data_avg), np.max(data_avg)
-        # self.im0.set_clim(vmin, vmax)  # Update the limits of the colormap
         ax.set_aspect('auto')
         ax.set_title(f'energy: {E1:.2f}, E+dE: {E2:.2f} , t: {te1:.2f}, t+dt: {te2:.2f}')
-        self.energy_kx_cursor = ax.axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
-        self.energy_ky_cursor = ax.axhline(y=self.data_array.coords[self.axes[1]][self.slider1[1].value()].item(), color='r', linestyle='--')
-        self.energy_kxky_x = ax.axvline(x=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
-        self.energy_kxky_y = ax.axhline(y=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
-        self.energy_delta_kx_cursor = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()+self.slider2[2].value()].item(), color='r', linestyle='--')
-        self.energy_delta_ky_cursor = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider1[1].value()+self.slider2[1].value()].item(), color='r', linestyle='--')
-        self.energy_delta_kxky_y = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[1]][self.slider1[3].value()+self.slider2[3].value()].item(), color='b', linestyle='--')
-        self.energy_delta_kxky_x = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[0]][self.slider3[3].value()+self.slider4[3].value()].item(), color='b', linestyle='--')
         self.graphs[0].tight_layout()
         self.graphs[0].canvas.draw_idle()
         
@@ -440,8 +463,6 @@ def update_ky(self,ypos,dy,ty,dty):
         self.im1.set_array(data_avg.T.values) 
         ax.set_aspect('auto')
         ax.set_title(f'ky: {y1:.2f}, ky+dky: {y2:.2f} , t: {ty1:.2f}, t+dt: {ty2:.2f}')
-        self.ky_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
-        self.ky_delta_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
         self.graphs[1].tight_layout()
         self.graphs[1].canvas.draw_idle()
         
@@ -457,8 +478,6 @@ def update_kx(self,xpos,dx,tx,dtx):
         self.im2.set_array(data_avg.T.values) 
         ax.set_aspect('auto')
         ax.set_title(f'kx: {x1:.2f}, kx+dkx: {x2:.2f} , t: {tx1:.2f}, t+dt: {tx2:.2f}')
-        self.kx_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
-        self.kx_delta_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
         self.graphs[2].tight_layout()
         self.graphs[2].canvas.draw_idle()
     
@@ -475,14 +494,6 @@ def update_dt(self,yt,dyt,xt,dxt):
         self.im3.set_array(data_avg.values) 
         ax.set_aspect('auto')
         ax.set_title(f'ky: {yt1:.2f}, ky+dky: {yt2:.2f} , kx: {xt1:.2f}, kx+dkx: {xt2:.2f}')
-        self.kx_ky_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
-        self.kx_ky_delta_energy_cursor = ax.axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
-        self.energy_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[0].value()].item(), color='r', linestyle='--')
-        self.delta_energy_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[0].value()+self.slider4[0].value()].item(), color='r', linestyle='--')
-        self.ky_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[1].value()].item(), color='b', linestyle='--')
-        self.delta_ky_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[1].value()+self.slider4[1].value()].item(), color='b', linestyle='--')
-        self.kx_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[2].value()].item(), color='g', linestyle='--')
-        self.delta_kx_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[2].value()+self.slider4[2].value()].item(), color='g', linestyle='--')
         self.graphs[3].tight_layout()
         self.graphs[3].canvas.draw_idle()
         
@@ -496,84 +507,50 @@ def slider_changed(self, value):
         self.slider_labels[index].setText(f"{base}: {value}")
 
         if index in range(0,4):
-            # ax = self.graphs[2].gca()
-            if self.kx_energy_cursor in self.graphs[2].gca().lines:
-                self.kx_energy_cursor.remove()
-            if self.ky_energy_cursor in self.graphs[1].gca().lines:
-                self.ky_energy_cursor.remove()
-            if self.kx_ky_energy_cursor in self.graphs[3].gca().lines:
-                self.kx_ky_energy_cursor.remove()
-            if self.kx_delta_energy_cursor in self.graphs[2].gca().lines:
-                self.kx_delta_energy_cursor.remove()
-            if self.ky_delta_energy_cursor in self.graphs[1].gca().lines:
-                self.ky_delta_energy_cursor.remove()
-            if self.kx_ky_delta_energy_cursor in self.graphs[3].gca().lines:
-                self.kx_ky_delta_energy_cursor.remove()
-            if self.energy_time_cursor in self.graphs[3].gca().lines:
-                self.energy_time_cursor.remove()
-            if self.delta_energy_time_cursor in self.graphs[3].gca().lines:
-                self.delta_energy_time_cursor.remove()
-            self.kx_energy_cursor = self.graphs[2].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
-            self.ky_energy_cursor = self.graphs[1].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
-            self.kx_ky_energy_cursor = self.graphs[3].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(), color='r', linestyle='--')
+            self.kx_energy_cursor.set_ydata([self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(),self.data_array.coords[self.axes[2]][self.slider1[0].value()].item()])
+            self.ky_energy_cursor.set_ydata([self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(),self.data_array.coords[self.axes[2]][self.slider1[0].value()].item()])
+            self.kx_ky_energy_cursor.set_ydata([self.data_array.coords[self.axes[2]][self.slider1[0].value()].item(),self.data_array.coords[self.axes[2]][self.slider1[0].value()].item()])
+            
+            self.kx_delta_energy_cursor.set_ydata([self.data_array.coords[self.axes[2]][self.slider1[0].value() + self.slider2[0].value()].item(),self.data_array.coords[self.axes[2]][self.slider1[0].value() + self.slider2[0].value()].item()])
+            self.ky_delta_energy_cursor.set_ydata([self.data_array.coords[self.axes[2]][self.slider1[0].value() + self.slider2[0].value()].item(),self.data_array.coords[self.axes[2]][self.slider1[0].value() + self.slider2[0].value()].item()])
+            self.kx_ky_delta_energy_cursor.set_ydata([self.data_array.coords[self.axes[2]][self.slider1[0].value() + self.slider2[0].value()].item(),self.data_array.coords[self.axes[2]][self.slider1[0].value() + self.slider2[0].value()].item()])
+            
+            self.energy_time_cursor.set_xdata([self.data_array.coords[self.axes[3]][self.slider3[0].value()].item(),self.data_array.coords[self.axes[3]][self.slider3[0].value()].item()])
+            self.delta_energy_time_cursor.set_xdata([self.data_array.coords[self.axes[3]][self.slider3[0].value() + self.slider4[0].value()].item(),self.data_array.coords[self.axes[3]][self.slider3[0].value() + self.slider4[0].value()].item()])
+
             
-            self.kx_delta_energy_cursor = self.graphs[2].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
-            self.ky_delta_energy_cursor = self.graphs[1].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
-            self.kx_ky_delta_energy_cursor = self.graphs[3].gca().axhline(y=self.data_array.coords[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()].item(), color='r', linestyle='--')
-            self.energy_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[0].value()].item(), color='r', linestyle='--')
-            self.delta_energy_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[0].value()+self.slider4[0].value()].item(), color='r', linestyle='--')
             self.graphs[2].canvas.draw_idle()
             self.graphs[1].canvas.draw_idle()
             self.graphs[3].canvas.draw_idle()
+            print(id(self.energy_time_cursor))
             self.update_energy(self.slider1[0].value(),self.slider2[0].value(),self.slider3[0].value(), self.slider4[0].value())
             
         elif index in range(4,8):
-            if self.energy_ky_cursor is not None:
-                self.energy_ky_cursor.remove()
-            if self.energy_delta_ky_cursor is not None:
-                self.energy_delta_ky_cursor.remove()
-            if self.ky_time_cursor in self.graphs[3].gca().lines:
-                self.ky_time_cursor.remove()
-            if self.delta_ky_time_cursor in self.graphs[3].gca().lines:
-                self.delta_ky_time_cursor.remove()
-           
-            self.energy_ky_cursor = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider1[1].value()].item(), color='r', linestyle='--')
-            self.energy_delta_ky_cursor = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[0]][self.slider1[1].value()+self.slider2[1].value()].item(), color='r', linestyle='--')
-            self.ky_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[1].value()].item(), color='b', linestyle='--')
-            self.delta_ky_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[1].value()+self.slider4[1].value()].item(), color='b', linestyle='--')
+
+            self.energy_ky_cursor.set_ydata([self.data_array.coords[self.axes[0]][self.slider1[1].value()].item(),self.data_array.coords[self.axes[0]][self.slider1[1].value()].item()])
+            self.energy_delta_ky_cursor.set_ydata([self.data_array.coords[self.axes[0]][self.slider1[1].value() + self.slider2[1].value()].item(),self.data_array.coords[self.axes[0]][self.slider1[1].value() + self.slider2[1].value()].item()])
+            self.ky_time_cursor.set_xdata([self.data_array.coords[self.axes[3]][self.slider3[1].value()].item(),self.data_array.coords[self.axes[3]][self.slider3[1].value()].item()])
+            self.delta_ky_time_cursor.set_xdata([self.data_array.coords[self.axes[3]][self.slider3[1].value() + self.slider4[1].value()].item(),self.data_array.coords[self.axes[3]][self.slider3[1].value() + self.slider4[1].value()].item()])
+
+            
             self.graphs[0].canvas.draw_idle()
             self.graphs[3].canvas.draw_idle()
             self.update_ky(self.slider1[1].value(), self.slider2[1].value(),self.slider3[1].value(), self.slider4[1].value())
         elif index in range (8,12):
-            ax = self.graphs[0].gca()
-            if self.energy_kx_cursor in ax.lines:
-                self.energy_kx_cursor.remove()
-            if self.energy_delta_kx_cursor in ax.lines:
-                self.energy_delta_kx_cursor.remove()
-            if self.kx_time_cursor in self.graphs[3].gca().lines:
-                self.kx_time_cursor.remove()
-            if self.delta_kx_time_cursor in self.graphs[3].gca().lines:
-                self.delta_kx_time_cursor.remove()
-            self.energy_kx_cursor = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(), color='r', linestyle='--')
-            self.energy_delta_kx_cursor = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[1]][self.slider1[2].value()+self.slider2[2].value()].item(), color='r', linestyle='--')
-            self.kx_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[2].value()].item(), color='g', linestyle='--')
-            self.delta_kx_time_cursor = self.graphs[3].gca().axvline(x=self.data_array.coords[self.axes[3]][self.slider3[2].value()+self.slider4[2].value()].item(), color='g', linestyle='--')
+            self.energy_kx_cursor.set_xdata([self.data_array.coords[self.axes[1]][self.slider1[2].value()].item(),self.data_array.coords[self.axes[1]][self.slider1[2].value()].item()])
+            self.energy_delta_kx_cursor.set_xdata([self.data_array.coords[self.axes[1]][self.slider1[2].value() + self.slider2[2].value()].item(),self.data_array.coords[self.axes[1]][self.slider1[2].value() + self.slider2[2].value()].item()])
+            self.kx_time_cursor.set_xdata([self.data_array.coords[self.axes[3]][self.slider3[2].value()].item(),self.data_array.coords[self.axes[3]][self.slider3[2].value()].item()])
+            self.delta_kx_time_cursor.set_xdata([self.data_array.coords[self.axes[3]][self.slider3[2].value() + self.slider4[2].value()].item(),self.data_array.coords[self.axes[3]][self.slider3[2].value() + self.slider4[2].value()].item()])
+
             self.graphs[3].canvas.draw_idle()
             self.graphs[0].canvas.draw_idle()
             self.update_kx(self.slider1[2].value(), self.slider2[2].value(),self.slider3[2].value(), self.slider4[2].value())
         elif index in range (12,16):
-            if self.energy_kxky_x in self.graphs[0].gca().lines:
-                self.energy_kxky_x.remove()
-            if self.energy_kxky_y in self.graphs[0].gca().lines:
-                self.energy_kxky_y.remove()
-            if self.energy_delta_kxky_x in self.graphs[0].gca().lines:
-                self.energy_delta_kxky_x.remove()
-            if self.energy_delta_kxky_y in self.graphs[0].gca().lines:
-                self.energy_delta_kxky_y.remove()
-            self.energy_kxky_y = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(), color='b', linestyle='--')
-            self.energy_kxky_x = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(), color='b', linestyle='--')
-            self.energy_delta_kxky_y = self.graphs[0].gca().axhline(y=self.data_array.coords[self.axes[1]][self.slider1[3].value()+self.slider2[3].value()].item(), color='b', linestyle='--')
-            self.energy_delta_kxky_x = self.graphs[0].gca().axvline(x=self.data_array.coords[self.axes[0]][self.slider3[3].value()+self.slider4[3].value()].item(), color='b', linestyle='--')
+
+            self.energy_kxky_y.set_ydata([self.data_array.coords[self.axes[1]][self.slider1[3].value()].item(),self.data_array.coords[self.axes[1]][self.slider1[3].value()].item()])
+            self.energy_kxky_x.set_xdata([self.data_array.coords[self.axes[0]][self.slider3[3].value()].item(),self.data_array.coords[self.axes[0]][self.slider3[3].value()].item()])
+            self.energy_delta_kxky_y.set_ydata([self.data_array.coords[self.axes[1]][self.slider1[3].value() + self.slider2[3].value()].item(),self.data_array.coords[self.axes[1]][self.slider1[3].value() + self.slider2[3].value()].item()])
+            self.energy_delta_kxky_x.set_xdata([self.data_array.coords[self.axes[0]][self.slider3[3].value() + self.slider4[3].value()].item(),self.data_array.coords[self.axes[0]][self.slider3[3].value() + self.slider4[3].value()].item()])
             self.graphs[0].canvas.draw_idle()
             self.update_dt(self.slider1[3].value(), self.slider2[3].value(), self.slider3[3].value(), self.slider4[3].value())
 

From 4c28ff33e3c28c77957838d40c623d6e329b3ce7 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 11:44:17 +0200
Subject: [PATCH 42/67] cleaned out some prints

---
 src/mpes_tools/colorscale_slider_handler.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/mpes_tools/colorscale_slider_handler.py b/src/mpes_tools/colorscale_slider_handler.py
index e2a0649..5ab0fb6 100644
--- a/src/mpes_tools/colorscale_slider_handler.py
+++ b/src/mpes_tools/colorscale_slider_handler.py
@@ -30,7 +30,6 @@ def __init__(self, layout, imshow_artist,canvas, limits=None):
         self.slider.setFixedWidth(15)
         self.slider.setMinimum(int(1 * self.cmin))
         self.slider.setMaximum(int(1* self.cmax))
-        print('new_values',[self.new_values(self.vmin), self.new_values(self.vmax)])
         self.slider.setValue([self.new_values(self.vmin), self.new_values(self.vmax)])
         # self.slider.valueChanged.connect(self.update_clim)
         self.slider.valueChanged.connect(lambda value: self.update_clim(value))
@@ -61,7 +60,6 @@ def inverse(self, x):
 
     def update_clim(self, value):
         vmin, vmax = self.inverse(value[0]), self.inverse(value[1])
-        print('theinverse,',value)
         self.im.set_clim(vmin, vmax)
         self.label.setText(f" {vmin:.2f} to {vmax:.2f}")
         if self.colorbar:

From 40b509a2df7fd49fa6f55d94606816dd18e2c107 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 14:33:26 +0200
Subject: [PATCH 43/67] cleaned up

---
 src/mpes_tools/show_4d_window.py | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/mpes_tools/show_4d_window.py b/src/mpes_tools/show_4d_window.py
index 4a6a5ef..f6e6c26 100644
--- a/src/mpes_tools/show_4d_window.py
+++ b/src/mpes_tools/show_4d_window.py
@@ -60,15 +60,10 @@ def __init__(self,data_array: xr.DataArray):
                 canvas.mpl_connect("button_press_event", handler.on_right_click)
                 self.handler_list.append(handler)
                 
-                # self.color_graph=QHBoxLayout()
-                # self.color_graph.addWidget(canvas)
-                
                 self.graph_layout.addWidget(canvas)
-                # self.graph_layout.addWidget(self.color_graph)
                 self.axis_list.append(axis)
                 self.canvases.append(canvas)
                 
-                # self.color_graph_list.append(self.color_graph)
                 
                 
                 slider_layout= QHBoxLayout()

From 9607b6bfbf1c32053ec6fc7c633ac70b1e892d18 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 14:34:03 +0200
Subject: [PATCH 44/67] changed the structure for the 4 plots each its own
 canvas and added the colorscale

---
 src/mpes_tools/Gui_3d.py | 172 +++++++++++++++++++++++----------------
 1 file changed, 100 insertions(+), 72 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index d1f24dc..34036b7 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -14,11 +14,13 @@
 from mpes_tools.double_click_handler import SubplotClickHandler
 import xarray as xr
 from mpes_tools.right_click_handler import RightClickHandler
-from PyQt5.QtWidgets import QMenu
+from PyQt5.QtWidgets import QMenu,QGridLayout,QHBoxLayout, QSizePolicy,QLabel
 from PyQt5.QtGui import QCursor
 from mpes_tools.cursor_dot_handler import Cursor_dot_handler
 from cursor_handler import Cursor_handler
 from dot_handler import Dot_handler
+from colorscale_slider_handler import colorscale_slider
+from matplotlib.figure import Figure
 #graphic window showing a 2d map controllable with sliders for the third dimension, with cursors showing cuts along the x direction for MDC and y direction for EDC
 # Two vertical cursors and two horizontal cursors are defined in the main graph with each same color for the cursors being horizontal and vertical intercept each other in a dot so one can move either each cursor or the dot itself which will move both cursors. 
 class Gui_3d(QMainWindow):  
@@ -36,16 +38,15 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         central_widget.setLayout(layout)
         
         
-        self.fig, self.axs = plt.subplots(2,2,figsize=(20,16))
-        plt.close(self.fig)
-        self.canvas = FigureCanvas(self.fig)
+        # self.fig, self.axs = plt.subplots(2,2,figsize=(20,16))
+        # plt.close(self.fig)
+        # self.canvas = FigureCanvas(self.fig)
+        
+        
         self.click_handlers = []
         self.handler_list = []
             
-        for idx, ax in enumerate(self.axs.flatten()):
-            handler = RightClickHandler(self.canvas, ax,self.show_pupup_window)
-            self.canvas.mpl_connect("button_press_event", handler.on_right_click)
-            self.handler_list.append(handler)
+        
         # plt.ioff()
         # add the checkboxes for EDC and MDC integration and the button to save the results
         self.checkbox_e = QCheckBox("Integrate_energy")
@@ -73,6 +74,23 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
             sub_layout.addWidget(label)
             sub_layout.addWidget(input_field)
             h_layout.addLayout(sub_layout)
+        
+        self.canvases = []
+        self.axes = []
+        
+        for i in range(4):
+            fig = Figure(figsize=(10, 8))  # optional: smaller size per plot
+            canvas = FigureCanvas(fig)
+            ax = fig.add_subplot(111)
+            self.canvases.append(canvas)
+            self.axes.append(ax)
+            
+        canvas_layout = QGridLayout()
+
+        canvas_layout.addWidget(self.canvases[0], 0, 0)
+        canvas_layout.addWidget(self.canvases[1], 0, 1)
+        canvas_layout.addWidget(self.canvases[2], 1, 0)
+        canvas_layout.addWidget(self.canvases[3], 1, 1)
 
         checkbox_layout= QHBoxLayout()
         # Add the canvas to the layout
@@ -80,7 +98,8 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         checkbox_layout.addWidget(self.checkbox_k)
         layout.addLayout(checkbox_layout)
         layout.addLayout(h_layout)
-        layout.addWidget(self.canvas)
+        layout.addLayout(canvas_layout)
+        # layout.addWidget(self.canvas)
         
         slider_layout= QHBoxLayout()
         self.slider1 = QSlider(Qt.Horizontal)
@@ -103,6 +122,14 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         slider_layout.addWidget(self.slider2_label)
         layout.addLayout(slider_layout)
 
+
+        for idx, ax in enumerate(self.axes):
+            handler = RightClickHandler(self.canvases[idx], ax,self.show_pupup_window)
+            self.canvases[idx].mpl_connect("button_press_event", handler.on_right_click)
+            self.handler_list.append(handler)
+        
+
+
         #define the data_array
         self.data=data_array
         self.axis=[data_array.coords[dim].data for dim in data_array.dims]
@@ -111,8 +138,8 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
             self.data = self.data.assign_coords(Ekin=self.data.coords['Ekin'] -21.7)
 
         # define the cut for the spectra of the main graph
-        # self.data2D_plot=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).sum(dim=self.data.dims[2])
-        self.data2D_plot=self.data.sel({self.data.dims[2]:slice(self.axis[2][t], self.axis[2][t + dt])}).sum(dim=self.data.dims[2])
+        # self.data2D_plot=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).mean(dim=self.data.dims[2])
+        self.data2D_plot=self.data.sel({self.data.dims[2]:slice(self.axis[2][t], self.axis[2][t + dt])}).mean(dim=self.data.dims[2])
         
         #Initialize the relevant prameters
         self.t=t
@@ -158,7 +185,8 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         print(data_array.dims)
         
         # plot the main graph
-        self.im = self.data2D_plot.plot(ax=self.axs[0, 0], cmap='terrain', add_colorbar=False)
+        self.im = self.data2D_plot.plot(ax=self.axes[0], cmap='terrain', add_colorbar=False)
+        colorscale_slider(canvas_layout, self.im, self.axes[0].figure.canvas)
         
         # define the initial positions of the cursors in the main graph
         
@@ -166,10 +194,10 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         initial_y = 0
         initial_x2 = 0.5
         initial_y2 = 0.5
-        ax = self.axs[0, 0]
+        ax = self.axes[0]
         # define the lines for the cursors
-        ymin, ymax = self.axs[0, 0].get_ylim()
-        xmin, xmax = self.axs[0, 0].get_ylim()
+        ymin, ymax = self.axes[0].get_ylim()
+        xmin, xmax = self.axes[0].get_ylim()
         ymin, ymax = 5 * ymin, 5 * ymax
         xmin, xmax = 5 * xmin, 5 * xmax
         self.cursor_vert1 = Line2D([initial_x, initial_x], [ymin, ymax], color='yellow', linewidth=2, picker=10, linestyle='--')
@@ -205,27 +233,29 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         # define the integrated EDC and MDC 
         x_min = min(self.dot2.center[1], self.dot1.center[1])
         x_max = max(self.dot2.center[1], self.dot1.center[1])
-        self.integrated_edc=self.data2D_plot.sel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
+        self.integrated_edc=self.data2D_plot.sel({self.data.dims[0]:slice(x_min, x_max)}).mean(dim=self.data.dims[0])
         x_min = min(self.dot1.center[0], self.dot2.center[0])
         x_max = max(self.dot1.center[0], self.dot2.center[0])
-        self.integrated_mdc=self.data2D_plot.sel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
+        self.integrated_mdc=self.data2D_plot.sel({self.data.dims[1]:slice(x_min, x_max)}).mean(dim=self.data.dims[1])
         self.active_handler = None
-        self.edc_yellow, = self.axs[1, 0].plot([], [], color='orange')
-        self.edc_green, = self.axs[1, 0].plot([], [], color='green')
+        self.edc_yellow, = self.axes[2].plot([], [], color='orange')
+        self.edc_green, = self.axes[2].plot([], [], color='green')
         self.update_show() 
-        self.fig.canvas.draw_idle()
+        self.update_all_canvases()
         self.cursor_dot_handler=[]
         self.cursors_list=[self.cursor_vert1, self.cursor_horiz1,self.cursor_vert2, self.cursor_horiz2]
         self.cursors_functions=[lambda:  self.changes_cursor_vertical_1(),lambda: self.changes_cursor_horizontal_1(), lambda: self.changes_cursor_vertical_2(),lambda: self.changes_cursor_horizontal_2()]
         self.dots_list=[self.dot1,self.dot2]
         self.dots_function=[lambda: self.changes_dot1(), lambda: self.changes_dot2()]
         for idx, c in enumerate(self.cursors_list):
-            c_handler = Cursor_handler(self.fig,self.axs[0,0],c, self.cursors_functions[idx],parent=self)
+            c_handler = Cursor_handler(self.canvases[0].figure,self.axes[0],c, self.cursors_functions[idx],parent=self)
             self.cursor_dot_handler.append(c_handler)
         for idx, d in enumerate(self.dots_list):
-            d_handler = Dot_handler(self.fig,self.axs[0,0], d, self.dots_function[idx])
+            d_handler = Dot_handler(self.canvases[0].figure,self.axes[0], d, self.dots_function[idx])
             self.cursor_dot_handler.append(d_handler)
-
+    def update_all_canvases(self):
+        for canvas in self.canvases:
+            canvas.draw_idle()         
     def changes_cursor_vertical_1(self):
         x_val= self.cursor_vert1.get_xdata()[0]
         self.dot1.center = (x_val, self.dot1.center[1])
@@ -233,7 +263,7 @@ def changes_cursor_vertical_1(self):
         self.cursor_label[0].setText(f"{base}: {x_val:.2f}")
         self.update_mdc()
         self.box()
-        self.fig.canvas.draw_idle() 
+        self.update_all_canvases() 
     def changes_cursor_horizontal_1(self):
         y_val= self.cursor_horiz1.get_ydata()[0]
         self.dot1.center = (self.dot1.center[0],y_val)
@@ -241,7 +271,7 @@ def changes_cursor_horizontal_1(self):
         self.cursor_label[1].setText(f"{base}: {y_val:.2f}")
         self.update_edc()
         self.box()
-        self.fig.canvas.draw_idle() 
+        self.update_all_canvases() 
     def changes_cursor_vertical_2(self):
         x_val= self.cursor_vert2.get_xdata()[0]
         self.dot2.center = (x_val, self.dot2.center[1])
@@ -249,7 +279,7 @@ def changes_cursor_vertical_2(self):
         self.cursor_label[2].setText(f"{base}: {x_val:.2f}")
         self.update_mdc()
         self.box()
-        self.fig.canvas.draw_idle() 
+        self.update_all_canvases() 
     def changes_cursor_horizontal_2(self):
         y_val= self.cursor_horiz2.get_ydata()[0]
         self.dot2.center = (self.dot2.center[0], y_val)
@@ -257,7 +287,7 @@ def changes_cursor_horizontal_2(self):
         self.cursor_label[3].setText(f"{base}: {y_val:.2f}")
         self.update_edc()
         self.box()
-        self.fig.canvas.draw_idle() 
+        self.update_all_canvases() 
     def changes_dot1(self):
         x_val,y_val= self.dot1.center
         self.cursor_vert1.set_xdata([x_val,x_val])
@@ -269,7 +299,7 @@ def changes_dot1(self):
         self.update_edc()
         self.update_mdc()
         self.box()
-        self.fig.canvas.draw_idle() 
+        self.update_all_canvases() 
     def changes_dot2(self):
         x_val,y_val= self.dot2.center
         self.cursor_vert2.set_xdata([x_val,x_val])
@@ -281,10 +311,10 @@ def changes_dot2(self):
         self.update_edc()
         self.update_mdc()
         self.box()
-        self.fig.canvas.draw_idle() 
+        self.update_all_canvases() 
    
     def show_pupup_window(self,canvas,ax):
-        if ax==self.axs[0,0]:
+        if ax==self.axes[0]:
             menu = QMenu(canvas)
             action1 = menu.addAction("data_2D")
             action2 = menu.addAction("cursors")
@@ -292,11 +322,11 @@ def show_pupup_window(self,canvas,ax):
             action = menu.exec_(QCursor.pos())
     
             if action == action1:
-                print('data2D_plot=data.sel({data.dims[2]:slice('+f"{self.axis[2][self.slider1.value()]:.2f}"+', '+f"{self.axis[2][self.slider1.value()+self.slider2.value()+1]:.2f}"+')}).sum(dim=data.dims[2])' )
+                print('data2D_plot=data.sel({data.dims[2]:slice('+f"{self.axis[2][self.slider1.value()]:.2f}"+', '+f"{self.axis[2][self.slider1.value()+self.slider2.value()+1]:.2f}"+')}).mean(dim=data.dims[2])' )
             elif action == action2:
                 print('yellow_vertical,yellow_horizontal,green_vertical,green_horizontal= '+ f"{self.dot1.center[0]:.2f} ,{self.dot1.center[1]:.2f},{self.dot2.center[0]:.2f},{self.dot2.center[1]:.2f}")
 
-        elif ax==self.axs[1,0]:
+        elif ax==self.axes[2]:
             menu = QMenu(canvas)
             action1 = menu.addAction("yellow_EDC")
             action2 = menu.addAction("green_EDC")
@@ -308,25 +338,25 @@ def show_pupup_window(self,canvas,ax):
                 print("data.sel({data.dims[2]: slice(" +
               f"{self.axis[2][self.slider1.value()]:.2f}, " +
               f"{self.axis[2][self.slider1.value() + self.slider2.value() + 1]:.2f}" +
-              ")}).sum(dim=data.dims[2]).sel({data.dims[0]: " +
+              ")}).mean(dim=data.dims[2]).sel({data.dims[0]: " +
               f"{self.dot1.center[1]:.2f}" +
               "}, method='nearest')  # Yellow EDC")
             elif action == action2: 
                 print("data.sel({data.dims[2]: slice(" +
               f"{self.axis[2][self.slider1.value()]:.2f}, " +
               f"{self.axis[2][self.slider1.value() + self.slider2.value() + 1]:.2f}" +
-              ")}).sum(dim=data.dims[2]).sel({data.dims[0]: " +
+              ")}).mean(dim=data.dims[2]).sel({data.dims[0]: " +
               f"{self.dot2.center[1]:.2f}" +
               "}, method='nearest')  # Green EDC")
             elif action == action3: 
                 print("data.sel({data.dims[2]: slice(" +
               f"{self.axis[2][self.slider1.value()]:.2f}, " +
               f"{self.axis[2][self.slider1.value() + self.slider2.value() + 1]:.2f}" +
-              ")}).sum(dim=data.dims[2]).sel({data.dims[0]: slice(" +
+              ")}).mean(dim=data.dims[2]).sel({data.dims[0]: slice(" +
               f"{min(self.dot1.center[1], self.dot2.center[1]):.2f}, " +
               f"{max(self.dot1.center[1], self.dot2.center[1]):.2f}" +
-              ")}).sum(dim=data.dims[0])  # Integrated EDC")
-        elif ax==self.axs[0,1]:
+              ")}).mean(dim=data.dims[0])  # Integrated EDC")
+        elif ax==self.axes[1]:
             menu = QMenu(canvas)
             action1 = menu.addAction("yellow_MDC")
             action2 = menu.addAction("green_MDC")
@@ -338,14 +368,14 @@ def show_pupup_window(self,canvas,ax):
                 print("data.sel({data.dims[2]: slice(" +
               f"{self.axis[2][self.slider1.value()]:.2f}, " +
               f"{self.axis[2][self.slider1.value() + self.slider2.value() + 1]:.2f}" +
-              ")}).sum(dim=data.dims[2]).sel({data.dims[1]: " +
+              ")}).mean(dim=data.dims[2]).sel({data.dims[1]: " +
               f"{self.dot1.center[0]:.2f}" +
               "}, method='nearest')  # Yellow MDC")
             elif action == action2: 
                 print("data.sel({data.dims[2]: slice(" +
               f"{self.axis[2][self.slider1.value()]:.2f}, " +
               f"{self.axis[2][self.slider1.value() + self.slider2.value() + 1]:.2f}" +
-              ")}).sum(dim=data.dims[2]).sel({data.dims[1]: " +
+              ")}).mean(dim=data.dims[2]).sel({data.dims[1]: " +
               f"{self.dot2.center[0]:.2f}" +
               "}, method='nearest')  # Green MDC")
 
@@ -353,11 +383,11 @@ def show_pupup_window(self,canvas,ax):
                 print("data.sel({data.dims[2]: slice(" +
               f"{self.axis[2][self.slider1.value()]:.2f}, " +
               f"{self.axis[2][self.slider1.value() + self.slider2.value() + 1]:.2f}" +
-              ")}).sum(dim=data.dims[2]).sel({data.dims[1]: slice(" +
+              ")}).mean(dim=data.dims[2]).sel({data.dims[1]: slice(" +
               f"{min(self.dot1.center[0], self.dot2.center[0]):.2f}, " +
               f"{max(self.dot1.center[0], self.dot2.center[0]):.2f}" +
-              ")}).sum(dim=data.dims[1])  # Integrated MDC")
-        elif ax==self.axs[1,1]:
+              ")}).mean(dim=data.dims[1])  # Integrated MDC")
+        elif ax==self.axes[3]:
             menu = QMenu(canvas)
             action1 = menu.addAction("intensity box")
             action = menu.exec_(QCursor.pos())
@@ -370,7 +400,7 @@ def show_pupup_window(self,canvas,ax):
               "), data.dims[1]: slice(" +
               f"{min(self.dot1.center[0], self.dot2.center[0]):.2f}, " +
               f"{max(self.dot1.center[0], self.dot2.center[0]):.2f}" +
-              ")}].sum(dim=(data.dims[0], data.dims[1]))  # Box integration")
+              ")}].mean(dim=(data.dims[0], data.dims[1]))  # Box integration")
                 
    
                   
@@ -410,34 +440,34 @@ def slider1_changed(self,value): # change the slider controlling the third dimen
         # self.slider1_label.setText(str(value))
         base = self.slider1_label.text().split(':')[0]
         self.slider1_label.setText(f"{base}: {self.data[self.data.dims[2]][value].item():.2f}")
-        self.data2D_plot=self.data.sel({self.data.dims[2]:slice(self.axis[2][self.slider1.value()], self.axis[2][self.slider1.value() + self.slider2.value()])}).sum(dim=self.data.dims[2])
+        self.data2D_plot=self.data.sel({self.data.dims[2]:slice(self.axis[2][self.slider1.value()], self.axis[2][self.slider1.value() + self.slider2.value()])}).mean(dim=self.data.dims[2])
         self.update_show()
         self.t=self.slider1.value()
     def slider2_changed(self,value): # change the slider controlling the third dimension for windowing
         # self.slider2_label.setText(str(value))
         base = self.slider2_label.text().split(':')[0]
         self.slider2_label.setText(f"{base}: {value}")
-        self.data2D_plot=self.data.sel({self.data.dims[2]:slice(self.axis[2][self.slider1.value()], self.axis[2][self.slider1.value() + self.slider2.value()])}).sum(dim=self.data.dims[2])
+        self.data2D_plot=self.data.sel({self.data.dims[2]:slice(self.axis[2][self.slider1.value()], self.axis[2][self.slider1.value() + self.slider2.value()])}).mean(dim=self.data.dims[2])
         self.update_show()
         self.dt=self.slider2.value()
     def checkbox_e_changed(self, state): # Checkbox for integrating the EDC between the cursors
         self.update_edc()
-        self.fig.canvas.draw_idle()
+        self.update_all_canvases()
     def checkbox_k_changed(self, state): # Checkbox for integrating the MDC between the cursors
         self.update_mdc()
-        self.fig.canvas.draw_idle()
+        self.update_all_canvases()
 
     def fit_energy_panel(self,event): # open up the fit panel for the EDC 
         x_min = min(self.dot2.center[1], self.dot1.center[1])
         x_max = max(self.dot2.center[1], self.dot1.center[1])
-        data_fit=self.data.sel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
+        data_fit=self.data.sel({self.data.dims[0]:slice(x_min, x_max)}).mean(dim=self.data.dims[0])
         graph_window=fit_panel(data_fit, self.t, self.dt, self.data.dims[1])
         graph_window.show()
         self.graph_windows.append(graph_window)
     def fit_momentum_panel(self,event): # open up the fit panel for the MDC
         x_min = min(self.dot1.center[0], self.dot2.center[0])
         x_max = max(self.dot1.center[0], self.dot2.center[0])
-        data_fit=self.data.sel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
+        data_fit=self.data.sel({self.data.dims[1]:slice(x_min, x_max)}).mean(dim=self.data.dims[1])
         graph_window=fit_panel(data_fit, self.t, self.dt, self.data.dims[0])
         graph_window.show()
         self.graph_windows.append(graph_window)
@@ -446,46 +476,44 @@ def fit_box_panel(self,event): # open up the fit panel for the intensity box
         graph_window.show()
         self.graph_windows.append(graph_window)
     def update_edc(self):
-        self.axs[1, 0].clear()
+        self.axes[2].clear()
         if self.checkbox_e.isChecked():
             self.integrate_E()
         else:
             self.edc_yellow=self.data2D_plot.sel({self.data.dims[0]:self.dot1.center[1]}, method='nearest')
             self.edc_green=self.data2D_plot.sel({self.data.dims[0]:self.dot2.center[1]}, method='nearest')
-            self.edc_yellow.plot(ax=self.axs[1,0],color='orange')
-            self.edc_green.plot(ax=self.axs[1,0],color='green')
+            self.edc_yellow.plot(ax=self.axes[2],color='orange')
+            self.edc_green.plot(ax=self.axes[2],color='green')
     def update_mdc(self):
-        self.axs[0, 1].clear()
+        self.axes[1].clear()
         if self.checkbox_k.isChecked():
             self.integrate_k()
         else:
-            self.data2D_plot.sel({self.data.dims[1]:self.dot1.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='orange')
-            self.data2D_plot.sel({self.data.dims[1]:self.dot2.center[0]}, method='nearest').plot(ax=self.axs[0,1],color='green')
+            self.data2D_plot.sel({self.data.dims[1]:self.dot1.center[0]}, method='nearest').plot(ax=self.axes[1],color='orange')
+            self.data2D_plot.sel({self.data.dims[1]:self.dot2.center[0]}, method='nearest').plot(ax=self.axes[1],color='green')
     
     def integrate_E(self): # integrate EDC between the two cursors in the main graph
-        self.axs[1, 0].clear()
+        self.axes[2].clear()
 
         x_min = min(self.dot2.center[1], self.dot1.center[1])
         x_max = max(self.dot2.center[1], self.dot1.center[1])
         
-        # self.data2D_plot.isel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0]).plot(ax=self.axs[1,0])
-        self.integrated_edc=self.data2D_plot.sel({self.data.dims[0]:slice(x_min, x_max)}).sum(dim=self.data.dims[0])
-        self.integrated_edc.plot(ax=self.axs[1,0])
-        # self.fig.canvas.draw_idle()
+        # self.data2D_plot.isel({self.data.dims[0]:slice(x_min, x_max)}).mean(dim=self.data.dims[0]).plot(ax=self.axes[2])
+        self.integrated_edc=self.data2D_plot.sel({self.data.dims[0]:slice(x_min, x_max)}).mean(dim=self.data.dims[0])
+        self.integrated_edc.plot(ax=self.axes[2])
 
     def integrate_k(self): # integrate MDC between the two cursors in the main graph
-        self.axs[0, 1].clear()
+        self.axes[1].clear()
 
         x_min = min(self.dot1.center[0], self.dot2.center[0])
         x_max = max(self.dot1.center[0], self.dot2.center[0])
 
-        # self.data2D_plot.isel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1]).plot(ax=self.axs[0,1])
-        self.integrated_mdc=self.data2D_plot.sel({self.data.dims[1]:slice(x_min, x_max)}).sum(dim=self.data.dims[1])
-        self.integrated_mdc.plot(ax=self.axs[0,1])
-        # self.fig.canvas.draw_idle()
+        # self.data2D_plot.isel({self.data.dims[1]:slice(x_min, x_max)}).mean(dim=self.data.dims[1]).plot(ax=self.axes[1])
+        self.integrated_mdc=self.data2D_plot.sel({self.data.dims[1]:slice(x_min, x_max)}).mean(dim=self.data.dims[1])
+        self.integrated_mdc.plot(ax=self.axes[1])
 
     def box(self): # generate the intensity graph between the four cursors in the main graph
-        self.axs[1, 1].clear()
+        self.axes[3].clear()
         
         x0,y0=self.dot1.center
         x1,y1=self.dot2.center
@@ -494,12 +522,12 @@ def box(self): # generate the intensity graph between the four cursors in the ma
         x0, x1 = sorted([x0, x1])
         y0, y1 = sorted([y0, y1])
 
-        self.int = self.data.loc[{self.data.dims[0]: slice(y0, y1), self.data.dims[1]: slice(x0, x1)}].sum(dim=(self.data.dims[0], self.data.dims[1]))
+        self.int = self.data.loc[{self.data.dims[0]: slice(y0, y1), self.data.dims[1]: slice(x0, x1)}].mean(dim=(self.data.dims[0], self.data.dims[1]))
         if x0 != x1 and y0 != y1:
             
-            self.int.plot(ax=self.axs[1,1])
-            self.dot, = self.axs[1, 1].plot([self.axis[2][self.slider1.value()]], [self.int[self.slider1.value()]], 'ro', markersize=8)
-            self.fig.canvas.draw_idle()
+            self.int.plot(ax=self.axes[3])
+            self.dot, = self.axes[3].plot([self.axis[2][self.slider1.value()]], [self.int[self.slider1.value()]], 'ro', markersize=8)
+            self.update_all_canvases()
 
     def update_show(self): # update the main graph as well as the relevant EDC and MDC cuts. Also the box intensity
         self.update_edc()
@@ -508,8 +536,8 @@ def update_show(self): # update the main graph as well as the relevant EDC and M
         self.box() # update the intensity box graph
         time1 = self.axis[2][self.slider1.value()]
         timedt1 = self.axis[2][self.slider1.value() + self.slider2.value()]
-        self.axs[0, 0].set_title(f't: {time1:.2f}, t+dt: {timedt1:.2f}')
-        self.fig.canvas.draw_idle()
+        self.axes[0].set_title(f't: {time1:.2f}, t+dt: {timedt1:.2f}')
+        self.update_all_canvases()
 
 
    

From d4838150dc0cf3bf9266ac53253fb843138234df Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 14:36:38 +0200
Subject: [PATCH 45/67] added a colorbar

---
 src/mpes_tools/Gui_3d.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index 34036b7..32f79ad 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -80,6 +80,7 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         
         for i in range(4):
             fig = Figure(figsize=(10, 8))  # optional: smaller size per plot
+            plt.close(fig)
             canvas = FigureCanvas(fig)
             ax = fig.add_subplot(111)
             self.canvases.append(canvas)
@@ -99,7 +100,6 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         layout.addLayout(checkbox_layout)
         layout.addLayout(h_layout)
         layout.addLayout(canvas_layout)
-        # layout.addWidget(self.canvas)
         
         slider_layout= QHBoxLayout()
         self.slider1 = QSlider(Qt.Horizontal)
@@ -186,6 +186,7 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         
         # plot the main graph
         self.im = self.data2D_plot.plot(ax=self.axes[0], cmap='terrain', add_colorbar=False)
+        self.axes[0].figure.colorbar(self.im, ax=self.axes[0])
         colorscale_slider(canvas_layout, self.im, self.axes[0].figure.canvas)
         
         # define the initial positions of the cursors in the main graph

From e26036c87994d977191a3a974b5cb9a1ecd6aee5 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 14:37:24 +0200
Subject: [PATCH 46/67] made it more general

---
 src/mpes_tools/colorscale_slider_handler.py | 44 ++++++++++++++-------
 1 file changed, 30 insertions(+), 14 deletions(-)

diff --git a/src/mpes_tools/colorscale_slider_handler.py b/src/mpes_tools/colorscale_slider_handler.py
index 5ab0fb6..ec26354 100644
--- a/src/mpes_tools/colorscale_slider_handler.py
+++ b/src/mpes_tools/colorscale_slider_handler.py
@@ -1,4 +1,4 @@
-from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QLabel,QHBoxLayout
+from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QLabel,QHBoxLayout,QGridLayout
 from superqt import QRangeSlider
 from PyQt5.QtCore import Qt
 import numpy as np
@@ -9,7 +9,7 @@
 class colorscale_slider(QWidget):
     def __init__(self, layout, imshow_artist,canvas, limits=None):
         super().__init__()
-
+        self.case=False
         self.im = imshow_artist
         self.canvas = canvas
         self.colorbar = None  # Optional: set this externally if you want to update a colorbar
@@ -20,8 +20,12 @@ def __init__(self, layout, imshow_artist,canvas, limits=None):
             self.vmin,self.vmax= limits
         if self.vmin==self.vmax:
             self.vmax += 0.1
-        self.cmin, self.cmax = 10, 1e5
-
+        if self.vmax<10:
+            self.cmin, self.cmax = 10, 1e9
+            self.case=True
+        else:
+            self.cmin, self.cmax=self.vmin,self.vmax
+        print(self.vmin,self.vmax)
         # Slider Widget
         slider_widget = QWidget()
         slider_layout = QVBoxLayout(slider_widget)
@@ -29,15 +33,21 @@ def __init__(self, layout, imshow_artist,canvas, limits=None):
         self.slider = QRangeSlider(Qt.Vertical)
         self.slider.setFixedWidth(15)
         self.slider.setMinimum(int(1 * self.cmin))
-        self.slider.setMaximum(int(1* self.cmax))
-        self.slider.setValue([self.new_values(self.vmin), self.new_values(self.vmax)])
+        self.slider.setMaximum(int(1.5* self.cmax))
+        self.slider.setValue([float(self.vmin),float(self.vmax)])
+        if self.case :
+            self.slider.setValue([self.new_values(self.vmin), self.new_values(self.vmax)])
         # self.slider.valueChanged.connect(self.update_clim)
         self.slider.valueChanged.connect(lambda value: self.update_clim(value))
-
-        self.label = QLabel(f"{self.vmin:.2f} to {self.vmax:.2f}")
+        
+        self.vmin_label = QLabel(f"{self.vmin:.2e}")
+        self.vmax_label = QLabel(f"{self.vmax:.2e}")
+        # # self.label = QLabel(f"{self.vmin:.2f} to {self.vmax:.2f}")
+        # self.label = QLabel(f"{self.vmin:.2e} to {self.vmax:.2e}")
         # self.label = QLabel(' ')
-        slider_layout.addWidget(self.label)
+        slider_layout.addWidget(self.vmax_label)
         slider_layout.addWidget(self.slider)
+        slider_layout.addWidget(self.vmin_label)
 
         # New horizontal layout: slider left, canvas right
         h_container = QWidget()
@@ -45,9 +55,12 @@ def __init__(self, layout, imshow_artist,canvas, limits=None):
         h_layout.addWidget(slider_widget)
         h_layout.addWidget(self.canvas)
         h_layout.addWidget(self.canvas, stretch=1)
-
-        layout.insertWidget(0, h_container)
-
+        if isinstance(layout, QGridLayout):
+            layout.addWidget(h_container,0,0)
+        else:
+            layout.insertWidget(0, h_container)
+        
+        
     def new_values(self, x):
         a = (self.cmax - self.cmin) / (self.vmax - self.vmin)
         b = self.vmax * self.cmin - self.vmin * self.cmax
@@ -59,9 +72,12 @@ def inverse(self, x):
         return (x - b) / a
 
     def update_clim(self, value):
-        vmin, vmax = self.inverse(value[0]), self.inverse(value[1])
+        vmin, vmax = value
+        if self.case:
+            vmin, vmax = self.inverse(value[0]), self.inverse(value[1])
         self.im.set_clim(vmin, vmax)
-        self.label.setText(f" {vmin:.2f} to {vmax:.2f}")
+        self.vmin_label.setText(f" {vmin:.2e}")
+        self.vmax_label.setText(f"{vmax:.2e}")
         if self.colorbar:
             self.colorbar.update_normal(self.im)
         self.canvas.draw_idle()

From 22a458b78f03459eeb22556f717c8a1cfeb6a615 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 14:37:57 +0200
Subject: [PATCH 47/67] added a feature to keep the log scale on when updating
 the graph with the slider

---
 src/mpes_tools/graphs.py | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/mpes_tools/graphs.py b/src/mpes_tools/graphs.py
index 1efc59d..8a75c41 100644
--- a/src/mpes_tools/graphs.py
+++ b/src/mpes_tools/graphs.py
@@ -100,7 +100,12 @@ def __init__(self, x, y_arrays,y_arrays_err,names,list_axis,list_plot_fits):
             self.ax_list.append(ax)
             self.cursor=ax.axvline(x=self.x[0], color='r', linestyle='--')
             self.cursor_list.append(self.cursor)
-        self.update_parameter(0)
+        # self.update_parameter(0)
+        self.axis.plot(self.list_axis[0][0],self.list_plot_fits[0][0][0],'o', label='data')
+        self.axis.plot(self.list_axis[1][0],self.list_plot_fits[0][1][0],'r--', label='fit')
+        self.axis.legend()
+        self.figure.tight_layout()
+        self.canvas.draw()
         self.slider.valueChanged.connect(self.update_parameter)
         
     def show_pupup_window(self,canvas,ax):
@@ -204,10 +209,14 @@ def update_parameter(self, value):
             self.ax_list[i].figure.canvas.draw_idle()
         base = self.slider_label.text().split(':')[0]
         self.slider_label.setText(f"{base}: {self.x[value]:.2f}")
+        yscale = self.axis.get_yscale()
+        ylim = self.axis.get_ylim()
         self.axis.clear()
         
         self.axis.plot(self.list_axis[0][0],self.list_plot_fits[value][0][0],'o', label='data')
         self.axis.plot(self.list_axis[1][0],self.list_plot_fits[value][1][0],'r--', label='fit')
+        self.axis.set_yscale(yscale)
+        self.axis.set_ylim(ylim)
         self.axis.legend()
         self.figure.tight_layout()
         self.canvas.draw()

From ed8027b46be4a508a0fcdb8134a558fbcac91bbb Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 14:41:04 +0200
Subject: [PATCH 48/67] added mpes_tools.

---
 src/mpes_tools/Gui_3d.py         | 6 +++---
 src/mpes_tools/show_4d_window.py | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index 32f79ad..4cf9fbd 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -17,9 +17,9 @@
 from PyQt5.QtWidgets import QMenu,QGridLayout,QHBoxLayout, QSizePolicy,QLabel
 from PyQt5.QtGui import QCursor
 from mpes_tools.cursor_dot_handler import Cursor_dot_handler
-from cursor_handler import Cursor_handler
-from dot_handler import Dot_handler
-from colorscale_slider_handler import colorscale_slider
+from mpes_tools.cursor_handler import Cursor_handler
+from mpes_tools.dot_handler import Dot_handler
+from mpes_tools.colorscale_slider_handler import colorscale_slider
 from matplotlib.figure import Figure
 #graphic window showing a 2d map controllable with sliders for the third dimension, with cursors showing cuts along the x direction for MDC and y direction for EDC
 # Two vertical cursors and two horizontal cursors are defined in the main graph with each same color for the cursors being horizontal and vertical intercept each other in a dot so one can move either each cursor or the dot itself which will move both cursors. 
diff --git a/src/mpes_tools/show_4d_window.py b/src/mpes_tools/show_4d_window.py
index f6e6c26..8d45fab 100644
--- a/src/mpes_tools/show_4d_window.py
+++ b/src/mpes_tools/show_4d_window.py
@@ -13,7 +13,7 @@
 from mpes_tools.right_click_handler import RightClickHandler
 from PyQt5.QtWidgets import QMenu
 from PyQt5.QtGui import QCursor
-from colorscale_slider_handler import colorscale_slider
+from mpes_tools.colorscale_slider_handler import colorscale_slider
 
 class show_4d_window(QMainWindow):
     def __init__(self,data_array: xr.DataArray):

From a47bb54904768aa153ae42eddbf1433c8a2a0829 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 14:48:18 +0200
Subject: [PATCH 49/67] small clean up

---
 src/mpes_tools/Gui_3d.py                    | 10 +---------
 src/mpes_tools/colorscale_slider_handler.py |  5 -----
 src/mpes_tools/show_4d_window.py            |  3 ---
 3 files changed, 1 insertion(+), 17 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index 4cf9fbd..bf432c9 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -36,17 +36,9 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         
         layout = QVBoxLayout()
         central_widget.setLayout(layout)
-        
-        
-        # self.fig, self.axs = plt.subplots(2,2,figsize=(20,16))
-        # plt.close(self.fig)
-        # self.canvas = FigureCanvas(self.fig)
-        
-        
+
         self.click_handlers = []
         self.handler_list = []
-            
-        
         # plt.ioff()
         # add the checkboxes for EDC and MDC integration and the button to save the results
         self.checkbox_e = QCheckBox("Integrate_energy")
diff --git a/src/mpes_tools/colorscale_slider_handler.py b/src/mpes_tools/colorscale_slider_handler.py
index ec26354..aab4954 100644
--- a/src/mpes_tools/colorscale_slider_handler.py
+++ b/src/mpes_tools/colorscale_slider_handler.py
@@ -25,7 +25,6 @@ def __init__(self, layout, imshow_artist,canvas, limits=None):
             self.case=True
         else:
             self.cmin, self.cmax=self.vmin,self.vmax
-        print(self.vmin,self.vmax)
         # Slider Widget
         slider_widget = QWidget()
         slider_layout = QVBoxLayout(slider_widget)
@@ -37,14 +36,10 @@ def __init__(self, layout, imshow_artist,canvas, limits=None):
         self.slider.setValue([float(self.vmin),float(self.vmax)])
         if self.case :
             self.slider.setValue([self.new_values(self.vmin), self.new_values(self.vmax)])
-        # self.slider.valueChanged.connect(self.update_clim)
         self.slider.valueChanged.connect(lambda value: self.update_clim(value))
         
         self.vmin_label = QLabel(f"{self.vmin:.2e}")
         self.vmax_label = QLabel(f"{self.vmax:.2e}")
-        # # self.label = QLabel(f"{self.vmin:.2f} to {self.vmax:.2f}")
-        # self.label = QLabel(f"{self.vmin:.2e} to {self.vmax:.2e}")
-        # self.label = QLabel(' ')
         slider_layout.addWidget(self.vmax_label)
         slider_layout.addWidget(self.slider)
         slider_layout.addWidget(self.vmin_label)
diff --git a/src/mpes_tools/show_4d_window.py b/src/mpes_tools/show_4d_window.py
index 8d45fab..46ba815 100644
--- a/src/mpes_tools/show_4d_window.py
+++ b/src/mpes_tools/show_4d_window.py
@@ -322,7 +322,6 @@ def open_graph_kyedt(self):
         kx1=self.data_array[self.axes[0]][self.slider1[2].value()].item()
         kx2=self.data_array[self.axes[0]][self.slider1[2].value()+self.slider2[2].value()+1].item()
         data_kyedt = self.data_array.loc[{self.axes[0]:slice(kx1,kx2)}].mean(dim=(self.axes[0]))
-        print(type(data_kyedt))
         graph_window = Gui_3d(data_kyedt, self.slider3[2].value(), self.slider4[2].value(),'METIS')
         # Show the graph window
         
@@ -332,7 +331,6 @@ def open_graph_kyedt(self):
     def load_data(self, data_array: xr.DataArray):
         self.data_array = data_array
         self.axes = data_array.dims
-        # print('theaxissss',self.axes)
         self.slider1[0].setRange(0,len(self.data_array.coords[self.axes[2]])-1)
         self.slider1[1].setRange(0,len(self.data_array.coords[self.axes[0]])-1)
         self.slider1[2].setRange(0,len(self.data_array.coords[self.axes[1]])-1)
@@ -517,7 +515,6 @@ def slider_changed(self, value):
             self.graphs[2].canvas.draw_idle()
             self.graphs[1].canvas.draw_idle()
             self.graphs[3].canvas.draw_idle()
-            print(id(self.energy_time_cursor))
             self.update_energy(self.slider1[0].value(),self.slider2[0].value(),self.slider3[0].value(), self.slider4[0].value())
             
         elif index in range(4,8):

From 9d7c1e2282376c3cf9065ebb2aaa80e1e34d8747 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 15:41:44 +0200
Subject: [PATCH 50/67] deleted unwanted import

---
 src/mpes_tools/Gui_3d.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index bf432c9..b1a3ee4 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -16,7 +16,6 @@
 from mpes_tools.right_click_handler import RightClickHandler
 from PyQt5.QtWidgets import QMenu,QGridLayout,QHBoxLayout, QSizePolicy,QLabel
 from PyQt5.QtGui import QCursor
-from mpes_tools.cursor_dot_handler import Cursor_dot_handler
 from mpes_tools.cursor_handler import Cursor_handler
 from mpes_tools.dot_handler import Dot_handler
 from mpes_tools.colorscale_slider_handler import colorscale_slider

From 4e35ccfea87c9a3c5272d04f3e97dae26161570c Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 15:49:09 +0200
Subject: [PATCH 51/67] added superqt into the dependencies

---
 pyproject.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pyproject.toml b/pyproject.toml
index cb04945..d55aead 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -35,6 +35,7 @@ dependencies = [
     "numpy>=1.26.1,<2.0",
     "PyQt5>=5.0.0",
     "xarray>=0.20.2",
+   "superqt >=0.3.0",
 ]
 
 [project.urls]

From 0430aff021911fa8582bbc295c48a0e26a138cbe Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 15:55:15 +0200
Subject: [PATCH 52/67] clean up

---
 src/mpes_tools/colorscale_slider_handler.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/mpes_tools/colorscale_slider_handler.py b/src/mpes_tools/colorscale_slider_handler.py
index aab4954..ff81703 100644
--- a/src/mpes_tools/colorscale_slider_handler.py
+++ b/src/mpes_tools/colorscale_slider_handler.py
@@ -38,8 +38,10 @@ def __init__(self, layout, imshow_artist,canvas, limits=None):
             self.slider.setValue([self.new_values(self.vmin), self.new_values(self.vmax)])
         self.slider.valueChanged.connect(lambda value: self.update_clim(value))
         
-        self.vmin_label = QLabel(f"{self.vmin:.2e}")
-        self.vmax_label = QLabel(f"{self.vmax:.2e}")
+        # self.vmin_label = QLabel(f"{self.vmin:.2e}")
+        # self.vmax_label = QLabel(f"{self.vmax:.2e}")
+        self.vmin_label = QLabel("")
+        self.vmax_label = QLabel("")
         slider_layout.addWidget(self.vmax_label)
         slider_layout.addWidget(self.slider)
         slider_layout.addWidget(self.vmin_label)
@@ -71,8 +73,8 @@ def update_clim(self, value):
         if self.case:
             vmin, vmax = self.inverse(value[0]), self.inverse(value[1])
         self.im.set_clim(vmin, vmax)
-        self.vmin_label.setText(f" {vmin:.2e}")
-        self.vmax_label.setText(f"{vmax:.2e}")
+        # self.vmin_label.setText(f" {vmin:.2e}")
+        # self.vmax_label.setText(f"{vmax:.2e}")
         if self.colorbar:
             self.colorbar.update_normal(self.im)
         self.canvas.draw_idle()

From 5df5e41373e3f9049b4ea0f1b1f6de35e589dba9 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 15:58:49 +0200
Subject: [PATCH 53/67] small changes

---
 src/mpes_tools/Main.py   |   2 +-
 tutorials/template.ipynb | 276 +++++++++++++++++++++++++++++++++------
 2 files changed, 237 insertions(+), 41 deletions(-)

diff --git a/src/mpes_tools/Main.py b/src/mpes_tools/Main.py
index eb9f0c0..a8a6ebc 100644
--- a/src/mpes_tools/Main.py
+++ b/src/mpes_tools/Main.py
@@ -65,7 +65,7 @@ def __init__(self):
 
         self.graph_windows = []
         self.ce = None
-
+        
         self.show()
 
 
diff --git a/tutorials/template.ipynb b/tutorials/template.ipynb
index 301403c..3771539 100644
--- a/tutorials/template.ipynb
+++ b/tutorials/template.ipynb
@@ -2,10 +2,20 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "6d2e0046",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# import the 4D data\n",
     "import numpy as np\n",
@@ -16,7 +26,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "5aeb6fe2",
    "metadata": {},
    "outputs": [
@@ -38,7 +48,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 7,
    "id": "b44542de",
    "metadata": {},
    "outputs": [
@@ -48,7 +58,7 @@
        "5"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -122,7 +132,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 6,
    "id": "a6a92293",
    "metadata": {},
    "outputs": [
@@ -141,6 +151,13 @@
      },
      "metadata": {},
      "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "data.sel({data.dims[2]: slice(-799.45, -499.65)}).sum(dim=data.dims[2]).sel({data.dims[1]: -0.85}, method='nearest')  # Green MDC\n"
+     ]
     }
    ],
    "source": [
@@ -154,17 +171,107 @@
     "# import the 3D data\n",
     "loaded_data= np.load('//nap33/wahada/Phoibospython/scan11443_filtered.npz')\n",
     "\n",
-    "V1= xr.DataArray(loaded_data['data_array'], dims=['Angle', 'Ekin','delay'], coords={'Angle': loaded_data['Angle'], 'Ekin': loaded_data['Ekin'],'delay': loaded_data['delay']})    \n",
-    "axis=[V1['Angle'],V1['Ekin']-21.7,V1['delay']]\n",
+    "data= xr.DataArray(loaded_data['data_array'], dims=['Angle', 'Ekin','delay'], coords={'Angle': loaded_data['Angle'], 'Ekin': loaded_data['Ekin'],'delay': loaded_data['delay']})    \n",
+    "axis=[data['Angle'],data['Ekin']-21.7,data['delay']]\n",
+    "\n",
     "# print(data.dims)\n",
-    "graph_window= Gui_3d(V1,0,0,'Phoibos')\n",
+    "graph_window= Gui_3d(data,0,0,'Phoibos')\n",
     "graph_window.show()\n",
+    "data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)\n",
     "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 9,
+   "id": "c14ca2d1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x221e8fc5700>]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "fig,ax=plt.subplots(1,1,figsize=(12,8))\n",
+    "data.loc[{data.dims[0]: slice(-3.42, 6.04), data.dims[1]: slice(-0.85, -0.07)}].sum(dim=(data.dims[0], data.dims[1])).plot(ax=ax)  # Green MDC\n",
+    "# data.sel({data.dims[2]: slice(-799.45, -499.65)}).sum(dim=data.dims[2]).sel({data.dims[1]: -0.19}, method='nearest')  # Yellow MDC\n",
+    "# data.sel({data.dims[2]: slice(-799.45, -499.65)}).sum(dim=data.dims[2]).sel({data.dims[1]: -0.19}, method='nearest').plot(ax=ax) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dea42cc8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "yellow_vertical,yellow_horizontal,green_vertical,green_horizontal= f\"{self.dot1.center[0]:.2f} ,{self.dot1.center[1]:.2f},{self.dot2.center[0]:.2f},{self.dot2.center[1]:.2f}\"\n",
+      "data2D_plot=data.sel({data.dims[2]:slice(624.57, 674.53)}).sum(dim=data.dims[2])\n"
+     ]
+    }
+   ],
+   "source": [
+    "data2D_plot=data.sel({data.dims[2]:slice(674.5333333333291, 749.4799999999675)}).sum(dim=data.dims[2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "f5bc2a27",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.QuadMesh at 0x221171081a0>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA5YAAAK2CAYAAAA10AP8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAA/S1JREFUeJzsvQuUZVdd53/uo25VV1c/0ukknZCEJEQCCAFERP+ggiLIYlgiMzg4qGGYcUZEfKCj4ANBkICvxYy60FEG1FmCjxHGQQXRJTAOoMBMFiASCCQkIekknU4/qqtuVd3Hf91z9nffvX/nt/fZ595bt6q6v5+1ep2657HPPq+b3PP97u+vMRwOhxkhhBBCCCGEEDIhzUk3JIQQQgghhBBCRvCHJSGEEEIIIYSQqeAPS0IIIYQQQgghU8EfloQQQgghhBBCpoI/LAkhhBBCCCGETAV/WBJCCCGEEEIImQr+sCSEEEIIIYQQMhX8YUkIIYQQQgghZCr4w5IQQgghhBBCyFTwhyUhhBBCCCGEkKngD0tCCCGEEEIImSMf/vCHs+c973nZFVdckTUajew973lP7TaGw2H2K7/yK9kjH/nIbHFxMXvYwx6W/eIv/mK2U7R3bM+EEEIIIYQQcgFy7ty57PGPf3z20pe+NHvBC14wURs/8iM/kv31X/91/uPycY97XHby5Mn8307RGI5+6hJCCCGEEEIImTuNRiN797vfnT3/+c+38zY2NrKf+Zmfyd75zndmp06dyh772Mdmb37zm7OnP/3p+fJ//ud/zm688cbsM5/5THbDDTdkuwFaYQkhhBBCCCFkF/FDP/RD2Uc/+tHsXe96V/apT30qe+ELX5h9+7d/e/aFL3whX/6//tf/yq677rrsve99b3bttddm11xzTfbv//2/31HFkj8sCSGEEEIIIWSXcOedd2Zvf/vbsz/5kz/JvvEbvzF7xCMekf3ET/xE9rSnPS2fP+JLX/pS9uUvfzlf5/d///ezd7zjHdknP/nJ7F/9q3+1Y/3mGEtCCCGEEEII2SV8+tOfzvr9fh7K4zKyx1588cX534PBIP88+lGJ9d72trdlT3rSk7Jbb711R+yx/GFJCCGEEEIIIbuE1dXVrNVq5QrkaOqysrKSTy+//PKs3W57Pz4f/ehHW8WTPywJIYQQQggh5ALmiU98Yq5Y3n///bkVVuOpT31q1uv1si9+8Yu5VXbE5z//+Xz68Ic/PNsJmApLCCGEEEIIIXNWJW+77Tb7Q/LXfu3Xsmc84xnZkSNHsquvvjr7nu/5nuz//J//k/3qr/5qvvyBBx7I/vZv/zZPgn3uc5+bW2Gf/OQn5wrmW97ylvzzy1/+8uzgwYN5CZKdgD8sCSGEEEIIIWSOfPCDH8x/SEpuuummPIhna2sre8Mb3pCPofzKV76SHT16NPv6r//67HWve11es3LEPffck73iFa/If0ju378/e85znpP/EB39ON0J+MOSEEIIIYQQQshUsNwIIYQQQgghhJCp4A9LQgghhBBCCCFTwVRYwWjg68ivfODAgazRaOx0dwghhBBCCLmgGY3cO3v2bHbFFVdkzebe0sW63W62ubm5I/vudDrZ0tLS3PbHH5aC0Y/Kq666aqe7QQghhBBCCHG46667siuvvDLbSz8qr7322uz48eM7sv9jx45lt99++9x+XPKHpWCkVI543OPelLVa8/uFTwghhBBCCCnT73ezT3/6Vfb/0/cKm5ub+Y/K0Q/iURmQeXLmzJlcLBv1gT8sdwjYX0c/KlutfTvdHUIIIYQQQojz/+l7jZX9+/N/82TQ72fzZm+ZlAkhhBBCCCGE7Dr4w5IQQgghhBBCyFTQCksIIYQQQggh21h1YjAYzH2f84aKJSGEEEIIIYSQqaBiSQghhBBCCCHbGKQzmHOYDsN7CCGEEEIIIYTsOahYEkIIIYQQQsg2MRj083/z3ue8oWJJCCGEEEIIIWQq+MOSEEIIIYQQQshU0ApLCCGEEEIIIdvEoD/I/817n/OGiiUhhBBCCCGEkKmgYkkIIYQQQggh28SA4T2EEEIIIYQQQkg1/GFJCCGEEEIIIWQqaIUlhBBCCCGEkG0N7+nPfZ/zhoolIYQQQgghhJCpoGJJCCGEEEIIIdvEYDjIBoM5lxsZUrEkhBBCCCGEELLHoGJJCCGEEEIIIdvEoN/fgTGWLDdCCCGEEEIIIWSPwR+WhBBCCCGEEEKmglZYQgghhBBCCNkmhjtghR3tc95QsSSEEEIIIYQQMhVULAkhhBBCCCFkmxgMdqDcyJz3N4KKJSGEEEIIIYSQqeAPS0IIIYQQQgghU0ErLCGEEEIIIYRsEwPWsSSEEEIIIYQQQqqhYkkIIYQQQggh28Rg0M//zXuf84aKJSGEEEIIIYSQqaBiSQghhBBCCCHbxKA/2IExliw3QgghhBBCCCFkj8EfloQQQgghhBBCpoJWWEIIIYQQQgjZJgbDQTYYDOa+z3lDxZIQQgghhBBCyFRQsSSEEEIIIYSQbWLQ7+9AeA/LjRBCCCGEEEII2WPwhyUhhBBCCCGEkKmgFZYQQgghhBBCtokBrbCEEEIIIYQQQkg1VCwJIYQQQgghZJsYDHag3Mic9zeCiiUhhBBCCCGEkKmgYkkIIYQQQggh28RwB8ZYjvY5b/aUYvnhD384e97znpddccUVWaPRyN7znvd4y1/ykpfk891/3/7t375j/SWEEEIIIYSQC4E99cPy3Llz2eMf//jsN3/zN4PrjH5I3nvvvfbfO9/5zrn2kRBCCCGEEEIuNPaUFfY5z3lO/i/G4uJiduzYsbn1iRBCCCGEEEJCDAb9/N88qbu/a665Jvvyl79cmv+DP/iDUVFvzyqWKXzwgx/MLr300uyGG27IXvayl2UPPvhgdP2NjY3szJkz3j9CCCGEEEIIuVD4+Mc/7rk+P/CBD+TzX/jCF56fimUVIxvsC17wguzaa6/NvvjFL2Y//dM/nSucH/3oR7NWq6Vuc/PNN2eve93r5t5XQgghhBBCyPnPoD/MBv05lxvpD2utf8kll3if3/SmN2WPeMQjsm/+5m++MH9YvuhFL7J/P+5xj8tuvPHG/ISMVMxv/dZvVbd59atfnb3yla+0n0eK5VVXXTWX/hJCCCGEEELIdiHdmKNhg6N/MTY3N7P//t//e/4baRSGmsp5Z4V1ue6667KjR49mt912W3Cd0Yk9ePCg948QQgghhBBC9jpXXXVVdujQIftv5NasYlR549SpU3nFjTqcV4ql5O67787HWF5++eU73ZXzlqGxGDd2oFYOIYQQQgghu53BcAfCe4bF/u666y5POKtSK0e87W1vy4cTjko8nrc/LFdXVz318fbbb89uueWW7MiRI/m/0VjJf/kv/2WeCjsaY/mTP/mT2fXXX589+9nP3tF+E0IIIYQQQsi8qevIHCXD/s3f/E32Z3/2Z7X3tad+WH7iE5/InvGMZ9jPGBt50003ZW9961uzT33qU9nv/d7v5dLt6Bf2s571rOz1r3990i/z80U5nDWDpu+Wbg4G6vJZe6p3iwKqnddp+pZynXbLsRNCCCGEkOkZ9Pv5v3nvcxLe/va35xU2nvvc557fPyyf/vSnZ8NhOOHo/e9//1z7QwghhBBCCCHnA4PBIP9hORLt2u32+f3DkoSBcjgL5dJVzNCenZplcj+YX9VeMkIpDSmmKSrrJGA/aluBc43jnETl9LZZWIiuq7WF/ob6oG3D8bGEEEIIIfP5wTZI+H/YWe+zLiML7J133pm99KUvnWif/GFJCCGEEEIIIRc4z3rWs6Lu0Au63AghhBBCCCGEkO2HiuUeB3bGQadT2wYatEs6VsySrVPYNFPslKFlrq01FBIkLb6T2DajtlZByeI7ZXjPrK3JVfsPWYWxjbrtFLbj0H72Au612Uv9JoQQQsjeYrCHwnumgYolIYQQQgghhJCpoGK5x4EK11tayqd9oyimKDB1Al5Cn2NIlSxlfxIosdo221VipW4Y0iTnMbQ/TSmU51FTEqtUzZj6GNpWBgK5xxG6do0pgpPmFcyk77w5tRI+icK7HczrGdlJ5P23XccZC+QK3Y+pfUn5/qvz3BJCCNm9DKhYEkIIIYQQQggh1fCHJSGEEEIIIYSQqaAVdo8D2xUssLDEVlm43GWThNGkWBJDtRXr2HSltTfleCQxa2roOGT9zhRilshJQojk+ZvEChuy1WrbYN3m5mZwP6H9yuCn2LbBoKZI+/O2dqbYW+WSOkbYWdgYU8K3ZtpuxXqxdSfZf7StimNMuU/kfVjnu0U+z+7ykI1efufEvifks9ja2sqn7W7Xrot58nmlRZYQQnYfgz1Sx3JaqFgSQgghhBBCCJkKKpZ7HKlU4jPe6Nd5C5+iCobetrtv/7E93qiHttXUQizDcYSUgrpBPyHs+RL7L53PxPMj91tVNiXWFtbBeZTnM6Y+yv1ry6WqadURoRKnBIjIdeu8IxvEjiGgWE+iXE4SaDWo0Uada1unT1V9nEebye2K5ynmVqg6X0Phvpj0OELfGbJEk/z+0NrAOvhekN+/2jpYJl0YKc/8wrlz+XTp1Kl8unj2rF0Xf2MdqJkI0KKCSQghu4dhfzD3MJ3RPucNFUtCCCGEEEIIIVPBH5aEEEIIIYQQQqaCVtg9ig2CMLYrzbrprhcLQrHzE2o3hqyjmr0rZHUbROyzWFfax6YJ76ljn4UdVO5f60PI0pYSylFVdzJH2IFjFrrU2pfufmC3G5p5IbtuLCzI2u5gUZVhPnXClSLXCe3XqS9aokYQVAitTmepnch1Sg3GSalFWSe8J7Ru7FyUvh9q1Mi1yL4ofZPXttTnhPNZ+o6J3EvyeZKW2Ng6+Ly1f38+3VxeLqYHD9ptB52N4o/Fk8V06U4zPW4OuPiO8Rh0/Gn3WDE9d3Wx6f2H8+nKcdOG05clcaywxOKpdZfSFksIITvDYNjPBoM517Ecso4lIYQQQgghhJA9BhXLPU5IQdTe2Ifi72PrVYXCxNqyg5Qr4vdTSIn1rwoj0o6ldJ6gXigqRjNBOcy3Uc6TVUAQbCT2j7a1fuIT1tCOR2qK8upjv5riJq/CUAYzKccjscch+hijjnKI/ts+JgRMSeS1SFEFS6VRJlA5o6V5AmFY2n0eC8xy20r5Poi9USyVxQgsnzYkCNvLaxvqR7QPCaVDZHtShXS3CYXzYJuNAwc85XKw/8HxjhaMUrnPqIsrtxXTZaNctleLvrfOlfvY3+8rlqvXFx8H355PW1sX23VlCRJ8tgFAWHEH4uYJIYT4DPLwnjmXG2F4DyGEEEIIIYSQvQYVyz1KqBxHaexjZIxgyji/acajyf3E2gopXjFVxL4VwbGKbWMKaara4qpEclxhiuI7ybui0LHXUXzl+Kp5ja2KFX+fBRONrTTUUe1CYzm158m2V6Uo1lD7tG3lua1Sj0PtpCLVzhSXQh2qHAYpfU/pQ532ZF/k+E75vau22dr0lEk7NWMrF9pr+XSp2Sr9h/hUVqiYw45RPTu++tlfuKh0XKFpJsoTEUII2TkGgx0YYznn/Y2gYkkIIYQQQgghZCr4w5IQQgghhBBCyFTQCrtHkVaskN3UNYrJdYPWt8i8OuEloXIVobAObdtprL1AW277VlUCQzseEcQT23aSEiiT2Ezr2JtnQWrZjFlTx5odC7KS8+W6VYFQ2rKQ+TfW1+2wDLttTmOF1dqblGks9Sl28BSbfaiNOvuZxFab9Va8aW/hoXzadc5ru9Eo2h/Gg8G0UCcg/xtACCFk9zDo98ehlnPc57yhYkkIIYQQQgghZCqoWJ5n4T2a6miXzVChkApBc3NzKpUutE85X1OMQiUHYtjSExUBOe7+5DZa6Q6tDbWvc1YFZ6ViSNU01MftVk1iCpW8Z6qUy6plLtr+Qsr5JOrcLBTGOqSUbZlGsYwp6JOUP0rd1j2PoXWlOq1tE1IqbZutvh/Qo4T12CnaNqpkuxl5RgYdf6ocy7TqLyGEkPkxGAzyf/Pe57yhYkkIIYQQQgghZCr4w5IQQgghhBBCyFTQCruHcK1PVXUsUwhZ9mJ2tZDV0X1DYYN+ZijB16lpF6qfGbNnyvOphoCI/aQgLXSho4idqZbot3YupDW1zrXF4G7bqqh/N0n9zxiT2IJDbcyaOvbj0P0W65tsb9YhTqltlmp6Rp7VOn2cptZlSshOVXhO7DimqcUbpCFqVrp/YypqUjYaeL7Kx4Blwwn6xtAeQgjZvQwY3kMIIYQQQgghhFRDxXIPEQuk0NaZlDpv9rW35LIHVSUcJlUxsO9Bxw+4qNOu7BOUS00tnCRspBQQEjhH2nFJBSymUEiVOLQ/rw0TuNTAPBFy00wovTKNYhQ6f1rbOxWEI/uiXds6yvwkpXFmoTqG9mPbSlg3di4ASvCEygVtN9o1kXsOPkcJ9wvabRlVv7+vKBOS9Z3voEBoDz6jtIgL5mG6FWpjAtz7RLofCCGEzIdBf7ADiiXDewghhBBCCCGE7DGoWO4hXGUOyppUxOooLHVUz2nGtNVRKuW+pRqpjhEMFAoP9UPbX8p4OauQVowFm1ZZLim+ieu566a0AaVyCHVHjK0E2jkIjWPVtpn3+MmqZ2JWbIcKpzoAxH5C986sSpXI8iyTnD957mPqbsrYyu0k5fsJx9Hudn1nQ++AacT5nuqtFNMtMw04KlzlEv8htoolFohyI+65KrkhzH6G5jnGcx0t0UQIIWQuDIY7UG5kSMWSEEIIIYQQQsgegz8sCSGEEEIIIYRMBa2wewAtWGYau1jIliatVXX6FttP6HNKmYJSQElyz9JKbVSVL4i1J6lz/qTdcF7hJillJWJnwh7bnO0cdQiFBOH6x+yYoZIhkwRPaeuGrMSS7b4fYqVRQtZUef7cHlZZyUM28lAf3G1UJig3Elp3CDu3YmG3Vu869mrYV117rAPsrkuuFdb83UP/A6E97rmS/10oWWPRd/f87uLnlhBCzmeGO1BuBP99mydULAkhhBBCCCGETAUVyz0A3kTHFMvQG3R3fugtwiShHynKTUjlmUSNkeUzUtqZtRoYCgkKqTWpAT+S7QzWcNuuCjmSJUzqkHJP1Wm3TjhQTI2r6tskSmVof9sdGjSrsJ4Qk7gi6gRnyXVTtg31KRZwNIk7QSqVTfFM2H60TJ8bjsIItdGdN/rYKEJ1lhrFtivKsfSGw3x6Fm20V4tp56TZ78NLxxX6nFL6hyE+hBAyHwaDfv5v3vucN1QsCSGEEEIIIYRMBX9YEkIIIYQQQgiZClph9wCyTtl2136L2aNSbJ8hprGkxoJXQn2sE0qjBZJUtSvbTyFkl3TbaCXWhnT7im2mOW91kOc0Fs5SxbzseHXs27NsVwuNCn2OncfQNYyFE6VejzrHrbVZZT+e1/WfKEALn51teoHak6X2hd21aMjMa/nLhsNiKEN3WBxv17lONrzHWGGzrOG3ZaaT1BjWzi8tsIQQMl8GOxDeM+/9jaBiSQghhBBCCCFkKqhY7gFknHwdZqlkau2llCuYRYjONIE/06hpdUq8pASUoD15PDFVKyUcprRvlFKQQTxaxwOlXuqoGqFt3H5JRW27VZNpVLQUSqVwItc0tU+xcz9Ll0Js20kUsFS0bavKHrn9CT3DkzzbdUoMBZXQoVJaBOVG+kL17K0U09ZpoU46q8g2xNQ9V9NcB4b3EELIfBkMBvm/ee9z3lCxJIQQQgghhBAyFVQs99DYSneMZamA9wSq1jTlCuqUbJDlEVLKJaCNWBmBVGal7IT2naL+VClULgMxbrJO/2VxdNnjlHGZkzBJkftplFGw3SU3piF2fKnKpbZ96BmfZPzxTl7/7SoLJPeb4rJw++H+HXp+7boYY6mVGxFjLDEf4ymXYvduQLHUygVRdSSEkN3PoD/YgTGWVCwJIYQQQgghhOwx+MOSEEIIIYQQQshU0Aq7i4HdSgvvqbLHTWJ5gxXNDaxJxd1f1b5TIvND9jhtP3VshVV9ktY37VxMYt2ssmy6+0FvhwFrYEqwSwPHLEJ8vL7BkgxLndgmdjx2v2Y6jY1x1vbtaeyekwT+yDCimP1ZXrs6+6u6vwdzCmmZJvgnRr9OiZAaZUVA1Tbad4v8DsbUrrtwqmx7FSVCMF1or+XTpUax7YpyL6MESbdTtLvVOVksMNPY8da5xrTPEkLIfBmw3AghhBBCCCGEEFINFctdjFTNUhSQ2BttqQLKt/8p+wmVPIiF3MRUxxBVJQi84wkcZ2xbGXgySUBO6PMkzDK4ZLuDUdRjn6D9kPqoza0T0rPdZUamua8l0yiVdb4DZlEqZ5I+1nELzLLEkNZ+lfqtKZZV03FnI4ple9VbFeE92jwE+rTNsUvFcrAwrFSjZajPrEqUEEIImZzBcAfKjQwZ3kMIIYQQQgghZI/BH5aEEEIIIYQQQqaCVthdTFUNxNiymHWwylboLp/EKloZDjRB4Eboc2heKtL+m2IVq1OzL9S3FIuqXCdmeaxTy1C2j9AeGxa0teW177Yo7wdpkZ5lbUy33e0mdN1j90VqsNC0R1BleUwJdAnZtyephThJYM4k7Wp3cuj+lscZ2699VsxnLRxN9inlu7jcWWGJFQE9JvYn57Bot2SXRT1Lhe22fBNCCJmeAcN7CCGEEEIIIYSQaqhY7mLqlP2Y5q11nbfxs3g7HlNHQorDrPsmjzmkuLWMejdpn2RAUopyWWo3ISSmSnHSgo5KapY51hT1MRYQktIfdxsZrjKvoeaTqHR1VOmU9mRfpik/EuujVZY7uvKllXiZVyhVVRkQt2+lsjoBFbepKfM1yhJhGzkt7bevnM+Gr1Q2Wufy6eFWWw3qccGydkj1RNs1ro/nQJFdZZgPIYTMhcGgn/+b9z7nDRVLQgghhBBCCCFTQcVyFyuVvaWliSP7Y6pWnfGE8xrjBtC3KqUvtu28ynGkqEup/Y+Na4VHvhlpE+MkQ+pmdIxgjWOvUipT9jsNof2p56SiDIc2RrUKTdUKqY+x7UsleWrse17lVGb5jGhM0/8U5TW0v5RxmKF7JaiuamMgjcpoS4hAjYyUG2kPh/46Uql0xmvO+7uZEELI5Az7g2zQH8x9n/OG/2UihBBCCCGEEDIV/GFJCCGEEEIIIWQqaIXdhcBmFYvBr9rWWko3w2EPk4TdpMxPtcxNa+WbxC4r911qYwalS1RawqLnhHAUHRpb6QaZOC/G9jdMKA0hQ3pi60pbqxbwM0vkfVEV2uJuEwpRqbOfmE039dlIKWMRQwuXqcu8y0tMUsImpUyRPBe4v2PXQn43ls555J4K2VllySFtG7uteRYHC4VlNWuZ57i9Ot4I8ypYciyxmj02Fdl/OWVADyGE7DwDhvcQQgghhBBCCCHVULHczUplIKAi5W10ylvqUIF3bb+h4J9YkEioaHlKOYMUZaqu4qGFtUyi4srSDVa9yCLnXCqUomi6WrbAEFISY4E80JhKZ9FRn6QSJT+rCo5ZZ5YqiGxrkpCYFOR9OMlbNbdvsoxFnT6Eng1Naa5qv06oT511ZPt12gg9v9q1rSohMisnhfz+keForuMg9B1l+9o6XUwXTurPc75y8Ux3zTH3zLYI81lx2oZ62TPhPRnOgRYKZJvvTO1wIYQQMh8GeXjPnBVLhvcQQgghhBBCCNlr8IclIYQQQgghhJCpoBV2FwKLVop1tMq6WceuFqvv1pxhgEhKHbnQflpbW2HLnAjPmcRil2IRtBZY275ot98qh/ZIqxwCPiIW2GmCeeQ2LSX4R9qZJyEU1jJJmzGbZJ1akdsZnDOr8KjU6xU71mnO9TTXPCVsCchz49VrnWB/Vec69t0S6rcWulV5TfH8YqpZYbHfoalLPBx4ttcVZx/4G1ZY2GXHjXSSa8pul5WcEELI5AwGg/zfvPc5b6hYEkIIIYQQQgiZCiqWuwgZnjOJKpgSrFHVrhZQIpUpuVx7Sx4K7dFUqLoBJXWOJ9Z2qNRATLUdB3jUUH0QwtGsViqrVB+pULjzqtqaVj2rIqUUyiR9TLmv5X6kgjOYwb1UhzrHVUeFrqNUhsK2UrYJqX84rli5lpRrHXJkTBNCZPsUURxDDpBY4E+lgukqlig9YqaNRuGyaDf8/9y6JUbwN5RKuyzkdJhSxWcJEkII2YFyI32WGyGEEEIIIYQQQqJQsdxFQKnEGMukbQJv0qdRLt232c2ayqW2LLTfOiUPJikRkTIGLqRmQY1sbimFy1uBMZWYH1MyZfkAKBJOOZJBc5/Xt0lUR7lNijrXcMavbgezHCcZajOl3VmrNfI+i537kDon+xRTA+sQGocXGrsaQyqVKdtOcu+mtBs6j9p+5bHKshy1vitDz3bLqJQjOie9aUmFNKwq9yFKkwConUNZrkjpW51rOc34XEIIIfUZ9HdAsdyB73gqloQQQgghhBBCpoI/LAkhhBBCCCGETAWtsLsIadGaRZBISkBOihUsZO8rBdo4pJRLkf2UfSkFibh9iuy7qo+yL9ISOy4Zolj5pPW1tGPFtoZyAXJbzSlolg2ylnru7blwS1KI8xeyZbrHja3bVUEoE1jp6oTEyFPg9jlkpYyVkplXuYWqQJdZBfGE7L+TWB9Tzkzo2QgtTyH2HTNJe1XbaM865mnlReQ2wQA1WF4R0APb60LZCrvQ7OXTpYZvhZVT92/YZlF+ZMXs/yzad8J8Bs390eOYZPgAIYSQ7WHAciOEEEIIIYQQQkg1VCx3ATJUYpKSCnL+JGrGJKpLTLWRx1UH7FeeE7c/IUU0pUxGVXBRtPyDPGapXLrFzCOhG0VbyvJIKZIqSseV8LbKbpMQ3hNSQbAXnHPtek0TFFJZXmKPUKU+ascZOvaU8K1ZKqQpJYaq9jvJ/lywz2Gg//Y7wCiO2rJQgJG738ryIqKkiJ3m7oFzxSyjVEoOm/1g6pcXEeqm/J7wvi90xZIQQsjuY8DwHkIIIYQQQgghpBr+sCSEEEIIIYSQC5yvfOUr2fd8z/dkF198cbZv377scY97XPaJT3wieXtaYXcBNmxBsW9p6826Fpy02k1rL0wN7YnV96uDtMDathJCR6rOabQ/NuAn4Qmzlth9/ufWZqX9NRhO5PQNx1rn2skQIGlzjbUVshtPcg+lWCrr3BeTWDXr2kBT2p/EdqrNr7LAyvsjdkeH6mWmhOqkfP9UrVPnOyxGKOQrFiImP4cCwpLuO1hSZZiPQyiQJ1TXckRvOIzvz7HWh+py2k12ILSBEEKIzmDQz//Nk7r7e+ihh7KnPvWp2TOe8Yzsr/7qr7JLLrkk+8IXvpBddNFF56di+eEPfzh73vOel11xxRVZo9HI3vOe93jLh8Nh9prXvCa7/PLL81/Zz3zmM/MTQgghhBBCCCFE581vfnN21VVXZW9/+9uzr/u6r8uuvfba7FnPelb2iEc8IjsvFctz585lj3/847OXvvSl2Qte8ILS8l/6pV/K/st/+S/Z7/3e7+Un4+d+7ueyZz/72dlnP/vZbGlpKdutQKnsmT4GlY6Et/ExJSL0Vn8WQT8xNVAeT0p5k9SwjpS+aYTe7vdr9KkqQEkFQT8ytKe/kl7OxDAcOH1NCN6RfQuWkUhQOlLVkFi5m0kUlRTFq+p6TFL6YhK1LnZ8IaWyjnomg6YmYRYljergnpNJvodCamMs+Kyk7AlniKb41T4vg3GbUCJlSA+mUrl0lcols21pHauQjr835DGH1Ns99faYEELOU4b9YTboD+a+zxFnzpzx5i8uLub/JH/+53+e/2564QtfmH3oQx/KHvawh2U/+IM/mH3/939/8j731H9znvOc52RveMMbsu/8zu8sLRuplW95y1uyn/3Zn82+4zu+I7vxxhuz3//938/uueeekrJJCCGEEEIIIec7V111VXbo0CH77+abb1bX+9KXvpS99a1vzb7qq74qe//735+97GUvy374h384F+zOS8Uyxu23354dP348t7+C0cl7ylOekn30ox/NXvSiF6nbbWxs5P+A/FU/D/DmuaosR+xtf4riESsqX7XtJEi1MTS+K2Wf21VWIqQqpYzTCy7TlEaUIJHlR+qUFhHbDpr7gmMepzlfaKuhjFUNtVtHfZzl2C+trUnG8aUqldP2vU5pjdQ2UhwAVfvVlGW5TayUTLC9iHo8i++bScadp4wBl+WO7HezoxgWG5ef362B/59VqI8rYj/uGEsola6K6X1Wyo2kjBElhBCyOxjs4BjLu+66Kzt48KCdr6mVxfqD7Gu/9muzN77xjfnnJz7xidlnPvOZ7Ld+67eym2666fxTLGOMflSOuOyyy7z5o89YpjH61e7+ih/9qieEEEIIIYSQvc7Bgwe9f6EflqOMmsc85jHevEc/+tHZnXfembyv8+aH5aS8+tWvzk6fPm3/jX7VE0IIIYQQQsiFwlOf+tTs1ltv9eZ9/vOfzx7+8IdfeFbYY8eO5dP77rsv/8UNRp+f8IQnBLcLDWDdblzbkgxhCJVymJVVrKr8h2vJrRVME2ivMUHIDfqAbWRgjktzczPanrS+aX2chY3M7r+x7nbOLJy6edV2ZxcJ22rIzqiGv8CyLO2MuF5KMJBsV1qH65QdmaY8yCTUudYpfQrZZVOuQR2qAn9qBTRFSL12KdbbSa7tJNvErL5VgWOx70gb9NNe98uK2Oe6UwrvaTTwvJhQNhHQg88u0ia7ao6n9B9oGfrlgOPAd2e7hjWaEELIHKyw/d1dbuTHfuzHsv/v//v/civsd33Xd2X/+I//mP3X//pf838XnGI5SoEd/bj827/9W2+85D/8wz9k3/AN37CjfSOEEEIIIYSQ3cqTn/zk7N3vfnf2zne+M3vsYx+bvf71r8+DUV/84hefn4rl6upqdtttt3mBPbfcckt25MiR7Oqrr85+9Ed/NE+NHaUZodzIqObl85///Gy34b4lx1vxUPy+fPs/LVVBHrMuWC8VHC1sIqQcpqiNk/RV9sm2CbUkotpYNWNBFjPvl5XFqlOJMJCBo0S0RNAP2ksoQyJVyFngKWAVqlZMbapSrKdRt1KIBdZMQpVCri2NPQPaenX6q/VnEmWq6vsh5RqHru0k+4n1Ec9pnf3JszgQZZ7cv207iyeLaeekHqYDJdMJ3EEgT1uE9WCK5W7AT9eomm6wj7q/Gvevt94EjgJCCCHTMxgM8n/z3mdd/sW/+Bf5v0nZUz8sP/GJT2TPeMYz7OdXvvKV+XSUVPSOd7wj+8mf/Mm81uV/+A//ITt16lT2tKc9LXvf+963q2tYEkIIIYQQQsheZ0/9sHz605+e16sM0Wg0sl/4hV/I/xFCCCGEEEIImQ976ofl+YQW3hOykVXVt5y29mUdprETynXr1LGMrYd5IatlzEaLbfqBvkX7BWsqgj1qBe6IEI6FsZUu21rRNxEWWPd4WyJgJxQA5W4TssHF7HHWIoj2Attq+0+9/6axt2p9mWW9x5S+hWzWMdu73DbWxzqW4Unss6EjjNlN5TE3E57B1D6n2ILlc+wuD9bvld+7zjo9uFzwbLdWfcvr4nHfIrs0Lml12OwbllgE88DuKud7fyO0R1phE5BBZ4QQQnYPg/4OhPfswHCH8ya8hxBCCCGEEELIzkDFcodwVciQIhkK84mRsk5IGY0G1Zh1peqjqSchRWWS4wn1I28/cVtNlYGSJku9hBTM6HmEKglVwyk9YEkI3hk3LEoZzAB7riNqRkjhU9sBgfZiyltIFawTJBILv5H3aMpxVaE9o7MIPgkFdMWep5AiFSvJU0flxLFuRxBUihJbp3TINC4MqVTa0iLu9V6833cUWMXSKJXLRdHoi9rjc7TSbHsKpZxCsYz9xxelSSyR74LQOWAwDyGE7B4GVCwJIYQQQgghhJBq+MOSEEIIIYQQQshU0Ao7Z6yl07FdVVlC69R9nKQv0yDDXDQmCfCYhJL1S9j/prWGBc+5tblGAntggUVtyhSCwT8ROxxCc9A1aftzzkFD2GND1kct8CdkL43ZJqvO/ySW2JR1Z1GzbxbPW6xdSYrFM6VPqVbRaSz00yK/H1Kuk7Swp1h98Z0rbcdoywb2jOic1kN78FnUr4S91atTKUJ6Drfb3n903W1gfS1NsYJTvzJ03nAcpe9bJ9hrklqxhBBCLpw6ltNCxZIQQgghhBBCyFRQsZwzeGO8ubwcLDdSp8TGJG+iQyE6anmECnUipppM8p6kjhoi1TOp7KaUlQidR+2cVKo6dUJ7WkKB6EfUSdmGUT0HzX3j4xH9LR2XWC9fB/eKUTRkwI92P0hlUq4j78NJVEJNmZdqWUpJlEnCoar6m3I89hxk28s06mlKcNcs+1RH8cU6KKHjfo9Uhfdo3x9S1RwKtdMqfQvD8vOJKRRLhPgYBbHRKPrYbnRKiqVVLs1UhvdgvqtQdrEuVE4cL/bvIL/rQ64B99rKZbNQ8wkhhFQz6A92ILyHiiUhhBBCCCGEkD0GFcs5g3E+7ngeOU5RvkWeZnyX+wZfbi/3U0fpsW/HlTGWqapFbD+hN+nbPTbIHftaeU6tgmiKqGvIsZVyrJQydsqql9imJT43xfwRW3of5Zsjq1I64y3lupgvx2BOWsx+FlQp2SllR1K2kcu2azzhvNsMfcds93UrKWTafgLqqTY2u2q8duy7Bc92aXwmnvnWWadP4lkTYyqzzklPWYQ66f4tpyXF0jnurjlPS0a5hFKJ6b6Fc/l03VEuq9T7lGtKpZIQQubDYNDPBoPm3Pc5b6hYEkIIIYQQQgiZCv6wJIQQQgghhBAyFbTCzhnYl1zLJaxZ0ryVYhmdxFpXZXXV7LMhW6G1UjnbhAJX6vStTsiH/Fwn4EUi+9rS2gjZW7XwHmDtqzUssbZTgTb6CedtczN4HLg+pZIx5t6MlSgZbKM1edb2vHnZ/eT9Pklph5ilVxKyhWqBU3Kack6qwsTqWC1TAshSsPcsvmPM/Nh3jPxeKFlhEdrjBmqFLLBLx/PJQudUPj3cWvBDdpy/26Ewnxrfh67FNvQ9VMsWzDIjhBCyIwwHA2840rz2OW+oWBJCCCGEEEIImQoqlnNCBkXgrbm2Tgj3rXwoNl4qSW6bVe1PU75A3XYGb0rqKJdStbAKErrjqMSVKirUgEE5OMSG9UgF0a6otRdRJIN9kO12gsqoVyrBKVEChVGWFnGPB2qmLDdilV+tRAnaMNNmIHhFO8tS6ZpGUZyktMg0TKLQpqhpsyBWHqYqUCvlGGPBOaGzElMUQ+3FArRC51LeB+56cj+yzEjpeXYVSqlYmqkM13EVy6PtthfWYxXMiPqIZbbsiLkG+Gy3dftoHBOThFMRQgiZL81WM/83733OGyqWhBBCCCGEEEKmgj8sCSGEEEIIIYRMBa2wcwb1K1WLqrQZThB6Y7cNzNfar/N2oU79OxleMk0NP83SV2WLi53PyuMwVlKv5BBCe0JW1RS7K2pUpoT2VIHwIJehH7wja6FGmxPrxmyfoQCXOsEuYJqQpzrE2pfHqoVS1W0/di4msaWHApOmCdHR+hh6bkPbxujX2KZO7VC5rvzs2d7N38F9W0v7amUdy0ajsJIvNTtqjUrX+gpLLD4jtAf21iXHGttLtMSqz3wA1qgkhJDdQ7PVyP/Ne5/zhoolIYQQQgghhJCpoGI5J2TUfeytfEoZAVAV3DCJWhJrbxZtAbdvsgQAaJpyGdr+6oQdpZ4fqQZ5bVSpBVKNTFExo2VGAiEmvX2mbSV4ZauhnrftCoWRn+uUeJFBP6H16vZxlqElMTU1FmYj+zSN8p/qRkh51kP7iSmkoYCkWZ9z+R2Q4oaQYWix8J4geEZj5UYCz6JWQgR/r5i+YIr/2HahRmrtBEqTRMuOGEKKsufySHAjEEIImT3NZiP/N+99zhsqloQQQgghhBBCpoKK5ZwoRdzX2EYj9L5Zvu1XlQg5LmmKEiWTlC3QtmlNoHyExveFPscInjdXFZTqhVQoQwpj3o5QENEWVFAzNjLeSX/85MCetfE8KJUhpc09Z6GSNVppkllQdb22mxT1EWMq5bnRtk0dJznrsW7bcd5m5WIIqYMpCpl89lK+u0JKZWxb+x3cXtdLi2jjLs1nOabSHScJsI4ca4n/2K6I8ZN5O+K8He71vLZi/6GW99c0Y9kJIYRsD02OsSSEEEIIIYQQQqrhD0tCCCGEEEIIIVNBK+ycgP0K5UY0qsJApi1XULVM27+0VUlLG45Ls/vJsgUp/bCBLk65gLrWxpTzN1N7IiywsLNqIT9asI+7TZ3dJVjdZmGHQxsN93wGLKIpTGMNrRN2U0WKrTVU2mNWfZzmHNQJ4KnbhrasdG5q3FvRMKzAukOzfy3QK7UkifcdZr5L7HcK7O2LJ4vp0nHTAee57ZxU14EF1lpUNSts4DNCfJZQOkS5Xqvi3JfaTylpRAghZNfRZHgPIYQQQgghhBBSDRXLbQZvzqFUlt6eT9DWpFSVManTfkwlDIVJxNq324hwo5haIsOG6gQjhfZfVkQUZWdhVVchoVTGSoiEgn7cz2hXqhNov1W+d2yQj7mvSqqTEsyEcJ6QerVdJQlmGWqTElI1yXHIYKtp0J6NkCoYU+SqjiNFzUs5F1XfA3WCjGJ7S/2+0RwUoe9P+X3r/j3obESDeaxK6aqYZrrQOZVPD7c7XjAPQnfc8B2ojD2E9Jjp4YjKiSCfIrIny1bNZyiYmO9950zgdiCEELIzNBneQwghhBBCCCGEVMMfloQQQgghhBBCpoJW2DkBO1aKXTMlLCMUilEnLCNEyjbYTz9Sc65OuEnVMatWx0Cf6hxzpS1TC+Kpok7AxtZKeg1M2a5nxV3xLLFNGYYEC6FzbmQ4T8imGbOsoo2WsKTK/brXZxIL7DSBNfLZmFWdv6o+afdW6BmIWXpD9UZTCIUS4XrVOW+TWOZTQsSqnnXvnjUWWBnsE7ayuzVKK55L1LN0bLELS/f7oT1iE8zH1AVWWDldUiyxp8w5PmXqV1prrKx52TffF/nf+r0kr1fseduuWquEEEJ8Rjk6cw/vmb8TloolIYQQQgghhJDpoGK5zeBtORRL7Y26DKEJvcF33yoH3/ILVSZW0kNuO0k4kNZnqYbIcB37Zj3SXqgvKX2cRrksL3BVwU1fKZQqo6aIYB6m2CZFqaxqy6iURZ/SmtBKN2DTlgj1qUNI+agTFjNr1SSk1s2aWdyzKaR8L6TuL7ZO6LmRz/ok+4kF/sj2tYAeuW/7nSLme22jvIgM32qJ50lRLJcC5UWWhFLphvfgb6iNMsynLdrU2kdpEi3ohxBCyN6jyfAeQgghhBBCCCGkGiqW24R9+27eutvIe+VtvyzGHnqT7xIa7yTf9s9qjJvcbwohhUNro2qdFFVLKi0p401rqT1QF42K2dwq3gQNFoa6oqmpmGgD05TSJJLeiq965vtsqde4FVEfQ+PT7DlQtq0ahxkqNeP2rY6ylzq2UltvXmM5p1EkU8ZTp4w3dtHGdMauSxV19h/6XpJjIrX2p3FMyO8abyx767RfQgSKJRTKhZNlxdI8l3Z8pJktxzyilAjmu38viePBNqtQPRXFEkqlHdOZoFhO4zjh2EpCCJkPjWZj7mMsR/ucN1QsCSGEEEIIIYRMBX9YEkIIIYQQQgiZClphtxlYYLf27w/alayNS3yO2ZWq7IRaAMYQ9kjRrtzGtZDK8ijDCey0WgiHu7/Y8aScg2AISCRApqp0gg0AGkfaZFmrM3m5ERnSAzueWjpEtDOBXXYWNlB7P0S2qQrncc8vStOEyiJo24Tak/dqnVAnjarSNaFgLW2bScJ0UuymIbtxLKwqtS8p3zEppVEkKZbbqhCfmH0WfSmVc+oY+6trgV086QXz2Ocq8pzFAnc8e6tz/qytFXZZ3HcI9THruiVK7H7E/qNWWBNKFLpHte/HSYYYEEIImZ4mw3sIIYQQQgghhJBqqFhuEzJEIhQy4dIMLNN+/U9SvNzuO1LuI7SN3a/YVisdElI6YoXjJVKF0dQmKGByG8yXyqVG6A2+qrSgILlQCpJqfchyI3J+bJsaWCUncOzuUTW63SSlzStRIgORlHanJSmIJ0EJq1JT3TbRmlX6A2qZ22adABy5TUoZliqmaSPFFVGFFhIUmmrblNwQCaFOIXWzpFS6jgCpSGLaEGVG3GcTAVmdU14JkVD5EU1ZROAPAn7aTsBPPt+5fj05Feui/S33O8H0v85/AyRUKgkhZD40qVgSQgghhBBCCCHV8IclIYQQQgghhJCpoBV2m0GoRKyOJRiIsBvYlDTDWymgpkaf0D7CfIDdn2PxK9n9xLYlK5oSzhLqex1SbF42XGQCG2NKOEsJY4m1lrpYEE8dpGVP2mf7fj1Nry9YJSuuR+lsOefAWpKNJTaFUKBP6D6MhsJMYeWcxAZaJ/Cnqp5qjGlCbWZZE3NSe2Sojdj+6tStlNvIdVF7Fd9T7ncL/i7V6cX9D9srAnrcv6UFtiWssIr1vC1qTi4FLLCoP5n/DdusWSZrX9ptlXMTqpup4j7/DqEas4QQQnaO5g7UsZz3/vJ9zn2PhBBCCCGEEELOK6hYbhN4o44yI1AsNYJlPxL2EwqoiUX0Vyk2KSVREJ6iKZZ2axn0UiO4JEVRlOEfzRrnqLLMyEJEKYDiIUuGTKJYSjUyZRmUlkEk3MeURrHKpVGBNHAecUZwnlqK2pWqfqSsJ+/zOsrKrEteyHWSVB+xDc5jynHUefZC7dUp5RE6X3VCv+S67vNXdR1ifZXKJL4r0ab73SnVzUFno1jQXPXVR0zl3/nG5rlqB8qPjB7t9lo+XWm2vNAeiRvAAw6bvslAn574j25bWTYNVeWXRlC9JISQnaHJ8B5CCCGEEEIIIaQaKpbbBN7Qby4ve2/d8cZYU5BKJUmwQCtNIouimzf5dcaehcqaSCUw1sc67cv5UMS0ZaWyBTUUMEnsLX14bGVg/KRGnZIhVeMmJ9nWVWFkfzH2bKt6zCNKiUyjasS2rWo3VoYmpsLUVfImKROSQuj4tLG9oRI8Kar+LMtJTHLOtXHiVWOUte8NqVDKceh2HKXmHmhs+K4BqJLa8xoaWwml0mzbaIy/k5cCSqUtISLGS7pjIWV5EYy/xH9sZcmS4sQM1bGctsyJ+bwe+T6S12W77nNCCCH1aTaaWXPO38ujfc4b/peHEEIIIYQQQshU8IclIYQQQgghhJCpoBV2m5DBE5g2NzfL1rNAUE3MpjYIxfxHtglZprBurERAKOQjZt2DlU2ihQeFLLASdz7akf1OKRFRsouJch3jnSRYYSVuWAisa7CqwsYq23WtsPg7tG9ZjsTdprfPX1VcF++coyyM+NzAOpHAH2lnnqT8h2wrxf4Zune1dVPL37jtyjZi91KoPdlHPJOh/k5K6Dhj69Sx3Kaeo9gyGfSjBf7YEiLSAos2G+vjhnHPwwLbwjRgGy8ajJcXMcuH2fgZ7DaK8J6e6cMpc25XYHk1fV8x62O5V4IENlZMzTbS5prvB/ZZUb4EbeDzQ4tKGRUcsrCyT/NMEkIImS1NhvcQQgghhBBCCCHVULGcMaW38AHVTis/IgN5rGoSUReqFIhoWEuKMoq36qL9WDBEVZ+0bUPnSbbpgv7i/NQp4WD70HbUEA2phLiEFEU3YAPb9wLHpwXxYBvZPtbVtum3Zq5SDBOUy2lKh6SogqnhMynLcGZi93BI4asTmCO/A7RrkhL0E2o3GM6SoEKWAl6wqdK3kJMhFg4TWkcG9WjY6yIXuCp8Rzwb8lmJOQz6Rl8crPrPUQ+645gt0w6USFk6RIb6uGVHVrGNUCOxDrZ1t3HDf/J1hOqJqVZGpbd0KBrewxIjhBCy8zSbjfzfvPc5b6hYEkIIIYQQQgiZCv6wJIQQQgghhBAyFbTCbhNb+/er1i/NWger0kDYQuvUXwxZ21JsUNLGGNtfKBzItcVZS5s5DtSglKESbpDHJGEitg8i/EMeR1LbIQudG6ojwz9AyUrnfB4Gak9K615TsbfKbbZW/H64Nl1j6R2I8B7bdXENNGT4h3ZtEeyj1WGd1hIrrareMmE9rGPvC1liY6FOdfYTrL0q69E616HKWus9TxX7k31NsanLz96TUVGLMqU+ogzisTUqHcu7tNyGzolXBxTPBOzm8jmSz6baOWGB1bYx6/SaRYiPBNZVaXsd0dXqVCo1MN3zLK2wMsTHtqVYYfsLR5OHAlQFm9E2Swgh20OT4T2EEEIIIYQQQkg1VCxnDN7UyzIjUOcQNOMSVNgiSkRIeSitGwnFkUqeLSHhqlGBQIim2F/sTTeOvS365h6DqpwoaGqWbQclQwY13tDYMiBZPDAnb1+oIkroR2kbqTpiWzfgJ99vpB0olfiMUguxoBIclwn1qUOsRElKkE+wSxWlcFLvAa2PKYpenaCf0PwUta5O+Y866p/9LJ7pOqpwSKFKKcmTEvYlQ3ps6RBZQmSE+C4JnQt/m8A9L0uIaOVGbCcjIVgBEKYDtXFVqJGuOnnYTG3JEFE6BOuizbzdQNCPLEPiHZc4FynfxRIqlIQQMh8aO6BYjvY5b6hYEkIIIYQQQgiZCiqW20RJsVwyaiBeTTtokf9eXLyiJrjjEz3k+Ex3fFJAeWh2u8nlOaSqhDFj2rqSlJINleUdNsdv6bEXu24fc0ShcKUZq9KGuqSpGVAIoFSGFMsYaNfK0ZtlBdOqqIFxmTFs0XfM2De1ijFN6ZCU/cSUxUkUlZAqiGtep3TINAplM6G97R7jNkmJEvmsy3Ijto/KuZHfe/L4tP1YdRPtwXnQWC/f91DrSzsW4yU1ZQ/PU6jsiKpy+mMspaIIVpTSIaUSIlAsFZVzxfx9ynxeNe2d6GFkZhbpIz52fIeIcs0bCd/fhBBCZk+T5UYIIYQQQgghhJBq+MOSEEIIIYQQQshU0Ao7Y6R9zFpWjdVx2FoMbivLjTSN7RNtaME1pc9mG7wx6CXYWqX9DiVFUojZCkvW20jgCvogy7MAzcbYTyxFoVkux9v0dZspLHduuZFJkGEisK9JS6yGtfUpVj23jdjuzXmLhd2EShDMwgKr2Vonsc1OY1GtU8Kmqn3tfpdldKJ7qxGEE6KqPIcWiiWRAUAoCeSC7x25Lua7IV/WahsI64kd5zho7HS5jI4Ez0Ar8DzJ9bwddeJlRxS2TDur7TXPzmpDdcx6rmEVJUhgY0VID9Y92m57YT4juqY9a5dFuRFZukSx+Mr/5tgyT9qwAhG+NYtnkRBCSDVNlhshhBBCCCGEEEKqoWI5Y/AGuBReYQttlxVLq2qKQB4Z2uMqicHC8QklG+Qb7ljRbK/0SKIyJQkVbteUJKv6LAzVchleaBFCPozq2NxqpJd2sAEhQtmAEqIpHnKeVCFTCCqXTtsygES2rykssoSCCQCKKREhJS9U7kZdp6qNiMoO6vQxpICppWsC5XTqMEnQT2UAVcJ+UkqVhJ5bXZnPokqi+90jz2mKemvVMrOunYr9obSI1388i7FnL5WQgqkF/Fg3QiSEy2yztXS8+Nwp4nUOh8LTHBDwAzUSoPzIYaNceuuaKVTNU+YcHTbbHGiPn4ez5jhkuNI05UcIIYRsD83GDoT3iNJYc9nn3PdICCGEEEIIIeS8gj8sCSGEEEIIIYRMBa2wMwa2pHJttk3/c9vUaItYHvumBqGKsIHCMpoSCmItU6aNWK27mE02XzebHK9t1Oy0tSdb6XuwdlndNlmqi+cibXexsB5pm82mCPapY6MNrRvbNnBO1BAWrInrgbAWEwTlWrIRwFRliZ4k+CcWslNlx4zZP6v2X3dZyDIqnx+tjap2Y+FA0yAtqSn9CVl60R/Xlh6yY8pn0Ksb21wQ32GBkCoN+Zyi9itsrppdHPPQPrbpdcLtI8QL2xorLAJ62say6tasRJAPgnjckB7X7oo2XBDSAyss1rlD1MAs+nLS2xZhb7H7hbZYQgjZGZoM7yGEEEIIIYQQQqqhYjlj8OZ+a/9+X5nEW3JE6uNNuMvWih5ioSlTcpm5kgO8hbfrjVWFkCLkBeIISuEbCaUbQuUQ5Hzt3XmoJEWsj7avUAZKSmWNUBB5rt3rJM+tJKXEQSgAyFVD5Tq4L+T+XdWmVKJhXzSQx1tmVeJMVRDV8B6UNDDLQrpX7G5JuZdi6l+IkGoaC/FJbT/mAAiF98QU1NAz0pygb9q5kkpiSikeGe4VLG2kzCupnPIZdO9h67rI0kuHoB3c71ASY6VDpLoZKi+iBWiJPm1tHs6n3cXTnqLoqpL4jyrmIawHCuYq7ntTjsRdBsUSJUqwBrZxy5qMS1hVl52R86YpMUQIIaQ+zeYOhPfU3N9rX/va7HWve50374Ybbsg+97nPJbfBH5aEEEIIIYQQcoHz1V/91dnf/M3f2M8Y8pEKf1jOCLzxhVKJMZb2LTimUMDc8TGyVATelssY/FjhcDAIX+FBb5+uIrTDitwAWhTGSJnPUH9UJVHMQ8mSoKqhvCkvqY+xcYRS+bCNTlC+ILauprq410tbHlJhWqvha4p1cV+ElFJN9bbtGyXKG9Tm3x4hxTA2rnZQUQYkRYWUWGUvsiylHIdcJtuN9S10zLHjqlISY9tWjQN1l9dRa+X60nHQqnreIopl7JyHVc1h+B4ujVnOqsc7y1MRer5cVbIRcABgGnuesK1QRLsLD3mqJJTGGHLMJcZRusswVhPtYV0omK4yejbw/MsyI+79l+JGIIQQMnuarfmPeRztsy6jH5LHjh2bfJ8Tb0kIIYQQQgghZNdy5swZ79/GxkZw3S984QvZFVdckV133XXZi1/84uzOO++stS/+sCSEEEIIIYSQ85CrrroqO3TokP138803q+s95SlPyd7xjndk73vf+7K3vvWt2e2335594zd+Y3b27NnkfdEKOyNgJYMV1ob3tB5Mb0QGuUgbbcq2EtfuhastLVTYFuv2nW0QNgQrWKujWmRjFtV+tqCHp7jbOiFDRV9FaRBY6WwZDQVpRbX2OxH4UYfYudeCd6q2x2cZ0BRDK4cQ2g+uk+nToLlPDeaRf6uhM2Z+K8F2Kq11dSx2IbvrpKSW9EjZn7SxpmwjLaR1LL4phGy6WtBVVXkRrR/YPmSj1doKWXubW77tx1sP30ehZ0ALLWvje0CsEysThGdN2nFl+RGv4xgmYL4r1495351DM79tPsOqms9D8I5TgsRFs8JiG4QBob3D5hxfaa7Fbc5b5ntNH1PL6xBCCLkww3vuuuuu7ODBg3b+4uKiuv5znvMc+/eNN96Y/9B8+MMfnv3xH/9x9u/+3b9L2id/WBJCCCGEEELIecjBgwe9H5apHD58OHvkIx+Z3Xbbbcnb8IfljMDb+83l5Xw66Gz4b7xjhbvxJh2BLlAU8aZdDbEQcftoXwa+uOqkDAeSCp8WBiHnWQV0JazWybsKpVDwGftzt21X7Neeg0CpAE+1E/vRlI/QucV+U9TIYJvKvBBa3ySyDzguV2kJlWgwCnNja5AcriPDWrSQpSqlMhZYEwr+SaFOuZvQ/rUyIFXtpvQxpeyDXEe2G1OHQ2VN7O1ulEZXsSztD38ESqNoSiWQQV1Yr9a1cNuU6r3dkWjXvbelyhhSKr3nYSVe1kn7zgmpqELJ1EJ7ZOkQfLVBhcRyjbZYB4olpkvq+ev7101cF/c6NmSgFeYzxIcQQraVZquZ/5v3PqdhdXU1++IXv5h97/d+b/o+s/OIUf2VRqPh/XvUox61090ihBBCCCGEkF3LT/zET2Qf+tCHsjvuuCP7yEc+kn3nd35n1mq1su/+7u++cBXLaeuvEEIIIYQQQsiFxN13353/iHzwwQezSy65JHva056WfexjH8v/TuW8+9U1bf2VSYGVrFS/MsVKaetWCmLhPXIe2mh2fLuXpkmjT9YKFrPcBoJ+emKbmOVT9lXWj/P2J45Z1qlz+4N5IUtdyRKr7EduE7tuMvxDnkfteoWOQ+Ke+1CwD9YJ1dOU7UyJFj4DK11mapPKdYFWO7LKAptSLzHYxwmsql5gTcW+NZurtAqH2tf6FqrLqe1HWl9DbcnQoFifJFrgjzyuUn1Q97hkiBdCtuSxu+vZZ1p8l4Rs3e46ct2gdT4C1pHPqPs3ph3T/tLxfHJRu7iXlxrtkiXWWmCFTXbFnDeE97g1Ka0FVmy7IiywbkiQJBigNEFtWUIIIbOl2WrsQB3Levt717veNf0+s/OMuvVXRrVcZH0XQgghhBBCCCHZhalYov7KDTfckN17773Z6173urz+ymc+85nswIED6jajWi6j9aYFb4srAy1kKRH3b6nAyeUaVqkMBFG4b+Hxhj5UbgRqp6uElZRI2TfleOXxdE7qwUWayjlJiRUZuIM+DaR6q5zzQJkOtW8o+5GiVMrrIxUQqcqkKCyxMCep/tj5xedhq4iWHjiKnHyrNISyIdTIGFIlkW3W0UpiwT91VLpQuyntyW1i7YaCeFJVQm0dKKfaMtl+K6Aax1TPlGOZRIGVJYZKYL7mBJDqY2+fX3LIfVbMdxPKmJT6oqn4A/F8bh4K9NEN7xF9Ms9xY/G+fLpiQrE0dbKUXSbUSKiQh51hGsOeKcVkbv02lEqhUPYi/U5R7+s8Y4QQQmZHozH/ciOjfc6b80qxHNVfeeELX5jXXnn2s5+d/eVf/mV26tSpvP5KiFe/+tXZ6dOn7b9RrRdCCCGEEEIIIReoYjlJ/ZVRkdBQoVBCCCGEEEIIIRf4D8tJ6q/MLLxHhsPIumsxW2bICquFS4RCfLSQGDkvtC6sq1r70t4aC+KReniofqa2jrTNwu4as4xam7Hsh2Jvhe1N1gMFsf2ELLAx+27ommK/rQSbrgxKijk8S30KvzyxlkdjrbT1JrWVzToh6+g0xOx5dWpdSmT4jJ0qbU4SHDRNX0LL3eOVtt9Z9jnUZt1QGNsH684d+O3HnvnNfaImatFIPzOWWId2t+v3YdwDMy3fn/0l8fyI/g/s8+V8B+AZC1jXe8OhN/X6CMtroBYl5vc3x9ete843ua5ctFj9H2x8V5q+Sguzdn/KQC6cg0mCswghhJxf4T2z4Lyyws6i/gohhBBCCCGEkAtYsZxF/ZVJqVIVomqWVB9l+REbFuPMw9t12a5UBmIqp9xWqnZye7dvsi13vc0j+nGElDhtWUitayp9DKm2OB4ZVqSpjq5K6yqxmsIS2m+M0PmqE1YkcVXOoThGobRAdbLlQhTVQq6D5S1HxbCKB0JA5GGiTaW7Ug2RKolVShXlsqrURjRQSKgyWY2+hQJ6YuvKdTQVKNQXLQQspBimhARVbasdZ6m/oUCeQSM5HMaqj6G2FEW5rZw3GVgU6rN1juRBP/51GSujfT8saEEJOhPP0XDrony62jrjqY8oB+Iqk8fMfwuuNNcSn/eZ3Z45uTHu75Z5BvvFtL1QtHfUBPzYEiXuNQ6VqYrcA+6zrEHlkhBCtodmc/7hPfPe33n3w3IW9VcIIYQQQgghhFzAPyx3knKpgb5Q2jphdVCqVlok/4hFR1XrCXVTltbAfHdcUUiwgSoXG59ZpXJCpXT7L9U5Ed2vti8/yz6NX/I7x7WZNubSPa8hlVPiHpfcNjTONeX8yTGWbhu27IJYFlK03WW4/gNdcdWUqZA6ERvzWBqrJZajbEZsFGJonGad8ZQpZUEkobIgWt/qrFtnDGSVkqi1VWdcZmgd2ZY2zrTcnl4qZNDcl6yE2XvJUTnHxzNQ121ublbekyGlWVU2jXIo7/umPV53DLbYt1QwDbbciDNvJaBYQqlcPVW0vXqqrFjadheKNo5etuipoF75EVFqatDUxxJrlFRbQggh20qTYywJIYQQQgghhJBq+MOSEEIIIYQQQshU0ApbAxls4NrL3LAN1ZJaCoNRrI92R8J2hdIYWthNVYBDSiiM3H+KfTalH1X71kquyL6kBP4AabldSCi9MkloziyCd8AkJUpSzgXAvdMwIT4IKnFCeobGFgf7YKksh2OXgz2yyvoYoyp0Zlb2PGmblLbWOvbZ2Lqy3VJ4UIKNVuKeA9uu+I4ZBmygWjvSWmvtpghu0tqRQTuRIKtSGZNAiRetD/L7FBZYzYot2wl99gJrsjiqhViGeuG7xMxvy9IizvGHyoxsrhXPV9dM11bHdt1Bf+iF9vS2iuNYhNVWTPNjbZjSKqZPw9bKxPc3IYSQ7aV5gYT3ULEkhBBCCCGEEDIVVCxrEFNS8NbbKgMlVSlSUkRT1KqoKs8RU+TkuqWQmEj4jAwJgiKGab6uEnjjbivb1NYJqZHueZPrIGgndG5ccMw4jtA2WpBSSB2soz7K+bHSKynqqlW3UW4G52lFLHeUsIFfOsSWYwjvZSYhIFWBO9uttGh9DQXvpATjVBErUVKlJObrBNbVgndK+zHblEq7BPrj9bexXkyNyl1WEMuKIvrYFCq4pkKGyrLIeyqmdoZod7vj/UilV15TPBOagyLwHQLlEGVGXCURYBmu2roJ6Omu9UrhPXab5WLtzW7Rp4tF+25ZE8zbMqrqsHXIOz7tXDGshxBCdoYmw3sIIYQQQgghhJBq+MOSEEIIIYQQQshU0Ao7I8qBCXGrlkfIfomf/bA3alatUFuxUJ9QvcpQgI62rE5gDfqPUKBICEjQ0iuXx/qUcly2BlxgP7LvWnuijlz0vIGqcCJt3dC5dtvC3/2K9jed8J7+lhoOMzT2RYT6uKRa6bT1prHAVtVwdIH9chY2VrmfWECO7WON2pdyHe1bo7e05K0rz2OolqP7dyh0KRr0IiywsVAde47NPWTXNVPXmmqRgWeGUp1JxcpZdS/FwqWs9duc13HA1Wb1M47wHlhTlTqWMmine66wvq6dRf1KMz1dfq5Rz7LdMfeQscSiJiaCgNyQoIdMn+z5Euc+9iwSQgiZD02G9xBCCCGEEEIIIdVQsZwCVwmpDByRamRKqYikTtRQwKrW0ZQ3GexTpXa6y2RkP+YjZEc7DrS/Ydbpr/j90LbR+pDyObaOphaib1LFkP1JUZYB1JKYihtSUycJfVKwqpZUgUT5kVgJj2aCElJS5wJKYlUwi9dn7N/ZJhSMU9WfGGqJocSwIzUYp6IvMdURimjoPMX2J1VArYW2UbqkIirL0XjtolSICN6x4T1aX81+gO2TOD4obynElEx77KGNY+4E8x3WaJ3LpyvNRU9BdMuNIGAHiiLCes6cLMJ6zpzslsJ7BoOi3MigX7TbWWp52x5dbpcVS/M3FMsQ7rmoUrsJIYRsD02G9xBCCCGEEEIIIdVQsZwC900w1JFxhH1AFYQyVUexxLg57WpVjcNT1DO8dR8OFzwFzs7v7x9vA6VQqnVSyXRZOu4rk3JdKJiuCilVVBQkx/mKjRnFOUC7cr72OVUl1sqbSPVZqo0xxVJeL6uSbJavd7PiOGLH0BPbYD9KuZE6SqHdNjQ2EGoTljtqkz2cijGP7nL0KaR2WnVSUahCiqTc1v1bKjraurJvpb4IpVTbtmqcafQcmWtoL18zrsxqWEURx6uMY9TG2IZKzNh1happy5soKmtIAYX6qY3/lNdHljeJ9XcQOveaUllqZNNTCQ+3iy/jo2KaryMUy9XTa55SeeahjdIYSyiWGGOJt8xQNQ8f2FdSRrUSJ9qY6YEzvhXnNqvxrBNCCJnRGMsWx1gSQgghhBBCCCFR+MOSEEIIIYQQQshU0Ao7I4JBICG7pFsWInQVrAXSTHtKkIwMm5F20AgLzSIYYktYq7a0wBqJsGEutAu7V2l77zgibYSCeGTwjxbigwAc2GdtR1bCwTgpoTkhcE2xP+ynrZQtCNnsbEkZZXmoZEhK6RWcH9sHab0dn6NBVqzb3KpvlYiVuCjaNuu5QTIVVlKNmBV10pIimmXVth8I/EkJ+omW7gigWUSrQmcGbWnJFveFe0/3433Rwluq+l8qrxIJgZHX2L1OCAkqBUJF9h3qG65lQzmf8h4q3VN43uRzp4DyIoeFJdYN1UFpkAODYt17TWjPyfvW8+mpB4rp6ulxeM+mKSsCYIk9enkxLOGG6w569tp8neEwKcRLK9dCCCFkvjR2oNzIaJ/zhoolIYQQQgghhJCpoGI5Y0pv1LWwnhEdRQmUgS7DSKiEbE8qi4qC2WhsqaEPmJ9lxfx9TsDLulBGpcppd++02Tbbr2PfCPGJhc2gv1UlRDRCqqpUFF31EMsGQq3AOjZAR1M7RekVeQyxsiah44mpDrESKBJZDgb3kKb0YtdGBbGqj1CkPJVjBqEfUqGKqXWhIBypUGoBL6FwHU1ZrFLpYopoVXkTL+QmoJrJMxDtT68IcslaHdUV4SrQjb58Uqv3I48VITsybEe7blVKtrYMrdjSJOhHQhvYpicCa2QpE29/Zp1oiE/AJYDwnKNCqXTDe/B391zPUyZPnVj3QnzWzo6vzdqqf52Wlot7qbtmzrlRMEOBPZMq5oQQQuZDk+VGCCGEEEIIIYSQavjDkhBCCCGEEELIVNAKm4CscSfnu/Yxuw7sn7BhyvqMGtLqCFujtWUm1l50th3bXCOrGnuVnLq1LZfM8bUbeBfR8wIkesPxNljX1sVsB2pRavZPWDYrAimiBGtFOoTOpa3XKfqjrSOvk9y/to20/KJ9LTjEDQGq2k/IQixDgtz9YJmxVMq6lup9LoJkqsJAVFveBHbaSex9VYE+KcE1IRttbJ1Y+6H9hb5jtHZtHUljj+wv7AvWl5Ttybqg2v6kxdVaX429NFR/MoZ2v0hLrbRej8u4ju/ZkN0YfbL3pxLeIy3fURaMjR92fvPsrTTbaq1KBPaMuNL8vXai6wXzjK2xxXnsrhWfRwwHpm89cxziGrQXml54kGvDvcs82/L4SrWVnTAttJ76HBNCCJmOZrOZ/5v3PucNFUtCCCGEEEIIIVNBxTKBlLe5pUAIG/O/Tz/TWqmNkOoUi8EPKW9mvqs+bg2KTmyZlHoE8WAd9224VB+xTH7uWsXSNOr8jXW7Cw95n+16zbXSNsPQOdHCb+T5kmqn3EZTEuU6KeVapHIYU5Irrs9Y/YxcY9tv0ZampsaOVaq3gXWkigYVKEXxiAW7aO1NSqxUSVVpEtlG3o7sY0CpjO1PLpv1W7tQaZKQwqgtK7WF9ZywG/l9BzWw3e0ml4mx64g20ZbWX01xDR0D1DipvLa0wClH8XSXYTpoHioWLHXKoWvmeUKg2Yp5TvGdqYX37DeHeIcpK3LGlBtBaM+5M8UKh49eWjquwaDYz+qps17ZkUF//P0K7Heu+R7orK1VhixVnWtCCCHbQ7M1/zCd0T7nDRVLQgghhBBCCCFTQcVyRoTGWdk3927R8nyGW8RcqHMYnzmFMgY1Utsnxj5ivCTUR0Tpu+ojxsNhmR2HaRZDsVxV3nzLMZuaIgpOme23QmMSteMMqXIxlVOuU3WOXQVTqoFQDOU2KddJ9tE9Frl9qMyIOwbTlqgJnJOYkmnV9eqxj6UxiGherBdtKaAgxSipgQnjNEPjJWPrVo3LrINUBTWgFErlrc6Y0pRt5DpSsXKVxJBiKbdpRtTUkIIYK1GSchyusjpC3jnoqzuO0o41FPddsDSU8vxjDOVhUWYELgyMqxxx4svF9+uJe/zpQw8UiuWxq68pml5asttsGjV4bfWsf7zm7XajXexn1Tl/9m+M4zfEzjUhhJCdodls5P/mvc95Q8WSEEIIIYQQQshU8IclIYQQQgghhJCpoBV2ClzbXFWIxKC5pNqWPIabvhUWVktE37u2zZCVU+DZWivKi7hBP2BcZsS3wNrlZn5PsRBaC6zoC+a7fbPzRHkTBPzIbUdsDTZ1S+rScf0cuTbQkI0VxMqdVJUZidla5bboh9tWyAobC+KRAU+h8iYu2MaUGxlkvh0UFkLXGlllfcV9H6Mq5Mbdn7QrWstqpP0qW6tmtZQhPaHSIe7xYZ2+sJeGQnZc5LLY8WjWU215LKxFTqV1VLPCVpUD8dqJLJPth5BWVQ17bMISGyq14f5t+ybLjuz/SvkZNBbYhgkeO9xaVocNwCJ7kXO/3GvKjJx5qAjt6a4Vx7584KA3da2wZ04W+1s7W1hhL7rU/6ZtRL7HUcLKhhCJc6KVG5mk5A8hhJDJabYaOxDeQyssIYQQQgghhJA9BhXLBELFxDXlIxSVb9WM/kpZbZLI8J4KVdLDKFO2fMewXAxchukggCczfcfb+BRk7L47ryveihfv8XWFdAUlSkRZE7ShRBHZuT2jKpSOVYQVecurQnRSQnVCyqJWBsSWFQmEA8UUUqk6xtZFoI9URrVtZHvm22DQWSyaMOfeVX9kzI98MzWMlL4IqYCSWHiLVBS1wJdQkBZwjyfUbkhVjQUNpSiVIaz6afoWUx2BLCuhURXkYoN5HAUwRaGs2m+orRTqBCnZfhu1E+qxdu1LIT6mhIhaasg8N7JEEj6jvMg1pq0T94xLJ50yZUaOf7lQH++7q/j+ueLaR+TT5QMHiraW99ttjlx2zCs3stkt9r92dsubut+zMgxN3g8pKjEhhJA5hve0GN5DCCGEEEIIIYRE4Q9LQgghhBBCCCFTQStsAilWMGk5s7Yrs9zaurCJG+Jjwhei9Q9DFstYncdRvxpjO1S7XVhHl0z9ypSboidsV1rwjjs/Nq8tpq69VVrO2iFLrLtfBPyYeb1hz7cBmyZtn8dVMrNhyCIas45WnONhf3942yobrVafU4YPaddfIkN8YvUrZZ1Ps04svCcL1DS0Vk6zWrqZejIrqX2eFNtrVQ3IUECPto7dX0I4kew3zo1mvZX7sevAnjloVNvrjQ0UlscUa76cn2KbTKmpWWV1jfXNDhOQKyjXNnQuhpiv3bPi/Nt7p1FYVi1KeA+spyvCAospwnu+cmJcf/LEvec8KywssEeveFg+PXjk4ny6vHJgfByoIbxVXNM7P/9gPj1535pnhV1abpa/X8WzXadGKSGEkPnQZB1LQgghhBBCCCGkGiqWM8YqAfJtO5QIDShGCF6B6tTs+PM11UkrV+GqZ44S1m72VTUwFj2PN/Wy7IgM5omVKsG6K0Lt1MqNtENqJ9pytxHtYNoVCqamslolt7WlBwq11kvbaCVPis+mb5kJCaqumlCtTmvESojYv839UEeYQJCUaSMWuGLv54hK5qmPyjLZrgxp0UJbQvvR1EeptEpFLxb4E1JitX5UhcvUUUSt2mmUSjdMJxTSkxLeA+TxxI5Tzgsdp6vQSsVTlrrQwo9CpWOskqksl9ewKqjJxa7TXvedIgjtccN7hGIJZfJKMz1mFMvhas9TFou/i/Zb7X1FG0cvyacrhw5706XlooTJiM2Nrhfo01kclyJxcb937d/muyTlHBBCCNkZmiw3QgghhBBCCCGEVEPFcsblRuSbe7tFX4yhcrElLgLlJFCixJXCoGJKQuUsRopbc/xWPRWojjLaPouUDpE3lRw/aXHOp1QD5dQuVwqFjxVKv2xKZsdW+n3V2pdjSDFddfuoH0XpOHuN8XkOKbwxMDa0VPpEXlt3zGXpnsG9ZErXpJQmqVFSA6pgSDULqVH57mo8V6WyH4FxjJriZsffBZQcd7/NRBUyVqqkDlZxM+UqYmMeqxRJOUZRG28q2y2pkl6DugpYOteRe7p0TuqsG6GkdqPMiLkuWlulMbuyFI+iWO4z39OHWx1PsbxmsSjFc/1SoSieuO1ssNzI0nKhTLZNH6FGHjxypFRuZLPb9UqRYJv2gvn+XS6+VU9sjr+FTuFcmPH6HD9JCCG7l8YOjLEc7XPeULEkhBBCCCGEEDIV/GFJCCGEEEIIIWQqaIWdEaGgi5INK2RhzTeWVlhjddxU7IzSztXbrAx46Q3PBcNzXFzLp7WgitIeIQupS6g0iW1bsR3KEB9Z7kSzoy4htMeca6zblfMdm1w5gEc/DvdzqcRKqO8RO2XoXLj76Q5M2EyoJIkW4iRtswgmiQHrtf1c3G/D1mJlCQppCU0xM8rAFflsaM9QqOxHrGRIVbmSYHmLiA00pURJCrFgpNA5D1lSQ233I310Q4FCyGOV1mLYWt1+VFmIY32PBSSV+i/LOVVcL3UdhFXB+rpgpkvH7TYI7UFZkWuMNfV6Y4U9ZC7TV0xQjxvec+ZkYWu9/Jplr6wILLCHj15a7N7YaUf0zHVfWz3rhfe0F4p+LB8ojvfEfeNvwBM983f3WLFu9361DI1n+a5hySeEEDI7mgzvIYQQQgghhBBCqqFiOSdKKklKuQmoUBuKYglFCu0grKUdVreGw+Ktd3dYvMFeSlAWofZ1RYjPkgisQVmSon1f1bRlQExbmI9ADHcdqVhK1TFTSpRAicQ6aGsVfY+oqhKr5irLpIoaUjfdsCJ5zHLd1BAgt2/DLKGeiVQutRooCP+BgmOmoVIRKoEyE+N+jD9DQwoG/SjqU6m8hFGOJiFFVUtR/YAM3AkqbpH9SgWzpA4q56VK9XTna+1pbXgKn2hPKl91ypukEFpXUy7lNSwp2pFSNYOFoa9Qwt2x/858cmDpjN3mys6SF9bzKKMuYnryzlVPnVw7O/4+32cUysOXXOpNDx65uNitEgDVxDNnzgXKjxw8UjyjD5qrYgN7Rse1dZEX7tba+krRFlVJQgjZdTR3ILxn3vvL9zn3PRJCCCGEEEIIOa/gD0tCCCGEEEIIIVNBK+yMSA71sJZExwoLGyumKcErSjhPdD3H+thtPFR8FLaxmD0TNkw3AEdaYG07Yop6kitm27ZWV9K0E6sjmffdsXkhYAPtYhkssLLv7v5kbU1po7XHF7muwSAezdYqLLahOp05Yh62sZbirAhhGrY74ftBWq1lqJO2Dj63hO3UCXzBWSvVQUywPlYF8YTW8/ZTUWNR22aS+n7y+LQ2QjbTkpU0YT+x8B57p1ZYYDVSbbOefRbhPQk2Xds1EcikWWzl56Samnmj42c1ZIWW94W7Hxs01TLPwKKoW2lCe650LKrXByywGyc28unxLxdtnbi3eBZPmhCfEZddfX0+Pfbwa/Lp0cuvKNWtHNFdK7YdcerEA6adoi8b60WIz8qhhxX7M+fKtcIi1K3V1a+xdi5wbmmXJYSQ+dJkeA8hhBBCCCGEEFINFcttVintW36r+hRv3AcoJZKvJJQjqEpQmQBCVrR1TYBDNkD5kZWyKmXWHfaLN+erzXW/lAdUSUchqBM6I0HwDlRNqd7FSnmgTxlUTvP5lNIXu65pH/vF/g4rfQsFFsk+astkn+VUruciw3y08ynbkwqs7ftCoTx7pUlw3XFf4HMdjLIzvkcdlQilDCoCazSFTIYB1SndEVOkqpCq4zSlQyYp3RAr2xIqveLuB9tXljKKzJdqY0z1rAzTqaF24Xtv2jItqfcD1El3fz2U9Vh4EJ3ylMoDnSIo52h7n90G5UUwvdZMb7u3aOOe24ugnzv+uXgGLz52td32uq9+XD69+pGPyqeXXlksa7YQ0GPcEc59sXq6+GZbO1solUvLxX+aO0vFcZw218SWGMk3KpTRRbNNu9tVFWbtnp1ExSeEEDI5zcYOhPfU+H/2me1z7nskhBBCCCGEEHJeQcVyxlS9mccb/EFzqfoqQHWCUplSomRLKFSRbXrtopxF8Z7bUf4iSDUNYyO1dYBVDs25gQLnrie3kZ+h0mljOkNgv5i64zWlYpmizMrz05OfNZVTlCA55SoOAXXTlkkJKEOaqorSJFu43mb8lb3+UL81BRPr2DGWKFVj7tWFsWLZ6Jv7W6hooaviKiOhMXS2FE/k2oaeq1kpL6EyFjGlL9SnUAkRrX2p/GpF7UE7oP7VUQPrlAwJlnxRVNZpxuzJ8bOTlJSxbZht7bjKEe11f4wlngUzxhLPKL6fRhxtt72xlhhDeeKeYlzk8S8XKmGrfTCfXvPor7bbXnn9I73yIh2jmKLMCJTK3tb4uxnzMO4SiuXKoeJ4bjXfGxhrWax8zFMqce/IKSGEkJ2nyTGWhBBCCCGEEEJINfxhSQghhBBCCCFkKmiF3aYwiZDVDJYx16bUz/Z5ZR6snRVlR+DQipUWseUmjoTts6IkxVZvOZ/2Wuc8a2fbtYya47FBMuK4rN3UtYUKe6m0lWJdWHC1dWWJDRvU41gWQyU8QpberjLfbqNuoa8rj0f2QytXYkuFCMtlLCzI7g/L5PE5/UBgEXqxJYOfbKPOfBnwhBApfMb959irh63FaOkQAItnik1zuyyws7CMys/uc4sSK6FnPmYPDdmBU45LhvlIK2lqH9xtp7UXh0KIYudc9hc21tj9YIcSGHuptc+KaX/JaQPlRfYd90J7GvvuyqfHFvZ59tcR1xgL7PVmP3edKkJ6Tp0ovrVOnSissQ+77qvy6ZHLjo37aPqwaSyqsLc2m8W5WDt7xgvqydc5h7IlRd+u+qriu3nlcNGPE701NcgrP1ZjscVUngv3bMp5DPEhhJD50Gw1bYjbPPc5b6hYEkIIIYQQQgiZCiqWuwD7ln/QKIWlJCNDWSLlRmSQC7QuBL/0moOSEgbVDG/MSyqkozLYbczndkh9dLZHCBCWoY1QiI/7t90P1M6ACqipnTHFMO+HoxCo6qzTV1lKxF0XarAM67HLnXkIKJLHJY/b6xv+QPttEeaDa+/eD6HQnqEIfIJyOWpmaMJR+oU6IvUoWdLDVURS1RFX5ZLtTFIyxAtyqehHSDnUtrGhQ+IziCmIVQE/2jkYN+y3McS2QsF0+9bAvIRAl9A5lyFL7nktBfuI+bINdb9YZwJlVPbdK+EkQ3uMYomwHiiVUCnd0J6zDxaq44l7C0Vx9dRGPt3aKLZdOVwUM1o+UIT4FPMuKnZnzk9n0airg+L4lvbv96ZukM/6aqFiHjxy2AvvOX7qdNEPN/zLfH/LsJ7YOWa5EUII2RmazR0oNzLn/eX7nPseCSGEEEIIIYScV/CHJSGEEEIIIYSQqaAVdkZUWYxK1jfHJiftfVnTWMz6sK7CGuvYu7AMaFZHd35sntjWtWXa0BlhibUYu5dnUcU0EMSzFLO1Yh5qOcpttfqSol4l2jhlzqtWk1LaVmHFxXz02bWuwqIKC52165r9yP17f5t1ZR1OzdZqrbCwzwZqfLp1NOX5wfGcGhb2uKG0vcq/NaSN1rEY9k3gCZCGVHs0zvFinZDtM2ZrDW2jWSPl8xSq5+daVe2+K55j1RIb6HOsPmeVFVHad7WalxLNfowah9Y2K851SuBPSj3EUJgT+qzV58Q2Iauytdc6dS1j/Q4Ci7exwGJqLbCmfdhfRzx2X3F/337bg/n0+JcLG+2dnz+VTw9fcrlXq/LwJZfYbVG3EiE++AwQ5tMzQUTFvMK6fvgSEyR0RRHes9FpeBbYsz3nuM9dnU8Wzt3vX2un3WlrjBJCCJkNTdaxJIQQQgghhBBCqqFiOQUpAQh1QhJswAXeysfKi5gQlWxThPQgoALbusom3txX4IXCQHUUwTsA5UekEqcqbFDVzPG5bZUUSaiD6JMI23GxSqH5jL6E+lynhIhb0gOlQ6xCKtqQpVjUPob24xyXVDERmGTV1ECwURTtXpLlReQ9pAVAOUE+I4aDRa/0RkxVqxO4Y7sYKFsilUqp0rjbhvrh3UnbEGpiS5RE2gwF42gqYVXfbHiLcy6kUuiqf1WqllUUQ31V1g2VXtGuedV9oKmTcj92HXNctswISoy493OnmHe5OQUoJXKlolgitOf4l4swnTs/X5QbabWLkJ5jD78mnx4+ekkpvAdK5cCcJ7esyIjV06e80iIj7r/7znx69Ioi0Ofo5cX0to0NP7SnOy5rkm0eKvq09RX1vAH3/EnlmiE+hBAyHxo7EN4z2ue8oWJJCCGEEEIIIWQqqFgmMInqaFUR5e1+jjKGKqhKQm1yS4pgHorXQ42ECiXLj+QIJUqqm2Z+b6F4O6+pYxjXhxsnNo7RqnSijeB4TYfQOEN3jGWoDAf2g7GQ7phRu67YRpYusX10FUsxlnOpYlvteAD6iPOHMZgxYuVT5DpyDOmWvNbufTD0VUg736rdisplVEyUxmn0jYIUGc/VM8pQnRIUEvlcTdLGoIaKNkn7UAy1bVLHBsa+c6RaC1USqnFsvGmojVgfq8Z2pvTbtplw/FKpdFVWWepETqFK2qk7tnK5UAWPmXWvNFOMscSYyxFnTq7n0+N3FmrjQ/cX3yKPfMJX5dNLr7wqnx6+5NKi6ZUDdtueuR6bG11v2j1XjK08c9KM27zzDrvN2YeKcZI3fM2V+fTIZcUYy3/oFv24Gyr02cfbbTpmXKZ8nia5ZwkhhGwvTY6xJIQQQgghhBBCquEPS0IIIYQQQgghOW9605uyRqOR/eiP/mi27VbY//2//3f227/929kXv/jF7E//9E+zhz3sYdkf/MEfZNdee232tKc9LTvfSAk6gP0NtjRYAq0tKWKFC4WaNLcKCXvQOFIOTpHlRiSwM7qWWNceljcsrLboj/P3aqMImpDIsiDW0ulYRGHVlBZOGULjtWeAjTVkWQ3Nc9vFfNhQXcOn7JtsaykWFiTWlTZXtzyIbU9sY63Fos/uPLltJu4Pd5uuKM8i969aYWER3DT3F8A6sFcPY6FPRbv9Jdxnhb1Qi2Wx9kvzOaWkh7Ryym0mCtCqYccM2QxjfYqVHmomWudj6wRLGon13W3qWHGr9qOVQqlqS7Mdy8AlWX4EU3dbzOuZ4B1MbWiPKCni/r2vVRzPsYVlL6xHhviM+MJJBOysedbXYw+/Np8evfxhXrkRWVIk79vWphfec+pEYXc99cAD+fT4l8dW2EuvXPFCew5dWpQdueP4aS/EJzt3vd0G5UWq7r/YPUUIIWQ+NBuj//2YsxV2wt19/OMfz3/n3XjjjfX3WXeD//E//kf27Gc/O9u3b1/2//7f/8s2zH/wTp8+nb3xjW+s3QFCCCGEEEIIITvL6upq9uIXvzj7nd/5neyiiy6qvX1txfINb3hD9lu/9VvZ933f92Xvete77PynPvWp+bILndQI/RglVQEhPppKCVVJFrtHqI8LVKv+iq5QQdF0VE4UPVjt+MqlVQkRsuO+FRdq4KpQLNWgHxmAI9qQZU+8ZTJURwT/2JvcOfelUCIZ1hNQQ1OUUa0MSCkkSGyD4/X6hBkiBEmqniPs1YFyWVI7C4Vi3VWtq+6ZpgiE8u433Itmm0Exv79QKC0xZcSW4RAlNeqUpJDtakpcKLxEK+UR2l9M/ZGty3VDwTkaMQVJU0u1Ps9KhZLHWirtETnX8phj8TEDo/JhW6lUIrTH3Z+dZ6ZQLLMlU3ID97cJ6nEVS4TzIKznUWbbx5rp6XsKdXLEiXuKoJ1TDxSq4FVfVRQ+Wj5QhPQs7S+URbBp1MO8T+b+glKJsJ4T99yTT++5/Yv59Ctf/ILd5uuedXU+vfTKot3PrBehPXeYF7f34hF0yo2E1PuUe4kQQsiFE95z5swZb/7i4mL+T+PlL3959tznPjd75jOfOdHvutqK5a233pp90zd9U2n+oUOHslOndNskIYQQQgghhJD5ctVVV+W/0/Dv5ptvVtcbCYb/9//+3+DybVEsjx07lt12223ZNdcUBaLB3//932fXXXfdxB0hhBBCCCGEEDI77rrrruzgwYP2s6ZWjtb5kR/5kewDH/hAtqTkBmzbD8vv//7vz3f83/7bf8vTgu65557sox/9aPYTP/ET2c/93M9l5yMpISMhmxg+ycCLqKUO89GWqRGYNTplm6K0M8KqCFz7rKxfCYttFglnEbUtZdhMrBblqjhvNoxGq78Y2j3qMoo28r/FPHwuWWFFII/XLupJ9nrqtq7dVPYbgTl2G8xXwnukPRafbfCPU0NP9k0LO5L7WcI6gUChsUV2bAMd4t7B/YBwqL6oa1llsc4bQ+BPcc37SohPilWviio7aGw/SUE5wiYbsu3m82pYXUN9qGNjlf3F90PKtvKYre1U2X/IQizrSrrbDBItMNq5kntD+6UalUrAT9Y57VtgF/2alSMOLJ/Ip9d09qmhPa3TxbN/++fH9Xvv/Hzhvun3iudy5XBhhV1aLqyqbfF9PhiMz8Xq6VOeBfbUiSKs58S9hV33zs9/Lp9efcN47AossMceXlht/8/Z4rjuxn23dnXp+Wv01717M6Vu5axt04QQQtJoNhvzD+8x+xv9qHR/WGp88pOfzO6///7sa77ma+y8fr+fffjDH85+4zd+I8/UaSX8/07tH5avetWrssFgkH3rt35rtra2lttiR798Rz8sX/GKV9RtjhBCCCGEEELIDjH6XffpT3/am/dv/+2/zR71qEdlP/VTP5X0o3KiH5YjlfJnfuZnsv/0n/5TbokdpQc95jGPyVZWAkoGUfEUglTlUgPBO1CfoFBCuZQKprtNSukSo1gOh8Ub+u6gFy3xoSlqoZIeWjCOVn5DayPWjlQWY/tD6FDPPDChsiBuu1hmA3IiKqdVH4WaAGVRU3Ft6JHZZjVwbnrOPRQqfSLbdM/BllS9oVzKsjQuUExwD1WUvdGURChSUj2JKS6hdTTVrkq5iQUKhUqF1FF4YttWlU2po36mECo3Ih0U3lqBcxzrWyisR96N7ndZlXqWdC6gsgvVfd++QiUccU1n0QvrkdMv3looml/6zPi+v/2zhXp5/Y1PEOVFitI8K4cQ5lN+A9xdO+cplaceuN+bbm0UfTxy2aV2m8NHCzX1vmHfKy+C8J5stSgz0uwWiuaIztqDXtkRlG+ZhTOAEELI+RPek8KBAweyxz72sd68/fv3ZxdffHFp/szrWI7odDr5D0pCCCGEEEIIIRc2ST8sX/CCFyQ3+Gd/9mfT9IcQQgghhBBCyA7ywQ9+cHt+WI6iaUkcaaWT9lVpS9IsgpWWWBu241oQZdCKsSq2TurhPlqIj61JKJZr80Q9Sxk0kzcrbZ+y/qKoN6mtG7LCevOF9VRaUa1l1fTHtYHCMtoWNlZpJfWOS/S1Leyzsl9aX4IWWXcbecyB0CD3yuNcykAhe7zK8fSGReiHnYP7QdpcXes0rNUTuOxs8AoskKaPTQTLOLUAU4OzUuziQRut8zeWwU4YQrPZDhJDb9y+hGzA1fEr1X3TzkWoPmfUZh8gZrWUxyXbr1OrNIa18raEfVvUrHTrVj5hedmzwJ6+f92rWXnP7eM6X7DAXv3IR+fTS6+8Kp8ePHKxZ4Ud5Q249lfX8nr8y7d7lth7bv9SPr3sqhUvqKdov5j3/4z19W5zH54woWKoX7nklPTqmLpksMKmhPjQHksIITtDc5dbYWdF0g/Lt7/97dle4jd/8zezX/7lX86OHz+ePf7xj89+/dd/Pfu6r/u6ne4WIYQQQgghhJyXTDzGcrfyR3/0R9krX/nK7Ld+67eypzzlKdlb3vKW7NnPfnZ26623ZpdeOg5LmDV4W1ylAGhR/SU1UwRrWFB2xANhKpt+mIWmVEJ5QgAL1mls6qE+yrYlNVAJkskCZUCAbUPZjS2tYc6jVe1sP8Zv460KCEXSKB8IvYH6qAULydAclCJZiQXxhI5DqJHuceH8VKm4XriPWSZVR6lkeoE/svRJQPF11VWED9kQnzpgGxsSddK/t1pQO9PfluHZ0Z6gmOKfb+Ocv1RVRlN2qgJltOc7FPhjlyvb4/tCbqMde+g7RaqOKeqjPWYEvdQoP5GiLFat44YGhYKYSoFD5jsz77ZRHbP9RemO7MBtxfTgZ/PJPjP/yoUiDMdVKFFm5FrT3m33FuE3999dfGeur47v1UuvLMp7HLnsmBfS014w34Pm+q2tnvVKi4w4ed9xb3r8y3fk04suLb4Zrnl0UWbk6kcWqme+7wPFMd995pynVErFUlPUZQkWrTSOXJfKJSGEXDjlRnb1D8snPvGJeTKsZDRvVFDz+uuvz17ykpdkz3jGM7Kd4Nd+7dfyWpujiNwRox+Yf/EXf5HX3RyVSiGEEEIIIYQQssM/LL/92789e+tb35o97nGPs/bSj3/849mnPvWp/AflZz/72eyZz3xmHuLzHd/xHdk82dzczAt8vvrVr7bzms1m3p+PfvSjM9+fppJIFSE0flIbYxkippIM0IwsHWE3rlYhbXF7bWwl2kPZETOWqTvY8lUzZVwhKI0vVMb7WaAcCoVt1ZwjjIl092PHSYp2oVxivqvwWaVSKK+ydIir8KUqlq76uCTUwdIx49o7fZPjJDGVSq9W1sSeW+w/Mq4VKm2vVagkw7a4D6B+u2N7Q6VIcC9hG1vIvVCJUsZL2qacPpbKVQTUrlgJEdlu6njKVCXO9kns15bgcI9HqJspZUfkOQipnLKESKzf9vwpYy1lO9pxFI2US4dYRBuy1EyOOP9YJpXLnlEcc1BGZOU2b7qwUoxfvH6xWPdKZz/4G4rlPV8qxibeeWsxXvHz/68oN3LpVdfZbTCWcvlAMQ6ybY5nySimUqlcdcY+dtfWvGmrXTyVx66+2BtbiXGVIz60XjyDnzPjJVFuZLhejO3MNooyJ62t8ThQqXqHxlZSnSSEkJ2nyTGWOidOnMh+/Md/PPu5n/s5b/4b3vCG7Mtf/nL213/919nP//zPZ69//evn/sNy1Ld+v59ddtll3vzR58997nPqNhsbG/k/cMYEIhBCCCGEEEIISaN2JOAf//EfZ9/93d9dmv+iF70oXzZitHw0pnEvcPPNN+ept/h31VXmDTEhhBBCCCGEkO1RLEfjKD/ykY/kYyldRvNGyxDBjr/nydGjR7NWq5Xdd9993vzR52PHivADycg2Owr7cRXLSX5cShtSlVWvjj1JC2MY29X6fogK2Dzil5DIVxXWV2mTxTaundbE98tSFMOsmK4Pi3X3tcLHA/vnigjEgb1VC9OxIT4IABJTF2kDDYUGadvAwitLhsgQH60PoZIosf0tBdpyz0XJRouSBmJb19Zqy4kIi2MWCyMSJVzWcd1l2RH3HsI8WZLE3n8iGMqxwoaeiVgwD7ZoG9tkVVCORtCerpUOCZTH0CyloT4EraORbWNWW2mPlQEsdqqE31TtJxSY437HxM6BRB5zKKAn/9v8NwLrYH/SijvobJS/jxaPe9bsw6Zvx8y2KDGihfZ89kRhW/3SPxU21sV9xffeFdc+wm5z8Egxb2l5f7Eb01dYYGF9xfTUiaLEiFtu5MQ9RZDQwx910LPAYvqgU1zmDuOauUOWGVkrQoSyfvFctbbGIUGl6y+msbIjhBBC5suw0cj/zXufu/6H5Ste8YrsB37gB/KxjE9+8pPtGMvf/d3fzX76p386//z+978/e8ITijpg86TT6WRPetKTsr/927/Nnv/859sfuaPPP/RDP6Rus7i4mP8jhBBCCCGEEDKnH5Y/+7M/m1177bXZb/zGb2R/8Ad/kM+74YYbst/5nd/J/s2/+Tf559EPz5e97GXZTjBSH2+66absa7/2a/NwoVG5kXPnztmU2O3CviU2b5y9kApleaxQuFyWpM6EQnu0QB4oUNhGKpfuZ9lOYJve0viNvVc6QwmfsVP3TYpQ+2TwzopyvtCOLOkh1caYyin7KJVLb51ACJFUA92Hyu4bQSQy2AjHoJRRse3g/CHASDkurCuXyQc8psA2EOLTFNfaVSxDyqW9H3y1c7AwPt5+3y+HIJU3Oz+hwLsWclO1TSsWEpQYfJKyP9lmTLmcRQmPGKH+a0E/dfeXUt7EKqJC/XS/C9GXrf37/XumZe6lxZOKYlnMaywW7pSj7SVfsXReFuLvk/ete+VFTtxThOtcdvUVpX6jnMjmRuETWDt7xvt85uRJr6TI/Xffabe9/Z8+nU+vf/zRYv+PusgrM7Lv0qKvt5hwnxF3m/0dN9NTuG7GRdLcmv9bZ0IIIbOjNxxGnW3btc89UcfyxS9+cf4vxL594xpi8+Zf/+t/nT3wwAPZa17zmuz48eO5cvq+972vFOhDCCGEEEIIIWQHf1iitMf999+fW01drr7ajAnZQUa215D1lRBCCCGEEELIDv+w/MIXvpC99KUvzcN6XIbDYdZoNPJyHxcKrs1MBiYMA+cBdr9+DesZlrt197BFv9XUw1QA6gq6hGpeaoQsj9IK68jt3YDdE9ZRaYnNQZ1HWGADllTXjiotqLKupKxJqYFlWliP/FyymYr9afUy5QMGiy+O85RiwZSWW61d93g9zH0Hm7ENAFLaxjHLds7C+gr7c6wWqryHcP9hfmO8vL+wrzKUKt8k8h0Sela0beqEl8gal3J+KGho1kh7cMq6sQAeiVw3th9ZV1Jae1MCjVCDEm15tUNF+9YCi1qpCyfLVljME6E9qFWJ0J5HOeFx+Pufv3yfZ4VttYv7sWNqX7psdn0LLEJ6EN6DYJ57bv9iPn3ofmPRzS2vR1QL7GXXFCE+n1lf92pWjrjbnBdYYc92i3Wz7jHvvLnn19ZjnSDQihBCyHzp0Qqr85KXvCRrt9vZe9/73uzyyy/Pf0wSQgghhBBCCLlwqf3D8pZbbskTYR/1qEdlFzruG2KoL3aeElahLdeWyakMAvLaMYEoVimCuhQK5nGR62hKZj8QAiSUqmG/CN5wS5AsNHt+yI55s76kKB1WqQyoclAFXTVU6gwhZVIG23hhPWJaCuJxFT7T71DAT1dRAKEKAoRyYGpLsUQU30ycN+wnhlSHoa5m7fEjH1KQu+0iVGRLlh2po3rLe2pEy5SqGRilDfc57gf5DCmBVtATZRCP17WAgpNS0mM7iCmndUKIUkuiaMeC7xCpcmrn0SqImGJb0Ve3H5iH70Esg2KZtQuVbtAcq9ZWAQ0plXBbYL6rXpoQH1leBOqkq1je+8XT+fTOzxeq4523FtOjV1znlRZZPlCUAXFZO2vKi5xGWZEH8un9d9+VT9dXT+TTK68/ZLe5+obDXlmRI5cte6okpigt4v6NZdnaIz3FsmOCftqOyilVTCqXhBCye+ldIIpl9f+hCh7zmMdkJ04U/zElhBBCCCGEEEJqK5ZvfvObs5/8yZ/M3vjGN2aPe9zjsgWhvB08aMaGXGCE1MY6yLf+KWqGfetvCmiPUZSkKnUptt6WGG8HNUuOx3O2h+LVbZhzgfGFUDocJQdvVeS4P1lKZJo3NCllR0JlO9y+ybGOYEkZO7rPbD/oF/OWAmUe3P1g+1WUFzHXH33DOYmNa1XHsYYUVpRCEW1tQSly7w9cZ5SCCJWlwfDJiGIulbxYCR4gnyvtOUtR/EPI9lLevEmFbxaF6bVzEWq/H1EqZTtS3cQWbpt2bKUYA4myN1pZJKiO/aVFf2ztwgP+d8rC+FrYPWIZ7jf53bI8LuWBvy/v+KVEMMVYy4t74+fpM3cWquPxLxfT4bBY9+BFUCoPBsdadtfOeYolyotgjOXDHlHc71dcO/7vHtRLKJYPmVNyx8amWlokn2fUx4c2TR/WrhZjLB+ovN+BvS4zuA8JIYTMht4FoljW/mH5zGc+M59+67d+a3ahh/cQQgghhBBCCJngh+Xf/d3fBZd9+tNFYWhCCCGEEEIIIRcOtX9YfvM3f7P3+ezZs9k73/nO7Hd/93fzUB/Wj9SRAQuu9SxkZcNnrSyDDPCYCGlf1AJ/YEeD9RFhPv0j/jauFRaWNjOv1zzllcCAxbOnHANCbWJlP4ANAxLtSPssQm8866hZBkMnAnlWjFVVs7uiD42AtQAmVzeAqLfZ96ywbWOuRJkE7fikdUEeJ47LDfGBnbUrzpO0FMOu67aH4CC7HwQlmfAlG+KT71xYYFvm+m8e0W2MsFDPCBlQUqc8B9Ds6iH7akoAUB3ra1W/Y3baUDgLeqSVAdGCdrz9we7qzOsH7NrWPovlLacf0sYKKyzuDw18l8iQnrb4vHKb3eSiThFec/3iPjWs53pjib3/jvF9es+XipIhJ+8rAnCWlovyH22UQNHCxGCBNWVGzpx8MJ+eeuD+fHro4uIcHLlsX8kKe+zqwgJ7el/xHN1igndu29gIhvdYW+zatb4FdqsRLc3jEgtkIoQQsrP0nSFH89znvJn418mHP/zh7KabbspLjvzKr/xK9i3f8i3Zxz72sdn2jhBCCCGEEELI+aVYHj9+PHvHO96Rve1tb8vOnDmTfdd3fVe2sbGRvec978nTYi80XFWhSrWQ5RJS1pW4qgP2hxIAWXPBi/WPlhmRQTxQDgAUBBcZ1hIrKyEU0K1BcZstNQdqOI1W5kMG5mhhOjawxpwLqJ02ZCeg3rl/2/2K+djWfbuEZY1eMW02TTDPwO8z5nvzWv66Bxb8ICD3XKya47Fqo1RvFQUWx4Ft5ecMSrDTjiyFEgr8ObHwkP17KO8rqXZjasNbVkv3HUpOpCgsISVSBshozwzm1HECVCmgKcqo7AvKQsTWLYXqOG1It0OwTwkuBqvWCnXTVSmrFEurVLrfCVJldEuEVJU/wjK0h3vGKJVQKd2QHiiTUrFEaM9n7ylUwhHHTXjP+mpx/vZd5h8fyt6srRbrjeieO+eF9WC6sV6onw97xBEvoOeK68aK5fqB4jx9br34Lr7FTD9nSoWc6BXfKncYBdML7Vk/5imWKC+i3QPyfphFaBQhhJDtoXeBhPckK5bPe97zshtuuCH71Kc+lb3lLW/J7rnnnuzXf/3Xt7d3hBBCCCGEEELOH8Xyr/7qr7If/uEfzl72spdlX/VVX7W9vSKEEEIIIYQQcv79sPz7v//73AL7pCc9KXv0ox+dfe/3fm/2ohe9aHt7t4eA3Q32up6xZqVY51LqVcrlMD1ZixSstkNhNfNsrrCumaCVzNjV5DaaTQ11MqXV0XYo0oaxS3ZNiI9aB1KEzABYOhEsc8rYyNx2emIdKf0fbrdLN7sNwpF2WTOVllINaW/VQGhPbwv1Rofetp2l4rod7ox71zbXFMcjbcKY4rjy48G6wvJqbcfiuDXaTnsu7jU5K2tbwgorrz9CW1y3qbnPgvUrawSUNBPCbkI1MFMsg6Fnsc7zrK1r684GrkPKd0FomVpfMrAf2w+lzVDtS9SqVIN5pAU2VJsyVEtX2eaipTNebcr8b2PTlZZYTB80tSrPnBzbZ8+cLCynK4cPF82b7+ae+c7umfvulKlN6Yb1nLj3nny6b3/mhfQgoOfqRxZt7rt0XANThvXAAnubsMKinmXO2nXFdENaYU97/11xbdX4W97Pk9RQJoQQsr30aIX1+fqv//rsd37nd7J77703+4//8T9m73rXu7IrrrgiGwwG2Qc+8IE8HZYQQgghhBBCyIVH7XIj+/fvz1760pfm/2699dZcxXzTm96UvepVr8q+7du+LfvzP//z7EIEb43xZhlT+fYfwRjuW2WElwyhuAnlwa7rhGpUqZtZv1V6mz3IUPoB6oEoBdGKqAohRUpbrgX6jAQpfG6vVapnUp1DMI/79mXFnAOodfgMhQ/tI8pflvhw10V4jn0gjHrnBtzYYJ9O0c662e8+E8TTPRcOkrZBP1AsRcDPsDe+Tm2zzB6fKAdi1dTImyj0RAs9kljl17SH/eKcq0gFKqZEiXtSRlhNEogjS/TE2qizDpCOgxSVc7uUolDwV+i7RftukOdAfre4ShjasSE+CAST11grQyPvh5ByKf8efb2Z8jZHzbN3ZWfJUymLecV3yzEol+bzulEloU66LoK2eT7xuFiF8sQDXmjP8S/fYbfZWC/Cey69spAqr7y+UCaPXrHsKZYXm/Cej5mwHzeUB1N8/xw3SiUUy/X1S8YHj3I9636ZEemEYUAPIYTsTXpULKsZhfn80i/9Unb33XfntSwJIYQQQgghhFx41FYsNVqtVvb85z8//3ch4RVYx3iXSGkBuY3d1ryF7leMs3K3DZZZsKqQNsZK7DugLKqUFMvA/Ni25q08lMt2o1xuJPRZluBwx/5BiYRKZz8L1dOW3nDaF5ptCa1ECZRDe3hGhYRKgs/uPKmeYIxlb9Ooj53xdVpqm3GXYr+rEdURxw71FuVSVmPHI+aFyo20FVVprD6v+uPuZAkbWcrGwd7DGO8H9cxZRyo2csygdApo6twkKo98BgeRN3GhZ15TDqtURzn20V0n9MzL45xW07LfM0tN/fsB5UCWihIcqmKJ+wHzzbThlK6BMmmfxWbHU8yPmeVQJ92/sS2e9dVThWK4dra4D7prY/cAnkeokM1myxtrCaVy/8HxmbvkYYfy6aVXrnhjKVFe5JBRLj9hlEq3dIgcW3m3uT+gVJ5dO1qsuHb1+PzhbzO2csG0i3IjsuxIDHt/UN0khJBdQ384fwXR+d/RvaFYEkIIIYQQQggh/GFJCCGEEEIIIWTnrbCkbMmTliXYk+qEgIRsclqZgFJZgVa/bI2VJUIkWtkRWBul5RXlR+z+nLZD1lqUpkD5kcbYFtdG8I7cRNhP285x2jAbaZs1Uy2sR7Zbmsrl7jaBQJytjZ5aWkT+PaKz6PdJLnftsgjV6Qp7a6YclwzekXZhBPG4FmOE/3QDxw7ckCWsa62woWsdKWEjS4aklBmxds/A/Kp57vygjTyyjey7tN/WaUNDlk3RnnVQCvWKnKNQuRGJWm4E3xewvuJawwLrWmFlCRKE9WAdY4V1n0nYWnF/4f62Vlhhe3X/RmjPgUGxzUPG+rppnsXuufG12dwozgtO6erpU15JkYsvL0qVXHplYXMdsXygaP/o5YXl9YrrijIjC5cU635mfd2zu2I64g5jfcUUZUVKFljFCtvsFn1odx9ULbBe6JsoQZISUkUIIWRn6In/p5zXPucNFUtCCCGEEEIIIVNBxXJG4C2xjIUPlUVAOQN3XVlWJKRI5NuY6RDzpDJhFYQEFRKKhFzuIpUpqI92XaNQuMhADxHiM3Ta7DYCJUiEeua9fZFqJnZrlA/M1wZLl5RQuQ1KcDgKn2ynYT7L8B5XhdzsFj1umxIlWAfhPVrIjy1JYsQdWT4FSqNXekUcuz0eHKdRetxtoPTinMpQIo1g2ZKWHtZi75OQil4TqDMh1U5bVlJINfVxBiqPdCPUiU4pfQd4C/2e11KmzLZSncWxx0qTjNsQKqScuuvguhul8qJOV6iQSyX1EUol7s3DIpjHC+8RZYCg7mOqPU/LKwteoE9nCeE9hfp45SOKoJ6jVxSlRfI+LS945UagVN4SUCpvUxRLuATO9pp+SRER1ON+N4b+OyLnE0II2Vv0WG6EEEIIIYQQQgiphj8sCSGEEEIIIYRMBa2wM0ba1Fo1QjRkAFA/YrVrwHq1f79udevtK/5oF9atYqVO3Iq4eLJshcXfIVurGuazGq9xKUJ83DCY3nBLt38qsj7WKdVdRA1Hc75gB11ya2BiinnmesGWp9lCYY+VwNbq1q8E1h672Q+G9YS2QbvS3qqB83TK1MqztkJR09MFVj17fKLeZ8p+S7VQpRUWU6+25aFowJV7hhq4r4UFcJqAkjrPosTdb1UfbF3JyP5Ctla1BqYJrKlqS+tDvyKwSA3vaa75tnpYX1urYSusmQcL7JWmz7CzurZW3JvyOcZ8u60T3iMDfbrnet5zhc+wsroWV1hhl5aLbQ8eWfLsrq4VduVQYX29+GHFvI+trnqhPahVifqVsL+69Spt3dxNE9qzfsz/3nNrvBpbbLu7llyLtRTyRpssIYTsWnq0whJCCCGEEEIIIdVQsZwRVeEKeKssQxli60rFI6W0gu2HmfYzo1zGQkagZIYURm2ZVDLdkBaLUTRkaQptXdPecFAs6y2MS5GkvnUJKWur5lwg8ENT7aCA2CAbsz8E5bh9wHTB7E+G9yCwR2Oz6yuXzWbRRtOUTfDmYWoECamIrrTHKpOrxrr9X8F8R/UJnS9b1sScJ5wvV72Forva2PIDmDCFuiUVzOA9Mr6/tQCdkCoYC+9JLekRay/4XCnPd0gFTAnImUZ5TSmXUgX66KqqfaiKrUC5EXx2r61ZttAuFLfD7Y6nOqI8iKtYyucR9yPmY1u33AjUTAT8nN3oqk6AlUPj7ysolFgH4T0HjxSq5JHLipIiRy8fK5atQ0U/P3HunKdQ3o1SIvhs7geolK5SeXZzyQ/p2TLhPRtHSuE9rW68XJV2v0QDnwghhOwqelQsCSGEEEIIIYSQaqhYzhiUQwiqFsobaak8yLEzMXUzhBzj6bZn1QmUf4DKpClLUoGSyiXWleVI3GWI2ZcqlruNKIEyHELZ0MuB5M0LhQMq3eGK0iL5NhjfFVhX+yzbWWr7SgiUytg4yt6WOedC+OosjXuC0gla+RJ3Ocqd5H+bdY52/LIiUBjbKHPjjjPFcYjxrDifKEcSRV7TgCrprdvSz4FU9bVl8h5u4tlxnrtQ6ZCYwhN6BuU2KdumENrfJNjnOTKWU5630vl0x29iXLYcJ9sKj5+1SqVpDyojpnJspLuuHMuL+w/buMomthn29Gdi+UCxTXuhFXyexmMsF72xlueWx/v53NqaN6YSSiWUS0xL4ynd8iKyrAimGI/ujEtvbW14//3AM5BSXmSS/z4QQgiZL/0dUCxH+5w3VCwJIYQQQgghhEwFf1gSQgghhBBCCJkKWmFnhCwVgqm1nAXCGDQaCeUQZDvSgivLDHjrms+DkIPPtbti5a0VP9DDLlcssABx+tIuq4X4uEEgDjYwB5+dZSsBq6YNrkkpl2GAHRS2O63Uhi2LIPqGsiBAfvaXGdvuua2gFVYG/SC0x5YfMda+odM3BP2ESq/A+uuWGJHHk1JeBO1jHZSJGXdEXGO3pIKwUdcJ4AkG4Zj7vI4dsFSmQSFkgXX3I0O1Qu2l2GelNXWSfsfaQCAPluEzpl5JlAVRTgTPJsoRmfn7FsaljI62/XIiV6K8iLDEurZWaXWV9x9sry6wazfNOp3FYp2Vw4vqM+KCZwTrwgp7r7GzfsbYX0d8zpRzguX1uPk+lyE+eJ7G1n3HArsuLLD4vjPfpQjs0SywbbN/+b0eC14KWcDd+4FBP4QQsjP0xP/Dzmuf84aKJSGEEEIIIYSQqaBiOWNKb5qXTOS8wFM+QmVGxHy1ALoIPImFglSGjGgBPbKsCJqDcimXu/QDKqds2/1b9KHbOOcFk7hqWihoR06jyptoVwbYaOpdW7Qhy4B4+xHBO81m31NWoKK4yPZsG1v+cpRNcNtrt5ueAovz1jX3gabAyrCeUpiPc99YtdaoPFu47rh+CGqqgQ2QkeUuEsp/4Dlzl1epMilhOzYcSM5X2pHteepf4r5LwVpT4LYh+9gz30dW7UJoDwJ7tHAeKJdmurB0fz49tjB+fq1CCcUSZUYWF4NBPFqgjxY81VOWobdLK0Ubh839jzIj7jO0udH31M3Fw8U6dwkV8g5HHZTKJMqKQLl8SJYScb/LoFRuYHrEX8d8LyKwR3O6hO73SaBKSQghO0+P5UYIIYQQQgghhJBq+MOSEEIIIYQQQshU0Ao7I2zdyJClybH3pVrepCVWCygZival7cndS8lq2HDsby5u4IpF1qvUw3Y8YP1CaAUsdUCreSgstRDxu9k5z55Z9L9slXNBncau2Uaz1MnalDHbgAwXQV/WYWs1wTzuQwVLHmroYRpDrgObK8J8YO1zbbawxS41/b7BAiuPWzsOWF5XzLkwRj51e5zTbtNYYkMH49qgsVIf1u7qGn1Vz1msNmUWeG5iVthQOJC2PLV+ZWybRo3AleAximAjryZl4PsG6wwWhn5gj1ZnFlPz/MqAnvxv0x6WXSM+yxAfd9kB0zfcDfKZ1GrXlkKq2uZeNqE97vfE4YEJKjLPEeytsLXeASusmbrLMEW9SkyzrgnoOWemQ+ecd4UFVthlm1vm+8KtvRqwwMbAfS2fAda1JISQ3UePVlhCCCGEEEIIIaQaKpYzRr5xTimpULVOMxLEE1Iz1DYRSAIl1H3Lns9QlEptXt4Igiiy5NIhpZIlmjIqVRKzf7xz6TXGJQGq1EcocqvmHNhAm9EyhJmIEiUoH4CQEVf5kG9+GiK8ByUOBk4gD5ZBZYTqaPthttns9kqPpW1PlBuRU28/pn2EmrRxLsx6bnjKakDZsEqmmLrnQ6q3W7hPcI0j5WhCioos2RNTYUL3u9w+VqpE248E6j621EKCZLv2+UpwJdQpUZK6bcqx2761ThfTBcdNAGcB5pnPBzpFMNnRth/I46qXIeUSUzcIqmEU9+56ce+3O+aZ6/ilcaxK6DoLxGd5f2r3bHdjoKqPCOrB1FM1xbpb3Uv9kCoElEGVdJeZEJ/m5qJQ27vJ919InUwKnqJySQghu4b+DiiWo33OGyqWhBBCCCGEEEKmgorlNlEaMyPUi1i5kSo10qVUoiRStB3rjMdlivcK65eUSw9YVXNTV6SgarjKphw7aVVI81k7HGwvp4Le0JQfcVRGjIPrKqVB8sMx8+36btkMMw+qpizOHitvIsuCyPGU7t8YD4kpyoxoYy7H5UTanjIplVGtVAnab28a5dWUH+kp6lbwHIj52thUqVhOQqikQp1xZlZ5U9RB+QykuAcmcRpUKZNaGyEFsc74T6lMDSLbQHm14y9b+A4w7oJFR7FcPF5M95np8p3eOElZWsQdO4nnBus8ypQ3Ga4Wd9G57lilk/f+0nLRxoK5v6FGQrl0lUPcq7g3l8QzjuXaPbsq2r1DUSyxDNOzsrwIVEl8dhVLM7YSSuXCuXOq+p5yH8p165TViY3XJYQQMl96HGNJCCGEEEIIIYRUwx+WhBBCCCGEEEKmglbYGQOrUbvb9e14xhIG26YWqhNqS8OWDBGkBIdYS9aWtNZpOzLrNDq+rdUG7xwpl5Wwndn0rbEI9dHWlaVJZBuGYX+//btrgnzaCOcQ1lhp04zd7DIMxIaEOOcR7Y+tBQ1hc+2XLLII08E6+GztrAPf5upaX7ENSolItPAe2AvR/lKnuE+WlONBkI8WVOSek1pWimHEymyupbVwYnaCNbBk+xQlNbxgq0BoScxqG7SZ4jOeGWWdqhCdlOOSdl33+ZUhLPLZtjbXyDNfKi/SWvWnbuAWbLFLhRX2QLvY/0prQbW9uvOuWVz0plsPFdf8zMni+1C1bZt7FdNlLFdsrTJ4R96b+Hy3E4xzyqwrvw+wLgJ6UFok36c55+tb+4oZZx7jW2AxxdAA1woryumkWGDlvVkVVpWyDPeDDLMihBAyf3qR8njbuc95Q8WSEEIIIYQQQshUULGcMTYW3sTVh9SG1gSFsDUVox9QS7C8pxRLlyE+UcUFQT5QMaBEyVIhrrIoS0zIz1C1QmVJXLA/UX5EBvnElDbc5FrQDNZxyxO4bbiBPyuyfaO4TENvc1BSH9vmfY9sX4b4aME/tl2z7VJA0dECeEpTs55XpkUUqLft4fo0RLkY99pbday4pwadQtXKzLPSgGoXKZMgl2glFaT6E7q/teeppELiWYGS6GwfalfO19YLqYuqCho4H1aFFNu4bVs1E0olSong2RPqpPv3QudUPj1slEqrcCOgx/lusUqlmXdxr7hP7jdKZXeteGo6i61SWM/SctH+gYsLV8ftJkTnDnNfuOojgnasYinOCdRJbJvvW5w/+T2AgJ4Htpz5vUPFdO1qPawHzgqUG3EIKZNVqqQ2r3QP11AfWW6EEEJ2Dz2G9xBCCCGEEEIIIdXwhyUhhBBCCCGEkKmgFXabCAUmxOxPsp5lzDZnbVWBAJGq2npRbO1Kx75oOyvDe7JyfUvUxpPIQBc3qMdaKAMWW8VaORwWFrqeOXN1bK1tBPwEgmxsiI9iA20LayqmqDvpWlibG32v5iTsf/aUtIalmpQ22AfW10G19bXdaQVrW7rHrtki5HHB6rhizgGCTPL+V9WvxLWHRdCzwm566wzsfabXLM03MVNpK4zV95ukRmWVNRXWdRkalMIkz2Kd+pnBWpVe3cqzft1ZWGD33enVqsxn7Xsgn1650PHqVUq7K6ZuvcrLGkVf1s7533/2/t8/Dh2DLXblcMezt8L6irqSt6wVIV3uMhuuZe5nWb/SrX2Jv0OWoK3Nw77dtThx/ncUlsn5sq6vYnW1wUzmc6nGcY2AnZTgKdaqJISQ3UePVlhCCCGEEEIIIaQaKpbbhFRS8EYaoT6xN84y+EcL9LBvpY2aUBVUMjF4Qy/VRqhPUKRclRNv8bWyIlr5kbydiv0p4T22ueF6NIRGqhvuPJTYwLpQ66DMuSU4ZFmOgVEm3VIhxeexwlcqM9JpegqOnTrhPXJbrCNLibjbSKVSa889zhzxJgvHZY8zpEpqgUi4PrakzKpePsZd16jUg4WwcmnL94hnok7pENmW7YajxEpVUa5bJ4BHEtuPLDOiEVImQ7jLbWgPlGQolQjxUcJ7UEYESuX1RqmEKimVS1epPHNyw7tXcQ9ravvygaL9rXZxDx3f2PQCem4T0xF3m/sACmVXqOr4DDeDF8Qj70UE8eD7yv0OCymWcGpsCAUTZZny7/oNteSUvD5tZ36V8q4F/oTCgRjaQwghu49+Nn/FcrTPeUPFkhBCCCGEEELIVFCxnDGpb43rKIvaupgnx2fa5RFVIzQ+c9xWq3yH4E29LP+BqasGWCVSKJZSjVTUR1XNdOfL0iWRIumhaXHwftkM2/WAcukuw7RvlMpNM47S7t8ZY9k9V4wb29ww5RG2/Hc5UB9j4yelqqmVOeksDr11umsY92nGsbXKKiSUKRwPxqetChXXOzZ5vuwfq8HrUwmUy+a+4NsuWf4jNo4MCh/aSSlQ35xiPGTVsxz7JtBKhITalOqm3BbjKT1Fs/OAryDj+kCxNNOF5rhwx4oZ53y03Vanx8TnEWtnt3yV3dyHVl039/DKofEzv9FpeCqkVCgx/7gz/vC4GYd5tmfOV++APgYy5XsnNG5S/u1+hlK5aVRQZYykdZyYKZaljIW096rYliokIYTsbXocY0kIIYQQQgghhFTDH5aEEEIIIYQQQqaCVthtAlamkGXPtUVZ654I6wGxYB7bvtgGFqp+pB1rrxLBKD0T0pH3BYEWthYKrGbC8uiWH0m9q1T7rFgmQ2EUq2U7VF4ExxOxN5ZKkxjbQMwGaq2wIqxHBvW482CJtSVEjI0WYT5uAJAM3uksFie0nfnr9hbG9jhYDoFdZ9OUVVlulUqulI5PnDcNG5pSZa9AuRH3Gks7td2xscAq+5WlGgawcSslQ6ossdgWpUPUbWtYYUNlguRzqoZuiT7GtpHryBCfUpmRzulxQ3huEN7TEWE9ZgpbdMwCe9hMrU3cOVcbolwG7seDR5Y8K+zG8nib20y4zR3m+wdlRT6zvu7NR4mREWfXjhZ/rF3tB+/gfotZYeVnaXd1v8PcIB9n3Wa3sN42N4u+g9i92zDHqZUZkdvLaelQnHPeEPZwQgghu5ee8/9Z89znvKFiSQghhBBCCCFkKqhYbhN44xwqfJ0SEhJSKuoUw3b3L9uzxd9FuITbZtME+YxLQshOJhSMD5UOiQH1AIpLLPAnKxSO0JsaO1VUNqiPttC6ePvvqjJYp2GmMnAHSqUb5jOAaorAHXM5sC3W1QJ5bLCPUR+Xlv1AJlcZBVCGZHsHW0WJiJXF8fGgRIPdX6ajlVw5hVIuOKfy+mjXWKpAoNX3QqOsEhNRKnHkTeWerXIJoE1tWehzX3s2UNoiEMqilgWpCOnRwnysEonPZhna7+03+2mdLZUOKZUXMcsa+7/olRS5slPcH145ETO90uxfhvbsc1T9dVtepO+FRnUWi2lrf7HNPxtVUgvrucUolZ8zCh/Ce7ZWrxsfzzkolUf0IB5Mp/0+smVEOl5YT7u7VlmOpqSym/PXNMcVI1R2RKrvhBBC9ha9PRDe89a3vjX/d8cdd+Sfv/qrvzp7zWtekz3nOc9JboP/nSKEEEIIIYSQC5grr7wye9Ob3pR98pOfzD7xiU9k3/It35J9x3d8R/ZP//RPyW1QsSSEEEIIIYSQC5jnPe953udf/MVfzBXMj33sY7l6mQJ/WG4TsDItnDuXT9cvvriy5l2VPdZdLsMd8BmWPW2b0L6lZc+1z/bkNqbmYNYSdSxTwjJsZ5VtZXgP2o+1bba3IT1G8peBPLjJU4JrYjZQLdAn74apEQl7qxvE4/6thusYy6prXUUYUGep7dlbx/vz61p688y6sj4m2l82FsUROOP2/Ik+qvU/Q8ukBRb3iXfQHT9wBdbYvgiTiiDt2tbOnRDiI9fRAnKq9us+K7IuZihkKxbeA9CuZnuXfYO10lpkYYGF7XWfa4U97i9bvtOzs15j2oDd1Z0np7DNIugHgVTu/YxnARZYWGK/Yr5TEMjjWl4xRZjP7V1zH5y50Q/qyXd6TA/tQX1JEwQVxVivo+D+jQRLeasnWLFD9VUnxd4jgeEWhBBCdg/9HbDCjvY54syZM978xcXF/F90234/+5M/+ZPs3Llz2Td8wzck75NWWEIIIYQQQgg5D7nqqquyQ4cO2X8333xzcN1Pf/rT2crKSv7D8wd+4Aeyd7/73dljHvOY5H1Rsdwm8Da6bd7Cx0qGhMqMpBAKDtGUDy0YRGtjEHuDD0UKoRaa+hiK8weyhIi2H4A2ZIiP/NtR3qAsQrmEUum+KZKBPu2AKinVzxHDhq4OYqqF6kgFsTkwZUc2oHI6iiWUT6E2htTJ2H5kKRS3rba5DeQbNBtklKBY1gpkkgilEiV6XHUI8wDuXTfgRwbyVIX3lFR4h1AoiywJpK0j15WhO7H2pSLqbhv6XhgsDH11H88IgnpG7L/TC+3Zt1AE5Bxt+yqkp1givMfMOxooM7LVGp+L5QML3v230SnuzXt7W15AD0qJjPiECfKBUol1sjOPN1PzH7J1o1K6iqVRKptbDe+8trbG4UCpYWh6YE7R7rDllwiR6jfmu/dFKIAnRmhdrf3QNvb+M59THACEEELO//Ceu+66Kzt48KCdH1Mrb7jhhuyWW27JTp8+nf3pn/5pdtNNN2Uf+tCHkn9c8oclIYQQQgghhJyHHDx40PthGaPT6WTXX399/veTnvSk7OMf/3j2n//zf85++7d/O2l7WmEJIYQQQgghhHiMyuZtwFGUABXLbQI2pI6xe8ESu7V/v7dc26Zk+4MdKmLhm6Rvap29ioChYDBPSi04iWuVhY0Przp6gTqWEUr2VnP+1PqVchszlUFAbuDPiqh5CUsqgku0oB4ZtAMrqg07UeysWKez5LchrbGurXUJ4TwHOmqftD62TbvS/ovPssanPB/eMlnHcqjcF9I23SrWaZi+S0tsvsoEwSSh+1c+cTFbq7QzwvqYEvgTDehC8I6wZcrwHq3tUoBQY90/n6JWpW6BbXsWWHzG1P37sJnC+oo1UMcVwTz5PPP3cYT0rG/6nxUrLP6+61zxnZid+VozfYwf2oOgnvzroOFZXqVVVBtyEKoBKa3KWgBPqIZwaL917lltf8H6mAltVlnAY+sQQgjZXnp7oI7lq1/96rxm5dVXX52dPXs2+8M//MPsgx/8YPb+978/uQ3+sCSEEEIIIYSQC5j7778/+77v+77s3nvvzUN+brzxxvxH5bd927clt8EfltsM1BcollKZiL2llm/YhxO8UW9ElI+UN9zjmRWKYUxRxLZaCQqpXmphQC7K/OGwOKfdQaE7rohjhuLiBvHIee0K5dJtF0oeNAQoijLEJ1+GIJd+Tw3msYfvqI9QMaUCKpVKrazJ0rKvQkdVzqUF/VzIc+KGHoUCfTaPxAObXBA2M8C1bFcGodQhqrgrQSzatnhuYupT8JmLlB8JlSKRSqZGf8ks6zxQTBeMQrmwGlQsoVTi2qJUiFUlzWdM3fsc2+DzRQg/MvfQ0LnPrTJpvu8QyIPPdr5jp7kbyvRDTy2mZ41Sea5QKlvnlkvXoN1dV0PR5Ll23RgIeip9z5p2sa6mYMs58vrJcCntGsp7KBbIY7/PEegm7tWUsSuyXaqUhBCy8/Qipe22c591eNvb3jb1PjnGkhBCCCGEEELIVFCx3CbG8fdbyeNubNmRUJvOm/BgVL5RPvoBJTO2X9BTyiSgNER5fsdXTVxaq7raGStRUqdsRcW6UnmLriPGGdpxmlq5kZ5ewgNTt9xIb6v4e3OjmK6d3fLmQ2nEcnf7jt1m01NGNbCsu1a0v7RfP2p3XNyyVKhCyqVyDkrzcP2c8XAl5Dr2vhjUHk+mjW0LkfIMhNYpleKpURIoZb+y3d6SGVjr0sKzDYXSTBdPqkplY/E+uynKisixlHIcpXs98bctN2Pm46q0O/54Svfvu4VC+TmhXFqVcnR+zj2i+GP9aq+USLN7oDi8s6eKz842chyu/H6F+ujeFyGHhpyvloKqGJ+rlYoK7S92z4aUSr75JYSQ84PeHhhjOQv43y1CCCGEEEIIIVPBH5aEEEIIIYQQQqaCVthtBrYnhE3YUh8Rm5y0xGoWrZDNTob2xCxheKsgrWCa3S8U5z9AEEsMhPakrGt3KNbVrLJiHVkeQ9pZNbufZvOsshHI8JxBfxAM5oGtFVOsi8+avVVaamFfRSiQDAty+9JdK4yLZ052vTCflcwvQ+Jiy0ng/EWOvZL+SjjMBxbY3j7PvhgqtZASSBILQgGwFU6CfBa0526agCFYX2Xpi6w9LsthbebSAotSPLCcm88rTh9heb3SWERRZuRKs79jZrm7jbSQn+r1PLsrgq1OmPkj7g6UFUFYD5afXb1ifFyr13sW2Gz9kmK/3TXV7ur+Xbr+SogOaJjvXiAt1/hudm3IMmTN3l9KSRxvufO9Hbon7Xenuz3+MH2SVls5VctSiXZjzwQhhJD50h/O35qq/C/ftkPFkhBCCCGEEELIVFCx3Gbw1rgUj+8oIbHi3iFk/HyKaiLbD23jKgShgAur5CC8B+pJvrDjh7O4y9zlbokSqVCmbCNKnPSahdKBN0IIH5nkgZAqnv+3r0xCWeye63kBOiNWT2968+y6RlnUFMTNrixNYtQKhOuYYJ7OYvk+QbsA7UPddEOCoIy2xeslKFKriuJhg13MsuHWRaaxFX8KFcpVLI2aKQNXpKofC7qSoVhyvkYr8Fy5amTVsxcq6xNDcwBIpRLK2GAB94FyHHg2FkU5ETwjcqpcL9zPUCYR2ITwHrdEj/yPAp6jU+YcQcF0FUsolbKsCMJ7bFDPGVNSZMTZQrFsnn54Pl04d9ZMz+XTztpa6dpWhaDZ+0OZF7rGMRUaz17V/lxC38mx7+xQqRqJey/hviaEELL76Q2HWYvhPXuLa665Jms0Gt6/N73pTTvdLUIIIYQQQgg5rznvFMtf+IVfyL7/+7/ffj5woIiuJ4QQQgghhBCyPZx3PyxHPySPHTM2vF2EtPnVsdRpyGCGqtppsRp8chvXpmstYSbsw7aB2noIaymcb3pNS9hlEd6Dzxqwt8JCCXufFt4j7LFbZlmvOagO4BEBP5hay6CY5n+bc7y+tanXr9zoebUqR6ye3vAssFgXtSlhd3WDeGSgzzgsyL9O7jags9T2LLCyj6pNFmFAgXPjWophge0F7Mil64cQn9Hl7/qWb2lrXTx7thSMsrV/f1JYVZ1lsWcvVOswtg2WwdYqcefjOcI8u6yxXl2bFcvwTKB+pZkuLN2fTw+3xvvDNZUhVbiOsLV2nft81fwN66udj23MfK2OpZxaC+ypJxTTc6Zm5YgzN3gWWFx/WGFTLNH21IhwHfdZkZZreQ3keu66Q9GHUMCZe3+khFGFjidkn9Xqc8qgH0IIIbuXHq2we5OR9fXiiy/OnvjEJ2a//Mu/nPWccUAaGxsb2ZkzZ7x/hBBCCCGEEEIuUMXyh3/4h7Ov+ZqvyY4cOZJ95CMfyV796ldn9957b/Zrv/ZrwW1uvvnm7HWve9229UnG4du35lpJDzPFshRlpSp0xFV/EEffq1BL3TfgpTflCBlBiQMolpjmyzZ9hQUhPnjZjs8oQ+KuWz4AX6XRFEux7ZJRZ6zqiONOeHOzJEJNDjvnamu9J8qByM/FAa6e2giWG5EKIqbNZqOkWMpwIKzT2/LDgrSQHoksjeIiz4ss2wJ1y/07+S1Y373X4sqKDDeJLgsoSS6yFIncu7sf+cylhKfYdsW28rNbxsKug+cISiVUftzn7rOBZYvHVaWysXhfPj22YEqIOEoc7mOpWNpgJvPiDfe9plTjmluVEyE+zjlCkA/Cex5aO+qH9aC0yNpYsUQ4DxRK+R2pgXVCKp0NglLKj8h7JKROe+qlmcryI7Y/gXvLXTd0PO4xpDpQ3P3bewnKP8N8CCFk19ITwXLz2ue82fWK5ate9apSII/897nPfS5f95WvfGX29Kc/PbvxxhuzH/iBH8h+9Vd/Nfv1X//1XJUMMfrxefr0afvvrrvumuPREUIIIYQQQsjeZ9crlj/+4z+eveQlL4muc91116nzn/KUp+RW2DvuuCO74YZiPI9kcXEx/7fdyHE+GiGl0iov7nzxhrv0xlwZ75WqciYBtRCKFMZcautYxOfOalixhGJTVYbE3aRhCp43FtSSIa4qI4GqCbUTU1/pEeVFTGkP+XltdaymlRXKvlpmxB0DOej64yOhXEKxhKLpbtPuNNX9dZZa3jbNVrPyzVbsfGEdq1jKMjDymjv3xXDQij4LGPvWq7r3nWclptJohejd+THQF7k/bZ5UKoPjKEe0xVjKVmDcpHufQ6ncd1wtN3LUqJJQKvHZVdxxP4dw1cdV8zdUTTu2UpQZccvR4G+UHbEKJRTLs9d64yhdpVKOP5f3h6vmVX2HaeMycV3k/WbL0CjjMkNja+244Mh3aKmsjbiXhsp4SqvWYtuAgimVeq1cFcdcEkLI7qM/HM59zONon/Nm1/+wvOSSS/J/k3DLLbfktf8uvfTSmfeLEEIIIYQQQsge+WGZykc/+tHsH/7hH7JnPOMZeTLs6POP/diPZd/zPd+TXXSRKeJOCCGEEEIIIWTmnDc/LEd21ne9613Za1/72nxM5bXXXpv/sByNu9wNwKaEwIrNgwfLwSQiCCIWNhEM6zFtyGARbR1pmNLsZcm2WTdsxB6YsEXC/ienLrAAwiIYa9Os22gZS13A7mftrc65KNlkzRQ2Qrl8BAwFNjzHWF9RUgShPa5F1Yb3mFIkbkiPa4ld64bts7CxIphnHO7j2GdFeREEC8EKO16vvE3XfAu4IT3yfEmb5FZv2XR2xZ/Ka+qE9zQ3u0nBOO5era1PCWOJlX9w25H3sHZPYz/9gOU2ZnkMWWCjz4y0wMop7K+uBRZhPQsPefbtwy0/aMoNnEKAlXw2QuVHtHAeTGGBldMR6xuHij/OfK1fXsSE9chSIpr1NWSBde8XaXVFr6exf9qAM8eyKu+DrOJeci3Z1lobsEpjXe37XNpy5T0cPQ5aYAkhZNfSGw6z5gVQbuS8+WE5SoP92Mc+ttPdIIQQQgghhJALjvPmh+VuB2+TEVThvYGG4hFQR+oUaU95Zx0KoFBDLkp9Crz90NTHfkdXH0PBPBoyFMbdxgagjFWQ2Bsb7WaHcoMpSizI5SPWhZJo2xchO24wD5RKKJfBPjpt9nvFPhsNU65ic0uUG/HLm+T9XGj5yzZkmRO/3Ikb+NMd9FTFUu0nzg8Uys0jUXVaK6kQUl/sfeiGnQTKS1iVMBLIZJeJ8JTYurJvtgQQpq6qJZRJlBWx+7XBRU6bsqyInCK8Z9FMlbIiUCqhRkp13b1n5TxcP6iQeCa00iEhpfK4UQ2HZx897iNCes5d7SmVnbMbakBPfjxCuasqJeJitwnMj5VxCt1/njKKbTBPhjmhbcUZ0pDb4LjQtjkH2nGGSu7Ic6UdhywNRQWTEEJ2D70LRLHc9eVGCCGEEEIIIYTsbvjDkhBCCCGEEELIVNAKOydgT0J4hWsJC4V9lOqhRYJ4pC3Kfo5YBUv2KoSPTFLf0rVChoJ3UqyvAFZLGQrktiFqWkLyD0n/bn3E4DpmPkJqus65kKE6IXsrQnbcv3ubvi0NVlVpox3RN5bDdsfUINy/4FlssV93PwjrgV12abntBf0ANzzIWmt7oqZmxA5s/7Z1TAN1LM00Zt1LwYZRGTshnglpb4zZ/kLruM9T1bMXCwmSVs6BscTaexf215gFNjR1/oYFFgFTsMLagJ4E6wvszrB847MbxGPrVwor7ANb5tqvPtq3v7p1K40Ftn2u+H5bOLfqfe9pNSmlNTRmiQ1+z4nP7rYhO6tdHvmOtH0yVl5bk1Rso/UV28hwJ3svudbbCZ4NQgghe4cerbCEEEIIIYQQQkg1VCznjH0775ZPWDalGyqi7b238IE35qH52rLKEiJKX5BH0l9CMI+ZMXTUAKhYthNCdcS6UCVdhaYUAiM6IpePmhsWKsJC09Uk48gyI1p5EXf+iH4pPKfnlwURpURipUOk+ui+VGqYffY2fRUD26BkiKtYoqyIDRAyU6yDcB9XGcW+l0yIjwx40cJ8QiVd7HXZWvGmk6iUUQUKZUEib8ZKoTA1QrCSSoUEKJf6UUKqoGLWUSzN9rhXUU4En6FkavewvIZ4QqBGIojHDe+RiqVdBqUS6mT32LjhjSNqWI8M7dFKh8jvxFDZkVjAmSxDolFVOkmbX1JEUTIksq0M0Qnt39tfINBHBlqlHCchhJDdR28H1Lz0/yueHVQsCSGEEEIIIYRMBRXLOSPHFcXWkWgF3achNIZT209pb30z1gjY0gqOeoWSCVBsZMkQV9nEnSjXQfkFrdyIUXWgVGrlFkI3e0iptKqQGcfWd1RDWWZElhfBZ3fsJf7GmEpZMgQlRdwuN8UYLJQbWVgsxu4t7ivOfW9r3W6zdnbLG8sJBdPu36irWG9E91Axb2XJv5Zy/J3q0ZcqNNTn/opQsMvlJarGBbtqfkppiNCy0phKM9UUoyqFMqZmYRmUqsHC0B9r3HLUR4y3lGqmLMHjnN+xEt/yrsuS6JMtJeKMlwRSjS6VEHG2QftbvWVfmVw/5peYcRwHze6BYj/dU6pSGVMs5ZjK6HdkRcmQFELKZcp4YPtsxtoPjNm0x6Mcl1ZORMPtM8rb2PbFurYkirIfQggh86U/HM59zONon/OGiiUhhBBCCCGEkKngD0tCCCGEEEIIIVNBK+ycgRUJVjHX3iQtfHWCREKR+bGSCiltlQNJTHiFsXPZ+H23LEhqWRG3DIO0AIamLsaS115YV+2tMUK2WWyLkg7rZ8b7hZ11HKLjW2Dx2bXMwopqy4qYdeBOWDl0uNS3gbRwmvtiaXm/N//UiaKEQ3EO/GOWfZE2XjdI6Bysr6Jci/zsbyyuhyw30se9Vrb9hcpJyPAWbR15n4dsr7NGlozQlvWXmr59G+fILb8jz5tcRwmnArgebtCOO7+L0CfnevXEFz3WRWgPpsOti8YNwuqKvuDz+tVeSREE9rjfZ/bamqkM8XEJWV5DATaTIu38ofZiNlH5HY3yIFpQTytQokauq92zpTI36LvYn7sfQgghu5/ecJg1WG6EEEIIIYQQQgiJQ8VyzuAtNQqGx4J8YvH4DeUNtrY8CyxPLRA+FTKYJBNqDEpTyPIK3jaiLReh7qDsAgrGSwUTgTza2xwsgYKJt0pQ/rQAHEy7phj8WB0cqxdueQ+X9kLHCwNpO9cJ5UTGbRTtdUxYB9SLZrNVUh8R2oPPsiQKlufn6VDRh6/0Nr1zEXvDZRXekCptApmk0h0jVGYiVl4ipvqkltXRFKpmRdCP5gCw7bfOVpcOwd8LRtXcd9yfj/PqbGPVddFXqI8owRK7bngGZAmR4cZlviqZtyfKAUGhxNSE+bTNfZ//3R0HSbnXUiqWmhtCXg+s05zg+6mqpIhGqFRTyn7w/Lr3klQZM6Ny9yN9svcX+mSmaKOBbZ3/VoTCrxjQQwghu48eFUtCCCGEEEIIIaQa/rAkhBBCCCGEEDIVtMLugvAe/C3rkk0SWiFtXTEbrd3GTGGrjdkLtfCSIA0RTDIU9klb6zBQp1Kb79oKzTxYBa0FVtamxGenWcwr1bNE15RamDaAB+cYdStNqA+ssW4dSy00p5i/6dtaTY1KaXHNP7eKZU1h1YMNz/TYzGt49TLxedy2XuPTswWLYCM34MhahVuFlXvoBjA51yvFjjdLy17UohrAtaD3A9vKAC2t9qXdN+7zFCssarwuHVdDqsa1K0f3qH/dbbiSuQ/xTRKq35pvY+pUrppt1tcv8e2tri19Q9SrxNRYYDtnN0rfYSE7s7S3ptwH0hYa+w5LCfoJBT5J26y7lrXjhur4Gtyaq6E+2O/8wHGq/Q5YyLU6oMGam9scaEUIISSdHq2whBBCCCGEEEJINVQsdwhXLUGQj1RHQm/y3b+lQimVSi9UokLBqRN8MVZpaqhOUGtMwItKSLGUbbizzFSqjjKMxi1DAnVTBv4g4Gdr3QT1rI6vU3etmHfm5IYX2mPDfFY3SyrluDRJMa/VLq7xQmfBC/Fxw3vaRhW2aiYUHPO5Z+4dV8HEPOx7HObT9sqRuGFCtp9C6JLnDcqYO2/Y368rymY6bC0WTbuqVkBBiSkrUjGSirmmaoWen0lKUoTUJ29Z6BmIlcoJ3d8JpXpwDaA+SqXZvV6l62RUR6tUIqDHDe/B36acSLN7QC0lohEqmYQQMfdaN829Ic+xdU5ErmMp7KaGOie/M2MhTqFtZD/cY6gKnJLbutvY1gOBbi7Ypm36JtuXqishhJCdo1f+36257HPeULEkhBBCCCGEEDIVVCx3kWLZPXx4LvuG6hN7gw7sOnKMFFQaWRbEpY9xW6v+GDS3YPy4U/4UXZFlGBRFJzS2LDbmLDTG8rA5Bxtnjfq4OT5H3XN+6Q6MrcSYyt6mrxa6LDhjKLVSIlAcw2Mox+tsbnS9ad5+p1kqj+IqlXLqlh7pdbeS33ihTEW2eZmveAFxbd17rEpB1MbN2Xnm8zCgqsf2k6I+po7Lc5+DsWp/2iwLlMhplVX2UkkPocS74yKgTMr7GcrkcOuifLol23T/xjIxXhKqZLblKJZwFAg1Fd9Z2ti+kComzz2un4tVQkUbJRUvQkyTkwp2Sjka6d6Q1z9Whka2UeorHAk1ton11SqvEyj1hBBC5kM/m/8Yy9E+5w0VS0IIIYQQQgghU8EfloQQQgghhBBCpoJW2B3CtSt11ta8eTbwImF7ackqlRJx7GVVwSRa3+zfok/NrYaaPeLZIaU1EBY7lKhwN5ZWWLsjUcJBscLKsJm2KDci13ORJTVaxkqK0B4E9uRdC9j9MH9cjmS8H4T27D+47AfvmHPvhvZIOqb8zCbK0ZgSJWhj6AahiGs5Dg0y52ShWL58YHx+15VwHvdcAHf5qrXCHtGvmylbodkbpdVVln2Q66nLAlbEmC1T3vc2XMU591gmS/6EnrOk4Crcs7Iki3sfqw9Qlg2H475tmedmS977vUN6WRC3dAjs6NImKy2wbngPEDZ3eb1cO7+cFwySceehPZxTc91iYTPSPirfjE4SWpZSkkmuE7PAhvpf6rvybLjntC51rN6EEELmS2/0/1wsN0IIIYQQQgghhMShYrkLQKFxvK2uUk1SUN9Wi3h9qYzG3nDj7XopfGPYKasbVSUToKi4QS8ldVMoLehjY6uk6nRF+QUE8CCYJ3bjQ53DulAbN7s9L6DHUySFGmgPwYT2uCVKENqztLxfKJYI0+lEFFBfvWg2/bIj7c74fugsQgHV3xVp4T3yTVaozAjOq1q+AlOo0eZ+aA6KkiyzwqqdkRAYiS3BI8JSNPURz0JKOYmpCD0bMgTJXQ9qolQ5pQqJQB5XfZTt4jpBqVy/JKieNfpGxd86530/ScVZbu8iz5t7fqFUWuVdqJ0xVVC2l/KG1JYxCYQEeVSU6oAib49hgu9m9/xJpbJ03wWUYHcd9LRFpZIQQnYdPSqWhBBCCCGEEEJINfxhSQghhBBCCCFkKmiF3QXAVoV6lrDCpoT4SGKWLNitYD1LsZrJMAy0bvvWb4XvJFj1ZPOwzcKWp1kEW3r9SjdYpt3ULV/tQG3KFefcYJlc13an2SjZXfG3DOlpwjZntvH6Iq4hPiOYB1PX9toz94ME6+g1LxsipKfYz9JycWGW9rdLVlicPZwDWCZQqxJTG9iTr3Q4ENpzxAt1Au691YzUq3RJsRXG7OHS8joJ2NZaZI2dVqylh1Xhvo4F4shAH2lndZ8HaR0XtuNSeI+7XzfIx6HZPZBP210/OMyzvIoAJlsvMRLeYy3zMigpocaivVdqXL9Y8FOpb2I/6Cum2vdtKEbInpNI31K+X+W6oeNJCeKJhR4RQgjZWXq0whJCCCGEEEIIIdVQsdwF4E0zyo6sX3yxup5WhqFO6ZDQvJgykKz6uAqLVSoDQSVuaI/cHlO5jmnTfftiVcdAIM+KWX603fam7jJMsU0TU6MAToKrXCJoZzAoph0T5mMVS/MZwTwxoHZiurU5VozGZUWK4+kstVXlsrM03s9DIqSnKz8jREh74yVVOTONlbvRQl80NJUzRCzMRN67VplSlKRQOYm46tSPK/RQId3noKTMb/rryqAet10J1pUlRDYPlV0K0nmw1fWCw6BOutvIQBmcg1BJEXcdSZVKnXrug6U8sDzSblXf3DsgFOIUur8HE3xnuuvJ/qecLxnsQwghZPfSv0D2ScWSEEIIIYQQQshUULHcBeDtNNQD+1a8xhjL0Jiz2NvzlP2kjA+qVB8xrkyORXNVGRSTx1QqO0a1cQvHt817foydxBTqo1QuMdbSVTvlOMzuqikz0i2/5wmpmCgPkrKsbcbqQaFE+YymUTTzdcT12BSlNqB2bqyfc7Yxymun6ZUfgXKplRs5tVGUBDnR63lTO7ZSKJnFAYnxfYLYmDA7Rg/qT0T5kttI5SapZETFMk8xEuP6Stu0+uWyOlXgXGHcZN7xiu1jaj/GS+LcQ6k085ubi/l04dzZ4PdCaAyfNl5SrosyFjE1LXS96owVlG2pyp4YF4lnI2WUoS23hHNSUVpE9iF1P8F7NdCm1sfYua46lxxzSQghu4fecJgN5zzmsc8xloQQQgghhBBC9hr8YUkIIYQQQgghZCpohd1FwAoLWxrKjqQQK7+Quq1eUiGrjOQPBvLIZc0EKyyshrKchWGh2Rtv0iiOdUlYXyXW9uosxzzYZPH5tLHAoqQIppo9VpYf6a71vDIk+aG3YEH1j6O3ZUo5mOUuY5ts0ysv0hTWN9fWilAezBuXHzHHt1xct3XHFgGrq51KC6wW3iOvC0J8rEW0kWx9DNkz3XvY3psJdsUqK2WoBIb7d/D+xvFpFlWcAyzDudGCeGzn9Pu79Dy4iHAefF+A1ta5kq3VDeXRvh+06xOysYaWu+vALlsHazs23z/4jO+jmK0ax9MT312a/dmGEsl1YKd1jkt+n8pSKLDeyvVj82Ln3pY+ESVeJClhWCklWAghhMyXHq2whBBCCCGEEEJINVQsdxF4s7xwrlAetvbvTy74LksDaCUXqoJQBtob7knCeyQykEdTaxBEYpUaoRB1TnrKovt3VdmRTPlsy41AqdosjnlzQ0y7Y4V07WxxjtfObnoKJqZQLBc6Y6X54JGLvUAelB/pCSXJVUCgWG4aRQrbAMxHCREtpAclT6SS6aqPsqwIQnqgXOKzWm5EhvjYMJ9w6YNQ4A7CfDTkPY/AlRjy3ocKGZqvrVNu1BxfS1ES7QEJFRcsONvIZ8B2ANuKsiOuWtrb55UlCqlbrkpZUr6EyqWFw0iVU7aVos6BWDkkuU3oGsS2DanQ2jb2ey7QV0/lFKqp3K+8D7W7Rh6fVFE1hZQQQsj5SY+KJSGEEEIIIYQQUg1/WBJCCCGEEEIImQpaYXcRsLMuni3q0K1ffHHQjipDRhCagTZgrNIsYXVqU4ZCJGy7qO+nAXsrpsbOqgaTwCIobbNmm0arsAcvNca3rKxXaQN5RD3LnmLptNuYKeysPWOJ7W36gTyuBfbMyaL+Y2/Lt8K22h2vzmTevrEzdxaLeZsbvr0VtlZ3G2uXNdcS62BbfN5/cGzTgy1W1qtEPUt8PutaYc3fdirCevDZrR1asnBa+yfqcW5U2iZD4N5178+QtTEWjBKyRcbCeyZChvKgzqQ8R5gfsxKb84dAHs0m2eifUm3vKbUO5TqlmrkKoXMeC/yRFlVpGU2xxFbN19qR19jdNhTMFKvxKW259vwF+qiGBVXUFnbPjTwrtl4nPifUhYXNmRBCyO6jN8x2wAqbzR0qloQQQgghhBBCpoKK5S4Cb7+hWFr1MVQCwX37bT5LNSOGbBehHVq5h1gfKoFiKVRIT7nE35hiHRHa44b3HDb9lCVDVsTUKpZul8w8KJdbpmQISoXYqfO6B4E+3bUtNbRn38rBkvqI0J4QCO3RwnsGKEEApQ0KyLDvlRRxQYgPQnts2ZFOcS66g7HyIZVcq1SKadY74Jw4ocqZKe67aUJINNWnVO4BiM8xZT4U4hMrSVFSNY2i6AXzyJAeqVRCjdwsQne87pfKS2wEg3PkuZXqIJZr28rzgnVjiqX8Tgn1Q0Mus6U9EkoayTbq3EuNyP0gS4WE1Ef3Oy6klFslEWq+sp5VQhEWlBAsNJiiXAshhJDdT3/0/T/nfe6Ej4WKJSGEEEIIIYSQqaBiuQuB8oCyI5vLy8F1S2OaJtmfebOeokrWGpcWKq2A+SijEFEqF5qFGrjUaKolRLTxknKspR1zqWyD6VmjOkKFdJVKCZZBwWw0MI6xOH/thfHxhkobtIVyg/GUI5pNf5ve1qYYj1nsr7M4PqLlAwveWMul5QVv2uoU25xaH5/zVXPdMT1l+mrLjWDMllv6An9DuTSqXUhl8u6XijFgk4x5jKlAIbQxllXj/LBmPzsULmMBZQzjjsW4SW0bqTpq/Ygpku58za0wTFQ33XMhl0llN0VJlOvYFgLH4G4jr6U7djTUF6vqm/luG6WxtnCCJJS5sSWa5ArivLrfnVhXnqXQuM38b/SlhuNE3kMsWUIIIbuX3nCYNec8xnLAciOEEEIIIYQQQvYa/GFJCCGEEEIIIWQqaIXdhcDiJMuODGI21kjcvqQUSJEQfIHQjZLdD3ZWWXohX0cpK+LOX3CWY3sx1ayvANZXG+Ijyoxg/jFjQTvcHt/uWNZAaE/fP7sIzkGIjwsCcVDKY8Oxl+bLnfNpLa6wICKsB8FCZv6audbFOk0vxAfLhsNiP4eOFOFAK4c7pdCelUPFvMOXLHkWWdharb3Vsbye6vU8SyxCjmx5FtfKDCusKKFRsqQq5UZCpS/q2FhDpRu0EiUhC6Lsj9eO2J+1YSo2XmxjA3hK+x8ES4cAaYHVSofYEiRKuJa7rratDYUx+wmFe2nfLTLkJlbWJLWkkbZtyN6qXZPQ9Q999vYtzh/ui1j5FGDXFTZq7ZrguxjrysAizfIbDF+rUUIkFDTEQCBCCNl5erTCEkIIIYQQQggh1VCx3IXgjTbCe7SAiKqghmmKv8fUnySgSLY2/WAeqJGYr+7cL2PRa64VnxXlUob0QMHETQ3lEmVHoFKOOGrUy94awj+ankLZM0ompi4Iz0GIz0LHVx/dIJ6O2WdJuTR92two1KjV06fsNggBQtkSbLv/YDF/5dCiF9TjqqfjciNtT7G8y7QBVVIL7ZHhPcPhQlmxlMq0uZb9pULBbPR9Fajt7E+qMaGwlklCerSwltB+VNVMbBsKRJFlLdz27LrmOKWqFS83Eg5iketINThUhmREO9C+PDc2PEZRnQc1lMpSGwI1nEgqlAmlZOp8L8nzEyr/4V6nUGkaWxYI6yrlU2z7Ttkhtx/yeN2/e6aPUKntuRdtu3/j2lGhJISQ3UuPiiUhhBBCCCGEEFINf1gSQgghhBBCCJkKWmF3MbBDYarZvwYBu18d+1gdW5m1k2ETN4AnuJGwAqIGIiyyslaiu03bWGENWi1K+dlOpWXWsZHtM+ucMvUre5t9z/qKepaYarUtEeKDbfatoI7l2LLs/l2059c0RGiQG/gzXoaamn2vPqasVenVtjTT9kLR3llzvU4goMexydlwHoGd3ztgpk5QT0VN0kGnsOlm5jg162PIjplSRzUUClOHmB1T2lglnh1U2FlDtSjdtqrCelQrrNiPnB8L/pHHXFWvU0Ozbspt5PdPa4oamNb2aabatSgF/CTcF9ICK+83rY3S96mwwMrvX23baG1Xse9QoBDCxFCD0+tbwOZcx7pMCCFke+kPh3O3pg5phSWEEEIIIYQQMk9uvvnm7MlPfnJ24MCB7NJLL82e//znZ7feemutNqhY7mKgbtiyI47ahTfbMpBCvrV238qHyhTElIFKZJmQ1GV55xz1C4E+YhuojVKNdP+WypvcBqE+mK+F82xu+AplTylDMp439KZj5XLLC+QplplgEJRCMdfDXSdvy1EX0E53rQhv2rffVyjHiuX48cXfNsTHTB8y9wMUS0zdsJ5u6I0W1En3OkG9HHb8siPmc+z+kwE4oTIZsfAobZ1S+1IhMn2wASxoy1EApboDlViqTlq5DrlMqoPuMVQplFrITkiJlPvVQoJCqllUzQqE3IT2621aQwkuXScRFoRQGnetUF9iKmepdEigHI0N5olg1U5xXrW7Ud5vJdUz0r5VYiNqp1xHloUhhBCye+iNvp/nvM+6euWHPvSh7OUvf3n+47LX62U//dM/nT3rWc/KPvvZz2b79+9PaoM/LAkhhBBCCCHkAuZ973uf9/kd73hHrlx+8pOfzL7pm74pqQ3+sCSEEEIIIYSQ85AzZ854nxcXF/N/VZw+fTqfHjkiclAi8IflLgaWpo65IRDi49qsJgkzCW1jLVSafVHaqzpjS2UJaWsNBL149SwR5COmsLGiBiVqVroW2LZcxxyfrHPp1rFE/UpZt7K7tuXbXc1yd560z9r5xuK2qZzfzuKSZ3l1Lbb5MTjnfBNWw3ZxXAePLHrTpf3GEmsssppNduVwYU293dwzsL1qVlgE+nRN34LW2LzjHd8Sa+2yJrRla8OzH7rWPdxBdk7AjplSk1Kr6yfXmaTWYSmwRvTRfQarwnQsimU0FPSj9aeqBqWsc+mekyoLbFJoT6CepbattKTGjqvq+ljLrTNvWGHT1a6NtJeW7McBu7BLKPAH35WuLdhak01fU0KpLAGbrPZ9L622sq+4Bu5y2mQJIWRn6A2HWWOHwnuuuuoqb/7P//zPZ6997Wuj247+f/VHf/RHs6c+9anZYx/72OR98oclIYQQQgghhJyH3HXXXdnBgwft5xS1cjTW8jOf+Uz293//97X2xR+We4DOWlFyY+FcEeYyore0pL65j72Rtssq3vbHSpWM35gLxRIqZEpoD5RKt9yIUCr3tUyJjUYrqDpaZVIolkfbbXW5G/yDs7TZ7anBPAjkaTadsKBO01una0qV4AUUlA83iAflRZpNLEM40Ka3LgJ78r71ir8PHimu8crh4gtg+YBfbgTL83UOFcsOX7Ivnz4QUCPdq3bKqJdWuTTrrBv1sRTU4+IG+kTCaDTlDdh7SdyP7v0nFUmoaM1A2Qd3P4OAOlgnIAdqoxZYI5VCScqzGFL/Ys9gaL+zKMUS7WuNdWWJkhRlWX4/yfU8AuuoITpmKu8vXEsthEj2237G/SYCqNRQHbMOvqutgqlcP6zbFu0uRMpITRS2Rggh5IJTLA8ePOj9sKzih37oh7L3vve92Yc//OHsyiuvrLVP/rAkhBBCCCGEkAuY4XCYveIVr8je/e53Zx/84Aeza6+9tnYb/GG5B8C4LpQdGdE9fNh7Q4/4e+3NdsoYyhCVBcgxxq7ZKc/DFITGXGplRoTKiM9QIbVxl3KK5bL8yAhoIK4i6R2WMsZSKpel+ea8uuojwDwolV2jQtvSCs2xegGFEuMkl1cWfFXyaKFKHrxobGWAerl8oFj3PqOKYLwk1MjjTt+gVJbGX3avMNNj5mR0ImMti740+uVjlqpMrAxHiJAaKLd1VSe7Hyh8NQrFa0qr24ZWoqRqnKS2/+B4Sayr3EMSOcYz+sxPQUhN1UqHhPanPTEYe1jlnFDHcgZKJWnfU6FlUsl2+9ELjO2VqqpU3bXjkqWhmkKVdNmS5XXMNcZ/AzTFsjQNuAcIIYRcmIplKiP76x/+4R9m//N//s+8luXx48fz+YcOHcr27Sv+f6+K7fFOEUIIIYQQQgjZE7z1rW/Nk2Cf/vSnZ5dffrn990d/9EfJbVCxJIQQQgghhJALmOEMFFX+sNxDLJ06Zf8+d8klXjBEir3VWrEQIhGI4Y9iQnVKIS6uFdYGu5jwl87JdCustV12PfuqnHrlRITFDTe1to0EVldrfRUlRfA5n7dpyox0TbDQgl9cAfZWD2O3Q4gPrLDoEtpAMI9XMuTQom6NNXZXzB+x39hi7zLWOdhaZUkRfHZtsVj3bK/pW2AxRYiPEugjA1BS7qGQXVuz7sl16gROhZgkVEeztaZaDGMhQTIEJil8S2D7VMPyG2u71vdBYrua3bQRCBGTNtdYew1h/9Tug0GgNIhsK1YWRAb8yONxt40NR/D65XxvyesvQ4G0vsEmW9pfgo2aEELInBkuZMPhwpz3OV/r7QhaYQkhhBBCCCGETAUVyz2EW24Ef1vFsiImP58n2gu9UU+J9w+WEknBLTMi2mu0iuNaai54N+ho0HOpGaFEYp1eYPmwNz4DUCSlMgkFUy53l0FlhLKIsiPdc4Uq2VkaP1YoW4L29+1ve/NlW656acuNmNCepeXinHSWiuvWWRxfP6iOcipLiuCzpmZmvYO+arx5xFcuR2wZxdKUJEFoT5XSNylSGZIBLFoASq37WiwLKVOx8B4Q6pu7X7RfpWalnLeQyqmpj7NQdGdxTb1zIZaVlMuUBuG+MB8RcuNei1CIE9ZBCZGUc9yWQUaKUgoniGzDbqOVDgmopw3z/a6Wu0lUqLWQJUIIIXNmsKCHIW7rPqlYEkIIIYQQQgjZY/CHJSGEEEIIIYSQqaAVdg9gbVDOPNS0XL/44mSrW6odzrVYWVsXQnsam/Utr7DNys/KuqhBiWAe0FMssaFgn66wiKEG5ub62AYG+yqCeDY3eiK8p1+2wjpBPm4NTNhZYYGFVdVdJsG2sMRi6m4vp2hrvL/xfrqDnnfssLkelyE+zrlBjcuxOTaAa92YgY0jaGtNsOvJ0BuNSepKpm6r1cvE8bQT6kpWWS2lFddFBv1U9dldFqpFmdKn0Daa5bbKquxZVHE9sG2g7xqxUJvSfnHPiOs1NNuq51VcS3nf4TqhTdSmlMeYirW+ynAi3BfGrusNbTD7CW2jMctgJkIIITUYduZvhWV4DyGEEEIIIYSQvQYVyz2E+5YZiiXenEudQ5YUibWHt+XN2D77RhnYJ4J3UFqk5cxfWPUVyoWTcQUzL79RHMGKCe1ZEiokPrtKJm5elBvB9LA5Zkz3D4ttzxiVcsTa2U1PuZRhPVAy/fCeQUlddNVHBPC4KqWmSLrrtBdaXgkRLbQHnzFdXinW3XAu2KktX5GEQokQH5QWcRXL1VJ4D4J5Im/UTJkRSUgtcRWlUkkFGaIC5SirT6ykR1Uf6wbiyHWzkMIXCRYqKVKiBIYX7CLCZ2ZZBqR0LAnrxtaR1047HokNRDKqXIq6iu+1UGkSLbAGfZPfiZpK3Az0UQYB4f52A4BsQFNFuA7UTq3dEG5YG/rUEWWO5PlyW5RlTKhcEkLInBjsgGLJ8B5CCCGEEEIIIXsNKpZ7FJQbwXTjwIHkcV1WLYH6J8YaRYHaiLcuUCdbzpgkqUhiHcxXFEsokVahDKiQUC69dcwyOT4TU6lKuvM2u/5YS8xHaRH1FBiFErhjHbXPrjKJbaFQYl2UGBlx8MiiqlBCwdx3sJjeZkoruIqkLDeC+XK5q2oONy7zFcuAKumWGYmNBQxh7y9RCkeqJpOMUXPbkKVBJhmTGFIHtTGWqZ9d6pRlSVWVUsafppaomLRsS9W2Wl/kWEG5H20sp/3uQltCjdRKvGRCFY4po3LsZkgZRT+0MipyTGfpuFxVuqIkCc6R2y+opFAxraoKFTxhTDEhhJDzudzIYL77o2JJCCGEEEIIIWRa+MOSEEIIIYQQQsiFYYX9xV/8xewv/uIvsltuuSXrdDrZqVOnSuvceeed2cte9rLs7/7u77KVlZXspptuym6++eas3d4zh5kM7F0I8Vk9dix5W2vbCkT1J1napK3VLSECiytKk8jyIuZzo1XYeEesNP1rBEssLLBHzTU87FxLa3lF0I/Y1i1NIu2tMjyn2ez7pTwWfeuqS3dty9t23H5hOegstoPhPbC1wvo6tsKOr8Xho/tUS+yCWeduY3lzba3S+irDezC1QT3u+YE1Y/OI/xnTLWORVUJmZmGzSy2D4+4X/ZD90fpWK3wmYKOtY//U+lQXbdtJygUBaY+N2UCrSq7EqCz1EunvIOE4qkJ7WpGyJnIdzIeV1D0HoWsI+6qda75DPWu4+Ru21Z6wtWqESu9YK6yxvXqloMQQBmmfRT+8/jOshxBCLqDwnsF897eXflhubm5mL3zhC7Nv+IZvyN72treVlvf7/ey5z31uduzYsewjH/lIdu+992bf933fly0sLGRvfOMbd6TPhBBCCCGEEHIhsGd+WL7uda/Lp+94xzvU5X/913+dffazn83+5m/+JrvsssuyJzzhCdnrX//67Kd+6qey1772tbnKeT6BN89LRrltmyCXrf371bfY7jYhRUALU7F/L9VwTUOhdAN9XCJvbKA2SmSYTz5PrGsDgIQiJ5VFTUnEFKqmFt5j10V5DKFQotA7yo5o7UARRVv4vLwyPicI6YFyOVxuqQE8UCVTFMquORfuNja0B0olwnu6x8T8oh8jGv2uquylhPmUQnQmCAACuN+1/VYF4mjKUUiptKUwpkALn6nqk9b3OiVCUvsUU9Gq1C1tW3nu64SJhcrPpGyDt7IDLRgnUOIFIVL2PDrXWiqWUAztGZfhPsp9IvuPzwjV8bavCJjSzknq9XHLmmBrKpeEEDJnBheGYnnejLH86Ec/mj3ucY/Lf1SCZz/72dmZM2eyf/qnfwput7Gxka/j/iOEEEIIIYQQcgH+sDx+/Lj3o3IEPo+WhRiNwTx06JD9d9VVV217XwkhhBBCCCHkfGJHrbCvetWrsje/+c3Rdf75n/85e9SjHrVtfXj1q1+dvfKVr7SfR4rlXvpxiTqWCPGBFTYUbqHVRsO6CMaI2tcg48tAnpSalxFggcUNaQN5AnUtY/Ur5eemYq8d9Ifq595m36t56Yb3jAN/0AfzudMMLB9bYdHO0v4Fzy6LdZf2jx/FlcOLngX2DmOzg61Vs8LKZZjCAts119gLNMJ1gQUW1ldMTWhPzHIZCrdJCb2ZpBYmkLZGbT+hfg+U5aHAn1CtzVj7dQjaNCP7mcSiOk1YUMq5SN1nHQtm1Jof2C/uKbcuJLaQx4HzOhR1H7X92BqR4jsydtx2HWPbTgmVCp1jbOM+M/h7kvswdi0JIYScL3Us+xfWD8sf//Efz17ykpdE17nuuuuS2hqF9vzjP/6jN+++++6zy0IsLi7m/wghhBBCCCGE7MEflpdcckn+bxaM0mJHJUnuv//+7NJLL83nfeADH8gOHjyYPeYxj8nOV/DGed+DD+bTc+Z8am/SU1UFfT0RZhNTLKGAoUzFgik/IsqRaEE9toSInJp1oUbmfwsVc0mUKMF0sIFgj/GbfRvWY5TKzQ39rY6rPkqgQqIt0FlqB8N6EMyDciNQLhHU465zX0Ugj1tuBOrlqlEvbGiPUCqHw4XydeqL8iJi6gWG4PxDEYcqjHMi1JhJFJFpg2uqFD4oU+781LIiKepQyrGHlMo67Yfa1Ai1q4XshJTKWD+kgjeTEJ/IulXnzw2sKSGDfmr0cSCVUWUbPBMImEL7sriTds5RIkS6SdAWpm4fQlCNJISQCz28p39h/bCsw6hG5cmTJ/PpqLTIqJ7liOuvvz6vWfmsZz0r/wH5vd/7vdkv/dIv5eMqf/ZnfzZ7+ctfTkWSEEIIIYQQQraRPfPD8jWveU32e7/3e/bzE5/4xHz6d3/3d9nTn/70rNVqZe9973uzl73sZbl6uX///uymm27KfuEXfiE7n8EbbZQdwZjL7uHDwcj+0Pia2Nt3pyS4T2OzrGDKciMBddNVLNtyTKWYyuXeuiGV00y3jM7QbJXPBRTFzmJx7O0OSoYUCt/S8lhngOq42RXqmVA/3XIjnaWWN0VZkZXDvnJ58Mj45ceG6eaqGe9ZGltppscdxVKOu4RyacdYYmwlVMq8w/XfnFUpbJgfU1NsYfeKYvQuof1o/Qi1U1IunT6mKpUppUNCfR4h58jzFVMQ5ecURWoS5ViuW2c/VZ/rjP+MqbeDiuvjPelmfKTct1RGUxRmlCixbShtQxF3x3lqbWFMewqx52qS60UIIWTODKhY7ipG9StDNSzBwx/+8Owv//Iv59YnQgghhBBCCCHnUbkRQgghhBBCCCE7w55RLImODYYQZUdghXXtZLAgVlnqPPtsyyzrC9sW5HzYXV2k9RWfI4E/CJmxn41101o6xTT/21hhvRIazmdMYVV1g3hkqA6sqrCxwhqL+d7hOCVIXLTSIZ3FtjdveWXBKymCzxudcZsnjN1N2lphgb1bLNcCfrAMn9dx/TQrbN/MC1g03HtIlj2oKqGgBvEIO2GKfTZk79P2m7quu15q6ZOUUhtJlt6KsKCU/aSE6kxTmqROoFDVGnUssCmW1DolWGKll/LlCX2xrYvv0Kq23ft90Ol438PaObHPgrhHNbt41bOmfb/LUCBCCCFzLDfSn7cVdjxkal5QsSSEEEIIIYQQMhVULM8T8AZalh3ZNG/J1Uh+8/baqgCiCHi+bGBKduAVhCwh0okolngzg8+dk8FyI7L0SEmF1JRN00+E26DsCLbF/IsWWiXFEiVBOktFy4O+CZQZDL0gHk2xlPOgYKJNN7xn+cCCFwKEZZj/oNE67t7YsNvYsiLmWI8btQJK5XFFsbTqpplC3Ty7uWRO3DF/6v69ecSfQrkcdrz7wv27KhQmtrxVofRpQTyhdScp06EppNOURZlXWEpof3UU02n2G9qf9p2y3X2rCiDT9mNjyITqqN1jpftLKqXOM5Gvp4Qt2XAq7N9s6z5PoeNCHztra54jRbtnMQ/TlFI8DPghhJA5M+zY/6+a3z6pWBJCCCGEEEII2WPwhyUhhBBCCCGEkKmgFXaPI61fyydPenUte0tLpbcI1vpqPsM41UyprwYZHzZXhMEYe6sa7GOssAudU35Nymxsf0XNSWmJLQXyRObJwB+0CRDI41pdVw511DCf3tYgaIUtW2BbXvtL+8dWO4TzILznAXOd7upterZWTGMBPHcbC51cnh+7OWYb9INl0uaKqXudYG/GtTSfm1uNYHhPnTAdibXzBQJztIAS2V4siKcKrY8hK2doW406wSih/tYJ08H+Qucm1seqfqT0yW3L2jzFvkP1JlP6plF1PwwioUfWOjrBubDnXhkukO/DDUkL1LNE3+T3sNaOPE7tuKueNdpdCSHkQq9j2Zvv/qhYEkIIIYQQQgiZFiqWe5zSm3vzRh2K5frFFwdDJWTsfVQxQNkRgLcucur+jRfyRgnbGphwm/agHN5jpktmnlQbY8jyIiHanXGbS4FbHyrk5kY/WKJEBvsgmAef3W0W9hmlUpYDEaojlEZ3nlQm5dTdxob2QCXZuMxXKKFKuoiQnrEKvS+fNPrlEgch6oTpTKMuSvWpTniPxFWMrGovFbeICll69gLzNUL9loFa2rr2czY5MYU2dC7rKIqyLEjKOZnFW84U5Tnl/IXUTFyV2NGEFFG5v4HSb6l2trtdb3mdUjLTPBuEEEK2odzIYN6KZVoptVlCxZIQQgghhBBCyFRQsTzPwPg1KJZuPP1mpDC3O99Tcuxbd/F2XEYmq4qliNW34zHPFH103ujjbzvFOEw5dZorLRPjM2M3ty0rYqal5UaV7Dm6AtRMOQ6zpG461Qxk6RM7NSqCHRvpqA+ldc20G9vGzIMqbM91ytsxrNNfSVY4YmUdUqkqJbJd7QN1vjh2eS5SxuGlzo8qbgntyOOrM8YzReGrOn8ak5QXmeQay/2kHHud4wmqtlguzrk6Lhjfp2KMJfbfjpQdkaVE4ERxv8+hZmKeVPGlQyV2XIQQQs7HMZZb890fFUtCCCGEEEIIIdPCH5aEEEIIIYQQQqaCVtjzlM7aWj5dOHfOzttcXlYtr9LWqFrFGn7pEEtTmS/nYSosALC7auVGVmAXk+E+jmUP67rtaOvC1rrZHdvV8PdmtwjIabbM/hf8YB4XzMO60hpr9++E95yDfdVYYkNBPAjqcefJ0iFYRys3Mty6yLfAyvIimI/piA0R7NO3sSO1LYqhMhApbUgr37TBP5P0ITUIRVtvEvtnlYVzuy2LKUE88rgmsZnGvlvkvEnOozyOmKW3ith6Ifts9DoJC6wtURIos6O1Jy2wrhVW2mRDfXHnswQJIYTsEANaYQkhhBBCCCGEkEqoWJ6n4M30vgcftPPOXXKJum5SmRGojgur/vLOyWLadubjb0ylyqlQUiYDgTyxkiLYFtofQm4yBAItj293BO+0F1q+QmnWwXKXzmJLVSahWOLzaScu4+7NLU9lvNuoC8fNZwTwHHeUCKlIhpRKW1JEUyRDiqVbdmTriBraIxUQVyWR2G0SFLZUVTCFUAmOOtu6VPVfU1NTVL9Q21XbqmVARF9C67qfQ0qo3Cal9Mp2B/JMsk3oeGLnXO6nVhAVFOZI8E5pE7EfrbyTPQ5Zwkbc37Fgq5iqTggh5EIsN7I53/1RsSSEEEIIIYQQMi38YUkIIYQQQgghZCpohT1PgR1q+eTJUt2z9f3782nf1LUcdHxpfmACbHJaq74FFrZWhPnA7gpLrDsP06XjxSYNU2OzUdx2h9vj28+G9QjrqxvWEyJmj3XZcJpaPrDg2VdhhcVnBP402s3SftBH2FgxHzUvTzlBPCEbK9aRIT7aPFvz0uynFNSTd7jjT6U11gb0ONv0O1G7p2b3kzZZfE6x31VZKzVba6jdOhZYuc4sbLtuO7OI2Um11cb6MdU2E5wT93PITjqNJVYLzAmF6MTs2tjm/2/v/oOjKO8Hjj93ySUhCSTEBAIFBCulQ6vY0oLUaQcVFdpBK23VajvQdqBVqlPQabUzitYptNpxnHaoTn8ItX/4q9NadaZai6jVgVK11Noapzj5FkQg/JCEBPPrbr/zbPZZdp/s3u1l7/Zy2fdr5tjc/r577rh77vPZz+P3mNN5pNj6Hcd77F9tXzkeg9c5hkn5ZsxKAIh78Z6qaI9HxBIAAAAAEBYRyzFK/bJe1dVlz6s5ftycnpw0yRWptH9hV4V6VJTS/FsbMsRZpMdvvrZOKjkUnatMWEV0VDEd53AjPkV6VFSw0eNXfrWOiuTpVGRxnDV937FeRdXQ/mq0IUNUPGJQ/eTi+NVfFQOyI5bacCD6es7z1yOW+rZZI5bW1N6vikI6f4nSi/b4RSqdxXt8fsnKFiXxK/CjL89WSCRX0RGvqFAhImH5RCpHEhkKUkAm1zbZ1s2l0EVb/CKH+USJgzzOXMMdeQ1RMhJ+Q7tkG+Ymn2hjruP63fc6N/116HWOfu9Tv8cHACihdNWwTLFIjhkxIpYAAAAAgFCIWI5xzl+v1fWW71m/YA+LVCY8hhTxu6Zy2IEc1+P5DC+iIn1qqq6r9LqWUq2j5qt1nZFL9bcdAVXravdPnhhwDyli3hGuSKVhHW9Q+7Xfef2mioyqdY5rkUS13BWx1Nb1i1yqqWueto6RrvO+jtIZidSvtTSq/K+xVG2aR7TOL0qST9TRb51sQyrkM/SFX1TJb5gJL0EibcOu3RzB9ZL5RDv92iVIu/ldAxkkAqdHErNtoy/TH0WQ6zK91s0lW9TTL2KYbTgd/XHY7aG1l9djqPA5b7WuutY92/Oov+7VOTqve8513SWRSgAYRYzUqe9kUR4zYkQsAQAAAACh0LEEAAAAAIRCKuwY50yHGnf0qKuIT9/ESu/UVa/iPYoaVsS5jmNIEeffqmhPszWsiEpNtVNYHQV71Dw7TVata22rlqt9Sa3WcCl6mqxaJzGQcQ0dMth/KjEvaRXtEdZwIgkrjVWdoz2EiCMV1i4WpFJffVJgvQrxDNtGT3d1bKMXJbLPQU+BdRbiUSmuzvRY5zZqmnam341zF+TRpopXaqpfURG/5U4qrS/IMCD5pMDqy/Q0xZEUAApSOEcdp9hDhuRKHfXal35Ofs9JPumt+ayjH891bqJwsr7echQh8noOcj7H6o8s7ea3j2yvF7/3XrbiPbnSxQEAo4BRguFGok69JWIJAAAAAAiLiOUY5RXdSPX0uCKWnamaoQW1e4em6pcUZ/RRj2aqddU61jap2nfsVU5FKKvc97WiPc7oo/pbX6Yil+r+NGuIFOc8FalUEcrBnqFIaX/f0GMfVPOtqfPvylTSVcRHTVUstd4alsRp6NkTolINP2JFFFW01Wu4EWfk03lfbeO1TD1fg9bUfwh4j8ik369iqlDTsOhl7mEZsvErCuMqapJlEHs/uc7FK9qUK1I5kuFHRhKpzOd5DBI5DCpI5DToc5RtWbYIn180OluRG9/HniUC6/vces33ef3Zz71HNFA/t6Dzw7btSF6zFOsBgFEsU4KIZdTHI2IJAAAAAAiLjiUAAAAAIBRSYWNEpVFVnzgxNKPSKvRSt2doOtA0NE1ZBXrMv7s9U2HH13QN7cKaXV+R8k1RVff1wjzOtFY95dUvNXaaVbDHPAdrm/7eoRSwE51Dabv9vUOpsL0nB12FelzjWKrnpMIa+7Jh6Fwqtd9akoOnUs8qrf2oAj/DxuXU7ktDZ+BP34fXPHW8gaQ2lqhXioNa1m+1ZdpaJ6WK9zi2SQz9nRkcKuKTtp5bO6XOI+3OHstQS230G78w4UxR9dkmSAqfX1ppPumF+piRzrTKkRQ+sc/bJ/U01ziD2ZZ5Pa6gxYe8ivfkes5HVPhlBGmZIym65DpPa1rQx6FkS9X2KThVsP0DAMa2dMr9HSyqY0aMiCUAAAAAIBQilmOU1y/ral5tR4c5TXaea04zE3e5o13VjoilHh2z7tfoUTVHxG3YMhXhs5arKKQaLsS5jYpMqmX6/tW25ilZ0US78I4dmbQipKkKVwRTRSed1LLB2krPqGbCGo5E6h0c9CzEo4YFUfTlzsfhVazHfHzOqJdfVERFLPWpM7KshiBR7aZHnJOO4Ui0iGfaGn7ELrKTJcJiRxCt+/lEcvKJVNqnHaKQUN6FX/IUZkiUfJYHLejiXG/YKz7AufpFoUcSrStEJNTzuET/AADlJEPxHgAAAAAAciJiGUPqGsvx+/eb087Gc9wDqTqHG1GRL2VwKOJ1uHG3OU0lh6J4NY7rJbutiIOK5OkRTDVfXYPpXEdtq0f9VKTSGfGzI6HWzyMTW4aGT1GxDLWPJisAoiKb5kO19mNYUc+exNC6B6zoiNr3oCMyooYOUY5b949YkUw1zIi6b65j/a0el/7cqH2o9ZzH0SOhNq8hRVSkMl3vvsZSn6/uO+YlB6yIb3+vNe13TZ3DhOiDsftdR5jt+kK/gd3V8fJRqCjaSK4JDHpOeUXtRhCZDRMZzXqOI4jEAgAAD/I7tvqeHZWoj0fEEgAAAAAQFh1LAAAAAEAopMLGkEpla25rM6cDdfNdxU0Ga6bY6w7WaaWKK6zU2K65Q9taBWTarWFITM6/hRD/V/+uZzqrSgPV02L1YUWc27yhzTfP0UoZdRYDcqadqn2rIU280kxV+qnaxk7bdaQDqr/VtnrKqlcKq54eq5ap+wetNNP3+xpOnUxvq/eQIWo4GD3N1Vyn3p0eq5apNIi09dz3DqW7ShUDJ12vB5XyqtZR950pqnqKq76toqe56vtxLvNKudV57S9fQVJH9XMLlPZpnbdelMirCE4h0khHUiwIAACUULrC/i4W6TEjRsQSAAAAABAKEcsYUhGPcUePmtOWf//bnKatiJ8zwjJQV+eKZqplfeNnmdPBmqGCOYM1C32jnO9ZEcz3qhzDmMgop1UAyFS/x7WsZdxRV5RTRSWdUUc1b9Dnxayij15RURWR1NfR93GqpM6p46lIq4pQGkbKHWm0Chy5ootqOqhFFvtUVNKxjTUv2V/tLqaTJcJ3KnI4FG1MpHtyRuD8isz4Hc85T9+HHlEMEh1U66oIaZAiNIWIWOazjn4855Alw87FJ+KaYGgMAABiLZHJmLcoGZmM8CkDWTRELAEAAAAAodCxBAAAAACEQipsjKnxLJP79rnSWp3UPJUCqNL/VNqsmjplrDEt9XUG6iZo9y+1t+kbP961j8PWcQ9XdQ7NqOgfXrBGo1JHMynDddGyOucDdUeHb9Nzmue+vNIz9eI26oz158YpV3GbUwVyDjuO865v8Rw9VVnfXz6FXfxSQ/MqXJPjPPJJbx1Jqqp+zk7Z2iXofnUVFMgBAAB5SqTT0RfZS6dJhQUAAAAAlBciljGk/2KiInDZhn1QUUYV/Tk1NEnNsKiQHqnUt1ERN+dx/CKgvY2NruM4h8tQ+1HTVE+P5+NUkVmvYR/UOeQ6Zye/CJjz3PTjqGXqHPT9ZotC+nGeR9ChNLyO47csSLQxn238ZIso6sfJZ/9EFwEAwGiQyJQgYpmJ/nsQEUsAAAAAQCh0LAEAAAAgxl588UWxfPlyMXXqVJFIJMTjjz+e9z5IhcWptNAAYw7q63oVXlHJrHr6op4Gmi19VqWo1h475tpGpbU619VTa/1Sbr0KDRWjgE22dFN9rMPI0yIKPaZiRGM0Rv48AQAAFEiyRONY5vPtqaenR8ybN098/etfFytWrBjRMelYAgAAAECMLVu2zLyFQccSoSJGQQq8BImMVmrFdPRtvaKAal35i4zn/rVomjpGsRFdAwAAQKmHG5G6urpcs6urq81bMXCNJQAAAACMQdOnTxcNDQ32bdOmTUU7FhFLjLnIaFQKMdQGAAAAxrZECSOW+/btExMmTLBnFytaKdGxBAAAAIAxaMKECa6OZTGRCgsAAAAACIWIJWLJb0gQfSgUdd9JX+YcNsVv3/qQK7nmey0j1RYAAKD8JDNGCYYbMfJav7u7W+zZs8e+397eLnbv3i2amprEjBkzAu2DjiUAAAAAxNgrr7wizj//fPv++vXrzenKlSvF1q1bA+2DjiUi5xWB84sg6rJtky365xd9zEWPRjqPk8/ecj2+0VicCAAAAOVdvCeoxYsXC8PIL8qp4xpLAAAAAEAodCwBAAAAAKGQCotRwa9QTdAU2SDrZktrjWrMTQAAAMRLogxSYQuBiCUAAAAAIBQilohcPoVqggzHAQAAAIxWSSMT/XAjRrTHk4hYAgAAAABCIWKJskB0EgAAAOUowTWWAAAAAADkRscSAAAAABAKqbAAAAAAUCQJUmEBAAAAAMiNiCUAAAAAFEkyU4LhRiI+nkTEEgAAAAAQCh1LAAAAAEAopMICAAAAQLGkM5EX7zHSpMICAAAAAMoMEUsAAAAAGEPDjSQYbsTfD3/4Q/GpT31K1NbWisbGRs91EonEsNvDDz8c+bkCAAAAQJyUTcSyv79ffOlLXxKLFi0Sv/71r33X27Jli1i6dKl9368TCgAAAABRDDeSjHr4jxIMN1I2Hcs77rjDnG7dujXrerIj2draGtFZAQAAAADKJhU2qLVr14rm5maxYMEC8cADDwjDMLKu39fXJ7q6ulw3AAAAAMAYjFgG8YMf/EBccMEF5nWYf/7zn8V1110nuru7xQ033OC7zaZNm+xoKAAAAAAUUiJTguI9mZgV77n55ps9C+44b21tbYH3d+utt4rzzjtPfOxjHxPf+973xHe/+11x9913Z93mlltuEZ2dnfZt3759BXhkAAAAABAfJY1Y3njjjWLVqlVZ1znjjDNGvP+FCxeKO++800x3ra6u9lxHzvdbBgAAAABhJGIy3EhJO5YtLS3mrVh2794tJk6cSMcRAAAAAIqobK6x3Lt3rzh27Jg5TafTZqdROvPMM0V9fb148sknxaFDh8S5554rampqxLPPPis2btwobrrpplKfOgAAAACMaWXTsbztttvEb37zG/u+vI5S2r59u1i8eLFIpVJi8+bNYt26dWYlWNnhvOeee8Tq1atLeNYAAAAA4izJOJajixy/MtsYlkuXLjVvAAAAAIBolU3HEgAAAADKTSImxXtKOtwIAAAAAKD8EbEEAAAAgCJJpDMliFhGf40lEUsAAAAAQCh0LAEAAAAAoZAKCwAAAABFkozJcCNELAEAAAAAoRCxBAAAAIAiSWRKMNxIhuFGAAAAAABlho4lAAAAACAUUmEBAAAAoEgS6bRIJKMex5JUWAAAAABAmSFiCQAAAABFkmS4EQAAAAAAciNiCQAAAABFkuAaSwAAAAAAcqNjCQAAAAAIhVRYAAAAACiSRDpTglRYivcAAAAAAMoMEUsAAAAAKJJECYYbMRhuBAAAAABQbuhYAgAAAABCIRUWAAAAAIokwTiWAAAAAADkRsQSAAAAAIokkUlHHkGUx4waEUsAAAAAQChELAEAAACgSJIMNwIAAAAAQG50LAEAAAAAoZAKCwAAAADFHG4kwXAjAAAAAABkRcQSAAAAAIokQcQSAAAAAIDc6FgCAAAAAEIhFRYAAAAAiiTJOJYAAAAAAORGxBIAAAAAiiSRzpSgeA8RSwAAAABAmaFjCQAAAAAIhVRYAAAAACiSBONYAgAAAACQGxFLAAAAACiSpFGC4UYMivcAAAAAACK2efNmMXPmTFFTUyMWLlwodu3aldf2dCwBAAAAoJjXWKajv+XjkUceEevXrxcbNmwQr732mpg3b5645JJLREdHR+B90LEEAAAAgBi75557xOrVq8XXvvY1MXfuXHH//feL2tpa8cADDwTeB9dYagzDMKfpdG+pTwUAAACIPfW9XH1PLzfpEvQr1DG7urpc86urq82bU39/v3j11VfFLbfcYs9LJpNiyZIlYseOHYGPScdSc+LECXP6r3/dXOpTAQAAAOD4nt7Q0CDKRVVVlWhtbS1Zv6K+vl5Mnz7dNU+mut5+++2ueUeOHBHpdFpMnjzZNV/eb2trC3w8OpaaqVOnin379onx48eLRCJh9/Rlo8j5EyZMKPUpooho63igneODto4H2jk+aOt4trOMVMpOpfyeXk5qampEe3u7GREsBfm8qf6MokcrC4mOpUaGfadNm+a5TL6w+U8sHmjreKCd44O2jgfaOT5o6/i1czlFKvXOpbyNZs3NzaKiokIcOnTINV/elxHXoCjeAwAAAAAxVVVVJebPny+2bdtmz8tkMub9RYsWBd4PEUsAAAAAiLH169eLlStXik984hNiwYIF4t577xU9PT1mldig6FgGIHOR5YWuxcxJxuhAW8cD7RwftHU80M7xQVvHA+0cvSuvvFIcPnxY3HbbbeLgwYPinHPOEU8//fSwgj7ZJIxyrdsLAAAAABgVuMYSAAAAABAKHUsAAAAAQCh0LAEAAAAAodCxBAAAAACEEruO5aZNm8QnP/lJMX78eDFp0iTx+c9/Xrz11luudXp7e8XatWvFaaedJurr68UXvvCFYQOG6mQNJFlFacqUKWLcuHFiyZIl4r///W+RHw2ibudVq1aJRCLhui1durTIjwZh2/oXv/iFWLx4sTnIsmyz48ePB9r35s2bxcyZM82BjRcuXCh27dpVpEeBUrXz7bffPuw9/eEPf7iIjwRh2/rYsWPi+uuvF3PmzDE/b2fMmCFuuOEG0dnZmXW/fE7Ho535nC7P/7+/+c1vig9+8INmW7e0tIjLLrtMtLW1Zd0v7+nRJ3YdyxdeeMHsTOzcuVM8++yzYmBgQFx88cXmOC3KunXrxJNPPikee+wxc/13331XrFixIut+77rrLvHTn/5U3H///eJvf/ubqKurE5dcconZecHYaWdJfkAdOHDAvj300ENFfjQI29YnT5402+373/9+4P0+8sgj5phOstz5a6+9JubNm2e+pzs6Oor0SFCKdpY+8pGPuN7TL730UhEeAQrV1vL/ann7yU9+It544w2xdetWsyT+N77xjaz75XM6Hu0s8Tldfv9/z58/X2zZskW8+eab4plnnjE7jXKddDrtu1/e06OQEXMdHR1yuBXjhRdeMO8fP37cSKVSxmOPPWav8+abb5rr7Nixw3MfmUzGaG1tNe6++257ntxPdXW18dBDD0XwKBBFO0srV640LrvsskjOGYVpa6ft27eby957772c+1mwYIGxdu1a+346nTamTp1qbNq0qeDnjNK184YNG4x58+YV6SxR7LZWHn30UaOqqsoYGBjwXM7ndDzaWeJzemy09T//+U9znT179ngu5z09OsUuYqlTKRVNTU3m9NVXXzV/SZHhdEWmRckUjB07dnjuo7293RxI1LlNQ0ODmTrntw3Kr52V559/3kzlkOk51157rTh69GiRzx5h2nok+vv7zdeI8/WRTCbN+7ynx047KzJ1aurUqeKMM84Q11xzjdi7d28BzhBRtrVcR6ZAV1ZWei7nczoe7azwOV3ebS0jmTJ6OWvWLDF9+nTPdXhPj06x7lhmMhnxne98R5x33nniox/9qDlPvkirqqpEY2Oja93Jkyeby7yo+XKdoNug/NpZpdc8+OCDYtu2beLHP/6xmd6xbNmyrKkaKG1bj8SRI0fMNuU9PbbbWZJfQlSK3X333Wd+Wfn0pz8tTpw4UbDzRXHbWr5f77zzTrFmzRrf/fA5HY92lvicLt+2/vnPf27WvJC3P/3pT2barPyu5oX39OiU/SefMU7me8u8fa6nGdsK2c5XXXWV/fdZZ50lzj77bPNic/nr6IUXXhh6/wiH93Q8FLKd5RdORb6fZUfz9NNPF48++miga7lQ2rbu6uoSn/vc58TcuXPNQkwoT4VsZz6ny7etZcbIRRddZF4XK6+tveKKK8TLL79sFtBDeYhtxPLb3/62eOqpp8T27dvFtGnT7Pmtra1mGpxeTVBWC5XLvKj5ekXRbNug/NrZi0yda25uFnv27CnoeaNwbT0Ssk0rKip4T4/xdvYisxg+9KEP8Z4ug7aWUWUZnZKVJv/whz+IVCrluy8+p+PRzl74nC6ftpaprLNnzxaf+cxnxO9+9zuzKqxscy+8p0en2HUsZZUp+cKWL9TnnnvOzN92klWp5H9aMoVCkSWR5TU3ixYt8tyn3Id8ETu3kb+uyQpVftug/NrZyzvvvGNeuyFLXWN0tvVIyNQb+Rpxvj5k+o68z3t67LSzl+7ubvH222/znh7lbS0/Y2XFSPlefeKJJ3JGNPicjkc7e+Fzujz//5bbyFtfX5/nct7To5QRM9dee63R0NBgPP/888aBAwfs28mTJ+11vvWtbxkzZswwnnvuOeOVV14xFi1aZN6c5syZY/z+97+37//oRz8yGhsbjT/+8Y/G66+/blYkmzVrlvH+++9H+vhQvHY+ceKEcdNNN5lVY9vb242//OUvxsc//nFj9uzZRm9vb+SPEcHbWt7/xz/+Yfzyl780q8y9+OKL5v2jR4/a61xwwQXGz372M/v+ww8/bFaX27p1q/Gf//zHWLNmjfkeP3jwYOSPEcVr5xtvvNHcp3xPv/zyy8aSJUuM5uZms2ohRmdbd3Z2GgsXLjTOOusss2Kkc53BwUF7P3xOx6+d+Zwuz7Z+++23jY0bN5rfxf73v/+Z/xcvX77caGpqMg4dOmTvh/f06Be7jqX8suF127Jli72OfEFed911xsSJE43a2lrj8ssvN98A+n6c28iyx7feeqsxefJk88vohRdeaLz11luRPjYUt53lf4AXX3yx0dLSYg5VcvrppxurV6+mo1EGbS2HlMi1jmxPuZ6T7IDIHx9keXs5/MjOnTsjfWwofjtfeeWVxpQpU8w2/sAHPmDe9ytvj9HR1mo4Ga+b7Ew498PndLzamc/p8mzr/fv3G8uWLTMmTZpkttu0adOMq6++2mhraxu2H97To1tC/lPqqCkAAAAAoHzF7hpLAAAAAEBh0bEEAAAAAIRCxxIAAAAAEAodSwAAAABAKHQsAQAAAACh0LEEAAAAAIRCxxIAAAAAEAodSwBA2UskEuLxxx/3XT5z5kxx7733RnpOAADECR1LAMCot2rVKrPzqN+WLl0aaPu///3vYs2aNUU/TwAA4qqy1CcAAEAQshO5ZcsW17zq6upA27a0tBTprAAAgETEEgBQFmQnsrW11XWbOHGi57obNmwQU6ZMEa+//rpnKqyMdv7qV78Sl19+uaitrRWzZ88WTzzxRGSPBQCAsYaOJQBgzDAMQ1x//fXiwQcfFH/961/F2Wef7bvuHXfcIa644gqz8/nZz35WXHPNNeLYsWORni8AAGMFHUsAQFl46qmnRH19veu2ceNGe/ng4KD4yle+IrZt2yZeeuklceaZZ+a8bvPLX/6yuZ7cT3d3t9i1a1cEjwQAgLGHaywBAGXh/PPPF/fdd59rXlNTk/33unXrzHTZnTt3iubm5pz7c0Yz6+rqxIQJE0RHR0eBzxoAgHggYgkAKAuy8yeji86bs2N50UUXif3794tnnnkm0P5SqZTrvrzuMpPJFPy8AQCIAyKWAIAx4dJLLxXLly8XV199taioqBBXXXVVqU8JAIDYoGMJACgLfX194uDBg655lZWVrrRXWeX1t7/9rfjqV79qLvviF79YgjMFACB+6FgCAMrC008/bQ4h4jRnzhzR1tbmmic7kzKlVXYuk8mkWLFiRcRnCgBA/CQMWZsdAAAAAIARongPAAAAACAUOpYAAAAAgFDoWAIAAAAAQqFjCQAAAAAIhY4lAAAAACAUOpYAAAAAgFDoWAIAAAAAQqFjCQAAAAAIhY4lAAAAACAUOpYAAAAAgFDoWAIAAAAAQqFjCQAAAAAQYfw/F5M8vA7cOEMAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 1200x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "fig,ax=plt.subplots(1,1,figsize=(12,8))\n",
+    "data2D_plot.plot(ax=ax, cmap='terrain')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
    "id": "fe4ced28",
    "metadata": {},
    "outputs": [
@@ -174,7 +281,7 @@
        "5"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -185,13 +292,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "8156e845",
    "metadata": {},
    "outputs": [],
    "source": [
     "\n",
-    "data='your data_array'\n",
+    "data=data\n",
     "data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)\n",
     "#the 2D plot data\n",
     "data2D_plot=data.isel({data.dims[2]:slice(0, 1)}).sum(dim=data.dims[2])   \n",
@@ -201,7 +308,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "5c78b3de",
    "metadata": {},
    "outputs": [
@@ -211,7 +318,8 @@
      "text": [
       "f0_A 68594891.74885073\n",
       "f0_x0 -0.04113953488371891\n",
-      "f0_gamma 0.2\n"
+      "f0_gamma 0.2\n",
+      "results extracted!\n"
      ]
     }
    ],
@@ -225,7 +333,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 15,
    "id": "fa77e9ea",
    "metadata": {},
    "outputs": [
@@ -235,7 +343,7 @@
        "5"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -253,6 +361,25 @@
     "5"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "87674cf1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "import xarray as xr\n",
+    "import numpy as np\n",
+    "\n",
+    "data_array = xr.DataArray(\n",
+    "    data=np.array([-0.06408675327381325, -0.063909542295367, -0.06371011897310751, -0.06503485241489142, -0.06674640906852701, -0.06805910712822637, -0.0673262244773315, -0.06791928154383757, -0.06794237706710785, -0.06664877554908763, -0.0652935335095996, -0.06504622348475712, -0.065035814834493, -0.0633718361899608, -0.063818909320266, -0.06232675039586483, -0.0621097230514767, -0.06305103749744877, -0.062396139421285524, -0.06241744208002782, -0.062120839236189614, -0.06176266979202111, -0.0630236363208958, -0.06278593213829542, -0.06303474668234264, -0.06426194448687265, -0.06597832379389597, -0.0675165514728734, -0.0681648104899741, -0.06789394642146951, -0.0682773450383019, -0.06821050673630791, -0.06812316809846124, -0.06794932731709455, -0.06727620917695594, -0.06688088523425127, -0.06681413040826198, -0.06555736923755218, -0.06565064400572977, -0.0646168556999122, -0.060782342905129925, -0.06230590290442724, -0.062307172077220564, -0.06460057558698659, -0.06627930899665781, -0.06544192791581478, -0.06468084127852305, -0.0644825518856323, -0.06423057418146402, -0.06252219575489999, -0.063163479851845, -0.06378012124599329, -0.06411224615179537, -0.06430960962767349, -0.06350623988348696, -0.06302572118934185, -0.06294101229235687, -0.06300268394088233, -0.06379463353897145, -0.06385408546578876, -0.06431904217520991, -0.06428783077386985, -0.06400554797596462, -0.0643282814344515, -0.06350550603083734, -0.06308239186415802, -0.06393654905327996, -0.06408506676353795, -0.06504035399665667, -0.06382432328214742, -0.06417442058913722, -0.06326170209225304, -0.06372611067357502, -0.06443451549183822, -0.06401162876760495, -0.06335447937775379, -0.06416821076582208, -0.06455746652083094, -0.06395384262610614, -0.06348368054215639, -0.06392145704513459, -0.06457859517607414]),\n",
+    "    dims=('delay',),\n",
+    "    coords={'delay': [-799.4466666666729, -499.65333333337486, -199.86000000002943, -99.93333333336332, -74.94666666668573, -49.96666666670534, -24.980000000027754, 0.0, 24.979999999980386, 49.96666666665798, 74.94666666663836, 99.93333333331596, 124.91333333329634, 149.8933333333241, 174.88000000000167, 199.85999999998208, 224.84666666665967, 249.82666666664005, 274.8066666666678, 299.79333333329805, 324.77333333332575, 349.76000000000334, 374.73999999998375, 399.71999999996416, 424.70666666664175, 449.6866666666695, 474.6733333332997, 499.65333333332745, 524.6399999999577, 549.6199999999855, 574.5999999999658, 599.5866666666434, 624.5666666666239, 649.5533333333013, 674.5333333333291, 699.5133333333096, 724.4999999999872, 749.4799999999675, 774.4666666666451, 799.4466666666254, 899.3799999999889, 999.3066666666549, 1099.239999999971, 1199.166666666637, 1299.1000000000004, 1399.0333333333162, 1498.9599999999823, 1598.8933333332984, 1698.8266666666616, 1798.7533333333279, 1898.6866666666438, 1998.6133333333098, 2098.5466666666257, 2198.479999999989, 2298.4066666666554, 2398.339999999971, 2498.2733333333344, 2598.2000000000007, 2698.1333333333164, 2798.0599999999827, 2897.993333333299, 2997.926666666662, 3097.853333333328, 3197.786666666644, 3297.7199999999602, 3397.646666666626, 3497.5799999999895, 3597.5066666666557, 3697.4399999999714, 3797.373333333335, 3897.300000000001, 3997.2333333333168, 4097.166666666633, 4197.093333333299, 4297.026666666662, 4396.953333333328, 4496.8866666666445, 4596.819999999961, 4696.746666666627, 4796.679999999989, 4896.6133333333055, 4996.539999999972]},\n",
+    "    name=\"f0_x0\"\n",
+    ")\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 4,
@@ -284,23 +411,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 3,
    "id": "2c6bc231",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x2547aabe120>]"
+       "[<matplotlib.lines.Line2D at 0x1ec49db33b0>]"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x800 with 1 Axes>"
       ]
@@ -318,7 +445,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 4,
    "id": "08f327a9",
    "metadata": {},
    "outputs": [
@@ -326,30 +453,99 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "f0_A -56591974.51984634\n",
-      "f0_x0 49.96666666665798\n",
-      "f0_gamma 0.2\n",
-      "f1_A -56591974.51984634\n",
+      "f0_A 0.0682773450383019\n",
+      "f0_omega 0.001\n",
+      "f0_phi 0\n",
+      "[[Model]]\n",
+      "    (Model(zero) + Model(sinusoid, prefix='f0_'))\n",
+      "[[Fit Statistics]]\n",
+      "    # fitting method   = leastsq\n",
+      "    # function evals   = 33\n",
+      "    # data points      = 59\n",
+      "    # variables        = 3\n",
+      "    chi-square         = 2.2764e-04\n",
+      "    reduced chi-square = 4.0650e-06\n",
+      "    Akaike info crit   = -729.451273\n",
+      "    Bayesian info crit = -723.218661\n",
+      "    R-squared          = 0.08350621\n",
+      "[[Variables]]\n",
+      "    f0_A:      0.06587170 +/- 0.00530377 (8.05%) (init = 0.06827735)\n",
+      "    f0_omega:  5.3119e-05 +/- 1.1647e-04 (219.26%) (init = 0.001)\n",
+      "    f0_phi:    1.70061631 +/- 0.57659252 (33.90%) (init = 0)\n",
+      "[[Correlations]] (unreported correlations are < 0.250)\n",
+      "    C(f0_A, f0_phi)     = +0.9978\n",
+      "    C(f0_omega, f0_phi) = -0.9888\n",
+      "    C(f0_A, f0_omega)   = -0.9804\n",
+      "f0_A 0.0682773450383019\n",
+      "f0_omega 1\n",
+      "f0_phi 0\n",
+      "[[Model]]\n",
+      "    (Model(zero) + Model(sinusoid, prefix='f0_'))\n",
+      "[[Fit Statistics]]\n",
+      "    # fitting method   = leastsq\n",
+      "    # function evals   = 110\n",
+      "    # data points      = 44\n",
+      "    # variables        = 3\n",
+      "    chi-square         = 0.11362185\n",
+      "    reduced chi-square = 0.00277126\n",
+      "    Akaike info crit   = -256.199040\n",
+      "    Bayesian info crit = -250.846471\n",
+      "    R-squared          = -599.468641\n",
+      "[[Variables]]\n",
+      "    f0_A:     -0.05410532 +/- 0.01095403 (20.25%) (init = 0.06827735)\n",
+      "    f0_omega:  1.00207580 +/- 3.5692e-04 (0.04%) (init = 1)\n",
+      "    f0_phi:    0.17032802 +/- 0.37060122 (217.58%) (init = 0)\n",
+      "[[Correlations]] (unreported correlations are < 0.250)\n",
+      "    C(f0_omega, f0_phi) = -0.8100\n",
+      "f0_A 0.0682773450383019\n",
+      "f0_omega 1\n",
+      "f0_phi 0\n",
+      "f0_A 0.0682773450383019\n",
+      "f0_omega 1\n",
+      "f0_phi 0\n",
+      "f1_A 0.0682773450383019\n",
+      "[[Model]]\n",
+      "    ((Model(zero) + Model(sinusoid, prefix='f0_')) + Model(constant, prefix='f1_'))\n",
+      "[[Fit Statistics]]\n",
+      "    # fitting method   = leastsq\n",
+      "    # function evals   = 152\n",
+      "    # data points      = 44\n",
+      "    # variables        = 4\n",
+      "    chi-square         = 5.7932e-05\n",
+      "    reduced chi-square = 1.4483e-06\n",
+      "    Akaike info crit   = -587.778608\n",
+      "    Bayesian info crit = -580.641849\n",
+      "    R-squared          = 0.69383876\n",
+      "[[Variables]]\n",
+      "    f0_A:      0.00244399 +/- 2.5720e-04 (10.52%) (init = 0.06827735)\n",
+      "    f0_omega:  0.99739845 +/- 1.6175e-04 (0.02%) (init = 1)\n",
+      "    f0_phi:    0.73122050 +/- 0.17476307 (23.90%) (init = 0)\n",
+      "    f1_A:      0.06459993 +/- 1.8170e-04 (0.28%) (init = 0.06827735)\n",
+      "[[Correlations]] (unreported correlations are < 0.250)\n",
+      "    C(f0_omega, f0_phi) = -0.7996\n",
+      "f0_A 0.0682773450383019\n",
+      "f0_omega 1\n",
+      "f0_phi 0\n",
+      "f1_A 0.0682773450383019\n",
       "[[Model]]\n",
-      "    ((Model(zero) + Model(lorentzian, prefix='f0_')) + Model(constant, prefix='f1_'))\n",
+      "    ((Model(zero) + Model(sinusoid, prefix='f0_')) + Model(constant, prefix='f1_'))\n",
       "[[Fit Statistics]]\n",
       "    # fitting method   = leastsq\n",
-      "    # function evals   = 138\n",
-      "    # data points      = 25\n",
+      "    # function evals   = 152\n",
+      "    # data points      = 44\n",
       "    # variables        = 4\n",
-      "    chi-square         = 1.0446e+14\n",
-      "    reduced chi-square = 4.9745e+12\n",
-      "    Akaike info crit   = 734.524718\n",
-      "    Bayesian info crit = 739.400221\n",
-      "    R-squared          = 0.80970692\n",
+      "    chi-square         = 5.7932e-05\n",
+      "    reduced chi-square = 1.4483e-06\n",
+      "    Akaike info crit   = -587.778608\n",
+      "    Bayesian info crit = -580.641849\n",
+      "    R-squared          = 0.69383876\n",
       "[[Variables]]\n",
-      "    f0_A:      13829756.4 +/- 1465794.12 (10.60%) (init = -5.659197e+07)\n",
-      "    f0_x0:     70.3869880 +/- 9.39332978 (13.35%) (init = 49.96667)\n",
-      "    f0_gamma:  103.001516 +/- 22.4624155 (21.81%) (init = 0.2)\n",
-      "    f1_A:     -70018457.3 +/- 1151952.86 (1.65%) (init = -5.659197e+07)\n",
+      "    f0_A:      0.00244399 +/- 2.5720e-04 (10.52%) (init = 0.06827735)\n",
+      "    f0_omega:  0.99739845 +/- 1.6175e-04 (0.02%) (init = 1)\n",
+      "    f0_phi:    0.73122050 +/- 0.17476307 (23.90%) (init = 0)\n",
+      "    f1_A:      0.06459993 +/- 1.8170e-04 (0.28%) (init = 0.06827735)\n",
       "[[Correlations]] (unreported correlations are < 0.250)\n",
-      "    C(f0_gamma, f1_A) = -0.7681\n",
-      "    C(f0_A, f1_A)     = -0.5074\n"
+      "    C(f0_omega, f0_phi) = -0.7996\n"
      ]
     }
    ],

From 917bd76c7eac678b8bf0e5e91f20a8c6a7952e41 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 16:05:42 +0200
Subject: [PATCH 54/67] added the nxarray that I mistakenly didnt merge earlier

---
 pyproject.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pyproject.toml b/pyproject.toml
index d55aead..cb70849 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -35,6 +35,7 @@ dependencies = [
     "numpy>=1.26.1,<2.0",
     "PyQt5>=5.0.0",
     "xarray>=0.20.2",
+    "nxarray>=0.4.4",
    "superqt >=0.3.0",
 ]
 

From 572a4dfd85609c6f7a2b7209a9fda9b7ce8c40b1 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 16:41:33 +0200
Subject: [PATCH 55/67] fixed a bug with the cursors for the fit

---
 src/mpes_tools/fit_panel.py                      | 3 +--
 src/mpes_tools/movable_vertical_cursors_graph.py | 5 -----
 2 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/mpes_tools/fit_panel.py b/src/mpes_tools/fit_panel.py
index f0e3d2c..000142d 100644
--- a/src/mpes_tools/fit_panel.py
+++ b/src/mpes_tools/fit_panel.py
@@ -824,11 +824,10 @@ def zero(x):
                 self.fit_results.append(getattr(self, pname))
                 self.fit_results_err.append(getattr(self, f"{pname}_err"))
                 names.append(pname)
-        # print('th dt',self.dt)    
-        # print('the xaxis',len(self.data[self.data.dims[1]][:len(self.data[self.data.dims[1]])-self.dt]))
         sg=showgraphs(self.data[self.data.dims[1]][:len(self.data[self.data.dims[1]])-self.dt], self.fit_results,self.fit_results_err,names,list_axis,list_plot_fits)
         sg.show()
         self.graph_windows.append(sg)
+        self.cursor_handler.redraw()
 
 if __name__ == "__main__":
     app = QApplication(sys.argv)
diff --git a/src/mpes_tools/movable_vertical_cursors_graph.py b/src/mpes_tools/movable_vertical_cursors_graph.py
index 44dcbf9..74cb907 100644
--- a/src/mpes_tools/movable_vertical_cursors_graph.py
+++ b/src/mpes_tools/movable_vertical_cursors_graph.py
@@ -39,8 +39,6 @@ def on_motion(self,event):
             elif self.active_cursor == self.Line2:
                 self.Line2.set_xdata([event.xdata, event.xdata])
                 self.cursorlinev2= event.xdata
-            # print(dot1.center) 
-            # print(self.cursorlinev1,self.cursorlinev2)
             self.ax.figure.canvas.draw()
             plt.draw()
             def find_nearest_index(array, value):
@@ -58,14 +56,11 @@ def remove(self):
         self.cursorlinev2= self.Line2.get_xdata()[0]
         self.Line1.remove()
         self.Line2.remove()
-        # plt.draw()
         self.ax.figure.canvas.draw()
-        
     def redraw(self):
         # print(self.cursorlinev1,self.cursorlinev2)
         self.Line1=self.ax.axvline(x=self.cursorlinev1, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
         self.Line2=self.ax.axvline(x=self.cursorlinev2, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
-        # plt.draw()
         self.ax.figure.canvas.draw()
     def cursors(self):
         return [self.v1_pixel,self.v2_pixel]        
\ No newline at end of file

From 70d4d9fc1152be16984249c3062cc7830cc7b8bb Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Fri, 25 Apr 2025 16:51:25 +0200
Subject: [PATCH 56/67] fixed a bug with leaving a touched cell in the table
 empty

---
 src/mpes_tools/make_model.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/mpes_tools/make_model.py b/src/mpes_tools/make_model.py
index c88353b..d13d969 100644
--- a/src/mpes_tools/make_model.py
+++ b/src/mpes_tools/make_model.py
@@ -19,35 +19,35 @@ def __init__(self,mod,table_widget):
                 print(header_item.text(),item.text())
                 if header_item.text()== "Fermi level":
                     self.params['mu'].set(value=float(item.text()))
-                    if table_widget.item(row, 0) is not None:
+                    if table_widget.item(row, 0) is not None and table_widget.item(row, 0).text().strip():
                         self.params['mu'].set(min=float(table_widget.item(row, 0).text()))
-                    if table_widget.item(row, 2) is not None:
+                    if table_widget.item(row, 2) is not None and table_widget.item(row, 2).text().strip():
                         self.params['mu'].set(max=float(table_widget.item(row, 2).text()))
                     if checkbox.isChecked():
                         self.params['mu'].vary = False
                         
                 elif header_item.text()== "Temperature":
                     self.params['T'].set(value=float(item.text()))
-                    if table_widget.item(row, 0) is not None:
+                    if table_widget.item(row, 0) is not None and table_widget.item(row, 0).text().strip():
                         self.params['T'].set(min=float(table_widget.item(row, 0).text()))
-                    if table_widget.item(row, 2) is not None:
+                    if table_widget.item(row, 2) is not None and table_widget.item(row, 2).text().strip():
                         self.params['T'].set(max=float(table_widget.item(row, 2).text()))
                     if checkbox.isChecked():
                         self.params['T'].vary = False
                 elif header_item.text()== "sigma":
                     self.params['sigma'].set(value=float(item.text()))
                     self.params['sigma'].set(min=0)
-                    if table_widget.item(row, 0) is not None:
+                    if table_widget.item(row, 0) is not None and table_widget.item(row, 0).text().strip():
                         self.params['sigma'].set(min=float(table_widget.item(row, 0).text()))
-                    if table_widget.item(row, 2) is not None:
+                    if table_widget.item(row, 2) is not None and table_widget.item(row, 2).text().strip():
                         self.params['sigma'].set(max=float(table_widget.item(row, 2).text()))
                     if checkbox.isChecked():
                         self.params['sigma'].vary = False
                 else:
                     self.params[header_item.text()].set(value=float(item.text()))
-                    if table_widget.item(row, 0) is not None:
+                    if table_widget.item(row, 0) is not None and table_widget.item(row, 0).text().strip():
                         self.params[header_item.text()].set(min=float(table_widget.item(row, 0).text()))
-                    if table_widget.item(row, 2) is not None:
+                    if table_widget.item(row, 2) is not None and table_widget.item(row, 2).text().strip():
                         self.params[header_item.text()].set(max=float(table_widget.item(row, 2).text()))
                     if checkbox.isChecked():
                         self.params[header_item.text()].vary = False

From 96d888b9ea750463a0af5234daca9bffcfbb0df7 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 6 May 2025 14:08:19 +0200
Subject: [PATCH 57/67] fixed changes suggested in the pull request

---
 src/mpes_tools/Gui_3d.py | 53 +++++++++++++++++-----------------------
 1 file changed, 23 insertions(+), 30 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index b1a3ee4..9002e96 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -11,7 +11,6 @@
 from mpes_tools.fit_panel import fit_panel
 from mpes_tools.fit_panel_single import fit_panel_single
 from IPython.core.getipython import get_ipython
-from mpes_tools.double_click_handler import SubplotClickHandler
 import xarray as xr
 from mpes_tools.right_click_handler import RightClickHandler
 from PyQt5.QtWidgets import QMenu,QGridLayout,QHBoxLayout, QSizePolicy,QLabel
@@ -23,7 +22,7 @@
 #graphic window showing a 2d map controllable with sliders for the third dimension, with cursors showing cuts along the x direction for MDC and y direction for EDC
 # Two vertical cursors and two horizontal cursors are defined in the main graph with each same color for the cursors being horizontal and vertical intercept each other in a dot so one can move either each cursor or the dot itself which will move both cursors. 
 class Gui_3d(QMainWindow):  
-    def __init__(self,data_array: xr.DataArray,t,dt,technique):
+    def __init__(self,data_array: xr.DataArray,t=None,dt=None):
         super().__init__()
 
         self.setWindowTitle("Graph Window")
@@ -118,23 +117,23 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
             handler = RightClickHandler(self.canvases[idx], ax,self.show_pupup_window)
             self.canvases[idx].mpl_connect("button_press_event", handler.on_right_click)
             self.handler_list.append(handler)
-        
 
 
         #define the data_array
         self.data=data_array
         self.axis=[data_array.coords[dim].data for dim in data_array.dims]
-        if technique == 'Phoibos':
-            self.axis[1]=self.axis[1]-21.7
-            self.data = self.data.assign_coords(Ekin=self.data.coords['Ekin'] -21.7)
 
+        
+        if t is not None and dt is not None:
+            self.t=t
+            self.dt=dt
+        else:
+            self.t=0
+            self.dt=0
         # define the cut for the spectra of the main graph
-        # self.data2D_plot=self.data.isel({self.data.dims[2]:slice(t, t+dt+1)}).mean(dim=self.data.dims[2])
-        self.data2D_plot=self.data.sel({self.data.dims[2]:slice(self.axis[2][t], self.axis[2][t + dt])}).mean(dim=self.data.dims[2])
+        self.data2D_plot=self.data.sel({self.data.dims[2]:slice(self.axis[2][self.t], self.axis[2][self.t + self.dt])}).mean(dim=self.data.dims[2])
         
         #Initialize the relevant prameters
-        self.t=t
-        self.dt=dt
         self.active_cursor = None
         self.Line1=None
         self.Line2=None
@@ -147,34 +146,33 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         
         # sliders for the delay
         self.slider1.setRange(0,len(self.axis[2])-1)
-        self.slider1_label.setText(self.data.dims[2]+": 0")
-        self.slider2_label.setText("Δ"+self.data.dims[2]+": 0")
-        
+        self.slider1.setValue(self.t)
+        self.slider2.setValue(self.dt)
+        self.slider1_label.setText(self.data.dims[2]+ f": {self.data[self.data.dims[2]][self.t].item():.2f}")
+        self.slider2_label.setText("Δ"+self.data.dims[2]+f": {self.dt}")
+    
         self.slider1.valueChanged.connect(self.slider1_changed)
         self.slider2.valueChanged.connect(self.slider2_changed)
         
         
         #create a menu for the fit panel
         menu_bar = self.menuBar()
-        graph_menu1 = menu_bar.addMenu("Fit Panel")
+        fit_menu = menu_bar.addMenu("Fit Panel")
         
         energy_panel_action = QAction('EDC',self)
         energy_panel_action.triggered.connect(self.fit_energy_panel)
-        graph_menu1.addAction(energy_panel_action)
+        fit_menu.addAction(energy_panel_action)
         
         momentum_panel_action = QAction('MDC',self)
         momentum_panel_action.triggered.connect(self.fit_momentum_panel)
-        graph_menu1.addAction(momentum_panel_action)
+        fit_menu.addAction(momentum_panel_action)
         
         box_panel_action = QAction('box',self)
         box_panel_action.triggered.connect(self.fit_box_panel)
-        graph_menu1.addAction(box_panel_action)
-        
+        fit_menu.addAction(box_panel_action)
         
         self.graph_windows=[]
         
-        print(data_array.dims)
-        
         # plot the main graph
         self.im = self.data2D_plot.plot(ax=self.axes[0], cmap='terrain', add_colorbar=False)
         self.axes[0].figure.colorbar(self.im, ax=self.axes[0])
@@ -182,10 +180,10 @@ def __init__(self,data_array: xr.DataArray,t,dt,technique):
         
         # define the initial positions of the cursors in the main graph
         
-        initial_x = 0
-        initial_y = 0
-        initial_x2 = 0.5
-        initial_y2 = 0.5
+        initial_x = self.data[self.data.dims[1]].values[int(len(self.data[self.data.dims[1]])/3)]
+        initial_y = self.data[self.data.dims[0]].values[int(len(self.data[self.data.dims[0]])/3)]
+        initial_x2 = self.data[self.data.dims[1]].values[int(2*len(self.data[self.data.dims[1]])/3)]
+        initial_y2 = self.data[self.data.dims[0]].values[int(2*len(self.data[self.data.dims[0]])/3)]
         ax = self.axes[0]
         # define the lines for the cursors
         ymin, ymax = self.axes[0].get_ylim()
@@ -421,12 +419,7 @@ def main_graph_cursor_changed(self, index): #set manually the values for the cur
             self.cursor_label[3].setText(f"{base}: {value:.2f}")
         # self.change_pixel_to_arrayslot()
         self.update_show()
-        try:
-            num = float(value)
-            # print(f"Cursor {index+1} changed to: {num}")
-            # Update graph logic here
-        except ValueError:
-            print("Invalid input!")
+
         
     def slider1_changed(self,value): # change the slider controlling the third dimension
         # self.slider1_label.setText(str(value))

From 936dee1e8a8eb2abad887e250bd2de6f2c8a24a2 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 6 May 2025 14:08:54 +0200
Subject: [PATCH 58/67] changed the call for Gui_3d

---
 src/mpes_tools/Main.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/mpes_tools/Main.py b/src/mpes_tools/Main.py
index 30f078e..e9229a1 100644
--- a/src/mpes_tools/Main.py
+++ b/src/mpes_tools/Main.py
@@ -88,7 +88,8 @@ def open_file_phoibos(self):
                 V1=V1[list(V1.data_vars)[0]]
 
         axis=[V1['Angle'],V1['Ekin']-21.7,V1['delay']]
-        graph_window= Gui_3d(V1,0,0,'Phoibos')
+        V1 = V1.assign_coords(Ekin=V1.coords['Ekin'] -21.7)
+        graph_window= Gui_3d(V1)
         graph_window.show()
         self.graph_windows.append(graph_window)
 

From 762f71f5a121f853c74610669bda8d778508a278 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 6 May 2025 14:09:15 +0200
Subject: [PATCH 59/67] took out old imports

---
 src/mpes_tools/graphs.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/mpes_tools/graphs.py b/src/mpes_tools/graphs.py
index 8a75c41..40dd213 100644
--- a/src/mpes_tools/graphs.py
+++ b/src/mpes_tools/graphs.py
@@ -5,7 +5,6 @@
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 import matplotlib.pyplot as plt
 from IPython.core.getipython import get_ipython
-from mpes_tools.double_click_handler import SubplotClickHandler
 from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
 import xarray as xr
 from mpes_tools.right_click_handler import RightClickHandler

From 8ff652e2beb7080f1289e88269213de8586c824f Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 6 May 2025 14:09:43 +0200
Subject: [PATCH 60/67] took out old imports and the external call

---
 src/mpes_tools/show_4d_window.py | 88 ++------------------------------
 1 file changed, 4 insertions(+), 84 deletions(-)

diff --git a/src/mpes_tools/show_4d_window.py b/src/mpes_tools/show_4d_window.py
index 46ba815..47dbb8a 100644
--- a/src/mpes_tools/show_4d_window.py
+++ b/src/mpes_tools/show_4d_window.py
@@ -9,7 +9,6 @@
 import xarray as xr
 from mpes_tools.hdf5 import load_h5
 from IPython.core.getipython import get_ipython
-from mpes_tools.double_click_handler import SubplotClickHandler
 from mpes_tools.right_click_handler import RightClickHandler
 from PyQt5.QtWidgets import QMenu
 from PyQt5.QtGui import QCursor
@@ -219,92 +218,13 @@ def show_pupup_window(self,canvas,ax):
     '{self.axes[0]}': slice({self.data_array[self.axes[0]][self.slider3[3].value()].item()}, {self.data_array[self.axes[0]][self.slider3[3].value() + self.slider4[3].value()].item()})
 }}].mean(dim=('{self.axes[1]}', '{self.axes[0]}')) 
 """)
-    def external_callback(self, ax):
-        # print(f"External callback: clicked subplot ({i},{j})")
-        if ax==self.graphs[0].gca():
-            content= f"""
-data='your data_array'
-#the energy plot
-data.loc[
-    {{
-        '{self.axes[2]}': slice(
-            {self.data_array[self.axes[2]][self.slider1[0].value()].item()},
-            {self.data_array[self.axes[2]][self.slider1[0].value() + self.slider2[0].value()].item()}
-        ),
-        '{self.axes[3]}': slice(
-            {self.data_array[self.axes[3]][self.slider3[0].value()].item()},
-            {self.data_array[self.axes[3]][self.slider3[0].value() + self.slider4[0].value()].item()}
-        )
-    }}
-].mean(dim=('{self.axes[2]}', '{self.axes[3]}')).T
-
-            """
-        elif ax==self.graphs[1].gca():
-            content= f"""
-data='your data_array'
-#the ky plot
-data.loc[
-    {{
-        '{self.axes[1]}': slice(
-            {self.data_array[self.axes[1]][self.slider1[1].value()].item()},
-            {self.data_array[self.axes[1]][self.slider1[1].value() + self.slider2[1].value()].item()}
-        ),
-        '{self.axes[3]}': slice(
-            {self.data_array[self.axes[3]][self.slider3[1].value()].item()},
-            {self.data_array[self.axes[3]][self.slider3[1].value() + self.slider4[1].value()].item()}
-        )
-    }}
-].mean(dim=('{self.axes[1]}', '{self.axes[3]}')).T
-            """
-        elif ax==self.axis_list[2]:
-            content= f"""
-data='your data_array'
-#the kx plot
-data.loc[
-    {{
-        '{self.axes[0]}': slice(
-            {self.data_array[self.axes[0]][self.slider1[2].value()].item()},
-            {self.data_array[self.axes[0]][self.slider1[2].value() + self.slider2[2].value()].item()}
-        ),
-        '{self.axes[3]}': slice(
-            {self.data_array[self.axes[3]][self.slider3[2].value()].item()},
-            {self.data_array[self.axes[3]][self.slider3[2].value() + self.slider4[2].value()].item()}
-        )
-    }}
-].mean(dim=('{self.axes[0]}', '{self.axes[3]}')).T
-            """
-        elif ax==self.axis_list[3]:
-            content= f"""
-data='your data_array'
-#the kx,ky plot
-data.loc[
-    {{
-        '{self.axes[1]}': slice(
-            {self.data_array[self.axes[1]][self.slider1[3].value()].item()},
-            {self.data_array[self.axes[1]][self.slider1[3].value() + self.slider2[3].value()].item()}
-        ),
-        '{self.axes[0]}': slice(
-            {self.data_array[self.axes[0]][self.slider3[3].value()].item()},
-            {self.data_array[self.axes[0]][self.slider3[3].value()+ self.slider4[3].value()].item()}
-        )
-    }}
-].mean(dim=('{self.axes[1]}', '{self.axes[0]}'))
-            """
-        shell = get_ipython()
-        payload = dict(
-            source='set_next_input',
-            text=content,
-            replace=False,
-        )
-        shell.payload_manager.write_payload(payload, single=False)
-        shell.run_cell('pass')
-        print('results extracted!')
+    
 
     def open_graph_kxkydt(self):
         E1=self.data_array[self.axes[2]][self.slider1[0].value()].item()
         E2=self.data_array[self.axes[2]][self.slider1[0].value()+self.slider2[0].value()+1].item()
         data_kxkydt = self.data_array.loc[{self.axes[2]:slice(E1,E2)}].mean(dim=(self.axes[2]))
-        graph_window=Gui_3d(data_kxkydt, self.slider3[0].value(), self.slider4[0].value(),'METIS')
+        graph_window=Gui_3d(data_kxkydt, self.slider3[0].value(), self.slider4[0].value())
         # Show the graph window
         graph_window.show()
         self.graph_windows.append(graph_window)
@@ -313,7 +233,7 @@ def open_graph_kxedt(self):
         ky1=self.data_array[self.axes[1]][self.slider1[1].value()].item()
         ky2=self.data_array[self.axes[1]][self.slider1[1].value()+self.slider2[1].value()+1].item()
         data_kxedt = self.data_array.loc[{self.axes[1]:slice(ky1,ky2)}].mean(dim=(self.axes[1]))
-        graph_window = Gui_3d(data_kxedt, self.slider3[1].value(), self.slider4[1].value(),'METIS')
+        graph_window = Gui_3d(data_kxedt, self.slider3[1].value(), self.slider4[1].value())
         # Show the graph window
         graph_window.show()
         self.graph_windows.append(graph_window)
@@ -322,7 +242,7 @@ def open_graph_kyedt(self):
         kx1=self.data_array[self.axes[0]][self.slider1[2].value()].item()
         kx2=self.data_array[self.axes[0]][self.slider1[2].value()+self.slider2[2].value()+1].item()
         data_kyedt = self.data_array.loc[{self.axes[0]:slice(kx1,kx2)}].mean(dim=(self.axes[0]))
-        graph_window = Gui_3d(data_kyedt, self.slider3[2].value(), self.slider4[2].value(),'METIS')
+        graph_window = Gui_3d(data_kyedt, self.slider3[2].value(), self.slider4[2].value())
         # Show the graph window
         
         graph_window.show()

From 7f767359b395ba14c79d91b11925813b78df79cb Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 6 May 2025 14:11:14 +0200
Subject: [PATCH 61/67] deleted unnecessary or unfinished files

---
 src/mpes_tools/Drawwindow.py            | 173 ------
 src/mpes_tools/call_gui.py              |  14 -
 src/mpes_tools/color_scale.py           |  44 --
 src/mpes_tools/double_click_handler.py  |  12 -
 src/mpes_tools/h5toxarray.py            |  55 --
 src/mpes_tools/k_path_4d_4.py           | 422 --------------
 tests/Arpes_gui.py                      | 392 -------------
 tests/Drawwindow.py                     | 173 ------
 tests/additional_window.py              | 473 ----------------
 tests/color_scale.py                    |  44 --
 tests/fit_panel6.py                     | 701 ------------------------
 tests/fit_panel_signle_test.py          | 577 -------------------
 tests/graphs2.py                        |  80 ---
 tests/h5toxarray.py                     |  55 --
 tests/k_path_4d_4.py                    | 422 --------------
 tests/movable_vertical_cursors_graph.py |  77 ---
 16 files changed, 3714 deletions(-)
 delete mode 100644 src/mpes_tools/Drawwindow.py
 delete mode 100644 src/mpes_tools/call_gui.py
 delete mode 100644 src/mpes_tools/color_scale.py
 delete mode 100644 src/mpes_tools/double_click_handler.py
 delete mode 100644 src/mpes_tools/h5toxarray.py
 delete mode 100644 src/mpes_tools/k_path_4d_4.py
 delete mode 100644 tests/Arpes_gui.py
 delete mode 100644 tests/Drawwindow.py
 delete mode 100644 tests/additional_window.py
 delete mode 100644 tests/color_scale.py
 delete mode 100644 tests/fit_panel6.py
 delete mode 100644 tests/fit_panel_signle_test.py
 delete mode 100644 tests/graphs2.py
 delete mode 100644 tests/h5toxarray.py
 delete mode 100644 tests/k_path_4d_4.py
 delete mode 100644 tests/movable_vertical_cursors_graph.py

diff --git a/src/mpes_tools/Drawwindow.py b/src/mpes_tools/Drawwindow.py
deleted file mode 100644
index f97c770..0000000
--- a/src/mpes_tools/Drawwindow.py
+++ /dev/null
@@ -1,173 +0,0 @@
-import sys
-import numpy as np
-import matplotlib.pyplot as plt
-from PyQt5.QtCore import Qt
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
-from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QTextEdit, \
-    QHBoxLayout, QSizePolicy,QSlider,QLabel
-# from k_path_4d_4 import drawKpath
-
-class DrawWindow(QMainWindow):
-    def __init__(self,data,s1,s2,s3,s4):
-        super().__init__()
-
-        # Set the title and size of the main window
-        self.setWindowTitle("PyQt5 Matplotlib Example")
-        self.setGeometry(100, 100, 800, 600)
-        self.data_array=data
-        print(data['E'][0])
-        # Create the main layout
-        main_layout = QVBoxLayout()
-
-        # Create a widget to hold the layout
-        widget = QWidget()
-        widget.setLayout(main_layout)
-        self.setCentralWidget(widget)
-
-        # Create a horizontal layout for the top row
-        top_row_layout = QHBoxLayout()
-
-
-        # Create top left graph
-        self.figure1, self.axis1 = plt.subplots()
-        self.canvas1 = FigureCanvas(self.figure1)
-        top_row_layout.addWidget(self.canvas1)
-
-        # Create bottom right graph
-        self.figure2, self.axis2 = plt.subplots()
-        self.canvas2 = FigureCanvas(self.figure2)
-        top_row_layout.addWidget(self.canvas2)
-        
-        layout = QVBoxLayout()
-        
-        slider_layout= QHBoxLayout()
-        self.slider1 = QSlider(Qt.Horizontal)
-        self.slider1.setRange(0, len(data['E'].data))
-        self.slider1.setValue(s1)
-        self.slider1_label = QLabel("0")
-        
-        self.slider2 = QSlider(Qt.Horizontal)
-        self.slider2.setRange(0, 10)
-        self.slider2.setValue(s2)
-        self.slider2_label = QLabel("0")
-        
-        self.slider1.setFixedSize(200, 12)  # Change the width and height as needed
-        self.slider2.setFixedSize(200, 12)  # Change the width and height as needed
-        
-        slider_layout.addWidget(self.slider1)
-        slider_layout.addWidget(self.slider1_label)
-        slider_layout.addWidget(self.slider2)
-        slider_layout.addWidget(self.slider2_label)
-        # layout.addLayout(slider_layout)
-        slider_layout2= QHBoxLayout()
-        self.slider3 = QSlider(Qt.Horizontal)
-        self.slider3.setRange(0, 100)
-        self.slider3.setValue(s3)
-        self.slider3_label = QLabel("0")
-        
-        self.slider4 = QSlider(Qt.Horizontal)
-        self.slider4.setRange(0, 10)
-        self.slider4.setValue(s4)
-        self.slider4_label = QLabel("0")
-        
-        self.slider3.setFixedSize(200, 12)  # Change the width and height as needed
-        self.slider4.setFixedSize(200, 12)  # Change the width and height as needed
-        
-        slider_layout2.addWidget(self.slider3)
-        slider_layout2.addWidget(self.slider3_label)
-        slider_layout2.addWidget(self.slider4)
-        slider_layout2.addWidget(self.slider4_label)
-        
-        # layout.addLayout(slider_layout2)
-        
-        self.slider1.valueChanged.connect(self.slider1_changed)
-        self.slider2.valueChanged.connect(self.slider2_changed)
-        self.slider3.valueChanged.connect(self.slider3_changed)
-        self.slider4.valueChanged.connect(self.slider4_changed)
-        
-
-        main_layout.addLayout(top_row_layout)
-        main_layout.addLayout(slider_layout)
-        main_layout.addLayout(slider_layout2)
-        
-
-        # Set size policy for the graph widgets
-        self.canvas1.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-        self.canvas2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-        
-        self.update_energy(s1, s2, s3, s4)
-        # self.d=drawKpath(data, axis, fig, ax, ax2, linewidth, slider, N)
-
-        # Plot data
-        # self.plot_graphs()
-        # self.update_text_edit_boxes()
-        
-    def slider1_changed(self,value):
-        self.slider1_label.setText(str(value))
-        print(value)
-        self.update_energy(self.slider1.value(),self.slider2.value() , self.slider3.value(), self.slider4.value())
-    def slider2_changed(self,value):
-        self.slider2_label.setText(str(value))
-        self.update_energy(self.slider1.value(),self.slider2.value() , self.slider3.value(), self.slider4.value())
-    def slider3_changed(self,value):
-        self.slider3_label.setText(str(value))
-        self.update_energy(self.slider1.value(),self.slider2.value() , self.slider3.value(), self.slider4.value())
-    def slider4_changed(self,value):
-        self.slider4_label.setText(str(value))
-        # self.plot_graph(self.slider1.value(),self.slider2.value())
-        # print(self.slider1.value(),self.slider2.value())
-        # self.update_show(self.slider1.value(),self.slider2.value())
-        self.update_energy(self.slider1.value(),self.slider2.value() , self.slider3.value(), self.slider4.value())
-        
-    def update_energy(self,Energy,dE,te,dte):
-        
-        # self.ce_state=True
-        E1=self.data_array['E'][Energy].item()
-        # print(Energy,E1)
-        E2=self.data_array['E'][Energy+dE].item()
-        te1=self.data_array['dt'][te].item()
-        te2=self.data_array['dt'][te+dte].item()
-        # print(E1,E2,te1)
-        self.figure1.clear()
-        ax = self.figure1.add_subplot(111)  # Recreate the axis on the figure
-        self.im=self.data_array.sel(E=slice(E1,E2), dt=slice(te1,te2)).mean(dim=("E", "dt")).plot(ax=ax)
-        # ax.set_title('Loaded Data')
-        ax.set_xlabel('X')
-        ax.set_ylabel('Y')
-        # self.graphs[0].tight_layout()
-        self.figure1.canvas.draw()
-        # self.ev = self.graphs[0].gca().axvline(x=self.axis[0][self.slider1[1].value()], color='r', linestyle='--')
-        # self.eh = self.graphs[0].gca().axhline(y=self.axis[1][self.slider1[2].value()], color='r', linestyle='--')
-        
-
-    def plot_graphs(self):
-        # Plot on the top left graph
-        x1 = np.linspace(0, 10, 100)
-        y1 = np.sin(x1)
-        self.axis1.plot(x1, y1)
-        self.axis1.set_title('Top Left Graph')
-        self.axis1.set_xlabel('X')
-        self.axis1.set_ylabel('Y')
-
-        # Plot on the bottom right graph
-        x2 = np.linspace(0, 10, 100)
-        y2 = np.cos(x2)
-        self.axis2.plot(x2, y2)
-        self.axis2.set_title('Bottom Right Graph')
-        self.axis2.set_xlabel('X')
-        self.axis2.set_ylabel('Y')
-
-        # Update the canvas
-        self.canvas1.draw()
-        self.canvas2.draw()
-
-    # def update_text_edit_boxes(self):
-    #     # self.text_edit_top_right.setPlaceholderText("Top Right Text Edit Box")
-    #     self.text_edit_bottom_left.setPlaceholderText("Bottom Left Text Edit Box")
-
-
-if __name__ == "__main__":
-    app = QApplication(sys.argv)
-    window = DrawWindow()
-    window.show()
-    sys.exit(app.exec_())
diff --git a/src/mpes_tools/call_gui.py b/src/mpes_tools/call_gui.py
deleted file mode 100644
index 89d4c5c..0000000
--- a/src/mpes_tools/call_gui.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from PyQt5.QtWidgets import QApplication
-from mpes_tools.Main import ARPES_Analyser  # Assuming the first code is saved as main_window.py
-
-import sys
-
-if __name__ == "__main__":
-    app = QApplication(sys.argv)  # Initialize the Qt application
-    window = ARPES_Analyser()  # Create an instance of your main window
-    window.show()  # Show the window
-    sys.exit(app.exec_())  # Run the Qt event loop
-    
-# if __name__ == "__main__":
-#     window = MainWindow()  # Instantiate the MainWindow
-#     window.show()  # Show the window
\ No newline at end of file
diff --git a/src/mpes_tools/color_scale.py b/src/mpes_tools/color_scale.py
deleted file mode 100644
index 86e03be..0000000
--- a/src/mpes_tools/color_scale.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import numpy as np
-import h5py
-import matplotlib
-import matplotlib.pyplot as plt
-import numpy as np
-from matplotlib.widgets import CheckButtons, Button
-from scipy.ndimage import rotate
-import h5py
-# import mplcursors
-from matplotlib.widgets import Slider, Cursor, SpanSelector
-
-
-class update_color():
-    def __init__(self,im,fig,ax):
-        # self.slider_plot=s
-        self.im=im
-        self.fig=fig
-        ax_position=ax.get_position()
-        # print(ax.get_position())
-        x0, y0, width, height = ax_position.bounds
-
-        # Print the coordinates
-        # print("Lower-left coordinate (x0, y0):", x0, y0)
-        # print("Upper-right coordinate (x1, y1):", x0 + width, y0 + height)
-        self.cbar = plt.colorbar(im, ax=ax)
-        # self.cbar.ax.set_position([0.43, 0.31, 0.01, 0.8])
-        # self.ax_slider = fig.add_axes([0.42, 0.56, 0.01, 0.30], facecolor='lightgoldenrodyellow')
-        self.cbar.ax.set_position([x0 + width +0.013, y0-0.08, 0.01, 0.5])
-        self.ax_slider = fig.add_axes([x0 + width +0.006, y0 + 0.03, 0.01, 0.30], facecolor='lightgoldenrodyellow')
-        self.slider_plot = Slider(self.ax_slider, '', -1.5, 1.5, valinit=0.0,valstep=0.01,orientation='vertical')
-        self.original_vmax = im.norm.vmax
-        # self.slider_plot.on_changed(self.update)
-    def update(self,val):
-        # print('whathbdjfs')
-        self.im.norm.vmax = 10**(self.slider_plot.val) * self.original_vmax
-        
-        # self.fig.canvas.draw_idle()
-    def slider (self):
-        self.slider_plot.on_changed(self.update)
-    def sprint(self,val):
-        print('somethign', self.slider_plot)
-        # self.fig.canvas.draw_idle()
-        # print('slider')    
-        
diff --git a/src/mpes_tools/double_click_handler.py b/src/mpes_tools/double_click_handler.py
deleted file mode 100644
index f187dca..0000000
--- a/src/mpes_tools/double_click_handler.py
+++ /dev/null
@@ -1,12 +0,0 @@
-class SubplotClickHandler:
-    def __init__(self, ax, on_subplot_click=None):
-        self.ax = ax
-        self.on_subplot_click = on_subplot_click
-
-    def handle_double_click(self, event):
-        # print(f"event.inaxes id: {id(event.inaxes)}, self.ax id: {id(self.ax)}")
-        if not event.dblclick or event.inaxes != self.ax:
-            return
-        # self.ax.set_title("Clicked", color='red')
-        if self.on_subplot_click:
-            self.on_subplot_click(self.ax)
diff --git a/src/mpes_tools/h5toxarray.py b/src/mpes_tools/h5toxarray.py
deleted file mode 100644
index 165ddf1..0000000
--- a/src/mpes_tools/h5toxarray.py
+++ /dev/null
@@ -1,55 +0,0 @@
-import h5py
-import numpy as np
-import xarray as xr
-
-
-class h5toxarray_loader():
-    def __init__(self, df):
-
-        if len(list(df['binned'].keys()))>1:
-            first_key = sorted(df['binned'].keys(), key=lambda x: int(x[1:]))[0]
-            data_shape = df['binned/' + first_key][:].shape  
-            self.M = np.empty((data_shape[0], data_shape[1], data_shape[2], len(df['binned'])))
-            axis=[]
-            for idx, v in enumerate(sorted(df['binned'].keys(), key=lambda x: int(x[1:]))):
-                self.M[:, :, :, idx] = df['binned/' + v][:]
-        else: 
-            self.M= df['binned/' + list(df['binned'].keys())[0]][:]
-        
-        
-        # Define the desired order lists
-        desired_orders = [
-            ['ax0', 'ax1', 'ax2', 'ax3'],
-            ['kx', 'ky', 'E', 'delay'],
-            ['kx', 'ky', 'E', 'ADC']
-        ]
-        
-        axes_list = []
-      
-        matched_order = None
-        for i, order in enumerate(desired_orders):
-            # Check if all keys in the current order exist in df['axes']
-            if all(f'axes/{axis}' in df for axis in order):
-                # If match is found, generate axes_list based on this order
-                axes_list = [df[f'axes/{axis}'] for axis in order]
-                matched_order = i + 1  # Store which list worked (1-based index)
-                break  # Stop once the first matching list is found
-        
-        if matched_order:
-            print(f"Matched desired list {matched_order}: {desired_orders[matched_order - 1]}")
-        else:
-            print("No matching desired list found.")
-        
-        # print("Axes list:", axes_list)
-        # print(M[12,50,4,20])
-        self.data_array = xr.DataArray(
-            self.M,
-            coords={"kx": axes_list[0], "ky": axes_list[1], "E": axes_list[2], "dt": axes_list[3]},
-            dims=["kx", "ky", "E","dt"]
-        )
-    def get_data_array(self):
-        return self.data_array
-    def get_original_array(self):
-        return self.M
-# df =h5py.File(r'C:\Users\admin-nisel131\Documents\Scan130_scan130_Amine_100x100x300x50_spacecharge4_gamma850_amp_3p3.h5', 'r')
-# test=h5toxarray_loader(df)
diff --git a/src/mpes_tools/k_path_4d_4.py b/src/mpes_tools/k_path_4d_4.py
deleted file mode 100644
index 9631edb..0000000
--- a/src/mpes_tools/k_path_4d_4.py
+++ /dev/null
@@ -1,422 +0,0 @@
-import numpy as np
-import h5py
-import matplotlib
-import matplotlib.pyplot as plt
-import numpy as np
-from matplotlib.widgets import CheckButtons, Button
-from scipy.ndimage import rotate
-import h5py
-# import mplcursors
-from matplotlib.widgets import Slider, Cursor, SpanSelector
-from matplotlib.gridspec import GridSpec
-from matplotlib.lines import Line2D
-from matplotlib.patches import Circle
-from AdditionalInterface import AdditionalInterface
-from AxisInteractor import AxisInteractor
-from LinePixelGetter import LinePixelGetter
-from update_plot_cut_4d import update_plot_cut
-import json
-import csv
-from datetime import datetime
-
-class drawKpath:
-    # print(True)
-    def __init__(self, data,axis,fig, ax,ax2,linewidth,slider,N):
-      self.active_cursor=None
-      self.dots_count=0
-      self.ax=ax
-      self.fig=fig
-      self.dot1_x=0
-      self.do1_y=0
-      self.dot2_x=0
-      self.do2_y=0
-      self.cid_press=None
-      self.linewidth=1
-      self.line_artist=None
-      self.cb_line=None
-      self.button_update=None
-      self.dot1=None
-      self.dot2=None
-      self.method_running = False
-      self.pixels_along_line=[]
-      self.number=N
-      self.og_number=N
-      self.dots_list=[]
-      self.line_artist_list=[None]*N
-      self.pixels_along_path=[None]*N
-      # self.number=N
-      self.is_drawn= False
-      self.is_loaded= False
-      self.new=False
-      self.add_pressed=False
-      self.lw=linewidth
-      self.ax2=ax2
-      self.data=data[:,:,:,slider]
-      self.axis=axis
-      self.pixels=[]
-      self.slider=slider
-      self.data2=data
-      self.slider_ax7 = plt.axes([0.55, 0.14, 0.02, 0.3])
-      self.slider_dcut= Slider(self.slider_ax7, 'dcut_kpath', 0, 15, valinit=1, valstep=1, orientation='vertical')
-    # def update_plot_cut(self):
-    #     update_plot_cut.update_plot_cut(self.data2[:,:,:,self.slider],self.ax2,self.pixels,self.lw)
-    def isdrawn(self):
-        return self.is_drawn
-        
-    
-    def get_pixels(self):
-        if self.pixels is not None:
-            return self.pixels
-    def get_pixels_along_line(self):
-        if self.pixels_along_line is not None:
-            return self.pixels_along_line
-   
-    def get_status(self):
-        if self.cb_line is not None:
-            return self.cb_line.get_status()[0]
-        else:
-            return False
-    
-    def draw(self):
-        # print('beginning')
-        def add_path(event):
-            self.add_pressed= True
-            
-            for i in range (self.number):
-                self.line_artist_list.append(None)
-                self.pixels_along_path.append(None)
-                # self.dots_list
-            print('line list=', len(self.line_artist_list))
-            self.number=self.number+self.og_number
-            self.is_drawn=False
-            self.dots_count=0
-            self.cid_press = self.fig.canvas.mpl_connect('button_press_event', drawdots)
-            
-        def drawline(dot1,dot2,pos):
-            self.pixels=[]
-            if self.dots_count ==0 and self.line_artist_list[len(self.dots_list)-2] is not None :
-                if not self.loaded:    
-                    self.line_artist_list[len(self.dots_list)-2].remove()  # Remove the previous line if exists
-                    print('test,code')
-            # if self.dots_count==2:
-            #     line = Line2D([self.dots_list[len(self.dots_list)].center[0], self.dots_list[len(self.dots_list)-1].center[0]], [self.dots_list[len(self.dots_list)].center[1], self.dots_list[len(self.dots_list)-1].center[1]], linewidth=self.linewidth, color='red')
-            if self.dots_count==2 :
-                line = Line2D([dot1.center[0], dot2.center[0]], [dot1.center[1], dot2.center[1]], linewidth=self.linewidth, color='red')
-                
-                self.ax.add_line(line)
-                # print('movement',len(self.line_artist_list))
-                print('currentline=',self.line_artist_list[pos])
-                if self.line_artist_list[pos] is not None:
-                    # print(pos,self.line_artist_list[pos].get_data())
-                    self.line_artist_list[pos].remove()
-                # if self.line_artist is not None:
-                #     self.line_artist.remove()  # Remove the previous line if exists
-                
-                self.line_artist = line
-                # self.line_artist_list.append(line)
-                self.line_artist_list[pos]=line
-                # print(pos,self.line_artist_list[pos].get_data())
-                # x1=self.line_artist_list[pos].get_data()[0][1]
-                # y1=self.line_artist_list[pos].get_data()[1][1]
-                # x2= self.line_artist_list[pos].get_data()[0][0]
-                # y2=self.line_artist_list[pos].get_data()[1][0]
-                x1_pixel=int((self.line_artist_list[pos].get_data()[0][1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-                y1_pixel=int((self.line_artist_list[pos].get_data()[1][1] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                x2_pixel=int((self.line_artist_list[pos].get_data()[0][0] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-                y2_pixel=int((self.line_artist_list[pos].get_data()[1][0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                
-                self.pixels_along_path[pos] = LinePixelGetter.get_pixels_along_line(x1_pixel, y1_pixel, x2_pixel, y2_pixel, self.linewidth)
-                # print(x1_pixel,y1_pixel)
-                # self.pixels_along_path[pos]=LinePixelGetter.get_pixels_along_line(self.line_artist_list[pos].get_data()[0][1], self.line_artist_list[pos].get_data()[1][1], self.line_artist_list[pos].get_data()[0][0], self.line_artist_list[pos].get_data()[1][0], self.linewidth)
-                # for i in self.pixels_along_path:
-                for i in range (0,self.number):
-                    if self.pixels_along_path[i] is not None:
-                        self.pixels+=self.pixels_along_path[i]
-                        
-        def drawdots(event):
-            # if self.add_pressed:
-                
-                
-            if self.cb_line.get_status()[0] and len(self.dots_list) < self.number and (self.new or not self.is_drawn):
-                x =  event.xdata  # Round the x-coordinate to the nearest integer
-                y =  event.ydata  # Round the y-coordinate to the nearest integer
-                print('you hereeee')
-                print(self.number)
-                # print('line list=', len(self.line_artist_list))
-                if self.dots_count==0:
-                    self.dot= Circle((x, y), radius=0.1, color='yellow', picker=20)
-                    self.ax.add_patch(self.dot)
-                    # self.dot_coords[self.dots_count] = (x, y)
-                    self.dots_list.append(self.dot)
-                    self.dots_count += 1
-                    self.fig.canvas.draw()
-                else:
-                    self.dot= Circle((x, y), radius=0.1, color='yellow', picker=20)
-                    self.ax.add_patch(self.dot)
-                    # self.dot_coords[self.dots_count] = (x, y)
-                    self.dots_count += 1
-                    self.dots_list.append(self.dot)
-                    print('dots list=',len(self.dots_list))
-                    drawline(self.dots_list[len(self.dots_list)-1],self.dots_list[len(self.dots_list)-2],len(self.dots_list)-2)
-                    self.dots_count -= 1
-                    update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
-                    
-                    self.fig.canvas.draw()
-                    if len(self.dots_list)== self.number:
-                        self.is_drawn=True
-                        # print(self.is_drawn)
-        def on_checkbox_change(label):
-                if self.cb_line.get_status()[0]:
-                    if self.is_loaded:
-                        for i in range(len(self.dots_list)):
-                            self.ax.add_patch(self.dots_list[i])
-                            plt.draw()
-                        for i in range(len(self.line_artist_list)):
-                            if self.line_artist_list[i] is not None:
-                                self.ax.add_line(self.line_artist_list[i])
-                                plt.draw()
-                    elif self.is_drawn:
-                        for i in range(len(self.dots_list)):
-                            self.ax.add_patch(self.dots_list[i])
-                            plt.draw()
-                        for i in range(len(self.line_artist_list)):
-                            if self.line_artist_list[i] is not None:
-                                self.ax.add_line(self.line_artist_list[i])
-                                plt.draw()
-                    
-                    else:
-                        self.cid_press = self.fig.canvas.mpl_connect('button_press_event', drawdots)
-                    
-                else:
-                    # Disconnect the click event
-                    self.is_loaded= False
-                    self.fig.canvas.mpl_disconnect(self.cid_press)
-                    for i in range(len(self.dots_list)):
-                        self.dots_list[i].remove()
-                        plt.draw()
-                    for i in range(len(self.line_artist_list)):
-                        if self.line_artist_list[i] is not None:
-                            self.line_artist_list[i].remove()
-                            plt.draw()
-        def new(event):
-            
-            for i in range(len(self.dots_list)):
-                print(i)
-                self.dots_list[i].remove()
-                plt.draw()
-            for i in range(len(self.line_artist_list)):
-                print(i)
-                if self.line_artist_list[i] is not None:
-                    self.line_artist_list[i].remove()
-                    plt.draw()
-            self.new=True
-            self.is_drawn= False
-            self.is_loaded= False
-            self.dots_list=[]
-            self.line_artist_list=[None]*self.number
-            self.pixels_along_path=[None]*self.number
-            self.dots_count=0
-            self.cid_press = self.fig.canvas.mpl_connect('button_press_event', drawdots)
-        def on_pick(event):
-            for i in range(len(self.dots_list)):
-                if event.artist == self.dots_list[i]:
-                    self.active_cursor = self.dots_list[i]
-        def on_motion(event):
-            # global dot1,dot2
-            if self.active_cursor is not None and event.inaxes == self.ax:
-                # Initialize a list of dictionaries to store dot information
-                dot_info_list = [{"dot": dot, "center": dot.center} for dot in self.dots_list]
-                self.dots_count=2
-            
-                # Iterate through the list to find the selected dot
-                selected_dot_index = None
-                for i, dot_info in enumerate(dot_info_list):
-                    dot = dot_info["dot"]
-                    contains, _ = dot.contains(event)
-                    if contains:
-                        selected_dot_index = i
-                        break  # Exit the loop when a matching dot is found
-                
-                if selected_dot_index is not None:
-                    selected_dot_info = dot_info_list[selected_dot_index]
-                    selected_dot = selected_dot_info["dot"]
-                    # print(f"Selected dot index: {selected_dot_index}")
-                    # print(f"Selected dot center: {selected_dot_info['center']}")
-                    selected_dot.center = (event.xdata, event.ydata)
-                    plt.draw()
-                    i=selected_dot_index
-                    if i==len(self.dots_list)-1:
-                        # self.line_artist_list[i-1].remove()
-                        drawline(self.dots_list[i],self.dots_list[i-1],i-1)
-                        update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
-                    elif i==0:
-                        drawline(self.dots_list[i+1],self.dots_list[i],i)
-                        update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
-                    else:
-                        # self.line_artist_list[i-1].remove()
-                        # self.line_artist_list[i].remove()
-                        drawline(self.dots_list[i+1],self.dots_list[i],i)
-                        update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
-                        drawline(self.dots_list[i],self.dots_list[i-1],i-1)
-                        update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
-                    plt.draw()
-                    
-                
-        def on_release(event):
-            self.active_cursor = None
-        def get_status():
-            return self.cb_line.get_status()[0]
-        def dots_coord():
-            return [self.dot1.center, self.dot2.center]
-        
-        def update_dcut(val):
-            self.linewidth=self.slider_dcut.val
-            self.pixels=[]
-            for position, line in enumerate(self.line_artist_list):
-                if line is not None:
-                    line.set_linewidth(self.linewidth+1)
-                    x1_pixel=int((line.get_data()[0][1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-                    y1_pixel=int((line.get_data()[1][1] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                    x2_pixel=int((line.get_data()[0][0] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-                    y2_pixel=int((line.get_data()[1][0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                    # print(x1_pixel,y1_pixel,x2_pixel,y2_pixel)
-                    self.pixels_along_path[position] = LinePixelGetter.get_pixels_along_line(x1_pixel, y1_pixel, x2_pixel, y2_pixel, self.linewidth)
-                    self.pixels+=self.pixels_along_path[position]
-                    
-            print('before before line')
-            # for pos in range(0,self.number):
-            #     print('before line')
-            #     if self.line_artist_list[pos] is not None:
-            #         x1_pixel=int((self.line_artist_list[pos].get_data()[0][1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            #         y1_pixel=int((self.line_artist_list[pos].get_data()[1][1] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            #         x2_pixel=int((self.line_artist_list[pos].get_data()[0][0] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            #         y2_pixel=int((self.line_artist_list[pos].get_data()[1][0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            #         print(x1_pixel,y1_pixel,x2_pixel,y2_pixel)
-            #         self.pixels_along_path[pos] = LinePixelGetter.get_pixels_along_line(x1_pixel, y1_pixel, x2_pixel, y2_pixel, self.linewidth)
-            #         self.pixels+=self.pixels_along_path[pos]
-            
-            # self.pixels_along_line = LinePixelGetter.get_pixels_along_line(self.dot1_x_pixel, self.dot1_y_pixel, self.dot2_x_pixel, self.dot2_y_pixel, self.linewidth)
-            # update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels_along_line,self.slider_dcut.val)
-            update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
-        def draw_load():
-            if self.is_loaded:
-                for i in range(len(self.dots_list)):
-                    self.ax.add_patch(self.dots_list[i])
-                    plt.draw()
-                for i in range(len(self.line_artist_list)):
-                    if self.line_artist_list[i] is not None:
-                        self.ax.add_line(self.line_artist_list[i])
-                        plt.draw()
-        def save_path(event):
-            def c_to_string(circle):
-                return f"{circle.center[0]}, {circle.center[1]}, {circle.radius}"
-            def l_to_string(line):
-                x_data, y_data = line.get_data()
-                linewidth = line.get_linewidth()
-                return f"{x_data[0]}, {y_data[0]}, {x_data[1]},{y_data[1]},{linewidth}"
-            # self.positions= np.array([[0]*4]*len(self.line_artist_list))
-            # for position, line in enumerate(self.line_artist_list):
-            #     if line is not None:
-            #         line.set_linewidth(self.linewidth+1)
-            #         x1_pixel=int((line.get_data()[0][1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            #         y1_pixel=int((line.get_data()[1][1] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            #         x2_pixel=int((line.get_data()[0][0] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            #         y2_pixel=int((line.get_data()[1][0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            #         self.positions[position][0]
-            output_directory = "C:/Users/admin-nisel131/Documents/CVS_TR_flatband_fig/"
-            current_time = datetime.now()
-            current_time_str = current_time.strftime("%Y-%m-%d_%H%M%S")
-            file_name = "k_path"
-            output_path = f"{output_directory}/{file_name}_{current_time_str}.txt"
-            with open(output_path, "w",newline="") as file:
-                file.write(f"{self.number}" + "\n")
-                for circle in self.dots_list:
-                    file.write(c_to_string(circle) + "\n")
-                for line in self.line_artist_list:
-                    if line is not None:
-                        file.write(l_to_string(line) + "\n")
-        def load_path(event):
-            self.fig.canvas.mpl_disconnect(self.cid_press)
-            circle_list=[]
-            line_list=[]
-            file_path1="C:/Users/admin-nisel131/Documents/CVS_TR_flatband_fig/"
-            # file="k_path_2023-10-06_153243.txt"
-            # file= "k_path_2023-10-10_221437.txt"
-            # file= "k_path_2024-04-03_125248.txt"
-            file= "k_path_2024-04-03_140548.txt"
-            
-            
-            file_path=file_path1+file
-            with open(file_path, "r") as file:
-                lines=file.readlines()
-                # print(lines)
-                # for line_number, line in enumerate(file, start=1):
-                for line_number, line in enumerate(lines, start =1):
-                    # if line_number==2:
-                    #     a,b,c= map(float, line.strip().split(', '))
-                    #     print(a,b,c)
-                    # print(map(float, line.strip().split(', ')))
-                    # print('linenumber=',line_number)
-                    # Split the line into individual values
-                    # if line_number==1:
-                    # print('firstline',line_number)
-                    # number=7
-                    # first_line = file.readline().strip()  # Read and strip whitespace
-                    # print(line)
-                    # first_line = file.readline()
-                    
-                    # number= int(first_line)
-                    # print(number)
-                    # print(first_line)
-                    # print()
-                    if line_number==1:
-                        number= int(line)
-                        # print(number)
-                    elif line_number>=2 and line_number<=number+1:
-                        x, y, radius = map(float, line.strip().split(', '))
-                        # print(x,y,radius)
-                        circle = Circle((x, y), radius=radius, color='yellow', picker=20)
-                        circle_list.append(circle)
-                        self.dots_list=circle_list
-                    else:
-                        x0,y0,x1,y1,lw=map(float, line.strip().split(','))
-                        line1=Line2D([x0,x1], [y0, y1], linewidth=lw, color='red')
-                        line_list.append(line1)
-                        self.line_artist_list=line_list
-                    self.is_loaded= True
-                    self.dots_count=2
-                    # draw_load()
-                    # print(len(self.line_artist_list),len(self.dots_list))
-                    
-                        # print(x0,y0,x1,y1,lw)
-                    # on_checkbox_change('K path')
-                    
-                
-        self.slider_dcut.on_changed(update_dcut)
-        self.fig.canvas.mpl_connect('pick_event', on_pick)
-        self.fig.canvas.mpl_connect('motion_notify_event', on_motion)
-        self.fig.canvas.mpl_connect('button_release_event', on_release)
-    
-        rax_line = self.fig.add_axes([0.45, 0.02, 0.06, 0.03])  # [left, bottom, width, height]
-        self.cb_line = CheckButtons(rax_line, ['K path'], [False])
-        self.cb_line.on_clicked(on_checkbox_change)
-        
-        rax_button = self.fig.add_axes([0.52, 0.02, 0.06, 0.03])
-        self.button_update = Button(rax_button, 'new k')
-        self.button_update.on_clicked(new)
-        
-        savepath_button = self.fig.add_axes([0.52, 0.06, 0.06, 0.03])
-        self.button_save = Button(savepath_button, 'save k-path')
-        self.button_save.on_clicked(save_path)
-        
-        loadpath_button = self.fig.add_axes([0.45, 0.06, 0.06, 0.03])
-        self.button_load = Button(loadpath_button, 'load k-path')
-        self.button_load.on_clicked(load_path)
-        
-        addpath_button = self.fig.add_axes([0.37, 0.06, 0.06, 0.03])
-        self.button_add = Button(addpath_button, 'add k-path')
-        self.button_add.on_clicked(add_path)
-        
-        plt.show()
-        self.fig.canvas.draw()
-        
\ No newline at end of file
diff --git a/tests/Arpes_gui.py b/tests/Arpes_gui.py
deleted file mode 100644
index 0270868..0000000
--- a/tests/Arpes_gui.py
+++ /dev/null
@@ -1,392 +0,0 @@
-import sys
-from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QAction, QFileDialog, QSlider, QGridLayout,QHBoxLayout, QSizePolicy,QLabel
-from PyQt5.QtCore import Qt
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
-import matplotlib.pyplot as plt
-import numpy as np
-import h5py
-from matplotlib.widgets import CheckButtons, Button
-from matplotlib.patches import Circle
-from matplotlib.lines import Line2D
-from additional_window import GraphWindow
-from color_scale import update_color
-import xarray as xr
-from Drawwindow import DrawWindow
-from h5toxarray import h5toxarray_loader
-# from k_path_4d_4 import drawKpath
-
-class MainWindow(QMainWindow):
-    def __init__(self):
-        super().__init__()
-
-        self.setWindowTitle("Main Window")
-        self.setGeometry(100, 100, 800, 600)
-
-        # Create a central widget for the graph and slider
-        central_widget = QWidget()
-        self.setCentralWidget(central_widget)
-
-        # Create a layout for the central widget
-        layout = QGridLayout()
-        central_widget.setLayout(layout)
-
-        # Create four graphs and sliders
-        self.graphs = []
-        self.slider1 = []
-        self.slider2 = []
-        self.slider3 = []
-        self.slider4 = []
-        self.sliders = []
-        self.slider_labels = []
-
-        for i in range(2):
-            for j in range(2):
-                graph_window = QWidget()
-                graph_layout = QVBoxLayout()
-                graph_window.setLayout(graph_layout)
-
-                # Create a figure and canvas for the graph
-                figure, axis = plt.subplots(figsize=(20, 20))
-                canvas = FigureCanvas(figure)
-                graph_layout.addWidget(canvas)
-
-                slider_layout= QHBoxLayout()
-                slider_layout_2= QHBoxLayout()
-                # Create a slider widget
-                slider1 = QSlider(Qt.Horizontal)
-                slider1.setRange(0, 100)
-                slider1.setValue(0)
-                slider1_label = QLabel("0")
-                # slider.valueChanged.connect(self.slider_changed)
-                # Set the size of the slider
-                
-                # default_size = slider1.sizeHint()
-                # print(f"Default size of the slider: {default_size.width()}x{default_size.height()}")
-                
-                slider2 = QSlider(Qt.Horizontal)
-                slider2.setRange(0, 10)
-                slider2.setValue(0)
-                slider2_label = QLabel("0")
-                
-                
-                
-                slider3 = QSlider(Qt.Horizontal)
-                slider3.setRange(0, 100)
-                slider3.setValue(0)
-                slider3_label = QLabel("0")
-                
-                slider4 = QSlider(Qt.Horizontal)
-                slider4.setRange(0, 10)
-                slider4.setValue(0)
-                slider4_label = QLabel("0")
-                
-                slider1.setFixedSize(200, 12)  # Change the width and height as needed
-                slider2.setFixedSize(200, 12)  # Change the width and height as needed
-                slider3.setFixedSize(200, 12)  # Change the width and height as needed
-                slider4.setFixedSize(155, 10)  # Change the width and height as needed
-                
-                slider_layout.addWidget(slider1)
-                slider_layout.addWidget(slider1_label)
-                slider_layout.addWidget(slider2)
-                slider_layout.addWidget(slider2_label)
-                
-                slider_layout_2.addWidget(slider3)
-                slider_layout_2.addWidget(slider3_label)
-                slider_layout_2.addWidget(slider4)
-                slider_layout_2.addWidget(slider4_label)
-                # slider2.valueChanged.connect(self.slider_changed)
-
-                # Add the slider to the layout
-                graph_layout.addLayout(slider_layout)
-                graph_layout.addLayout(slider_layout_2)
-                # graph_layout.addWidget(slider3)
-                # graph_layout.addWidget(slider2)
-
-                layout.addWidget(graph_window, i, j)
-                self.graphs.append(figure)
-                self.slider1.append(slider1)
-                self.slider2.append(slider2)
-                self.slider3.append(slider3)
-                self.slider4.append(slider4)
-                self.sliders.extend([slider1, slider2,slider3, slider4])
-                self.slider_labels.extend([slider1_label, slider2_label,slider3_label, slider4_label])
-        for slider in self.slider1:   
-            slider.valueChanged.connect(self.slider_changed)
-        for slider in self.slider2:   
-            slider.valueChanged.connect(self.slider_changed)
-        for slider in self.slider3:   
-            slider.valueChanged.connect(self.slider_changed)
-        for slider in self.slider4:   
-            slider.valueChanged.connect(self.slider_changed)
-            
-        self.xv = None
-        self.yv = None
-        self.ev = None
-        self.eh = None
-        self.ph= None
-        self.pxv=None
-        self.pyh=None
-        self.axis=[]
-        # print(self.sliders)
-        # Create a menu bar
-        menu_bar = self.menuBar()
-
-        # Create a 'File' menu
-        file_menu = menu_bar.addMenu("File")
-
-        # Create actions for opening a file and exiting
-        open_file_action = QAction("Open File", self)
-        open_file_action.triggered.connect(self.open_file)
-        file_menu.addAction(open_file_action)
-        
-        open_graphe_action = QAction("Energy", self)
-        open_graphe_action.triggered.connect(self.open_graph_energy)
-        open_graphy_action = QAction("kx_cut", self)
-        open_graphy_action.triggered.connect(self.open_graph_y_cut)
-        open_graphx_action = QAction("ky_cut", self)
-        open_graphx_action.triggered.connect(self.open_graph_x_cut)
-        
-        menu_bar = self.menuBar()
-
-        # Create a 'Graph' menu
-        graph_menu = menu_bar.addMenu("Graph")
-
-        # Add the actions to the menu
-        graph_menu.addAction(open_graphe_action)
-        graph_menu.addAction(open_graphx_action)
-        graph_menu.addAction(open_graphy_action)
-        
-        open_draw_action = QAction("k-path", self)
-        open_draw_action.triggered.connect(self.open_draw_k_path)
-        
-        draw_menu= menu_bar.addMenu("Draw path")
-        draw_menu.addAction(open_draw_action)
-        # file_menu.addAction(open_graph_action)
-        self.graph_windows = []
-        self.ce=None
-        
-    def open_draw_k_path(self):
-        D=DrawWindow(self.data_array,self.slider1[0].value(),self.slider2[0].value() , self.slider1[1].value(), self.slider2[1].value())
-        D.show()
-        self.graph_windows.append(D)
-    
-    def open_graph_energy(self):
-        print('energy')
-        self.dataet=np.zeros((len(self.axis[0]),len(self.axis[1]),len(self.axis[3])))
-        self.axet=[self.axis[0],self.axis[1],self.axis[3]]
-        
-        for i in range(self.slider1[0].value(),self.slider1[0].value()+self.slider2[0].value()+1):
-            self.dataet += self.data_updated[:, :, i,:]
-        graph_window= GraphWindow(self.dataet,self.axet,self.slider3[0].value(),self.slider4[0].value())
-        
-        graph_window.show()
-        self.graph_windows.append(graph_window)
-    def open_graph_x_cut(self):
-        self.dataxt=np.zeros((len(self.axis[0]),len(self.axis[2]),len(self.axis[3])))
-        self.axxt=[self.axis[0],self.axis[2],self.axis[3]]
-        for i in range(self.slider1[1].value(),self.slider1[1].value()+self.slider2[1].value()+1):
-            self.dataxt += self.data_updated[:, i, :,:]
-        graph_window = GraphWindow(self.dataxt,self.axxt,self.slider3[1].value(),self.slider4[1].value())
-        # Show the graph window
-        graph_window.show()
-        self.graph_windows.append(graph_window)
-    def open_graph_y_cut(self):
-        self.datayt=np.zeros((len(self.axis[1]),len(self.axis[2]),len(self.axis[3])))
-        self.axyt=[self.axis[1],self.axis[2],self.axis[3]]
-       
-        for i in range(self.slider1[2].value(),self.slider1[2].value()+self.slider2[2].value()+1):
-            self.datayt += self.data_updated[i, :, :,:]
-        graph_window = GraphWindow(self.datayt,self.axyt,self.slider3[2].value(),self.slider4[2].value())
-        # Show the graph window
-        graph_window.show()
-        self.graph_windows.append(graph_window)
-    def open_graph_xy_cut(self):
-        self.datapt=np.zeros((len(self.axis[0]),len(self.axis[1]),len(self.axis[3])))
-        self.axpt=[self.axis[0],self.axis[1],self.axis[3]]
-        
-        for i in range(self.slider1[2].value(),self.slider1[2].value()+self.slider2[2].value()+1):
-            self.datayt += self.data_updated[i, :, :,:]
-        graph_window = GraphWindow(self.datayt,self.axyt,self.slider3[2].value(),self.slider4[2].value())
-        # Show the graph window
-        graph_window.show()
-        self.graph_windows.append(graph_window)
-    def open_file(self):
-        # Open file dialog to select a .txt file
-        # file_path, _ = QFileDialog.getOpenFileName(self, "Open Text File", "", "Text Files (*.txt)")
-        file_path, _ = QFileDialog.getOpenFileName(self, "Open Text File", "", "Text Files (*.h5)")
-        print(file_path)
-        if file_path:
-            # Load data from the file
-            # x, y = self.load_data(file_path)
-            # self.axis,self.data_updated = self.load_data2(file_path)
-            # Convert to an xarray.DataArray with named dimensions
-            df = h5py.File(file_path, 'r')
-            loader= h5toxarray_loader(df)
-            self.data_array= loader.get_data_array()
-            self.data_updated= loader.get_original_array()
-            self.axis=[self.data_array['kx'].data,self.data_array['ky'].data,self.data_array['E'].data,self.data_array['dt'].data]
-            
-            # print(self.axis[2])
-            self.slider1[0].setRange(0,len(self.data_array['E'].data)-1)
-            self.slider1[1].setRange(0,len(self.data_array['kx'].data)-1)
-            self.slider1[2].setRange(0,len(self.data_array['ky'].data)-1)
-            self.slider1[3].setRange(0,len(self.data_array['kx'].data)-1)
-            self.slider3[3].setRange(0,len(self.data_array['ky'].data)-1)
-            self.slider3[0].setRange(0,len(self.data_array['dt'].data)-1)
-            self.slider3[1].setRange(0,len(self.data_array['dt'].data)-1)
-            self.slider3[2].setRange(0,len(self.data_array['dt'].data)-1)
-            
-            
-            
-            # self.update_plot(self.slider1[0].value(),self.slider2[0].value() , self.slider1[1].value(), self.slider2[0].value(), self.slider1[2].value(), self.slider2[2].value(), self.slider3[0].value(), self.slider4[0].value(),self.slider3[1].value(), self.slider4[1].value(), self.slider3[2].value(), self.slider4[2].value(), self.slider1[3].value(), self.slider3[3].value(), self.slider2[3].value(), self.slider4[3].value())
-            self.update_energy(self.slider1[0].value(),self.slider2[0].value() , self.slider1[1].value(), self.slider2[1].value())
-            
-            # self.ce= update_color(self.im,self.graphs[0],self.graphs[0].gca())
-            # self.ce.slider_plot.on_changed(self.ce.update)
-            
-            self.update_y(self.slider1[2].value(), self.slider2[2].value(), self.slider3[0].value(), self.slider4[0].value())
-       
-            self.update_x(self.slider3[1].value(), self.slider4[1].value(), self.slider3[2].value(), self.slider4[2].value())
-            
-            self.update_point(self.slider1[3].value(), self.slider3[3].value(), self.slider2[3].value(), self.slider4[3].value())
-            
-    def update_energy(self,Energy,dE,te,dte):
-        E1=self.data_array['E'][Energy].item()
-        # print(Energy,E1)
-        E2=self.data_array['E'][Energy+dE].item()
-        te1=self.data_array['dt'][te].item()
-        te2=self.data_array['dt'][te+dte].item()
-        
-        self.graphs[0].clear()
-        ax=self.graphs[0].gca()
-        self.im=self.data_array.sel(E=slice(E1,E2), dt=slice(te1,te2)).mean(dim=("E", "dt")).T.plot(ax=ax)
-        # ax.set_title('Loaded Data')
-        ax.set_xlabel('kx')
-        ax.set_ylabel('ky')
-        ax.set_title(f'Energy: {E1:.2f}, dE: {E2-E1}')
-        # self.graphs[0].tight_layout()
-        self.graphs[0].canvas.draw()
-        self.ev = self.graphs[0].gca().axvline(x=self.axis[1][self.slider1[2].value()], color='r', linestyle='--')
-        self.eh = self.graphs[0].gca().axhline(y=self.axis[0][self.slider1[1].value()], color='r', linestyle='--')
-        self.pxv = self.graphs[0].gca().axvline(x=self.axis[1][self.slider1[3].value()], color='b', linestyle='--')
-        self.pyh = self.graphs[0].gca().axhline(y=self.axis[0][self.slider3[3].value()], color='b', linestyle='--')
-        # if self.ce is not None:
-        #     self.ce.slider_plot.on_changed(self.ce.update)
-        
-    def update_y(self,ypos,dy,ty,dty):
-        
-        y1=self.data_array['ky'][ypos].item()
-        y2=self.data_array['ky'][ypos+dy].item()
-        ty1=self.data_array['dt'][ty].item()
-        ty2=self.data_array['dt'][ty+dty].item()
-        
-        self.graphs[1].clear()
-        ax=self.graphs[1].gca()
-        self.data_array.sel(ky=slice(y1,y2), dt=slice(ty1,ty2)).mean(dim=("ky", "dt")).plot(ax=ax)
-        # ax.set_title('Loaded Data')
-        
-        ax.set_xlabel('Energy (eV)')
-        ax.set_ylabel('kx (1/A)')
-        ax.set_title(f'ky_pos: {y1:.2f}, dky: {y2-y1}')
-        self.graphs[1].tight_layout()
-        self.graphs[1].canvas.draw()
-        self.yv = ax.axvline(x=self.axis[2][self.slider1[0].value()], color='r', linestyle='--')
-        
-    def update_x(self,xpos,dx,tx,dtx):
-        x1=self.data_array['kx'][xpos].item()
-        x2=self.data_array['kx'][xpos+dx].item()
-        tx1=self.data_array['dt'][tx].item()
-        tx2=self.data_array['dt'][tx+dtx].item()
-        
-        self.graphs[2].clear()
-        ax=self.graphs[2].gca()
-        self.data_array.sel(kx=slice(x1,x2), dt=slice(tx1,tx2)).mean(dim=("kx", "dt")).plot(ax=ax)
-        # ax.set_title('Loaded Data')
-        ax.set_xlabel('Energy (eV)')
-        ax.set_ylabel('ky (1/A)')
-        ax.set_title(f'kx_pos: {x1:.2f}, dkx: {x2-x1}')
-        self.graphs[2].tight_layout()
-        self.graphs[2].canvas.draw()
-        self.xv = ax.axvline(x=self.axis[2][self.slider1[0].value()], color='r', linestyle='--')
-    def update_point(self,xt,yt,dxt,dyt):
-        yt1=self.data_array['ky'][yt].item()
-        yt2=self.data_array['ky'][yt+dyt].item()
-        xt1=self.data_array['kx'][xt].item()
-        xt2=self.data_array['kx'][xt+dxt].item()
-        
-        self.graphs[3].clear()
-        ax=self.graphs[3].gca()
-        self.data_array.sel(kx=slice(xt1,xt2), ky=slice(yt1,yt2)).mean(dim=("kx", "ky")).plot(ax=ax)
-        # ax.set_title('Loaded Data')
-        ax.set_xlabel('time (fs)')
-        ax.set_ylabel('Energy (eV)')
-        ax.set_title(f'kx_pos: {xt1:.2f}, dkx: {xt2-xt1},ky_pos: {yt1:.2f}, dky: {yt2-yt1}')
-        self.graphs[3].tight_layout()
-        self.graphs[3].canvas.draw()
-        self.ph = ax.axhline(y=self.axis[2][self.slider1[0].value()], color='r', linestyle='--')
-    
-
-    def load_data2(self, file_path):
-        # Load data from the text file
-        # r'C:\Users\admin-nisel131\Documents\\'
-        # 'Scan130_scan130_Amine_100x100x300x50_spacecharge4_gamma850_amp_3p3.h5', 'r')
-        df = h5py.File(file_path, 'r')
-        # print(df.keys())
-        print(df['axes'].keys())
-        
-        axis=[df['axes/ax0'][: ],df['axes/ax1'][: ],df['axes/ax2'][: ],df['axes/ax3'][: ]]
-        # print(df['binned/BinnedData'].keys())
-        data=df['binned/BinnedData']
-        
-        
-        return axis,data
-
-    def slider_changed(self, value):
-        sender = self.sender()  # Get the slider that emitted the signal
-        index = self.sliders.index(sender)  # Find the index of the slider
-        # print(index)
-        
-        self.slider_labels[index].setText(str(value))  # Update the corresponding label text
-        
-        if index in range(0,4):
-            
-            self.update_energy(self.slider1[0].value(),self.slider2[0].value(),self.slider3[0].value(), self.slider4[0].value())
-            # self.update_line()
-            if self.xv is not None:
-                self.xv.remove()
-            if self.yv is not None:
-                 self.yv.remove() 
-            if self.ph is not None:
-                 self.ph.remove() 
-            
-            self.xv = self.graphs[1].gca().axvline(x=self.axis[2][self.slider1[0].value()], color='r', linestyle='--')
-            self.yv = self.graphs[2].gca().axvline(x=self.axis[2][self.slider1[0].value()], color='r', linestyle='--')
-            self.ph = self.graphs[3].gca().axhline(y=self.axis[2][self.slider1[0].value()], color='r', linestyle='--')
-        elif index in range(4,8):
-            
-            if self.eh is not None:
-                self.eh.remove()
-           
-            self.eh = self.graphs[0].gca().axhline(y=self.axis[0][self.slider1[1].value()], color='r', linestyle='--')
-            
-            self.update_y(self.slider1[1].value(), self.slider2[1].value(),self.slider3[1].value(), self.slider4[1].value())
-            print('here')
-        elif index in range (8,12):
-            if self.ev is not None:
-                self.ev.remove()
-            self.ev = self.graphs[0].gca().axvline(x=self.axis[1][self.slider1[2].value()], color='r', linestyle='--')
-            self.update_x(self.slider1[2].value(), self.slider2[2].value(),self.slider3[2].value(), self.slider4[2].value())
-        else: 
-            if self.pxv is not None:
-                self.pxv.remove()
-            if self.pyh is not None:
-                self.pyh.remove()
-            self.update_point(self.slider1[3].value(), self.slider3[3].value(), self.slider2[3].value(), self.slider4[3].value())
-            self.pxv = self.graphs[0].gca().axvline(x=self.axis[1][self.slider1[3].value()], color='b', linestyle='--')
-            self.pyh = self.graphs[0].gca().axhline(y=self.axis[0][self.slider3[3].value()], color='b', linestyle='--')
-        
-if __name__ == "__main__":
-    app = QApplication(sys.argv)
-    window = MainWindow()
-    window.show()
-    sys.exit(app.exec_())
diff --git a/tests/Drawwindow.py b/tests/Drawwindow.py
deleted file mode 100644
index 77f70fe..0000000
--- a/tests/Drawwindow.py
+++ /dev/null
@@ -1,173 +0,0 @@
-import sys
-import numpy as np
-import matplotlib.pyplot as plt
-from PyQt5.QtCore import Qt
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
-from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QTextEdit, \
-    QHBoxLayout, QSizePolicy,QSlider,QLabel
-# from k_path_4d_4 import drawKpath
-
-class DrawWindow(QMainWindow):
-    def __init__(self,data,s1,s2,s3,s4):
-        super().__init__()
-
-        # Set the title and size of the main window
-        self.setWindowTitle("PyQt5 Matplotlib Example")
-        self.setGeometry(100, 100, 800, 600)
-        self.data_array=data
-        print(data['E'][0])
-        # Create the main layout
-        main_layout = QVBoxLayout()
-
-        # Create a widget to hold the layout
-        widget = QWidget()
-        widget.setLayout(main_layout)
-        self.setCentralWidget(widget)
-
-        # Create a horizontal layout for the top row
-        top_row_layout = QHBoxLayout()
-
-
-        # Create top left graph
-        self.figure1, self.axis1 = plt.subplots()
-        self.canvas1 = FigureCanvas(self.figure1)
-        top_row_layout.addWidget(self.canvas1)
-
-        # Create bottom right graph
-        self.figure2, self.axis2 = plt.subplots()
-        self.canvas2 = FigureCanvas(self.figure2)
-        top_row_layout.addWidget(self.canvas2)
-        
-        layout = QVBoxLayout()
-        
-        slider_layout= QHBoxLayout()
-        self.slider1 = QSlider(Qt.Horizontal)
-        self.slider1.setRange(0, len(data['E'].data))
-        self.slider1.setValue(s1)
-        self.slider1_label = QLabel("0")
-        
-        self.slider2 = QSlider(Qt.Horizontal)
-        self.slider2.setRange(0, 10)
-        self.slider2.setValue(s2)
-        self.slider2_label = QLabel("0")
-        
-        self.slider1.setFixedSize(200, 12)  # Change the width and height as needed
-        self.slider2.setFixedSize(200, 12)  # Change the width and height as needed
-        
-        slider_layout.addWidget(self.slider1)
-        slider_layout.addWidget(self.slider1_label)
-        slider_layout.addWidget(self.slider2)
-        slider_layout.addWidget(self.slider2_label)
-        # layout.addLayout(slider_layout)
-        slider_layout2= QHBoxLayout()
-        self.slider3 = QSlider(Qt.Horizontal)
-        self.slider3.setRange(0, 100)
-        self.slider3.setValue(s3)
-        self.slider3_label = QLabel("0")
-        
-        self.slider4 = QSlider(Qt.Horizontal)
-        self.slider4.setRange(0, 10)
-        self.slider4.setValue(s4)
-        self.slider4_label = QLabel("0")
-        
-        self.slider3.setFixedSize(200, 12)  # Change the width and height as needed
-        self.slider4.setFixedSize(200, 12)  # Change the width and height as needed
-        
-        slider_layout2.addWidget(self.slider3)
-        slider_layout2.addWidget(self.slider3_label)
-        slider_layout2.addWidget(self.slider4)
-        slider_layout2.addWidget(self.slider4_label)
-        
-        # layout.addLayout(slider_layout2)
-        
-        self.slider1.valueChanged.connect(self.slider1_changed)
-        self.slider2.valueChanged.connect(self.slider2_changed)
-        self.slider3.valueChanged.connect(self.slider3_changed)
-        self.slider4.valueChanged.connect(self.slider4_changed)
-        
-
-        main_layout.addLayout(top_row_layout)
-        main_layout.addLayout(slider_layout)
-        main_layout.addLayout(slider_layout2)
-        
-
-        # Set size policy for the graph widgets
-        self.canvas1.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-        self.canvas2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-        
-        self.update_energy(s1, s2, s3, s4)
-        # self.d=drawKpath(data, axis, fig, ax, ax2, linewidth, slider, N)
-
-        # Plot data
-        # self.plot_graphs()
-        # self.update_text_edit_boxes()
-        
-    def slider1_changed(self,value):
-        self.slider1_label.setText(str(value))
-        print(value)
-        self.update_energy(self.slider1.value(),self.slider2.value() , self.slider3.value(), self.slider4.value())
-    def slider2_changed(self,value):
-        self.slider2_label.setText(str(value))
-        self.update_energy(self.slider1.value(),self.slider2.value() , self.slider3.value(), self.slider4.value())
-    def slider3_changed(self,value):
-        self.slider3_label.setText(str(value))
-        self.update_energy(self.slider1.value(),self.slider2.value() , self.slider3.value(), self.slider4.value())
-    def slider4_changed(self,value):
-        self.slider4_label.setText(str(value))
-        # self.plot_graph(self.slider1.value(),self.slider2.value())
-        # print(self.slider1.value(),self.slider2.value())
-        # self.update_show(self.slider1.value(),self.slider2.value())
-        self.update_energy(self.slider1.value(),self.slider2.value() , self.slider3.value(), self.slider4.value())
-        
-    def update_energy(self,Energy,dE,te,dte):
-        
-        # self.ce_state=True
-        E1=self.data_array['E'][Energy].item()
-        # print(Energy,E1)
-        E2=self.data_array['E'][Energy+dE].item()
-        te1=self.data_array['dt'][te].item()
-        te2=self.data_array['dt'][te+dte].item()
-        # print(E1,E2,te1)
-        self.figure1.clear()
-        ax = self.figure1.add_subplot(111)  # Recreate the axis on the figure
-        self.im=self.data_array.sel(E=slice(E1,E2), dt=slice(te1,te2)).mean(dim=("E", "dt")).plot(ax=ax)
-        # ax.set_title('Loaded Data')
-        ax.set_xlabel('X')
-        ax.set_ylabel('Y')
-        # self.graphs[0].tight_layout()
-        self.figure1.canvas.draw()
-        # self.ev = self.graphs[0].gca().axvline(x=self.axis[0][self.slider1[1].value()], color='r', linestyle='--')
-        # self.eh = self.graphs[0].gca().axhline(y=self.axis[1][self.slider1[2].value()], color='r', linestyle='--')
-        
-
-    def plot_graphs(self):
-        # Plot on the top left graph
-        x1 = np.linspace(0, 10, 100)
-        y1 = np.sin(x1)
-        self.axis1.plot(x1, y1)
-        self.axis1.set_title('Top Left Graph')
-        self.axis1.set_xlabel('X')
-        self.axis1.set_ylabel('Y')
-
-        # Plot on the bottom right graph
-        x2 = np.linspace(0, 10, 100)
-        y2 = np.cos(x2)
-        self.axis2.plot(x2, y2)
-        self.axis2.set_title('Bottom Right Graph')
-        self.axis2.set_xlabel('X')
-        self.axis2.set_ylabel('Y')
-
-        # Update the canvas
-        self.canvas1.draw()
-        self.canvas2.draw()
-
-    # def update_text_edit_boxes(self):
-    #     # self.text_edit_top_right.setPlaceholderText("Top Right Text Edit Box")
-    #     self.text_edit_bottom_left.setPlaceholderText("Bottom Left Text Edit Box")
-
-
-if __name__ == "__main__":
-    app = QApplication(sys.argv)
-    window = DrawWindow()
-    window.show()
-    sys.exit(app.exec_())
diff --git a/tests/additional_window.py b/tests/additional_window.py
deleted file mode 100644
index c63c2a1..0000000
--- a/tests/additional_window.py
+++ /dev/null
@@ -1,473 +0,0 @@
-import sys
-from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QCheckBox, QAction, QFileDialog, QSlider, QGridLayout,QHBoxLayout, QSizePolicy,QLabel
-from PyQt5.QtCore import Qt
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
-import matplotlib.pyplot as plt
-import numpy as np
-import h5py
-from matplotlib.widgets import CheckButtons, Button
-from matplotlib.patches import Circle
-from matplotlib.lines import Line2D
-
-
-from fit_panel6 import MainWindow
-
-# %matplotlib qt
-
-class GraphWindow(QMainWindow):
-    def __init__(self,data,axis,t,dt):
-        global t_final
-        super().__init__()
-
-        self.setWindowTitle("Graph Window")
-        self.setGeometry(100, 100, 800, 600)
-
-        # Create a central widget for the graph
-        central_widget = QWidget()
-        self.setCentralWidget(central_widget)
-        
-        layout = QVBoxLayout()
-        central_widget.setLayout(layout)
-        
-        self.fig, self.axs = plt.subplots(2,2,figsize=(20,16))
-        self.canvas = FigureCanvas(self.fig)
-        
-        self.checkbox_e = QCheckBox("Integrate_energy")
-        self.checkbox_e.stateChanged.connect(self.checkbox_e_changed)
-        
-        self.checkbox_k = QCheckBox("Integrate_k")
-        self.checkbox_k.stateChanged.connect(self.checkbox_k_changed)
-        
-        self.checkbox_cursors = QCheckBox("energy_cursors")
-        self.checkbox_cursors.stateChanged.connect(self.checkbox_cursors_changed)
-        checkbox_layout= QHBoxLayout()
-        # Add the canvas to the layout
-        checkbox_layout.addWidget(self.checkbox_e)
-        checkbox_layout.addWidget(self.checkbox_k)
-        layout.addLayout(checkbox_layout)
-        layout.addWidget(self.canvas)
-        layout.addWidget(self.checkbox_cursors)
-        
-        slider_layout= QHBoxLayout()
-        self.slider1 = QSlider(Qt.Horizontal)
-        self.slider1.setRange(0, 100)
-        self.slider1.setValue(0)
-        self.slider1_label = QLabel("0")
-        
-        self.slider2 = QSlider(Qt.Horizontal)
-        self.slider2.setRange(0, 10)
-        self.slider2.setValue(0)
-        self.slider2_label = QLabel("0")
-        
-        self.slider1.setFixedSize(200, 12)  # Change the width and height as needed
-        self.slider2.setFixedSize(200, 12)  # Change the width and height as needed
-        
-        slider_layout.addWidget(self.slider1)
-        slider_layout.addWidget(self.slider1_label)
-        slider_layout.addWidget(self.slider2)
-        slider_layout.addWidget(self.slider2_label)
-        layout.addLayout(slider_layout)
-        # Create a layout for the central widget
-        self.active_cursor = None
-        self.cursorlinev1=1
-        self.cursorlinev2=0
-        # self.v1_pixel=None
-        # self.v2_pixel=None
-        self.Line1=None
-        self.Line2=None
-        self.square_artists = []  # To store the artists representing the dots
-        self.square_coords = [(0, 0), (0, 0)]  # To store the coordinates of the dots
-        self.square_count = 0  # To keep track of the number of dots drawn
-        
-        
-        self.cid_press2= None
-        self.line_artists=[]
-        self.cid_press3 = None
-        self.cid_press4 = None
-        self.cid_press = None
-
-        # Create a figure and canvas for the graph
-        
-        self.data_o=data
-        self.axis=axis
-        self.dt=dt
-        self.datae=np.zeros((len(self.axis[0]),len(self.axis[1])))
-        # Plot data
-        self.plot_graph(t,dt)
-        self.ssshow(t,dt)
-        self.slider1.setRange(0,len(self.axis[2])-1)
-        self.plot=np.zeros_like(self.data[1,:])
-        
-        self.slider1.valueChanged.connect(self.slider1_changed)
-        self.slider2.valueChanged.connect(self.slider2_changed)
-        t_final=self.axis[2].shape[0]
-        
-        
-        fit_panel_action = QAction('Fit_Panel',self)
-        fit_panel_action.triggered.connect(self.fit_panel)
-        
-        menu_bar = self.menuBar()
-
-        # Create a 'Graph' menu
-        
-        graph_menu1 = menu_bar.addMenu("Fit Panel")
-        
-        graph_menu1.addAction(fit_panel_action)
-
-        # Add the actions to the menu
-        
-        self.graph_windows=[]
-        self.t=t
-        
-    def slider1_changed(self,value):
-        self.slider1_label.setText(str(value))
-        self.plot_graph(self.slider1.value(),self.slider2.value())
-        # print(self.slider1.value(),self.slider2.value())
-        self.update_show(self.slider1.value(),self.slider2.value())
-        self.t=self.slider1.value()
-        # self.us()
-        # update_show(self.slider1.value(),self.slider2.value())
-    def slider2_changed(self,value):
-        self.slider2_label.setText(str(value))
-        self.plot_graph(self.slider1.value(),self.slider2.value())
-        self.update_show(self.slider1.value(),self.slider2.value())
-        self.dt=self.slider2.value()
-        # self.ssshow(self.slider1.value(),self.slider2.value()).update_show()
-        # self.us()
-        # update_show(self.slider1.value(),self.slider2.value())
-    def checkbox_e_changed(self, state):
-        if state == Qt.Checked:
-            # print("Checkbox is checked")
-            self.integrate_E()
-        else:
-            # print("Checkbox is unchecked")
-            self.update_show(self.slider1.value(),self.slider2.value())
-    def checkbox_k_changed(self, state):
-        if state == Qt.Checked:
-            # print("Checkbox is checked")
-            self.integrate_k()
-        else:
-            # print("Checkbox is unchecked")
-            self.update_show(self.slider1.value(),self.slider2.value())
-    def checkbox_cursors_changed(self, state):
-        if state == Qt.Checked:
-            self.put_cursors()
-            # self.integrate_k()
-        else:
-            # print("Checkbox is unchecked")
-            self.remove_cursors()
-    def plot_graph(self,t,dt):
-        # Plot on the graph
-        x = [1, 2, 3, 4, 5]
-        y = [2, 3, 5, 7, 11]
-        self.data=np.zeros((len(self.axis[0]),len(self.axis[1])))
-        # self.ax.plot(x, y)
-        for i in range (t,t+dt+1):
-            self.data+= self.data_o[:,:,i]
-        
-        self.axs[0,0].imshow(self.data, extent=[self.axis[1][0], self.axis[1][-1], self.axis[0][0], self.axis[0][-1]], origin='lower', cmap='viridis',aspect='auto')
-        self.axs[0,0].set_title('Sample Graph')
-        self.axs[0,0].set_xlabel('X')
-        self.axs[0,0].set_ylabel('Y')
-        self.fig.tight_layout()
-        self.canvas.draw()
-    
-    def fit_panel(self,event):
-        print('forfit',len(self.plot),'axis',len(self.axis))
-        graph_window=   MainWindow( self.data_o, self.axis,self.square_coords[0][1], self.square_coords[1][1],self.t,self.dt)
-        graph_window.show()
-        self.graph_windows.append(graph_window)
-        
-    def lz_fit(self, event):
-        two_lz_fit(self.data_o, self.axis, self.square_coords[0][1], self.square_coords[1][1], 0, t_final, self.v1_pixel, self.v2_pixel,self.dt,self.a).fit()
-    def fit(self, event):
-        fit_4d(self.data_o, self.axis, self.square_coords[0][1], self.square_coords[1][1], 0, t_final, self.v1_pixel, self.v2_pixel,self.dt).fit()
-    def fit_FD(self, event):
-        fit_FD(self.data_o, self.axis, self.square_coords[0][1], self.square_coords[1][1], 0, t_final, self.v1_pixel, self.v2_pixel,self.dt).fit()
-    def fit_FD_conv(self, event):
-        # print('ax0test=',self.ax[0])
-        # print('ax1test=',self.ax[1])
-        
-        fit_FD_lor_conv(self.data_o, self.axis, self.square_coords[0][1], self.square_coords[1][1], 0, t_final, self.v1_pixel, self.v2_pixel,self.dt).fit()
-    def fit_FD_conv_2(self, event):
-        
-        f=fit_FD_conv(self.data_o, self.axis, self.square_coords[0][1], self.square_coords[1][1], 0, t_final, self.v1_pixel, self.v2_pixel,self.dt)
-        f.show()
-    def ssshow(self,t,dt):
-        def test(self):
-            print('whatever test')
-        print('show is running')
-        c= self.data.shape[1]// 10 ** (len(str(self.data.shape[1])) - 1)
-        
-        def put_cursors():
-            self.Line1=axe.axvline(x=self.cursorlinev1, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
-            self.Line2=axe.axvline(x=self.cursorlinev2, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
-            plt.draw()
-            self.fig.canvas.draw()
-        def remove_cursors():
-            self.Line1.remove()
-            self.Line2.remove()
-            plt.draw()
-            self.fig.canvas.draw()
-                    
-                           
-        def integrate_E():
-                self.plote=np.zeros_like(self.data[1,:])
-                self.axs[1,0].clear()
-                plt.draw()
-                x_min = int(min(self.square_coords[1][1], self.square_coords[0][1]))
-                x_max = int(max(self.square_coords[1][1], self.square_coords[0][1])) + 1
-                for i in range(x_min, x_max):
-                    self.plote += self.data[i, :]
-                # if self.square_coords[1][1]<self.square_coords[0][1]:
-                #     for i in range(self.square_coords[1][1],self.square_coords[0][1]+1):
-                #          self.plot+=self.data[i,:]
-                # elif self.square_coords[1][1]>self.square_coords[0][1]:
-                #     for i in range(self.square_coords[0][1],self.square_coords[1][1]+1):
-                #          self.plot+=self.data[i,:]
-                # else: 
-                #     self.plot+=self.data[self.square_coords[0][1],:]
-                                                       
-                self.axs[1, 0].plot(self.axis[1][:],self.plote/abs(self.square_coords[0][1]-self.square_coords[1][1]),color='red') 
-                
-                # save_data(self.axis[1], plot/abs(self.square_coords[0][1]-self.square_coords[1][1]),"EDC_time="+str(slider_t.val)+"_", [0.42,0.46],self.fig)        
-        def integrate_k():
-                self.plotk=np.zeros_like(self.data[:,1])
-                self.axs[0,1].clear()
-                plt.draw()
-                x_min = int(min(self.square_coords[0][0], self.square_coords[1][0]))
-                x_max = int(max(self.square_coords[0][0], self.square_coords[1][0])) + 1
-                for i in range(x_min, x_max):
-                    self.plotk += self.data[:, i]
-                # if self.square_coords[0][0]<self.square_coords[1][0]:
-                #     for i in range(int(self.square_coords[0][0]),int(self.square_coords[1][0])+1):
-                #         self.plot+=self.data[:,i] 
-                # else:    
-                #     for i in range(int(self.square_coords[1][0]),int(self.square_coords[0][0])+1):
-                #         self.plot+=self.data[:,i]
-                self.axs[0, 1].plot(self.plotk/abs(int(self.square_coords[0][0])-int(self.square_coords[1][0])),self.axis[0][:],color='red')
-                # plt.draw()    
-        def box():
-                self.int=np.zeros_like(self.axis[2])
-                self.axs[1,1].clear()
-                if self.square_coords[1][1]<self.square_coords[0][1]:
-                    if self.square_coords[0][0]<self.square_coords[1][0]:
-                        for i in range(self.square_coords[1][1],self.square_coords[0][1]+1):
-                            for j in range(int(self.square_coords[0][0]),int(self.square_coords[1][0])+1):
-                                self.int+=self.data_o[i,j,:]
-                                
-                    else:
-                        for i in range(self.square_coords[1][1],self.square_coords[0][1]+1):
-                            for j in range(int(self.square_coords[1][0]),int(self.square_coords[0][0])+1):
-                                self.int+=self.data_o[i,j,:]
-                else:
-                    if self.square_coords[0][0]<self.square_coords[1][0]:
-                        for i in range(self.square_coords[0][1],self.square_coords[1][1]+1):
-                            for j in range(int(self.square_coords[0][0]),int(self.square_coords[1][0])+1):
-                                self.int+=self.data_o[i,j,:]
-                    else:
-                        for i in range(self.square_coords[0][1],self.square_coords[1][1]+1):
-                            for j in range(int(self.square_coords[1][0]),int(self.square_coords[0][0])+1):
-                                self.int+=self.data_o[i,j,:]
-                if int(self.square_coords[1][1]) != int(self.square_coords[0][1]) and int(self.square_coords[0][0]) != int(self.square_coords[1][0]):
-                    # self.axs[1,1].plot(plot/np.sqrt((self.square_coords[0][0])-int(self.square_coords[1][0])**2+(self.square_coords[0][1]-self.square_coords[1][1])**2),self.axis[2])
-                    # print(plot)
-                    N=120
-                    self.axs[1,1].plot(self.axis[2][0:N],self.int[0:N])  
-      
-        def us(self):
-            update_show(self.slider1.value(),self.slider2.value())                      
-        def update_show(t,dt):
-            # print(self.data.shape)
-            # print(self.axis[2].shape)
-            # print(self.square_coords)
-            # self.data=np.zeros_like(self.data)
-            print('update_Shopwwww')
-            self.axs[0,1].clear()
-            self.axs[1,0].clear()
-            # if self.cursorlinev1 is not None and self.cursorlinev2 is not None:
-            # if cb_ce.get_status()[0]:
-            
-            # for j in range(t, t+dt+1):
-            #     self.data+=self.data_o[:,:,j]
-            im6.set_array(self.data)
-            if self.checkbox_e.isChecked() and self.checkbox_k.isChecked() :
-                integrate_E()
-                integrate_k()
-            elif self.checkbox_e.isChecked():
-                integrate_E()
-                self.axs[0, 1].plot(self.data[:,int(self.square_coords[0][0])],self.axis[0][:],color='orange') 
-                self.axs[0, 1].plot(self.data[:,int(self.square_coords[1][0])],self.axis[0][:],color='green')
-                # self.axs[0, 1].plot(self.data[:,int(self.square_coords[0][0])],np.arange(self.data[:,self.square_coords[0][0]].shape[0]),color='orange') 
-                # self.axs[0, 1].plot(self.data[:,int(self.square_coords[1][0])],np.arange(self.data[:,self.square_coords[0][0]].shape[0]),color='green')
-            elif self.checkbox_k.isChecked():
-                integrate_k()
-                self.axs[1, 0].plot(self.axis[1][:],self.data[self.square_coords[0][1],:],color='orange')
-                self.axs[1, 0].plot(self.axis[1][:],self.data[self.square_coords[1][1],:],color='green')
-            else:
-                self.axs[1, 0].plot(self.axis[1][:],self.data[self.square_coords[0][1],:],color='orange')
-                self.axs[1, 0].plot(self.axis[1][:],self.data[self.square_coords[1][1],:],color='green')
-                # self.axs[0, 1].plot(self.data[:,int(self.square_coords[0][0])],np.arange(self.data[:,int(self.square_coords[0][0])].shape[0]),color='orange') 
-                # self.axs[0, 1].plot(self.data[:,int(self.square_coords[1][0])],np.arange(self.data[:,int(self.square_coords[0][0])].shape[0]),color='green')
-                self.axs[0, 1].plot(self.data[:,int(self.square_coords[0][0])],self.axis[0][:],color='orange') 
-                self.axs[0, 1].plot(self.data[:,int(self.square_coords[1][0])],self.axis[0][:],color='green')
-                # save_data(self.axs[1], plot/abs(self.square_coords[0][1]-self.square_coords[1][1]),"EDC_time="+str(slider_t.val)+"_", [0.42,0.46],self.fig)
-                # save_data(self.axis[1], self.data[self.square_coords[0][1],:],"yellow, EDC_time="+str(slider_t.val)+"_", [0.42,0.46],self.fig)
-                # save_data(self.axis[1], self.data[self.square_coords[1][1],:],"green, EDC_time="+str(slider_t.val)+"_", [0.46,0.46],self.fig)
-            if self.checkbox_cursors.isChecked():
-                self.Line1=self.axs[1,0].axvline(x=self.cursorlinev1, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
-                self.Line2=self.axs[1,0].axvline(x=self.cursorlinev2, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
-                plt.draw()
-                self.fig.canvas.draw()
-            # print("update_show is called")
-            # line_profile(self.data[self.square_coords[0][1],:], self.axis[3][:],self.fig).line_profile()
-            # line_profile(self.data[self.square_coords[0][1],:], self.axis[3][:],self.fig)
-            box()
-            time1=self.axis[2][t]
-            timedt1=self.axis[2][t+dt]
-            # print( 'change')
-            self.axs[0,0].set_title(f't: {time1:.2f}, t+dt: {timedt1}')
-            im6.set_clim(vmin=self.data.min(), vmax=self.data.max())
-            self.fig.canvas.draw()
-            plt.draw() 
- 
-        
-        im6 = self.axs[0,0].imshow(self.datae, extent=[self.axis[1][0], self.axis[1][-1], self.axis[0][0], self.axis[0][-1]], origin='lower', cmap='viridis',aspect=1)
-       
-        initial_x = 0
-        initial_y = 0
-        initial_x2 = 0.5
-        initial_y2 = 0.5
-        ax=self.axs[0,0]
-        axe=self.axs[1,0]
-        # Create cursor lines with larger pick radius
-        cursor_vert1 = Line2D([initial_x, initial_x], [-200, len(self.data)+4000], color='yellow', linewidth=2, picker=10,linestyle='--')
-        cursor_horiz1 = Line2D([-200, len(self.data[0])+4000], [initial_y, initial_y], color='yellow', linewidth=2, picker=10,linestyle='--')
-        cursor_vert2 = Line2D([initial_x2, initial_x2], [-200, len(self.data)+4000], color='green', linewidth=2, picker=10,linestyle='--')
-        cursor_horiz2 = Line2D([-200, len(self.data[0])+4000], [initial_y2, initial_y2], color='green', linewidth=2, picker=10,linestyle='--')
-        # Create draggable dot at the intersection
-        dot1 = Circle((initial_x, initial_y), radius=0.05, color='yellow', picker=10)
-        dot2 = Circle((initial_x2, initial_y2), radius=0.05, color='green', picker=10)
-        
-        if dot1.center[0] is not None and dot1.center[1] is not None and dot2.center[0] is not None and dot2.center[1] is not None:
-            x1_pixel=int((dot1.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            y1_pixel=int((dot1.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            self.square_coords[0]=(x1_pixel,y1_pixel)
-            x2_pixel=int((dot2.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            y2_pixel=int((dot2.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            self.square_coords[1]=(x2_pixel,y2_pixel)
-        # self.square_coords=[dot1.center,dot2.center]
-        # Add cursor lines and dot to the plot
-        ax.add_line(cursor_vert1)
-        ax.add_line(cursor_horiz1)
-        ax.add_patch(dot1)
-        ax.add_line(cursor_vert2)
-        ax.add_line(cursor_horiz2)
-        ax.add_patch(dot2)
-        
-        ax.set_xlabel('Energy (eV)')
-        ax.set_ylabel('Momentum (1/A)')
-        self.axs[0,1].set_xlabel('Energy (eV)')
-        self.axs[0,1].set_ylabel('intensity (a.u.)')
-        initial_xe=1
-        
-        axe.axvline(x=initial_xe, color='red', linestyle='--',linewidth=2, label='Vertical Line')
-        axe.axvline(x=100, color='red', linestyle='--',linewidth=2, label='Vertical Line')
-        axe.axhline(y=0, color='red', linestyle='--',linewidth=2, label='Horizontal Line')
-        axe.axhline(y=100, color='red', linestyle='--',linewidth=2, label='Horizontal Line')
-        plt.draw()
-        update_show(self.slider1.value(),self.slider2.value()) 
-        self.fig.canvas.draw()
-        # def update_cursors():
-        self.active_cursor = None
-        def on_pick(event):
-            # global self.active_cursor
-            if event.artist == cursor_vert1:
-                self.active_cursor = cursor_vert1
-            elif event.artist == cursor_horiz1:
-                self.active_cursor = cursor_horiz1
-            elif event.artist == dot1:
-                self.active_cursor = dot1
-            elif event.artist == cursor_vert2:
-                self.active_cursor = cursor_vert2
-            elif event.artist == cursor_horiz2:
-                self.active_cursor = cursor_horiz2
-            elif event.artist == dot2:
-                self.active_cursor = dot2
-            # elif event.artist == cursor_vert_e1:
-            #     self.active_cursor = cursor_vert_e1
-            elif event.artist == self.Line1:
-                self.active_cursor =self. Line1
-            elif event.artist == self.Line2:
-                self.active_cursor =self. Line2
-        self.active_cursor=None
-        def on_motion(event):
-            # global self.active_cursor
-            if self.active_cursor is not None and event.inaxes == ax:
-                if self.active_cursor == cursor_vert1:
-                    cursor_vert1.set_xdata([event.xdata, event.xdata])
-                    dot1.center = (event.xdata, dot1.center[1])
-                    print(False)
-                elif self.active_cursor == cursor_horiz1:
-                    cursor_horiz1.set_ydata([event.ydata, event.ydata])
-                    dot1.center = (dot1.center[0], event.ydata)
-                elif self.active_cursor == dot1:
-                    dot1.center = (event.xdata, event.ydata)
-                    cursor_vert1.set_xdata([event.xdata, event.xdata])
-                    cursor_horiz1.set_ydata([event.ydata, event.ydata])
-                elif self.active_cursor == cursor_vert2:
-                    cursor_vert2.set_xdata([event.xdata, event.xdata])
-                    dot2.center = (event.xdata, dot2.center[1])
-                elif self.active_cursor == cursor_horiz2:
-                    cursor_horiz2.set_ydata([event.ydata, event.ydata])
-                    dot2.center = (dot2.center[0], event.ydata)
-                elif self.active_cursor == dot2:
-                    dot2.center = (event.xdata, event.ydata)
-                    cursor_vert2.set_xdata([event.xdata, event.xdata])
-                    cursor_horiz2.set_ydata([event.ydata, event.ydata])
-                # print(dot1.center) 
-                self.fig.canvas.draw()
-                
-                
-                plt.draw()
-                if dot1.center[0] is not None and dot1.center[1] is not None and dot2.center[0] is not None and dot2.center[1] is not None:
-                    x1_pixel=int((dot1.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                    y1_pixel=int((dot1.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-                    self.square_coords[0]=(x1_pixel,y1_pixel)
-                    x2_pixel=int((dot2.center[0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                    y2_pixel=int((dot2.center[1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-                    self.square_coords[1]=(x2_pixel,y2_pixel)
-                
-                update_show(self.slider1.value(),self.slider2.value()) 
-               
-            elif self.active_cursor is not None and event.inaxes == axe:
-                if self.active_cursor == self.Line1:
-                    self.Line1.set_xdata([event.xdata, event.xdata])
-                    self.cursorlinev1= event.xdata
-                elif self.active_cursor == self.Line2:
-                    self.Line2.set_xdata([event.xdata, event.xdata])
-                    self.cursorlinev2= event.xdata
-                # print(dot1.center) 
-                # print(self.cursorlinev1,self.cursorlinev2)
-                self.fig.canvas.draw()
-                plt.draw()
-                self.v1_pixel=int((self.cursorlinev1 - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                self.v2_pixel=int((self.cursorlinev2 - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                # print(self.v1_pixel,self.v2_pixel)
-        def on_release(event):
-            # global self.active_cursor
-            self.active_cursor = None
-            
-        # Connect pick and motion events
-        self.fig.canvas.mpl_connect('pick_event', on_pick)
-        self.fig.canvas.mpl_connect('motion_notify_event', on_motion)
-        self.fig.canvas.mpl_connect('button_release_event', on_release)
-       
-        
-        self.update_show=update_show
-        self.integrate_E=integrate_E
-        self.integrate_k=integrate_k
-        self.put_cursors=put_cursors
-        self.remove_cursors=remove_cursors
-        plt.show()
-   
\ No newline at end of file
diff --git a/tests/color_scale.py b/tests/color_scale.py
deleted file mode 100644
index 86e03be..0000000
--- a/tests/color_scale.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import numpy as np
-import h5py
-import matplotlib
-import matplotlib.pyplot as plt
-import numpy as np
-from matplotlib.widgets import CheckButtons, Button
-from scipy.ndimage import rotate
-import h5py
-# import mplcursors
-from matplotlib.widgets import Slider, Cursor, SpanSelector
-
-
-class update_color():
-    def __init__(self,im,fig,ax):
-        # self.slider_plot=s
-        self.im=im
-        self.fig=fig
-        ax_position=ax.get_position()
-        # print(ax.get_position())
-        x0, y0, width, height = ax_position.bounds
-
-        # Print the coordinates
-        # print("Lower-left coordinate (x0, y0):", x0, y0)
-        # print("Upper-right coordinate (x1, y1):", x0 + width, y0 + height)
-        self.cbar = plt.colorbar(im, ax=ax)
-        # self.cbar.ax.set_position([0.43, 0.31, 0.01, 0.8])
-        # self.ax_slider = fig.add_axes([0.42, 0.56, 0.01, 0.30], facecolor='lightgoldenrodyellow')
-        self.cbar.ax.set_position([x0 + width +0.013, y0-0.08, 0.01, 0.5])
-        self.ax_slider = fig.add_axes([x0 + width +0.006, y0 + 0.03, 0.01, 0.30], facecolor='lightgoldenrodyellow')
-        self.slider_plot = Slider(self.ax_slider, '', -1.5, 1.5, valinit=0.0,valstep=0.01,orientation='vertical')
-        self.original_vmax = im.norm.vmax
-        # self.slider_plot.on_changed(self.update)
-    def update(self,val):
-        # print('whathbdjfs')
-        self.im.norm.vmax = 10**(self.slider_plot.val) * self.original_vmax
-        
-        # self.fig.canvas.draw_idle()
-    def slider (self):
-        self.slider_plot.on_changed(self.update)
-    def sprint(self,val):
-        print('somethign', self.slider_plot)
-        # self.fig.canvas.draw_idle()
-        # print('slider')    
-        
diff --git a/tests/fit_panel6.py b/tests/fit_panel6.py
deleted file mode 100644
index cbf2070..0000000
--- a/tests/fit_panel6.py
+++ /dev/null
@@ -1,701 +0,0 @@
-import sys
-from PyQt5.QtGui import QBrush, QColor
-from PyQt5.QtWidgets import QTextEdit, QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, QWidget, QSlider, QLabel, QAction, QCheckBox, QPushButton, QListWidget, QTableWidget, QTableWidgetItem, QTableWidget, QCheckBox, QSplitter
-from PyQt5.QtCore import Qt
-from PyQt5.QtWidgets import QTableWidgetItem, QHBoxLayout, QCheckBox, QWidget
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
-import matplotlib.pyplot as plt
-from scipy.optimize import curve_fit
-import numpy as np
-from lmfit.models import ExpressionModel,Model
-from lmfit import CompositeModel, Model
-from lmfit.lineshapes import gaussian, step
-import inspect
-from numpy import loadtxt
-from movable_vertical_cursors_graph import MovableCursors
-from make_model import make_model
-from graphs2 import showgraphs
-
-
-
-class MainWindow(QMainWindow):
-    def __init__(self,data,axis,c1,c2,t,dt):
-        super().__init__()
-
-        self.setWindowTitle("Main Window")
-        self.setGeometry(100, 100, 1500, 800)
-        
-        # Create a menu bar
-        menu_bar = self.menuBar()
-
-        # Create a 'View' menu
-        view_menu = menu_bar.addMenu("View")
-
-        # Create actions for showing and hiding the graph window
-        show_graph_action = QAction("Show Graph", self)
-        show_graph_action.triggered.connect(self.show_graph_window)
-        view_menu.addAction(show_graph_action)
-
-        # Store references to graph windows to prevent garbage collection
-        self.graph_windows = []
-
-        # Create a central widget
-        central_widget = QWidget()
-        self.setCentralWidget(central_widget)
-
-        # Create a layout for the central widget
-        layout = QHBoxLayout()
-        central_widget.setLayout(layout)
-
-        # Create a splitter for two panels
-        splitter = QSplitter(Qt.Horizontal)
-
-        # Create a left panel widget and its layout
-        left_panel = QWidget()
-        left_layout = QVBoxLayout()
-        left_panel.setLayout(left_layout)
-
-        # Create a right panel widget and its layout
-        right_panel = QWidget()
-        right_layout = QVBoxLayout()
-        right_panel.setLayout(right_layout)
-
-        # Add the panels to the splitter
-        splitter.addWidget(left_panel)
-        splitter.addWidget(right_panel)
-        
-        self.figure, self.axis = plt.subplots()
-        self.canvas = FigureCanvas(self.figure)
-        # Create two checkboxes
-        self.checkbox0 = QCheckBox("Cursors")
-        self.checkbox0.stateChanged.connect(self.checkbox0_changed)
-        
-        self.slider = QSlider(Qt.Horizontal)
-        self.slider.setMinimum(0)
-        self.slider.setMaximum(len(axis[2])-1)
-        self.slider.setValue(t)
-        self.slider.valueChanged.connect(self.update_label)
-        self.slider2 = QSlider(Qt.Horizontal)
-        self.slider2.setMinimum(0)
-        self.slider2.setMaximum(10)
-        self.slider2.setValue(dt)
-        self.slider2.valueChanged.connect(self.update_label2)
- 
-        self.label = QLabel("Slider Value: {t}")
-        self.label2 = QLabel("Slider Value: {dt}")
-
-        # Create two checkboxes
-        self.checkbox1 = QCheckBox("Multiply with Fermi Dirac")
-        self.checkbox1.stateChanged.connect(self.checkbox1_changed)
-
-        self.checkbox2 = QCheckBox("Convolve with a Gaussian")
-        self.checkbox2.stateChanged.connect(self.checkbox2_changed)
-
-        # Create a QListWidget
-        self.list_widget = QListWidget()
-        self.list_widget.addItems(["linear","Lorentz", "Gauss", "sinusoid","constant","jump"])
-        self.list_widget.setMaximumSize(120,150)
-        self.list_widget.itemClicked.connect(self.item_selected)
-
-        self.add_button = QPushButton("add")
-        self.add_button.clicked.connect(self.button_add_clicked)
-        
-        self.remove_button = QPushButton("remove")
-        self.remove_button.clicked.connect(self.button_remove_clicked)
-        
-
-        self.graph_button = QPushButton("clear graph")
-        self.graph_button.clicked.connect(self.show_graph_window)
-        
-        self.fit_button = QPushButton("Fit")
-        self.fit_button.clicked.connect(self.fit)
-        
-        self.fitall_button = QPushButton("Fit all")
-        self.fitall_button.clicked.connect(self.fit_all)
-        
-        left_buttons=QVBoxLayout()
-        left_sublayout=QHBoxLayout()
-        
-        left_buttons.addWidget(self.add_button)
-        left_buttons.addWidget(self.remove_button)
-        left_buttons.addWidget(self.graph_button)
-        left_buttons.addWidget(self.fit_button)
-        left_buttons.addWidget(self.fitall_button)
-        
-        left_sublayout.addWidget(self.list_widget)
-        left_sublayout.addLayout(left_buttons) 
-
-        # Add widgets to the left layout
-        left_layout.addWidget(self.canvas)
-        left_layout.addWidget(self.checkbox0)
-        left_layout.addWidget(self.slider)
-        left_layout.addWidget(self.label)
-        left_layout.addWidget(self.slider2)
-        left_layout.addWidget(self.label2)
-        left_layout.addLayout(left_sublayout) 
-        
-        # left_layout.addWidget(self.list_widget)
-        # left_layout.addWidget(self.add_button)
-        # left_layout.addWidget(self.remove_button)
-        # left_layout.addWidget(self.graph_button)
-        # left_layout.addWidget(self.fit_button)
-        # left_layout.addWidget(self.fitall_button)
-        
-        self.text_equation = QTextEdit()
-        # self.text_equation.setMinimumSize(50, 50)  # Set minimum size
-        self.text_equation.setMaximumSize(500, 30)  # Set maximum size
-        
-        # Create a table widget for the right panel
-        self.table_widget = QTableWidget(0, 4)  # 6 rows and 4 columns (including the special row)
-        self.table_widget.setHorizontalHeaderLabels(['min', 'value', 'max', 'fix'])
-        # self.table_widget.setVerticalHeaderLabels(['Row 1', 'The ROW', 'Row 2', 'Row 3', 'Row 4', 'Row 5'])
-        self.table_widget.itemChanged.connect(self.table_item_changed)
-        self.table_widget.setMaximumSize(700,500)
-        # Add checkboxes to the last column of the table, except for the special row
-        for row in range(6):
-            if row != 1:  # Skip 'The ROW'
-                checkbox_widget = QWidget()
-                checkbox_layout = QHBoxLayout()
-                checkbox_layout.setAlignment(Qt.AlignCenter)
-                checkbox = QCheckBox()
-                checkbox_layout.addWidget(checkbox)
-                checkbox_widget.setLayout(checkbox_layout)
-                self.table_widget.setCellWidget(row, 3, checkbox_widget)
-
-        # Set 'The ROW' with uneditable empty cells
-        for col in range(4):
-            # if col == 3:  # Skip the checkbox column for 'The ROW'
-            #     continue
-            item = QTableWidgetItem('')
-            item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
-            self.table_widget.setItem(1, col, item)
-
-        # Add the table to the right layout
-        checkboxes=QVBoxLayout()
-        top_lay = QHBoxLayout()
-        checkboxes.addWidget(self.checkbox1)
-        checkboxes.addWidget(self.checkbox2)
-        top_lay.addWidget(self.text_equation)
-        top_lay.addLayout(checkboxes)
-        right_layout.addLayout(top_lay)
-        right_layout.addWidget(self.table_widget)
-
-        # Add the splitter to the main layout
-        layout.addWidget(splitter)
-        def zero(x):
-            return 0
-        self.equation= None
-        self.mod= Model(zero)
-        self.total_function=zero
-        self.function_before_Fermi= zero
-        self.function_before_convoluted= zero
-        self.update_text_edit_boxes()
-        self.i=0
-        
-        self.function_list=[]
-        self.function_names_list=[]
-        # Add a button to activate cursors
-        # self.add_cursors_button = QPushButton("Add Movable Cursors", self)
-        # self.add_cursors_button.clicked.connect(self.add_movable_cursors)
-        # right_layout.addWidget(self.add_cursors_button)
-
-        # To hold the MovableCursors instance
-        self.cursor_handler = None
-        self.FD_state = False
-        self.CV_state = False
-        print('data=',data.shape,'axs',len(axis),'axis1',len(axis[0]),'axis2',len(axis[1]),'axis3',len(axis[2]))
-        self.axs=axis
-        self.data_t=np.zeros((data.shape[1],data.shape[2]))
-        x_min = int(min(c1, c2))
-        x_max = int(max(c1, c2)) + 1
-        print('xmin=',x_min,'xmax=',x_max)
-        for i in range(x_min, x_max):
-            self.data_t += data[i, :,:]
-        print('data_t',self.data_t.shape)
-        self.t=t
-        self.dt=dt
-        print(t,dt)
-        self.slider.setValue(self.t)
-        self.slider2.setValue(self.dt)
-        self.plot_graph(t,dt)
-        self.fit_results=[]
-        
-    # def add_movable_cursors(self):
-    #     if self.cursor_handler is None:
-    #         # Initialize and add the cursors to the existing plot
-    #         self.cursor_handler = MovableCursors(self.axis)
-    #         self.canvas.draw()
-
-    def plot_graph(self,t,dt):
-        # Sample data
-        # self.x = np.linspace(-5,5,100)
-        # self.y = np.linspace(10,100,100)
-        self.y=np.zeros((self.data_t.shape[0]))
-        print('thecomp',self.y.shape,self.data_t[:,1].shape)
-        # data = loadtxt('C:/Users/admin-nisel131/Documents/CVS_TR_flatband_fig/EDC_time=0_2024-05-08_093401_6994.txt')
-        self.axis.clear()
-        # self.x= data[:,0]   
-        # self.y= data[:,1]
-        self.x=self.axs[1][:]
-        for i in range(0,dt+1):
-            self.y +=self.data_t[:,t+i]
-        
-        
-        self.axis.plot(self.x, self.y, 'bo', label='Data')
-
-        self.axis.set_title('Sample Graph')
-        self.axis.set_xlabel('X')
-        self.axis.set_ylabel('Y')
-        self.axis.legend()
-        self.figure.tight_layout()
-        self.canvas.draw()
-        print('sliders=',self.slider.value(),self.slider2.value())
-    def update_text_edit_boxes(self):
-        self.text_equation.setPlaceholderText("Top Right Text Edit Box")
-    
-    def constant (self,x,b):
-        return 0*x+b
-    def linear (self,x,a,b):
-        return a*x+b
-    def lorentzian(self,x, A, x0, gamma):
-        c=0.0002
-        return A / (1 + ((x - x0) / (gamma+c)) ** 2)
-    # def fermi_dirac(self,x, mu, T,off):
-    #     kb = 8.617333262145 * 10**(-5)  # Boltzmann constant in eV/K
-    #     return 1 / (1 + np.exp((x - mu) / (kb * T)))+off
-    def fermi_dirac(self,x, mu, T):
-        kb = 8.617333262145 * 10**(-5)  # Boltzmann constant in eV/K
-        return 1 / (1 + np.exp((x - mu) / (kb * T)))
-    def gaussian(self,x,A, mu, sigma):
-        return A* np.exp(-(x - mu)**2 / (2 * sigma**2))
-    def gaussian_conv(self,x,sigma):
-        return  np.exp(-(x)**2 / (2 * sigma**2))
-    def jump(self,x, mid):
-        """Heaviside step function."""
-        o = np.zeros(x.size)
-        imid = max(np.where(x <= mid)[0])
-        o[imid:] = 1.0
-        return o
-    def jump2(self,x, mid,Amp):
-        """Heaviside step function."""
-        o = np.zeros(x.size)
-        imid = max(np.where(x <= mid)[0])
-        o[:imid] = Amp
-        return o
-    
-    
-    def convolve(self, arr, kernel):
-        """Simple convolution of two arrays."""
-        npts = min(arr.size, kernel.size)
-        pad = np.ones(npts)
-        tmp = np.concatenate((pad*arr[0], arr, pad*arr[-1]))
-        out = np.convolve(tmp, kernel, mode='valid')
-        noff = int((len(out) - npts) / 2)
-        return out[noff:noff+npts]
-    
-    def convolution(x, func, *args, sigma=1.0):
-            N = 20  # Assuming N is intended to be a local variable here
-            x_step = x[1] - x[0]
-            
-            # Create the shifted input signal 'y' for convolution
-            y = np.zeros(N + len(x))
-            for i in range(N):
-                y[i] = x[0] - (N - i) * x_step
-            y[N:] = x  # Append the original signal x to y
-            
-            # Create the Gaussian kernel
-            x_gauss = np.linspace(-0.5, 0.5, len(x))
-            gaussian_values = np.exp(-0.5 * (x_gauss / sigma)**2) / (sigma * np.sqrt(2 * np.pi))
-            
-            # Evaluate the function values with parameters
-            function_values = func(x, *args)
-            
-            # Perform convolution
-            convolution_result = np.convolve(function_values, gaussian_values, mode='same')
-            
-            return convolution_result[N-1:-1]
-    
-    # def convolution(self,x,sigma,f):
-    #     global N
-    #     xmax=x[-1]
-    #     xmin=x[0]
-    #     N=20
-    #     y=np.zeros(N+len(x))
-    #     x_step=x[1]-x[0]
-    #     for i in range(0,N):
-    #         y[i]=x[0]-(N-i)*x_step
-    #     for i in range(0,len(x)):
-    #         y[i+N]=x[i]
-    #     x_gauss = np.linspace(-0.5, 0.5, len(self.ax))
-    #     gaussian_values = self.gaussian(x_gauss, 0, sigma)
-    #     # function_values = 
-    #     convolution = np.convolve( function_values, gaussian_values, mode='same')
-    #     return convolution[N-1:-1]
-    
-    def show_graph_window(self):
-        # Create a new graph window and show it
-        # graph_window = GraphWindow()
-        # graph_window.show()
-        
-        # # Store a reference to the window to prevent it from being garbage collected
-        # self.graph_windows.append(graph_window)
-        self.axis.clear()
-        self.plot_graph(self.t,self.dt)
-        
-        
-    def update_label(self, value):
-        self.label.setText(f"Slider Value: {value}")
-        self.t=self.slider.value()
-        self.plot_graph(self.t,self.dt)
-    def update_label2(self, value):
-        self.label2.setText(f"Slider Value: {value}")
-        self.dt=self.slider2.value()
-        self.plot_graph(self.t,self.dt)
-    
-    def checkbox0_changed(self, state):
-        # MovableCursors(self.axis)
-        if state == Qt.Checked:
-            if self.cursor_handler is None:
-                # Initialize and add the cursors to the existing plot
-                self.cursor_handler = MovableCursors(self.axis)
-                self.canvas.draw()
-            else:
-                self.cursor_handler.redraw()
-        else:
-            self.cursor_handler.remove()
-            # self.cursor_handler= None
-    
-    def checkbox1_changed(self, state):
-        if self.CV_state== True:
-            pos=2
-        else:
-            pos=0
-        if state == Qt.Checked:
-            self.FD_state = True
-            self.update_equation()
-            # pos=0
-            
-            print("Checkbox 1 is checked")
-            # new_row_name = QTableWidgetItem('Fermi')
-            self.table_widget.insertRow(pos)
-            label_item = QTableWidgetItem("Fermi")
-            # label_item.setTextAlignment(0x0004 | 0x0080)  # Align center
-            self.table_widget.setVerticalHeaderItem(pos, label_item)
-            # self.table_widget.setVerticalHeaderItem(0, new_row_name)
-            for col in range(4):
-                item = QTableWidgetItem('')
-                item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
-                self.table_widget.setItem(pos, col, item)
-                item.setBackground(QBrush(QColor('grey')))
-            c=self.table_widget.rowCount()
-            self.table_widget.insertRow(pos+1)
-            label_item1 = QTableWidgetItem("Fermi level")
-            # label_item1.setTextAlignment(0x0004 | 0x0080)  # Align center
-            checkbox_widget = QWidget()
-            checkbox_layout = QHBoxLayout()
-            checkbox_layout.setAlignment(Qt.AlignCenter)
-            checkbox = QCheckBox()
-            # checkbox.stateChanged.connect(self.handle_checkbox_state_change)
-            checkbox.stateChanged.connect(lambda state, row= pos+1: self.handle_checkbox_state_change(state, row))
-            print('thecount',c+1)
-            checkbox_layout.addWidget(checkbox)
-            checkbox_widget.setLayout(checkbox_layout)
-            self.table_widget.setCellWidget(pos+1, 3, checkbox_widget)
-            self.table_widget.setVerticalHeaderItem(pos+1, label_item1)
-            
-            self.table_widget.insertRow(pos+2)
-            label_item2 = QTableWidgetItem("Temperature")
-            checkbox_widget = QWidget()
-            checkbox_layout = QHBoxLayout()
-            checkbox_layout.setAlignment(Qt.AlignCenter)
-            checkbox = QCheckBox()
-            # checkbox.stateChanged.connect(self.handle_checkbox_state_change)
-            checkbox.stateChanged.connect(lambda state, row= pos+2: self.handle_checkbox_state_change(state, row))
-            checkbox_layout.addWidget(checkbox)
-            checkbox_widget.setLayout(checkbox_layout)
-            self.table_widget.setCellWidget(pos+2, 3, checkbox_widget)
-            # label_item2.setTextAlignment(0x0004 | 0x0080)  # Align center
-            self.table_widget.setVerticalHeaderItem(pos+2, label_item2)
-            
-            
-            
-        else:
-            self.FD_state = False
-            self.update_equation()
-            print("Checkbox 1 is unchecked")
-            
-            self.table_widget.removeRow(pos)
-            self.table_widget.removeRow(pos)
-            self.table_widget.removeRow(pos)
-            
-    def checkbox2_changed(self, state):
-        if state == Qt.Checked:
-            self.CV_state = True
-            
-            self.update_equation()
-           
-           
-            print("Checkbox 1 is checked")
-            # new_row_name = QTableWidgetItem('Fermi')
-            self.table_widget.insertRow(0)
-            label_item = QTableWidgetItem("Convolution")
-            # label_item.setTextAlignment(0x0004 | 0x0080)  # Align center
-            self.table_widget.setVerticalHeaderItem(0, label_item)
-            # self.table_widget.setVerticalHeaderItem(0, new_row_name)
-            for col in range(4):
-                item = QTableWidgetItem('')
-                item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
-                self.table_widget.setItem(0, col, item)
-                item.setBackground(QBrush(QColor('grey')))
-                
-            self.table_widget.insertRow(1)
-            label_item1 = QTableWidgetItem("sigma")
-            checkbox_widget = QWidget()
-            checkbox_layout = QHBoxLayout()
-            checkbox_layout.setAlignment(Qt.AlignCenter)
-            checkbox = QCheckBox()
-            # checkbox.stateChanged.connect(self.handle_checkbox_state_change)
-            checkbox.stateChanged.connect(lambda state, row= 1: self.handle_checkbox_state_change(state, row))
-            checkbox_layout.addWidget(checkbox)
-            checkbox_widget.setLayout(checkbox_layout)
-            self.table_widget.setCellWidget(1, 3, checkbox_widget)
-            # label_item1.setTextAlignment(0x0004 | 0x0080)  # Align center
-            self.table_widget.setVerticalHeaderItem(1, label_item1)
-            
-            # self.table_widget.insertRow(2)
-            # label_item2 = QTableWidgetItem("Temperature")
-            # # label_item2.setTextAlignment(0x0004 | 0x0080)  # Align center
-            # self.table_widget.setVerticalHeaderItem(2, label_item2)
-            
-            
-            
-        else:
-            self.CV_state = False
-            self.update_equation()
-            print("Checkbox 1 is unchecked")
-            
-            self.table_widget.removeRow(0)
-            self.table_widget.removeRow(0)
-            # self.table_widget.removeRow(0)
-
-    def item_selected(self, item):
-        print(f"Selected: {item.text()}")
-        if item.text() == 'Lorentz':
-            self.function_selected = self.lorentzian
-        elif item.text() == 'Gauss':
-            self.function_selected = self.gaussian 
-        elif item.text()=='linear':
-            self.function_selected =self.linear
-        elif item.text()=='constant':
-            self.function_selected =self.constant
-        elif item.text()=='jump':
-            self.function_selected =self.jump2
-        # print(self.list_widget.currentItem().text())
-    
-    def button_remove_clicked(self):
-        if self.i>0:
-            self.i-=1
-        # self.mod=
-        # print('removal')
-        current_row_count = self.table_widget.rowCount()
-        print(current_row_count)
-        sig = inspect.signature(self.function_list[-1])
-        params = sig.parameters
-        
-        for p in range(len(params)):
-            # print('p=',p)
-            # print('count=',current_row_count-1-p)
-            self.table_widget.removeRow(current_row_count-1-p)    
-            
-        self.function_list.remove(self.function_list[-1])
-        self.function_names_list.remove(self.function_names_list[-1])
-        self.update_equation()
-
-    def button_add_clicked(self):
-        # print(self.cursor_handler.cursors())
-        def zero(x):
-            return 0
-        
-        
-        self.i+=1
-        self.function_list.append(self.function_selected)
-        self.function_names_list.append(self.list_widget.currentItem().text())
-       
-        print('the list=',self.function_list,'iten',self.function_list[0])
-        print('listlength=',len(self.function_list))
-        j=0
-        for p in self.function_list:
-            # j=0
-            print('j==',j)
-            current_function=Model(p,prefix='f'+str(j)+'_')
-            j+=1
-            
-        
-        current_row_count = self.table_widget.rowCount()
-        
-        self.table_widget.insertRow(current_row_count)
-        # self.table_widget.setVerticalHeaderLabels([self.list_widget.currentItem().text()])
-        new_row_name = QTableWidgetItem(self.list_widget.currentItem().text())
-        self.table_widget.setVerticalHeaderItem(current_row_count, new_row_name)
-        for col in range(4):
-            item = QTableWidgetItem('')
-            item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
-            self.table_widget.setItem(current_row_count, col, item)
-            item.setBackground(QBrush(QColor('grey')))
-        c=current_row_count
-        # self.table_widget.insertRow(1)
-        # self.table_widget.insertRow(2)
-        for p in range(len(current_function.param_names)):
-            # c+=1
-            # print(c+p+1)
-            self.table_widget.insertRow(c+p+1)
-            print(current_function.param_names[p])
-            new_row_name = QTableWidgetItem(current_function.param_names[p])
-            self.table_widget.setVerticalHeaderItem(c+p+1, new_row_name)
-            checkbox_widget = QWidget()
-            checkbox_layout = QHBoxLayout()
-            checkbox_layout.setAlignment(Qt.AlignCenter)
-            checkbox = QCheckBox()
-            # checkbox.stateChanged.connect(self.handle_checkbox_state_change)
-            checkbox.stateChanged.connect(lambda state, row=c + p + 1: self.handle_checkbox_state_change(state, row))
-            checkbox_layout.addWidget(checkbox)
-            checkbox_widget.setLayout(checkbox_layout)
-            self.table_widget.setCellWidget(c+p+1, 3, checkbox_widget)
-            # self.table_widget.setVerticalHeaderLabels([Model(self.function_selected).param_names[p]])
-        # print(self.Mod.param_names)
-        # params['A'].set(value=1.35, vary=True, expr='')
-        
-        self.update_equation()
-        # print(self.params)
-        
-    def update_equation(self):
-        self.equation=''
-        print('names',self.function_names_list)
-        for j,n in enumerate(self.function_names_list):
-            if len(self.function_names_list)==1:
-                self.equation= n
-            else:
-                if j==0:
-                    self.equation= n
-                else:
-                    self.equation+= '+' + n
-        if self.FD_state:
-            self.equation= '('+ self.equation+ ')* Fermi_Dirac'
-        self.text_equation.setPlainText(self.equation)
-        print('equation',self.equation)
-    
-
-    def table_item_changed(self, item):
-        print(f"Table cell changed at ({item.row()}, {item.column()}): {item.text()}")
-        header_item = self.table_widget.verticalHeaderItem(item.row())
-        # print(header_item.text())
-        print('theeeeeeitem=',item.text())
-        
-    def handle_checkbox_state_change(self,state,row):
-        if state == Qt.Checked:
-            print("Checkbox is checked")
-            print(row)
-            header_item = self.table_widget.verticalHeaderItem(row)
-            # self.params[header_item.text()].vary = False
-            
-        else:
-            print("Checkbox is unchecked")
-            header_item = self.table_widget.verticalHeaderItem(row)
-            # self.params[header_item.text()].vary = True
-    def fit(self):
-        
-        def zero(x):
-            return 0
-        self.mod= Model(zero)
-        j=0
-        for f in self.function_list:
-            self.mod+=Model(f,prefix='f'+str(j)+'_')
-            j+=1
-        if self.FD_state == True:
-            self.mod= self.mod* Model(self.fermi_dirac)
-        if self.CV_state == True:
-            # self.mod=CompositeModel(self.mod, Model(self.gaussian_conv), self.convolve)
-            self.mod=CompositeModel(self.mod, Model(self.gaussian_conv), self.convolve)
-            # self.mod=CompositeModel(Model(self.jump), Model(gaussian), self.convolve)
-            
-        m1=make_model(self.mod, self.table_widget)
-        self.mod=m1.current_model()
-        # self.mod = CompositeModel(m1.current_model(), Model(gaussian), self.convolve)
-        self.params=m1.current_params()
-        # self.params=self.mod.make_params()
-        cursors= self.cursor_handler.cursors()
-        self.x_f=self.x[cursors[0]:cursors[1]]
-        self.y_f=self.y[cursors[0]:cursors[1]]
-        print(self.params)
-        # params['b'].set(value=0, vary=True, expr='')
-        # out = mod.fit(self.data[:,1], params, x=self.data[:,0],method='nelder')
-        out = self.mod.fit(self.y_f, self.params, x=self.x_f)
-        # dely = out.eval_uncertainty(sigma=3)
-        print(out.fit_report(min_correl=0.25))
-        self.axis.plot(self.x_f,out.best_fit,color='red',label='fit')
-        # self.axis.plot(self.x_f,1e5*self.gaussian_conv(self.x_f,out.best_values['sigma']))
-    def fit_all(self):
-        self.fit_results=[]
-        def zero(x):
-            return 0
-        self.mod= Model(zero)
-        j=0
-        for f in self.function_list:
-            self.mod+=Model(f,prefix='f'+str(j)+'_')
-            j+=1
-        if self.FD_state == True:
-            self.mod= self.mod* Model(self.fermi_dirac)
-        if self.CV_state == True:
-            # self.mod=CompositeModel(self.mod, Model(self.gaussian_conv), self.convolve)
-            self.mod=CompositeModel(self.mod, Model(self.gaussian_conv), self.convolve)
-        m1=make_model(self.mod, self.table_widget)
-        self.mod=m1.current_model()
-        self.params=m1.current_params()
-        for pname, par in self.params.items():
-            print('the paramsnames or',pname, par)
-            setattr(self, pname, np.zeros((len(self.axs[2]))))
-            # self.pname=np.zeros((len(self.axs[2])))
-        cursors= self.cursor_handler.cursors()
-        for i in range(len(self.axs[2])-self.dt):
-            self.y=np.zeros((self.data_t.shape[0]))
-            for j in range (self.dt+1):
-                self.y+= self.data_t[:,i+j]
-            self.x_f=self.x[cursors[0]:cursors[1]]
-            self.y_f=self.y[cursors[0]:cursors[1]]
-            # print(self.params)
-            # params['b'].set(value=0, vary=True, expr='')
-            # out = mod.fit(self.data[:,1], params, x=self.data[:,0],method='nelder')
-            self.axis.clear()
-            out = self.mod.fit(self.y_f, self.params, x=self.x_f)
-            # dely = out.eval_uncertainty(sigma=3)
-            # print(out.fit_report(min_correl=0.25))
-            self.axis.plot(self.x,self.y, 'bo', label='Data')
-            self.axis.plot(self.x_f,out.best_fit,color='red',label='fit')
-            for pname, par in self.params.items():
-                array=getattr(self, pname)
-                array[i]=out.best_values[pname]
-                setattr(self, pname,array)
-        if self.dt>0:
-            self.axs[2]=self.axs[2][:-self.dt]
-            for pname, par in self.params.items():
-                self.fit_results.append(getattr(self, pname)[:-self.dt])
-        else:
-            for pname, par in self.params.items():
-                self.fit_results.append(getattr(self, pname))
-        print('fit_results',len(self.fit_results))
-        print('thelengthis=',self.fit_results[0].shape)
-        
-            
-        sg=showgraphs(self.axs[2], self.fit_results)
-        sg.show()
-        self.graph_windows.append(sg)
-        # pname='T'
-        # print(getattr(self, pname))
-            # out.best_values['A1']
-            # self.axis.clear()
-
-if __name__ == "__main__":
-    app = QApplication(sys.argv)
-    window = MainWindow()
-    window.show()
-    sys.exit(app.exec_())
diff --git a/tests/fit_panel_signle_test.py b/tests/fit_panel_signle_test.py
deleted file mode 100644
index 1213d66..0000000
--- a/tests/fit_panel_signle_test.py
+++ /dev/null
@@ -1,577 +0,0 @@
-import sys
-from PyQt5.QtGui import QBrush, QColor
-from PyQt5.QtWidgets import QTextEdit, QLineEdit,QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, QWidget, QSlider, QLabel, QAction, QCheckBox, QPushButton, QListWidget, QTableWidget, QTableWidgetItem, QTableWidget, QCheckBox, QSplitter
-from PyQt5.QtCore import Qt
-from PyQt5.QtWidgets import QTableWidgetItem, QHBoxLayout, QCheckBox, QWidget
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
-import matplotlib.pyplot as plt
-from scipy.optimize import curve_fit
-import numpy as np
-from lmfit.models import ExpressionModel,Model
-from lmfit import CompositeModel, Model
-from lmfit.lineshapes import gaussian, step
-import inspect
-from mpes_tools.movable_vertical_cursors_graph import MovableCursors
-from mpes_tools.make_model import make_model
-from mpes_tools.graphs import showgraphs
-from numpy import loadtxt
-import xarray as xr
-
-
-class fit_panel_single(QMainWindow):
-    def __init__(self):
-        super().__init__()
-
-        self.setWindowTitle("Main Window")
-        self.setGeometry(100, 100, 1500, 800)
-        
-        # Create a menu bar
-        menu_bar = self.menuBar()
-
-        # Create a 'View' menu
-        view_menu = menu_bar.addMenu("View")
-
-        # Create actions for showing and hiding the graph window
-        clear_graph_action = QAction("Show Graph", self)
-        clear_graph_action.triggered.connect(self.clear_graph_window)
-        view_menu.addAction(clear_graph_action)
-
-        # Store references to graph windows to prevent garbage collection
-        self.graph_windows = []
-
-        # Create a central widget
-        central_widget = QWidget()
-        self.setCentralWidget(central_widget)
-
-        # Create a layout for the central widget
-        layout = QHBoxLayout()
-        central_widget.setLayout(layout)
-
-        # Create a splitter for two panels
-        splitter = QSplitter(Qt.Horizontal)
-
-        # Create a left panel widget and its layout
-        left_panel = QWidget()
-        left_layout = QVBoxLayout()
-        left_panel.setLayout(left_layout)
-
-        # Create a right panel widget and its layout
-        right_panel = QWidget()
-        right_layout = QVBoxLayout()
-        right_panel.setLayout(right_layout)
-
-        # Add the panels to the splitter
-        splitter.addWidget(left_panel)
-        splitter.addWidget(right_panel)
-        
-        self.figure, self.axis = plt.subplots()
-        plt.close(self.figure)
-        self.canvas = FigureCanvas(self.figure)
-        # Create two checkboxes
-        self.checkbox0 = QCheckBox("Cursors")
-        self.checkbox0.stateChanged.connect(self.checkbox0_changed)
-        
-
-        # Create two checkboxes
-        self.checkbox1 = QCheckBox("Multiply with Fermi Dirac")
-        self.checkbox1.stateChanged.connect(self.checkbox1_changed)
-
-        self.checkbox2 = QCheckBox("Convolve with a Gaussian")
-        self.checkbox2.stateChanged.connect(self.checkbox2_changed)
-        
-        self.checkbox3 = QCheckBox("add background offset")
-        self.checkbox3.stateChanged.connect(self.checkbox3_changed)
-
-        
-        self.guess_button = QPushButton("Guess")
-        self.guess_button.clicked.connect(self.button_guess_clicked)
-        
-        bigger_layout = QVBoxLayout()
-        bigger_layout.addWidget(self.guess_button)
-        # Create a QListWidget
-        self.list_widget = QListWidget()
-        self.list_widget.addItems(["linear","Lorentz", "Gauss", "sinusoid","constant","jump"])
-        self.list_widget.setMaximumSize(120,150)
-        self.list_widget.itemClicked.connect(self.item_selected)
-
-        self.add_button = QPushButton("add")
-        self.add_button.clicked.connect(self.button_add_clicked)
-        
-        self.remove_button = QPushButton("remove")
-        self.remove_button.clicked.connect(self.button_remove_clicked)
-        
-
-        self.graph_button = QPushButton("clear graph")
-        self.graph_button.clicked.connect(self.clear_graph_window)
-        
-        self.fit_button = QPushButton("Fit")
-        self.fit_button.clicked.connect(self.fit)
-
-
-        
-        left_buttons=QVBoxLayout()
-        left_sublayout=QHBoxLayout()
-        
-        left_buttons.addWidget(self.add_button)
-        left_buttons.addWidget(self.remove_button)
-        left_buttons.addWidget(self.graph_button)
-        left_buttons.addWidget(self.fit_button)
-
-        
-        left_sublayout.addWidget(self.list_widget)
-        left_sublayout.addLayout(left_buttons) 
-
-        # Add widgets to the left layout
-        left_layout.addWidget(self.canvas)
-        left_layout.addWidget(self.checkbox0)
-        left_layout.addLayout(left_sublayout) 
-        
-        
-        self.text_equation = QTextEdit()
-        # self.text_equation.setMinimumSize(50, 50)  # Set minimum size
-        self.text_equation.setMaximumSize(500, 30)  # Set maximum size
-        
-        # Create a table widget for the right panel
-        self.table_widget = QTableWidget(0, 4)  # 6 rows and 4 columns (including the special row)
-        self.table_widget.setHorizontalHeaderLabels(['min', 'value', 'max', 'fix'])
-        # self.table_widget.setVerticalHeaderLabels(['Row 1', 'The ROW', 'Row 2', 'Row 3', 'Row 4', 'Row 5'])
-        self.table_widget.itemChanged.connect(self.table_item_changed)
-        self.table_widget.setMaximumSize(700,500)
-        # Add checkboxes to the last column of the table, except for the special row
-        for row in range(6):
-            if row != 1:  # Skip 'The ROW'
-                checkbox_widget = QWidget()
-                checkbox_layout = QHBoxLayout()
-                checkbox_layout.setAlignment(Qt.AlignCenter)
-                checkbox = QCheckBox()
-                checkbox_layout.addWidget(checkbox)
-                checkbox_widget.setLayout(checkbox_layout)
-                self.table_widget.setCellWidget(row, 3, checkbox_widget)
-
-        # Set 'The ROW' with uneditable empty cells
-        for col in range(4):
-            # if col == 3:  # Skip the checkbox column for 'The ROW'
-            #     continue
-            item = QTableWidgetItem('')
-            item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
-            self.table_widget.setItem(1, col, item)
-
-        # Add the table to the right layout
-        checkboxes=QVBoxLayout()
-        top_lay = QHBoxLayout()
-        above_table=QVBoxLayout()
-        checkboxes.addWidget(self.checkbox1)
-        checkboxes.addWidget(self.checkbox2)
-        checkboxes.addWidget(self.checkbox3)
-        top_lay.addWidget(self.text_equation)
-        top_lay.addLayout(checkboxes)
-        above_table.addLayout(top_lay)
-        above_table.addLayout(bigger_layout)
-        right_layout.addLayout(above_table)
-        right_layout.addWidget(self.table_widget)
-
-        # Add the splitter to the main layout
-        layout.addWidget(splitter)
-        def zero(x):
-            return 0
-        self.equation= None
-        self.mod= Model(zero)
-        self.total_function=zero
-        self.function_before_Fermi= zero
-        self.function_before_convoluted= zero
-        self.update_text_edit_boxes()
-        self.i=0
-        
-        self.function_list=[]
-        self.function_names_list=[]
-        self.cursor_handler = None
-        self.FD_state = False
-        self.CV_state = False
-        self.t0_state = False
-        self.offset_state = False
-        # self.data=data
-        # self.y=data
-        # self.dim=self.data.dims[0]
-        self.dim='delay'
-        self.plot_graph()
-        
-        
-    def plot_graph(self):
-        self.axis.clear()
-        data= loadtxt('//nap33/wahada/data_CVS_new/11626/vhs3/position2025-03-13_173331.txt')
-        dim= self.dim
-        title='peak'
-        self.y = xr.DataArray(
-            data=data[:,1],
-            dims=[dim],                # e.g., 'energy', 'time', etc.
-            coords={dim: data[:,0]},
-            name=title                      # Optional: give it a name (like the plot title)
-        )
-        self.y.plot(ax=self.axis)
-        if self.checkbox0.isChecked():
-            if self.cursor_handler is None:
-                self.cursor_handler = MovableCursors(self.axis)
-            else:
-                self.cursor_handler.redraw()
-        self.figure.tight_layout()
-        self.canvas.draw()
-    def update_text_edit_boxes(self):
-        self.text_equation.setPlaceholderText("Top Right Text Edit Box")
-    
-    def offset_function (self,x,offset):
-        return 0*x+offset    
-    def constant (self,x,A):
-        return 0*x+A
-    def linear (self,x,a,b):
-        return a*x+b
-    def lorentzian(self,x, A, x0, gamma):
-        c=0.0000
-        return A / (1 + ((x - x0) / (gamma+c)) ** 2)
-    def fermi_dirac(self,x, mu, T):
-        kb = 8.617333262145 * 10**(-5)  # Boltzmann constant in eV/K
-        return 1 / (1 + np.exp((x - mu) / (kb * T)))
-    def gaussian(self,x,A, x0, gamma):
-        return A* np.exp(-(x -x0)**2 / (2 * gamma**2))
-    def gaussian_conv(self,x,sigma):
-        return  np.exp(-(x)**2 / (2 * sigma**2))
-    def jump(self,x, mid):
-        """Heaviside step function."""
-        o = np.zeros(x.size)
-        imid = max(np.where(x <= mid)[0])
-        o[imid:] = 1.0
-        return o
-    def jump2(self,x, mid,Amp):
-        """Heaviside step function."""
-        o = np.zeros(x.size)
-        imid = max(np.where(x <= mid)[0])
-        o[:imid] = Amp
-        return o
-
-    def centered_kernel(self,x, sigma):
-        mean = x.mean()
-        return np.exp(-(x-mean)**2/(2*sigma/2.3548200)**2)
-
-    def convolve(self,arr, kernel):
-        """Simple convolution of two arrays."""
-        npts = min(arr.size, kernel.size)
-        pad = np.ones(npts)
-        tmp = np.concatenate((pad*arr[0], arr, pad*arr[-1]))
-        out = np.convolve(tmp, kernel/kernel.sum(), mode='valid')
-        noff = int((len(out) - npts) / 2)
-        return out[noff:noff+npts]
-    
-    
-    def convolution(x, func, *args, sigma=1.0):
-            N = 20  # Assuming N is intended to be a local variable here
-            x_step = x[1] - x[0]
-            
-            # Create the shifted input signal 'y' for convolution
-            y = np.zeros(N + len(x))
-            for i in range(N):
-                y[i] = x[0] - (N - i) * x_step
-            y[N:] = x  # Append the original signal x to y
-            
-            # Create the Gaussian kernel
-            x_gauss = np.linspace(-0.5, 0.5, len(x))
-            gaussian_values = np.exp(-0.5 * (x_gauss / sigma)**2) / (sigma * np.sqrt(2 * np.pi))
-            
-            # Evaluate the function values with parameters
-            function_values = func(x, *args)
-            
-            # Perform convolution
-            convolution_result = np.convolve(function_values, gaussian_values, mode='same')
-            
-            return convolution_result[N-1:-1]
-    
-
-    def clear_graph_window(self):
-        self.axis.clear()
-        self.plot_graph()
-        
-    def checkbox0_changed(self, state):
-        if state == Qt.Checked:
-            if self.cursor_handler is None:
-                self.cursor_handler = MovableCursors(self.axis)
-                self.canvas.draw()
-            else:
-                self.cursor_handler.redraw()
-        else:
-            self.cursor_handler.remove()
-    
-    def checkbox1_changed(self, state):
-        if self.CV_state== True:
-            pos=2
-        else:
-            pos=0
-        if state == Qt.Checked:
-            self.FD_state = True
-            self.update_equation()
-            self.table_widget.insertRow(pos)
-            label_item = QTableWidgetItem("Fermi")
-            self.table_widget.setVerticalHeaderItem(pos, label_item)
-            for col in range(4):
-                item = QTableWidgetItem('')
-                item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
-                self.table_widget.setItem(pos, col, item)
-                item.setBackground(QBrush(QColor('grey')))
-            c=self.table_widget.rowCount()
-            self.table_widget.insertRow(pos+1)
-            label_item1 = QTableWidgetItem("Fermi level")
-            checkbox_widget = QWidget()
-            checkbox_layout = QHBoxLayout()
-            checkbox_layout.setAlignment(Qt.AlignCenter)
-            checkbox = QCheckBox()
-            checkbox.stateChanged.connect(lambda state, row= pos+1: self.handle_checkbox_state_change(state, row))
-            # print('thecount',c+1)
-            checkbox_layout.addWidget(checkbox)
-            checkbox_widget.setLayout(checkbox_layout)
-            self.table_widget.setCellWidget(pos+1, 3, checkbox_widget)
-            self.table_widget.setVerticalHeaderItem(pos+1, label_item1)
-            
-            self.table_widget.insertRow(pos+2)
-            label_item2 = QTableWidgetItem("Temperature")
-            checkbox_widget = QWidget()
-            checkbox_layout = QHBoxLayout()
-            checkbox_layout.setAlignment(Qt.AlignCenter)
-            checkbox = QCheckBox()
-            checkbox.stateChanged.connect(lambda state, row= pos+2: self.handle_checkbox_state_change(state, row))
-            checkbox_layout.addWidget(checkbox)
-            checkbox_widget.setLayout(checkbox_layout)
-            self.table_widget.setCellWidget(pos+2, 3, checkbox_widget)
-            self.table_widget.setVerticalHeaderItem(pos+2, label_item2)
-        else:
-            self.FD_state = False
-            self.update_equation()
-            # print("Checkbox 1 is unchecked")
-            
-            self.table_widget.removeRow(pos)
-            self.table_widget.removeRow(pos)
-            self.table_widget.removeRow(pos)
-            
-    def checkbox2_changed(self, state):
-        if state == Qt.Checked:
-            self.CV_state = True
-            
-            self.update_equation()
-
-            self.table_widget.insertRow(0)
-            label_item = QTableWidgetItem("Convolution")
-            self.table_widget.setVerticalHeaderItem(0, label_item)
-            # self.table_widget.setVerticalHeaderItem(0, new_row_name)
-            for col in range(4):
-                item = QTableWidgetItem('')
-                item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
-                self.table_widget.setItem(0, col, item)
-                item.setBackground(QBrush(QColor('grey')))
-                
-            self.table_widget.insertRow(1)
-            label_item1 = QTableWidgetItem("sigma")
-            checkbox_widget = QWidget()
-            checkbox_layout = QHBoxLayout()
-            checkbox_layout.setAlignment(Qt.AlignCenter)
-            checkbox = QCheckBox()
-            checkbox.stateChanged.connect(lambda state, row= 1: self.handle_checkbox_state_change(state, row))
-            checkbox_layout.addWidget(checkbox)
-            checkbox_widget.setLayout(checkbox_layout)
-            self.table_widget.setCellWidget(1, 3, checkbox_widget)
-            self.table_widget.setVerticalHeaderItem(1, label_item1)
-            
-        else:
-            self.CV_state = False
-            self.update_equation()
-            # print("Checkbox 1 is unchecked")
-            
-            self.table_widget.removeRow(0)
-            self.table_widget.removeRow(0)
-    def checkbox3_changed(self, state):
-        if state == Qt.Checked:
-            self.offset_state=True
-        else:
-            self.offset_state=False
-        
-    def item_selected(self, item):
-        # print(f"Selected: {item.text()}")
-        if item.text() == 'Lorentz':
-            self.function_selected = self.lorentzian
-        elif item.text() == 'Gauss':
-            self.function_selected = self.gaussian 
-        elif item.text()=='linear':
-            self.function_selected =self.linear
-        elif item.text()=='constant':
-            self.function_selected =self.constant
-        elif item.text()=='jump':
-            self.function_selected =self.jump2
-        
-    def button_guess_clicked(self):
-        cursors= self.cursor_handler.cursors()
-        self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
-        self.x_f=self.y_f[self.dim]
-        max_value= self.y_f.data.max()
-        min_value= self.y_f.data.min()
-        mean_value= self.y_f.data.mean()
-        max_arg=self.y_f.data.argmax()
-        # print(self.x_f[max_arg].item())
-        for row in range(self.table_widget.rowCount()):
-            header_item = self.table_widget.verticalHeaderItem(row)
-            if "A" in header_item.text():
-                self.params[header_item.text()].set(value=max_value)
-                item = QTableWidgetItem(str(max_value))
-                self.table_widget.setItem(row, 1, item)
-            elif "x0" in header_item.text():
-                self.params[header_item.text()].set(value=self.x_f[max_arg].item())
-                item = QTableWidgetItem(str(self.x_f[max_arg].item()))
-                self.table_widget.setItem(row, 1, item)
-            elif "gamma" in header_item.text():
-                self.params[header_item.text()].set(value=0.2)
-                item = QTableWidgetItem(str(0.2))
-                self.table_widget.setItem(row, 1, item)
-
-            
-    
-    def button_remove_clicked(self):
-        if self.i>0:
-            self.i-=1
-        current_row_count = self.table_widget.rowCount()
-        sig = inspect.signature(self.function_list[-1])
-        params = sig.parameters
-        
-        for p in range(len(params)):
-            self.table_widget.removeRow(current_row_count-1-p)    
-            
-        self.function_list.remove(self.function_list[-1])
-        self.function_names_list.remove(self.function_names_list[-1])
-        self.update_equation()
-        self.create()
-
-    def button_add_clicked(self):
-        def zero(x):
-            return 0
-        
-        
-        self.i+=1
-        self.function_list.append(self.function_selected)
-        self.function_names_list.append(self.list_widget.currentItem().text())
-        j=0
-        for p in self.function_list:
-            current_function=Model(p,prefix='f'+str(j)+'_')
-            j+=1
-            
-        
-        current_row_count = self.table_widget.rowCount()
-        
-        self.table_widget.insertRow(current_row_count)
-        new_row_name = QTableWidgetItem(self.list_widget.currentItem().text())
-        self.table_widget.setVerticalHeaderItem(current_row_count, new_row_name)
-        for col in range(4):
-            item = QTableWidgetItem('')
-            item.setFlags(Qt.ItemIsEnabled)  # Make cell uneditable
-            self.table_widget.setItem(current_row_count, col, item)
-            item.setBackground(QBrush(QColor('grey')))
-        c=current_row_count
-        for p in range(len(current_function.param_names)):
-
-            self.table_widget.insertRow(c+p+1)
-            # print(current_function.param_names[p])
-            new_row_name = QTableWidgetItem(current_function.param_names[p])
-            self.table_widget.setVerticalHeaderItem(c+p+1, new_row_name)
-            checkbox_widget = QWidget()
-            checkbox_layout = QHBoxLayout()
-            checkbox_layout.setAlignment(Qt.AlignCenter)
-            checkbox = QCheckBox()
-            checkbox.stateChanged.connect(lambda state, row=c + p + 1: self.handle_checkbox_state_change(state, row))
-            checkbox_layout.addWidget(checkbox)
-            checkbox_widget.setLayout(checkbox_layout)
-            self.table_widget.setCellWidget(c+p+1, 3, checkbox_widget)
-        
-        self.update_equation()
-        self.create()
-        
-    def update_equation(self):
-        self.equation=''
-        # print('names',self.function_names_list)
-        for j,n in enumerate(self.function_names_list):
-            if len(self.function_names_list)==1:
-                self.equation= n
-            else:
-                if j==0:
-                    self.equation= n
-                else:
-                    self.equation+= '+' + n
-        if self.FD_state:
-            self.equation= '('+ self.equation+ ')* Fermi_Dirac'
-        self.text_equation.setPlainText(self.equation)
-        # print('equation',self.equation)
-    
-
-    def table_item_changed(self, item):
-        # print(f"Table cell changed at ({item.row()}, {item.column()}): {item.text()}")
-        header_item = self.table_widget.verticalHeaderItem(item.row())
-        # print('theeeeeeitem=',item.text())
-        
-    def handle_checkbox_state_change(self,state,row):
-        if state == Qt.Checked:
-            header_item = self.table_widget.verticalHeaderItem(row)
-            
-        else:
-            header_item = self.table_widget.verticalHeaderItem(row)
-    def create(self):
-        def zero(x):
-            return 0
-        cursors= self.cursor_handler.cursors()
-        self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
-        self.x_f=self.y_f[self.dim]
-        # print(self.y_f)
-        if self.offset_state==True:
-            self.params['offset'].set(value=self.y_f.data.min())
-        list_axis=[[self.y[self.dim]],[self.x_f]]
-        self.mod= Model(zero)
-        j=0
-        for f in self.function_list:
-            self.mod+=Model(f,prefix='f'+str(j)+'_')
-            j+=1
-        if self.FD_state == True:
-            self.mod= self.mod* Model(self.fermi_dirac)
-        if self.CV_state == True:
-            self.mod = CompositeModel(self.mod, Model(self.centered_kernel), self.convolve)
-        if self.offset_state==True:
-            self.mod= self.mod+Model(self.offset_function)
-        m1=make_model(self.mod, self.table_widget)
-        self.mod=m1.current_model()
-        self.params=m1.current_params()
-    def fit(self):
-        
-        def zero(x):
-            return 0
-        self.mod= Model(zero)
-        cursors= self.cursor_handler.cursors()
-        j=0
-        for f in self.function_list:
-            self.mod+=Model(f,prefix='f'+str(j)+'_')
-            j+=1
-        if self.FD_state == True:
-            self.mod= self.mod* Model(self.fermi_dirac)
-        if self.CV_state == True:
-            self.mod = CompositeModel(self.mod, Model(self.centered_kernel), self.convolve)
-        if self.offset_state==True:
-            self.mod= self.mod+Model(self.offset_function)
-        m1=make_model(self.mod, self.table_widget)
-        self.mod=m1.current_model()
-        self.params=m1.current_params()
-        self.y_f=self.y.isel({self.dim:slice(cursors[0], cursors[1])})
-        self.x_f=self.y_f[self.dim]
-        if self.offset_state==True:
-            self.params['offset'].set(value=self.y_f.data.min())
-        # print(self.params)
-        out = self.mod.fit(self.y_f, self.params, x=self.x_f)
-        print(out.fit_report(min_correl=0.25))
-        self.axis.plot(self.x_f,out.best_fit,color='red',label='fit')
-        self.figure.tight_layout()
-        self.canvas.draw()
-        
-    
-
-if __name__ == "__main__":
-    app = QApplication(sys.argv)
-    window = fit_panel_single()
-    window.show()
-    sys.exit(app.exec_())
diff --git a/tests/graphs2.py b/tests/graphs2.py
deleted file mode 100644
index 7b50216..0000000
--- a/tests/graphs2.py
+++ /dev/null
@@ -1,80 +0,0 @@
-import sys
-import numpy as np
-from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QPushButton, QGridLayout
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
-import matplotlib.pyplot as plt
-
-class showgraphs(QMainWindow):
-    def __init__(self, x, y_arrays):
-        super().__init__()
-        self.setWindowTitle("Multiple Array Plots")
-        self.setGeometry(100, 100, 800, 600)
-
-        # Store x and y data
-        self.x = x
-        self.y_arrays = y_arrays
-        self.num_plots = len(y_arrays)
-
-        # Create a central widget and layout
-        central_widget = QWidget(self)
-        self.setCentralWidget(central_widget)
-        layout = QGridLayout(central_widget)
-
-        # Create and add buttons and plots for each y array in a 3x3 layout
-        for i, y in enumerate(y_arrays):
-            # Create a button to show the plot in a new window
-            button = QPushButton(f"Show Plot {i+1}")
-            button.setFixedSize(80, 30)  # Set a fixed size for the button
-            button.clicked.connect(lambda checked, y=y, index=i+1: self.show_plot(y, index))
-
-            # Calculate grid position
-            row = (i // 3) * 2  # Each function will take 2 rows: one for the plot, one for the button
-            col = i % 3
-
-            # Add the plot canvas to the grid
-            layout.addWidget(self.create_plot_widget(y, f"Plot {i+1}"), row, col)  # Plot in a 3x3 grid
-            layout.addWidget(button, row + 1, col)  # Button directly below the corresponding plot
-
-    def create_plot_widget(self, y, title):
-        """Creates a plot widget for displaying a function."""
-        figure, ax = plt.subplots()
-        ax.plot(self.x, y)
-        ax.set_title(title)
-        ax.grid(True)
-        ax.set_xlabel('x')
-        ax.set_ylabel('y')
-
-        # Create a FigureCanvas to embed in the Qt layout
-        canvas = FigureCanvas(figure)
-        return canvas  # Return the canvas so it can be used in the layout
-
-    def show_plot(self, y, index):
-        """Show the plot in a new window."""
-        figure, ax = plt.subplots()
-        ax.plot(self.x, y)
-        ax.set_title(f"Plot {index}")
-        ax.grid(True)
-        ax.set_xlabel('x')
-        ax.set_ylabel('y')
-        plt.show()  # Show the figure in a new window
-
-if __name__ == "__main__":
-    app = QApplication(sys.argv)
-    
-    # # Example data: Define x and multiple y arrays
-    # x = np.linspace(-10, 10, 400)
-    # y_arrays = [
-    #     np.sin(x),
-    #     np.cos(x),
-    #     np.tan(x),
-    #     np.exp(x / 10),
-    #     x**2,
-    #     x**3,
-    #     np.abs(x),
-    #     np.log(x + 11),  # Shift to avoid log(0)
-    #     np.sqrt(x + 11)  # Shift to avoid sqrt of negative
-    # ]
-    
-    main_window = showgraphs()
-    main_window.show()
-    sys.exit(app.exec_())
diff --git a/tests/h5toxarray.py b/tests/h5toxarray.py
deleted file mode 100644
index ff6065f..0000000
--- a/tests/h5toxarray.py
+++ /dev/null
@@ -1,55 +0,0 @@
-import h5py
-import numpy as np
-import xarray as xr
-
-
-class h5toxarray_loader():
-    def __init__(self, df):
-
-        if len(list(df['binned'].keys()))>1:
-            first_key = sorted(df['binned'].keys(), key=lambda x: int(x[1:]))[0]
-            data_shape = df['binned/' + first_key][:].shape  
-            self.M = np.empty((data_shape[0], data_shape[1], data_shape[2], len(df['binned'])))
-            axis=[]
-            for idx, v in enumerate(sorted(df['binned'].keys(), key=lambda x: int(x[1:]))):
-                self.M[:, :, :, idx] = df['binned/' + v][:]
-        else: 
-            self.M= df['binned/' + list(df['binned'].keys())[0]][:]
-        
-        
-        # Define the desired order lists
-        desired_orders = [
-            ['ax0', 'ax1', 'ax2', 'ax3'],
-            ['kx', 'ky', 'E', 'delay'],
-            ['kx', 'ky', 'E', 'ADC']
-        ]
-        
-        axes_list = []
-      
-        matched_order = None
-        for i, order in enumerate(desired_orders):
-            # Check if all keys in the current order exist in df['axes']
-            if all(f'axes/{axis}' in df for axis in order):
-                # If match is found, generate axes_list based on this order
-                axes_list = [df[f'axes/{axis}'] for axis in order]
-                matched_order = i + 1  # Store which list worked (1-based index)
-                break  # Stop once the first matching list is found
-        
-        if matched_order:
-            print(f"Matched desired list {matched_order}: {desired_orders[matched_order - 1]}")
-        else:
-            print("No matching desired list found.")
-        
-        # print("Axes list:", axes_list)
-        # print(M[12,50,4,20])
-        self.data_array = xr.DataArray(
-            self.M,
-            coords={"kx": axes_list[0], "ky": axes_list[1], "E": axes_list[2], "dt": axes_list[3]},
-            dims=["kx", "ky", "E","dt"]
-        )
-    def get_data_array(self):
-        return self.data_array
-    def get_original_array(self):
-        return self.M
-# df =h5py.File(r'C:\Users\admin-nisel131\Documents\Scan130_scan130_Amine_100x100x300x50_spacecharge4_gamma850_amp_3p3.h5', 'r')
-# test=h5toxarray_loader(df)
diff --git a/tests/k_path_4d_4.py b/tests/k_path_4d_4.py
deleted file mode 100644
index 13876c7..0000000
--- a/tests/k_path_4d_4.py
+++ /dev/null
@@ -1,422 +0,0 @@
-import numpy as np
-import h5py
-import matplotlib
-import matplotlib.pyplot as plt
-import numpy as np
-from matplotlib.widgets import CheckButtons, Button
-from scipy.ndimage import rotate
-import h5py
-# import mplcursors
-from matplotlib.widgets import Slider, Cursor, SpanSelector
-from matplotlib.gridspec import GridSpec
-from matplotlib.lines import Line2D
-from matplotlib.patches import Circle
-from AdditionalInterface import AdditionalInterface
-from AxisInteractor import AxisInteractor
-from LinePixelGetter import LinePixelGetter
-from update_plot_cut_4d import update_plot_cut
-import json
-import csv
-from datetime import datetime
-
-class drawKpath:
-    # print(True)
-    def __init__(self, data,axis,fig, ax,ax2,linewidth,slider,N):
-      self.active_cursor=None
-      self.dots_count=0
-      self.ax=ax
-      self.fig=fig
-      self.dot1_x=0
-      self.do1_y=0
-      self.dot2_x=0
-      self.do2_y=0
-      self.cid_press=None
-      self.linewidth=1
-      self.line_artist=None
-      self.cb_line=None
-      self.button_update=None
-      self.dot1=None
-      self.dot2=None
-      self.method_running = False
-      self.pixels_along_line=[]
-      self.number=N
-      self.og_number=N
-      self.dots_list=[]
-      self.line_artist_list=[None]*N
-      self.pixels_along_path=[None]*N
-      # self.number=N
-      self.is_drawn= False
-      self.is_loaded= False
-      self.new=False
-      self.add_pressed=False
-      self.lw=linewidth
-      self.ax2=ax2
-      self.data=data[:,:,:,slider]
-      self.axis=axis
-      self.pixels=[]
-      self.slider=slider
-      self.data2=data
-      self.slider_ax7 = plt.axes([0.55, 0.14, 0.02, 0.3])
-      self.slider_dcut= Slider(self.slider_ax7, 'dcut_kpath', 0, 15, valinit=1, valstep=1, orientation='vertical')
-    # def update_plot_cut(self):
-    #     update_plot_cut.update_plot_cut(self.data2[:,:,:,self.slider],self.ax2,self.pixels,self.lw)
-    def isdrawn(self):
-        return self.is_drawn
-        
-    
-    def get_pixels(self):
-        if self.pixels is not None:
-            return self.pixels
-    def get_pixels_along_line(self):
-        if self.pixels_along_line is not None:
-            return self.pixels_along_line
-   
-    def get_status(self):
-        if self.cb_line is not None:
-            return self.cb_line.get_status()[0]
-        else:
-            return False
-    
-    def draw(self):
-        # print('beginning')
-        def add_path(event):
-            self.add_pressed= True
-            
-            for i in range (self.number):
-                self.line_artist_list.append(None)
-                self.pixels_along_path.append(None)
-                # self.dots_list
-            print('line list=', len(self.line_artist_list))
-            self.number=self.number+self.og_number
-            self.is_drawn=False
-            self.dots_count=0
-            self.cid_press = self.fig.canvas.mpl_connect('button_press_event', drawdots)
-            
-        def drawline(dot1,dot2,pos):
-            self.pixels=[]
-            if self.dots_count ==0 and self.line_artist_list[len(self.dots_list)-2] is not None :
-                if not self.loaded:    
-                    self.line_artist_list[len(self.dots_list)-2].remove()  # Remove the previous line if exists
-                    print('test,code')
-            # if self.dots_count==2:
-            #     line = Line2D([self.dots_list[len(self.dots_list)].center[0], self.dots_list[len(self.dots_list)-1].center[0]], [self.dots_list[len(self.dots_list)].center[1], self.dots_list[len(self.dots_list)-1].center[1]], linewidth=self.linewidth, color='red')
-            if self.dots_count==2 :
-                line = Line2D([dot1.center[0], dot2.center[0]], [dot1.center[1], dot2.center[1]], linewidth=self.linewidth, color='red')
-                
-                self.ax.add_line(line)
-                # print('movement',len(self.line_artist_list))
-                print('currentline=',self.line_artist_list[pos])
-                if self.line_artist_list[pos] is not None:
-                    # print(pos,self.line_artist_list[pos].get_data())
-                    self.line_artist_list[pos].remove()
-                # if self.line_artist is not None:
-                #     self.line_artist.remove()  # Remove the previous line if exists
-                
-                self.line_artist = line
-                # self.line_artist_list.append(line)
-                self.line_artist_list[pos]=line
-                # print(pos,self.line_artist_list[pos].get_data())
-                # x1=self.line_artist_list[pos].get_data()[0][1]
-                # y1=self.line_artist_list[pos].get_data()[1][1]
-                # x2= self.line_artist_list[pos].get_data()[0][0]
-                # y2=self.line_artist_list[pos].get_data()[1][0]
-                x1_pixel=int((self.line_artist_list[pos].get_data()[0][1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-                y1_pixel=int((self.line_artist_list[pos].get_data()[1][1] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                x2_pixel=int((self.line_artist_list[pos].get_data()[0][0] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-                y2_pixel=int((self.line_artist_list[pos].get_data()[1][0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                
-                self.pixels_along_path[pos] = LinePixelGetter.get_pixels_along_line(x1_pixel, y1_pixel, x2_pixel, y2_pixel, self.linewidth)
-                # print(x1_pixel,y1_pixel)
-                # self.pixels_along_path[pos]=LinePixelGetter.get_pixels_along_line(self.line_artist_list[pos].get_data()[0][1], self.line_artist_list[pos].get_data()[1][1], self.line_artist_list[pos].get_data()[0][0], self.line_artist_list[pos].get_data()[1][0], self.linewidth)
-                # for i in self.pixels_along_path:
-                for i in range (0,self.number):
-                    if self.pixels_along_path[i] is not None:
-                        self.pixels+=self.pixels_along_path[i]
-                        
-        def drawdots(event):
-            # if self.add_pressed:
-                
-                
-            if self.cb_line.get_status()[0] and len(self.dots_list) < self.number and (self.new or not self.is_drawn):
-                x =  event.xdata  # Round the x-coordinate to the nearest integer
-                y =  event.ydata  # Round the y-coordinate to the nearest integer
-                print('you hereeee')
-                print(self.number)
-                # print('line list=', len(self.line_artist_list))
-                if self.dots_count==0:
-                    self.dot= Circle((x, y), radius=0.1, color='yellow', picker=20)
-                    self.ax.add_patch(self.dot)
-                    # self.dot_coords[self.dots_count] = (x, y)
-                    self.dots_list.append(self.dot)
-                    self.dots_count += 1
-                    self.fig.canvas.draw()
-                else:
-                    self.dot= Circle((x, y), radius=0.1, color='yellow', picker=20)
-                    self.ax.add_patch(self.dot)
-                    # self.dot_coords[self.dots_count] = (x, y)
-                    self.dots_count += 1
-                    self.dots_list.append(self.dot)
-                    print('dots list=',len(self.dots_list))
-                    drawline(self.dots_list[len(self.dots_list)-1],self.dots_list[len(self.dots_list)-2],len(self.dots_list)-2)
-                    self.dots_count -= 1
-                    update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
-                    
-                    self.fig.canvas.draw()
-                    if len(self.dots_list)== self.number:
-                        self.is_drawn=True
-                        # print(self.is_drawn)
-        def on_checkbox_change(label):
-                if self.cb_line.get_status()[0]:
-                    if self.is_loaded:
-                        for i in range(len(self.dots_list)):
-                            self.ax.add_patch(self.dots_list[i])
-                            plt.draw()
-                        for i in range(len(self.line_artist_list)):
-                            if self.line_artist_list[i] is not None:
-                                self.ax.add_line(self.line_artist_list[i])
-                                plt.draw()
-                    elif self.is_drawn:
-                        for i in range(len(self.dots_list)):
-                            self.ax.add_patch(self.dots_list[i])
-                            plt.draw()
-                        for i in range(len(self.line_artist_list)):
-                            if self.line_artist_list[i] is not None:
-                                self.ax.add_line(self.line_artist_list[i])
-                                plt.draw()
-                    
-                    else:
-                        self.cid_press = self.fig.canvas.mpl_connect('button_press_event', drawdots)
-                    
-                else:
-                    # Disconnect the click event
-                    self.is_loaded= False
-                    self.fig.canvas.mpl_disconnect(self.cid_press)
-                    for i in range(len(self.dots_list)):
-                        self.dots_list[i].remove()
-                        plt.draw()
-                    for i in range(len(self.line_artist_list)):
-                        if self.line_artist_list[i] is not None:
-                            self.line_artist_list[i].remove()
-                            plt.draw()
-        def new(event):
-            
-            for i in range(len(self.dots_list)):
-                print(i)
-                self.dots_list[i].remove()
-                plt.draw()
-            for i in range(len(self.line_artist_list)):
-                print(i)
-                if self.line_artist_list[i] is not None:
-                    self.line_artist_list[i].remove()
-                    plt.draw()
-            self.new=True
-            self.is_drawn= False
-            self.is_loaded= False
-            self.dots_list=[]
-            self.line_artist_list=[None]*self.number
-            self.pixels_along_path=[None]*self.number
-            self.dots_count=0
-            self.cid_press = self.fig.canvas.mpl_connect('button_press_event', drawdots)
-        def on_pick(event):
-            for i in range(len(self.dots_list)):
-                if event.artist == self.dots_list[i]:
-                    self.active_cursor = self.dots_list[i]
-        def on_motion(event):
-            # global dot1,dot2
-            if self.active_cursor is not None and event.inaxes == self.ax:
-                # Initialize a list of dictionaries to store dot information
-                dot_info_list = [{"dot": dot, "center": dot.center} for dot in self.dots_list]
-                self.dots_count=2
-            
-                # Iterate through the list to find the selected dot
-                selected_dot_index = None
-                for i, dot_info in enumerate(dot_info_list):
-                    dot = dot_info["dot"]
-                    contains, _ = dot.contains(event)
-                    if contains:
-                        selected_dot_index = i
-                        break  # Exit the loop when a matching dot is found
-                
-                if selected_dot_index is not None:
-                    selected_dot_info = dot_info_list[selected_dot_index]
-                    selected_dot = selected_dot_info["dot"]
-                    # print(f"Selected dot index: {selected_dot_index}")
-                    # print(f"Selected dot center: {selected_dot_info['center']}")
-                    selected_dot.center = (event.xdata, event.ydata)
-                    plt.draw()
-                    i=selected_dot_index
-                    if i==len(self.dots_list)-1:
-                        # self.line_artist_list[i-1].remove()
-                        drawline(self.dots_list[i],self.dots_list[i-1],i-1)
-                        update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
-                    elif i==0:
-                        drawline(self.dots_list[i+1],self.dots_list[i],i)
-                        update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
-                    else:
-                        # self.line_artist_list[i-1].remove()
-                        # self.line_artist_list[i].remove()
-                        drawline(self.dots_list[i+1],self.dots_list[i],i)
-                        update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
-                        drawline(self.dots_list[i],self.dots_list[i-1],i-1)
-                        update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
-                    plt.draw()
-                    
-                
-        def on_release(event):
-            self.active_cursor = None
-        def get_status():
-            return self.cb_line.get_status()[0]
-        def dots_coord():
-            return [self.dot1.center, self.dot2.center]
-        
-        def update_dcut(val):
-            self.linewidth=self.slider_dcut.val
-            self.pixels=[]
-            for position, line in enumerate(self.line_artist_list):
-                if line is not None:
-                    line.set_linewidth(self.linewidth+1)
-                    x1_pixel=int((line.get_data()[0][1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-                    y1_pixel=int((line.get_data()[1][1] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                    x2_pixel=int((line.get_data()[0][0] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-                    y2_pixel=int((line.get_data()[1][0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-                    # print(x1_pixel,y1_pixel,x2_pixel,y2_pixel)
-                    self.pixels_along_path[position] = LinePixelGetter.get_pixels_along_line(x1_pixel, y1_pixel, x2_pixel, y2_pixel, self.linewidth)
-                    self.pixels+=self.pixels_along_path[position]
-                    
-            print('before before line')
-            # for pos in range(0,self.number):
-            #     print('before line')
-            #     if self.line_artist_list[pos] is not None:
-            #         x1_pixel=int((self.line_artist_list[pos].get_data()[0][1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            #         y1_pixel=int((self.line_artist_list[pos].get_data()[1][1] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            #         x2_pixel=int((self.line_artist_list[pos].get_data()[0][0] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            #         y2_pixel=int((self.line_artist_list[pos].get_data()[1][0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            #         print(x1_pixel,y1_pixel,x2_pixel,y2_pixel)
-            #         self.pixels_along_path[pos] = LinePixelGetter.get_pixels_along_line(x1_pixel, y1_pixel, x2_pixel, y2_pixel, self.linewidth)
-            #         self.pixels+=self.pixels_along_path[pos]
-            
-            # self.pixels_along_line = LinePixelGetter.get_pixels_along_line(self.dot1_x_pixel, self.dot1_y_pixel, self.dot2_x_pixel, self.dot2_y_pixel, self.linewidth)
-            # update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels_along_line,self.slider_dcut.val)
-            update_plot_cut.update_plot_cut(self.data,self.ax2,self.pixels,self.slider_dcut.val)
-        def draw_load():
-            if self.is_loaded:
-                for i in range(len(self.dots_list)):
-                    self.ax.add_patch(self.dots_list[i])
-                    plt.draw()
-                for i in range(len(self.line_artist_list)):
-                    if self.line_artist_list[i] is not None:
-                        self.ax.add_line(self.line_artist_list[i])
-                        plt.draw()
-        def save_path(event):
-            def c_to_string(circle):
-                return f"{circle.center[0]}, {circle.center[1]}, {circle.radius}"
-            def l_to_string(line):
-                x_data, y_data = line.get_data()
-                linewidth = line.get_linewidth()
-                return f"{x_data[0]}, {y_data[0]}, {x_data[1]},{y_data[1]},{linewidth}"
-            # self.positions= np.array([[0]*4]*len(self.line_artist_list))
-            # for position, line in enumerate(self.line_artist_list):
-            #     if line is not None:
-            #         line.set_linewidth(self.linewidth+1)
-            #         x1_pixel=int((line.get_data()[0][1] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            #         y1_pixel=int((line.get_data()[1][1] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            #         x2_pixel=int((line.get_data()[0][0] - self.axis[0][0]) / (self.axis[0][-1] - self.axis[0][0]) * (self.axis[0].shape[0] - 1) + 0.5)
-            #         y2_pixel=int((line.get_data()[1][0] - self.axis[1][0]) / (self.axis[1][-1] - self.axis[1][0]) * (self.axis[1].shape[0] - 1) + 0.5)
-            #         self.positions[position][0]
-            output_directory = "C:/Users/admin-nisel131/Documents/CVS_TR_flatband_fig/"
-            current_time = datetime.now()
-            current_time_str = current_time.strftime("%Y-%m-%d_%H%M%S")
-            file_name = "k_path"
-            output_path = f"{output_directory}/{file_name}_{current_time_str}.txt"
-            with open(output_path, "w",newline="") as file:
-                file.write(f"{self.number}" + "\n")
-                for circle in self.dots_list:
-                    file.write(c_to_string(circle) + "\n")
-                for line in self.line_artist_list:
-                    if line is not None:
-                        file.write(l_to_string(line) + "\n")
-        def load_path(event):
-            self.fig.canvas.mpl_disconnect(self.cid_press)
-            circle_list=[]
-            line_list=[]
-            file_path1="C:/Users/admin-nisel131/Documents/CVS_TR_flatband_fig/"
-            # file="k_path_2023-10-06_153243.txt"
-            # file= "k_path_2023-10-10_221437.txt"
-            # file= "k_path_2024-04-03_125248.txt"
-            file= "k_path_2024-04-03_140548.txt"
-            
-            
-            file_path=file_path1+file
-            with open(file_path, "r") as file:
-                lines=file.readlines()
-                # print(lines)
-                # for line_number, line in enumerate(file, start=1):
-                for line_number, line in enumerate(lines, start =1):
-                    # if line_number==2:
-                    #     a,b,c= map(float, line.strip().split(', '))
-                    #     print(a,b,c)
-                    # print(map(float, line.strip().split(', ')))
-                    # print('linenumber=',line_number)
-                    # Split the line into individual values
-                    # if line_number==1:
-                    # print('firstline',line_number)
-                    # number=7
-                    # first_line = file.readline().strip()  # Read and strip whitespace
-                    # print(line)
-                    # first_line = file.readline()
-                    
-                    # number= int(first_line)
-                    # print(number)
-                    # print(first_line)
-                    # print()
-                    if line_number==1:
-                        number= int(line)
-                        # print(number)
-                    elif line_number>=2 and line_number<=number+1:
-                        x, y, radius = map(float, line.strip().split(', '))
-                        # print(x,y,radius)
-                        circle = Circle((x, y), radius=radius, color='yellow', picker=20)
-                        circle_list.append(circle)
-                        self.dots_list=circle_list
-                    else:
-                        x0,y0,x1,y1,lw=map(float, line.strip().split(','))
-                        line1=Line2D([x0,x1], [y0, y1], linewidth=lw, color='red')
-                        line_list.append(line1)
-                        self.line_artist_list=line_list
-                    self.is_loaded= True
-                    self.dots_count=2
-                    # draw_load()
-                    # print(len(self.line_artist_list),len(self.dots_list))
-                    
-                        # print(x0,y0,x1,y1,lw)
-                    # on_checkbox_change('K path')
-                    
-                
-        self.slider_dcut.on_changed(update_dcut)
-        self.fig.canvas.mpl_connect('pick_event', on_pick)
-        self.fig.canvas.mpl_connect('motion_notify_event', on_motion)
-        self.fig.canvas.mpl_connect('button_release_event', on_release)
-    
-        rax_line = self.fig.add_axes([0.45, 0.02, 0.06, 0.03])  # [left, bottom, width, height]
-        self.cb_line = CheckButtons(rax_line, ['K path'], [False])
-        self.cb_line.on_clicked(on_checkbox_change)
-        
-        rax_button = self.fig.add_axes([0.52, 0.02, 0.06, 0.03])
-        self.button_update = Button(rax_button, 'new k')
-        self.button_update.on_clicked(new)
-        
-        savepath_button = self.fig.add_axes([0.52, 0.06, 0.06, 0.03])
-        self.button_save = Button(savepath_button, 'save k-path')
-        self.button_save.on_clicked(save_path)
-        
-        loadpath_button = self.fig.add_axes([0.45, 0.06, 0.06, 0.03])
-        self.button_load = Button(loadpath_button, 'load k-path')
-        self.button_load.on_clicked(load_path)
-        
-        addpath_button = self.fig.add_axes([0.37, 0.06, 0.06, 0.03])
-        self.button_add = Button(addpath_button, 'add k-path')
-        self.button_add.on_clicked(add_path)
-        
-        plt.show()
-        self.fig.canvas.draw()
-        
\ No newline at end of file
diff --git a/tests/movable_vertical_cursors_graph.py b/tests/movable_vertical_cursors_graph.py
deleted file mode 100644
index 580f4a8..0000000
--- a/tests/movable_vertical_cursors_graph.py
+++ /dev/null
@@ -1,77 +0,0 @@
-# movable_cursors.py
-
-import numpy as np
-import matplotlib.pyplot as plt
-
-class MovableCursors:
-    def __init__(self, ax):
-        self.ax = ax
-        line = self.ax.lines[0] 
-        self.active_cursor=None
-
-        self.axis = line.get_xdata()
-        
-        self.cursorlinev1=self.axis[int(len(self.axis)/4)]
-        self.cursorlinev2=self.axis[int(3*len(self.axis)/4)]
-        # Create initial cursors (at the middle of the plot)
-        # self.v1_cursor = self.ax.axvline(x=5, color='r', linestyle='--', label='Cursor X')
-        # self.v2_cursor = self.ax.axhline(y=0, color='g', linestyle='--', label='Cursor Y')
-        
-        self.Line1=self.ax.axvline(x=self.cursorlinev1, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
-        self.Line2=self.ax.axvline(x=self.cursorlinev2, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
-
-        # Connect mouse events for the canvas of the axes
-        self.ax.figure.canvas.mpl_connect('pick_event', self.on_pick)
-        self.ax.figure.canvas.mpl_connect('motion_notify_event', self.on_motion)
-        self.ax.figure.canvas.mpl_connect('button_release_event', self.on_release)
-
-    def on_pick(self,event):
-        
-        if event.artist == self.Line1:
-            self.active_cursor =self.Line1
-        elif event.artist == self.Line2:
-            self.active_cursor =self.Line2
-    # self.active_cursor=None
-    def on_motion(self,event):
-        
-        if self.active_cursor is not None and event.inaxes == self.ax:
-            if self.active_cursor == self.Line1:
-                self.Line1.set_xdata([event.xdata, event.xdata])
-                self.cursorlinev1= event.xdata
-            elif self.active_cursor == self.Line2:
-                self.Line2.set_xdata([event.xdata, event.xdata])
-                self.cursorlinev2= event.xdata
-            # print(dot1.center) 
-            # print(self.cursorlinev1,self.cursorlinev2)
-            self.ax.figure.canvas.draw()
-            plt.draw()
-            def find_nearest_index(array, value):
-                idx = (np.abs(array - value)).argmin()
-                return idx
-            self.v1_pixel=find_nearest_index(self.axis, self.cursorlinev1)
-            self.v2_pixel=find_nearest_index(self.axis, self.cursorlinev2)
-            
-            # self.v1_pixel=int((self.cursorlinev1 - self.axis[0]) / (self.axis[-1] - self.axis[0]) * (self.axis.shape[0] - 1) + 0.5)
-            # self.v2_pixel=int((self.cursorlinev2 - self.axis[0]) / (self.axis[-1] - self.axis[0]) * (self.axis.shape[0] - 1) + 0.5)
-            print(self.v1_pixel,self.v2_pixel)
-            
-            # print(self.v1_pixel,self.v2_pixel)
-    def on_release(self,event):
-        # global self.active_cursor
-        self.active_cursor = None    
-    def remove(self):
-        self.cursorlinev1= self.Line1.get_xdata()[0]
-        self.cursorlinev2= self.Line2.get_xdata()[0]
-        self.Line1.remove()
-        self.Line2.remove()
-        # plt.draw()
-        self.ax.figure.canvas.draw()
-        
-    def redraw(self):
-        # print(self.cursorlinev1,self.cursorlinev2)
-        self.Line1=self.ax.axvline(x=self.cursorlinev1, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
-        self.Line2=self.ax.axvline(x=self.cursorlinev2, color='red', linestyle='--',linewidth=2, label='Vertical Line',picker=10)
-        # plt.draw()
-        self.ax.figure.canvas.draw()
-    def cursors(self):
-        return [self.v1_pixel,self.v2_pixel]        
\ No newline at end of file

From 7aadfd632ed9846a5f65b54b7fcf56595024c99f Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 6 May 2025 14:13:01 +0200
Subject: [PATCH 62/67] deleted unnecessary or unfinished files

---
 tests/__init__.py   |  0
 tests/make_model.py | 70 ---------------------------------------------
 2 files changed, 70 deletions(-)
 delete mode 100644 tests/__init__.py
 delete mode 100644 tests/make_model.py

diff --git a/tests/__init__.py b/tests/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/make_model.py b/tests/make_model.py
deleted file mode 100644
index 940b1e2..0000000
--- a/tests/make_model.py
+++ /dev/null
@@ -1,70 +0,0 @@
-import sys
-from PyQt5.QtGui import QBrush, QColor
-from PyQt5.QtWidgets import QTextEdit, QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, QWidget, QSlider, QLabel, QAction, QCheckBox, QPushButton, QListWidget, QTableWidget, QTableWidgetItem, QTableWidget, QCheckBox, QSplitter
-from PyQt5.QtCore import Qt
-from PyQt5.QtWidgets import QTableWidgetItem, QHBoxLayout, QCheckBox, QWidget
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
-import matplotlib.pyplot as plt
-
-
-
-class make_model:
-    # from matplotlib.widgets import CheckButtons, Button
-    # %matplotlib qt
-    
-    def __init__(self,mod,table_widget):
-        
-        self.mod=mod
-        self.params=mod.make_params()
-        print('otherpalce',self.params)
-        print('thefuuuuTable',table_widget)
-        print('count',table_widget.rowCount())
-        for row in range(table_widget.rowCount()):
-            item = table_widget.item(row, 1)
-            checkbox_widget = table_widget.cellWidget(row, 3)
-            print('tableitenm=',item)
-            if item is not None and item.text().strip():
-                header_item = table_widget.verticalHeaderItem(item.row())
-                checkbox=checkbox_widget.findChild(QCheckBox)
-                print(header_item.text(),item.text())
-                if header_item.text()== "Fermi level":
-                    self.params['mu'].set(value=float(item.text()))
-                    if table_widget.item(row, 0) is not None:
-                        self.params['mu'].set(min=float(table_widget.item(row, 0).text()))
-                    if table_widget.item(row, 2) is not None:
-                        self.params['mu'].set(max=float(table_widget.item(row, 2).text()))
-                    if checkbox.isChecked():
-                        self.params['mu'].vary = False
-                        
-                elif header_item.text()== "Temperature":
-                    self.params['T'].set(value=float(item.text()))
-                    if table_widget.item(row, 0) is not None:
-                        self.params['T'].set(min=float(table_widget.item(row, 0).text()))
-                    if table_widget.item(row, 2) is not None:
-                        self.params['T'].set(max=float(table_widget.item(row, 2).text()))
-                    if checkbox.isChecked():
-                        self.params['T'].vary = False
-                elif header_item.text()== "sigma":
-                    self.params['sigma'].set(value=float(item.text()))
-                    self.params['sigma'].set(min=0)
-                    if table_widget.item(row, 0) is not None:
-                        self.params['sigma'].set(min=float(table_widget.item(row, 0).text()))
-                    if table_widget.item(row, 2) is not None:
-                        self.params['sigma'].set(max=float(table_widget.item(row, 2).text()))
-                    if checkbox.isChecked():
-                        self.params['sigma'].vary = False
-                else:
-                    self.params[header_item.text()].set(value=float(item.text()))
-                    if table_widget.item(row, 0) is not None:
-                        self.params[header_item.text()].set(min=float(table_widget.item(row, 0).text()))
-                    if table_widget.item(row, 2) is not None:
-                        self.params[header_item.text()].set(max=float(table_widget.item(row, 2).text()))
-                    if checkbox.isChecked():
-                        self.params[header_item.text()].vary = False
-        
-        
-    def current_model(self):
-        return self.mod
-    def current_params(self):
-        return self.params
-                
\ No newline at end of file

From 325810269491b8d1f5dd09ecf44632d910cb62c9 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Tue, 6 May 2025 15:40:41 +0200
Subject: [PATCH 63/67] bug fix

---
 src/mpes_tools/Gui_3d.py | 9 ++++-----
 src/mpes_tools/graphs.py | 4 ++--
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index 9002e96..5504a3f 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -28,12 +28,12 @@ def __init__(self,data_array: xr.DataArray,t=None,dt=None):
         self.setWindowTitle("Graph Window")
         self.setGeometry(100, 100, 1200, 1000)
 
-        # Create a central widget for the graph
-        central_widget = QWidget()
-        self.setCentralWidget(central_widget)
+        # Create a main widget for the graph
+        main_widget = QWidget()
+        self.setCentralWidget(main_widget)
         
         layout = QVBoxLayout()
-        central_widget.setLayout(layout)
+        main_widget.setLayout(layout)
 
         self.click_handlers = []
         self.handler_list = []
@@ -105,7 +105,6 @@ def __init__(self,data_array: xr.DataArray,t=None,dt=None):
         # self.slider1.setFixedSize(200, 12)  # Change the width and height as needed
         # self.slider2.setFixedSize(200, 12)  # Change the width and height as needed
         
-        # Create a layout for the central widget
         slider_layout.addWidget(self.slider1)
         slider_layout.addWidget(self.slider1_label)
         slider_layout.addWidget(self.slider2)
diff --git a/src/mpes_tools/graphs.py b/src/mpes_tools/graphs.py
index 40dd213..f11a999 100644
--- a/src/mpes_tools/graphs.py
+++ b/src/mpes_tools/graphs.py
@@ -172,7 +172,7 @@ def create_plot_widget(self, data_array, y_err , title):
         plt.close(figure)
         
         # ax.errorbar(data_array[data_array.dims[0]].values, data_array.values, yerr=y_err, fmt='o', capsize=3)
-        ax.plot(data_array[data_array.dims[0]].values, data_array.values,'o')
+        ax.plot(data_array[data_array.dims[0]].values, data_array.values,marker='o', linestyle='-')
         # data_array.plot(ax=ax,fmt='o', capsize=3)
         ax.set_title(title)
         # print('create_plot'+f"self.ax id: {id(ax)}")
@@ -194,7 +194,7 @@ def show_err(self,state,data_array,y_err,i):
         if state == Qt.Checked:
             self.ax_list[i].errorbar(data_array[data_array.dims[0]].values, data_array.values, yerr=y_err, fmt='o', capsize=3)
         else:
-            self.ax_list[i].plot(data_array[data_array.dims[0]].values, data_array.values,'o')
+            self.ax_list[i].plot(data_array[data_array.dims[0]].values, data_array.values,marker='o', linestyle='-')
             # data_array.plot(ax=self.ax_list[i], fmt='o', capsize=3)
         self.ax_list[i].set_title(data_array.name)
         self.cursor_list[i]=self.ax_list[i].axvline(x=self.x[self.slider.value()], color='r', linestyle='--')

From a019a5e8434ec2798e58abc24c32b214bd59f271 Mon Sep 17 00:00:00 2001
From: Laurenz Rettig <rettig@fhi-berlin.mpg.de>
Date: Wed, 7 May 2025 09:40:24 +0200
Subject: [PATCH 64/67] Add download path for example file

---
 .gitignore               |   3 +-
 tutorials/template.ipynb | 523 ++++-----------------------------------
 2 files changed, 46 insertions(+), 480 deletions(-)

diff --git a/.gitignore b/.gitignore
index 9b30dad..4e9e2d1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -161,4 +161,5 @@ cython_debug/
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
 
-poetry.toml
\ No newline at end of file
+poetry.toml
+*.nxs
\ No newline at end of file
diff --git a/tutorials/template.ipynb b/tutorials/template.ipynb
index 3771539..c203373 100644
--- a/tutorials/template.ipynb
+++ b/tutorials/template.ipynb
@@ -2,92 +2,52 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "6d2e0046",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<Figure size 640x480 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# import the 4D data\n",
     "import numpy as np\n",
     "from mpes_tools.hdf5 import load_h5\n",
-    "\n",
-    "data_array= load_h5('//nap33/wahada/Scan130_scan130_Amine_100x100x300x50.h5')"
+    "import nxarray\n",
+    "import os"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "id": "5aeb6fe2",
+   "execution_count": null,
+   "id": "8e923734",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "results extracted!\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# Use the 4D Gui\n",
-    "from mpes_tools.show_4d_window import show_4d_window\n",
-    "%gui qt\n",
-    "graph_4d = show_4d_window(data_array)\n",
-    "graph_4d.show()"
+    "# get data from the NOMAD repository\n",
+    "if not os.path.exists(\"Scan49_binned.nxs\"):\n",
+    "    ! curl -o Scan49_binned.nxs https://nomad-lab.eu/prod/v1/oasis-b/api/v1/entries/MehgoizphpnxG_t-J0WGgbUZKlTp/raw/Scan49_binned.nxs"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "id": "b44542de",
+   "execution_count": null,
+   "id": "6a046f68",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "5"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "5"
+    "data_array = nxarray.load(\"Scan49_binned.nxs\").data"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "805bb93c",
+   "id": "5aeb6fe2",
    "metadata": {},
    "outputs": [],
    "source": [
-    "data='your data_array'\n",
-    "#the kx plot\n",
-    "data.loc[\n",
-    "    {\n",
-    "        'kx': slice(\n",
-    "            1.0800000000000003,\n",
-    "            1.0800000000000003\n",
-    "        ),\n",
-    "        'ADC': slice(\n",
-    "            590.0,\n",
-    "            590.0\n",
-    "        )\n",
-    "    }\n",
-    "].mean(dim=('kx', 'ADC')).T            "
+    "# Use the 4D Gui\n",
+    "from mpes_tools.show_4d_window import show_4d_window\n",
+    "%gui qt\n",
+    "graph_4d = show_4d_window(data_array)\n",
+    "graph_4d.show()"
    ]
   },
   {
@@ -95,215 +55,56 @@
    "execution_count": null,
    "id": "f416bc6e",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x800 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "data=data_array\n",
     "#the energy plot\n",
     "\n",
-    "en=data.loc[\n",
-    "    {\n",
-    "        'energy': slice(\n",
-    "            0.4333333333333331,\n",
-    "            0.4333333333333331\n",
-    "        ),\n",
-    "        'ADC': slice(\n",
-    "            590.0,\n",
-    "            590.0\n",
-    "        )\n",
-    "    }\n",
-    "].mean(dim=('energy', 'ADC'))\n",
-    "fig,ax=plt.subplots(1,1,figsize=(12,8),cmap='terrain')\n",
-    "en.plot(ax=ax)\n",
+    "en=data.loc[{\n",
+    "    'energy': slice(-0.04999999999999982, 0.0),\n",
+    "    'delay': slice(-0.00399999999999999, 0.014000000000000012)\n",
+    "}].mean(dim=('energy', 'delay')).T  \n",
+    "fig,ax=plt.subplots(1,1)\n",
+    "en.plot(ax=ax,cmap='terrain')\n",
     "plt.show()\n",
     "            "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "a6a92293",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "('Angle', 'Ekin', 'delay')\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<Figure size 640x480 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "data.sel({data.dims[2]: slice(-799.45, -499.65)}).sum(dim=data.dims[2]).sel({data.dims[1]: -0.85}, method='nearest')  # Green MDC\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Use the 3D Gui\n",
     "\n",
     "import numpy as np\n",
-    "import xarray as xr\n",
     "from mpes_tools.Gui_3d import Gui_3d\n",
     "%gui qt\n",
     "\n",
     "# import the 3D data\n",
-    "loaded_data= np.load('//nap33/wahada/Phoibospython/scan11443_filtered.npz')\n",
-    "\n",
-    "data= xr.DataArray(loaded_data['data_array'], dims=['Angle', 'Ekin','delay'], coords={'Angle': loaded_data['Angle'], 'Ekin': loaded_data['Ekin'],'delay': loaded_data['delay']})    \n",
-    "axis=[data['Angle'],data['Ekin']-21.7,data['delay']]\n",
+    "data= data_array.loc[{\n",
+    "    'kx': slice(0.48, 0.6800000000000002),\n",
+    "}].mean(dim=('kx'))\n",
     "\n",
     "# print(data.dims)\n",
-    "graph_window= Gui_3d(data,0,0,'Phoibos')\n",
-    "graph_window.show()\n",
-    "data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "c14ca2d1",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x221e8fc5700>]"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x800 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "fig,ax=plt.subplots(1,1,figsize=(12,8))\n",
-    "data.loc[{data.dims[0]: slice(-3.42, 6.04), data.dims[1]: slice(-0.85, -0.07)}].sum(dim=(data.dims[0], data.dims[1])).plot(ax=ax)  # Green MDC\n",
-    "# data.sel({data.dims[2]: slice(-799.45, -499.65)}).sum(dim=data.dims[2]).sel({data.dims[1]: -0.19}, method='nearest')  # Yellow MDC\n",
-    "# data.sel({data.dims[2]: slice(-799.45, -499.65)}).sum(dim=data.dims[2]).sel({data.dims[1]: -0.19}, method='nearest').plot(ax=ax) "
+    "graph_window= Gui_3d(data)\n",
+    "graph_window.show()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "dea42cc8",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "yellow_vertical,yellow_horizontal,green_vertical,green_horizontal= f\"{self.dot1.center[0]:.2f} ,{self.dot1.center[1]:.2f},{self.dot2.center[0]:.2f},{self.dot2.center[1]:.2f}\"\n",
-      "data2D_plot=data.sel({data.dims[2]:slice(624.57, 674.53)}).sum(dim=data.dims[2])\n"
-     ]
-    }
-   ],
-   "source": [
-    "data2D_plot=data.sel({data.dims[2]:slice(674.5333333333291, 749.4799999999675)}).sum(dim=data.dims[2])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "f5bc2a27",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.QuadMesh at 0x221171081a0>"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x800 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "fig,ax=plt.subplots(1,1,figsize=(12,8))\n",
-    "data2D_plot.plot(ax=ax, cmap='terrain')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "fe4ced28",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "5"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "5"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "8156e845",
+   "id": "c14ca2d1",
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
-    "data=data\n",
-    "data = data.assign_coords(Ekin=data.coords['Ekin'] -21.7)\n",
-    "#the 2D plot data\n",
-    "data2D_plot=data.isel({data.dims[2]:slice(0, 1)}).sum(dim=data.dims[2])   \n",
-    "\n",
-    "            "
+    "import matplotlib.pyplot as plt\n",
+    "fig,ax=plt.subplots(1,1)\n",
+    "data.loc[{data.dims[0]: slice(-0.97, -0.60), data.dims[1]: slice(0.99, 1.56)}].mean(dim=(data.dims[0], data.dims[1])).plot(ax=ax)  # Box integration\n",
+    "plt.show()"
    ]
   },
   {
@@ -311,255 +112,19 @@
    "execution_count": null,
    "id": "5c78b3de",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "f0_A 68594891.74885073\n",
-      "f0_x0 -0.04113953488371891\n",
-      "f0_gamma 0.2\n",
-      "results extracted!\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "#Use the fit panel on the extracted data\n",
     "from mpes_tools.fit_panel import fit_panel\n",
     "%gui qt\n",
-    "graph_window=fit_panel(data,7.26502584586467,0, 0,0, data.dims[1])\n",
-    "graph_window.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "fa77e9ea",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "5"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<Figure size 640x480 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "5"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "87674cf1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "import xarray as xr\n",
-    "import numpy as np\n",
-    "\n",
-    "data_array = xr.DataArray(\n",
-    "    data=np.array([-0.06408675327381325, -0.063909542295367, -0.06371011897310751, -0.06503485241489142, -0.06674640906852701, -0.06805910712822637, -0.0673262244773315, -0.06791928154383757, -0.06794237706710785, -0.06664877554908763, -0.0652935335095996, -0.06504622348475712, -0.065035814834493, -0.0633718361899608, -0.063818909320266, -0.06232675039586483, -0.0621097230514767, -0.06305103749744877, -0.062396139421285524, -0.06241744208002782, -0.062120839236189614, -0.06176266979202111, -0.0630236363208958, -0.06278593213829542, -0.06303474668234264, -0.06426194448687265, -0.06597832379389597, -0.0675165514728734, -0.0681648104899741, -0.06789394642146951, -0.0682773450383019, -0.06821050673630791, -0.06812316809846124, -0.06794932731709455, -0.06727620917695594, -0.06688088523425127, -0.06681413040826198, -0.06555736923755218, -0.06565064400572977, -0.0646168556999122, -0.060782342905129925, -0.06230590290442724, -0.062307172077220564, -0.06460057558698659, -0.06627930899665781, -0.06544192791581478, -0.06468084127852305, -0.0644825518856323, -0.06423057418146402, -0.06252219575489999, -0.063163479851845, -0.06378012124599329, -0.06411224615179537, -0.06430960962767349, -0.06350623988348696, -0.06302572118934185, -0.06294101229235687, -0.06300268394088233, -0.06379463353897145, -0.06385408546578876, -0.06431904217520991, -0.06428783077386985, -0.06400554797596462, -0.0643282814344515, -0.06350550603083734, -0.06308239186415802, -0.06393654905327996, -0.06408506676353795, -0.06504035399665667, -0.06382432328214742, -0.06417442058913722, -0.06326170209225304, -0.06372611067357502, -0.06443451549183822, -0.06401162876760495, -0.06335447937775379, -0.06416821076582208, -0.06455746652083094, -0.06395384262610614, -0.06348368054215639, -0.06392145704513459, -0.06457859517607414]),\n",
-    "    dims=('delay',),\n",
-    "    coords={'delay': [-799.4466666666729, -499.65333333337486, -199.86000000002943, -99.93333333336332, -74.94666666668573, -49.96666666670534, -24.980000000027754, 0.0, 24.979999999980386, 49.96666666665798, 74.94666666663836, 99.93333333331596, 124.91333333329634, 149.8933333333241, 174.88000000000167, 199.85999999998208, 224.84666666665967, 249.82666666664005, 274.8066666666678, 299.79333333329805, 324.77333333332575, 349.76000000000334, 374.73999999998375, 399.71999999996416, 424.70666666664175, 449.6866666666695, 474.6733333332997, 499.65333333332745, 524.6399999999577, 549.6199999999855, 574.5999999999658, 599.5866666666434, 624.5666666666239, 649.5533333333013, 674.5333333333291, 699.5133333333096, 724.4999999999872, 749.4799999999675, 774.4666666666451, 799.4466666666254, 899.3799999999889, 999.3066666666549, 1099.239999999971, 1199.166666666637, 1299.1000000000004, 1399.0333333333162, 1498.9599999999823, 1598.8933333332984, 1698.8266666666616, 1798.7533333333279, 1898.6866666666438, 1998.6133333333098, 2098.5466666666257, 2198.479999999989, 2298.4066666666554, 2398.339999999971, 2498.2733333333344, 2598.2000000000007, 2698.1333333333164, 2798.0599999999827, 2897.993333333299, 2997.926666666662, 3097.853333333328, 3197.786666666644, 3297.7199999999602, 3397.646666666626, 3497.5799999999895, 3597.5066666666557, 3697.4399999999714, 3797.373333333335, 3897.300000000001, 3997.2333333333168, 4097.166666666633, 4197.093333333299, 4297.026666666662, 4396.953333333328, 4496.8866666666445, 4596.819999999961, 4696.746666666627, 4796.679999999989, 4896.6133333333055, 4996.539999999972]},\n",
-    "    name=\"f0_x0\"\n",
-    ")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "e74ff8ab",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<Figure size 640x480 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "\n",
-    "import xarray as xr\n",
-    "import numpy as np\n",
-    "\n",
-    "data_array = xr.DataArray(\n",
-    "    data=np.array([72454952.77813482, 74319394.28211385, 73902532.98867458, 71794649.12762325, 69014759.66859658, 64599615.499209926, 60882255.5172165, 58062323.58021691, 56750480.96430322, 56591974.51984634, 57053402.50227239, 58778077.13226885, 59581963.89421518, 62141887.68747307, 62140060.63846748, 63885922.12931153, 64763429.65702102, 65304896.7568378, 65599500.53851978, 67176412.11176091, 67299577.25888413, 67704501.05965017, 67746919.56904675, 67477095.46338437, 68109844.82892786, 68152383.42887904, 68101379.96762604, 68354705.80635957, 68622612.31118561, 68693658.6672469, 68949276.09725638, 68464478.46383135, 68297500.8992677, 68581073.5576817, 69156170.4879223, 68784956.93797548, 68601158.52842137, 68982572.6141164, 70068112.8320306, 69431684.97362354, 70064932.14450617, 69014533.06417881, 69112771.21447168, 69085856.65415049, 68686796.79644686, 69635436.53035763, 70133547.77226815, 70765222.3548185, 69798788.24872309, 70365060.35463753, 69805831.4598499, 70565982.03507684, 70761296.45137312, 70079495.2628483, 71242645.59718813, 71227586.09940824, 70449179.10912453, 69801265.3630908, 71011537.35769275, 70572296.99510731, 69851458.57252772, 70041990.79150626, 70929439.1441927, 70376205.0775435, 69823762.39368734, 70497642.1116163, 70653051.51037209, 70691808.57159007, 70598843.36181132, 70560704.38856414, 71101037.98545931, 70926537.33602336, 70388372.96071577, 70458144.73793708, 70415826.91751112, 71362907.81362744, 70449584.87394847, 70543133.37354767, 71670780.93813168, 70373590.28219332, 70527269.34599042, 69911586.02810569]),\n",
-    "    dims=('delay',),\n",
-    "    coords={'delay': [-799.4466666666729, -499.65333333337486, -199.86000000002943, -99.93333333336332, -74.94666666668573, -49.96666666670534, -24.980000000027754, 0.0, 24.979999999980386, 49.96666666665798, 74.94666666663836, 99.93333333331596, 124.91333333329634, 149.8933333333241, 174.88000000000167, 199.85999999998208, 224.84666666665967, 249.82666666664005, 274.8066666666678, 299.79333333329805, 324.77333333332575, 349.76000000000334, 374.73999999998375, 399.71999999996416, 424.70666666664175, 449.6866666666695, 474.6733333332997, 499.65333333332745, 524.6399999999577, 549.6199999999855, 574.5999999999658, 599.5866666666434, 624.5666666666239, 649.5533333333013, 674.5333333333291, 699.5133333333096, 724.4999999999872, 749.4799999999675, 774.4666666666451, 799.4466666666254, 899.3799999999889, 999.3066666666549, 1099.239999999971, 1199.166666666637, 1299.1000000000004, 1399.0333333333162, 1498.9599999999823, 1598.8933333332984, 1698.8266666666616, 1798.7533333333279, 1898.6866666666438, 1998.6133333333098, 2098.5466666666257, 2198.479999999989, 2298.4066666666554, 2398.339999999971, 2498.2733333333344, 2598.2000000000007, 2698.1333333333164, 2798.0599999999827, 2897.993333333299, 2997.926666666662, 3097.853333333328, 3197.786666666644, 3297.7199999999602, 3397.646666666626, 3497.5799999999895, 3597.5066666666557, 3697.4399999999714, 3797.373333333335, 3897.300000000001, 3997.2333333333168, 4097.166666666633, 4197.093333333299, 4297.026666666662, 4396.953333333328, 4496.8866666666445, 4596.819999999961, 4696.746666666627, 4796.679999999989, 4896.6133333333055, 4996.539999999972]},\n",
-    "    name=\"f0_A\"\n",
-    ")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "2c6bc231",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x1ec49db33b0>]"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1200x800 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "fig,ax=plt.subplots(1,1,figsize=(12,8))\n",
-    "data_array.plot(ax=ax)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "08f327a9",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "f0_A 0.0682773450383019\n",
-      "f0_omega 0.001\n",
-      "f0_phi 0\n",
-      "[[Model]]\n",
-      "    (Model(zero) + Model(sinusoid, prefix='f0_'))\n",
-      "[[Fit Statistics]]\n",
-      "    # fitting method   = leastsq\n",
-      "    # function evals   = 33\n",
-      "    # data points      = 59\n",
-      "    # variables        = 3\n",
-      "    chi-square         = 2.2764e-04\n",
-      "    reduced chi-square = 4.0650e-06\n",
-      "    Akaike info crit   = -729.451273\n",
-      "    Bayesian info crit = -723.218661\n",
-      "    R-squared          = 0.08350621\n",
-      "[[Variables]]\n",
-      "    f0_A:      0.06587170 +/- 0.00530377 (8.05%) (init = 0.06827735)\n",
-      "    f0_omega:  5.3119e-05 +/- 1.1647e-04 (219.26%) (init = 0.001)\n",
-      "    f0_phi:    1.70061631 +/- 0.57659252 (33.90%) (init = 0)\n",
-      "[[Correlations]] (unreported correlations are < 0.250)\n",
-      "    C(f0_A, f0_phi)     = +0.9978\n",
-      "    C(f0_omega, f0_phi) = -0.9888\n",
-      "    C(f0_A, f0_omega)   = -0.9804\n",
-      "f0_A 0.0682773450383019\n",
-      "f0_omega 1\n",
-      "f0_phi 0\n",
-      "[[Model]]\n",
-      "    (Model(zero) + Model(sinusoid, prefix='f0_'))\n",
-      "[[Fit Statistics]]\n",
-      "    # fitting method   = leastsq\n",
-      "    # function evals   = 110\n",
-      "    # data points      = 44\n",
-      "    # variables        = 3\n",
-      "    chi-square         = 0.11362185\n",
-      "    reduced chi-square = 0.00277126\n",
-      "    Akaike info crit   = -256.199040\n",
-      "    Bayesian info crit = -250.846471\n",
-      "    R-squared          = -599.468641\n",
-      "[[Variables]]\n",
-      "    f0_A:     -0.05410532 +/- 0.01095403 (20.25%) (init = 0.06827735)\n",
-      "    f0_omega:  1.00207580 +/- 3.5692e-04 (0.04%) (init = 1)\n",
-      "    f0_phi:    0.17032802 +/- 0.37060122 (217.58%) (init = 0)\n",
-      "[[Correlations]] (unreported correlations are < 0.250)\n",
-      "    C(f0_omega, f0_phi) = -0.8100\n",
-      "f0_A 0.0682773450383019\n",
-      "f0_omega 1\n",
-      "f0_phi 0\n",
-      "f0_A 0.0682773450383019\n",
-      "f0_omega 1\n",
-      "f0_phi 0\n",
-      "f1_A 0.0682773450383019\n",
-      "[[Model]]\n",
-      "    ((Model(zero) + Model(sinusoid, prefix='f0_')) + Model(constant, prefix='f1_'))\n",
-      "[[Fit Statistics]]\n",
-      "    # fitting method   = leastsq\n",
-      "    # function evals   = 152\n",
-      "    # data points      = 44\n",
-      "    # variables        = 4\n",
-      "    chi-square         = 5.7932e-05\n",
-      "    reduced chi-square = 1.4483e-06\n",
-      "    Akaike info crit   = -587.778608\n",
-      "    Bayesian info crit = -580.641849\n",
-      "    R-squared          = 0.69383876\n",
-      "[[Variables]]\n",
-      "    f0_A:      0.00244399 +/- 2.5720e-04 (10.52%) (init = 0.06827735)\n",
-      "    f0_omega:  0.99739845 +/- 1.6175e-04 (0.02%) (init = 1)\n",
-      "    f0_phi:    0.73122050 +/- 0.17476307 (23.90%) (init = 0)\n",
-      "    f1_A:      0.06459993 +/- 1.8170e-04 (0.28%) (init = 0.06827735)\n",
-      "[[Correlations]] (unreported correlations are < 0.250)\n",
-      "    C(f0_omega, f0_phi) = -0.7996\n",
-      "f0_A 0.0682773450383019\n",
-      "f0_omega 1\n",
-      "f0_phi 0\n",
-      "f1_A 0.0682773450383019\n",
-      "[[Model]]\n",
-      "    ((Model(zero) + Model(sinusoid, prefix='f0_')) + Model(constant, prefix='f1_'))\n",
-      "[[Fit Statistics]]\n",
-      "    # fitting method   = leastsq\n",
-      "    # function evals   = 152\n",
-      "    # data points      = 44\n",
-      "    # variables        = 4\n",
-      "    chi-square         = 5.7932e-05\n",
-      "    reduced chi-square = 1.4483e-06\n",
-      "    Akaike info crit   = -587.778608\n",
-      "    Bayesian info crit = -580.641849\n",
-      "    R-squared          = 0.69383876\n",
-      "[[Variables]]\n",
-      "    f0_A:      0.00244399 +/- 2.5720e-04 (10.52%) (init = 0.06827735)\n",
-      "    f0_omega:  0.99739845 +/- 1.6175e-04 (0.02%) (init = 1)\n",
-      "    f0_phi:    0.73122050 +/- 0.17476307 (23.90%) (init = 0)\n",
-      "    f1_A:      0.06459993 +/- 1.8170e-04 (0.28%) (init = 0.06827735)\n",
-      "[[Correlations]] (unreported correlations are < 0.250)\n",
-      "    C(f0_omega, f0_phi) = -0.7996\n"
-     ]
-    }
-   ],
-   "source": [
-    "from mpes_tools.fit_panel_single import fit_panel_single\n",
-    "%gui qt\n",
-    "graph_window=fit_panel_single(-data_array)\n",
+    "graph_window=fit_panel(data,0, 10, \"box\")\n",
     "graph_window.show()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "721a63f3",
+   "id": "f46368fe",
    "metadata": {},
    "outputs": [],
    "source": []
@@ -567,7 +132,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -581,7 +146,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.4"
+   "version": "3.12.0"
   }
  },
  "nbformat": 4,

From 1629809a04f95c410c40ddde10916174680842f8 Mon Sep 17 00:00:00 2001
From: Laurenz Rettig <rettig@fhi-berlin.mpg.de>
Date: Wed, 7 May 2025 12:16:28 +0200
Subject: [PATCH 65/67] update easy access api

---
 .cspell/custom-dictionary.txt | 14 ++++++
 src/mpes_tools/__init__.py    |  5 +-
 tutorials/template.ipynb      | 89 ++++++++++++++++++++++-------------
 3 files changed, 74 insertions(+), 34 deletions(-)

diff --git a/.cspell/custom-dictionary.txt b/.cspell/custom-dictionary.txt
index e69de29..944bb8b 100644
--- a/.cspell/custom-dictionary.txt
+++ b/.cspell/custom-dictionary.txt
@@ -0,0 +1,14 @@
+ARPES
+cmap
+codemirror
+ipython
+kernelspec
+matplotlib
+mpes
+nbconvert
+nbformat
+numpy
+nxarray
+pygments
+pyplot
+venv
diff --git a/src/mpes_tools/__init__.py b/src/mpes_tools/__init__.py
index cb01bcb..3905e21 100644
--- a/src/mpes_tools/__init__.py
+++ b/src/mpes_tools/__init__.py
@@ -1,7 +1,10 @@
 """mpes-tools module easy access APIs."""
 import importlib.metadata
 
+from mpes_tools.fit_panel import fit_panel
+from mpes_tools.Gui_3d import Gui_3d
+from mpes_tools.Main import ARPES_Analyser
 from mpes_tools.show_4d_window import show_4d_window
 
 __version__ = importlib.metadata.version("mpes-tools")
-__all__ = ["show_4d_window"]
\ No newline at end of file
+__all__ = ["show_4d_window", "Gui_3d", "fit_panel", "ARPES_Analyser"]
diff --git a/tutorials/template.ipynb b/tutorials/template.ipynb
index c203373..f3b6d87 100644
--- a/tutorials/template.ipynb
+++ b/tutorials/template.ipynb
@@ -9,9 +9,26 @@
    "source": [
     "# import the 4D data\n",
     "import numpy as np\n",
-    "from mpes_tools.hdf5 import load_h5\n",
     "import nxarray\n",
-    "import os"
+    "import os\n",
+    "import matplotlib.pyplot as plt\n",
+    "from mpes_tools import show_4d_window\n",
+    "from mpes_tools import Gui_3d\n",
+    "from mpes_tools import fit_panel\n",
+    "from mpes_tools import ARPES_Analyser\n",
+    "\n",
+    "%gui qt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d7a3e58c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Loading panel\n",
+    "ARPES_Analyser()"
    ]
   },
   {
@@ -44,8 +61,6 @@
    "outputs": [],
    "source": [
     "# Use the 4D Gui\n",
-    "from mpes_tools.show_4d_window import show_4d_window\n",
-    "%gui qt\n",
     "graph_4d = show_4d_window(data_array)\n",
     "graph_4d.show()"
    ]
@@ -57,18 +72,21 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "data=data_array\n",
-    "#the energy plot\n",
-    "\n",
-    "en=data.loc[{\n",
-    "    'energy': slice(-0.04999999999999982, 0.0),\n",
-    "    'delay': slice(-0.00399999999999999, 0.014000000000000012)\n",
-    "}].mean(dim=('energy', 'delay')).T  \n",
-    "fig,ax=plt.subplots(1,1)\n",
-    "en.plot(ax=ax,cmap='terrain')\n",
-    "plt.show()\n",
-    "            "
+    "data = data_array\n",
+    "# the energy plot\n",
+    "en = (\n",
+    "    data.loc[\n",
+    "        {\n",
+    "            \"energy\": slice(-0.04999999999999982, 0.0),\n",
+    "            \"delay\": slice(-0.00399999999999999, 0.014000000000000012),\n",
+    "        }\n",
+    "    ]\n",
+    "    .mean(dim=(\"energy\", \"delay\"))\n",
+    "    .T\n",
+    ")\n",
+    "fig, ax = plt.subplots(1, 1)\n",
+    "en.plot(ax=ax, cmap=\"terrain\")\n",
+    "plt.show()"
    ]
   },
   {
@@ -79,18 +97,15 @@
    "outputs": [],
    "source": [
     "# Use the 3D Gui\n",
-    "\n",
-    "import numpy as np\n",
-    "from mpes_tools.Gui_3d import Gui_3d\n",
-    "%gui qt\n",
-    "\n",
-    "# import the 3D data\n",
-    "data= data_array.loc[{\n",
-    "    'kx': slice(0.48, 0.6800000000000002),\n",
-    "}].mean(dim=('kx'))\n",
+    "# select the 3D data\n",
+    "data = data_array.loc[\n",
+    "    {\n",
+    "        \"kx\": slice(0.48, 0.6800000000000002),\n",
+    "    }\n",
+    "].mean(dim=(\"kx\"))\n",
     "\n",
     "# print(data.dims)\n",
-    "graph_window= Gui_3d(data)\n",
+    "graph_window = Gui_3d(data)\n",
     "graph_window.show()"
    ]
   },
@@ -101,9 +116,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "fig,ax=plt.subplots(1,1)\n",
-    "data.loc[{data.dims[0]: slice(-0.97, -0.60), data.dims[1]: slice(0.99, 1.56)}].mean(dim=(data.dims[0], data.dims[1])).plot(ax=ax)  # Box integration\n",
+    "fig, ax = plt.subplots(1, 1)\n",
+    "data.loc[{data.dims[0]: slice(-0.97, -0.60), data.dims[1]: slice(0.99, 1.56)}].mean(\n",
+    "    dim=(data.dims[0], data.dims[1])\n",
+    ").plot(ax=ax)  # Box integration\n",
     "plt.show()"
    ]
   },
@@ -114,10 +130,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#Use the fit panel on the extracted data\n",
-    "from mpes_tools.fit_panel import fit_panel\n",
-    "%gui qt\n",
-    "graph_window=fit_panel(data,0, 10, \"box\")\n",
+    "# Use the fit panel on the extracted data\n",
+    "data_edc = data.sel({data.dims[0]: slice(0.86, 1.08)}).mean(dim=data.dims[0])\n",
+    "graph_window = fit_panel(data_edc, 0, 5, \"\")\n",
     "graph_window.show()"
    ]
   },
@@ -128,6 +143,14 @@
    "metadata": {},
    "outputs": [],
    "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a5a0b003",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {

From 18cfc9a5918b02a599a909faabd633607ec519b0 Mon Sep 17 00:00:00 2001
From: Amine Wahada <wahada@FHI.MPG.DE>
Date: Wed, 7 May 2025 12:50:54 +0200
Subject: [PATCH 66/67] stored the colorscale variables

---
 src/mpes_tools/Gui_3d.py         |  2 +-
 src/mpes_tools/show_4d_window.py | 12 ++++++++----
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/mpes_tools/Gui_3d.py b/src/mpes_tools/Gui_3d.py
index 5504a3f..bec027b 100644
--- a/src/mpes_tools/Gui_3d.py
+++ b/src/mpes_tools/Gui_3d.py
@@ -175,7 +175,7 @@ def __init__(self,data_array: xr.DataArray,t=None,dt=None):
         # plot the main graph
         self.im = self.data2D_plot.plot(ax=self.axes[0], cmap='terrain', add_colorbar=False)
         self.axes[0].figure.colorbar(self.im, ax=self.axes[0])
-        colorscale_slider(canvas_layout, self.im, self.axes[0].figure.canvas)
+        self.colorscale_2dplot=colorscale_slider(canvas_layout, self.im, self.axes[0].figure.canvas)
         
         # define the initial positions of the cursors in the main graph
         
diff --git a/src/mpes_tools/show_4d_window.py b/src/mpes_tools/show_4d_window.py
index 47dbb8a..3339e6d 100644
--- a/src/mpes_tools/show_4d_window.py
+++ b/src/mpes_tools/show_4d_window.py
@@ -152,6 +152,10 @@ def __init__(self,data_array: xr.DataArray):
         # file_menu.addAction(open_graph_action)
         self.graph_windows = []
 
+        self.colorscale_energy=[]
+        self.colorscale_ky=[]
+        self.colorscale_kx=[]
+        self.colorscale_dt=[]
         self.show()
         self.load_data(data_array)
 
@@ -318,10 +322,10 @@ def initialize_plots(self):
         self.im2.set_clim([self.data_array.min(),self.data_array.max()])
         self.im3.set_clim([self.data_array.min(),self.data_array.max()])
     
-        colorscale_slider(self.graph_layout_list[0], self.im0, self.canvases[0], [self.data_array.min(),self.data_array.max()])
-        colorscale_slider(self.graph_layout_list[1], self.im1, self.canvases[1], [self.data_array.min(),self.data_array.max()])
-        colorscale_slider(self.graph_layout_list[2], self.im2, self.canvases[2], [self.data_array.min(),self.data_array.max()])
-        colorscale_slider(self.graph_layout_list[3], self.im3, self.canvases[3], [self.data_array.min(),self.data_array.max()])
+        self.colorscale_energy=colorscale_slider(self.graph_layout_list[0], self.im0, self.canvases[0], [self.data_array.min(),self.data_array.max()])
+        self.colorscale_ky=colorscale_slider(self.graph_layout_list[1], self.im1, self.canvases[1], [self.data_array.min(),self.data_array.max()])
+        self.colorscale_kx=colorscale_slider(self.graph_layout_list[2], self.im2, self.canvases[2], [self.data_array.min(),self.data_array.max()])
+        self.colorscale_dt=colorscale_slider(self.graph_layout_list[3], self.im3, self.canvases[3], [self.data_array.min(),self.data_array.max()])
         
     def initialize_cursors(self):
         

From 657b3addf7d591c2bb155b6b76e22b19953586b4 Mon Sep 17 00:00:00 2001
From: Laurenz Rettig <rettig@fhi-berlin.mpg.de>
Date: Wed, 7 May 2025 13:53:46 +0200
Subject: [PATCH 67/67] format

---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index cb70849..1404c97 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -36,7 +36,7 @@ dependencies = [
     "PyQt5>=5.0.0",
     "xarray>=0.20.2",
     "nxarray>=0.4.4",
-   "superqt >=0.3.0",
+    "superqt >=0.3.0",
 ]
 
 [project.urls]