barsukov 0.0.0__py3-none-any.whl

barsukov/__init__.py

@@ -0,0 +1,18 @@
+# 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/data/__init__.py

@@ -0,0 +1 @@
+from .fft import *

barsukov/data/fft.py

@@ -0,0 +1,87 @@
+### BEGIN Dependencies ###
+import numpy as np
+import scipy as sp
+from barsukov.logger import debug    # Un-comment before implementing in pip
+### END Dependencies ###
+
+
+def fft(x, y, equidistant_check=True, equidistant_rel_error=1e-4, remove_negative_f=False, inverse=False):
+    ### Takes: x=list of real floats, y=list of data or list of lists of data. Data can be real or complex.
+    ### Returns: freqs, fft_y_norm, msg
+    ### This fft used to give wrong sign of the imaginary component because of the "wrong" definition of fft in np and sp
+    ### Now it has been corrected to the Mathematica definition of fft = int ... exp(2pi f t)
+    msg = ''
+    if equidistant_check:
+        diffs = np.diff(x)
+        if not np.allclose(diffs, diffs[0], rtol=equidistant_rel_error):
+            # x is not equidistant, must start interpolating
+            x,y = make_equidistant(x, y, step=None)
+            y = y.T
+            msg += debug('fft(x,y) made x,y equidistant.')
+
+    y = np.array(y)
+    #print(y)
+
+    if y.ndim == 1:
+        # y is 1D, treat it as a single column
+        n = len(y)  # Number of points in the column
+        if inverse is False: fft_y = np.fft.ifft(y) * n # np fft has the "wrong" imag sign
+        else: fft_y = np.fft.fft(y) # That's why fft and ifft are inverted in this code
+    else:
+        # y is 2D, treat it as multiple columns
+        n = y.shape[1]  # Number of points in each column
+        if inverse is False: fft_y = np.fft.ifft(y, axis=1) * n # np fft has the "wrong" imag sign
+        else: fft_y = np.fft.fft(y, axis=1) # That's why fft and ifft are inverted in this code
+
+    sample_spacing = ( x[-1] - x[0] ) / (n-1)
+    #print(n, sample_spacing, x[1] - x[0])
+    fft_y_norm = fft_y * sample_spacing # This normalizes FFT to mathematically correct
+    freqs = np.fft.fftfreq(n, d=sample_spacing)
+
+    if remove_negative_f is False:
+        sorted_indices = np.argsort(freqs)
+        freqs = freqs[sorted_indices]
+        if isinstance(fft_y_norm[0], (list, np.ndarray)):  # If fft_y_norm contains multiple columns
+            fft_y_norm = [x[sorted_indices] for x in fft_y_norm]
+        else:  # If fft_y_norm is a single column
+            fft_y_norm = fft_y_norm[sorted_indices]
+        msg += debug('fft(x,y) sorted negative and positive frequencies.')
+    else:
+        mask = freqs >= 0 # Boolean array with Falses for negative frequencies, effectively removing them
+        freqs = freqs[mask]
+        # If fft_y_norm contains multiple columns:
+        if isinstance(fft_y_norm[0], (list, np.ndarray)):
+            fft_y_norm = [x[mask] for x in fft_y_norm]
+        else:  # If fft_y_norm is a single column
+            fft_y_norm = fft_y_norm[mask]
+        msg += debug('fft(x,y) removed negative frequencies.')
+
+    msg += debug('freqs, fft_y_norm, msg = fft(x,y) is done.\nThe forward fft approximates the mathematically correct integral over ...exp(+i2pift).\nNow do not forget to apply np.abs(fft_y_norm), np.angle(fft_y_norm), fft_y_norm.real, fft_y_norm.imag')
+    return freqs, fft_y_norm, msg
+
+def ifft(x, y, equidistant_check=True, equidistant_rel_error=1e-4, remove_negative_f=False):
+    return fft(x, y, equidistant_check=equidistant_check, equidistant_rel_error=equidistant_rel_error, remove_negative_f=remove_negative_f, inverse=True)
+
+def make_equidistant(x, y, step=None):
+    ### Takes one column x and one or more columns y and makes them equidistant in x
+    ### Returns new_x, new_y. The number of points will likely change.
+    if step is None:
+        # Calculate the smallest difference between consecutive elements
+        min_step = np.min(np.diff(x))
+    else:
+        min_step = step
+    
+    # Generate the new equidistant x array
+    new_x = np.arange(x[0], x[-1] + min_step, min_step)
+    
+    if isinstance(y[0], (list, np.ndarray)):  # If y contains multiple columns
+        new_y = []
+        for y_column in y:
+            interpolation_function = sp.interpolate.interp1d(x, y_column, kind='linear', fill_value='extrapolate')
+            new_y.append(interpolation_function(new_x))
+        new_y = np.array(new_y).T  # Transpose to match the original structure
+    else:  # If y is a single column
+        interpolation_function = sp.interpolate.interp1d(x, y, kind='linear', fill_value='extrapolate')
+        new_y = interpolation_function(new_x)
+    
+    return new_x, new_y

barsukov/exp/__init__.py

@@ -0,0 +1 @@
+from . import mwHP

barsukov/exp/exp_utils.py

