barsukov 1.3.3__py3-none-any.whl → 1.3.4__py3-none-any.whl

barsukov/data/fft.py

@@ -1,68 +1,114 @@
-### BEGIN Dependencies ###
 import numpy as np
-import scipy as sp
-from barsukov.logger import debug    # Un-comment before implementing in pip
-### END Dependencies ###
 
 
-def fft(x, y, equidistant_check=True, equidistant_rel_error=1e-4, remove_negative_f=False, inverse=False):
-    ### Takes: x=list of real floats, y=list of data or list of lists of data. Data can be real or complex.
-    ### Returns: freqs, fft_y_norm, msg
-    ### This fft used to give wrong sign of the imaginary component because of the "wrong" definition of fft in np and sp
-    ### Now it has been corrected to the Mathematica definition of fft = int ... exp(2pi f t)
-    msg = ''
+def fft(x, y, equidistant_check=True, equidistant_rel_error=1e-4, remove_negative_f=False, mathematica_convention=False, inverse=False):
+    """
+    Perform Fast Fourier Transform (FFT) or Inverse FFT on one-dimensional or multi-dimensional data,
+    with optional handling for non-equidistant sampling, mandatory normalization to continuous Fourier definition.
+    Allows for +- in exp for scientific and engineering definition for Fourier Transform.
+
+    Parameters
+    ----------
+    x (array_like): 
+        The time or spatial domain axis (1D array). Must be increasing, doesn't need to be equidistant.
+    y (array_like): 
+        The signal to be transformed. Can be 1D or 2D array (if 2D, the FFT is applied along axis 1).
+    equidistant_check (bool, optional): 
+        If True (default), checks whether `x` is uniformly spaced. If not, interpolates to uniform spacing.
+    equidistant_rel_error : float, optional
+        Relative tolerance for equidistant spacing check. Default is 1e-4.
+    remove_negative_f : bool, optional
+        If True, removes negative frequencies from output. Default is False.
+    mathematica_convention : bool, optional
+        If True, uses Mathematica-style conventions: forward Fourier ~ exp(i2pift).
+        If False (default), uses NumPy convention: forward Fourier ~ exp(-i2pift)
+    inverse : bool, optional
+        If True, computes the inverse FFT. Default is False (forward transform).
+
+    Returns
+    -------
+    fft_x : ndarray
+        Ordered frequency domain axis corresponding to the transformed data (negative frequencies can be removed if remove_negative_f is True).
+        Ordered time domain axis if inverse is True (time axis starts at 0).
+    fft_y : ndarray
+        Transformed signal. Shape matches `y`.
+
+    Notes
+    -----
+    - The function supports both real and complex-valued input `y`.
+    - If `x` is not equidistant and `equidistant_check=True`, the function interpolates `y` using `make_equidistant`.
+
+    Examples
+    --------
+    >>> t = np.linspace(0, 1, 1000)
+    >>> y = np.sin(2 * np.pi * 50 * t)
+    >>> f, Y = fft(t, y)
+
+    >>> # Inverse transform
+    >>> t_rec, y_rec = fft(f, Y, inverse=True)
+    """
+
+    x, y = np.array(x), np.array(y)
+
+    # Handle non-equidistant input
     if equidistant_check:
         diffs = np.diff(x)
         if not np.allclose(diffs, diffs[0], rtol=equidistant_rel_error):
             # x is not equidistant, must start interpolating
-            x,y = make_equidistant(x, y, step=None)
-            y = y.T
-            msg += debug('fft(x,y) made x,y equidistant.')
-
-    y = np.array(y)
-    #print(y)
+            x, y = make_equidistant(x, y, step=None)
 
+    # Determine shape and axis
     if y.ndim == 1:
-        # y is 1D, treat it as a single column
-        n = len(y)  # Number of points in the column
-        if inverse is False: fft_y = np.fft.ifft(y) * n # np fft has the "wrong" imag sign
-        else: fft_y = np.fft.fft(y) # That's why fft and ifft are inverted in this code
+        n, axis = len(y), -1
+    else:
+        n, axis = y.shape[1], 1
+
+    #Determine Convention
+    if mathematica_convention is False:
+        fft_func, fft_norm = np.fft.fft, "backward"
+        ifft_func, ifft_norm = np.fft.ifft, "forward"
     else:
