barsukov 1.2.6__tar.gz → 1.3.7__tar.gz

{barsukov-1.2.6 → barsukov-1.3.7}/.gitignore

@@ -27,7 +27,6 @@ share/python-wheels/
 *.egg-info/
 .installed.cfg
 *.egg
-MANIFEST.in
 
 # PyInstaller
 #  Usually these files are written by a python script from a template
@@ -79,6 +78,7 @@ docs/_build/
 target/
 
 # Jupyter Notebook
+*.ipynb
 .ipynb_checkpoints
 
 # IPython
@@ -241,4 +241,4 @@ fabric.properties
 .idea/httpRequests
 
 # Android studio 3.1+ serialized cache file
-.idea/caches/build_file_checksums.ser
+.idea/caches/build_file_checksums.ser

barsukov-1.3.7/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+
+recursive-include src *.py

barsukov-1.3.7/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: barsukov
+Version: 1.3.7
+Summary: Experiment Automation Package
+Author-email: Igor Barsukov <igorb@ucr.edu>
+Maintainer-email: Steven Castaneda <scast206@ucr.edu>, Marlon Lopez <mlope589@ucr.edu>
+Project-URL: Homepage, https://barsukov.ucr.edu
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: pytz>=2014.10
+Requires-Dist: numpy>=1.0.0
+Requires-Dist: scipy>=0.9.0
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: sympy>=1.2
+Requires-Dist: PyQt5>=5.15
+Requires-Dist: pyqtgraph>=0.13.7
+Requires-Dist: dill>=0.4.0
+
+# Barsukov
+
+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.
+
+```bash
+pip install barsukov
+```
+Dependencies: pytz, dill, numpy, scipy, matplotlib, pyvisa, IPython, PyQt5, pyqtgraph
+## Usage
+
+```python
+#
+#
+#
+#
+#
+#
+#
+```
+
+## Contributing
+
+-
+-
+-
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

barsukov-1.3.7/README.md

@@ -0,0 +1,37 @@
+# Barsukov
+
+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.
+
+```bash
+pip install barsukov
+```
+Dependencies: pytz, dill, numpy, scipy, matplotlib, pyvisa, IPython, PyQt5, pyqtgraph
+## Usage
+
+```python
+#
+#
+#
+#
+#
+#
+#
+```
+
+## Contributing
+
+-
+-
+-
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

barsukov-1.3.7/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=64", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "barsukov"
+dynamic = ["version"]
+dependencies = [
+    "pytz>=2014.10",
+    "numpy>=1.0.0",
+    "scipy>=0.9.0",
+    "matplotlib>=3.8",
+    "sympy >=1.2",
+    "PyQt5 >=5.15",
+    "pyqtgraph >=0.13.7",
+    "dill >=0.4.0",
+]
+authors = [
+    { name = "Igor Barsukov", email = "igorb@ucr.edu" },
+]
+maintainers = [
+    { name = "Steven Castaneda", email = "scast206@ucr.edu" },
+    { name = "Marlon Lopez", email = "mlope589@ucr.edu"},
+]
+requires-python = ">=3.6"
+description = "Experiment Automation Package"
+readme = "README.md"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://barsukov.ucr.edu"
+#Repository = <githublink>
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools_scm]

{barsukov-1.2.6 → barsukov-1.3.7}/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.7/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.")

barsukov-1.3.7/src/barsukov/data/Lock_in_emulator.py

@@ -0,0 +1,175 @@
+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 = 0.5 * self.x_amp * np.gradient(self.original_signal, self.x_plot)
+        self.output_signal = self.signal_output_arr(self.t_plot)
+
+        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.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-1.3.7/src/barsukov/data/__init__.py

@@ -0,0 +1,6 @@
+from . import constants
+from . import noise
+from .fft import *
+from .Change_phase import Change_phase
+from .Lock_in_emulator import Lock_in_emulator
+from . import lock_in_emulator_app

barsukov-1.3.7/src/barsukov/data/color_map_app.py