@@ -0,0 +1,136 @@
+### BEGIN Dependencies ###
+import numpy as np
+import sys
+from barsukov.time import *
+### END Dependencies
+
+
+### BEGIN Helper functions
+
+def log_in_eq(eq_obj, msg, log='default'): # FINISHED 2024/10/26
+    decorated_msg = str(eq_obj.msg_deco) + ' ' + msg
+    if eq_obj.logger is None:
+        if log=='no': return
+        else: print(time_stamp() + ' ' + decorated_msg)
+    else:
+        eq_obj.logger.log(decorated_msg, log)
+
+
+def initialize_gpib(eq_obj):
+    # Initializes a visa.open_resource(). Returns rm.open_resource(). Exits if error.
+    if eq_obj.rm is None: # eq_obj has no ResourceManager
+        if eq_obj.script is None:  # If there is no Script
+            eq_obj.log('Visa ResourceManager and Script have not been passed to me. I will attempt to initialize visa myself.', log='important')
+            try:
+                import pyvisa as visa
+                eq_obj.rm = visa.ResourceManager()
+                eq_obj.log('I just set my self.rm = visa.ResourceManager.', log='screen')
+            except:
+                eq_obj.log('I failed to initialize set my self.rm = visa.ResourceManager. I am sys-exiting.', log='important')
+                sys.exit()
+        else: # If there is a Script
+            if eq_obj.script.rm is None: # If Script has no ResourceManager
+                eq_obj.log('I see Script but it does not have rm. I am asking Script to initialize visa.ResourceManager and pass it to me.', log='important')
+                try: 
+                    eq_obj.rm = eq_obj.script.init_rm() # Script will try to init ResourceManager
+                    #print('eq_obj.rm initialized as ', eq_obj.rm)
+                except:
+                    eq_obj.log('Error while Script was initializing visa.ResourceManager. I am sys-exiting.', log='important')
+                    sys.exit()
+            else:
+                eq_obj.log('Script has visa.ResourceManager. I am grabbing it.', log='screen')
+                eq_obj.rm = eq_obj.script.rm
+            if eq_obj.rm is None: # Just to double check if rm is in fact there.
+                eq_obj.log('My last check showed that my self.rm is still None. I am sys-exiting.', log='important')
+                sys.exit()
+    # Now, we assume there is a resource manager
+    if (eq_obj.gpib is None) or (eq_obj.gpib_card is None):
+        eq_obj.log('GPIB card number or GPIB address is not set.', log='important')
+        sys.exit()
+    try:
+        #print(eq_obj.rm)
+        eq_obj.log('I am trying to rm.open_resource().', log='screen')
+        y = eq_obj.rm.open_resource(f'GPIB{eq_obj.gpib_card}::{eq_obj.gpib}')
+        #print('y=',y)
+        return y
+    except:
+        eq_obj.log(f'I could not initialize rm.open_resource() for GPIB {eq_obj.gpib_card}::{eq_obj.gpib}. Also check visa_rm, just in case.', log='important')
+        sys.exit()
+
+
+def eq_disconnect(eq_obj):
+    try:
+        eq_obj.rm.close()
+        eq_obj.rm.visalib._registry.clear()
+        eq_obj.log( f'Successfully disconnected GPIB resource for {eq_obj.gpib_card}::{eq_obj.gpib}.', log='screen')
+    except:
+        eq_obj.log( f'Failed to disconnect GPIB resource for {eq_obj.gpib_card}::{eq_obj.gpib}.', log='screen')
+
+
+def eq_reconnect(eq_obj):
+    try:
+        import pyvisa as visa
+        eq_obj.rm = visa.ResourceManager()
+        eq_obj.eq = initialize_gpib(eq_obj)
+        eq_obj.log( f'Successfully reconnected GPIB resource for {eq_obj.gpib_card}::{eq_obj.gpib}.', log='screen')
+        eq_obj.log( f'Initialized: {eq_obj.identify()}', log='important' )
+    except: 
+        eq_obj.log(f'Failed to reconnect GPIB resource for {eq_obj.gpib_card}::{eq_obj.gpib}.', log='important')
+
+### END Helper functions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### BEGIN Functions that are likely unnecessary
+
+def query_float(eq_obj, cmd):
+    ### Returns float or np.nan
+    try:
+        q = eq_obj.eq.query(cmd)
+        q = float(q) # Will it work with all equipment?
+        return q
+    except:
+        eq_obj.log(f'Error while quering: \"{cmd}\".', log='important')
+        return np.nan
+
+def write_float(eq_obj, cmd, value, digits, limits):
+    value_differs = ''
+    try:
+        value = float(value)
+        value_round = round(value, digits)
+        if value_round < limits[0]:
+            value_round = limits[0]
+        if value_round > limits[1]:
+            value_round = limits[1]
+        if value_round != value:
+            value_differs = f' But requested {value}.'
+        cmd = ''.join( [value_round if el is None else el for el in cmd] )
+        eq_obj.eq.write(cmd)
+        write_error = False
+        return write_error, value_differs
+    except:
+        write_error = True
+        eq_obj.log(f'Error while writing: \"{cmd}\".', log='important')
+        return write_error, value_differs
+
+### END Functions that are likely unnecessary