-        # y is 2D, treat it as multiple columns
-        n = y.shape[1]  # Number of points in each column
-        if inverse is False: fft_y = np.fft.ifft(y, axis=1) * n # np fft has the "wrong" imag sign
-        else: fft_y = np.fft.fft(y, axis=1) # That's why fft and ifft are inverted in this code
-
-    sample_spacing = ( x[-1] - x[0] ) / (n-1)
-    #print(n, sample_spacing, x[1] - x[0])
-    fft_y_norm = fft_y * sample_spacing # This normalizes FFT to mathematically correct
-    freqs = np.fft.fftfreq(n, d=sample_spacing)
-
-    if remove_negative_f is False:
-        sorted_indices = np.argsort(freqs)
-        freqs = freqs[sorted_indices]
-        if isinstance(fft_y_norm[0], (list, np.ndarray)):  # If fft_y_norm contains multiple columns
-            fft_y_norm = [x[sorted_indices] for x in fft_y_norm]
-        else:  # If fft_y_norm is a single column
-            fft_y_norm = fft_y_norm[sorted_indices]
-        msg += debug('fft(x,y) sorted negative and positive frequencies.')
+        fft_func, fft_norm = np.fft.ifft, "forward"
+        ifft_func, ifft_norm = np.fft.fft, "backward"
+
+    # Compute FFT and normalize
+    sample_spacing = (x[-1] - x[0]) / (n-1.0)
+
+    if inverse is True:
+        y = np.fft.ifftshift(y, axes=axis) # Reorder y to match np.fft.ifft convention
+        fft_x = np.arange(0, n) / (n * sample_spacing) # Time domain creation
+        fft_y = ifft_func(y, axis=axis, norm=ifft_norm) * sample_spacing # Sample Spacing is the Fourier consistent normalization
     else:
-        mask = freqs >= 0 # Boolean array with Falses for negative frequencies, effectively removing them
-        freqs = freqs[mask]
-        # If fft_y_norm contains multiple columns:
-        if isinstance(fft_y_norm[0], (list, np.ndarray)):
-            fft_y_norm = [x[mask] for x in fft_y_norm]
-        else:  # If fft_y_norm is a single column
-            fft_y_norm = fft_y_norm[mask]
-        msg += debug('fft(x,y) removed negative frequencies.')
+        fft_x = np.fft.fftfreq(n, d=sample_spacing) # Frequency domain creation
+        fft_y = fft_func(y, axis=axis, norm=fft_norm) * sample_spacing
+        fft_x, fft_y = np.fft.fftshift(fft_x), np.fft.fftshift(fft_y, axes=axis) # Reorder x, y for plotting
+
+    # Remove negative frequencies
+    if remove_negative_f is True:
+        mask = fft_x >= 0
+        fft_x = fft_x[mask]
+        if y.ndim == 1:
+            fft_y = fft_y[mask]
+        else:
+            fft_y = fft_y[:, mask]
+
+    return fft_x, fft_y
+
+# NOTES For Developer:
+        # Mathematica has convention exp(i*2pi*t)
+        # np.fft.fft takes x input -3,-2,-1,0,1,2,3 and np.fft.ifft takes x input 0,1,2,3,-3,-2,-1
+        # Our fft(np.fft.ifft) takes x input -3,-2,-1,0,1,2,3 and our ifft(np.fft.fft) takes x input 0,1,2,3,-3,-2,-1
+        # Numpy outputs in 0,1,2,3,-3,-2,-1 order, our function sorts to -3,-2,-1,0,1,2,3
+
+        #Tested with Lorentzian, Gaussian, and Rectangular Signals
+
+def ifft(x, y, equidistant_check=True, equidistant_rel_error=1e-4, remove_negative_f=False, mathematica_convention=False):
+    return fft(x, y, equidistant_check=equidistant_check, equidistant_rel_error=equidistant_rel_error, remove_negative_f=remove_negative_f, mathematica_convention=mathematica_convention, inverse=True)
 
-    msg += debug('freqs, fft_y_norm, msg = fft(x,y) is done.\nThe forward fft approximates the mathematically correct integral over ...exp(+i2pift).\nNow do not forget to apply np.abs(fft_y_norm), np.angle(fft_y_norm), fft_y_norm.real, fft_y_norm.imag')
-    return freqs, fft_y_norm, msg
 
