VNA.py

# -*- coding: utf-8 -*-
"""
Module for VNA Measurements

Author: Christian Schneider <c.schneider@uibk.ac.at>
Date: 07.09.2017
"""
from sqlalchemy.exc import StatementError

import DataModule as dm
import numpy as np
import time
from .Drivers.Keysight.E5080 import E5080
from .Drivers.Keysight.E5071C import E5071C
from IPLIST import IPList
import SensorReader as SR
from Monitor.main import db, Instruments
import getpass
from Monitor.functions import retrieve_name
import pickle


class VNA(object):
    """VNA Instrument class.

    Provides an object to measure with the VNAs in the Kirchmair Lab.

    Parameters
    -----------
    id_string : str
        Name of the VNA. Right now choose between 'VNA1', 'VNA2' or 'VNA3'.
        You can also specify an IP, however then you have to manually specify
        the driver for the chosen IP address
    cryostat : str
        Name of the Cryostat. Choose between 'Freezer' and 'Cooler'
    driver : object, optional
        Driver for the VNA. Only needed if VNA is not already in IPList, or
        you specified it with an IP.
    """
    def __init__(self, id_string, cryostat, driver=None):
        try:
            self.ip = IPList[id_string]
        except KeyError:
            # If VNA is not specified by valid IPList entry. Try directly ip
            if driver is not None:
                self.ip = id_string
            else:
                raise Exception('VNA not in IPList. Please specify driver')
        self.CryoID = cryostat

        # New for DB
        self.ch = 1  # Not required here, however added for compatibility to CS
        self.dB_ID = None
        self.id = id_string
        self.check_db()

        # Load driver
        if id_string == 'VNA3' or id_string == "VNA4":
            self.driver = E5080
        elif id_string == 'VNA1' or id_string == 'VNA2':
            self.driver = E5071C
        else:
            if driver is None:
                raise Exception('DriverError. Specify Driver')
            else:
                self.driver = driver

        self.instr = self.driver(self.ip)
        print("Identify: " + self.identify())  # Identify at beginning
        print("IP: " + self.ip)
        self.update_db()

    def identify(self):
        return self.instr.identify()

    # def meas(self, f_range, npoints=1601, navg=10, power=-50, Spar='S21',
    #          Format='MLOG', BW=1e3, autoSave=True,
    #          filename='measurements/measurement.dm',
    #          Use_Date=True, overwrite=False, Temp_reading=True,
    #          parameters={}, power_port2=False):
    #     """VNA Measurement
    #
    #     Automatically save as data_table datamodule if not specified
    #     otherwise (autoSave=False).
    #
    #     Parameters
    #     -----------
    #     f_range : array
    #         Frequency range [[f_start, f_stop]]
    #     npoints : int
    #         Number of Points
    #     navg : int
    #         Number of averages
    #     power : float
    #         VNA output power in dBm
    #     Spar : str
    #         S Parameter to measure. E.g. 'S21'
    #     Format : str
    #         Format for measurement. Choose from
    #          | 'MLOG' : magnitude in dB
    #          | 'PHAS': phase
    #          | 'MLIN': linear magnitude
    #          | 'REAL': real part of the complex data
    #          | 'IMAG' imaginary part of the complex data
    #          | 'UPH': Extended phase
    #          | 'PPH': Positive phase
    #     BW : int
    #         IF Bandwidth in Hz
    #     autosave : bool
    #         Automatically save data to disk (RECOMMENDED!!)
    #     filename : str
    #         Filepath + Filename. E.g. '/measurements/test'
    #     overwrite : bool
    #         Force override
    #     Temp_reading : bool
    #         Append temperature to datamodule file
    #     Use_Date : bool
    #         Add Date as leading part of filename
    #     parameters : dict
    #         Additional parameters to save in dm
    #     power_port2 : bool
    #         Power excitation on port2
    #
    #     Returns
    #     --------
    #     datamodule object
    #         Returns datamodule object if autoSave is set to False
    #     """
    #     # Initialize datamodule
    #     data = dm.data_table()
    #     data.time_start = time.strftime(data.date_format, time.localtime())
    #     if Temp_reading and self.CryoID:
    #         a = SR.SensorReader(self.CryoID)
    #         data.temp_start = a.base_temp()
    #
    #     # Measure
    #     f, d = self.instr.meas(f_range=f_range, npoints=npoints, navg=navg,
    #                            power=power, Spar=Spar, BW=BW, Format=Format,
    #                            power_port2=power_port2)
    #     # Save in datamodule
    #     data.time_stop = time.strftime(data.date_format, time.localtime())
    #     if Temp_reading and self.CryoID:
    #         data.temp_stop = a.base_temp()
    #     data.load_var(f, d)
    #     data.insert_par(frange=f_range, npoints=npoints, navg=navg,
    #                     power=power, Spar=Spar, BW=BW, **parameters)
    #
    #     # Save
    #     if (autoSave is True):
    #         data.save(filename, Use_Date, overwrite)
    #         self.update_db()
    #     else:
    #         self.update_db()
    #         return data

    def meas_complex_avg(self, f_range, npoints=1601, navg=10, power=-50,
                         Spar='S21', BW=1e3, autoSave=True,
                         filename='measurements/measurement.dm',
                         Use_Date=True, overwrite=False, Temp_reading=True,
                         parameters={}, power_port2=False):
        """VNA Measurement with complex data format.

        Automatically save as complex datamodule (Voltages) if not specified
        otherwise (autoSave=False).

        Parameters
        -----------
        f_range : [float, float]
            Frequency range in GHz. [f_start, f_stop]
        npoints : int
            Number of Points
        navg : int
            Number of averages
        power : float
            VNA output power in dBm
        Spar : str
            S Parameter to measure. E.g. 'S21'
        BW : int
            IF Bandwidth in Hz
        autoSave : bool
            Automatically save data to disk (RECOMMENDED!!)
        filename : str
            Filepath + Filename. E.g. '/measurements/test'
        overwrite : bool
            Force override
        Temp_reading : bool
            Append temperature to datamodule file
        Use_Date : bool
            Add Date as leading part of filename
        parameters : dict
            Additional parameters to save in dm
        power_port2 : bool
            Power excitation on port2

        Returns
        --------
        datamodule object
            Returns datamodule object if autoSave is set to False
        """
        # Initialize datamodule
        time_start = time.strftime('%Y-%m-%d-%H:%M:%S', time.localtime())
        cor = self.instr.correction()
        # Measure
        pars = {'f_start': '{:.4f} GHz'.format(f_range[0]),
                'f_stop': '{:.4f} GHz'.format(f_range[1]),
                'Power': '{:.0f} dBm'.format(power),
                'Points': '{:.0f}'.format(npoints),
                'Averages': '{:.0f}'.format(navg),
                'Format': '{}'.format("REAL"),
                'IF Bandwidth': '{:.2f} kHz'.format(BW/1e3),
                'RF Power': '{}'.format("ON"),
                'S-Parameter': '{}'.format(Spar),
                'Correction': '{}'.format('ON' if int(cor) == 1
                                          else 'OFF')
               }
        self.update_db(pars=pars) 
        f, v_re, v_im = self.instr.meas_complex(f_range=f_range,
                                                npoints=npoints, navg=navg,
                                                power=power, Spar=Spar,
                                                BW=BW,
                                                power_port2=power_port2)
        # Save in datamodule
        data = dm.data_complex(f, np.array(v_re) + 1j * np.array(v_im))
        data.time_start = time_start
        data.time_stop = time.strftime(data.date_format, time.localtime())
        if Temp_reading and self.CryoID:
            a = SR.SensorReader(self.CryoID)
            temp_start = a.base_temp()
            data.temp_start = temp_start
            data.temp_stop = a.base_temp()
        data.load_var(f, v_re, v_im)
        data.insert_par(frange=f_range, npoints=npoints, navg=navg,
                        power=power, Spar=Spar, BW=BW, **parameters)

        # Save
        if autoSave is True:
            data.save(filename, Use_Date, overwrite)
            self.update_db()
        else:
            self.update_db()
            return data

    def get_current_measurement_cplx(self):
        """Gets current complex measurement data and saves to cplx. datamodule
        """
        data = dm.data_complex()
        re = np.asarray(self.instr.trace_read(1)[0], dtype='float')
        im = np.asarray(self.instr.trace_read(2)[0], dtype='float')
        try:
            # Try to get frequency range (not supported by E5080)
            x = np.asarray(self.instr.freq_read(), dtype='float')
        except:
            # If not supported, return zeros for setting later manually
            print("Could not receive frequencies. Set to 0. Please"
                  "add manually")
            x = np.zeros_like(re)
        data.load_var(x/1e9, re, im)
        data.time_stop = time.strftime(data.date_format, time.localtime())
        return data

    def get_current_measurement(self):
        """Gets current measurement data and saves to datamodule"""
        dat = dm.data_table()
        y = np.asarray(self.instr.trace_read()[0], dtype='float')
        try:
            # Try to get frequency range (not supported by E5080)
            x = np.asarray(self.instr.freq_read(), dtype='float')
        except:
            # If not supported, return zeros for setting later manually
            print("Could not receive frequencies. Set to 0. Please"
                  "add manually")
            x = np.zeros_like(y)
        dat.load_var(x/1e9, y)
        dat.time_stop = time.strftime(dat.date_format, time.localtime())
        return dat

    # Database functions #######################################################
    def check_db(self):
        """A check if device is already in database and used by someone else
        """
        try:
            # Try to reach database
            d = Instruments.query.filter_by(ip=self.ip).filter_by(
                channel=self.ch).first()
            if d:
                if d.user != getpass.getuser():
                    # If you are not the user print Error

                    user = d.user
                    db.session.commit()
                    raise Exception('Device already used by {user}. Please '
                                    'talk  to him and then delete the device '
                                    'from the Device Monitor'
                                    .format(user=user))
                else:
                    # If you are the user and the device is already in db,
                    # extract the id
                    self.dB_ID = d.id
                    db.session.commit()
        except StatementError:
            # Do nothing if database is not responding
            return None

    def get_parameters(self):
        pars = self.instr.read_settings()
        d = {'f_start': '{:.4f} GHz'.format(pars['f_start (GHz)']),
             'f_stop': '{:.4f} GHz'.format(pars['f_stop (GHz)']),
             'Power': '{:.0f} dBm'.format(pars['power (dBm)']),
             'Points': '{:.0f}'.format(pars['Points']),
             'Averages': '{:.0f}'.format(pars['averages']),
             'Format': '{}'.format(pars['Format']),
             'IF Bandwidth': '{:.2f} kHz'.format(pars['IF - BW (Hz)']/1e3),
             'RF Power': '{}'.format('ON' if int(pars['output']) == 1 else
                                     'OFF'),
             'S-Parameter': '{}'.format(pars['S_parameter ']),
             'Correction': '{}'.format('ON' if int (pars['correction']) == 1
                                       else 'OFF')
            }
        return d

    def update_db(self, update_fromWeb=False, pars=None):
        """Update parameters in database value. Handles events from the
        Device Monitor WebApp by the flag update_fromWeb=True
        """
        if self.dB_ID:
            try:
                # To ensure that the library is working even if there is no
                # connection to the database
                d = Instruments.query.get(int(self.dB_ID))
                if not update_fromWeb:
                    # Only Update if flag is not set. Useful for flask server
                    #  who would rename it to an unreadable name
                    d.varname = retrieve_name(self)
                    d.user = getpass.getuser()
                if not pars:
                    d.parameters = self.get_parameters()
                else:
                    d.parameters = pars
                db.session.add(d)
                db.session.commit()
                db.session.close()
            except StatementError:
                # Do nothing if database is not responding
                return None

        else:
            # Create db entry
            # Create check to warn if the device is already used and demand
            # to delete it
            # Socket is not pickleable, close connection and remove socket
            idn = self.identify()
            pars = self.get_parameters()
            self.instr.close()
            self.instr = None
            try:
                d = Instruments(ip=self.ip,
                                devtype='VNA',
                                name=self.id,
                                varname=self.id,
                                parameters=pars,
                                pckle=pickle.dumps(self),
                                user=getpass.getuser(),
                                idn=idn,
                                channel=self.ch)
                # Store to database
                db.session.add(d)
                db.session.commit()
                # Acquire ID
                self.dB_ID = d.id
                # Save Object with self.dB_ID tag
                d.pckle = pickle.dumps(self)
                db.session.commit()
                db.session.close()
                # Reinitialize device
                self.instr = self.driver(self.ip)
            except StatementError:
                # Do nothing if database is not responding
                return None