barsukov/exp/mwHP.py

@@ -0,0 +1,263 @@
+### BEGIN Dependencies ###
+import numpy as np
+import sys
+from barsukov.exp.exp_utils import *
+### END Dependencies
+
+
+class mwHP:
+    def __init__(self, gpib=None, visa_rm=None, logger=None, gpib_card=0, log='default', script=None):
+        # Pass the Script object, if available.
+        # If Script has no visa_rm or if no Script is passed, you'll need to pass the visa_rm=visa.ResourceManager manually.
+        # If Script has no logger or if no Script is passed, you can pass the logger manually.
+        # If no logger is passed, will simply print to screen.
+        # Change log from 'default' to 'screen', 'file', 'both', 'no'.
+        # gpib_card is per default 0. You can change, if you have multiple.
+
+        self.script = script
+        self.logger = logger
+        self.eq_default_log = log
+        self.rm = visa_rm
+        self.gpib_card = gpib_card
+        self.gpib = gpib
+
+        self.msg_deco = f'[mwHP {self.gpib_card}::{self.gpib}]'
+        self.eq = initialize_gpib(self) # This will initialize self.eq = visa.open_resource()
+        self.log( f'Initialized: {self.identify()}', log='important' ) # This is the 'welcome message' and a check if communication works.
+
+        self.f_digits = 9 # Digits of precision of mw frequency
+        self.f_limits = [0.01, 20.5] # Lower and upper GHz limits
+        self.p_digits = 1 # Digits of precision of mw power
+        self.p_limits = [-15.0, 17.0] # Lower and upper dBm limits
+        self.phase_limits = [0.0, 360.0]
+        self.pulsef_limits = [0.016, 500]
+        self.pulsedc_limits = [0, 100] # Lower and upper % limits
+
+
+### BEGIN The definition of the following functions may be specific to this equipment.
+    def query(self, cmd):
+        return self.eq.query(cmd)
+
+    def write(self, cmd):
+        return self.eq.write(cmd)
+
+    def identify(self):
+        return str(self.eq.query('*IDN?'))
+### END The definition of the following functions may be specific to this equipment.
+    def disconnect(self):
+        eq_disconnect(self)
+
+    def reconnect(self):
+        eq_reconnect(self)
+
+    def log(self, msg, log=None):
+        if log is None: log=self.eq_default_log
+        log_in_eq(self, msg, log=log)
+### END These functions could be shared across all equipment.
+
+    def 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.
+    ### output(1) writes state of Output to ON.
+    ### output(1) returns the state that was actually sent to equipment.
+    ### output(1, check=True) returns the state queried after writing
+        if log is None: log=self.eq_default_log
+        if state is None:
+            try:
+                y = self.eq.query('output?')
+                y = int(y)         
+                self.log(f'Output is {y}.')
+                return y
+            except:
+                self.log(f'Error while reading Output.', log='important')
+                return np.nan
+        else:
+            if (state == 1) or (state == 'on') or (state=='ON') or (state=='On'): sstate = 1
+            else: sstate = 0
+            try:
+                self.eq.write(f'output {sstate}')
+                if check: y=self.output(log='no')
+                else: y = sstate
+                if y == state: self.log(f'Output set to {sstate}.')
+                else: self.log(f'Warning: Setting Output to {sstate}, but was asked for {state}.')
+                return y
+            except:
+                self.log(f'Error while changing Output state.', log='important')
+                return np.nan
+
+
+    def f(self, f=None, log=None, check=False):
+    ### Always has a return! Which is frequency in GHz.
+    ### f() reads and returns the frequency in GHz.
+    ### f(10) writes frequency to 10 GHz.
+    ### f(10) returns the frequency that was actually sent to equipment.
+    ### f(10, check=True) returns the frequency queried after writing.
+    ### Do set log='no' to avoid latency for repeated calls. 
+        if log is None: log=self.eq_default_log
+        if f is None: 
+            try:
+                y = self.eq.query('freq?')
+                y = float(y)/1e9 # Is the frequency returned in GHz??
+                self.log(f'Reading f as {y} GHz.', log=log)
+                return y
+            except:
+                self.log(f'Error while reading Frequency.', log='important')
+                return np.nan
+        else:
+            try:
+                x = round(f, self.f_digits) # rounding the digits
+                x = max(self.f_limits[0], min(x, self.f_limits[1])) # sets x within f_limits
+                self.eq.write(f'freq {x} GHz')
+                if check: y = self.f(log='no')
+                else: y = x
+                if abs(y-f)<10.0**(-self.f_digits): self.log(f'Writing f as {x}.', log=log)
+                else: self.log(f'Warning: writing Frequency as {x}, but was asked {f}.', log='important')
+                return y
+            except:
+                self.log(f'Error while writing Frequency as {f}.', log='important')
+                return np.nan
+
+
+    def p(self, p=None, log=None, check=False):
+    ### Always has a return! Which is the power in dBm.
+    ### p() reads and returns the power in dBm.
+    ### p(1) writes power to 1 dBm.
+    ### p(1) returns the power that was actually sent to equipment.
+    ### p(1, check=True) returns the power queried after writing
+    ### Do set log='no' to avoid latency for repeated calls.
+        if log is None: log=self.eq_default_log
+        if p is None:
+            try:
+                y = self.eq.query('pow?')
+                y = float(y)
+                self.log(f'Reading p as {y} dBm.', log=log)
+                return y
+            except:
+                self.log(f'Error while reading Power.', log='important')
+                return np.nan
+        else:
+            try:
+                x = round(p, self.p_digits) # rounding the digits
+                x = max(self.p_limits[0], min(x, self.p_limits[1])) # sets x within p_limits
+                self.eq.write(f'pow {x} dBm')
+                if check: y = self.p(log='no')
+                else: y = x
+                if abs(y-p)<10**(-self.p_digits): self.log(f'Writing p as {x}.', log=log)
+                else: self.log(f'Warning: writing Power as {x}, but was asked {p}.', log='important')
+                return y
+            except:
+                self.log(f'Error while writing Power as {p}.', log='important')
+                return np.nan
+
+
+    def sweep(self, start, stop, step, dwell, mode, log=None):
+        if log is None: log=self.eq_default_log
+        units, write_start, write_stop, mode = '', start, stop, mode.lower()
+        if (mode == 'freq') or (mode == 'frequency') or (mode == 'f'): 
+            write_start = max(self.f_limits[0], min(write_start, self.f_limits[1]))
+            write_stop = max(self.f_limits[0], min(write_stop, self.f_limits[1]))
+            mode = 'Frequency'
+            units = 'GHz'
+        if (mode == 'pow') or (mode == 'power') or (mode == 'p'): 
+            write_start = max(self.p_limits[0], min(write_start, self.p_limits[1]))
+            write_stop = max(self.p_limits[0], min(write_stop, self.p_limits[1]))
+            mode = 'Power'
+            units = 'dBm'
+        if (write_start != start):
+            self.log(f'Warning: Writing {mode} Sweep start to {write_start} but was asked {start}.', log='important')
+        if (write_stop != stop): 
+            self.log(f'Warning: Writing {mode} Sweep stop to {write_stop} but was asked {stop}.', log='important')
+        try:
+            self.log(f'{mode} Sweep parameters are start: {write_start} {units}, stop: {write_stop} {units}, step: {step} {units}, dwell: {dwell} s.', log=log)
+            self.log(f'Initiating {mode} Sweep: ', log=log)
+            from time import sleep
+            for point in np.arange(write_start, write_stop+(step/2.0), step):
+                if mode == 'Frequency': 
+                    self.f(f=point)
+                elif mode == 'Power': 
+                    self.p(p=point)
+                sleep(dwell)
+            self.log(f'{mode} Sweep completed.', log=log)
+        except:
+            self.log(f'Error while conducting Sweep.', log='important')
+            return np.nan
+
+
+    def pulse(self, f=None, duty=None, log=None):
+        if log is None: log=self.eq_default_log
+        if f is None and duty is None:
+            try:
+                T = float(self.eq.query('puls:per?')) * 10.0**3
+                f = 1.0 / T
+                w = float(self.eq.query('puls:widt?')) * 10.0**3
+                duty = w / T * 100.0
+                y = self.eq.query('pulm:stat?')
+                y = int(y)
+                x = self.eq.query('pulm:sour?')
+                x = x[:-1].lower()
+                self.log(f'Pulse Frequency {f} KHz, duty-cycle {duty}%. state {y}, source {x}.', log=log)
+                return f, duty
+            except:
+                self.log(f'Error while reading Pulse state.', log='important')
+                return np.nan
+        else:
+            if duty is None: duty = 50.0
+            try:
+                if f is None and duty != 50.0:
+                    duty_write = max(self.pulsedc_limits[0], min(float(duty), self.pulsedc_limits[1]))
+                    T = float(self.eq.query('puls:per?')) * 10.0**3
+                    w = duty_write * T / 100.0
+                    self.eq.write(f'puls:widt {w} ms')
+                elif f is not None and duty == 50.0:
+                    f_write = max(self.pulsef_limits[0], min(float(f), self.pulsef_limits[1]))
+                    duty_write = duty
+                    T = 1.0 / f_write
+                    w = duty_write * T / 100.0
+                    self.eq.write(f'puls:per {T} ms')
+                    self.eq.write(f'puls:widt {w} ms')
+                else:
+                    f_write = max(self.pulsef_limits[0], min(float(f), self.pulsef_limits[1]))
+                    duty_write = max(self.pulsedc_limits[0], min(float(duty), self.pulsedc_limits[1]))
+                    T = 1.0 / f_write
+                    w = duty_write * T / 100.0
+                    self.eq.write(f'puls:per {T} ms')
+                    self.eq.write(f'puls:widt {w} ms')
+            except:
+                self.log(f'Error while writing pulse frequency as {f} and duty cycle as {duty}', log='important')
+                return np.nan
+            freal, dutyreal = self.pulse()
+            if abs(freal - f) < 0.10*float(f): self.log(f'Writing Pulse Frequency as {freal}.', log=log)
+            else: self.log(f'Warning:Writing Pulse Frequency as {freal}, but was asked {f}.', log='important')
+            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
+
+
+### BEGIN: OBJ2FILE Tools
+    # Prepares the Script object for serialization by removing non-seriable attributes (e.g. logger and rm).
+        # Returns:
+            # dict: A dictionary representing the serializable state of the Script object.
+    def __getstate__(self):
+        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__()
+        else:
+            seriable_data['script'] == 'needsrebuild'
+            seriable_data['script_information'] = self.script.__getstate__()
+        seriable_data['rm'] = None
+        seriable_data['eq'] = None
+        return seriable_data
+
+
+    def __setstate__(self, seriable_data):
+        from barsukov.script import Script
+        from barsukov.logger import Logger
+        self.__dict__.update(seriable_data)
+        if self.script == 'needsrebuild':
+            self.script = Script(**seriable_data['script_information'])
+        if self.logger == 'needsrebuild':
+            self.logger = Logger(**seriable_data['logger_information'])
+        eq_reconnect(self)
+### END: OBJ2FILE Tools

