From 301e6fb5580ba7a66833cb68ca50f6bab0aa68f5 Mon Sep 17 00:00:00 2001
From: johnhornibrook <johnhornibrook@hotmail.com>
Date: Sat, 21 Oct 2017 22:49:33 +1100
Subject: [PATCH 01/25] Keysight N5245A driver

---
 qcodes/instrument_drivers/Keysight/N5245A.py | 289 +++++++++++++++++++
 1 file changed, 289 insertions(+)
 create mode 100644 qcodes/instrument_drivers/Keysight/N5245A.py

diff --git a/qcodes/instrument_drivers/Keysight/N5245A.py b/qcodes/instrument_drivers/Keysight/N5245A.py
new file mode 100644
index 00000000000..c0069c4cdd4
--- /dev/null
+++ b/qcodes/instrument_drivers/Keysight/N5245A.py
@@ -0,0 +1,289 @@
+from cmath import phase
+import math
+import numpy as np
+from qcodes import VisaInstrument, MultiParameter
+from qcodes.utils.validators import Numbers
+import time
+
+
+def _Sparam(string):
+    """
+    Converting S-parameter of active trace to a number for qcodes loop
+    """
+    x = string.strip('"')
+    idx = x.find('_S')
+    return int(x[idx+2:idx+4])
+
+class RawSweep(MultiParameter):
+    """
+    RawSweep pulls the magnitude and phase directly from the instrument without waiting.
+    """
+    def __init__(self, name, instrument, start, stop, npts):
+        super().__init__(name, names=("",""), shapes=((), ()))
+        self._instrument = instrument
+        self.set_sweep(start, stop, npts)
+        self.names = ('magnitude', 'phase')
+        self.units = ('dB', 'rad')
+        self.setpoint_names = (('frequency',), ('frequency',))
+        
+    def set_sweep(self, start, stop, npts):
+        f = tuple(np.linspace(int(start), int(stop), num=npts))
+        self.setpoints = ((f,), (f,))
+        self.shapes = ((npts,), (npts,))
+        
+    def get(self):
+        self.set_sweep(self._instrument.start(), self._instrument.stop(), self._instrument.points())
+        
+        data_str = self._instrument.ask('CALC:DATA? SDATA').split(',')
+        data_list = [float(v) for v in data_str]
+
+        # Unpack and convert to log magnitude and phase
+        data_arr = np.array(data_list).reshape(int(len(data_list) / 2), 2)
+        mag_array, phase_array = [], []
+        for comp in data_arr:
+            complex_num = complex(comp[0], comp[1])
+            mag_array.append(20 * math.log10(abs(complex_num)))
+            phase_array.append(phase(complex_num))
+        return mag_array, phase_array
+        
+        
+class MagPhaseSweep(MultiParameter):
+    """
+    MagPhase will run a sweep, including averaging, before returning data.
+    As such, wait time in a loop is not needed.
+    """
+    def __init__(self, name, instrument, start, stop, npts):
+        super().__init__(name, names=("",""), shapes=((), ()))
+        self._instrument = instrument
+        self.set_sweep(start, stop, npts)
+        self.names = ('magnitude', 'phase')
+        self.units = ('dB', 'degrees')
+        self.setpoint_names = (('frequency',), ('frequency',))
+        
+    def set_sweep(self, start, stop, npts):
+        f = tuple(np.linspace(int(start), int(stop), num=npts))
+        self.setpoints = ((f,), (f,))
+        self.shapes = ((npts,), (npts,))
+        
+    def get(self):
+        self.set_sweep(self._instrument.start(), self._instrument.stop(), self._instrument.points())
+        
+        # Take instrument out of continuous mode, and send triggers equal to the number of averages
+        self._instrument.write('SENS:AVER:CLE')
+        self._instrument.write('TRIG:SOUR IMM')
+        avg = self._instrument.averages()
+        self._instrument.write('SENS:SWE:GRO:COUN {0}'.format(avg))
+        self._instrument.write('SENS:SWE:MODE GRO')
+
+        # Once the sweep mode is in hold, we know we're done
+        while True:
+            if self._instrument.ask('SENS:SWE:MODE?') == 'HOLD':
+                break
+            time.sleep(0.2)
+        
+        # Ask for magnitude
+        previous_format = self._instrument.ask('CALC:FORM?')
+        self._instrument.write('CALC:FORM MLOG')
+        mag_str = self._instrument.ask('CALC:DATA? FDATA').split(',')
+        mag_list = [float(v) for v in mag_str]
+        
+        # Then phase
+        self._instrument.write('CALC:FORM UPH')
+        phase_str = self._instrument.ask('CALC:DATA? FDATA').split(',')
+        phase_list = [float(v) for v in phase_str]
+
+        # Return the instrument state
+        self._instrument.write('CALC:FORM {}'.format(previous_format))
+        self._instrument.write('SENS:SWE:MODE CONT')
+                      
+        return mag_list, phase_list
+        
+
+class N5245A(VisaInstrument):
+    """
+    qcodes driver for Agilent N5245A Network Analyzer. Command list at
+    http://na.support.keysight.com/pna/help/latest/Programming/GP-IB_Command_Finder/SCPI_Command_Tree.htm
+    """
+
+    def __init__(self, name, address, **kwargs):
+        super().__init__(name, address, terminator='\n', **kwargs)
+        
+        # A default measurement and output format on initialisation
+        self.write('FORM ASCii,0')
+        self.write('FORM:BORD SWAP')
+        self.write('CALC:PAR:DEF:EXT "S21", S21')
+        self.write('CALC:FORM MLOG')
+
+        # Query the instrument for what options are installed
+        options = self.ask('*OPT?').strip('"').split(',')
+        
+        '''
+        Parameters
+        '''
+        # The active trace (i.e. what is pulled from the PNA), and its assigned S parameter.
+        # To extract multiple S-parameters, set the trace first, then use one of the sweeps.
+        self.add_parameter('trace_number',
+                           label='Trace No',
+                           get_cmd='CALC:PAR:MNUM?',
+                           set_cmd='CALC:PAR:MNUM {}',
+                           get_parser=int
+                           )
+        self.add_parameter('trace',
+                           label='Trace',
+                           get_cmd='CALC:PAR:SEL?',
+                           get_parser=_Sparam
+                           )
+        
+        # Drive power
+        min_power = -90 if '419' in options or '219' in options else -30
+        self.add_parameter('power',
+                           label='Power',
+                           get_cmd='SOUR:POW?',
+                           get_parser=float,
+                           set_cmd='SOUR:POW {:.2f}',
+                           unit='dBm',
+                           vals=Numbers(min_value=min_power,max_value=10))
+        self.add_parameter('sweep_time',
+                           label='Time',
+                           get_cmd='SENS:SWE:TIME?',
+                           get_parser=float,
+                           unit='s',
+                           vals=Numbers(0,1e6))
+        
+        # IF bandwidth
+        self.add_parameter('if_bandwidth',
+                           label='IF Bandwidth',
+                           get_cmd='SENS:BAND?',
+                           get_parser=float,
+                           set_cmd='SENS:BAND {:.2f}',
+                           unit='Hz',
+                           vals=Numbers(min_value=1,max_value=15e6))
+        
+        # Number of averages (also resets averages)
+        self.add_parameter('averages',
+                           label='Averages',
+                           get_cmd='SENS:AVER:COUN?',
+                           get_parser=int,
+                           set_cmd='SENS:AVER:COUN {:d}',
+                           unit='',
+                           vals=Numbers(min_value=1,max_value=65536))
+        
+        # Setting frequency range
+        self.add_parameter('start',
+                           label='Start Frequency',
+                           get_cmd='SENS:FREQ:STAR?',
+                           get_parser=float,
+                           set_cmd=self._set_start,
+                           unit='',
+                           vals=Numbers(min_value=10e6,max_value=50.2e9))
+        self.add_parameter('stop',
+                           label='Stop Frequency',
+                           get_cmd='SENS:FREQ:STOP?',
+                           get_parser=float,
+                           set_cmd=self._set_stop,
+                           unit='',
+                           vals=Numbers(min_value=10e6,max_value=50.2e9))
+        
+        # Number of points in a sweep
+        self.add_parameter('points',
+                           label='Points',
+                           get_cmd='SENS:SWE:POIN?',
+                           get_parser=int,
+                           set_cmd=self._set_points,
+                           unit='',
+                           vals=Numbers(min_value=1, max_value=100001))
+        
+        # Electrical delay
+        self.add_parameter('electrical_delay',
+                           label='Electrical Delay',
+                           get_cmd='CALC:CORR:EDEL:TIME?',
+                           get_parser=float,
+                           set_cmd='CALC:CORR:EDEL:TIME {:.6e}',
+                           unit='s',
+                           vals=Numbers(min_value=0, max_value=100000))
+        
+        '''
+        PNA-x units with two sources have an enormous list of functions & configurations.
+        In practice, most of this will be set up manually on the unit, with power and frequency
+        varied.
+        '''
+        if '400' in options or '224' in options:
+            ports = ['1','2','3','4'] if '400' in options else ['1','2']
+            for p in ports:
+                power_cmd = 'SOUR:POW{}'.format(p)
+                self.add_parameter('aux_power{}'.format(p),
+                                   label='Aux Power',
+                                   get_cmd=power_cmd + '?',
+                                   get_parser=float,
+                                   set_cmd=power_cmd+ ' {:.2f}',
+                                   unit='dBm',
+                                   vals=Numbers(min_value=min_power, max_value=10))
+            self.add_parameter('aux_frequency',
+                               label='Aux Frequency',
+                               get_cmd='SENS:FOM:RANG4:FREQ:CW?',
+                               get_parser=float,
+                               set_cmd='SENS:FOM:RANG4:FREQ:CW {:.2f}',
+                               unit='Hz',
+                               vals=Numbers(min_value=10e6,max_value=50e9))
+        
+        '''
+        Sweeps
+        '''
+        # An immediate collection of data from the instrument
+        self.add_parameter('raw_trace',
+                           start=self.start(),
+                           stop=self.stop(),
+                           npts=self.points(),
+                           parameter_class=RawSweep)
+        
+        # Wait until the sweep (and averages) are completed first
+        self.add_parameter('vector_trace',
+                           start = self.start(),
+                           stop = self.stop(),
+                           npts = self.points(),
+                           parameter_class=MagPhaseSweep)
+                    
+        '''
+        Functions
+        '''
+        # Clear averages
+        self.add_function('reset_averages',
+                          call_cmd='SENS:AVER:CLE')
+        
+        # Averages ON
+        self.add_function('averages_on',
+                          call_cmd='SENS:AVER ON')
+        
+        # Averages OFF
+        self.add_function('averages_off',
+                          call_cmd='SENS:AVER OFF')
+                
+        self.connect_message()
+
+
+    def get_idn(self):
+        IDN = self.ask_raw('*IDN?')
+        vendor, model, serial, firmware = map(str.strip, IDN.split(','))
+        IDN = {'vendor': vendor, 'model': model,
+               'serial': serial, 'firmware': firmware}
+        return IDN
+        
+    # Adjusting the sweep requires an adjustment to the sweep parameters
+    def _set_start(self, val):
+        self.write('SENS:FREQ:STAR {:.2f}'.format(val))
+        self.raw_trace.set_sweep(val, self.stop(), self.points())
+        self.vector_trace.set_sweep(val, self.stop(), self.points())
+            
+    def _set_stop(self, val):
+        self.write('SENS:FREQ:STOP {:.2f}'.format(val))
+        self.raw_trace.set_sweep(self.start(), val, self.points())
+        self.vector_trace.set_sweep(self.start(), val, self.points())
+            
+    def _set_points(self, val):
+        self.write('SENS:SWE:POIN {:d}'.format(val))
+        self.raw_trace.set_sweep(self.start(), self.stop(), val)
+        self.vector_trace.set_sweep(self.start(), self.stop(), val)
+
+
+        
+                

From d2ff2c9b26c2b470b0492fbf68cd3c0ee1daec4c Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Thu, 7 Jun 2018 10:11:04 +1000
Subject: [PATCH 02/25] Add new array parameters to PNA driver

---
 qcodes/instrument_drivers/Keysight/N5245A.py | 75 +++++++++++++++++---
 1 file changed, 66 insertions(+), 9 deletions(-)

diff --git a/qcodes/instrument_drivers/Keysight/N5245A.py b/qcodes/instrument_drivers/Keysight/N5245A.py
index c0069c4cdd4..c8651c4af66 100644
--- a/qcodes/instrument_drivers/Keysight/N5245A.py
+++ b/qcodes/instrument_drivers/Keysight/N5245A.py
@@ -97,7 +97,56 @@ def get(self):
         self._instrument.write('SENS:SWE:MODE CONT')
                       
         return mag_list, phase_list
