qcodespp 0.1.2__tar.gz → 0.1.4__tar.gz

{qcodespp-0.1.2 → qcodespp-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qcodespp
-Version: 0.1.2
+Version: 0.1.4
 Summary: Package providing additional functions for QCoDeS
 Maintainer-email: Damon Carrad <damonc@dtu.dk>
 Requires-Python: >=3.10

{qcodespp-0.1.2 → qcodespp-0.1.4}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = 'flit_core.buildapi'
 
 [project]
 name = "qcodespp"
-version = '0.1.2'
+version = '0.1.4'
 maintainers = [{name = "Damon Carrad", email = "damonc@dtu.dk"}]
 description = "Package providing additional functions for QCoDeS"
 classifiers = [

{qcodespp-0.1.2 → qcodespp-0.1.4}/qcodespp/__init__.py

@@ -65,6 +65,7 @@ from qcodespp.actions import Task, Wait, BreakIf
 
 from qcodespp.plotting.RemotePlot import Plot, live_plot
 from qcodespp.plotting.offline.main import offline_plotting
+from qcodespp.plotting.analysis_tools import colorplot, colored_traces
 
 from qcodespp.data.data_set import new_data, load_data, load_data_num, load_data_nums, set_data_format, set_data_folder
 

{qcodespp-0.1.2 → qcodespp-0.1.4}/qcodespp/data/data_set.py

@@ -274,6 +274,8 @@ class DataSetPP(DelegateAttributes):
     default_formatter = GNUPlotFormat()
     location_provider = FormatLocation()
 
+    default_folder=None
+
     background_functions: Dict[str, Callable] = OrderedDict()
 
     def __init__(self, location=None, arrays=None, formatter=None, io=None,

{qcodespp-0.1.2 → qcodespp-0.1.4}/qcodespp/loops.py

@@ -123,7 +123,10 @@ def loop1d(sweep_parameter,
     if measure:
         Station.default.set_measurement(*measure)
     loop=Loop(sweep_parameter.sweep(start,stop,num=num), delay).each(*Station.default.measure())
-    name=f'{device_info} {sweep_parameter.full_name}({start:.6g} {stop:.6g}){sweep_parameter.unit} with {instrument_info}'
+    
+    start_text, stop_text, unit_text = _filename_text(start, stop, sweep_parameter)
+
+    name=f'{device_info} {sweep_parameter.full_name}({start_text} {stop_text}){unit_text} with {instrument_info}'
     data=loop.get_data_set(name=name)
     if plot:
         pp=live_plot(data,plot)
@@ -208,8 +211,11 @@ def loop2d(sweep_parameter,
     else:
         loop2d=Loop(step_parameter.sweep(step_start,step_stop,num=step_num), step_delay,snake=snake).each(loop)
 
-    name=(f'{device_info} {step_parameter.full_name}({step_start:.6g} {step_stop:.6g}){sweep_parameter.unit} '
-        f'{sweep_parameter.full_name}({start:.6g} {stop:.6g}){sweep_parameter.unit} with {instrument_info}')
+    start_text, stop_text, unit_text = _filename_text(start, stop, sweep_parameter)
+    step_start_text, step_stop_text, step_unit_text = _filename_text(step_start, step_stop, step_parameter)
+
+    name=(f'{device_info} {step_parameter.full_name}({step_start_text} {step_stop_text}){step_unit_text} '
+        f'{sweep_parameter.full_name}({start_text} {stop_text}){unit_text} with {instrument_info}')
     data=loop2d.get_data_set(name=name)
 
     if plot:
@@ -297,8 +303,11 @@ def loop2dUD(sweep_parameter,
     else:
         loop2d=Loop(step_parameter.sweep(step_start,step_stop,num=step_num), step_delay).each(loop,loop_down)
 
-    name=(f'{device_info} {step_parameter.full_name}({step_start:.6g} {step_stop:.6g}){sweep_parameter.unit} '
-        f'{sweep_parameter.full_name}({start:.6g} {stop:.6g}){sweep_parameter.unit} with {instrument_info}')
+    start_text, stop_text, unit_text = _filename_text(start, stop, sweep_parameter)
+    step_start_text, step_stop_text, step_unit_text = _filename_text(step_start, step_stop, step_parameter)
+
+    name=(f'{device_info} {step_parameter.full_name}({step_start_text} {step_stop_text}){step_unit_text} '
+        f'{sweep_parameter.full_name}({start_text} {stop_text}){unit_text} with {instrument_info}')
     data=loop2d.get_data_set(name=name)
 
     if plot:
@@ -311,6 +320,23 @@ def loop2dUD(sweep_parameter,
     
     return loop2d
 
+def _filename_text(start,stop,parameter):
+    '''
+    Function to deal with MultiParameter sweeps, where the filename text can become complicted
+    '''
+    if isinstance(start, tuple):
+        start_text= ','.join([f'{s:.6g}' for s in start])
+        start_text=f'({start_text})'
+        stop_text= ','.join([f'{s:.6g}' for s in stop])
+        stop_text=f'({stop_text})'
+        unit_text= ','.join([unit for unit in parameter.units])
+        unit_text=f'({unit_text})'
+    else:
+        start_text= f'{start:.6g}'
+        stop_text= f'{stop:.6g}'
+        unit_text= parameter.unit
+    return start_text, stop_text, unit_text
+
 class Loop(Metadatable):
     """
     Create a measurement loop to sweep over a parameter and store measured data from other
@@ -986,7 +1012,7 @@ class ActiveLoop(Metadatable):
             if isinstance(action, ActiveLoop):
                 estimate=estimate+self.sweep_values.snapshot()['values'][0]['num']*action.sweep_values.snapshot()['values'][0]['num']*(commtime+action.delay+extra_delay[1])
         
-        string=(f'Estimated time: {estimate} s, {estimate/60} mins, {estimate/3600} hours\n'
+        string=(f'Estimated time: {estimate:.2f} s / {estimate/60:.2f} mins / {estimate/3600:.2f} hours\n'
                 f'Done at: {time.asctime(time.localtime(time.time()+estimate))}')
         return string
 

{qcodespp-0.1.2 → qcodespp-0.1.4}/qcodespp/parameters.py

@@ -1,6 +1,8 @@
 """A collection of functions that get added to the QCoDeS Parameter class.
 
-In addition, two wrapper classes are provided to easily create ArrayParameters and MultiParameters."""
+In addition, two wrapper classes are provided to easily create ArrayParameters and MultiParameters.
+MultiParameters created with this method become settable, sweepable and movable.
+"""
 
 import time
 
@@ -10,9 +12,15 @@ from qcodes.parameters import (
     ArrayParameter,
     MultiParameter,
     Parameter,
-    SweepFixedValues,
+    ParameterBase,
+    SweepFixedValues
 )
 
+from typing import Any
+
+from qcodes.parameters.sequence_helpers import is_sequence
+from qcodes.parameters.sweep_values import make_sweep
+
 def move(self,end_value,steps=101,step_time=0.03):
     """
     Move the parameter to a new value in a number of steps without taking data.
@@ -216,6 +224,52 @@ class ArrayParameterWrapper(ArrayParameter):
 
         super().__init__(name=name, shape=shape,instrument=instrument,label=label,unit=unit)
 
+class SweepMultiValues(SweepFixedValues):
+    '''
+    Class to enable sweeping MultiParameters with different values for each parameter.
+
+    Simply a subclass of SweepFixedValues with a restricted set of options to ensure that the
+    setpoints are constructed correctly.
+    
+    Args:
+        parameter (MultiParameter): The MultiParameter to sweep.
+        keys (list): A list of lists, where each inner list contains the setpoints for each 
+        parameter at that sweep index.
+    '''
+    def __init__(
+        self,
+        parameter: ParameterBase,
+        keys: Any | None = None):
+
+        super().__init__(parameter,keys)
+        # Initialising the parent class constructs the setpoints incorrectly, 
+        # so reset self._values to an empty list.
+        self._values: list[Any] = []
+        self._snapshot: dict[str, Any] = {}
+        self._value_snapshot: list[dict[str, Any]] = []
+
+        if isinstance(keys, slice):
+            self._add_slice(keys)
+            self._add_linear_snapshot(self._values)
+
+        elif is_sequence(keys):
+            for key in keys:
+                if isinstance(key, slice):
+                    self._add_slice(key)
+                else:
+                    # assume a single value
+                    self._values.append(key)
+            # we dont want the snapshot to go crazy on big data
+            if self._values:
+                self._add_sequence_snapshot(self._values)
+
+        else:
+            # assume a single value
+            self._values.append(keys)
+            self._value_snapshot.append({"item": keys})
+
+        self.validate(self._values)
+
 class MultiParameterWrapper(MultiParameter):
     """
     Class to wrap multiple pre-existing parameters into MultiParameter. Enables getting, setting, sweeping and moving.
@@ -271,12 +325,28 @@ class MultiParameterWrapper(MultiParameter):
 
         self.labels=tuple(labels)
         self.units=tuple(units)
+        self.unit='' # Mainly to be compatible with automatic naming in loop1d,loop2d, etc.
 
     def get_raw(self):
+        '''
+        Method to get the values of all parameters in the MultiParameter.
+
+        Returns:
+            tuple: A tuple containing the values of all parameters in the MultiParameter.
+        '''
         return tuple([param.get() for param in self.parameters])
 
     def set_raw(self, values):
-        if type(values) is int or type(values) is float:
+        """
+        Method to set the values of all parameters in the MultiParameter.
+
+        Args:
+            values (list, tuple, int, float): The values to set for the parameters.
+                If a single value is provided, it will be set for all parameters.
+                If a list or tuple is provided, it must match the number of parameters.
+        """
+
+        if type(values) in [int, float]:
             for parameter in self.parameters:
                 parameter.set(values)
         elif numpy.array(values).shape != numpy.array(self.parameters).shape:
@@ -286,26 +356,90 @@ class MultiParameterWrapper(MultiParameter):
                 self.parameters[i].set(value)
 
     def move(self,end_values,steps=101,step_time=0.03):
-        if type(end_values) is int or type(end_values) is float:
+        """
+        Move all parameters to new values in a number of steps without taking data.
+
+        Args:
+            end_values (list, tuple, int, float): The values to move to.
+                If a single value is provided, it will be moved for all parameters.
+                If a list or tuple is provided, it must match the number of parameters.
+            steps (int, optional): Number of steps to take. Defaults to 101.
+            step_time (float, optional): Time in seconds between each step. Defaults to 0.03.
+        """
+
+        if type(end_values) in [int, float]:
             for i,param in enumerate(self.parameters):
                 param.move(end_values,steps,step_time)       
         else:
             for i,param in enumerate(self.parameters):
                 param.move(list(end_values)[i],steps,step_time)
 
-    def sweep(self, start_vals,stop_vals,num):
+    def sweep(self, start_vals,stop_vals,num,print_warning=True):
+        """
+        Create a collection of parameter values to be iterated over for all parameters in the MultiParameter.
+
+        Args:
+            start_vals (list, tuple, int, float): The starting values of the sequence.
+                If a single value is provided, it will be used for all parameters.
+                If a list or tuple is provided, it must match the number of parameters.
+
+            stop_vals (list, tuple, int, float): The end values of the sequence.
+                If a single value is provided, it will be used for all parameters.
+                If a list or tuple is provided, it must match the number of parameters.
+
+            num (int): Number of values to generate.
+
+            print_warning (bool): Whether to print a warning if the start value is different from the 
+                current value. Defaults to True.
+
+        Returns:
+            SweepFixedValues or SweepMultiValues: A collection of parameter values to be iterated over which can be passed to a Loop.
+
+        Raises:
+            ValueError: If the number of start_vals or stop_vals does not match the number of parameters, 
+            or if they are not a single value.
+        """
+
         #If the user is sweeping all params with the same values, the case is the same as Parameter.sweep
-        if numpy.array(start_vals).shape == ():
+        if type(start_vals) in [int, float]:
+            # Check that the start and stop values are the same shape
             if numpy.array(start_vals).shape != numpy.array(stop_vals).shape:
                 raise ValueError('Number of start values must match number of stop values')
+            
+            # Warn the user if the start value is different from any of the current values
+            sweeprange= numpy.abs(stop_vals - start_vals)
+            for i,parameter in enumerate(self.parameters):
+                try:
+                    if print_warning and numpy.abs(parameter.get()-start_vals)>sweeprange*1e-3:
+                        print(f'Are you sure? Start value for {parameter.name} sweep is '
+                            f'{start_vals} {parameter.unit} but '
+                            f'{parameter.name}()={parameter.get()} {parameter.unit}')
+                except TypeError: #Sometimes a parameter (especially a dummy parameter) will return None if it has not been set yet.
+                    pass
+            
+            # return SweepFixedValues as for a Parameter
             return SweepFixedValues(self, start=start_vals, stop=stop_vals,num=num)
         
-        #Otherwise, check that the shapes are correct, and make a setpointarray of the appropriate size for SweepFixedValues
+        # Otherwise, check that the shapes are correct, and make a setpointarray of the appropriate size 
+        # for SweepMultiValues, after checking the start values are close to the current values.
         elif numpy.array(start_vals).shape != numpy.array(self.parameters).shape:
-            raise ValueError('Number of start_vals must match number of parameters')
+            raise ValueError('Number of start_vals must match number of parameters, or be a signle value')
         elif numpy.array(stop_vals).shape != numpy.array(self.parameters).shape:
-            raise ValueError('Number of stop_vals must match number of parameters')
-        setpointarray=[]
-        for j in range(num):
-            setpointarray.append([start_vals[i] + (stop_vals[i] - start_vals[i])/(num-1) * j for i in range(numpy.array(self.parameters).shape[0])])
-        return SweepFixedValues(self,setpointarray)
+            raise ValueError('Number of stop_vals must match number of parameters, or be a signle value')
+        
+        else:
+            for i,parameter in enumerate(self.parameters):
+                sweeprange= numpy.abs(stop_vals[i] - start_vals[i])
+                try:
+                    if print_warning and numpy.abs(parameter.get()-start_vals[i])>sweeprange*1e-3:
+                        print(f'Are you sure? Start value for {parameter.name} sweep is '
+                                f'{start_vals[i]} {parameter.unit} but '
+                                f'{parameter.name}()={parameter.get()} {parameter.unit}')
+                except TypeError: #Sometimes a parameter (especially a dummy parameter) will return None if it has not been set yet.
+                    pass
+
+            setpointarray=[]
+            for j in range(num):
+                setpointarray.append([start_vals[i] + (stop_vals[i] - start_vals[i])/(num-1) * j for i in range(numpy.array(self.parameters).shape[0])])
+            return SweepMultiValues(self,setpointarray)
+

{qcodespp-0.1.2 → qcodespp-0.1.4}/qcodespp/plotting/analysis_tools.py

@@ -7,7 +7,8 @@ from matplotlib.ticker import MultipleLocator
 import numpy as np
 
 
-def colorplot(x,y,z,figsize=0,cmap=0,labels=0,xlim=0,ylim=0,zlim=0,xmajor=0,xminor=0,ymajor=0,yminor=0,font_size=0,label_size=0):
+def colorplot(x,y,z,figsize=0,cmap=0,labels=0,xlim=0,ylim=0,zlim=0,xmajor=0,
+              xminor=0,ymajor=0,yminor=0,font_size=0,label_size=0,check_shapes=True):
     """
     Make a nice colourplot from a three-dimensional data array using matplotlib. 
     
@@ -43,6 +44,7 @@ def colorplot(x,y,z,figsize=0,cmap=0,labels=0,xlim=0,ylim=0,zlim=0,xmajor=0,xmin
         
         label_size (int, optional): Font size for the tick labels. Default is 12.
 
+        check_shapes (bool, optional): If True, checks the shapes of x, y, and z arrays and transposes if necessary. Default is True.
 
     Returns:
         tuple: A tuple containing the figure, axis, and colorbar axis objects.
@@ -65,10 +67,11 @@ def colorplot(x,y,z,figsize=0,cmap=0,labels=0,xlim=0,ylim=0,zlim=0,xmajor=0,xmin
     fig, (ax1, cax)=plt.subplots(nrows=1,ncols=2,figsize=figsize,dpi=300,gridspec_kw={'width_ratios':[1,0.02]}) #This allows us better control over the colourbar. Note you can then 'easily' generalise this to more subplots (see below)
     fig.tight_layout(h_pad=None, w_pad=-2)
 
-    if np.shape(z)[1] != np.shape(x)[0] and np.shape(z)[0] == np.shape(x)[0]:
-        z= z.T
-    if np.shape(np.shape(y))==(2,) and np.shape(y)[1] != np.shape(x)[0] and np.shape(y)[0] == np.shape(x)[0]:
-        y= y.T
+    if check_shapes:
+        if np.shape(z)[1] != np.shape(x)[0] and np.shape(z)[0] == np.shape(x)[0]:
+            z= z.T
+        if np.shape(np.shape(y))==(2,) and np.shape(y)[1] != np.shape(x)[0] and np.shape(y)[0] == np.shape(x)[0]:
+            y= y.T
 
     if zlim!=0:
         sdbs=ax1.pcolormesh(x,y,z,cmap=cmap,rasterized=True,linewidth=0,vmin=zlim[0],vmax=zlim[1])

{qcodespp-0.1.2 → qcodespp-0.1.4}/qcodespp/plotting/offline/datatypes.py

@@ -401,7 +401,8 @@ class BaseClassData:
         
     def add_cbar_hist(self):
         self.hax=self.cbar.ax.inset_axes([-1.05, 0, 1, 1],picker=True)
-        counts, self.cbar_hist_bins = np.histogram(self.processed_data[-1],bins=int(self.settings['cmap levels']))
+        counts, self.cbar_hist_bins = np.histogram(self.processed_data[-1],bins=int(self.settings['cmap levels']),
+                                                   range=(np.nanmin(self.processed_data[-1]), np.nanmax(self.processed_data[-1])))
         midpoints = self.cbar_hist_bins[:-1] + np.diff(self.cbar_hist_bins)/2
         self.hax.fill_between(-counts, midpoints,0,color='mediumslateblue')
         self.haxfill=self.hax.fill_betweenx(np.linspace(self.view_settings['Minimum'], self.view_settings['Maximum'], 100), 
@@ -448,7 +449,7 @@ class BaseClassData:
                                                   norm=norm, cmap=cmap,
                                                   rasterized=self.settings['rasterized'])
                 if self.settings['colorbar'] == 'True':
-                    self.cbar = self.figure.colorbar(self.image, orientation='vertical')
+                    self.cbar = self.figure.colorbar(self.image)
                     if self.view_settings['CBarHist'] == True:
                         self.add_cbar_hist()
 
@@ -884,7 +885,7 @@ class MixedInternalData(BaseClassData):
                                                 norm=norm, cmap=cmap,
                                                 rasterized=self.dataset2d.settings['rasterized'])
             if self.dataset2d.settings['colorbar'] == 'True':
-                self.cbar = self.figure.colorbar(self.image, orientation='vertical')
+                self.cbar = self.figure.colorbar(self.image)
                 if self.view_settings['CBarHist'] == True:
                     self.add_cbar_hist()
 
@@ -933,7 +934,9 @@ class MixedInternalData(BaseClassData):
 
     def add_cbar_hist(self):
         self.hax=self.cbar.ax.inset_axes([-1.05, 0, 1, 1],picker=True)
-        counts, self.cbar_hist_bins = np.histogram(self.dataset2d.processed_data[-1],bins=int(self.settings['cmap levels']))
+        counts, self.cbar_hist_bins = np.histogram(self.dataset2d.processed_data[-1],bins=int(self.settings['cmap levels']),
+                                                   range=(np.nanmin(self.dataset2d.processed_data[-1]), 
+                                                          np.nanmax(self.dataset2d.processed_data[-1])))
         midpoints = self.cbar_hist_bins[:-1] + np.diff(self.cbar_hist_bins)/2
         self.hax.fill_between(-counts, midpoints,0,color='mediumslateblue')
         self.haxfill=self.hax.fill_betweenx(np.linspace(self.view_settings['Minimum'], self.view_settings['Maximum'], 100), 

{qcodespp-0.1.2 → qcodespp-0.1.4}/qcodespp/plotting/offline/editor.py

@@ -215,7 +215,7 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
                 self.update_link_to_folder(folder=folder)
             except Exception as e:
                 print(f'Failed to link to folder {folder}:', e)
-        elif link_to_default and os.path.isdir(DataSetPP.default_folder):
+        elif link_to_default and DataSetPP.default_folder and os.path.isdir(DataSetPP.default_folder):
             try:
                 print(f'Linking to qcodespp data folder at {DataSetPP.default_folder}... This may take some time.')
                 self.update_link_to_folder(folder=DataSetPP.default_folder)
@@ -1024,8 +1024,9 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
     
     def reinstate_markers(self, item, orientation):
         orientations={'horizontal':'horimarkers','vertical':'vertmarkers'}
-        arrayname=orientations[orientation]
-        setattr(item.data,arrayname,[])
+        if orientation != 'diagonal':
+            arrayname=orientations[orientation]
+            setattr(item.data,arrayname,[])
         if orientation == 'horizontal':
             for line in item.data.linecuts['horizontal']['lines']:
                 z=item.data.linecuts[orientation]['lines'][line]['cut_axis_value']
@@ -1041,6 +1042,14 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
                     color=item.data.linecuts[orientation]['lines'][line]['linecolor']))
                 item.data.vertmarkers.append(item.data.axes.axvline(x=z, linestyle='dashed', linewidth=1, ymin=0.9,
                     color=item.data.linecuts[orientation]['lines'][line]['linecolor']))
+                
+        elif orientation == 'diagonal':
+            for line in item.data.linecuts[orientation]['lines']:
+                points0= item.data.linecuts[orientation]['lines'][line]['points'][0]
+                points1= item.data.linecuts[orientation]['lines'][line]['points'][1]
+                item.data.linecuts[orientation]['lines'][line]['draggable_points']=[DraggablePoint(item.data, points0[0], points0[1],
+                                                                                            line,orientation),
+                                            DraggablePoint(item.data, points1[0], points1[1],line,orientation,draw_line=True)]
     
     def clear_sidebar1D(self):
         # clear the sidebar1D
@@ -1074,7 +1083,7 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
                     item.data.axes = item.data.figure.add_subplot(rows, cols, index+1)
                     item.data.add_plot(editor_window=self)
                     if hasattr(item.data, 'linecuts'):
-                        for orientation in ['horizontal','vertical']:#,'diagonal']:#,'circular']:
+                        for orientation in ['horizontal', 'vertical', 'diagonal']:
                             if len(item.data.linecuts[orientation]['lines']) > 0:
                                 self.reinstate_markers(item,orientation)
                             if item.data.linecuts[orientation]['linecut_window'] is not None and item==self.file_list.currentItem():
@@ -1474,7 +1483,7 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
             else:
                 item.data.filters = filters
 
-        else: # A filter is being appended
+        else: # A filter is being appended to the table
             if isinstance(item.data,MixedInternalData) and self.mixeddata_filter_box.currentIndex() == 0:
                 item.data.dataset2d.filters.append(filt)
             elif hasattr(item.data, 'sidebar1D'):
@@ -1485,6 +1494,9 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
                     filt.method_list.remove('Z')
                     if hasattr(filt, 'method') and filt.method == 'Z':
                         filt.method=filt.method_list[0]
+                elif filt.name == 'Sort':
+                    filt.method_list = ['']
+                    filt.method= ''
                 if isinstance(item.data,MixedInternalData):
                     item.data.dataset1d.plotted_lines[current_line]['filters'].append(filt)
                 else:
@@ -2177,6 +2189,10 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
             method_box.setCurrentIndex(filt.method_list.index(filt.method))
             setting_1 = QtWidgets.QTableWidgetItem(filt.settings[0])
             setting_2 = QtWidgets.QTableWidgetItem(filt.settings[1])
+            if hasattr(filt, 'tooltips'):
+                setting_1.setToolTip(filt.tooltips[0])
+                if len(filt.tooltips) > 1:
+                    setting_2.setToolTip(filt.tooltips[1])
             method_box.currentIndexChanged.connect(lambda: self.filters_table_edited(setting_1))
             self.filters_table.setItem(row, 0, filter_item)
             self.filters_table.setCellWidget(row, 1, method_box)
@@ -2219,13 +2235,12 @@ class Editor(QtWidgets.QMainWindow, design.Ui_MainWindow):
             if ((row > 0 and to == -1) or
                 (row < self.filters_table.rowCount()-1 and to == 1)):
                 filters[row], filters[row+to] = filters[row+to], filters[row]
-                self.show_current_filters()
-                self.filters_table.setCurrentCell(row+to, 0)
                 if (self.filters_table.item(row,0).checkState() and 
                     self.filters_table.item(row+to,0).checkState()):
-                    current_item.data.apply_all_filters()
                     self.update_plots(update_color_limits=True)
-                    self.show_current_view_settings()
+                else:
+                    self.show_current_filters()
+                self.filters_table.setCurrentCell(row+to, 0)
 
     def save_image(self):
         current_item = self.file_list.currentItem()

{qcodespp-0.1.2 → qcodespp-0.1.4}/qcodespp/plotting/offline/filters.py

@@ -7,7 +7,9 @@ Created on Thu Nov 9 20:05:23 2017
 
 import numpy as np
 from scipy import ndimage, signal
-from scipy.interpolate import interp1d, interp2d
+from scipy.interpolate import LinearNDInterpolator, CloughTocher2DInterpolator, make_interp_spline
+
+from qcodespp.plotting.analysis_tools import sort_lists
 
 
 # Filter definitions
@@ -15,16 +17,16 @@ from scipy.interpolate import interp1d, interp2d
 def derivative(data, method, times_x, times_y):
     times_x, times_y = int(times_x), int(times_y)
     if len(data) == 3:
-        for _ in range(times_x):
-            data[-1] = np.gradient(data[-1], data[0][:,0], axis=0)
         for _ in range(times_y):
-            data[-1] = np.gradient(data[-1], data[1][0,:], axis=1)
+            data[-1]= np.array([np.gradient(data[-1][i,:], data[1][i,:]) for i in range(data[-1].shape[0])])
+        for _ in range(times_x):
+            data[-1]= np.array([np.gradient(data[-1][:,i], data[0][:,i]) for i in range(data[-1].shape[1])]).T
     elif len(data) == 2:
         for _ in range(times_y):
-            data[-1] = np.gradient(data[-1], data[0])        
+            data[-1] = np.gradient(data[-1], data[0])
     return data
 
-def integrate(data, method, times_x, times_y):
+def cumulative_sum(data, method, times_x, times_y):
     times_x, times_y = int(times_x), int(times_y)
     if len(data) == 3:
         if method=='Z':
@@ -46,7 +48,53 @@ def integrate(data, method, times_x, times_y):
             for _ in range(times_x):
                 data[0] = np.cumsum(data[0])
     
-    return data    
+    return data
+
+def integrate_rectangle(x, y):
+    """
+    Numerically integrate y with respect to x. Should be the same as cumulative sum for regularly spaced x.
+    """
+    integrated_y = np.zeros_like(y)
+    for i in range(1, len(y)):
+        integrated_y[i] = integrated_y[i-1] + y[i] * (x[i] - x[i-1])
+    return integrated_y
+
+def integrate_trapezoid(x,y):
+    """
+    Numerically integrate y with respect to x using the trapezoidal rule.
+    """
+    integrated_y = np.zeros_like(y)
+    for i in range(1,len(y)):
+        integrated_y[i] = integrated_y[i-1] + (y[i] + y[i-1]) * (x[i] - x[i-1]) / 2.0
+    return integrated_y
+
+def integrate_simpson(x, y):
+    """
+    Numerically integrate y with respect to x using Simpson's rule.
+    """
+    integrated_y = np.zeros_like(y)
+    for i in range(1,len(y) - 1):
+        integrated_y[i] = integrated_y[i-1] + (y[i-1] + 4 * y[i] + y[i+1]) * (x[i+1] - x[i-1])/6
+    # Use trapezoidal rule for the last segment
+    integrated_y[-1] = integrated_y[-2] + (y[-1] + y[-2]) * (x[-1] - x[-2]) / 2.0
+    
+    return integrated_y
+
+
+def integrate(data, method, times_x, times_y):
+    times_x, times_y = int(times_x), int(times_y)
+    functions={'Trapezoid': integrate_trapezoid, 'Simpson': integrate_simpson, 'Rectangle': integrate_rectangle}
+    if len(data) == 3:
+        for _ in range(times_x):
+            data[-1] = np.array([functions[method](data[-1][:,i], data[0][:,i]) for i in range(data[-1].shape[1])]).T
+        for _ in range(times_y):
+            data[-1] = np.array([functions[method](data[-1][i,:], data[1][i,:]) for i in range(data[-1].shape[0])])
+
+    elif len(data) == 2:
+        for _ in range(times_y):
+            data[-1] = functions[method](data[0], data[1])
+
+    return data
         
 def smooth(data, method, width_x, width_y):
     filters = {'Gauss': ndimage.gaussian_filter, 
@@ -163,7 +211,10 @@ def cut_y(data, method, bottom, width):
     return data 
 
 def swap_xy(data, method, setting1, setting2):
-    data[0], data[1] = data[1], data[0]
+    if len(data) == 3:
+        data[0], data[1], data[-1] = data[1].T, data[0].T, data[-1].T
+    elif len(data) == 2:
+        data[0], data[1] = data[1], data[0]
     return data
 
 def flip(data, method, setting1, setting2):
@@ -388,23 +439,51 @@ def root(data, method, setting1, setting2):
                 data[axis[method]][j] = np.abs(data[axis[method]][j])**(1/float(setting1))
     return data
 
+def interp2d(x, y, z, kind='linear'):
+    """
+    Re-do the job that scipy used to do
+    """
+    if kind == 'linear':
+        interpolator = LinearNDInterpolator(list(zip(x,y)), z)
+    elif kind == 'cubic':
+        interpolator = CloughTocher2DInterpolator(list(zip(x,y)), z)
+    return interpolator
+
 def interpolate(data, method, n_x, n_y):
+    n_x, n_y = int(n_x), int(n_y)
     if len(data) == 3:
-        x, y = data[0][:,0], data[1][0,:]
-        f_z = interp2d(y, x, data[2], kind=method)
-        n_x, n_y = int(n_x), int(n_y)
-        min_x, max_x = np.amin(data[0]), np.amax(data[0]) 
-        min_y, max_y = np.amin(data[1]), np.amax(data[1])
-        yp, xp = np.linspace(min_y, max_y, n_y), np.linspace(min_x, max_x, n_x)
-        data[1], data[0] = np.meshgrid(yp, xp)
-        data[2] = f_z(yp, xp)
+        x=data[0].flatten()
+        y=data[1].flatten()
+        z=data[2].flatten()
+        f_z = interp2d(x,y,z, kind=method)
+        X, Y = np.linspace(min(x), max(x), n_x), np.linspace(min(y), max(y), n_y)
+        X, Y = np.meshgrid(X, Y)
+        data[2] = np.ma.masked_invalid(f_z(X,Y).T)
+        data[0] = X.T
+        data[1] = Y.T
     elif len(data) == 2:
-        f = interp1d(data[0], data[1], kind=method)
-        n_x = int(n_x)
-        min_x, max_x = np.amin(data[0]), np.amax(data[0]) 
-        data[0] = np.linspace(min_x, max_x, n_x)
+        kind={'linear': 1, 'cubic': 3}
+        x,y=sort_lists(data[0], data[1])
+        f = make_interp_spline(x, y, kind[method])
+        data[0] = np.linspace(np.min(x), np.max(x), n_x)
         data[1] = f(data[0])
     return data
+
+def sort(data, method, setting1, setting2):
+    if len(data) == 3:
+        if method == 'X':
+            xsort,zsort=np.zeros_like(data[-1]),np.zeros_like(data[-1])
+            for i in range(data[-1].shape[1]):
+                xsort[:,i],zsort[:,i]=sort_lists(data[0][:,i],data[-1][:,i])
+            data=[xsort, data[1], zsort]
+        elif method == 'Y':
+            ysort,zsort=np.zeros_like(data[-1]),np.zeros_like(data[-1])
+            for i in range(data[-1].shape[0]):
+                ysort[i,:],zsort[i,:]=sort_lists(data[1][i],data[-1][i])
+            data=[data[0], ysort, zsort]
+    elif len(data) == 2:
+        data[0], data[1] = sort_lists(data[0], data[1])
+    return data
     
 def add_slope(data, method, a_x, a_y):
     if len(data) == 3:
@@ -431,36 +510,49 @@ def invert(data, method, setting1, setting2):
         
         
 class Filter:   
-    DEFAULT_SETTINGS = {'Derivative': {'Method': ['Mid'],
+    DEFAULT_SETTINGS = {'Derivative': {'Method': [''],
                                        'Settings': ['0', '1'],
+                                       'tooltips': ['Order in X', 'Order in Y'],
                                        'Function': derivative,
                                        'Checkstate': 2},
-                        'Integrate': {'Method': ['Z','Y','X'],
+                        'Integrate': {'Method': ['Trapezoid','Simpson','Rectangle'],
                                        'Settings': ['0', '1'],
+                                       'tooltips': ['Order in X', 'Order in Y'],
                                        'Function': integrate,
                                        'Checkstate': 2},
+                        'Cumulative sum': {'Method': ['Z','Y','X'],
+                                       'Settings': ['0', '1'],
+                                       'tooltips': ['Order in zero-th index', 'Order in first index'],
+                                        'Function': cumulative_sum,
+                                        'Checkstate': 2},
                         'Smoothen': {'Method': ['Gauss', 'Median'],
                                      'Settings': ['0', '2'],
+                                     'tooltips': ['Smoothing window in X', 'Smoothing window in Y'],
                                      'Function': smooth,
                                      'Checkstate': 2},
                         'Savitzy-Golay smoothing': {'Method': ['Y','X','dY','dX','ddY','ddX'],
                                     'Settings': ['7', '2'],
+                                    'tooltips': ['Smoothing window', 'Polynomial order'],
                                     'Function': sav_gol,
-                                    'Checkstate': 2},                               
+                                    'Checkstate': 2},
                         'Add/Subtract': {'Method': ['X','Y','Z'],
                                    'Settings': ['0', ''],
+                                   'tooltips': ['Value'],
                                    'Function': offset,
                                    'Checkstate': 2},
                         'Multiply': {'Method': ['X','Y','Z'],
                                      'Settings': ['1', ''],
+                                     'tooltips': ['Value'],
                                      'Function': multiply,
                                      'Checkstate': 2}, 
                         'Divide': {'Method': ['X','Y','Z'],
                                    'Settings': ['1', ''],
+                                   'tooltips': ['Value'],
                                    'Function': divide,
                                    'Checkstate': 0},
                         'Add Slope': {'Method': [''],
                                   'Settings': ['0', '-1'],
+                                  'tooltips': ['Slope value in X', 'Slope value in Y'],
                                   'Function': add_slope,
                                   'Checkstate': 2},
                         'Invert': {'Method': ['X','Y','Z'],
@@ -469,6 +561,7 @@ class Filter:
                                    'Checkstate': 0},
                         'Normalize': {'Method': ['Max', 'Min', 'Min to Max','Point'],
                                       'Settings': ['', ''],
+                                      'tooltips': ['X coordinate', 'Y coordinate'],
                                       'Function': normalize,
                                       'Checkstate': 2},
                         'Subtract average': {'Method': ['Z', 'Y', 'X'],
@@ -476,7 +569,8 @@ class Filter:
                                         'Function': subtract_average,
                                         'Checkstate': 2},
                         'Offset line by line': {'Method': ['Z', 'Y'],
-                                      'Settings': ['', ''],
+                                      'Settings': ['0', ''],
+                                      'tooltips': ['Index'],
                                       'Function': offset_line_by_line,
                                       'Checkstate': 2},
                         'Subtract average line by line': {'Method': ['Z', 'Y'],
@@ -485,18 +579,22 @@ class Filter:
                                         'Checkstate': 2},
                         'Subtract trace': {'Method': ['Ver', 'Hor'],
                                      'Settings': ['0', ''],
+                                     'tooltips': ['Index'],
                                      'Function': subtract_trace,
                                      'Checkstate': 0},
                         'Logarithm': {'Method': ['Mask','Shift','Abs'],
                                       'Settings': ['10', ''],
+                                      'tooltips': ['Base; 10, 2 or e'],
                                       'Function': logarithm,
                                       'Checkstate': 2}, 
                         'Power': {'Method': ['X','Y','Z'],
                                  'Settings': ['2', ''],
+                                 'tooltips': ['Exponent'],
                                  'Function': power,
                                  'Checkstate': 2}, 
                         'Root': {'Method': ['X','Y','Z'],
                                  'Settings': ['2', ''],
+                                 'tooltips': ['Exponent'],
                                  'Function': root,
                                  'Checkstate': 2}, 
                         'Absolute': {'Method': [''],
@@ -507,32 +605,43 @@ class Filter:
                                  'Settings': ['', ''],
                                  'Function': flip,
                                  'Checkstate': 2}, 
-                        'Interp': {'Method': ['linear','cubic','quintic'],
+                        'Interpolate': {'Method': ['linear','cubic'],
                                    'Settings': ['800', '600'],
+                                   'tooltips': ['Number of points in X', 'Number of points in Y'],
                                    'Function': interpolate,
                                    'Checkstate': 0},
+                        'Sort': {'Method': ['X','Y'],
+                                   'Settings': ['', ''],
+                                   'Function': sort,
+                                   'Checkstate': 2},
                         'Roll X': {'Method': ['Index'],
                                    'Settings': ['0', '0'],
+                                    'tooltips': ['Position', 'Amount'],
                                    'Function': roll_x,
                                    'Checkstate': 0},                             
                         'Roll Y': {'Method': ['Index'],
                                    'Settings': ['0', '0'],
+                                    'tooltips': ['Position', 'Amount'],
                                    'Function': roll_y,
                                    'Checkstate': 0},
                         'Crop X': {'Method': ['Abs', 'Rel', 'Lim'],
                                    'Settings': ['-1', '1'],
+                                   'tooltips': ['Min', 'Max'],
                                    'Function': crop_x,
                                    'Checkstate': 0},                              
                         'Crop Y': {'Method': ['Abs', 'Rel', 'Lim'],
-                                   'Settings': ['-2', '2'],
+                                   'Settings': ['-1', '1'],
+                                   'tooltips': ['Min', 'Max'],
                                    'Function': crop_y,
                                    'Checkstate': 0},
                         'Cut X': {'Method': ['Index'],
                                   'Settings': ['0', '0'],
+                                    'tooltips': ['Left index', 'Width'],
                                   'Function': cut_x,
                                   'Checkstate': 0},                               
                         'Cut Y': {'Method': ['Index'],
                                   'Settings': ['0', '0'],
+                                    'tooltips': ['Bottom index', 'Width'],
                                   'Function': cut_y,
                                   'Checkstate': 0},                                
                         'Swap X/Y': {'Method': [''],
@@ -541,7 +650,7 @@ class Filter:
                                     'Checkstate': 2}, 
                                    } 
     
-    def __init__(self, name, method=None, settings=None, checkstate=None):
+    def __init__(self, name, method=None, settings=None, checkstate=None, dimension=2):
         self.name = name
         default_settings = self.DEFAULT_SETTINGS.copy()
         self.method_list = default_settings[name]['Method']
@@ -558,4 +667,6 @@ class Filter:
         else:
             self.checkstate = default_settings[name]['Checkstate']
         self.function = default_settings[name]['Function']
+        if 'tooltips' in default_settings[name]:
+            self.tooltips = default_settings[name]['tooltips']
         

qcodespp-0.1.4/qcodespp/version.py

@@ -0,0 +1 @@
+__version__ = '0.1.4'

qcodespp-0.1.2/qcodespp/version.py

@@ -1 +0,0 @@
-__version__ = '0.1.2'