barsukov/logger.py

@@ -0,0 +1,161 @@
+### BEGIN Dependencies ###
+import os
+from barsukov.time import time_stamp
+### END Dependencies ###
+
+class Logger:
+    """
+    Logger class that handles logging to both screen and file with flexible configuration
+
+    The logger is started upon initialization. 
+    It can be started with the 'start()' method and can be closed using the 'close()' method
+    It is designed to avoid creating multiple Logger instances. Restarting the logger logs to the same file unless the 'full_file_path' is manually changed
+
+    Avaliable log options:
+    - 'screen': Logs only to the screen.
+    - 'file': Logs only to a file.
+    - 'both': Logs to both the screen and file.
+    - 'no': Disables logging.
+
+    log level 'important' is used for important logs, typically for internal use with higher priority
+
+    Attributes:
+        full_file_path (str): path to the log file (e.g., 'D:/Rundong/Projects/AFM sims/2024-07-06 Autooscillations/text.txt')
+        description (str): Description of the log's purpose.
+        log_mode (str): Defines the logging mode ('screen', 'file', 'both, or 'no').
+        file (file object): Log file object.
+        file_error (bool): Flag indicating an error with the file
+    """
+    ### Don't create multiple Logger objects.
+    ### Logger can be opened and closed with start() and close() methods.
+    ### Restarting the logger will log to the same file, unless self.full_file_path has been changed by hand.
+    ### start=True will start the logger automatically, but be careful
+    ### about the full_folder_path=os.getcwd() in init.
+    ### Log options are 'screen', 'file', 'both', 'no'. The logger default is 'both'.
+    ### The log='important' is for the Logger.log() method only. Try not to use it.
+    ### Default hyerarchy is logger-default overriden by object-default overriden by instance.
+    ### Instances, that log errors, will usually use 'both'.
+
+### BEGIN: Initializing Tools
+    def __init__(self,
+        description=None, # Will be passed by Script. If not, write a brief description!
+        full_folder_path=os.getcwd(), # Will be passed by Script. If not, specify!
+        full_file_path=None, #  Specify only if you want to log into an already existing file.
+        log='both', # Logger default will be passed by Script. If not, you may choose to change.
+        start_file=True,
+        ):
+
+        ### Initializing all variables before setting/getting them
+        self.full_file_path = full_file_path # If changed by hand later, needs start() to take effect
+        self.description = description # If changed by hand later, needs set_full_file_path and start() to take effect       
+        self.log_mode = log # Default log mode can be changed by hand any time, no restart needed.
+
+        if self.full_file_path is not None: self.full_folder_path = None
+        else:
+            self.full_folder_path = full_folder_path # If changed by hand later, needs set_full_file_path and start() to take effect
+            self.set_full_file_path(description=description, full_folder_path=full_folder_path)
+
+        if start_file: self.start_file()
+        else: self.file = None
+
+        self.file_error = False 
+        # If a problem with file, will be set to True. Just in case for later.
+        # If problem is remedied, you need to set file_error to False by hand.
+
+        self.log(f'Logger initialization complete.', log='important')
+
+
+    def set_full_file_path(self, description=None, full_folder_path=None):
+        ### Checking if optional arguments are filled or if defaults are provided ###
+        if description is None:
+            description = self.description
+        if full_folder_path is None:
+            full_folder_path = self.full_folder_path
+
+        ### Create a file name like log_timeStamp_description_.txt ###
+        if not (description is None or description == ''):
+            description = f"_{description}"
+        else:
+            description = ''
+        file_name = f"log_{time_stamp()}{description}_.txt"
+        self.full_file_path = os.path.join(full_folder_path, file_name)
+
+
+    def start_file(self):
+        try:
+            self.file = open(self.full_file_path, 'a')
+            self.log('Logging file started.', log='important')
+        except:
+            print(f'{time_stamp()} Logger failed to open the log file \"{self.full_file_path}\".', log='important')
+
+
+    def close_file(self): # If closed, you'll need to restart before logging.
+        self.log('Logger is closing log file.', log='important')
+        self.file.close()
+        self.file = None
+### END: Initializing Tools
+
+
+### BEGIN: logging Tools
+    def decorated_msg(self, msg):
+        decorated_msg = time_stamp() + ' ' + msg + '\n'
+        return decorated_msg
+
+
+    def write_to_file(self, msg):
+        if self.file:
+            self.file.write(msg)
+            ### flushing the log file to make sure it's written ###
+            self.file.flush()
+            os.fsync(self.file)
+        else:
+            self.file_error = True
+            print(f'{time_stamp()} Logger is trying to write to a closed or non-existent file.')
+
+
+    def log(self, msg, log='default'):
+        ### This is the main function. Log options: 'screen', 'file', 'both', 'no', 'default', 'important'
+        if log == 'important' and self.log_mode == 'no':
+            log = 'screen'
+        elif log == 'important' and self.log_mode == 'file':
+            log = 'both'
+        elif (log == 'important') or(log == 'default') or (log is None):
+            log = self.log_mode
+
+        decorated_message = self.decorated_msg(msg)
+
+        if log == 'both':
+            print(self.decorated_msg(msg))
+            self.write_to_file(decorated_message)
+        elif log == 'file':
+            self.write_to_file(decorated_message)
+        elif log == 'no':
+            pass
+        else: # log == 'screen' or anything else
+            print(decorated_message)
+### END: logging Tools
+
+
+### BEGIN: OBJ2FILE TOOLS:
+    def __getargs__(self):
+        logger_args = self.__getstate__()
+        del logger_args['log_mode']
+        del logger_args['file_error']
+        del logger_args['file']
+        return logger_args
+
+    def __getstate__(self):
+        seriable_data = self.__dict__.copy()
+        return seriable_data
+### BEGIN: OBJ2FILE TOOLS:
+
+
+### Use this function in other libraries if needed for debugging -- Not really needed
+DEBUG = False
+def debug(msg):
+    if DEBUG:
+        print(msg)
+        return msg+'\n'
+    else:
+        return msg
+###