-def ifft(x, y, equidistant_check=True, equidistant_rel_error=1e-4, remove_negative_f=False):
-    return fft(x, y, equidistant_check=equidistant_check, equidistant_rel_error=equidistant_rel_error, remove_negative_f=remove_negative_f, inverse=True)
 
 def make_equidistant(x, y, step=None):
+    import scipy.interpolate as sp
     ### Takes one column x and one or more columns y and makes them equidistant in x
     ### Returns new_x, new_y. The number of points will likely change.
     if step is None:
@@ -70,18 +116,17 @@ def make_equidistant(x, y, step=None):
         min_step = np.min(np.diff(x))
     else:
         min_step = step
-    
+
     # Generate the new equidistant x array
     new_x = np.arange(x[0], x[-1] + min_step, min_step)
-    
+
     if isinstance(y[0], (list, np.ndarray)):  # If y contains multiple columns
         new_y = []
         for y_column in y:
             interpolation_function = sp.interpolate.interp1d(x, y_column, kind='linear', fill_value='extrapolate')
             new_y.append(interpolation_function(new_x))
-        new_y = np.array(new_y).T  # Transpose to match the original structure
     else:  # If y is a single column
         interpolation_function = sp.interpolate.interp1d(x, y, kind='linear', fill_value='extrapolate')
         new_y = interpolation_function(new_x)
-    
-    return new_x, new_y
+
+    return np.array(new_x), np.array(new_y)

barsukov/data/noise.py

