barsukov 1.3.3__tar.gz → 1.3.4__tar.gz

{barsukov-1.3.3/src/barsukov.egg-info → barsukov-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: barsukov
-Version: 1.3.3
+Version: 1.3.4
 Summary: Experiment Automation Package
 Author-email: Igor Barsukov <igorb@ucr.edu>, Steven Castaneda <scast206@ucr.edu>
 Project-URL: Homepage, https://barsukov.ucr.edu
@@ -16,6 +16,10 @@ Requires-Dist: scipy>=0.9.0
 
 Barsukov is a Python library for experiment automation.
 
+## For Developers
+
+To push to PyPi, commit to main on Github Desktop, click the history tab, right click and create tag, format the tag v\*.\*.\* and push to the repository (ctrl+p).
+
 ## Installation
 
 Use the package manager [pip](https://pip.pypa.io/en/stable/) to install barsukov.

{barsukov-1.3.3 → barsukov-1.3.4}/README.md

@@ -2,6 +2,10 @@
 
 Barsukov is a Python library for experiment automation.
 
+## For Developers
+
+To push to PyPi, commit to main on Github Desktop, click the history tab, right click and create tag, format the tag v\*.\*.\* and push to the repository (ctrl+p).
+
 ## Installation
 
 Use the package manager [pip](https://pip.pypa.io/en/stable/) to install barsukov.
@@ -30,4 +34,4 @@ pip install barsukov
 
 ## License
 
-[MIT](https://choosealicense.com/licenses/mit/)
+[MIT](https://choosealicense.com/licenses/mit/)

{barsukov-1.3.3 → barsukov-1.3.4}/src/barsukov/__init__.py

@@ -1,18 +1,15 @@
 # Modules:
 from . import time
 from . import data
-    
+
 
 # Objects/Functions:
 from .script import Script
 from .logger import Logger
-
 from .obj2file import *
 
 
 # Equipment Objects:
 from .exp.mwHP import mwHP
 
-__all__ = ["time", "data", "save_object", "load_object", "Script", "Logger", "mwHP"]
-
 

barsukov-1.3.4/src/barsukov/app/lock_in_emulator_app.py

@@ -0,0 +1,293 @@
+from PyQt5 import QtWidgets
+import pyqtgraph as pg
+import sys
+
+from barsukov.data import Lock_in_emulator, noise
+
+def make_lorentzian(center, width, amp):
+    def l(x):
+        return amp / ((x - center)**2 + width**2)
+    return l
+
+def make_gaussian(center, width, amp):
+    def g(x):
+        return amp / ((x - center)**2 + width**2)
+    return g
+
+params = [
+    ("l_center", 2, "Center:", float),
+    ("l_width", 1, "Width:", float),
+    ("l_amp", 1e-6, "Amplitude:", float),
+    ("g_center", 4, "Center:", float),
+    ("g_width", 2, "Width:", float),
+    ("g_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", "Gaussian"])
+        #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>Width:</b>", self.line_edits["l_width"])
+        lorentz_layout.addRow("<b>Amplitude:</b>", self.line_edits["l_amp"])
+        signal_stack.addWidget(lorentz_widget)
+
+        #Guassian Inputs
+        gauss_widget = QtWidgets.QWidget()
+        gauss_layout = QtWidgets.QFormLayout(gauss_widget)
+        gauss_layout.addRow("<b>Center:</b>", self.line_edits["g_center"])
+        gauss_layout.addRow("<b>Width:</b>", self.line_edits["g_width"])
+        gauss_layout.addRow("<b>Amplitude:</b>", self.line_edits["g_amp"])
+        signal_stack.addWidget(gauss_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_width"], v["l_amp"])
+            else:
+                signal = make_gaussian(v["g_center"], v["g_width"], v["g_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()
+
+if __name__ == "__main__":
+    app = QtWidgets.QApplication(sys.argv)
+    w = MyWindow()
+    w.show()
+    sys.exit(app.exec_())

barsukov-1.3.4/src/barsukov/data/Change_phase.py

@@ -0,0 +1,160 @@
+from barsukov.data.constants import deg2rad
+from barsukov.time import time_stamp
+
+from scipy.optimize import curve_fit
+from scipy.optimize import differential_evolution
+import numpy as np
+import matplotlib.pyplot as plt
+
+import glob
+import sys
+import os
+
+
+class Change_phase:
+        ### the phase you receive from auto, is a phase shift that you need to add to the phase of the original data. 
+        ### adding the two phases together gives to you the total effective lock-in phase of the calculated data.
+        ### Note that lock-in phase corresponds to the reference, not to the signal itself.
+        ### Lock-in phase is an artificial phase delay of the reference
+        ### new reference is cos(Wt - phase)
+        ### This script's phase, if added to the original phase of the lock-in, will give you a cumulative phase.
+        ### The recalculated signal would correspond to lock-in signal if measured with this cumulative phase.
+        ### This cumulative phase is the phase delay of your signal with respect to the original unaltered reference.
+        ### The automatically recalculated data is correct only if considered together with the automatically calculated phase
+        ### This means, you may get positive or negative signals in x-channel. So always consider the cummulative phase when evaluating the data. 
+
+    def __init__(self, x=[], A=[], B=[], initial_phase=0):
+        self.x = np.array(x)
+        self.A = np.array(A)
+        self.B = np.array(B)
+        self.initial_phi = initial_phase
+
+        self.phi = initial_phase
+        self.newA = None
+        self.newB = None
+
+
+    def read_from_file(self, full_file_path, x_column=0, A_column=1, B_column=2, initial_phase=0):
+        self.full_file_path = full_file_path
+        data = np.loadtxt(self.full_file_path, skiprows=0, unpack=True, usecols=(x_column, A_column, B_column))
+        self.x = data[0]
+        self.A = data[1]
+        self.B = data[2]
+        self.initial_phi = initial_phase
+
+
+    def offset_phase(self, phi=None):
+        if phi is not None:
+            self.phi = float(phi)
+            self.newA = self.A * np.cos(self.phi*deg2rad) + self.B * np.sin(self.phi*deg2rad)
+            self.newB = - self.A * np.sin(self.phi*deg2rad) + self.B * np.cos(self.phi*deg2rad)
+        else:
+            def to_minimize(phi_val):
+                self.phi = phi_val[0] #Differential evolution passes arrays
+                self.newA = self.A * np.cos(self.phi*deg2rad) + self.B * np.sin(self.phi*deg2rad)
+                self.newB = - self.A * np.sin(self.phi*deg2rad) + self.B * np.cos(self.phi*deg2rad)
+                popt, pcov = curve_fit(lambda x,a,b: a+b*x, self.x, self.newB, p0=[0,0])
+                return 1-(pcov[0,1]/(pcov[0,0]*pcov[1,1]))**2
+
+            ### MINIMIZES the sum of the data in the Y-channel (B)
+            result = differential_evolution(to_minimize, bounds=[(0,359.99)], strategy='best1bin')
+            if result.success:
+                self.offset_phase(phi=result.x[0])
+                print(f"Auto-adjusted phase: {result.x[0]} degrees")
+            else:
+                self.phi = initial_phase
+                print("Optimization failed!")
+
+
+    def plot_offset(self):
+        if not hasattr(self, "fig") or not hasattr(self, "axes"):
+            self.fig, self.axes = plt.subplots(nrows=4, ncols=1, figsize=(12,18))
+
+            self.lines = [
+                self.axes[0].plot(self.x, self.A ,'b-', label='X-')[0],
+                self.axes[0].plot(self.x, self.B, 'r-', label='Y-')[0],
+                self.axes[1].plot(self.x, self.newA, 'b-', label='X-')[0],
+                self.axes[2].plot(self.x, self.newB, 'r-', label='Y-')[0],
+                self.axes[3].plot(self.x, self.newA ,'b-', label='X-')[0],
+                self.axes[3].plot(self.x, self.newB, 'r-', label='Y-')[0],
+            ]
+
+            self.axes[0].set_title('Original X- & Y-')
+            self.axes[1].set_title('Adjusted X-')
+            self.axes[2].set_title('Adjusted Y-')
+            self.axes[3].set_title('Adjusted X- & Y-')
+
+            for ax in self.axes:
+                ax.legend()
+        else:
+            for line in self.lines:
+                line.set_xdata(self.x)
+
+            self.lines[0].set_ydata(self.A)
+            self.lines[1].set_ydata(self.B)
+            self.lines[2].set_ydata(self.newA)
+            self.lines[3].set_ydata(self.newB)
+            self.lines[4].set_ydata(self.newA)
+            self.lines[5].set_ydata(self.newB)
+
+            for ax in self.axes:
+                ax.relim()
+                ax.autoscale_view()
+
+        if "IPython" in sys.modules:
+            from IPython.display import display
+            display(self.fig)
+        else:
+            plt.ion()
+            self.fig.canvas.draw()
+            self.fig.canvas.flush_events()
+            plt.show()
+
+
+    def save_data(self, full_folder_path=None, file_name=None):
+        if hasattr(self, "full_file_path"):
+            full_folder_path, file_name = os.path.split(self.full_file_path)
+            file_name = f"Corrected_{round(self.phi)}_{file_name}"
+        else:
+            if full_folder_path is None:
+                full_folder_path = os.getcwd()
+            if file_name is None:
+                file_name = f"{time_stamp()}_Corrected_Phase_Lock_in_Data"
+
+        full_folder_path = os.path.join(full_folder_path, 'phase-corrected_data')
+        if not os.path.isdir(full_folder_path):
+            os.makedirs(full_folder_path)
+
+        full_file_path = os.path.join(full_folder_path, file_name)
+        with open(full_file_path, "w") as file:
+            for i in range(len(self.x)):
+                file.write(f"{self.x[i]} {self.newA[i]} {self.newB[i]} \n")
+
+
+    def offset_phase_script(self, full_folder_path=None, x_column=0, A_column=1, B_column=2, initial_phase=0, nocheck=False):
+        if full_folder_path is None:
+            full_folder_path = os.getcwd()
+        for file in glob.glob(os.path.join(full_folder_path, '*.txt')):
+            self.read_from_file(file, x_column, A_column, B_column, initial_phase)
+
+            self.offset_phase()
+            self.plot_offset()
+
+            while True:
+                if nocheck is False:
+                    manual_input=input('Enter "auto" to auto-calculate phase, a number/float for manual phase, or press ENTER to skip: ')
+
+                    if manual_input == "auto":
+                        self.offset_phase()
+                        self.plot_offset()
+                    elif manual_input:
+                        try:
+                            self.offset_phase(manual_input)
+                            self.plot_offset()
+                        except ValueError:
+                            print(f"Invalid input: {manual_input}. Please enter a valid phase value or 'auto'.")
+                    if not manual_input:
+                        print("Phase adjustment completed.")
+                        break
+            self.save_data()
+            print("Adjusted phase data saved.")