barsukov/obj2file.py

@@ -0,0 +1,93 @@
+### BEGIN Dependencies ###
+import dill
+import os
+from barsukov.logger import debug
+### END Dependencies ###
+
+
+def save_object(obj, file_name, update=False, full_folder_path=None, script=None):
+    """
+    Saves a class object to a file using the '.pickle' format.
+
+    Args:
+        obj (object): An instance of a class to be saved. (Required)
+        file_name (str): Name of the file (must end with '.pickle'). (required)
+        update (bool, optional): if 'True', overwrites an existing file. Defaults to 'False'.
+        full_folder_path (str, optional): absolute path to the directory (e.g., "C://Users//John//Documents").
+            Defaults to the current working directory if not provided.
+        script (Script, optional): Script object providing directory information. 
+            Defaults to 'None'.
+
+    Returns:
+        str: Confirmation message upon successful save.
+
+    Raises:
+        FileExistsError: If the file already exists and 'update=False'.
+
+    Example:
+        >>> equipment = mwHP(...)
+        >>> save_object(obj=equipment, file_name="mwHP.pickle")
+        'equipment successfully saved in mwHP.pickle.'
+    """
+    # Check if full_folder_path is provided and is an absolute path:
+    if full_folder_path and not os.path.isabs(full_folder_path):
+        return debug(f"Please provide an absolute path (e.g., 'C://Users//John//Documents').")
+
+    #Set folder_path based on the provided or default to current directory
+    full_folder_path = full_folder_path or (script.full_folder_path if script else os.getcwd())
+    full_file_path = os.path.join(full_folder_path, file_name)
+
+    if update:
+        # If update is True, overwrite the file
+        with open(full_file_path, 'wb') as file:
+            dill.dump(obj, file)
+            return debug(f"{obj} object successfully saved.")
+    else:
+        try:
+            # Try to create the file and save the object
+            with open(full_file_path, 'xb') as file:
+                dill.dump(obj, file)
+                return debug(f"{obj} successfully saved in {file_name}.")
+        except FileExistsError:
+            # If the file already exists, provide a message
+            raise FileExistsError(f"File '{file_name}' already exists. Use 'update=True' to overwrite.")
+
+
+def load_object(file_name, full_folder_path=None, script=None):
+    """
+    Loads a class object stored in a '.pickle' formatted file.
+
+    Args:
+        file_name (str): Class object file (must end in '.pickle'). (Required)
+        full_folder_path (str, optional): absolute path to the directory where file exists (excluding the file name).
+            Defaults to the current working directory.
+        script (Script, optional): Script object providing directory information. 
+            Defaults to 'None'.
+
+    Returns:
+        object: The loaded class object.
+
+    Raises:
+        FileNotFoundError: If the file doesn't exist in the specified location.
+
+    Example:
+        >>> new_equipment = load_object(file_name="mw.pickle")
+        'Object successfully loaded from mw.pickle.'
+    """
+    # Check if the provided full_folder_path is absolute
+    if full_folder_path and not os.path.isabs(full_folder_path):
+        return debug(f"Please provide an absolute path (e.g., 'C://Users//John//Documents').")
+
+    # Set full_folder_path based on provided or default to current directory
+    full_folder_path = full_folder_path or (script.full_folder_path if script else os.getcwd())
+    full_file_path = os.path.join(full_folder_path, file_name)
+
+    # Check if the file exists at the specified path
+    if not os.path.isabs(full_file_path):
+        raise FileNotFoundError(f"The object file {file_name} does not exist at the specified directory.")
+
+    # load the object from the file
+    with open(full_file_path, 'rb') as file:
+        instance = dill.load(file)
+        print(debug(f'Object successfully loaded from {file_name}.'))
+    return instance