@@ -0,0 +1,127 @@
+import sys
+import os
+import argparse
+import numpy as np
+
+try:
+    from PyQt5 import QtCore, QtWidgets
+except ImportError:
+    from PySide6 import QtCore, QtWidgets
+
+from color_map_core import (
+    DataLoader,
+    DEFAULT_XY_FILE,
+    DEFAULT_Z_FILE,
+    DEFAULT_CMAP
+)
+
+from color_map_widget import InteractiveHeatmapWidget
+
+
+def build_arg_parser():
+    """Build command line argument parser"""
+    p = argparse.ArgumentParser(
+        description="Interactive heatmap viewer (CSV/TSV/space-delimited supported)."
+    )
+    p.add_argument("--xy", dest="xy_file", default=DEFAULT_XY_FILE,
+                   help="Path to XY file (X,Y vectors; header optional).")
+    p.add_argument("--z", dest="z_file", default=DEFAULT_Z_FILE,
+                   help="Path to Z matrix file (rows form image lines).")
+    p.add_argument("--x-col", type=int, default=1,
+                   help="Zero-based column index to use for X (default: 1).")
+    p.add_argument("--y-col", type=int, default=0,
+                   help="Zero-based column index to use for Y (default: 0).")
+    p.add_argument("--cmap", default=DEFAULT_CMAP,
+                   help="Colormap to use (e.g., viridis, plasma, inferno, magma, cividis, gray, jet).")
+    return p
+
+
+def main():
+    """Main CLI entry point"""
+    # Parse command line arguments
+    parser = build_arg_parser()
+    args = parser.parse_args()
+    
+    # Load data with data loader
+    loader = DataLoader()
+    
+    # Use command line arguments
+    xy_file = args.xy_file
+    z_file = args.z_file
+    x_col = args.x_col
+    y_col = args.y_col
+    cmap = args.cmap
+    
+    try:
+        # Check if file exists and detect columns
+        if os.path.exists(xy_file):
+            num_cols, col_names = loader.detect_columns(xy_file)
+            if num_cols > 0:
+                # Load with specified columns
+                y, x = loader.load_xy_data(xy_file, x_col=x_col, y_col=y_col)
+                # Use column names for labels if available
+                if col_names and len(col_names) > max(x_col, y_col):
+                    x_label = f'X ({col_names[x_col]})'
+                    y_label = f'Y ({col_names[y_col]})'
+                else:
+                    x_label = 'X'
+                    y_label = 'Y'
+            else:
+                raise ValueError("No columns detected")
+        else:
+            raise FileNotFoundError(f"{xy_file} not found")
+            
+        Z = loader.load_matrix_data(z_file)
+    except Exception as e:
+        print(f"Error loading files: {e}")
+        print("Creating demo data...")
+        # Create demo data if files not found
+        x = np.linspace(0, 10, 100)
+        y = np.linspace(0, 10, 100)
+        xx, yy = np.meshgrid(x, y)
+        Z = np.sin(xx) * np.cos(yy)
+        x_label = 'X'
+        y_label = 'Y'
+    
+    # Calculate ranges
+    xmin, xmax = float(np.nanmin(x)), float(np.nanmax(x))
+    ymin, ymax = float(np.nanmin(y)), float(np.nanmax(y))
+    
+    # Create the app
+    app = QtWidgets.QApplication.instance()
+    created_app = False
+    if app is None:
+        app = QtWidgets.QApplication(sys.argv)
+        created_app = True
+        # Enable high DPI support
+        try:
+            app.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling, True)
+            app.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps, True)
+        except:
+            pass  # Older Qt version
+    
+    # Initial vmin/vmax from data
+    vmin = float(np.nanmin(Z))
+    vmax = float(np.nanmax(Z))
+    
+    # Create widget
+    win = InteractiveHeatmapWidget(
+        data=Z,
+        x_range=(xmin, xmax),
+        y_range=(ymin, ymax),
+        x_label=x_label,
+        y_label=y_label,
+        cmap=cmap,
+        vmin=vmin,
+        vmax=vmax
+    )
+    
+    win.show()
+    
+    # For CLI, run the event loop
+    if created_app:
+        sys.exit(app.exec_())
+
+
+if __name__ == "__main__":
+    main()