@@ -0,0 +1,276 @@
+import numpy as np
+
+K_b = 1.380649e-23
+q = 1.602176634e-19
+
+def johnson(time_arr, T, R):
+    #CHECKED
+    """
+    Generates Johnson-Nyquist noise voltage signal in the time domain, for a given time array.
+
+    Parameters:
+    time_arr (array-like): Array of ordered time values in Seconds (assumed to be evenly spaced).
+    T (float): Temperature in Kelvin.
+    R (float): Resistance in Ohms.
+
+    Returns:
+    np.ndarray: Array of normally distributed noise values with RMS amplitude corresponding to the thermal noise voltage.
+    """
+    size = len(time_arr)
+    Df = 0.5 * (size - 1) / (time_arr[-1] - time_arr[0]) # Nyquist Frequency is this correct. Becomes noise's bandwidth
+    # Nyquist Frequency used for bandwidth as it is the maximum resolvable frequency that can be detected. Generating noise purely by itself, before any filtering is being simulated. 
+
+    V_rms = np.sqrt(4 * K_b * T * R * Df)
+    return np.random.normal(0, V_rms, size)
+
+def shot(time_arr, I, R):
+    #CHECKED
+    """
+    Generates Shot noise voltage signal in the time domain, for a given time array.
+
+    Parameters:
+    time_arr (array-like): Array of ordered time values in Seconds (assumed to be evenly spaced).
+    I (float): Current in Amperes.
+    R (float): Resistance in Ohms.
+
+    Returns:
+    np.ndarray: Array of normally distributed voltage noise values with RMS amplitude corresponding to shot noise.
+
+    Note:
+    Ideally, shot noise follows a Poisson distribution, but for large mean values (lambda), the Poisson distribution approximates a normal distribution.
+    """
+    
+    size = len(time_arr)
+    Df = 0.5 * (size - 1) / (time_arr[-1] - time_arr[0])
+
+    I_rms = np.sqrt(2 * q * I * Df) # Shot noise current
+    V_rms = R * I_rms # Recalculating to Shot noise voltage
+    return np.random.normal(0, V_rms, size) #poisson should be used, but lamda is too large for np.random.poisson
+
+def color(time_arr, V_rms, exponent=1):
+    """
+    Generates 1/f^(exponent) noise (pink noise by default, exp=1) in the time domain.
+
+    Parameters:
+    time_arr (array-like): Array of ordered time values in Seconds (assumed to be evenly spaced).
+    V_rms (float): RMS value of the generated noise.
+    exponent (float, optional): Power of the frequency dependence. Default is 1, which gives 1/f noise (pink noise). Set to 0 for white noise, 2 for brown noise, etc...
+
+    Returns:
+    np.ndarray: Array of noise values with PSD proportional to 1/f^(exponent).
+    """
+    #Generate Guassian White Noise in time domain
+    size = len(time_arr)
+    dt = (time_arr[-1] - time_arr[0]) / (size-1.0)
+    white = np.random.standard_normal(size)
+
+    #Fourier Transform to Frequency Domain
+    freqs = np.fft.rfftfreq(size, d=dt)
+    fft = np.fft.rfft(white, norm='backward') * dt
+
+    #Scale Fourier Transform by 1/f^(exponent/2) for 1/f^exponent PSD (psd proportional to fft^2) 
+    freqs[0] = freqs[1] #Avoid division by zero
+    fft = fft / (freqs**(exponent*0.5))
+
+    #Convert back to time domain
+    ifft = (np.fft.irfft(fft, n=size, norm='forward') / dt).real
+    ifft_rms = np.sqrt(np.mean(ifft**2))
+
+    return V_rms * ifft / ifft_rms #Ensure V_rms is as specified
+
+
+def rtn(time_arr, tau_up, tau_down, state_up=1, state_down=0, initial_state=None):
+    """
+    Generate random telegraph noise on a user-supplied time array.
+
+    Parameters:
+        time_arr (np.ndarray): Array of ordered time values in Seconds (assumed to be evenly spaced).
+        tau_up (float): Mean dwell time in the 'up' state.
+        tau_down (float): Mean dwell time in the 'down' state.
+        state_up (float): Value of the up state (default: 1).
+        state_down (float): Value of the down state (default: 0).
+        initial_state (float): Value of the first state (default: None = random(up, down))
+
+    Returns:
+        signal (np.ndarray): RTN signal array, same shape as time_arr.
+
+    Notes:
+    - PSD of RTN will have lorentzian profile: S(f) = 4*A^2*tau / (1 + (2pi*f*tau)^2), 
+    with correlation time: tau = tau_up*tau_down / (tau_up+tau_down)
+    - Characteristic (roll-off) frequency corresponds to 1 / (2pi*tau)
+    """
+    if tau_up <= 0 or tau_down <= 0:
+        raise ValueError("tau_up and tau_down must be positive to avoid infinite loops.")
+
+    time_arr = np.asarray(time_arr)
+    signal = np.zeros_like(time_arr)
+
+    if initial_state is None:
+        current_state = np.random.choice([state_up,state_down])
+    else: current_state = initial_state
+
+    current_time = time_arr[0]
+    i = 0
+
+    while i < len(time_arr):
+        # Sample dwell time
+        dwell_time = np.random.exponential(tau_up if current_state == state_up else tau_down)
+        dwell_end_time = current_time + dwell_time
+
+        # Assign current state until dwell time is over
+        while i < len(time_arr) and time_arr[i] < dwell_end_time:
+            signal[i] = current_state
+            i += 1
+
+        # Flip state
+        current_time = dwell_end_time
+        current_state = state_down if current_state == state_up else state_up
+
+    return signal
+
+
+def bit(signal_arr, bit_depth, measure_min, measure_max, noise_only = False):
+    """
+    Quantize an analog signal to simulate ADC behavior with given bit depth.
+
+    Parameters:
+    signal_arr (array-like): Input analog signal values.
+    bit_depth (int): number of bits used in quantization (e.g., 8, 12, 16).
+    measure_min (float): Minimum measurable value of the ADC range.
+    measure_max (float): Maximum measurable value of the ADC range.
+    noise_only (bool, optional): If True, quantization noise only. If False (default), return the quantized signal.
+
+    Returns:
+    np.ndarray: Quantized signal or Quantization noise, depending on 'noise_only'.
+
+    Notes:
+    - The signal is clipped to the measurement range before quantization.
+    - The number of quantization levels is 2^bit_depth.
+    """
+    levels = int(2**int(bit_depth)) # 1<<int(bit_depth)
+    quantization_step = (measure_max - measure_min) / (levels - 1)
+
+    signal_clipped = np.clip(signal_arr, measure_min, measure_max)
+    quantized_signal = np.round((signal_clipped - measure_min) / quantization_step) * quantization_step + measure_min
+
+    if noise_only is False:
+        return quantized_signal
+    else:
+        return quantized_signal - signal_arr
+
+
+def psd(time_arr, signal_arr, return_onesided=True):
+    """
+    Computes the Power Spectral Density (PSD) of a time-domain signal using Welch's method.
+
+    Parameters:
+    time_arr (array-like): Ordered time values in Seconds (assumed to be increasing).
+    signal_arr (array-like): Signal values as a function of time.
+
+    Returns:
+    tuple:
+        - f_welch (np.ndarray): Array of frequency values corresponding to the PSD.
+        - psd_welch (np.ndarray): Power Spectral Density values in (signal_unit)^2/Hz.
+        - msg (str): Message describing the PSD normalization and units.
+
+    Notes:
+    - Welch's method averages overlapping FFTs to reduce variance in the PSD estimate.
+    - The RMS value of the signal over a bandwidth B can be computed from the PSD as:
+        V_rms = sqrt( ∫ PSD(f) df ) over bandwidth.
+    - The PSD values follow the convention:
+        mean(PSD) ≈ 2 × (b.fft)^2 / total duration
+    -When dealing with real signals, (one sided, only positive frequencies) the relationship is psd = np.abs(fft)**2 / total_time * 2, where factor of 2 is applied everywhere except at the DC and Nyquist bins. When dealing with complex signals (positive and negative) the relationship is psd = np.abs(fft)**2 / total_time.
+    """
+    from scipy import signal as sp_signal
+    #make equidistant
+    size = len(time_arr)
+    sampling_freq = (size-1) / (time_arr[-1] - time_arr[0])
+
+    f_welch, psd_welch = sp_signal.welch(signal_arr, sampling_freq, nperseg=min(size, 4024), return_onesided=return_onesided)
+    return f_welch, psd_welch
+
+def noise_help(noise):
+    import matplotlib.pyplot as plt
+
+    doc = {}
+
+    if noise == "johnson":
+        time = np.arange(0,100)
+
+        doc = {
+            "name": "Johnson Noise",
+            "time": time,
+            "function": johnson,
+            "params": [300, 200],
+            "text_title_size": 20,
+            "text_midbreak_size": 15,
+            "text_main_size": 10,
+            "text_bullet_size": 10,
+            "text_title_x": .5,
+            "text_title_y": 9,
+            "text_main_x": .3,
+            "text_main_y": 8,
+        }
+        
+    if noise == "johnson2":
+        time = np.arange(0,100)
+
+        doc = {
+            "name": "Johnson Noise",
+            "time": time,
+            "function": johnson,
+            "params": [300, 200],
+            "text_title_size": 20,
+            "text_midbreak_size": 15,
+            "text_main_size": 10,
+            "text_bullet_size": 10,
+            "text_title_x": .5,
+            "text_title_y": 9,
+            "text_main_x": .3,
+            "text_main_y": 6,
+        }
+
+    if noise == "shot":
+        time = np.arange(0,100)
+
+        doc = {
+            "name": "Shot Noise",
+            "time": time,
+            "function": shot,
+            "params": [1, 200],
+            "text_title_size": 30,
+            "text_midbreak_size": 15,
+            "text_main_size": 15,
+            "text_bullet_size":10,
+            "text_title_x": .5,
+            "text_title_y": 9,
+            "text_main_x": .5,
+            "text_main_y": 8,
+        }
+
+        
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(22,7))
+    fig.suptitle(doc["name"], fontsize=20)
+    ax1.plot(doc["time"], doc["function"](doc["time"], *doc["params"]), 'red', label='(t^2)*exp(-(t^2))')
+
+
+    ax1.set(title="2 lines chart", xlabel="t", ylabel="y")
+    ax1.legend(loc="upper right")
+
+
+    # Set both x- and y-axis limits to [0, 10] instead of default [0, 1]
+
+
+    ax2.axis([0, 10, 0, 10])
+    ax2.tick_params(axis='x', colors='white')
+    ax2.tick_params(axis='y', colors='white')
+
+    ax2.text(doc["text_title_x"], doc["text_title_y"], doc["name"], weight='bold', fontsize=doc["text_title_size"],
+             bbox={'facecolor': 'red', 'alpha': 0.3, 'pad': 10})
+    ax2.text(doc["text_main_x"], doc["text_main_y"], doc["function"].__doc__, wrap="false", fontsize=doc["text_main_size"])
+
+
+    #use for bullet points#ax2.text(0.5, 5.5, 'Topic 2', weight='bold', fontsize=doc["text_midbreak_size"])
+    #use for bullet points#ax2.text(0.5, 4.5, '- Bullet pont 1\n- Bullet point 2', fontsize= doc["text_bullet_size"])
+
+    #use to display function # ax2.text(2, 3, r'a function to plot: $t^2*exp(-t^2)$', fontsize=12)