barsukov/script.py

@@ -0,0 +1,153 @@
+### BEGIN Dependencies ###
+import sys
+import os
+from barsukov.time import *
+from barsukov.logger import Logger
+### END Dependencies
+
+
+class Script():
+    """
+    A class that represents a scientific experiment script, managing logging, file handing, and device initialization.
+
+    Args:
+        RECOMMENDED:
+        operator (str): The name of the operator (default: 'Anon').
+        station (str): The station of the experiment (default: 'No-Station').
+        sample (str): The sample being tested (default: 'No-Sample').
+        description (str): A brief description of the experiment (default: 'No-Description').
+        project_folder (str): The base folder for the project files (default: current directory).
+
+        OPTIONAL:
+        log (str, optional): The logging configuration (default: 'both')
+            This is the default log setting which will be passed to the logger.
+            It will be overriden by other objects, which in turn will be overriden by methods.
+            Choose here and everywhere from 'screen', 'file', 'both', 'no'.
+
+        BEST NOT TO CHANGE:
+        log_full_folder_path (str, optional): Path to save logs (default: current directory).
+        log_full_file_path (str, optional): Full path for log file (default: None).
+
+    Attributes:
+        operator (str): The operator's name (e.g., 'ib', 'Rundong', 'Sasha', 'Ameerah', 'Steven', 'Alex', or 'AlexH' if ambiguous).
+        station (str): The station where the experiment is conducted (e.g., 'qd', 'ppms', 'mseppms', 'data', 'orange', ...).
+        sample (str): The sample being used in the experiment (e.g. 'cro2410a1').
+        description (str): A brief description of the experiment (e.g., 'Testing modulation').
+        project_folder (str): Absolute path to the directory (e.g., 'D:/Rundong/Projects/AFM sims/2024-07-06 Autooscillations').
+        folder_name (str): A generated folder name based on the experiment details.
+        full_folder_path (str): The full path to the experiment folder.
+        logger (Logger): A Logger instance for logging experiment data.
+        rm (ResourceManager or None): The pyvisa ResourceManager used for controlling instruments.
+    """
+### BEGIN: Initializing tools
+    def __init__(self, 
+        operator='Anon',
+        station='No-Station',
+        sample='No-Sample',
+        description='No-Description',
+        project_folder = os.getcwd(),
+        log='both', 
+        log_full_folder_path=os.getcwd(),
+        log_full_file_path=None, 
+        ):
+
+        ### Description Attributes
+        self.operator = operator
+        self.station = station
+        self.sample = sample
+        self.description = description
+        self.project_folder = project_folder
+
+        ### Creating the sub-project folder
+        self.folder_name = f"{date()}_{self.station}_{self.operator}_{self.sample}_{self.description}"
+        self.full_folder_path = os.path.join(self.project_folder, self.folder_name)
+        os.makedirs(self.full_folder_path, exist_ok=True)
+
+        ### Logger Attributes
+        self.start_logger = True
+        self.log_mode = log
+        self.log_full_folder_path = log_full_folder_path
+        self.log_full_file_path = log_full_file_path
+        self.init_logger(start=self.start_logger)
+        self.logger_name = self.logger.full_file_path
+
+        ### Equipment Attributes
+        self.rm = None
+        self.equipment = None
+
+    def init_logger(self, start):
+        ### Starting the logger
+        self.logger = Logger(
+            description=f"{self.operator}_{self.description}",
+            full_folder_path=self.log_full_folder_path,
+            full_file_path=self.log_full_file_path,
+            log=self.log_mode, # Script.log becomes Logger's default
+            start_file=start)
+        self.logger.log(f'Script object initialized. Logger started.', log='both')
+
+
+    def log(self, msg, log='default'):
+        """
+        Logs a message using the Script object's logger.
+
+        Args:
+            msg (str): The message to log.
+            log (str, optional): The log destination (e.g., 'screen', 'file', 'both'). Defaults to the 'default' of the logger
+        """
+        self.logger.log(msg, log=log)
+### END: Initializing tools
+
+
+### BEGIN: Equipment related stuff
+    def init_rm(self):
+        # Initializes the pyvisa ResourceManager for controlling instruments.
+        # Returns ResourceManager The pyvisa ResourceManager object.
+        # Raises SystemExit If pyvisa cannot be imported or the ResourceManager cannot be initialized.
+        self.equipment = True
+        import pyvisa as visa
+        try: 
+            self.rm = visa.ResourceManager()
+        except:
+            self.rm = None
+            self.log('Script could not import pyvisa.', log='important')
+            sys.exit()
+        self.log(f'Script started pyvisa.ResourceManager.', log='both')
+        return self.rm
+### END: Equipment related stuff
+
+
+### BEGIN: Equipment devices
+    def mwHP(self, gpib=None, **kwargs):
+        """
+        Initializes and returns a mwHP equipment object with the specified parameters.
+
+        Args:
+            gpib (str): gpib number of equipment. Defaults to 'None'.
+            **kwargs: Additional keyword arguments passed to the mwHP equipment initialization.
+
+        Returns:
+            mwHP: A mwHP equipment object.
+        """
+        from barsukov.exp.mwHP import mwHP as eq
+        return eq(gpib, logger=self.logger, script=self, **kwargs)
+### END: Equipment devices
+
+
+### BEGIN: OBJ2FILE TOOLS:
+    def __getstate__(self):
+        # Prepares the Script object for serialization by removing non-seriable attributes (e.g. logger and rm).
+        # Returns a dict: A dictionary representing the serializable state of the Script object.
+        seriable_data = self.__dict__.copy()
+        seriable_data['start_log'] = False
+        del seriable_data['logger']
+        del seriable_data['rm']
+        return seriable_data
+
+
+    def __setstate__(self, seriable_data):
+        # Restores the Script object from its serialized state, including reinitializing the logger and rm.
+        # Args: seriable_data (dict): A dictionary representing the serialized state of the Script object
+        self.__dict__.update(seriable_data)
+        self.init_logger(self.start_logger)
+        if self.equipment is True: self.init_rm()
+### END: OBJ2FILE TOOLS:

barsukov/time.py

@@ -0,0 +1,37 @@
+### BEGIN Dependencies ###
+import datetime
+from pytz import timezone
+### END Dependencies ###
+
+TIMEZONE = timezone('America/Los_Angeles')
+
+def time_stamp():
+    """
+    Generates a timestamp in the format 'YYYY-MM-DD_HH-MM-SSS', where the last digit represents 1/10th of a second based on the current date and time.
+
+    returns:
+        str: A string representing the current date and time in the format 'YYYY-MM-DD_HH-MM-SSS'.
+
+    Example:
+        >>> time_stamp()
+        '2025-01-28_17-27-210'
+    """
+    now = datetime.datetime.now(TIMEZONE)
+    formatted_datetime = now.strftime(f"%Y-%m-%d_%H-%M-%S") + str(int( now.microsecond / 100000 ))
+    return formatted_datetime
+
+
+def date(): 
+    """
+    Generates the current date in the format 'YYYY-MM-DD'.
+
+    Returns:
+        str: A string representing the current date in the format 'YYYY-MM-DD'.
+
+    Example:
+        >>> date()
+        '2025-01-28'
+    """
+    now = datetime.datetime.now(TIMEZONE)
+    formatted_datetime = now.strftime(f"%Y-%m-%d")
+    return formatted_datetime

