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

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/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/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.")

barsukov/data/Lock_in_emulator.py

@@ -0,0 +1,183 @@
+import numpy as np
+from barsukov.data import noise
+
+import sympy as sp
+
+class Lock_in_emulator:
+    def __init__(self, signal, f, phase, x_start, x_stop, x_amp, time, dt, TC, order, plot_points, buffer_size, 
+                 johnson_T=0, johnson_R=0,
+                 shot_I=0, shot_R=0,
+                 onef_rms=0,
+                 rtn_tau_up=0, rtn_tau_down=0, rtn_state_up=0, rtn_state_down=0,
+                 bit_depth=0, bit_measure_min=0, bit_measure_max=0):
+
+        #Signal Properties
+        self.signal_arr = signal
+        self.f = f
+        self.phase = np.pi * phase / 180
+        self.x_start = x_start
+        self.x_stop = x_stop
+        self.x_amp = x_amp
+        self.time = abs(time)
+
+        #Noise Properties
+        self.jT, self.jR = johnson_T, johnson_R
+        self.sI, self.sR = shot_I, shot_R
+        self.oRMS = onef_rms
+        self.rTU, self.rTD, self.rSU, self.rSD = rtn_tau_up, rtn_tau_down, rtn_state_up, rtn_state_down
+        self.bD, self.bMIN, self.bMAX = bit_depth, bit_measure_min, bit_measure_max
+
+        #Filter Properties
+        self.dt = abs(dt)
+        self.TC = TC
+        self.n = abs(order)
+
+
+        #Plotting Properties
+        self.plot_points = plot_points
+        self.buffer_size = buffer_size
+        self.buffer_period = self.buffer_size*self.dt
+        self.buffer_offset = np.linspace(-self.buffer_period, 0, self.buffer_size)
+
+    def run(self):
+        self.t_plot = np.linspace(self.buffer_period, self.time, self.plot_points)
+        self.x_plot = self.x_arr(self.t_plot)
+
+        self.original_signal = self.signal_arr(self.x_plot)
+        self.expected_signal_num = 0.5 * self.x_amp * np.gradient(self.original_signal, self.x_plot)
+        self.output_signal = self.signal_output_arr(self.t_plot)
+
+        #Symbolic feature:
+        x, p, w, a = sp.symbols('x p w a')
+        f = a / ((x - p)**2 + w**2)
+        dfdx = sp.diff(f, x)
+        f_prime = sp.lambdify((x, p, w, a), dfdx, 'numpy')
+        self.expected_signal = 0.5 * self.x_amp * f_prime(self.x_plot, 2, 1, 1e-6)
+
+        self.fit()
+        #self.plot()
+
+### BEGIN: FIELD
+    def x_arr(self, t_arr):
+        return self.x_start + t_arr * (self.x_stop - self.x_start) / self.time
+
+    def x_with_mod_arr(self, t_arr):
+        return self.x_arr(t_arr) + self.x_amp * np.cos(2 * np.pi * self.f * t_arr)
+
+
+### BEGIN: NOISE
+    def noise(self, t_arr):
+        if self.jT and self.jR: self.johnson = noise.johnson(t_arr, self.jT, self.jR)
+        else: self.johnson = np.zeros(len(t_arr))
+        
+        if self.sI and self.sR: self.shot = noise.shot(t_arr, self.sI, self.sR)
+        else: self.shot = np.zeros(len(t_arr))
+            
+        if self.oRMS: self.onef = noise.color(t_arr, self.oRMS)
+        else: self.onef = np.zeros(len(t_arr))
+        
+        if (self.rTU and self.rTD) or (self.rSU and self.rSD): self.rtn = noise.rtn(t_arr, self.rTU, self.rTD, self.rSU, self.rSD)
+        else: self.rtn = np.zeros(len(t_arr))
+        return self.johnson + self.shot + self.onef + self.rtn
+
+
+    def lp_filter_arr(self, t_arr):
+        t_arr = -(t_arr - t_arr[-1])
+        factorial = np.math.factorial(self.n - 1)
+        lp_filter_arr = (t_arr ** (self.n - 1)) * np.exp(-t_arr / self.TC) / (self.TC**self.n * factorial)
+        return lp_filter_arr / abs(np.sum(lp_filter_arr) * self.dt)
+
+    def signal_output(self, t):
+        t_arr = t + self.buffer_offset
+
+        x_arr = self.x_with_mod_arr(t_arr)
+        s_arr = self.signal_arr(x_arr)
+        noise_arr = self.noise(t_arr)
+        filter_arr = self.lp_filter_arr(t_arr)
+        ref_X = np.cos(2 * np.pi * self.f * t_arr - self.phase)
+
+        integrand = (s_arr+noise_arr) * ref_X * filter_arr * self.dt
+        return np.sum(integrand)
+
+    def signal_output_arr(self, t_arr):
+        output = np.array([self.signal_output(t) for t in t_arr])
+
+        if self.bD or (self.bMIN and self.bMAX):
+            return noise.bit(output, self.bD, self.bMIN, self.bMAX)
+        else:
+            return output
+
+
+### BEGIN: FIT:
+    def fit(self):
+        from scipy.interpolate import interp1d
+        from scipy.optimize import curve_fit
+
+        interp = interp1d(self.x_plot, self.expected_signal, kind='cubic', fill_value=0.0, bounds_error=False)
+
+        def model(x, diminish, stretch, shift):
+            x_trans = (x / stretch) - shift
+            return (1.0 / diminish) * interp(x_trans)
+
+        expected_max_idx, expected_min_idx = np.argmax(self.expected_signal), np.argmin(self.expected_signal)
+        output_max_idx, output_min_idx = np.argmax(self.output_signal), np.argmin(self.output_signal)
+
+        expected_peak_xdif = np.abs(self.x_plot[expected_max_idx] - self.x_plot[expected_min_idx])
+        output_peak_xdif = np.abs(self.x_plot[output_max_idx] - self.x_plot[output_min_idx])
+
+        initial_stretch = np.abs(output_peak_xdif / expected_peak_xdif)
+        initial_diminish = np.ptp(self.expected_signal) / np.ptp(self.output_signal)
+
+        initial_transform = model(self.x_plot, initial_diminish, initial_stretch, 0)
+        transform_max_idx = np.argmax(initial_transform)
+
+        initial_shift = (self.x_plot[output_max_idx] - self.x_plot[transform_max_idx]) / initial_stretch
+
+        initial_guess = [np.max([1,initial_diminish]), np.max([1,initial_stretch]), np.max([-np.ptp(self.x_plot),initial_shift])]
+
+        bounds = [(1, 1, -np.ptp(self.x_plot)), (10, 0.5*np.ptp(self.x_plot), np.ptp(self.x_plot) )]
+        popt, _ = curve_fit(model, self.x_plot, self.output_signal, sigma=1e-4, p0=initial_guess, bounds=bounds, method='trf')
+
+        #print(f"initial diminish: {initial_diminish}\ninitial stretch: {initial_stretch}\ninitial shift: {initial_shift}")
+        self.diminish = popt[0]
+        self.stretch = popt[1]
+        self.shift = popt[2]
+        self.adjusted_signal = model(self.x_plot, self.diminish, self.stretch, self.shift)
+
+        #SNR Calculation
+        p2p = np.max(self.adjusted_signal) - np.min(self.adjusted_signal)
+        noise_sample = self.output_signal[int(len(self.adjusted_signal) * 0.9):] #last 10% of the output signal
+        v_rms = np.sqrt(np.mean(noise_sample**2))
+
+        self.snr = p2p / v_rms
+
+    def plot(self):
+        import matplotlib.pyplot as plt
+
+        print(f'diminish: {self.diminish}')
+        print(f'stretch: {self.stretch}')
+        print(f'shift: {self.shift}')
+        print(f'Signal to Noise Ratio: {self.snr}')
+
+        self.fig, self.axes = plt.subplots(nrows=2, ncols=1, figsize=(12,18))
+
+        self.lines = [
+            self.axes[0].plot(self.x_plot, self.original_signal, 'r-', label='Original Signal')[0],
+            self.axes[1].plot(self.x_plot, self.output_signal, 'b-', label='Demodulated Signal (Lock-In)')[0],
+            self.axes[1].plot(self.x_plot, self.expected_signal, 'r-', label='Demodulated Signal (Expected)')[0],
+            self.axes[1].plot(self.x_plot, self.expected_signal_num, 'm-', label='Demodulated Signal (Expected Numerical)')[0],
+            self.axes[1].plot(self.x_plot, self.adjusted_signal, 'g-', label=f'Demodulated Signal (Adjusted)\n  Diminish: {self.diminish}\n  Stretch:{self.stretch}\n  Shift: {self.shift}')[0],
+        ]
+
+        self.axes[0].set_title('Original Signal vs x')
+        self.axes[1].set_title('Demodulated Signal vs x')
+
+        plt.legend()
+        plt.show()
+
+    def spectrum_average(self, num):
+        result = np.zeros_like(self.t_plot)
+        for i in range(0, num):
+            result += self.signal_output_arr(self.t_plot)
+
+        return result / num

barsukov/data/__init__.py

@@ -1 +1,5 @@
+from . import constants
+from . import noise
 from .fft import *
+from .Change_phase import Change_phase
+from .Lock_in_emulator import Lock_in_emulator

barsukov/data/constants.py

@@ -0,0 +1,10 @@
+import numpy as np
+
+
+### Conversions:
+deg2rad=2*np.pi/360.0
+
+
+### Constants:
+K_b = 1.380649e-23 #Boltzmann constant
+q = 1.602176634e-19 # Elementary Charge