barsukov/exp/__init__.py

@@ -1 +1,3 @@
 from . import mwHP
+
+from . import smKE

barsukov/exp/mwHP.py

@@ -55,6 +55,8 @@ class mwHP:
         log_in_eq(self, msg, log=log)
 ### END These functions could be shared across all equipment.
 
+
+### BEGIN: mwHP Functions:
     def output(self, state=None, log=None, check=False):
     ### Always has a return! Which is the state of Output.
     ### output() reads and returns the state of Output.
@@ -231,6 +233,7 @@ class mwHP:
             if abs(dutyreal - duty) < 0.03*float(duty): self.log(f'Writing Pulse duty cycle as {dutyreal}.', log=log)
             else: self.log(f'Warning:Writing Pulse duty cycle as {dutyreal}, but was asked {duty}.', log='important')
             return freal, dutyreal
+### END: mwHP Functions:
 
 
 ### BEGIN: OBJ2FILE Tools
@@ -241,8 +244,10 @@ class mwHP:
         seriable_data = self.__dict__.copy()
         # take the attributes of unseriable data
         if self.script is None: 
-            seriable_data['logger'] == 'needsrebuild'
-            seriable_data['logger_information'] = self.logger.__getargs__()
+            if self.logger is not None:
+                seriable_data['logger'] == 'needsrebuild'
+                seriable_data['logger_information'] = self.logger.__getargs__()
+                seriable_data['logger_information']['start_file'] = False
         else:
             seriable_data['script'] == 'needsrebuild'
             seriable_data['script_information'] = self.script.__getstate__()
