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

barsukov/data/lock_in_emulator_app.py

@@ -0,0 +1,297 @@
+from PyQt5 import QtWidgets
+import pyqtgraph as pg
+import numpy as np
+import sys
+
+from barsukov.data import Lock_in_emulator, noise
+
+def make_lorentzian(center, HW, amp):
+    def l(x):
+        return amp / ((x - center)**2 + HW**2)
+    return l
+
+def make_antilorentzian(center, HW, amp):
+    def al(x):
+        return amp * (x - center) / np.abs(HW) / (1 + ( (x - center) / HW)**2)
+    return al
+
+params = [
+    ("l_center", 2, "Center:", float),
+    ("l_HW", 1, "HW:", float),
+    ("l_amp", 1e-6, "Amplitude:", float),
+    ("al_center", 4, "Center:", float),
+    ("al_HW", 2, "HW:", float),
+    ("al_amp", 2e-6, "Amplitude:", float),
+    ("jT", 300, "Temperature (K):", float),
+    ("jR", 200, "Resistance (Ohms):", float),
+    ("sI", 1e-3, "Current (Amps):", float),
+    ("sR", 200, "Resistance (Ohms):", float),
+    ("oRMS", 1e-7, "RMS:", float),
+    ("rTU", 0.01, "Tau Up (s):", float),
+    ("rTD", 0.01, "Tau Down (s):", float),
+    ("rSU", 1e-7, "State Up:", float),
+    ("rSD", 1e-7, "State Down:", float),
+    ("bD", 64, "Bit Depth (bits):", int),
+    ("bMIN", -21, "Minimum Measurement:", float),
+    ("bMAX", 21, "Maximum Measurement:", float),
+    ("xstart_input", 0, "X Start:", float),
+    ("plotpoints_input", 500, "# Plot Points:", int),
+    ("time_input", 120, "Sweep Time (s):", float),
+    ("xstop_input", 10, "X Stop:", float),
+    ("xamp_input", 0.2, "Modulation Amp:", float),
+    ("f_input", 1000, "Modulation Freq (Hz):", float),
+    ("TC_input", 500e-3, "Time Constant (s):", float),
+    ("order_input", 4, "Filter Order:", int),
+    ("dt_input", 1e-4, "Sampling Step (s):", float),
+    ("buffersize_input", 10000, "Buffer Size:", int),
+    ("phase_input", 0, "Phase Offset (deg):", float),
+]
+
+class MyWindow(QtWidgets.QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Lock-in Amplifier Emulator")
+        self.resize(1000, 800)
+
+        #Window Area (horizontal)
+        main_layout = QtWidgets.QHBoxLayout(self)
+        self.inputs = {} # (widget, cast, method)
+        self.line_edits = {}
+
+        #Interactive Input Box Setup
+        for name, default, label, cast in params:
+            le = QtWidgets.QLineEdit(str(default))
+            #le.editingFinished.connect(self.update_plot)
+            self.line_edits[name] = le
+            self.inputs[name] = (le, lambda w=le, c=cast: c(w.text()))
+
+#Left Area:
+        left_layout = QtWidgets.QVBoxLayout()
+        main_layout.addLayout(left_layout, 1)
+
+        # Signal Type Selector
+        signal_combo = QtWidgets.QComboBox()
+        signal_combo.addItems(["Lorentzian", "Anti-Lorentzian"])
+        #signal_combo.currentIndexChanged.connect(self.update_plot)
+        self.inputs["signal_type"] = (signal_combo, lambda w: str(w.currentText()))
+        left_layout.addWidget(QtWidgets.QLabel("<b>Signal Type:</b>"))
+        left_layout.addWidget(signal_combo)
+
+        # Signal Inputs Stack
+        signal_stack = QtWidgets.QStackedWidget()
+        left_layout.addWidget(signal_stack)
+
+        #Lorentzian Inputs
+        lorentz_widget = QtWidgets.QWidget()
+        lorentz_layout = QtWidgets.QFormLayout(lorentz_widget)
+        lorentz_layout.addRow("<b>Center:</b>", self.line_edits["l_center"])
+        lorentz_layout.addRow("<b>HW:</b>", self.line_edits["l_HW"])
+        lorentz_layout.addRow("<b>Amplitude:</b>", self.line_edits["l_amp"])
+        signal_stack.addWidget(lorentz_widget)
+
+        #Guassian Inputs
+        antilorentz_widget = QtWidgets.QWidget()
+        antilorentz_layout = QtWidgets.QFormLayout(antilorentz_widget)
+        antilorentz_layout.addRow("<b>Center:</b>", self.line_edits["al_center"])
+        antilorentz_layout.addRow("<b>HW:</b>", self.line_edits["al_HW"])
+        antilorentz_layout.addRow("<b>Amplitude:</b>", self.line_edits["al_amp"])
+        signal_stack.addWidget(antilorentz_widget)
+
+        signal_combo.currentIndexChanged.connect(signal_stack.setCurrentIndex)
+
+        #Noise Options:
+        left_layout.addWidget(QtWidgets.QLabel("<b>Noise Options:</b>"))
+
+        noises = [
+            ("Johnson Noise", "Temperature (K):,jT", "Resistance (Ohms):,jR"),
+            ("Shot Noise", "Current (Amps):,sI", "Resistance (Ohms):,sR"),
+            ("1/f Noise", "RMS:,oRMS"),
+            ("Random Telegraph Noise", "Tau Up (s):,rTU", "Tau Down (s):,rTD", "State Up:,rSU", "State Down:,rSD"),
+            ("Bit Noise", "Bit Depth (bits):,bD", "Minimum Measurement:,bMIN", "Maximum Measurement:,bMAX")
+        ]
+
+        for noise in noises:
+            #Noise Checkbox
+            cb = QtWidgets.QCheckBox(noise[0])
+            self.inputs[noise[0]] = (cb, lambda w=cb: w.isChecked())
+            left_layout.addWidget(cb)
+
+            # Group of Noise Inputs
+            group = QtWidgets.QGroupBox(noise[0] + " Settings")
+            group.setCheckable(False)
+            group.setVisible(False)
+            form = QtWidgets.QFormLayout(group)
+            for p in noise[1:]:
+                label, name = p.split(",")
+                form.addRow("<b>"+label+"</b>", self.line_edits[name])
+            left_layout.addWidget(group)
+
+            cb.toggled.connect(group.setVisible)
+            #cb.toggled.connect(self.update_plot)
+
+        left_layout.addStretch(1)
+
+        # Simulate Button
+        simulate_button = QtWidgets.QPushButton("Simulate")
+        simulate_button.clicked.connect(self.update_plot)
+        left_layout.addWidget(simulate_button)
+
+        # Reset Button
+        reset_button = QtWidgets.QPushButton("Reset")
+        reset_button.clicked.connect(self.reset_fields)
+        left_layout.addWidget(reset_button)
+
+        # User Notes
+        left_layout.addWidget(QtWidgets.QLabel("<b>User Notes:</b>"))
+        user_notes = QtWidgets.QLabel()
+        user_notes.setText("- SweepTime ≥ SamplingStep*BufferSize*#PlotPoints\n"
+                           "- Runs well up to 50 million calculations\n"
+                           "   EX: 500 PlotPoints * 100000 BufferSize")
+        left_layout.addWidget(user_notes)
+
+#Right Area (vertical) - right side of window
+        right_layout = QtWidgets.QVBoxLayout()
+        main_layout.addLayout(right_layout, 4)
+
+        #Graph 1:
+        plot1 = pg.PlotWidget(title="Original Signal vs X", background='w')
+        legend1 = plot1.addLegend()
+        legend1.anchor((1,0), (1,0))
+        right_layout.addWidget(plot1)
+
+        #Input Area 1:
+        input_layout1 = QtWidgets.QGridLayout()
+        cols = 4
+        for i, p in enumerate(params[18:22]):
+            name, label = p[0], p[2]
+            row = i // cols
+            col = i % cols
+
+            h_layout = QtWidgets.QHBoxLayout()
+            h_layout.addWidget(QtWidgets.QLabel("<b>"+label+"</b>"))
+            h_layout.addWidget(self.line_edits[name])
+            input_layout1.addLayout(h_layout, row, col)
+        right_layout.addLayout(input_layout1)
+
+        #Fit Results:
+        result_layout = QtWidgets.QHBoxLayout()
+        self.result_text = QtWidgets.QLabel()
+        result_layout.addWidget(self.result_text)
+        result_layout.addStretch(1)
+
+        #Label:
+        output2expected = QtWidgets.QLabel()
+        output2expected.setText("Output ≈ <sup>1</sup>&frasl;<sub>Diminish</sub> * Expected(<sup>x</sup>&frasl;<sub>Stretch</sub> - Shift)")
+        right_layout.addWidget(output2expected)
+
+        #Graph 2:
+        plot2 = pg.PlotWidget(title="Demodulated Signal vs X", background='w')
+        legend2 = plot2.addLegend()
+        legend2.anchor((1,0), (1,0))
+        right_layout.addWidget(plot2)
+
+        #Input Area 2:
+        input_layout2 = QtWidgets.QGridLayout()
+        for i, p in enumerate(params[22:]):
+            name, label = p[0], p[2]
+            row = i // cols
+            col = i % cols
+
+            h_layout = QtWidgets.QHBoxLayout()
+            h_layout.addWidget(QtWidgets.QLabel("<b>"+label+"</b>"))
+            h_layout.addWidget(self.line_edits[name])
+            input_layout2.addLayout(h_layout, row, col)
+        right_layout.addLayout(input_layout2)
+
+        #Plot Curve Initialization:
+        self.curve_orig = plot1.plot(pen=pg.mkPen(color='r', width=2), name="Original Signal")
+        self.curve_out = plot2.plot(pen=pg.mkPen(color='b', width=2), name="Output Signal")
+        self.curve_expected = plot2.plot(pen=pg.mkPen(color='r', width=2), name="Expected Signal")
+        self.curve_adjusted = plot2.plot(pen=pg.mkPen(color='g', width=2), name="Adjusted Signal")
+
+        #Show Curves Options:
+        curve_params = [ ("Output", self.curve_out), ("Expected", self.curve_expected), ("Adjusted", self.curve_adjusted) ]
+        for name, curve in curve_params:
+            cb = QtWidgets.QCheckBox(f"Show {name} Signal")
+            cb.setChecked(True)
+            cb.stateChanged.connect(lambda state, c=curve, box=cb: c.setVisible(box.isChecked()))
+            result_layout.addWidget(cb)
+        right_layout.insertLayout(2, result_layout)
+
+        self.update_plot()
+
+    def update_plot(self):
+        try:
+            # Read input v
+            v = {}
+            for name, (widget, extract) in self.inputs.items():
+                v[name] = extract(widget)
+
+            #Signal Setup
+            signal = 0
+            if v["signal_type"] == "Lorentzian": 
+                signal = make_lorentzian(v["l_center"], v["l_HW"], v["l_amp"])
+            else:
+                signal = make_antilorentzian(v["al_center"], v["al_HW"], v["al_amp"])
+
+            #Noise Setup
+            jT = jR = sI = sR = oRMS = rTU = rTD = rSU = rSD = bD = bMIN = bMAX = 0
+            if v["Johnson Noise"]:
+                jT, jR = v["jT"], v["jR"]
+            if v["Shot Noise"]:
+                sI, sR = v["sI"], v["sR"]
+            if v["1/f Noise"]:
+                oRMS = v["oRMS"]
+            if v["Random Telegraph Noise"]:
+                rTU, rTD, rSU, rSD = v["rTU"], v["rTD"], v["rSU"], v["rSD"]
+            if v["Bit Noise"]:
+                bD, bMIN, bMAX = v["bD"], v["bMIN"], v["bMAX"]
+
+            # Run lock-in emulator
+            LI = Lock_in_emulator(
+                signal,
+                v["f_input"],
+                v["phase_input"],
+                v["xstart_input"],
+                v["xstop_input"],
+                v["xamp_input"],
+                v["time_input"],
+                v["dt_input"],
+                v["TC_input"],
+                v["order_input"],
+                v["plotpoints_input"],
+                v["buffersize_input"],
+                jT, jR, sI, sR, oRMS, rTU, rTD, rSU, rSD, bD, bMIN, bMAX
+            )
+            LI.run()
+
+            # Update plots
+            self.curve_orig.setData(LI.x_plot, LI.original_signal)
+            self.curve_out.setData(LI.x_plot, LI.output_signal)
+            self.curve_expected.setData(LI.x_plot, LI.expected_signal)
+            self.curve_adjusted.setData(LI.x_plot, LI.adjusted_signal)
+
+            # Update results
+            self.result_text.setText(f"<b>Diminish:</b> {LI.diminish:.6f},  "
+                                     f"<b>Shift:</b> {LI.shift:.6f},  "
+                                     f"<b>Stretch:</b> {LI.stretch:.6f},  "
+                                     f"<b>SNR</b>: {LI.snr:.6f}")
+
+        except Exception as e:
+            self.result_text.setText(f"Error: {e}")
+
+    def reset_fields(self):
+        for p in params:
+            name, default = p[0], p[1]
+            self.line_edits[name].clear()
+            self.line_edits[name].setText(str(default))
+        self.update_plot()
+
+def run():
+    app = QtWidgets.QApplication(sys.argv)
+    w = MyWindow()
+    w.show()
+    sys.exit(app.exec_())
+
+if __name__ == "__main__":
+    run()

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