barsukov-0.0.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.2
+Name: barsukov
+Version: 0.0.0
+Summary: Experiment Automation Package
+Author-email: Igor Barsukov <igorb@ucr.edu>, Steven Castaneda <scast206@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
+
+# Barsukov
+
+Barsukov is a Python library for experiment automation.
+
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) to install barsukov.
+
+```bash
+pip install barsukov
+```
+
+## Usage
+
+```python
+#
+#
+#
+#
+#
+#
+#
+```
+
+## Contributing
+
+-
+-
+-
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

barsukov-0.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+barsukov/__init__.py,sha256=GVsEnM_uD4x1XN_PIKdD-VSRMNUnvPr2iCWuEHwM6sU,293
+barsukov/logger.py,sha256=nrkS1Pg3WGEjRJQ5MbplhyGYGbfFGkgyxgx1qdSu1x0,6489
+barsukov/obj2file.py,sha256=nivCmCEpmOSaG4VpQgIDb-7hsvdEq45Iuu5HOfRxbcw,3923
+barsukov/script.py,sha256=nrKwEl60u9ces3B8FwRfY4VmlEx5bNvk_hoPaylldP0,6359
+barsukov/time.py,sha256=fSf5JKqr6Pd5691qQcFuBsjDd9alMrfASnndlstLits,1039
+barsukov/data/__init__.py,sha256=IMnOEliXsRMPWeCTprPSddRKg9kwfV-neQiwUwHdpqs,19
+barsukov/data/fft.py,sha256=f9aPLeusVpWiWmXO5n4XwkfQ9xJQhZVFdyhFoT9DB2A,4365
+barsukov/exp/__init__.py,sha256=urLfGpap40kN9ULi53JB0NT-iMsZDSFdBmdSq3ckB0E,19
+barsukov/exp/exp_utils.py,sha256=7qVQJbJGbsNW0JZQ7A1cmI73J6vi_aN8Zu6WMq2-7LE,4789
+barsukov/exp/mwHP.py,sha256=eoX82jon5nIsExvRHO1PIOQAWWWhJYY4N21VtoLXuSw,12136
+barsukov-0.0.0.dist-info/METADATA,sha256=H_KUEI5ZW4N0sz2pQIOJu-hO9501NDH4ujZvHYgCzlE,791
+barsukov-0.0.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+barsukov-0.0.0.dist-info/top_level.txt,sha256=Js5sHbNjP0UNMB9O5HtCHZqlfHabuNS8nTsHbg-1DDQ,9
+barsukov-0.0.0.dist-info/RECORD,,

barsukov-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

barsukov-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+barsukov