IQCALIBRATION.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Sep  2 16:28:12 2017

@author: Oscar,Moritz

v1.1.1 - OSC:
    - improved the calibration routine for speedup and quality

v1.1.0 - MOR:
    - added documentation for all classes and functions
    - improved the calibration procedure for the offset, phase and ratio
    - added new functionality to the measure_SB() function: you can now measure
      whatever sideband you wnat
    - added functionality to measure the signal for a grid of offset values
    - added function to initialize the entire calibration
    - added function to run the entire calibration

v1.0.1 - OSC:
    - added compatibility with SignalHound spectrum analyzer
    - added a lower edge of -95 dBm to stop the automation

v1.0.0 - OSC:
    - LIbrary used to perform the calibration of an IQ mixer
"""


import numpy as np
import time
import matplotlib.pyplot as plt
from UtilitiesLib import progressive_plot_2d


class CalibrationParameters(object):
    version = '1.1.1'
    
    
    def __init__(self, offI = 0., offQ = 0., amp_ratio = 1., amp_channel = 0, phase_corr = 0.):
        """
        This object contains the calibration parameters of an IQ mixer.
        
        It is possible to initialize the parameters when initializing the 
        object or do it later with the proper functions.
        
        Parameters
        ----------
        offI : float, optional
            The offset at the I entry of the IQ mixer (default: 0.). The value
            is given in (V).
        offQ : float, optional
            The offset at the Q entry of the IQ mixer (default: 0.). The value
            is given in (V).
        amp_ratio: float, optional
            The ratio between the amplitudes of the signals in I and Q 
            (default: 1.). 
        amp_channel : int, optional
            The channel of the input signal (default: 1).
        phase_corr : float, optional
            The phase correction between the two input signals (default: 0.). 
            The value is given in degrees and always divided by 360°. It is 
            applied to the signal in channel Q.
        
        """
        
        self.set_cal_parameters(offI, offQ, amp_ratio, amp_channel, phase_corr)
        self.__MAXF = 12                                                        #GHz
        self.__MINF = 3                                                         #GHz
        self.__frequency = None
        self.__AWG_freq = None
        self.__AWG_chI = 0
        self.__AWG_chQ = 1
        self.__SB = None
        self.__LSB = None
        self.__carrier = None
        self.__RSB = None
    

    def set_cal_parameters(self, offI = 0., offQ = 0., amp_ratio = 1., amp_channel = 0, phase_corr = 0.):
        """
        Set the calibration parameters to specific values.
    
        Parameters
        ----------
        offI : float, optional
            The offset at the I entry of the IQ mixer (default: 0.). The value
            is given in (V).
        offQ : float, optional
            The offset at the Q entry of the IQ mixer (default: 0.). The value
            is given in (V).
        amp_ratio: float, optional
            The ratio between the amplitudes of the signals in I and Q 
            (default: 1.). 
        amp_channel : int, optional
            The channel of the input signal (default: 1).
        phase_corr : float, optional
            The phase correction between the two input signals (default: 0.). 
            The value is given in degrees and always divided by 360°. It is 
            applied to the signal in channel Q.
    
        Returns
        -------
        nothing: None
            This function sets the internal values of the class to the values
            given to the parameters.
    
        See Also
        --------
        __init__()
    
    
        Notes
        -----
        If no values whatsoever are given, then the function simply initializes
        all the parameters to the default values specified in Parameters.
        All the input values are rounded according to the function np.round(). 
        This is done to avoid infinite internal representations of certain 
        numbers.
    
        """
       
        self.offI = np.round(offI, 12)
        self.offQ = np.round(offQ, 12)
        self.amp_ratio = np.round(amp_ratio, 12)
        self.amp_channel = int(amp_channel)
        self.phase_corr = np.round(phase_corr % 360, 12)
    
    
    #----------------------------------------------------------------------------------------------------------------------------Output functions, delete at end-------------------
    def LSB(self):
        return self.__LSB
    
    def carrier(self):
        return self.__carrier
    
    def RSB(self):
        return self.__RSB
    
    def AWG_freq(self):
        return self.__AWG_freq


    #--------------------------------------------------------------------------

    def cal_par_list(self):
        """
        Return the parameters of the calibration in a tuple.
    
        Parameters
        ----------
        none
    
        Returns
        -------
        tuple: tuple
            The return value is a tuple containing all the values of the 
            parameters set by the function set_cal_parameters().
            
            (offI, offQ, amp_ratio, amp_channel, phase_corr)
    
        See Also
        --------
        set_cal_parameters()
    
        """
        
        return self.offI, self.offQ, self.amp_ratio, self.amp_channel, self.phase_corr
    
        
    #--------------------------------------------------------------------------
    
    def frequency(self, frequency = None, SB = 'R'):
        """
        Query or set the up-mixed frequency. It is possible to specify the 
        sideband that is calibrated.
    
        Parameters
        ----------
        frequency : float, optional
            The calibrated frequency (default: None). The value is given in 
            (GHz).
        SB : string, optional
            Defines which sideband is used for the calibration (default: 'R').
            The used convention is:
            'R' or 'r':         right
            'L' or 'l':         left
    
        Returns
        -------
        Tuple: tuple
            This function returns the frequency and the sideband in a tuple:
            
            (frequency, SB)
    
    
        Notes
        -----
        The frequency has to be an element of a certain range: [3, 12].
    
        """
        
        # If no values are given, return the current values.
        if frequency is None:
            return self.__frequency, self.__SB
        
        # Ensure that the frequency is positive.
        frequency = abs(frequency)
        
        # Check that the frequency is inside given bounds.
        if frequency < self.__MINF:
            print('Warning: very low frequency, is it correct?')
            raise Exception('LOWFREQ')
        
        if frequency > self.__MAXF:
            print('Warning: high frequency, is it correct?')
            raise Exception('HIGHFREQ')
        
        # Define the sideband for the calibration.
        if SB.upper() == 'R':
            self.__SB = 'RSB'
        elif SB.upper() == 'L':
            self.__SB = 'LSB'
        else:
            print('ERROR: wrong sideband specified')
            raise Exception('SBERR')
        
        # Set the new value for the frequency.
        self.__frequency = np.round(frequency, 12)
        return self.__frequency, self.__SB
    

    
    #--------------------------------------------------------------------------    
    
    def AWG_parameters(self, AWG_freq = None, chI = 0, chQ = 1):
        """
        Set or return the AWG parameters.
    
        Parameters
        ----------
        AWG_freq : float, optional
            The frequency of the AWG (default: None). The value is given in 
            (MHz)
        chI : int, optional
            The channel of the AWG connected to the I port (default: 0).
        chQ : int, optional
            The channel of the AWG connected to the Q port (default: 1).
    
        Returns
        -------
        Tuple: tuple
            This function returns the frequency and the channels of the AWG in 
            a tuple:
            
            (AWG_freq, chI, chQ)
    
        Notes
        -----
        The value for the AWG frequency is entered and returned in MHz. 
        Internally it is saved in GHz.
    
        """
        
        # Check if you want to set or return values.
        if AWG_freq is None:
            if self.__AWG_freq is None:
                return None, self.__AWG_chI, self.__AWG_chQ
            return self.__AWG_freq*1e3, self.__AWG_chI, self.__AWG_chQ
        
        # Check that the frequency is positive.
        if AWG_freq < 0:
            print('Error: frequency is negative')
            raise Exception('NEGVAL')
        
        # Check that the frequency doesn't get too high.
        if AWG_freq > 450.:
            print('WARNING: frequency is high, is it correct?')
        
        # Set the values.
        self.__AWG_freq = np.round(AWG_freq*1e-3, 12)
        self.__AWG_chI = int(chI)
        self.__AWG_chQ = int(chQ)
        
        return self.__AWG_freq*1e3, self.__AWG_chI, self.__AWG_chQ
        
    
    #--------------------------------------------------------------------------    
    
    def Sidebands(self):
        """
        Calculate and set the frequencies for the sidebands of the calibration.
    
        Parameters
        ----------
        none
    
        Returns
        -------
        Tuple: tuple
            This function returns the frequencies in the sidebands a tuple:
            
            (LSB_freq, carrier_freq, RSB_freq)
    
        Notes
        -----
        First it is checked if a value for the frequency and the AWG frequency
        have been entered. Otherwise the calculation would fail. The 
        frequencies are calculated based on which sideband is being calibrated.
    
        """
        
        # Check if initial setup is done.
        if self.__frequency is None or self.__AWG_freq is None:
            print('Setup not complete')
            return 0, 0, 0
        else:
            # Calculate the frequencies of the sidebands.
            AWG_freq = self.__AWG_freq
            if self.__SB == 'RSB':
                self.__LSB, self.__carrier, self.__RSB = np.round_([self.__frequency - 2*AWG_freq, 
                                                                    self.__frequency - AWG_freq, 
                                                                    self.__frequency], 
                                                                    9)
                return self.__LSB, self.__carrier, self.__RSB
            elif self.__SB == 'LSB':
                self.__LSB, self.__carrier, self.__RSB = np.round_([self.__frequency, 
                                                                    self.__frequency + AWG_freq, 
                                                                    self.__frequency + 2*AWG_freq], 
                                                                    9)
                return self.__LSB, self.__carrier, self.__RSB
            else:
                print('Sideband not yet specified!')
                raise Exception('SBERR')
    

    #--------------------------------------------------------------------------

    def print_parameters(self):
        """
        Print all the parameters that have already been initialized.
    
        Parameters
        ----------
        none
    
        Returns
        -------
        nothing: None
    
        Notes
        -----
        Depending on the setup, a different amount of parameters is printed.
        The output looks always at least like:
        
        offI: {}V
        offQ: {}V
        amp_ratio: {}
        amp_channel: {}
        phase_corr: {} deg
        
        If the AWG has been initialized the following is added:
        AWG_frequency: {} MHz
        chI: {}
        chQ: {}
        
        If the sidebands have been initialized the following is added:
        LSB: {} GHz
        LO: {} GHz
        RSB: {} GHz
        calibrated for: {}
    
        """
        
        text = '\noffI: {}V\noffQ: {}V\namp_ratio: {}\namp_channel: {}\nphase_corr: {} deg\n'.format(self.offI,self.offQ,self.amp_ratio,self.amp_channel,self.phase_corr)
        text2, text3 = '', ''
        
        if self.__AWG_freq is not None:
            text2 = 'AWG_frequency: {} MHz\nchI: {}\nchQ: {}\n'.format(*self.AWG_parameters())
        if self.__frequency is not None:
            text3 = 'LSB: {} GHz\nLO: {} GHz\nRSB: {} GHz\ncalibrated for: {}\n'.format(*self.Sidebands(),self.__SB)
            
        print(text + text2 + text3)
    
    
    #--------------------------------------------------------------------------    
    
    def save(self, fname, Force = False):
        """
        Save the calibration into a file.
    
        Parameters
        ----------
        fname : string
            The path and filename for where to save the file.
        Force : bool, optional
            Defines if an already existing file should be overwritten 
            (default: False).
    
        Returns
        -------
        nothing : None
    
        Notes
        -----
        First it is checked if a value for the frequency and the AWG frequency
        have been entered. Otherwise the calibration is not yet completed. Then
        the folder is search and created if needed. The file extension is then 
        set to '*.cal'. If a file with the given name already exists in this 
        directory and the parameter Force is True, then the existing file is
        overwritten.
    
        """
        
        import os
        import pickle
        
        if self.__frequency is None or self.__AWG_freq is None:
            print('Calibration not complete, impossible to save!\n')
            raise Exception('CALERR')
        
        
        #Split fname in folder and filename
        folder = os.path.split(fname)[0]
        file_name = os.path.split(fname)[1]

        #Create directory if not already existent
        if not os.path.exists(folder) and folder:
            os.makedirs(folder)

        # Check for file extension
        if file_name[-4:].lower() != '.cal':
            file_name += '.cal'

        # Append Folder and be adaptive to windows, etc.
        file_name = os.path.normpath(os.path.join(folder, file_name))

        # Check for Overwrite
        if not Force:
            if os.path.isfile(file_name):
                print('File already exists!\n')
                raise Exception('FILEEXISTSERR')
        
        with open(file_name, "wb") as f:
            pickle.dump(self, f, -1)


    #--------------------------------------------------------------------------

    def copy(self):
        """
        Copy this object.
    
        Parameters
        ----------
        none
    
        Returns
        -------
        nothing : None
    
        Notes
        -----
        Creates a deep copy of the given object.
    
        """
        
        import copy
        return copy.deepcopy(self)
 
##------------------------------------------------------------------------------------------------------------------------------


def load_calibration_file(filename):
    """
    Load a saved calibration from a given file.

    Parameters
    ----------
    filename : string
        The path and filename for the saved file.

    Returns
    -------
    nothing : None

    Notes
    -----
    The function checks if the given filename does exist before attempting to
    load the saved calibration.

    """
    
    import pickle,os
    
    if not os.path.exists(filename):
        print('Wrong path or file does not exist.\n')
        raise Exception('FILEEXISTSERR')
    
    with open(filename, 'rb') as f:
        return pickle.load(f)


##-------------------------------------------------------------------------------------------------------------------------------
class IQCalAM(object):
    version = '1.1.1'
    
    
    #----------------------------------------------------------------------------------------------------------------------------Initialization of the Class-----------------------
    
    def __init__(self, AWG, sgLOIP, sgLOch, SpecAna = 'SH', AWG_channel_cal_amplitude = 1., cal_file = None):
        """
        This object contains the calibration parameters of an IQAM.
        
        It is possible to initialize the parameters when initializing the 
        object or do it later with the proper functions.
        
        Parameters
        ----------
        AWG : object
            The AWG object providing the interaction with the AWG in use.
        sgLOIP : string
            The IP adress for the LO written in a string.
        sgLOch : int
            The channel of the LO used for the experiment.
        SpecAna : string, optional
            The spectrum analyzer used for the experiment (default: 'SH'). The 
            two options are:
            'SH':               Signal Hound
            'RS':               Rohde Schwarz
        AWG_channel_cal_amplitude : float, optional
            The amplitude for the AWG signal given in (V) (default: 1.).
        cal_file : string, optional
            The filepath to a saved calibration file (default: None).
        
        Notes
        -----
        If a calibration file is used, all the other parameters still have to 
        be initialized. Only the parameters of the CalibrationParameters class 
        are initialized.
        
        """
        
        if SpecAna.upper() == 'RS':
            from SPECAN import Specan
            self._SpecAna = Specan()  
        elif SpecAna.upper()=='SH':
            from SIGNALHOUND import SignalHound
            self._SpecAna = SignalHound()
        else:
            print('Wrong spectrum analyzer specified')
            raise Exception('SpecAnaERR')
        
        self._SpecAnaType = SpecAna.upper()
        self._AWG = AWG
        self._sgLOIP = sgLOIP
        self._sgLOch = sgLOch
        self._amplitude = AWG_channel_cal_amplitude                             # Amplitude of the AWG
        self.__cal_tol = 0.3                                                    #dB
        
        if cal_file is not None:
            self.calibration = load_calibration_file(cal_file)
        else:
            self.calibration = CalibrationParameters()
    
    
    
    #----------------------------------------------------------------------------------------------------------------------------Initialization of the instruments-----------------
    
    def set_AWG(self, AWG_freq, chI = 0, chQ = 1):
        """
        Set the values of the AWG using the methods provided from the 
        CalibrationParameters class.
    
        Parameters
        ----------
        AWG_freq : float
            The frequency for the AWG.
        chI : int, optional
            The channel for the I signal (default: 0).
        chQ : int, optional
            The channel for the Q signal (default: 1).
    
        Returns
        -------
        nothing : None
    
        """
        
        self.calibration.AWG_parameters(AWG_freq, chI, chQ)
        


    #--------------------------------------------------------------------------
    
    def set_frequency(self, frequency, SB = 'R'):
        """
        Set the up-mixed frequency for the experiment. It is possible to 
        specify the sideband that is calibrated.
    
        Parameters
        ----------
        frequency : float
            The calibrated frequency for the experiment. The value is given in 
            (GHz).
        SB : string, optional
            Defines which sideband is used for the calibration (default: 'R').
            The used convention is:
            'R' or 'r':         right
            'L' or 'l':         left
    
        Returns
        -------
        nothing: None
    
        """
        
        self.calibration.frequency(frequency, SB)



    #--------------------------------------------------------------------------
    
    def apply_corr(self):
        """
        Apply the values determined by the calibration to the AWG.
    
        Parameters
        ----------
        none : None
    
        Returns
        -------
        nothing: None
    
        """

        
        freq, chI, chQ = self.calibration.AWG_parameters()
        offI, offQ, amp_ratio, amp_channel, phase_corr = self.calibration.cal_par_list()
        
        self._AWG.mode(chI, 'sin')
        self._AWG.mode(chQ, 'sin')
        
        self._AWG.frequency(chI, freq)
        self._AWG.frequency(chQ, freq)
        
        self._AWG.modulation(chI, 0)
        self._AWG.modulation(chQ, 0)
        
        
        #off0, off1, amp,ph, amp_chan
        self._AWG.offset(chI, offI)
        self._AWG.offset(chQ, offQ)
        
        if amp_channel == chI:
            self._AWG.amplitude(chI, self._amplitude * amp_ratio)
            self._AWG.amplitude(chQ, self._amplitude)
        elif amp_channel == chQ:
            self._AWG.amplitude(chI, self._amplitude)
            self._AWG.amplitude(chQ, self._amplitude * amp_ratio)

        self._AWG.phase(chI, 0)
        self._AWG.phase(chQ, np.round(90 + phase_corr, 9) )
        
        self._AWG.set_channel(chI)
        self._AWG.set_channel(chQ)
        
        mask = (1<<chI)
        mask += (1<<chQ)
         
        self._AWG.phase_reset(mask)
        time.sleep(0.01)



    #--------------------------------------------------------------------------
    
    def set_LO(self, power = 13, channel = 1):
        """
        Apply the values determined by the calibration to the LO.
    
        Parameters
        ----------
        power : float, optional
            The power provided by the LO (default: 13). The value is given in 
            (dbm).
        channel : int, optional
            The channel of the LO (default: 1).
    
        Returns
        -------
        nothing: None
    
        """
        
        from SIGGEN import Siggen
        
        # Parameters
        LOfreq = self.calibration.Sidebands()[1]
        
        # LO setup
        sgLO = Siggen(self._sgLOIP)
        sgLO.pulse_triggered(0, 0, 0)
        sgLO.ALC('ON')
        sgLO.power(power, channel)
        sgLO.frequency(LOfreq, channel)
        sgLO.frequency_reference('EXT')
        sgLO.output(1, channel)
        sgLO.close()
        del sgLO


 
    #--------------------------------------------------------------------------
    
    def initialize_calibration(self, AWG_pulse, SB = 'R', *LO_para):
        """
        Initializes all the parameters for the calibration of the experiment. 
        
        Parameters
        ----------
        AWG_pulse : list: [awg_freq,awg_chI,awg_chQ]
            This list contains all the parameters for the calibration of the 
            I/Q mixer.
        SB : string, optional
            Defines which sideband is used for the calibration (default: 'R').
            The used convention is:
            'R' or 'r':         right
            'L' or 'l':         left
        LO_parameters : array, optional
            This array contains the parameters for the LO: [power,channel]
            power:              default to 13 dbm
            channel:            default to 1
        
        Returns
        -------
        nothing: None
        
        Notes
        -----
        If values for the LO are given, the first one is always used for the 
        power and the second one for the channel. It is possible to give zero, 
        one or two values for those parameters. Depending on the number of the 
        given values, the default values are used.
        
        """
        
        self.set_AWG(AWG_pulse.par['awg_freq'], 
                     AWG_pulse.par['awg_chan1'], 
                     AWG_pulse.par['awg_chan2'])
        self.set_frequency(AWG_pulse.frequency(), 
                           SB)
        self.apply_corr()
        
        if len(LO_para) == 0:
            power = 13
            channel = 1
        elif len(LO_para) == 1:
            power = LO_para[0]
            channel = 1
        else:
            power = LO_para[0]
            channel = LO_para[1]
        
        self.set_LO(power, channel)



    #----------------------------------------------------------------------------------------------------------------------------Measurement of the Sidebands----------------------
    
    def measure_SB(self, plot = False, print_diff = False, bands = 'ALL', *args):
        """
        Measure the power in the sidebands. 
        
        Parameters
        ----------
        plot : bool, optional
            This defines if the measured power should be plotted by one of two
            engines (default: False).
        print_diff : bool, optional
            This defines if the difference in power between the two sidebands 
            is to be printed (default: False).
        bands : string, optional
            This string sets which sidebands are to be measured (default: ALL):
            'ALL':              Measure all three peaks
            'R' or 'r':         Measure only the right sideband
            'C' or 'c':         Measure only the carrier
            'L' or 'l':         Measure only the left sideband
        *args : array, optional
            This array contains the parameters for the spectrum analyzer:
            averages:           default to 50
            peak_span:          default to 5 MHz
            Only the 'RS' spectrum analyzer can use both values. The 
            Signalhound only uses the peak_span variable.
        
        Returns
        -------
        Tuple: tuple
            The return value of this function is a tuple that always contains 
            three values, depending on which bands were measured:
            'ALL':              (max left peak, max center peak, max right peak)
            'R' or 'r':         (0, 0, max right peak)
            'C' or 'c':         (0, max center peak, 0)
            'L' or 'l':         (max left peak, 0, 0)
        
        Notes
        -----
        The parameter bands is only useful if the Signalhound is used. The 'RS'
        spectrum analyzer always measures the entire width of the sidebands.
        
        """
        
        if len(args) == 0:
            ave = 50
            peak_span = 5
        elif len(args) == 1:
            ave = args[0]
            peak_span = 5
        else:
            ave = args[0]
            peak_span = args[1]
        
        if self._SpecAnaType == 'RS':
            left, middle, right = self.__measure_SB_RS(ave, peak_span, plot)
        else:
            left, middle, right = self.__measure_SB_SH(peak_span, plot, bands)
        
        if print_diff:
            print("The difference between the sidebands is {0:.5f} dB".format(abs(right - left)))
        
        return left, middle, right
    

    def __measure_SB_SH(self, peak_span, plot, bands):
        """
        This function measures the power in the sidebands using a SignalHound. 
        It can be chosen which sideband is measured.
        
        """
        
        peak_span /= 1e3        
        
        # Set up the Spectrum Analyzer
        self._SpecAna.default_settings()
        self._SpecAna.Reference()
        self._SpecAna.ConfigLevel(-30)
        self._SpecAna.BandWidth(100e3)                                          # in Hz
        
        # Set the variables
        LSB = self.calibration.LSB()
        Carrier = self.calibration.carrier()
        RSB = self.calibration.RSB()
        
        #------------------------------------------------------        
        
        if bands == 'ALL':
            #Measure left Sideband
            self._SpecAna.CenterSpan(LSB, peak_span)
            self._SpecAna.Initiate()
            measL = self._SpecAna.GetSweep()
        
            #------------------------------------------------------
    
            #Measure Carrier
            self._SpecAna.CenterSpan(Carrier, peak_span)
            self._SpecAna.Initiate()
            measC = self._SpecAna.GetSweep()
            
            #------------------------------------------------------
    
            #Measure right Sideband
            self._SpecAna.CenterSpan(RSB, peak_span)
            self._SpecAna.Initiate()
            measR = self._SpecAna.GetSweep()
            
            #------------------------------------------------------
            if plot is True:
                measL.plot(engine = 'p')
                measC.plot(engine = 'p')
                measR.plot(engine = 'p')
                
                plt.xlim([measL.x[0] - peak_span, measR.x[-1] + peak_span])
                
                min_y = np.min((measL.y.min(), measC.y.min(), measR.y.min(), ))
                max_y = np.max((measL.y.max(), measC.y.max(), measR.y.max(), ))
                
                plt.ylim([min_y, max_y + 2])
            
            #------------------------------------------------------       
        
            #return data
            return measL.y.max(), measC.y.max(), measR.y.max()
            
        elif bands.upper() == 'L':
            #Measure left Sideband
            self._SpecAna.CenterSpan(LSB, peak_span)
            self._SpecAna.Initiate()
            measL = self._SpecAna.GetSweep()
            
            #------------------------------------------------------
            if plot is True:
                measL.plot(engine = 'p')
                
                plt.xlim([measL.x[0] - peak_span, measL.x[-1] + peak_span])
                
                min_y = measL.y.min()
                max_y = measL.y.max()
                
                plt.ylim([min_y, max_y + 2])
            
            #------------------------------------------------------       
        
            #return data
            return measL.y.max(), 0, 0
                
        elif bands.upper() == 'C':
            #Measure Carrier
            self._SpecAna.CenterSpan(Carrier, peak_span)
            self._SpecAna.Initiate()
            measC = self._SpecAna.GetSweep()
            
            #------------------------------------------------------
            if plot is True:
                measC.plot(engine = 'p')
                
                plt.xlim([measC.x[0] - peak_span, measC.x[-1] + peak_span])
                
                min_y = measC.y.min()
                max_y = measC.y.max()
                
                plt.ylim([min_y, max_y + 2])
            
            #------------------------------------------------------       
        
            #return data
            return 0, measC.y.max(), 0
            
        elif bands.upper() == 'R':
            #Measure right Sideband
            self._SpecAna.CenterSpan(RSB, peak_span)
            self._SpecAna.Initiate()
            measR = self._SpecAna.GetSweep()
            
            #------------------------------------------------------
            if plot is True:
                measR.plot(engine = 'p')
                
                plt.xlim([measR.x[0] - peak_span, measR.x[-1] + peak_span])
                
                min_y = measR.y.min()
                max_y = measR.y.max()
                
                plt.ylim([min_y, max_y + 2])
            
            #------------------------------------------------------       
        
            #return data
            return 0, 0, measR.y.max()
            
            

        





    def __measure_SB_RS(self, ave, peaks_span, plot):
        """
        This function measures the power in the sidebands using the Rohde Schwarz
        spectrum analyzer.
        
        """
        
        import DataModule as dm
        import time
        
        # Set the variables
        peaks_span /= 1e3                                                       #MHz -> GHz
        LSB = self.calibration.LSB()
        carrier = self.calibration.carrier()
        RSB = self.calibration.RSB()
        AWG_freq = self.calibration.AWG_parameters()[0]
        
        # Initialize the spectrum analyzer
        self._SpecAna.Center(carrier)
        self._SpecAna.Span(2.5*AWG_freq)
        self._SpecAna.Averages(1, ave)
        self._SpecAna.Single()
        
    
        
        # Start the spectrum analyzer
        self._SpecAna.Run()
        time.sleep(0.001)
        while self._SpecAna.Count() < ave:
            time.sleep(0.0001)
        
        # Completing the measurement
        x, y = self._SpecAna.Read()