+
+class FormattedSweep(ArrayParameter):
+    """
+    Mag will run a sweep, including averaging, before returning data.
+    As such, wait time in a loop is not needed.
+    """
+    def __init__(self, name, instrument, format, label, unit, start, stop, npts):
+        super().__init__(name,
+                         label=label,
+                         unit=unit,
+                         shape=(npts,),
+                         setpoints=(np.linspace(start, stop, num=npts),),
+                         setpoint_names=('frequency',),
+                         setpoint_labels=('Frequency',),
+                         setpoint_units=('Hz',)
+                         )
+        self._instrument = instrument
+        self.format = format
+        
+    def set_sweep(self, start, stop, npts):
+        f = np.linspace(int(start), int(stop), num=npts)
+        self.setpoints = (f,)
+        self.shape = (npts,)
+        
+    def get_raw(self):
+        npts = self._instrument.points()
+        self.set_sweep(self._instrument.start(), self._instrument.stop(), npts)
+        
+        # Take instrument out of continuous mode, and send triggers equal to the number of averages
+        self._instrument.write('SENS:AVER:CLE')
+        self._instrument.write('TRIG:SOUR IMM')
+        avg = self._instrument.averages()
+        self._instrument.write('SENS:SWE:GRO:COUN {0}'.format(avg))
+        self._instrument.write('SENS:SWE:MODE GRO')
+
+        # Once the sweep mode is in hold, we know we're done
+        while True:
+            if self._instrument.ask('SENS:SWE:MODE?') == 'HOLD':
+                break
+            time.sleep(0.1)
         
+        # Ask for magnitude
+        self._instrument.write('CALC:FORM %s' % self.format)
+        data_str = self._instrument.ask('CALC:DATA? FDATA').split(',')
+        data_list = np.fromiter((float(v) for v in data_str), float, count=npts)
+
+        # Return the instrument state
+        self._instrument.write('SENS:SWE:MODE CONT')
+                      
+        return data_list
 
 class N5245A(VisaInstrument):
     """
@@ -160,6 +209,11 @@ def __init__(self, name, address, **kwargs):
                            vals=Numbers(min_value=1,max_value=15e6))
         
         # Number of averages (also resets averages)
+        self.add_parameter('averages_enabled',
+                            label='Averages Enabled',
+                            get_cmd="SENS:AVER?",
+                            set_cmd="SENS:AVER {}",
+                            val_mapping={True: 'ON', False: 'OFF'})
         self.add_parameter('averages',
                            label='Averages',
                            get_cmd='SENS:AVER:COUN?',
@@ -271,19 +325,22 @@ def get_idn(self):
     # Adjusting the sweep requires an adjustment to the sweep parameters
     def _set_start(self, val):
         self.write('SENS:FREQ:STAR {:.2f}'.format(val))
-        self.raw_trace.set_sweep(val, self.stop(), self.points())
-        self.vector_trace.set_sweep(val, self.stop(), self.points())
+        self._set_sweep(start=val)
             
     def _set_stop(self, val):
         self.write('SENS:FREQ:STOP {:.2f}'.format(val))
-        self.raw_trace.set_sweep(self.start(), val, self.points())
-        self.vector_trace.set_sweep(self.start(), val, self.points())
+        self._set_sweep(stop=val)
             
     def _set_points(self, val):
         self.write('SENS:SWE:POIN {:d}'.format(val))
-        self.raw_trace.set_sweep(self.start(), self.stop(), val)
-        self.vector_trace.set_sweep(self.start(), self.stop(), val)
+        self._set_sweep(npts=val)
 
-
-        
-                
+    def _set_sweep(self, start=None, stop=None, npts=None):
+        if start is None:
+            start = self.start()
+        if stop is None:
+            stop = self.stop()
+        if npts is None:
+            npts = self.points()
+        for trace in self.traces:
+            trace.set_sweep(start, stop, npts)

From 4af2c8926990e8f38de164efd4accffb11d2f19f Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Fri, 8 Jun 2018 12:26:12 +1000
Subject: [PATCH 03/25] Make PNA driver generic

---
 qcodes/instrument_drivers/Keysight/{N5245A.py => N52xx.py} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename qcodes/instrument_drivers/Keysight/{N5245A.py => N52xx.py} (100%)

diff --git a/qcodes/instrument_drivers/Keysight/N5245A.py b/qcodes/instrument_drivers/Keysight/N52xx.py
similarity index 100%
rename from qcodes/instrument_drivers/Keysight/N5245A.py
rename to qcodes/instrument_drivers/Keysight/N52xx.py

From a8136cb8b603f868e4d5485c9b4926f9bfb758dc Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Fri, 8 Jun 2018 12:26:49 +1000
Subject: [PATCH 04/25] Make driver generic, extend with traces and ports

---
 qcodes/instrument_drivers/Keysight/N52xx.py | 275 ++++++++++++++------
 1 file changed, 194 insertions(+), 81 deletions(-)

diff --git a/qcodes/instrument_drivers/Keysight/N52xx.py b/qcodes/instrument_drivers/Keysight/N52xx.py
index c8651c4af66..fc95757a12b 100644
--- a/qcodes/instrument_drivers/Keysight/N52xx.py
+++ b/qcodes/instrument_drivers/Keysight/N52xx.py
@@ -1,18 +1,10 @@
 from cmath import phase
 import math
 import numpy as np
-from qcodes import VisaInstrument, MultiParameter
+from qcodes import VisaInstrument, MultiParameter, InstrumentChannel
 from qcodes.utils.validators import Numbers
 import time
-
-
-def _Sparam(string):
-    """
-    Converting S-parameter of active trace to a number for qcodes loop
-    """
-    x = string.strip('"')
-    idx = x.find('_S')
-    return int(x[idx+2:idx+4])
+import re
 
 class RawSweep(MultiParameter):
     """
@@ -116,14 +108,7 @@ def __init__(self, name, instrument, format, label, unit, start, stop, npts):
         self._instrument = instrument
         self.format = format
         
-    def set_sweep(self, start, stop, npts):
-        f = np.linspace(int(start), int(stop), num=npts)
-        self.setpoints = (f,)
-        self.shape = (npts,)
-        
     def get_raw(self):
-        npts = self._instrument.points()
-        self.set_sweep(self._instrument.start(), self._instrument.stop(), npts)
         
         # Take instrument out of continuous mode, and send triggers equal to the number of averages
         self._instrument.write('SENS:AVER:CLE')
@@ -141,34 +126,155 @@ def get_raw(self):
         # Ask for magnitude
         self._instrument.write('CALC:FORM %s' % self.format)
         data_str = self._instrument.ask('CALC:DATA? FDATA').split(',')
-        data_list = np.fromiter((float(v) for v in data_str), float, count=npts)
+        data_list = np.fromiter((float(v) for v in data_str), float)
 
         # Return the instrument state
         self._instrument.write('SENS:SWE:MODE CONT')
                       
         return data_list
 
-class N5245A(VisaInstrument):
+    @property
+    def shape(self):
+        return (self._instrument.root_instrument.points(),)
+    @property
+    def setpoints(self):
+        start = self._instrument.root_instrument.start()
+        stop = self._instrument.root_instrument.stop()
+        return (np.linspace(start, stop, self.shape),)
+    
+
+class PNAPort(InstrumentChannel):
+    """
+    Allow operations on individual PNA ports.
+    Note: This can be expanded to include a large number of extra parameters...
+    """
+
+    def __init__(self, parent, name, port,
+                 min_power, max_power):
+        super().__init__(parent, name)
+
+        self.port = int(port)
+        if self.port < 1 or self.port > 4:
+            raise ValueError("Port must be between 1 and 4.")
+
+        pow_cmd = f"SOUR:POW{self.port}"
+        self.add_parameter("source_power",
+                           label="power",
+                           unit="dBm",
+                           get_cmd=pow_cmd + "?",
+                           set_cmd=pow_cmd + "{}",
+                           get_parser=float)
+
+class PNATrace(InstrumentChannel):
+    """
+    Allow operations on individual PNA traces.
+    """
+
+    def __init__(self, parent, name, trace):
+        super().__init__(parent, name)
+        self.trace = trace
+
+        # Name of parameter
+        self.add_parameter('trace',
+                           label='Trace',
+                           get_cmd='CALC:PAR:SEL?'.format(self.trace),
+                           get_parser=_Sparam
+                           )
+
+        # And a list of individual formats
+        self.add_parameter('magnitude',
+                           format='MLOG',
+                           label='Magnitude',
+                           unit='dB',
+                           start=start,
+                           stop=stop,
+                           npts=npts,
+                           parameter_class=FormattedSweep)
+        self.add_parameter('phase',
+                           format='PHAS',
+                           label='Phase',
+                           unit='deg',
+                           start=start,
+                           stop=stop,
+                           npts=npts,
+                           parameter_class=FormattedSweep)
+        self.add_parameter('real',
+                           format='REAL',
+                           label='Real',
+                           unit='LinMag',
+                           start=start,
+                           stop=stop,
+                           npts=npts,
+                           parameter_class=FormattedSweep)
+        self.add_parameter('imaginary',
+                           format='IMAG',
+                           label='Imaginary',
+                           unit='LinMag',
+                           start=start,
+                           stop=stop,
+                           npts=npts,
+                           parameter_class=FormattedSweep)
+
+    def write(self, cmd):
+        """
+        Select correct trace before querying
+        """
+        super().write("CALC:PAR:MNUM {}".format(self.trace))
+        super().write(cmd)
+    def ask(self, cmd):
+        """
+        Select correct trace before querying
+        """
+        super().write("CALC:PAR:MNUM {}".format(self.trace))
+        return super().ask(cmd)
+
+    @staticmethod
+    def parse_paramstring(paramspec):
+        """
+        Parse parameter specification from PNA
+        """
+        paramspec = paramspec.strip('"')
+        ch, param, trnum = re.findall(r"CH(\d+)_(S\d+)_(\d+)", paramspec)[0]
+        return ch, param, trnum
+
+    def _Sparam(self, paramspec):
+        """
+        Extrace S_parameter from returned PNA format
+        """
+        return self.parse_paramstring(paramspec)[1]
+
+class PNABase(VisaInstrument):
     """
-    qcodes driver for Agilent N5245A Network Analyzer. Command list at
+    Base qcodes driver for Agilent/Keysight series PNAs
     http://na.support.keysight.com/pna/help/latest/Programming/GP-IB_Command_Finder/SCPI_Command_Tree.htm
+
+    Note: Currently this driver only expects a single channel on the PNA. We can handle multiple
+          traces, but using traces across multiple channels may have unexpected results.
     """
 
-    def __init__(self, name, address, **kwargs):
+    def __init__(self, name, address, 
+                 min_freq, max_freq, # Set frequency ranges
+                 min_power, max_power, # Set power ranges
+                 nports, # Number of ports on the PNA
+                 **kwargs):
         super().__init__(name, address, terminator='\n', **kwargs)
-        
-        # A default measurement and output format on initialisation
-        self.write('FORM ASCii,0')
-        self.write('FORM:BORD SWAP')
-        self.write('CALC:PAR:DEF:EXT "S21", S21')
-        self.write('CALC:FORM MLOG')
 
-        # Query the instrument for what options are installed
-        options = self.ask('*OPT?').strip('"').split(',')
+        #Ports
+        ports = ChannelList(self, "PNAPorts", PNAPort)
+        for port in range(1,nports+1):
+            port = PNAPort(self, f"Port{port}", port)
+            ports.append(port)
+            self.add_submodule(port)
+        ports.lock()
+        self.add_submodule("ports", ports)
+
+        # Traces
+        # Note: These will be accessed through the traces property which updates
+        # the channellist to include only active trace numbers
+        self._traces = ChannelList(self, "PNATraces", PNATrace)
+        self.add_submodule("traces", self._traces)
         
-        '''
-        Parameters
-        '''
+        # Parameters
         # The active trace (i.e. what is pulled from the PNA), and its assigned S parameter.
         # To extract multiple S-parameters, set the trace first, then use one of the sweeps.
         self.add_parameter('trace_number',
@@ -177,21 +283,15 @@ def __init__(self, name, address, **kwargs):
                            set_cmd='CALC:PAR:MNUM {}',
                            get_parser=int
                            )
-        self.add_parameter('trace',
-                           label='Trace',
-                           get_cmd='CALC:PAR:SEL?',
-                           get_parser=_Sparam
-                           )
-        
+
         # Drive power
-        min_power = -90 if '419' in options or '219' in options else -30
         self.add_parameter('power',
                            label='Power',
                            get_cmd='SOUR:POW?',
                            get_parser=float,
                            set_cmd='SOUR:POW {:.2f}',
                            unit='dBm',
-                           vals=Numbers(min_value=min_power,max_value=10))
+                           vals=Numbers(min_value=min_power,max_value=max_power))
         self.add_parameter('sweep_time',
                            label='Time',
                            get_cmd='SENS:SWE:TIME?',
@@ -256,40 +356,9 @@ def __init__(self, name, address, **kwargs):
                            unit='s',
                            vals=Numbers(min_value=0, max_value=100000))
         