@@ -259,5 +264,9 @@ class mwHP:
             self.script = Script(**seriable_data['script_information'])
         if self.logger == 'needsrebuild':
             self.logger = Logger(**seriable_data['logger_information'])
+        if (self.script is not None):
+            self.log(f'I am using Script saved in memory: {self.script.folder_name}.', log='screen')
+        elif (self.logger is not None):
+            self.log(f'I am using Logger saved in memory: {self.logger.description}.', log='screen')
         eq_reconnect(self)
 ### END: OBJ2FILE Tools

barsukov/exp/smKE.py

@@ -0,0 +1,148 @@
+### BEGIN Dependencies ###
+import numpy as np
+import sys
+from barsukov.exp.exp_utils import *
+### END Dependencies
+
+
+class smKE:
+    def __init__(self, gpib=None, visa_rm=None, logger=None, gpib_card=0, log='default', script=None):
+        # Pass the Script object, if available.
+        # If Script has no visa_rm or if no Script is passed, you'll need to pass the visa_rm=visa.ResourceManager manually.
+        # If Script has no logger or if no Script is passed, you can pass the logger manually.
+        # If no logger is passed, will simply print to screen.
+        # Change log from 'default' to 'screen', 'file', 'both', 'no'.
+        # gpib_card is per default 0. You can change, if you have multiple.
+
+        self.script = script
+        self.logger = logger
+        self.eq_default_log = log
+        self.rm = visa_rm
+        self.gpib_card = gpib_card
+        self.gpib = gpib
+
+        self.msg_deco = f'[smKE {self.gpib_card}::{self.gpib}]'
+        self.eq = initialize_gpib(self) # This will initialize self.eq = visa.open_resource()
+        self.log( f'Initialized: {self.identify()}', log='important' ) # This is the 'welcome message' and a check if communication works.
+        
+        # Digits, x_Min, x_Max, Range_min, Range_max, units, function
+        self.I_params = [10, -1.05, 1.05, 1e-6, 1, 'A', 'curr']
+        self.V_params = [10, -210.0, 210.0, 0, 210.0, 'V', 'volt'] #digits and range undetermined
+        self.R_params = [10, 0.0, 2.1e8, 'R'] #digits undetermined
+
+### BEGIN The definition of the following functions may be specific to this equipment.
+    def query(self, cmd):
+        return self.eq.query(cmd)
+
+    def write(self, cmd):
+        return self.eq.write(cmd)
+
+    def identify(self):
+        return str(self.eq.query('*IDN?'))
+### END The definition of the following functions may be specific to this equipment.
+    def disconnect(self):
+        eq_disconnect(self)
+
+    def reconnect(self):
+        eq_reconnect(self)
+
+    def log(self, msg, log=None):
+        if log is None: log=self.eq_default_log
+        log_in_eq(self, msg, log=log)
+### END These functions could be shared across all equipment.\
+
+    def source(self, function=None, scale=None, level=None, cmpl_scale=None, cmpl_level=None, log=None):
+        if log is None: log=self.eq_default_log
+        if function is None:
+            try:
+                f = self.eq.query('sour:func?')
+                f = str(f)[:-1]
+
+                s = self.eq.query(f'sour:{f}:rang?')
+                s = float(s) / 1.05
+                exp = np.floor(np.log10(abs(s)))
+                s = np.ceil(s / 10**exp) * 10**exp
+
+                l = self.eq.query(f'sour:{f}:lev?')
+                l = float(l)
+
+                if f == 'CURR': source_param, compliance_param = self.I_params, self.V_params
+                if f == 'VOLT': source_param, compliance_param = self.V_params, self.I_params
+
+                cs = self.eq.query(f'sens:{source_param[6]}:rang?')
+                cs = float(cs)
+
+                cl = self.eq.query(f'sens:{source_param[6]}:prot?')
+                cl = float(cl)
+
+                self.log(f'Source function is {f}, scale is {s} {source_param[5]}, level is {l} {source_param[5]}. Compliance scale is {cs} {compliance_param[5]}, level is {cl} {compliance_param[5]}')
+                return f, s, l, cs, cl
+
+            except:
+                self.log(f'Error while reading source function.', log='important')
+                return np.nan
+        else:
+            if (function == 'curr') or (function == 'current'): source_param, compliance_param = self.I_params, self.V_params
+            else: source_param, compliance_param,  = self.V_params, self.I_params
+            try:
+                if level > scale: level = scale #level must be equal to or less than scale
+                if cmpl_level > cmpl_scale: cmpl_level = cmpl_scale
+
+                f = source_param[6]
+                self.eq.write(f'sour:func {f}')
+                self.eq.write(f'sour:{f}:mode fix')
+
+                s = max(source_param[3], min(float(scale), source_param[4]))
+                self.eq.write(f'sour:{f}:rang {s}')
+
+                l = max(source_param[1], min(float(level), source_param[2]))
+                self.eq.write(f'sour:{f}:lev {l}')
+
+                cs = max(compliance_param[3], min(float(cmpl_scale), compliace_param[4]))
+                self.eq.write(f'sens:{compliance_param[6]}rang:auto off')
+                self.eq.write(f'sens:{compliance_param[6]}:rang: {cs}')
+
+                cl = max(compliance_param[1], min(float(cmpl_level), compliance_param[2]))
+                self.eq.write(f'sens:{compliance_param[6]}:prot:rsyn on')
+                self.eq.write(f'sens:{compliance_param[6]}:prot {cmpl_level}')
+
+                freal, sreal, lreal, csreal, clreal = self.source()
+                return freal, sreal, lreal, csreal, clreal
+
+            except:
+                self.log(f'Error while changing Source.', log='important')
+                return np.nan
+
+    def measure(self, function=None, four_wire=None, res_mode=None, res_guard=None, res_compensation=None, log=None):
+        if log is None: log=self.eq_default_log
+        if function is None:
+            try:
+                f = self.eq.query('sens:func?')
+                f = str(f)[:-1]
+
+                ws = self.eq.query('syst:rsen?')
+                ws = float(ws)
+                if ws: ws = 'on'
+                else: ws = 'off'
+
+                #self.log(f'Measure function
+
+                if 'RES' in f:
+                    rm = self.eq.query('res:mode?')
+                    rm = str(f)[:-1]
+
+                    rg = self.eq.query('syst:guard?')
+                    rg = str(f)[:-1]
+
+                    rc = self.eq.query('res:ocom?')
+                    if ws: ws = 'on'
+                    else: ws = 'off'
+
+            except:
+                return 0
+
+        self.eq.write(f'sens:func:off:all')
+        self.eq.write(f'sens:func:on "{function}"')
+        self.eq.write(f'{function}:mode {source}')
+        self.eq.write(f'syst:rsen {sense_mode}')
+        self.eq.write(f'syst:guard {guard}')