-        '''
-        PNA-x units with two sources have an enormous list of functions & configurations.
-        In practice, most of this will be set up manually on the unit, with power and frequency
-        varied.
-        '''
-        if '400' in options or '224' in options:
-            ports = ['1','2','3','4'] if '400' in options else ['1','2']
-            for p in ports:
-                power_cmd = 'SOUR:POW{}'.format(p)
-                self.add_parameter('aux_power{}'.format(p),
-                                   label='Aux Power',
-                                   get_cmd=power_cmd + '?',
-                                   get_parser=float,
-                                   set_cmd=power_cmd+ ' {:.2f}',
-                                   unit='dBm',
-                                   vals=Numbers(min_value=min_power, max_value=10))
-            self.add_parameter('aux_frequency',
-                               label='Aux Frequency',
-                               get_cmd='SENS:FOM:RANG4:FREQ:CW?',
-                               get_parser=float,
-                               set_cmd='SENS:FOM:RANG4:FREQ:CW {:.2f}',
-                               unit='Hz',
-                               vals=Numbers(min_value=10e6,max_value=50e9))
-        
         '''
         Sweeps
         '''
-        # An immediate collection of data from the instrument
-        self.add_parameter('raw_trace',
-                           start=self.start(),
-                           stop=self.stop(),
-                           npts=self.points(),
-                           parameter_class=RawSweep)
-        
         # Wait until the sweep (and averages) are completed first
         self.add_parameter('vector_trace',
                            start = self.start(),
@@ -303,25 +372,43 @@ def __init__(self, name, address, **kwargs):
         # Clear averages
         self.add_function('reset_averages',
                           call_cmd='SENS:AVER:CLE')
-        
         # Averages ON
         self.add_function('averages_on',
                           call_cmd='SENS:AVER ON')
-        
         # Averages OFF
         self.add_function('averages_off',
                           call_cmd='SENS:AVER OFF')
-                
+
+        # A default output format on initialisation
+        self.write('FORM ASCii,0')
+        self.write('FORM:BORD SWAP')
+
         self.connect_message()
 
+    @property
+    def traces(self):
+        """
+        Update channel list with active traces and return the new list
+        """
+        parlist = self.ask("CALC:PAR:CAT:EXT?").strip('"').split(",")
+        self._traces.clear()
+        for trace in parlist[::2]:
+            trnum = PNATrace.parse_paramstring(trace)[2]
+            trace = PNATrace(self, "tr{}".format(trnum), int(trnum))
+            self._traces.add(trace)
+        return self._traces
+    
+
+    def get_options(self):
+        # Query the instrument for what options are installed
+        return self.ask('*OPT?').strip('"').split(',')
+
+    def _set_power_limits(self, min_power, max_power):
+        """
+        Set port power limits
+        """
+        self.power.vals = Numbers(min_value=min_power,max_value=max_power)
 
-    def get_idn(self):
-        IDN = self.ask_raw('*IDN?')
-        vendor, model, serial, firmware = map(str.strip, IDN.split(','))
-        IDN = {'vendor': vendor, 'model': model,
-               'serial': serial, 'firmware': firmware}
-        return IDN
-        
     # Adjusting the sweep requires an adjustment to the sweep parameters
     def _set_start(self, val):
         self.write('SENS:FREQ:STAR {:.2f}'.format(val))
@@ -344,3 +431,29 @@ def _set_sweep(self, start=None, stop=None, npts=None):
             npts = self.points()
         for trace in self.traces:
             trace.set_sweep(start, stop, npts)
+
+class PNAxBase(PNABase):
+    def __init__(self, name, address, 
+                 min_freq, max_freq, # Set frequency ranges
+                 min_power, max_power, # Set power ranges
+                 nports, # Number of ports on the PNA
+                 **kwargs):
+
+        super.__init__(self, name, address, 
+                       min_freq, max_freq,
+                       min_power, max_power,
+                       **kwargs)
+
+    def _enable_fom(self):
+        '''
+        PNA-x units with two sources have an enormous list of functions & configurations.
+        In practice, most of this will be set up manually on the unit, with power and frequency
+        varied.
+        '''
+        self.add_parameter('aux_frequency',
+                           label='Aux Frequency',
+                           get_cmd='SENS:FOM:RANG4:FREQ:CW?',
+                           get_parser=float,
+                           set_cmd='SENS:FOM:RANG4:FREQ:CW {:.2f}',
+                           unit='Hz',
+                           vals=Numbers(min_value=10e6,max_value=50e9))
\ No newline at end of file

From 9dcbda94ae7b0d96c6a30aab94b57b3deb9f1906 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Fri, 8 Jun 2018 12:27:22 +1000
Subject: [PATCH 05/25] Add initializer for N5245A PNA

---
 qcodes/instrument_drivers/Keysight/N5245A.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 qcodes/instrument_drivers/Keysight/N5245A.py

diff --git a/qcodes/instrument_drivers/Keysight/N5245A.py b/qcodes/instrument_drivers/Keysight/N5245A.py
new file mode 100644
index 00000000000..431b840a30e
--- /dev/null
+++ b/qcodes/instrument_drivers/Keysight/N5245A.py
@@ -0,0 +1,12 @@
+from . import N52xx
+
+class N5245A(N52xx.PNAxBase):
+    def __init__(self, name, address, **kwargs):
+        super().__init__(name, address, 
+                         min_freq=10e6, max_freq=50e9, 
+                         min_power=-30, max_power=13,
+                         **kwargs)
+
+        options = self.get_options()
+        if "419" in options:
+            self._set_power_limits(min_power=-90, max_power=13)

From 92d0bfa51ff42f6a761c3743866e7745a528a932 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Fri, 8 Jun 2018 13:49:31 +1000
Subject: [PATCH 06/25] Allow channel lists to be cleared

---
 qcodes/instrument/channel.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/qcodes/instrument/channel.py b/qcodes/instrument/channel.py
index 26acccc9dbb..734aed64dc4 100644
--- a/qcodes/instrument/channel.py
+++ b/qcodes/instrument/channel.py
@@ -259,6 +259,12 @@ def append(self, obj: InstrumentChannel):
         self._channel_mapping[obj.short_name] = obj
         return self._channels.append(obj)
 
+    def clear(self):
+        if self._locked:
+            raise AttributeError("Cannot clear a locked channel list")
+        self._channels.clear()
+        self._channel_mapping.clear()
+
     def extend(self, objects):
         """
         Insert an iterable of objects into the list of channels.

From a0051d1ed4bc7284340428839d0738122c9e7153 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Fri, 8 Jun 2018 14:41:10 +1000
Subject: [PATCH 07/25] Add nports to N5245A

---
 qcodes/instrument_drivers/Keysight/N5245A.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/qcodes/instrument_drivers/Keysight/N5245A.py b/qcodes/instrument_drivers/Keysight/N5245A.py
index 431b840a30e..f1866d0eecc 100644
--- a/qcodes/instrument_drivers/Keysight/N5245A.py
+++ b/qcodes/instrument_drivers/Keysight/N5245A.py
@@ -5,6 +5,7 @@ def __init__(self, name, address, **kwargs):
         super().__init__(name, address, 
                          min_freq=10e6, max_freq=50e9, 
                          min_power=-30, max_power=13,
+                         nports=4,
                          **kwargs)
 
         options = self.get_options()

From c98754b55424d105b77316c9ff2071b087999e6c Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Fri, 8 Jun 2018 14:41:45 +1000
Subject: [PATCH 08/25] Remove multi-parameters, not compatible with new
 dataset

---
 qcodes/instrument_drivers/Keysight/N52xx.py | 243 ++++++--------------
 1 file changed, 65 insertions(+), 178 deletions(-)

diff --git a/qcodes/instrument_drivers/Keysight/N52xx.py b/qcodes/instrument_drivers/Keysight/N52xx.py
index fc95757a12b..712e6ef273f 100644
--- a/qcodes/instrument_drivers/Keysight/N52xx.py
+++ b/qcodes/instrument_drivers/Keysight/N52xx.py
@@ -1,115 +1,54 @@
 from cmath import phase
 import math
 import numpy as np
-from qcodes import VisaInstrument, MultiParameter, InstrumentChannel
+from qcodes import VisaInstrument, MultiParameter, InstrumentChannel, ArrayParameter, ChannelList
 from qcodes.utils.validators import Numbers
 import time
 import re
 
-class RawSweep(MultiParameter):
-    """
-    RawSweep pulls the magnitude and phase directly from the instrument without waiting.
-    """
-    def __init__(self, name, instrument, start, stop, npts):
-        super().__init__(name, names=("",""), shapes=((), ()))
-        self._instrument = instrument
-        self.set_sweep(start, stop, npts)
-        self.names = ('magnitude', 'phase')
-        self.units = ('dB', 'rad')
-        self.setpoint_names = (('frequency',), ('frequency',))
-        
-    def set_sweep(self, start, stop, npts):
-        f = tuple(np.linspace(int(start), int(stop), num=npts))
-        self.setpoints = ((f,), (f,))
-        self.shapes = ((npts,), (npts,))
-        
-    def get(self):
-        self.set_sweep(self._instrument.start(), self._instrument.stop(), self._instrument.points())
-        
-        data_str = self._instrument.ask('CALC:DATA? SDATA').split(',')
-        data_list = [float(v) for v in data_str]
-
-        # Unpack and convert to log magnitude and phase
-        data_arr = np.array(data_list).reshape(int(len(data_list) / 2), 2)
-        mag_array, phase_array = [], []
-        for comp in data_arr:
-            complex_num = complex(comp[0], comp[1])
-            mag_array.append(20 * math.log10(abs(complex_num)))
-            phase_array.append(phase(complex_num))
-        return mag_array, phase_array
-        
-        
-class MagPhaseSweep(MultiParameter):
-    """
-    MagPhase will run a sweep, including averaging, before returning data.
-    As such, wait time in a loop is not needed.
-    """
-    def __init__(self, name, instrument, start, stop, npts):
-        super().__init__(name, names=("",""), shapes=((), ()))
-        self._instrument = instrument
-        self.set_sweep(start, stop, npts)
-        self.names = ('magnitude', 'phase')
-        self.units = ('dB', 'degrees')
-        self.setpoint_names = (('frequency',), ('frequency',))
-        
-    def set_sweep(self, start, stop, npts):
-        f = tuple(np.linspace(int(start), int(stop), num=npts))
-        self.setpoints = ((f,), (f,))
-        self.shapes = ((npts,), (npts,))
-        
-    def get(self):
-        self.set_sweep(self._instrument.start(), self._instrument.stop(), self._instrument.points())
-        
-        # Take instrument out of continuous mode, and send triggers equal to the number of averages
-        self._instrument.write('SENS:AVER:CLE')
-        self._instrument.write('TRIG:SOUR IMM')
-        avg = self._instrument.averages()
-        self._instrument.write('SENS:SWE:GRO:COUN {0}'.format(avg))
-        self._instrument.write('SENS:SWE:MODE GRO')
-
-        # Once the sweep mode is in hold, we know we're done
-        while True:
-            if self._instrument.ask('SENS:SWE:MODE?') == 'HOLD':
-                break
-            time.sleep(0.2)
-        
-        # Ask for magnitude
-        previous_format = self._instrument.ask('CALC:FORM?')
-        self._instrument.write('CALC:FORM MLOG')
-        mag_str = self._instrument.ask('CALC:DATA? FDATA').split(',')
-        mag_list = [float(v) for v in mag_str]
-        
-        # Then phase
-        self._instrument.write('CALC:FORM UPH')
-        phase_str = self._instrument.ask('CALC:DATA? FDATA').split(',')
-        phase_list = [float(v) for v in phase_str]
+class PNASweep(ArrayParameter):
+    def __init__(self, name, instrument, **kwargs):
+        super().__init__(name,
+                 instrument=instrument,
+                 shape=(0,),
+                 setpoints=((0,),),
+                 **kwargs
+                 )
 
-        # Return the instrument state
-        self._instrument.write('CALC:FORM {}'.format(previous_format))
-        self._instrument.write('SENS:SWE:MODE CONT')
-                      
-        return mag_list, phase_list
+    @property
+    def shape(self):
+        if self._instrument is None:
+            return (0,)
+        return (self._instrument.root_instrument.points(),)
+    @shape.setter
+    def shape(self, val):
+        pass
+    @property
+    def setpoints(self):
+        start = self._instrument.root_instrument.start()
+        stop = self._instrument.root_instrument.stop()
+        return (np.linspace(start, stop, self.shape[0]),)
+    @setpoints.setter
+    def setpoints(self, val):
+        pass
 
-class FormattedSweep(ArrayParameter):
+class FormattedSweep(PNASweep):
     """
     Mag will run a sweep, including averaging, before returning data.
     As such, wait time in a loop is not needed.
     """
-    def __init__(self, name, instrument, format, label, unit, start, stop, npts):
+    def __init__(self, name, instrument, format, label, unit):
         super().__init__(name,
+                         instrument=instrument,
                          label=label,
                          unit=unit,
-                         shape=(npts,),
-                         setpoints=(np.linspace(start, stop, num=npts),),
                          setpoint_names=('frequency',),
                          setpoint_labels=('Frequency',),
                          setpoint_units=('Hz',)
                          )
-        self._instrument = instrument
         self.format = format
         
     def get_raw(self):
-        
         # Take instrument out of continuous mode, and send triggers equal to the number of averages
         self._instrument.write('SENS:AVER:CLE')
         self._instrument.write('TRIG:SOUR IMM')
@@ -131,17 +70,7 @@ def get_raw(self):
         # Return the instrument state
         self._instrument.write('SENS:SWE:MODE CONT')
                       
-        return data_list
-
-    @property
-    def shape(self):
-        return (self._instrument.root_instrument.points(),)
-    @property
-    def setpoints(self):
-        start = self._instrument.root_instrument.start()
-        stop = self._instrument.root_instrument.stop()
-        return (np.linspace(start, stop, self.shape),)
-    
+        return data_list    
 
 class PNAPort(InstrumentChannel):
     """
@@ -164,6 +93,12 @@ def __init__(self, parent, name, port,
                            get_cmd=pow_cmd + "?",
                            set_cmd=pow_cmd + "{}",
                            get_parser=float)
+    
+    def _set_power_limits(self, min_power, max_power):
+        """
+        Set port power limits
+        """
+        self.source_power.vals = Numbers(min_value=min_power,max_value=max_power)
 
 class PNATrace(InstrumentChannel):
     """
@@ -178,7 +113,7 @@ def __init__(self, parent, name, trace):
         self.add_parameter('trace',
                            label='Trace',
                            get_cmd='CALC:PAR:SEL?'.format(self.trace),
-                           get_parser=_Sparam
+                           get_parser=self._Sparam
                            )
 
         # And a list of individual formats
@@ -186,33 +121,21 @@ def __init__(self, parent, name, trace):
                            format='MLOG',
                            label='Magnitude',
                            unit='dB',
-                           start=start,
-                           stop=stop,
-                           npts=npts,
                            parameter_class=FormattedSweep)
         self.add_parameter('phase',
                            format='PHAS',
                            label='Phase',
                            unit='deg',
-                           start=start,
-                           stop=stop,
-                           npts=npts,
                            parameter_class=FormattedSweep)
         self.add_parameter('real',
                            format='REAL',
                            label='Real',
                            unit='LinMag',
-                           start=start,
-                           stop=stop,
-                           npts=npts,
                            parameter_class=FormattedSweep)
         self.add_parameter('imaginary',
                            format='IMAG',
                            label='Imaginary',
                            unit='LinMag',
-                           start=start,
-                           stop=stop,
-                           npts=npts,
                            parameter_class=FormattedSweep)
 
     def write(self, cmd):
@@ -261,29 +184,13 @@ def __init__(self, name, address,
 
         #Ports
         ports = ChannelList(self, "PNAPorts", PNAPort)
-        for port in range(1,nports+1):
-            port = PNAPort(self, f"Port{port}", port)
+        for port_num in range(1,nports+1):
+            port = PNAPort(self, f"port{port_num}", port_num, min_power, max_power)
             ports.append(port)
-            self.add_submodule(port)
+            self.add_submodule(f"port{port_num}", port)
         ports.lock()
         self.add_submodule("ports", ports)
 
-        # Traces
-        # Note: These will be accessed through the traces property which updates
-        # the channellist to include only active trace numbers
-        self._traces = ChannelList(self, "PNATraces", PNATrace)
-        self.add_submodule("traces", self._traces)
-        
-        # Parameters
-        # The active trace (i.e. what is pulled from the PNA), and its assigned S parameter.
-        # To extract multiple S-parameters, set the trace first, then use one of the sweeps.
-        self.add_parameter('trace_number',
-                           label='Trace No',
-                           get_cmd='CALC:PAR:MNUM?',
-                           set_cmd='CALC:PAR:MNUM {}',
-                           get_parser=int
-                           )
-
         # Drive power
         self.add_parameter('power',
                            label='Power',
@@ -313,7 +220,7 @@ def __init__(self, name, address,
                             label='Averages Enabled',
                             get_cmd="SENS:AVER?",
                             set_cmd="SENS:AVER {}",
-                            val_mapping={True: 'ON', False: 'OFF'})
+                            val_mapping={True: '1', False: '0'})
         self.add_parameter('averages',
                            label='Averages',
                            get_cmd='SENS:AVER:COUN?',
@@ -327,23 +234,23 @@ def __init__(self, name, address,
                            label='Start Frequency',
                            get_cmd='SENS:FREQ:STAR?',
                            get_parser=float,
-                           set_cmd=self._set_start,
+                           set_cmd='SENS:FREQ:STAR {}',
                            unit='',
-                           vals=Numbers(min_value=10e6,max_value=50.2e9))
+                           vals=Numbers(min_value=min_freq,max_value=max_freq))
         self.add_parameter('stop',
                            label='Stop Frequency',
                            get_cmd='SENS:FREQ:STOP?',
                            get_parser=float,
-                           set_cmd=self._set_stop,
+                           set_cmd='SENS:FREQ:STOP {}',
                            unit='',
-                           vals=Numbers(min_value=10e6,max_value=50.2e9))
+                           vals=Numbers(min_value=min_freq,max_value=max_freq))
         
         # Number of points in a sweep
         self.add_parameter('points',
                            label='Points',
                            get_cmd='SENS:SWE:POIN?',
                            get_parser=int,
-                           set_cmd=self._set_points,
+                           set_cmd='SENS:FREQ:STOP {}',
                            unit='',
                            vals=Numbers(min_value=1, max_value=100001))
         
@@ -355,20 +262,20 @@ def __init__(self, name, address,
                            set_cmd='CALC:CORR:EDEL:TIME {:.6e}',
                            unit='s',
                            vals=Numbers(min_value=0, max_value=100000))
-        
-        '''
-        Sweeps
-        '''
-        # Wait until the sweep (and averages) are completed first
-        self.add_parameter('vector_trace',
-                           start = self.start(),
-                           stop = self.stop(),
-                           npts = self.points(),
-                           parameter_class=MagPhaseSweep)
+
+        # Traces
+        # Note: These will be accessed through the traces property which updates
+        # the channellist to include only active trace numbers
+        self._traces = ChannelList(self, "PNATraces", PNATrace)
+        self.add_submodule("traces", self._traces)
+        # Add shortcuts to trace 1
+        trace1 = PNATrace(self, "tr1", 1)
+        for param in trace1.parameters.values():
+            self.parameters[param.name] = param
+        # By default we should also pull any following values from this trace
+        self.write("CALC:PAR:MNUM 1")
                     
-        '''
-        Functions
-        '''
+        # Functions
         # Clear averages
         self.add_function('reset_averages',
                           call_cmd='SENS:AVER:CLE')
@@ -380,8 +287,8 @@ def __init__(self, name, address,
                           call_cmd='SENS:AVER OFF')
 
         # A default output format on initialisation
-        self.write('FORM ASCii,0')
-        self.write('FORM:BORD SWAP')
+        self.write('FORM REAL,32')
+        self.write('FORM:BORD NORM')
 
         self.connect_message()
 
@@ -395,7 +302,7 @@ def traces(self):
         for trace in parlist[::2]:
             trnum = PNATrace.parse_paramstring(trace)[2]
             trace = PNATrace(self, "tr{}".format(trnum), int(trnum))
-            self._traces.add(trace)
+            self._traces.append(trace)
         return self._traces
     
 
@@ -408,29 +315,8 @@ def _set_power_limits(self, min_power, max_power):
         Set port power limits
         """
         self.power.vals = Numbers(min_value=min_power,max_value=max_power)
-
-    # Adjusting the sweep requires an adjustment to the sweep parameters
-    def _set_start(self, val):
-        self.write('SENS:FREQ:STAR {:.2f}'.format(val))
-        self._set_sweep(start=val)
-            
-    def _set_stop(self, val):
-        self.write('SENS:FREQ:STOP {:.2f}'.format(val))
-        self._set_sweep(stop=val)
-            
-    def _set_points(self, val):
-        self.write('SENS:SWE:POIN {:d}'.format(val))
-        self._set_sweep(npts=val)
-
-    def _set_sweep(self, start=None, stop=None, npts=None):
-        if start is None:
-            start = self.start()
-        if stop is None:
-            stop = self.stop()
-        if npts is None:
-            npts = self.points()
-        for trace in self.traces:
-            trace.set_sweep(start, stop, npts)
+        for port in self.ports:
+            port._set_power_limits(min_power, max_power)
 
 class PNAxBase(PNABase):
     def __init__(self, name, address, 
@@ -439,9 +325,10 @@ def __init__(self, name, address,
                  nports, # Number of ports on the PNA
                  **kwargs):
 
-        super.__init__(self, name, address, 
+        super().__init__(name, address, 
                        min_freq, max_freq,
                        min_power, max_power,
+                       nports,
                        **kwargs)
 
     def _enable_fom(self):

From 2cbb44b2a0d07c5cc6c3478e70d3d5b890920183 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Fri, 8 Jun 2018 15:28:31 +1000
Subject: [PATCH 09/25] Add FOM parameters

---
 qcodes/instrument_drivers/Keysight/N5245A.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/qcodes/instrument_drivers/Keysight/N5245A.py b/qcodes/instrument_drivers/Keysight/N5245A.py
index f1866d0eecc..ae1af3e6d5c 100644
--- a/qcodes/instrument_drivers/Keysight/N5245A.py
+++ b/qcodes/instrument_drivers/Keysight/N5245A.py
@@ -11,3 +11,5 @@ def __init__(self, name, address, **kwargs):
         options = self.get_options()
         if "419" in options:
             self._set_power_limits(min_power=-90, max_power=13)
+        if "080" in options:
+            self._enable_fom()

From 4e5fc69c3ccfcc5e688d2cfe269ea15afa98a4e6 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Fri, 8 Jun 2018 15:28:45 +1000
Subject: [PATCH 10/25] Fix parameter getting

---
 qcodes/instrument_drivers/Keysight/N52xx.py | 140 ++++++++++++++------
 1 file changed, 96 insertions(+), 44 deletions(-)

diff --git a/qcodes/instrument_drivers/Keysight/N52xx.py b/qcodes/instrument_drivers/Keysight/N52xx.py
index 712e6ef273f..a8b6d59cb09 100644
--- a/qcodes/instrument_drivers/Keysight/N52xx.py
+++ b/qcodes/instrument_drivers/Keysight/N52xx.py
@@ -2,7 +2,7 @@
 import math
 import numpy as np
 from qcodes import VisaInstrument, MultiParameter, InstrumentChannel, ArrayParameter, ChannelList
-from qcodes.utils.validators import Numbers
+from qcodes.utils.validators import Numbers, Enum, Bool
 import time
 import re
 
@@ -37,7 +37,7 @@ class FormattedSweep(PNASweep):
     Mag will run a sweep, including averaging, before returning data.
     As such, wait time in a loop is not needed.
     """
-    def __init__(self, name, instrument, format, label, unit):
+    def __init__(self, name, instrument, format, label, unit, memory=False):
         super().__init__(name,
                          instrument=instrument,
                          label=label,
@@ -47,30 +47,41 @@ def __init__(self, name, instrument, format, label, unit):
                          setpoint_units=('Hz',)
                          )
         self.format = format
-        
+        self.memory = memory
+
     def get_raw(self):
+        root_instr = self._instrument.root_instrument
+        # Check if we should run a new sweep
+        if root_instr.auto_sweep():
+            prev_mode = self.run_sweep()
+        # Ask for data, setting the format to the requested form
+        self._instrument.write(f'CALC:FORM {self.format}')
+        data = np.array(root_instr.visa_handle.query_binary_values('CALC:DATA? FDATA', datatype='f', is_big_endian=True))
+        # Restore previous state if it was changed
+        if root_instr.auto_sweep():
+            root_instr.sweep_mode(prev_mode)
+
+        return data
+
+    def run_sweep(self):
+        root_instr = self._instrument.root_instrument
+        # Store previous mode
+        prev_mode = root_instr.sweep_mode()
         # Take instrument out of continuous mode, and send triggers equal to the number of averages
-        self._instrument.write('SENS:AVER:CLE')
-        self._instrument.write('TRIG:SOUR IMM')
-        avg = self._instrument.averages()
-        self._instrument.write('SENS:SWE:GRO:COUN {0}'.format(avg))
-        self._instrument.write('SENS:SWE:MODE GRO')
+        if root_instr.averages_enabled:
+            avg = root_instr.averages()
+            root_instr.write('SENS:AVER:CLE')
+            root_instr.write('SENS:SWE:GRO:COUN {0}'.format(avg))
+            root_instr.root_instrument.sweep_mode('GRO')
+        else:
+            root_instr.root_instrument.sweep_mode('SING')
 
         # Once the sweep mode is in hold, we know we're done
-        while True:
-            if self._instrument.ask('SENS:SWE:MODE?') == 'HOLD':
-                break
+        while root_instr.sweep_mode() != 'HOLD':
             time.sleep(0.1)
-        
-        # Ask for magnitude
-        self._instrument.write('CALC:FORM %s' % self.format)
-        data_str = self._instrument.ask('CALC:DATA? FDATA').split(',')
-        data_list = np.fromiter((float(v) for v in data_str), float)
 
-        # Return the instrument state
-        self._instrument.write('SENS:SWE:MODE CONT')
-                      
-        return data_list    
+        # Return previous mode, incase we want to restore this
+        return prev_mode
 
 class PNAPort(InstrumentChannel):
     """
@@ -93,7 +104,7 @@ def __init__(self, parent, name, port,
                            get_cmd=pow_cmd + "?",
                            set_cmd=pow_cmd + "{}",
                            get_parser=float)
-    
+
     def _set_power_limits(self, min_power, max_power):
         """
         Set port power limits
@@ -109,12 +120,21 @@ def __init__(self, parent, name, trace):
         super().__init__(parent, name)
         self.trace = trace
 
-        # Name of parameter
+        # Name of parameter (i.e. S11, S21 ...)
         self.add_parameter('trace',
                            label='Trace',
                            get_cmd='CALC:PAR:SEL?'.format(self.trace),
-                           get_parser=self._Sparam
+                           get_parser=self._Sparam,
+                           set_cmd=self._set_Sparam
                            )
+        # Format
+        # Note: Currently parameters that return complex values are not supported
+        # as there isn't really a good way of saving them into the dataset
+        self.add_parameter('format',
+                           label='Format',
+                           get_cmd='CALC:FORM?',
+                           set_cmd='CALC:FORM {}',
+                           vals=Enum('MLIN', 'MLOG', 'PHAS', 'UPH', 'IMAG', 'REAL'))
 
         # And a list of individual formats
         self.add_parameter('magnitude',
@@ -122,6 +142,11 @@ def __init__(self, parent, name, trace):
                            label='Magnitude',
                            unit='dB',
                            parameter_class=FormattedSweep)
+        self.add_parameter('linear_magnitude',
+                           format='MLIN',
+                           label='Magnitude',
+                           unit='ratio',
+                           parameter_class=FormattedSweep)
         self.add_parameter('phase',
                            format='PHAS',
                            label='Phase',
@@ -165,6 +190,14 @@ def _Sparam(self, paramspec):
         Extrace S_parameter from returned PNA format
         """
         return self.parse_paramstring(paramspec)[1]
+    def _set_Sparam(self, val):
+        """
+        Set an S-parameter, in the format S<a><b>, where a and b
+        can range from 1-4
+        """
+        if not re.match("S[1-4][1-4]"):
+            raise ValueError("Invalid S parameter spec")
+        self.write(f"CALC:PAR:MOD:EXT {val}")
 
 class PNABase(VisaInstrument):
     """
@@ -175,7 +208,7 @@ class PNABase(VisaInstrument):
           traces, but using traces across multiple channels may have unexpected results.
     """
 
-    def __init__(self, name, address, 
+    def __init__(self, name, address,
                  min_freq, max_freq, # Set frequency ranges
                  min_power, max_power, # Set power ranges
                  nports, # Number of ports on the PNA
@@ -199,13 +232,7 @@ def __init__(self, name, address,
                            set_cmd='SOUR:POW {:.2f}',
                            unit='dBm',
                            vals=Numbers(min_value=min_power,max_value=max_power))
-        self.add_parameter('sweep_time',
-                           label='Time',
-                           get_cmd='SENS:SWE:TIME?',
-                           get_parser=float,
-                           unit='s',
-                           vals=Numbers(0,1e6))
-        
+
         # IF bandwidth
         self.add_parameter('if_bandwidth',
                            label='IF Bandwidth',
@@ -214,13 +241,13 @@ def __init__(self, name, address,
                            set_cmd='SENS:BAND {:.2f}',
                            unit='Hz',
                            vals=Numbers(min_value=1,max_value=15e6))
-        
+
         # Number of averages (also resets averages)
         self.add_parameter('averages_enabled',
-                            label='Averages Enabled',
-                            get_cmd="SENS:AVER?",
-                            set_cmd="SENS:AVER {}",
-                            val_mapping={True: '1', False: '0'})
+                           label='Averages Enabled',
+                           get_cmd="SENS:AVER?",
+                           set_cmd="SENS:AVER {}",
+                           val_mapping={True: '1', False: '0'})
         self.add_parameter('averages',
                            label='Averages',
                            get_cmd='SENS:AVER:COUN?',
@@ -228,7 +255,7 @@ def __init__(self, name, address,
                            set_cmd='SENS:AVER:COUN {:d}',
                            unit='',
                            vals=Numbers(min_value=1,max_value=65536))
-        
+
         # Setting frequency range
         self.add_parameter('start',
                            label='Start Frequency',
@@ -244,16 +271,16 @@ def __init__(self, name, address,
                            set_cmd='SENS:FREQ:STOP {}',
                            unit='',
                            vals=Numbers(min_value=min_freq,max_value=max_freq))
-        
+
         # Number of points in a sweep
         self.add_parameter('points',
                            label='Points',
                            get_cmd='SENS:SWE:POIN?',
                            get_parser=int,
-                           set_cmd='SENS:FREQ:STOP {}',
+                           set_cmd='SENS:SWE:POIN {}',
                            unit='',
                            vals=Numbers(min_value=1, max_value=100001))
-        
+
         # Electrical delay
         self.add_parameter('electrical_delay',
                            label='Electrical Delay',
@@ -263,6 +290,20 @@ def __init__(self, name, address,
                            unit='s',
                            vals=Numbers(min_value=0, max_value=100000))
 
+        # Sweep Time
+        self.add_parameter('sweep_time',
+                           label='Time',
+                           get_cmd='SENS:SWE:TIME?',
+                           get_parser=float,
+                           unit='s',
+                           vals=Numbers(0,1e6))
+        # Sweep Mode
+        self.add_parameter('sweep_mode',
+                           label='Mode',
+                           get_cmd='SENS:SWE:MODE?',
+                           set_cmd='SENS:SWE:MODE {}',
+                           vals=Enum("HOLD", "CONT", "GRO", "SING"))
+
         # Traces
         # Note: These will be accessed through the traces property which updates
         # the channellist to include only active trace numbers
@@ -274,7 +315,17 @@ def __init__(self, name, address,
             self.parameters[param.name] = param
         # By default we should also pull any following values from this trace
         self.write("CALC:PAR:MNUM 1")
-                    
+
+        # Set auto_sweep parameter
+        # If we want to return multiple traces per setpoint without sweeping
+        # multiple times, we should set this to false
+        self._auto_sweep = True
+        self.add_parameter('auto_sweep',
+                           label='Auto Sweep',
+                           set_cmd=self._set_auto_sweep,
+                           get_cmd=lambda: self._auto_sweep,
+                           vals=Bool())
+
         # Functions
         # Clear averages
         self.add_function('reset_averages',
@@ -304,12 +355,13 @@ def traces(self):
             trace = PNATrace(self, "tr{}".format(trnum), int(trnum))
             self._traces.append(trace)
         return self._traces
-    
 
     def get_options(self):
         # Query the instrument for what options are installed
         return self.ask('*OPT?').strip('"').split(',')
 
+    def _set_auto_sweep(self, val):
+        self._auto_sweep = val
     def _set_power_limits(self, min_power, max_power):
         """
         Set port power limits
@@ -319,13 +371,13 @@ def _set_power_limits(self, min_power, max_power):
             port._set_power_limits(min_power, max_power)
 
 class PNAxBase(PNABase):
-    def __init__(self, name, address, 
+    def __init__(self, name, address,
                  min_freq, max_freq, # Set frequency ranges
                  min_power, max_power, # Set power ranges
                  nports, # Number of ports on the PNA
                  **kwargs):
 
-        super().__init__(name, address, 
+        super().__init__(name, address,
                        min_freq, max_freq,
                        min_power, max_power,
                        nports,

From e8c63855e6f16326d2092ddd1cec5f17d299f05e Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Fri, 8 Jun 2018 17:54:14 +1000
Subject: [PATCH 11/25] Add mypy annotations

---
 qcodes/instrument_drivers/Keysight/N52xx.py | 98 +++++++++++++--------
 1 file changed, 62 insertions(+), 36 deletions(-)

diff --git a/qcodes/instrument_drivers/Keysight/N52xx.py b/qcodes/instrument_drivers/Keysight/N52xx.py
index a8b6d59cb09..153550aed1c 100644
--- a/qcodes/instrument_drivers/Keysight/N52xx.py
+++ b/qcodes/instrument_drivers/Keysight/N52xx.py
@@ -1,13 +1,18 @@
 from cmath import phase
 import math
 import numpy as np
-from qcodes import VisaInstrument, MultiParameter, InstrumentChannel, ArrayParameter, ChannelList
+from qcodes import Instrument, VisaInstrument, MultiParameter, InstrumentChannel, ArrayParameter, ChannelList
 from qcodes.utils.validators import Numbers, Enum, Bool
+from typing import Optional, Sequence, TYPE_CHECKING, Union, Callable, List, Dict, Any, Sized, Iterable, Tuple
 import time
 import re
 
 class PNASweep(ArrayParameter):
-    def __init__(self, name, instrument, **kwargs):
+    def __init__(self, 
+                 name: str, 
+                 instrument: 'PNABase',
+                 **kwargs: Any) -> None:
+
         super().__init__(name,
                  instrument=instrument,
                  shape=(0,),
@@ -16,20 +21,20 @@ def __init__(self, name, instrument, **kwargs):
                  )
 
     @property
-    def shape(self):
+    def shape(self) -> Sequence[int]:
         if self._instrument is None:
             return (0,)
         return (self._instrument.root_instrument.points(),)
     @shape.setter
-    def shape(self, val):
+    def shape(self, val: Sequence[int]) -> None:
         pass
     @property
-    def setpoints(self):
+    def setpoints(self) -> Sequence:
         start = self._instrument.root_instrument.start()
         stop = self._instrument.root_instrument.stop()
         return (np.linspace(start, stop, self.shape[0]),)
     @setpoints.setter
-    def setpoints(self, val):
+    def setpoints(self, val: Sequence[int]) -> None:
         pass
 
 class FormattedSweep(PNASweep):
@@ -37,7 +42,13 @@ class FormattedSweep(PNASweep):
     Mag will run a sweep, including averaging, before returning data.
     As such, wait time in a loop is not needed.
     """
-    def __init__(self, name, instrument, format, label, unit, memory=False):
+    def __init__(self, 
+                 name: str, 
+                 instrument: 'PNABase', 
+                 format: str, 
+                 label: str, 
+                 unit: str, 
+                 memory: bool=False) -> None:
         super().__init__(name,
                          instrument=instrument,
                          label=label,
@@ -49,7 +60,7 @@ def __init__(self, name, instrument, format, label, unit, memory=False):
         self.format = format
         self.memory = memory
 
-    def get_raw(self):
+    def get_raw(self) -> Sequence[float]:
         root_instr = self._instrument.root_instrument
         # Check if we should run a new sweep
         if root_instr.auto_sweep():
@@ -63,7 +74,7 @@ def get_raw(self):
 
         return data
 
-    def run_sweep(self):
+    def run_sweep(self) -> str:
         root_instr = self._instrument.root_instrument
         # Store previous mode
         prev_mode = root_instr.sweep_mode()
@@ -89,8 +100,12 @@ class PNAPort(InstrumentChannel):
     Note: This can be expanded to include a large number of extra parameters...
     """
 
-    def __init__(self, parent, name, port,
-                 min_power, max_power):
+    def __init__(self, 
+                 parent: 'PNABase', 
+                 name: str, 
+                 port: int,
+                 min_power: Union[int, float], 
+                 max_power: Union[int, float]) -> None:
         super().__init__(parent, name)
 
         self.port = int(port)
@@ -105,7 +120,9 @@ def __init__(self, parent, name, port,
                            set_cmd=pow_cmd + "{}",
                            get_parser=float)
 
-    def _set_power_limits(self, min_power, max_power):
+    def _set_power_limits(self, 
+                          min_power: Union[int, float], 
+                          max_power: Union[int, float]) -> None:
         """
         Set port power limits
         """
@@ -116,7 +133,10 @@ class PNATrace(InstrumentChannel):
     Allow operations on individual PNA traces.
     """
 
-    def __init__(self, parent, name, trace):
+    def __init__(self, 
+                 parent: 'PNABase', 
+                 name: str, 
+                 trace: int) -> None:
         super().__init__(parent, name)
         self.trace = trace
 
@@ -163,13 +183,13 @@ def __init__(self, parent, name, trace):
                            unit='LinMag',
                            parameter_class=FormattedSweep)
 
-    def write(self, cmd):
+    def write(self, cmd: str) -> None:
         """
         Select correct trace before querying
         """
         super().write("CALC:PAR:MNUM {}".format(self.trace))
         super().write(cmd)
-    def ask(self, cmd):
+    def ask(self, cmd: str) -> str:
         """
         Select correct trace before querying
         """
@@ -177,7 +197,7 @@ def ask(self, cmd):
         return super().ask(cmd)
 
     @staticmethod
-    def parse_paramstring(paramspec):
+    def parse_paramstring(paramspec: str) -> Tuple[str, str, str]:
         """
         Parse parameter specification from PNA
         """
@@ -185,17 +205,17 @@ def parse_paramstring(paramspec):
         ch, param, trnum = re.findall(r"CH(\d+)_(S\d+)_(\d+)", paramspec)[0]
         return ch, param, trnum
 
-    def _Sparam(self, paramspec):
+    def _Sparam(self, paramspec: str) -> str:
         """
         Extrace S_parameter from returned PNA format
         """
         return self.parse_paramstring(paramspec)[1]
-    def _set_Sparam(self, val):
+    def _set_Sparam(self, val: str) -> None:
         """
         Set an S-parameter, in the format S<a><b>, where a and b
         can range from 1-4
         """
-        if not re.match("S[1-4][1-4]"):
+        if not re.match("S[1-4][1-4]", val):
             raise ValueError("Invalid S parameter spec")
         self.write(f"CALC:PAR:MOD:EXT {val}")
 
@@ -208,11 +228,13 @@ class PNABase(VisaInstrument):
           traces, but using traces across multiple channels may have unexpected results.
     """
 
-    def __init__(self, name, address,
-                 min_freq, max_freq, # Set frequency ranges
-                 min_power, max_power, # Set power ranges
-                 nports, # Number of ports on the PNA
-                 **kwargs):
+    def __init__(self, 
+                 name: str, 
+                 address: str,
+                 min_freq: Union[int, float], max_freq: Union[int, float], # Set frequency ranges
+                 min_power: Union[int, float], max_power: Union[int, float], # Set power ranges
+                 nports: int, # Number of ports on the PNA
+                 **kwargs: Any) -> None:
         super().__init__(name, address, terminator='\n', **kwargs)
 
         #Ports
@@ -344,7 +366,7 @@ def __init__(self, name, address,
         self.connect_message()
 
     @property
-    def traces(self):
+    def traces(self) -> ChannelList:
         """
         Update channel list with active traces and return the new list
         """
@@ -352,17 +374,19 @@ def traces(self):
         self._traces.clear()
         for trace in parlist[::2]:
             trnum = PNATrace.parse_paramstring(trace)[2]
-            trace = PNATrace(self, "tr{}".format(trnum), int(trnum))
-            self._traces.append(trace)
+            pna_trace = PNATrace(self, "tr{}".format(trnum), int(trnum))
+            self._traces.append(pna_trace)
         return self._traces
 
-    def get_options(self):
+    def get_options(self) -> Sequence[str]:
         # Query the instrument for what options are installed
         return self.ask('*OPT?').strip('"').split(',')
 
-    def _set_auto_sweep(self, val):
+    def _set_auto_sweep(self, val: bool) -> None:
         self._auto_sweep = val
-    def _set_power_limits(self, min_power, max_power):
+    def _set_power_limits(self, 
+                          min_power: Union[int, float], 
+                          max_power: Union[int, float]) -> None:
         """
         Set port power limits
         """
@@ -371,11 +395,13 @@ def _set_power_limits(self, min_power, max_power):
             port._set_power_limits(min_power, max_power)
 
 class PNAxBase(PNABase):
-    def __init__(self, name, address,
-                 min_freq, max_freq, # Set frequency ranges
-                 min_power, max_power, # Set power ranges
-                 nports, # Number of ports on the PNA
-                 **kwargs):
+    def __init__(self, 
+                 name: str, 
+                 address: str,
+                 min_freq: Union[int, float], max_freq: Union[int, float], # Set frequency ranges
+                 min_power: Union[int, float], max_power: Union[int, float], # Set power ranges
+                 nports: int, # Number of ports on the PNA
+                 **kwargs: Any) -> None:
 
         super().__init__(name, address,
                        min_freq, max_freq,
@@ -383,7 +409,7 @@ def __init__(self, name, address,
                        nports,
                        **kwargs)
 
-    def _enable_fom(self):
+    def _enable_fom(self) -> None:
         '''
         PNA-x units with two sources have an enormous list of functions & configurations.
         In practice, most of this will be set up manually on the unit, with power and frequency

From c73b215e04783cc2ffc6c13ad82d8538ea6d13f5 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Fri, 8 Jun 2018 17:57:15 +1000
Subject: [PATCH 12/25] Ignore typing on overloaded properties

---
 qcodes/instrument_drivers/Keysight/N52xx.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/qcodes/instrument_drivers/Keysight/N52xx.py b/qcodes/instrument_drivers/Keysight/N52xx.py
index 153550aed1c..e1e09203bac 100644
--- a/qcodes/instrument_drivers/Keysight/N52xx.py
+++ b/qcodes/instrument_drivers/Keysight/N52xx.py
@@ -20,16 +20,16 @@ def __init__(self,
                  **kwargs
                  )
 
-    @property
-    def shape(self) -> Sequence[int]:
+    @property # type: ignore
+    def shape(self) -> Sequence[int]: # type: ignore
         if self._instrument is None:
             return (0,)
         return (self._instrument.root_instrument.points(),)
     @shape.setter
     def shape(self, val: Sequence[int]) -> None:
         pass
-    @property
-    def setpoints(self) -> Sequence:
+    @property # type: ignore
+    def setpoints(self) -> Sequence: # type: ignore
         start = self._instrument.root_instrument.start()
         stop = self._instrument.root_instrument.stop()
         return (np.linspace(start, stop, self.shape[0]),)

From 1da163596fe70ad10c711c0045aa04de199ef517 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Fri, 8 Jun 2018 18:01:25 +1000
Subject: [PATCH 13/25] Add N5230C driver as well

---
 qcodes/instrument_drivers/Keysight/N5230C.py | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 qcodes/instrument_drivers/Keysight/N5230C.py

diff --git a/qcodes/instrument_drivers/Keysight/N5230C.py b/qcodes/instrument_drivers/Keysight/N5230C.py
new file mode 100644
index 00000000000..3bb77aeef0d
--- /dev/null
+++ b/qcodes/instrument_drivers/Keysight/N5230C.py
@@ -0,0 +1,9 @@
+from . import N52xx
+
+class N5230C(N52xx.PNABase):
+    def __init__(self, name, address, **kwargs):
+        super().__init__(name, address, 
+                         min_freq=300e3, max_freq=13.5e9, 
+                         min_power=-90, max_power=13,
+                         nports=2,
+                         **kwargs)

From fb5aa72e6c2ceabf57d8cc1361b6d7db49f679e8 Mon Sep 17 00:00:00 2001
From: "Jens H. Nielsen" <Jens.Nielsen@microsoft.com>
Date: Thu, 7 Jun 2018 20:51:20 +0200
Subject: [PATCH 14/25] make register_parameter match add_result for
 array_parameter

---
 qcodes/dataset/measurements.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qcodes/dataset/measurements.py b/qcodes/dataset/measurements.py
index 1d76e1e4682..82635004a60 100644
--- a/qcodes/dataset/measurements.py
+++ b/qcodes/dataset/measurements.py
@@ -422,8 +422,8 @@ def register_parameter(
         if isinstance(parameter, ArrayParameter):
             parameter = cast(ArrayParameter, parameter)
             spname_parts = []
-            if parameter.instrument is not None:
-                inst_name = parameter.instrument.name
+            if parameter._instrument is not None:
+                inst_name = parameter._instrument.name
                 if inst_name is not None:
                     spname_parts.append(inst_name)
             if parameter.setpoint_names is not None:

From 64dad3c0e99c3f17ba17c834a652774f75ab0d1c Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Mon, 23 Jul 2018 09:48:23 +1000
Subject: [PATCH 15/25] Add docstring to clear

---
 qcodes/instrument/channel.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/qcodes/instrument/channel.py b/qcodes/instrument/channel.py
index 6238c846eae..9e25cc147fc 100644
--- a/qcodes/instrument/channel.py
+++ b/qcodes/instrument/channel.py
@@ -281,6 +281,9 @@ def append(self, obj: InstrumentChannel):
         return self._channels.append(obj)
 
     def clear(self):
+        """
+        Clear all items from the channel list.
+        """
         if self._locked:
             raise AttributeError("Cannot clear a locked channel list")
         self._channels.clear()

From 9cea3f78b13aa6930a1c597647be6df78f1334b7 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Mon, 23 Jul 2018 09:53:28 +1000
Subject: [PATCH 16/25] Fix codacy errors

- Lots of trailing white space
- rename variables
- fix format string
---
 qcodes/instrument_drivers/Keysight/N5230C.py |  4 +-
 qcodes/instrument_drivers/Keysight/N5245A.py |  4 +-
 qcodes/instrument_drivers/Keysight/N52xx.py  | 58 ++++++++++----------
 3 files changed, 32 insertions(+), 34 deletions(-)

diff --git a/qcodes/instrument_drivers/Keysight/N5230C.py b/qcodes/instrument_drivers/Keysight/N5230C.py
index 3bb77aeef0d..40962842b5d 100644
--- a/qcodes/instrument_drivers/Keysight/N5230C.py
+++ b/qcodes/instrument_drivers/Keysight/N5230C.py
@@ -2,8 +2,8 @@
 
 class N5230C(N52xx.PNABase):
     def __init__(self, name, address, **kwargs):
-        super().__init__(name, address, 
-                         min_freq=300e3, max_freq=13.5e9, 
+        super().__init__(name, address,
+                         min_freq=300e3, max_freq=13.5e9,
                          min_power=-90, max_power=13,
                          nports=2,
                          **kwargs)
diff --git a/qcodes/instrument_drivers/Keysight/N5245A.py b/qcodes/instrument_drivers/Keysight/N5245A.py
index ae1af3e6d5c..f33e77da5e8 100644
--- a/qcodes/instrument_drivers/Keysight/N5245A.py
+++ b/qcodes/instrument_drivers/Keysight/N5245A.py
@@ -2,8 +2,8 @@
 
 class N5245A(N52xx.PNAxBase):
     def __init__(self, name, address, **kwargs):
-        super().__init__(name, address, 
-                         min_freq=10e6, max_freq=50e9, 
+        super().__init__(name, address,
+                         min_freq=10e6, max_freq=50e9,
                          min_power=-30, max_power=13,
                          nports=4,
                          **kwargs)
diff --git a/qcodes/instrument_drivers/Keysight/N52xx.py b/qcodes/instrument_drivers/Keysight/N52xx.py
index e1e09203bac..eeef809ca24 100644
--- a/qcodes/instrument_drivers/Keysight/N52xx.py
+++ b/qcodes/instrument_drivers/Keysight/N52xx.py
@@ -1,15 +1,13 @@
-from cmath import phase
-import math
 import numpy as np
-from qcodes import Instrument, VisaInstrument, MultiParameter, InstrumentChannel, ArrayParameter, ChannelList
+from qcodes import VisaInstrument, InstrumentChannel, ArrayParameter, ChannelList
 from qcodes.utils.validators import Numbers, Enum, Bool
-from typing import Optional, Sequence, TYPE_CHECKING, Union, Callable, List, Dict, Any, Sized, Iterable, Tuple
+from typing import Sequence, TYPE_CHECKING, Union, Callable, List, Dict, Any, Sized, Iterable, Tuple
 import time
 import re
 
 class PNASweep(ArrayParameter):
-    def __init__(self, 
-                 name: str, 
+    def __init__(self,
+                 name: str,
                  instrument: 'PNABase',
                  **kwargs: Any) -> None:
 
@@ -42,12 +40,12 @@ class FormattedSweep(PNASweep):
     Mag will run a sweep, including averaging, before returning data.
     As such, wait time in a loop is not needed.
     """
-    def __init__(self, 
-                 name: str, 
-                 instrument: 'PNABase', 
-                 format: str, 
-                 label: str, 
-                 unit: str, 
+    def __init__(self,
+                 name: str,
+                 instrument: 'PNABase',
+                 sweep_format: str,
+                 label: str,
+                 unit: str,
                  memory: bool=False) -> None:
         super().__init__(name,
                          instrument=instrument,
@@ -57,7 +55,7 @@ def __init__(self,
                          setpoint_labels=('Frequency',),
                          setpoint_units=('Hz',)
                          )
-        self.format = format
+        self.sweep_format = format
         self.memory = memory
 
     def get_raw(self) -> Sequence[float]:
@@ -66,7 +64,7 @@ def get_raw(self) -> Sequence[float]:
         if root_instr.auto_sweep():
             prev_mode = self.run_sweep()
         # Ask for data, setting the format to the requested form
-        self._instrument.write(f'CALC:FORM {self.format}')
+        self._instrument.write(f'CALC:FORM {self.sweep_format}')
         data = np.array(root_instr.visa_handle.query_binary_values('CALC:DATA? FDATA', datatype='f', is_big_endian=True))
         # Restore previous state if it was changed
         if root_instr.auto_sweep():
@@ -100,11 +98,11 @@ class PNAPort(InstrumentChannel):
     Note: This can be expanded to include a large number of extra parameters...
     """
 
-    def __init__(self, 
-                 parent: 'PNABase', 
-                 name: str, 
+    def __init__(self,
+                 parent: 'PNABase',
+                 name: str,
                  port: int,
-                 min_power: Union[int, float], 
+                 min_power: Union[int, float],
                  max_power: Union[int, float]) -> None:
         super().__init__(parent, name)
 
@@ -120,8 +118,8 @@ def __init__(self,
                            set_cmd=pow_cmd + "{}",
                            get_parser=float)
 
-    def _set_power_limits(self, 
-                          min_power: Union[int, float], 
+    def _set_power_limits(self,
+                          min_power: Union[int, float],
                           max_power: Union[int, float]) -> None:
         """
         Set port power limits
@@ -133,9 +131,9 @@ class PNATrace(InstrumentChannel):
     Allow operations on individual PNA traces.
     """
 
-    def __init__(self, 
-                 parent: 'PNABase', 
-                 name: str, 
+    def __init__(self,
+                 parent: 'PNABase',
+                 name: str,
                  trace: int) -> None:
         super().__init__(parent, name)
         self.trace = trace
@@ -143,7 +141,7 @@ def __init__(self,
         # Name of parameter (i.e. S11, S21 ...)
         self.add_parameter('trace',
                            label='Trace',
-                           get_cmd='CALC:PAR:SEL?'.format(self.trace),
+                           get_cmd='CALC:PAR:SEL?',
                            get_parser=self._Sparam,
                            set_cmd=self._set_Sparam
                            )
@@ -228,8 +226,8 @@ class PNABase(VisaInstrument):
           traces, but using traces across multiple channels may have unexpected results.
     """
 
-    def __init__(self, 
-                 name: str, 
+    def __init__(self,
+                 name: str,
                  address: str,
                  min_freq: Union[int, float], max_freq: Union[int, float], # Set frequency ranges
                  min_power: Union[int, float], max_power: Union[int, float], # Set power ranges
@@ -384,8 +382,8 @@ def get_options(self) -> Sequence[str]:
 
     def _set_auto_sweep(self, val: bool) -> None:
         self._auto_sweep = val
-    def _set_power_limits(self, 
-                          min_power: Union[int, float], 
+    def _set_power_limits(self,
+                          min_power: Union[int, float],
                           max_power: Union[int, float]) -> None:
         """
         Set port power limits
@@ -395,8 +393,8 @@ def _set_power_limits(self,
             port._set_power_limits(min_power, max_power)
 
 class PNAxBase(PNABase):
-    def __init__(self, 
-                 name: str, 
+    def __init__(self,
+                 name: str,
                  address: str,
                  min_freq: Union[int, float], max_freq: Union[int, float], # Set frequency ranges
                  min_power: Union[int, float], max_power: Union[int, float], # Set power ranges

From e5144b04ed226d463cc94dbb2b85504e3a30cd89 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Mon, 23 Jul 2018 10:02:01 +1000
Subject: [PATCH 17/25] Remove unused imports

---
 qcodes/instrument_drivers/Keysight/N52xx.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qcodes/instrument_drivers/Keysight/N52xx.py b/qcodes/instrument_drivers/Keysight/N52xx.py
index eeef809ca24..89fd4cbadf8 100644
--- a/qcodes/instrument_drivers/Keysight/N52xx.py
+++ b/qcodes/instrument_drivers/Keysight/N52xx.py
@@ -1,7 +1,7 @@
 import numpy as np
 from qcodes import VisaInstrument, InstrumentChannel, ArrayParameter, ChannelList
 from qcodes.utils.validators import Numbers, Enum, Bool
-from typing import Sequence, TYPE_CHECKING, Union, Callable, List, Dict, Any, Sized, Iterable, Tuple
+from typing import Sequence, Union, Any, Tuple
 import time
 import re
 

From 95e8d6777abffd7b57ca951af47766c85eb1f183 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Mon, 23 Jul 2018 22:11:51 +1000
Subject: [PATCH 18/25] Fix whitespace and formatting

---
 qcodes/instrument_drivers/Keysight/N52xx.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/qcodes/instrument_drivers/Keysight/N52xx.py b/qcodes/instrument_drivers/Keysight/N52xx.py
index 89fd4cbadf8..75ec0bd9cfc 100644
--- a/qcodes/instrument_drivers/Keysight/N52xx.py
+++ b/qcodes/instrument_drivers/Keysight/N52xx.py
@@ -26,6 +26,7 @@ def shape(self) -> Sequence[int]: # type: ignore
     @shape.setter
     def shape(self, val: Sequence[int]) -> None:
         pass
+
     @property # type: ignore
     def setpoints(self) -> Sequence: # type: ignore
         start = self._instrument.root_instrument.start()
@@ -114,8 +115,8 @@ def __init__(self,
         self.add_parameter("source_power",
                            label="power",
                            unit="dBm",
-                           get_cmd=pow_cmd + "?",
-                           set_cmd=pow_cmd + "{}",
+                           get_cmd=f"{pow_cmd}?",
+                           set_cmd=f"{pow_cmd} {{}}",
                            get_parser=float)
 
     def _set_power_limits(self,
@@ -187,6 +188,7 @@ def write(self, cmd: str) -> None:
         """
         super().write("CALC:PAR:MNUM {}".format(self.trace))
         super().write(cmd)
+
     def ask(self, cmd: str) -> str:
         """
         Select correct trace before querying
@@ -208,6 +210,7 @@ def _Sparam(self, paramspec: str) -> str:
         Extrace S_parameter from returned PNA format
         """
         return self.parse_paramstring(paramspec)[1]
+
     def _set_Sparam(self, val: str) -> None:
         """
         Set an S-parameter, in the format S<a><b>, where a and b
@@ -382,6 +385,7 @@ def get_options(self) -> Sequence[str]:
 
     def _set_auto_sweep(self, val: bool) -> None:
         self._auto_sweep = val
+
     def _set_power_limits(self,
                           min_power: Union[int, float],
                           max_power: Union[int, float]) -> None:
@@ -419,4 +423,4 @@ def _enable_fom(self) -> None:
                            get_parser=float,
                            set_cmd='SENS:FOM:RANG4:FREQ:CW {:.2f}',
                            unit='Hz',
-                           vals=Numbers(min_value=10e6,max_value=50e9))
\ No newline at end of file
+                           vals=Numbers(min_value=10e6,max_value=50e9))

From 525988d6bb42dde8c9cf951049dd06169b03f05c Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Thu, 26 Jul 2018 16:05:27 +1000
Subject: [PATCH 19/25] Move run_sweep to trace

---
 qcodes/instrument_drivers/Keysight/N52xx.py | 64 ++++++++++++---------
 1 file changed, 37 insertions(+), 27 deletions(-)

diff --git a/qcodes/instrument_drivers/Keysight/N52xx.py b/qcodes/instrument_drivers/Keysight/N52xx.py
index 75ec0bd9cfc..9eb0a19972b 100644
--- a/qcodes/instrument_drivers/Keysight/N52xx.py
+++ b/qcodes/instrument_drivers/Keysight/N52xx.py
@@ -56,14 +56,14 @@ def __init__(self,
                          setpoint_labels=('Frequency',),
                          setpoint_units=('Hz',)
                          )
-        self.sweep_format = format
+        self.sweep_format = sweep_format
         self.memory = memory
 
     def get_raw(self) -> Sequence[float]:
         root_instr = self._instrument.root_instrument
         # Check if we should run a new sweep
         if root_instr.auto_sweep():
-            prev_mode = self.run_sweep()
+            prev_mode = self._instrument.run_sweep()
         # Ask for data, setting the format to the requested form
         self._instrument.write(f'CALC:FORM {self.sweep_format}')
         data = np.array(root_instr.visa_handle.query_binary_values('CALC:DATA? FDATA', datatype='f', is_big_endian=True))
@@ -73,26 +73,6 @@ def get_raw(self) -> Sequence[float]:
 
         return data
 
-    def run_sweep(self) -> str:
-        root_instr = self._instrument.root_instrument
-        # Store previous mode
-        prev_mode = root_instr.sweep_mode()
-        # Take instrument out of continuous mode, and send triggers equal to the number of averages
-        if root_instr.averages_enabled:
-            avg = root_instr.averages()
-            root_instr.write('SENS:AVER:CLE')
-            root_instr.write('SENS:SWE:GRO:COUN {0}'.format(avg))
-            root_instr.root_instrument.sweep_mode('GRO')
-        else:
-            root_instr.root_instrument.sweep_mode('SING')
-
-        # Once the sweep mode is in hold, we know we're done
-        while root_instr.sweep_mode() != 'HOLD':
-            time.sleep(0.1)
-
-        # Return previous mode, incase we want to restore this
-        return prev_mode
-
 class PNAPort(InstrumentChannel):
     """
     Allow operations on individual PNA ports.
@@ -157,31 +137,61 @@ def __init__(self,
 
         # And a list of individual formats
         self.add_parameter('magnitude',
-                           format='MLOG',
+                           sweep_format='MLOG',
                            label='Magnitude',
                            unit='dB',
                            parameter_class=FormattedSweep)
         self.add_parameter('linear_magnitude',
-                           format='MLIN',
+                           sweep_format='MLIN',
                            label='Magnitude',
                            unit='ratio',
                            parameter_class=FormattedSweep)
         self.add_parameter('phase',
-                           format='PHAS',
+                           sweep_format='PHAS',
+                           label='Phase',
+                           unit='deg',
+                           parameter_class=FormattedSweep)
+        self.add_parameter('unwrapped_phase',
+                           sweep_format='UPH',
                            label='Phase',
                            unit='deg',
                            parameter_class=FormattedSweep)
+        self.add_parameter("group_delay",
+                           sweep_format='GDEL',
+                           label='Group Delay',
+                           unit='s',
+                           parameter_class=FormattedSweep)
         self.add_parameter('real',
-                           format='REAL',
+                           sweep_format='REAL',
                            label='Real',
                            unit='LinMag',
                            parameter_class=FormattedSweep)
         self.add_parameter('imaginary',
-                           format='IMAG',
+                           sweep_format='IMAG',
                            label='Imaginary',
                            unit='LinMag',
                            parameter_class=FormattedSweep)
 
+    def run_sweep(self) -> str:
+        root_instr = self.root_instrument
+        # Store previous mode
+        prev_mode = root_instr.sweep_mode()
+        # Take instrument out of continuous mode, and send triggers equal to the number of averages
+        if root_instr.averages_enabled:
+            avg = root_instr.averages()
+            root_instr.write('SENS:AVER:CLE')
+            root_instr.write('SENS:SWE:GRO:COUN {0}'.format(avg))
+            root_instr.root_instrument.sweep_mode('GRO')
+        else:
+            root_instr.root_instrument.sweep_mode('SING')
+
+        # Once the sweep mode is in hold, we know we're done
+        while root_instr.sweep_mode() != 'HOLD':
+            time.sleep(0.1)
+
+        # Return previous mode, incase we want to restore this
+        return prev_mode
+
     def write(self, cmd: str) -> None:
         """
         Select correct trace before querying

From 77a1de4728fe2a6f4fe1080d56acd4c882a11180 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Thu, 26 Jul 2018 16:05:39 +1000
Subject: [PATCH 20/25] Add tests for channel clear

---
 qcodes/tests/test_channels.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/qcodes/tests/test_channels.py b/qcodes/tests/test_channels.py
index 829a8c9e53f..c774f3b76d0 100644
--- a/qcodes/tests/test_channels.py
+++ b/qcodes/tests/test_channels.py
@@ -107,6 +107,20 @@ def test_insert_channel(self):
             self.instrument.channels.insert(2, channel)
         self.assertEqual(len(self.instrument.channels), n_channels + 1)
 
+    def test_clear_channels(self):
+        channels = self.instrument.channels
+        original_length = len(channels)
+        channels.clear()
+        self.assertEqual(len(channels), 0)
+
+    def test_clear_locked_channels(self):
+        channels = self.instrument.channels
+        original_length = len(channels)
+        channels.lock()
+        with self.assertRaises(AttributeError):
+            channels.clear()
+        self.assertEqual(len(channels), original_length)
+
     def test_remove_channel(self):
         channels = self.instrument.channels
         chanA = self.instrument.A

From 94176004d26cc6c8cd0e98c97853a961ad5a1681 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Thu, 26 Jul 2018 16:06:40 +1000
Subject: [PATCH 21/25] Add Keysight PNA driver example

---
 ...ample_with_Keysight_Network_Analyzer.ipynb | 381 ++++++++++++++++++
 1 file changed, 381 insertions(+)
 create mode 100644 docs/examples/driver_examples/Qcodes_example_with_Keysight_Network_Analyzer.ipynb

diff --git a/docs/examples/driver_examples/Qcodes_example_with_Keysight_Network_Analyzer.ipynb b/docs/examples/driver_examples/Qcodes_example_with_Keysight_Network_Analyzer.ipynb
new file mode 100644
index 00000000000..560beefa336
--- /dev/null
+++ b/docs/examples/driver_examples/Qcodes_example_with_Keysight_Network_Analyzer.ipynb
@@ -0,0 +1,381 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Example Notebook for Keysight Network Analyzers\n",
+    "\n",
+    "This notebook is indendet to give an overview over the functions implemented in the QCoDeS driver for the Keysight network analyzers. The driver is implemented to be generic as possible, with individual instrument drivers filling in only the hardware limits of the instrument, so although this example uses the N5245A, the concepts and code should work for any keysight network analyzer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Experiment loaded. Last ID no: 16\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Import Dependencies\n",
+    "\n",
+    "import logging\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# qcodes imports\n",
+    "import qcodes as qc\n",
+    "from qcodes.dataset.experiment_container import new_experiment, load_experiment_by_name\n",
+    "from qcodes.dataset.measurements import Measurement\n",
+    "from qcodes.dataset.plotting import plot_by_id\n",
+    "import qcodes.instrument_drivers.Keysight.N5245A as N5245A\n",
+    "\n",
+    "#setup\n",
+    "logger = logging.getLogger()\n",
+    "logger.setLevel(logging.DEBUG)\n",
+    "\n",
+    "# Start experiment\n",
+    "exp_name = 'PNA_Example'\n",
+    "sample_name = 'Thru_Coax'\n",
+    "try:\n",
+    "    exp = load_experiment_by_name(exp_name, sample=sample_name)\n",
+    "    print('Experiment loaded. Last ID no:', exp.last_counter)\n",
+    "except ValueError:\n",
+    "    exp = new_experiment(exp_name, sample_name)\n",
+    "    print('Starting new experiment.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Connect to the instrument\n",
+    "\n",
+    "You will have to insert the correct VISA address for your PNA below. On my PC, the PNA has IP address `192.168.0.10`. You can generally use NI MAX or Agilent IO Toolkit to figure out what the VISA address of your instrument is, particularly for USB or GPIB connections."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Connected to: Agilent Technologies N5245A (serial:MY52451750, firmware:A.10.49.08) in 0.21s\n"
+     ]
+    }
+   ],
+   "source": [
+    "pna = N5245A.N5245A('pna', 'TCPIP::192.168.0.10::inst0::INSTR')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Simple Measurements\n",
+    "\n",
+    "We can very easily set up measurements and pull, for example, magnitude data off the PNA."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting experimental run with id: 17\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "([<matplotlib.axes._subplots.AxesSubplot at 0x1ba0bf174a8>], [None])"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Set up a frequency sweep from 100 MHz to 1 GHz, with 1001 points, at a power of -40dBm\n",
+    "pna.power(-40)\n",
+    "pna.start(100e6)\n",
+    "pna.stop(1e9)\n",
+    "pna.points(1001)\n",
+    "pna.trace(\"S21\")\n",
+    "\n",
+    "# Enable 2 averages, and set IF BW to 1kHz\n",
+    "pna.if_bandwidth(1e3)\n",
+    "pna.averages_enabled(True)\n",
+    "pna.averages(2)\n",
+    "\n",
+    "# Run a measurement\n",
+    "meas = Measurement()\n",
+    "meas.register_parameter(pna.magnitude)\n",
+    "\n",
+    "with meas.run() as datasaver:\n",
+    "    mag = pna.magnitude()\n",
+    "    datasaver.add_result((pna.magnitude, mag))\n",
+    "    dataid = datasaver.run_id\n",
+    "plot_by_id(dataid)\n",
+    "\n",
+    "# Other valid parameter types are:\n",
+    "# pna.linear_magnitude()\n",
+    "# pna.phase()\n",
+    "# pna.unwrapped_phase()\n",
+    "# pna.group_delay()\n",
+    "# pna.real()\n",
+    "# pna.imaginary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Reading multiple parameters in one measurement\n",
+    "\n",
+    "If we want to read out multiple parameters in a single loop, we can disable auto-sweep and manually tell the PNA to take new data for each setpoint. Otherwise, each time we get a measured parameter of the PNA (e.g. magnitude and phase) a new trace will be taken."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting experimental run with id: 18\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "([<matplotlib.axes._subplots.AxesSubplot at 0x1ba0d6cab00>,\n",
+       "  <matplotlib.axes._subplots.AxesSubplot at 0x1ba0e6fe668>],\n",
+       " [None, None])"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Disable automatic sweeping\n",
+    "pna.auto_sweep(False)\n",
+    "\n",
+    "# Run a measurement\n",
+    "meas = Measurement()\n",
+    "meas.register_parameter(pna.magnitude)\n",
+    "meas.register_parameter(pna.phase)\n",
+    "\n",
+    "with meas.run() as datasaver:\n",
+    "    pna.traces.tr1.run_sweep() # Ask the PNA to take a measurement\n",
+    "    mag = pna.magnitude()\n",
+    "    phase = pna.unwrapped_phase()\n",
+    "    datasaver.add_result((pna.magnitude, mag),\n",
+    "                         (pna.phase, phase))\n",
+    "    dataid = datasaver.run_id\n",
+    "plot_by_id(dataid)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Multiple Traces\n",
+    "\n",
+    "We can also read multiple traces off the PNA at once. For example if the PNA is set up such that:\n",
+    " - Trace 1 is S11\n",
+    " - Trace 2 is S12\n",
+    " - Trace 3 is S21\n",
+    " - Trace 4 is S22\n",
+    " \n",
+    "we can read these off simultaneously as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting experimental run with id: 20\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "([<matplotlib.axes._subplots.AxesSubplot at 0x1ba0d6aca58>,\n",
+       "  <matplotlib.axes._subplots.AxesSubplot at 0x1ba0e9b90f0>,\n",
+       "  <matplotlib.axes._subplots.AxesSubplot at 0x1ba0e976a90>,\n",
+       "  <matplotlib.axes._subplots.AxesSubplot at 0x1ba0e8b3470>],\n",
+       " [None, None, None, None])"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Disable automatic sweeping\n",
+    "pna.auto_sweep(False)\n",
+    "\n",
+    "# Update the list of traces\n",
+    "traces = pna.traces\n",
+    "\n",
+    "# Run a measurement\n",
+    "meas = Measurement()\n",
+    "meas.register_parameter(traces.tr1.magnitude)\n",
+    "meas.register_parameter(traces.tr2.magnitude)\n",
+    "meas.register_parameter(traces.tr3.magnitude)\n",
+    "meas.register_parameter(traces.tr4.magnitude)\n",
+    "\n",
+    "with meas.run() as datasaver:\n",
+    "    traces.tr1.run_sweep() # Ask the PNA to take a measurement\n",
+    "    data = []\n",
+    "    for trace in traces:\n",
+    "        mag = trace.magnitude()\n",
+    "        data.append((trace.magnitude, mag))\n",
+    "    datasaver.add_result(*data)\n",
+    "    dataid = datasaver.run_id\n",
+    "plot_by_id(dataid)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set the PNA back into continuous sweep mode\n",
+    "pna.sweep_mode(\"CONT\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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.6.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From d4db4a81d99c8a2d2380b85c347890c986571c3c Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Thu, 26 Jul 2018 16:43:49 +1000
Subject: [PATCH 22/25] Remove unused variable

---
 qcodes/tests/test_channels.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/qcodes/tests/test_channels.py b/qcodes/tests/test_channels.py
index c774f3b76d0..d9a836d8bb9 100644
--- a/qcodes/tests/test_channels.py
+++ b/qcodes/tests/test_channels.py
@@ -109,7 +109,6 @@ def test_insert_channel(self):
 
     def test_clear_channels(self):
         channels = self.instrument.channels
-        original_length = len(channels)
         channels.clear()
         self.assertEqual(len(channels), 0)
 

From ae6d5c0e8fe10f615351d8f1add38e3a7e340747 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Fri, 27 Jul 2018 11:28:59 +1000
Subject: [PATCH 23/25] Rearrange trace parameters, change auto_sweep
 implementation

---
 qcodes/instrument_drivers/Keysight/N52xx.py | 51 +++++++++++++--------
 1 file changed, 32 insertions(+), 19 deletions(-)

diff --git a/qcodes/instrument_drivers/Keysight/N52xx.py b/qcodes/instrument_drivers/Keysight/N52xx.py
index 9eb0a19972b..67758599448 100644
--- a/qcodes/instrument_drivers/Keysight/N52xx.py
+++ b/qcodes/instrument_drivers/Keysight/N52xx.py
@@ -196,14 +196,14 @@ def write(self, cmd: str) -> None:
         """
         Select correct trace before querying
         """
-        super().write("CALC:PAR:MNUM {}".format(self.trace))
+        super().active_trace(self.trace)
         super().write(cmd)
 
     def ask(self, cmd: str) -> str:
         """
         Select correct trace before querying
         """
-        super().write("CALC:PAR:MNUM {}".format(self.trace))
+        super().active_trace(self.trace)
         return super().ask(cmd)
 
     @staticmethod
@@ -338,7 +338,13 @@ def __init__(self,
                            vals=Enum("HOLD", "CONT", "GRO", "SING"))
 
         # Traces
-        # Note: These will be accessed through the traces property which updates
+        self.add_parameter('active_trace',
+                           label='Active Trace',
+                           get_cmd="CALC:PAR:MNUM?",
+                           get_parser=int,
+                           set_cmd="CALC:PAR:MNUM {}",
+                           vals=Numbers(min_value=1, max_value=24))
+        # Note: Traces will be accessed through the traces property which updates
         # the channellist to include only active trace numbers
         self._traces = ChannelList(self, "PNATraces", PNATrace)
         self.add_submodule("traces", self._traces)
@@ -347,28 +353,17 @@ def __init__(self,
         for param in trace1.parameters.values():
             self.parameters[param.name] = param
         # By default we should also pull any following values from this trace
-        self.write("CALC:PAR:MNUM 1")
+        self.active_trace(1)
 
         # Set auto_sweep parameter
         # If we want to return multiple traces per setpoint without sweeping
         # multiple times, we should set this to false
-        self._auto_sweep = True
         self.add_parameter('auto_sweep',
                            label='Auto Sweep',
-                           set_cmd=self._set_auto_sweep,
-                           get_cmd=lambda: self._auto_sweep,
-                           vals=Bool())
-
-        # Functions
-        # Clear averages
-        self.add_function('reset_averages',
-                          call_cmd='SENS:AVER:CLE')
-        # Averages ON
-        self.add_function('averages_on',
-                          call_cmd='SENS:AVER ON')
-        # Averages OFF
-        self.add_function('averages_off',
-                          call_cmd='SENS:AVER OFF')
+                           set_cmd=None,
+                           get_cmd=None,
+                           vals=Bool(),
+                           initial_value=True)
 
         # A default output format on initialisation
         self.write('FORM REAL,32')
@@ -393,6 +388,24 @@ def get_options(self) -> Sequence[str]:
         # Query the instrument for what options are installed
         return self.ask('*OPT?').strip('"').split(',')
 
+    def reset_averages(self):
+        """
+        Reset averaging
+        """
+        self.write("SENS:AVER:CLE")
+
+    def averages_on(self):
+        """
+        Turn on trace averaging
+        """
+        self.averages_enabled(True)
+
+    def averages_off(self):
+        """
+        Turn off trace averaging
+        """
+        self.averages_enabled(False)
+
     def _set_auto_sweep(self, val: bool) -> None:
         self._auto_sweep = val
 

From f4331645097fc80898c9c0626c81f551e9df8b78 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Fri, 27 Jul 2018 11:30:35 +1000
Subject: [PATCH 24/25] Clarify comment on traces

---
 qcodes/instrument_drivers/Keysight/N52xx.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qcodes/instrument_drivers/Keysight/N52xx.py b/qcodes/instrument_drivers/Keysight/N52xx.py
index 67758599448..d13d72c3365 100644
--- a/qcodes/instrument_drivers/Keysight/N52xx.py
+++ b/qcodes/instrument_drivers/Keysight/N52xx.py
@@ -352,7 +352,8 @@ def __init__(self,
         trace1 = PNATrace(self, "tr1", 1)
         for param in trace1.parameters.values():
             self.parameters[param.name] = param
-        # By default we should also pull any following values from this trace
+        # Set this trace to be the default (it's possible to end up in a situation where
+        # no traces are selected, causing parameter snapshots to fail)
         self.active_trace(1)
 
         # Set auto_sweep parameter

From 8f73d571096bf1d2f6923ced2f45067d5f91a4f2 Mon Sep 17 00:00:00 2001
From: Sebastian Pauka <spauka@gmail.com>
Date: Fri, 27 Jul 2018 11:52:59 +1000
Subject: [PATCH 25/25] Set active trace in correct location

---
 qcodes/instrument_drivers/Keysight/N52xx.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/qcodes/instrument_drivers/Keysight/N52xx.py b/qcodes/instrument_drivers/Keysight/N52xx.py
index d13d72c3365..2c2e8b463ed 100644
--- a/qcodes/instrument_drivers/Keysight/N52xx.py
+++ b/qcodes/instrument_drivers/Keysight/N52xx.py
@@ -196,14 +196,14 @@ def write(self, cmd: str) -> None:
         """
         Select correct trace before querying
         """
-        super().active_trace(self.trace)
+        self.root_instrument.active_trace(self.trace)
         super().write(cmd)
 
     def ask(self, cmd: str) -> str:
         """
         Select correct trace before querying
         """
-        super().active_trace(self.trace)
+        self.root_instrument.active_trace(self.trace)
         return super().ask(cmd)
 
     @staticmethod