barsukov 0.0.1__py3-none-any.whl

barsukov/__init__.py

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

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,119 @@
+### 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()
+
+### 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,357 @@
+### BEGIN Dependencies ###
+import numpy as np
+import sys
+from barsukov.exp.exp_utils import *
+### END Dependencies
+
+# STATUS: f() finished, nor test it and then add more funcitons
+
+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}]'
+        #print( 'visa_rm is ', visa_rm )
+        #print( 'script is ', script )
+        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 #TODO -- Digits of precision of mw power
+        self.p_limits = [-15.0, 17.0] #TODO -- Lower and upper __ limits
+        self.pulsef_digits = 3 # digits in KHz
+        self.pulsew_digits = 3 # digits in ms
+        self.pulsef_limits = [0.016, 500]
+        self.pulsew_limits = [0.001, 65.53] # digits in ms
+        self.pulsedc_limits = [0, 100]
+
+    ### 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 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 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
+                print(y, f)
+                if abs(y-f)<10.0**(-self.f_digits): self.log(f'Writing f as {x}.', log=log) #################### THIS IS WRONG!!!! IT SHOULD BE abs(y-f)<(10**self.f_digits)
+                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 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 sweep(self, mode, state=None, step=None, dwell=None, minm=None, maxm=None, log=None, check=False):
+        #if log is None: log=self.eq_default_log
+        #if (mode == 'pow') or (mode == 'freq'): ### Sweep function can write to power or frequency
+            #if state is None: ### sweep(pow) or sweep(freq) reads and returns if the sweep mode is on or off
+                #try:
+                    #y = self.eq.query(f'{mode} swe?')
+                    #y = float(y)
+                    #self.log(f'{mode} Sweep state is {y}.')
+                    #return y
+                #except:
+                    #self.log(f'Error while reading {mode} Sweep state.', log='important')
+                    #return np.nan
+            #else:
+                #if (state == 1) or (state == 'on') or (state=='ON') or (state=='On'): sstate = 'swe' ### sweep(pow, 1) or sweep (freq, 1) turns the sweep mode for pow/freq ON
+                #else: sstate = 'fix'
+                #try:
+                    #self.eq.write(f'{mode} {sstate}')
+                    #if check: y=self.output(log='no')
+                    #else: y = sstate
+                    #if y == state: 
+                        #self.log(f'{mode} Sweep state set to {sstate}.')
+                        #if (step=None) or (dwell=None) or (maxm=None) or (minm=None):
+                            #self.log(f'Warning: missing arguements to conduct {mode} Sweep.') ### indicates that while power mode on, sweep
+                        #else:
+                            #if (mode == 'pow'): level = 'dBm'
+                            #elif (mode == 'freq'): level = 'GHz'
+                            #dwellunit = 'us' ### is it in microseconds?
+                            #self.eq.write(f'{mode} step {step} {level})
+                            #self.eq.write(f'{mode} dwel1 {dwell} {dwellunit})
+                            #self.eq.write(f'{mode} star {minm} {level}')
+                            #self.eq.write(f'{mode} stop {maxm} {level}')
+                            ### write checks to see if values are actually written to Output
+                            #self.eq.write(f'init imm')
+                        #return y                          
+                    #else: 
+                        #self.log(f'Warning: Setting {mode} Sweep state to {sstate}, but was asked for {state}.')
+                        #return y
+                #except:
+                    #self.log(f'Error while changing {mode} Sweep state.', log='important')
+                    #return np.nan
+        #else:
+            #self.log(f'Warning: mode for sweep was not specified.', log=log)
+            #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:
+            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
+        
+        else:
+            if f is None and duty is not None:
+                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 is None:
+                f_write = max(self.pulsef_limits[0], min(float(f), self.pulsef_limits[1]))
+                duty_write = 50.0
+                T = 1.0 / f
+                w = duty_write * T / 100.0
+                self.eq.write(f'puls:per {T} ms')
+                self.eq.write(f'puls:widt {w} ms')
+
+            elif f is not None and duty is not None:
+                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
+                w = duty_write * T / 100.0
+                self.eq.write(f'puls:per {T} ms')
+                self.eq.write(f'puls:widt {w} ms')
+
+            check = self.pulse()
+            return check
+
+
+    #def pulse(self, on_off=None, freq=None, duty_cycle=None, int_ext=None, log=None):
+    ### Always has a return! Which is the state, freq, duty cycle, and source of pulse
+    ### Frequency in KHz, Duty Cycle in %, source int(ernal) or ext(ernal)
+    ### pulse() reads and returns state, frequency, duty cycle, and source of pulse
+    ### pulse(1,1,50,int) writes state ON, frequency 1KHz, duty cycle 50%, and internal mode to Pulse
+    ### pulse(1,1,50,int) returns the state, frequency, duty cycle, and source that was actually sent to the equipment
+    ### pulse(1,1,50,int) returns the state, frequency, duty cycle, and source queried after writing
+        #if log is None: log=self.eq_default_log
+        #if (on_off is None) and (freq is None) and (duty_cycle is None) and (int_ext is None): 
+        ### Accesser Code - returns whats on equipment object
+            #try:
+                #y = self.eq.query('pulm:stat?')
+                #y = int(y)
+                #f = float(self.eq.query('puls:freq?')) / 10.0**3
+                    # returns in Khz
+                #dc = float(self.eq.query('puls:widt?')) * f * 10.0**5
+                    # returns in %
+                #x = self.eq.query('pulm:sour?')
+                #x = x[:-1].lower()
+                    # returns in lowercase
+                #self.log(f'Pulse state is {y}, frequency {f} KHz, duty-cycle {dc}%, source {x}.', log=log)
+                #return [y, f, dc, x]
+            #except:
+                #self.log(f'Error while reading Pulse state.', log='important')
+                #return np.nan
+        #else: 
+        ### Mutator Code - Writes to equipment object
+            #if (on_off == 1) or (on_off == 'on') or (on_off=='ON') or (on_off=='On'): state = 1
+            #else: state = 0
+            #error = False
+            #if (int_ext == 'int') or (int_ext == 'ext') or (int_ext == 'INT') or (int_ext == 'EXT'): 
+                ### writes mode (int/ext)
+                    #try:
+                        #self.eq.write(f'pulm:sour {int_ext}')
+                        #y = self.eq.query('pulm:sour?')
+                        #y = y[:-1].lower()
+                        #if (str(y) == str(int_ext.lower())): self.log(f'Setting Pulse to {int_ext}.', log=log)
+                        #else: self.log(f'Warning:Setting Pulse to {y[3]}, but was asked {int_ext}.', log='important')
+                    #except: 
+                        #self.log(f'Error while changing Pulse Source.', log='important')
+                        #return np.nan 
+            #elif (int_ext is not None): self.log(f'Error: Invalid Pulse Source.', log='important')
+            #if (freq is None) and (duty_cycle is not None): 
+            ### if frequency and duty cycle not in ratio, changes duty cycle to acceptable value
+                #try:
+                    #writeduty_cycle = float(duty_cycle)
+                    #writeduty_cycle = max(self.pulsedc_limits[0], min(writeduty_cycle, self.pulsedc_limits[1])) # sets writeduty_cycle within pulsedc_limits
+                    #y = float(self.eq.query(f'puls:freq?')) / 1000.0 #returns in KHz
+                    #writefreq = y
+                    #width = writeduty_cycle * 0.01 / writefreq # units of ms
+                    #width = max(self.pulsew_limits[0], min(width, self.pulsew_limits[1]))
+                    #wdth = ceil(width * 1000.0) / 1000.0
+                    #idth = round(width, self.pulsew_digits)
+                    #lf.eq.write(f'puls:widt {width} ms')
+               #except:
+                   #self.log(f'Error while changing Duty Cycle within limits.', log='important')
+                   #error = True
+                   #return np.nan              
+           #elif (duty_cycle is None) and (freq is not None):
+            ### if frequency and duty cycle not in ratio, changes frequency to acceptable value
+             #  try:
+              #     writeduty_cycle = 50.0
+               #    writefreq = round(freq, self.pulsef_digits) # rounding the digits
+                #   writefreq = max(self.pulsef_limits[0], min(writefreq, self.pulsef_limits[1])) # sets writeduty_cycle within pulsedc_limits
+                 #  print(writefreq)
+                  # width = writeduty_cycle * 0.01 / writefreq # units of ms
+                #   width = max(self.pulsew_limits[0], min(width, self.pulsew_limits[1]))
+                #   width = ceil(width * 1000.0) / 1000.0 
+                  #width = round(width, self.pulsew_digits)
+                #   print(width)
+                #   self.eq.write(f'puls:freq {writefreq} KHz')
+                #   self.eq.write(f'puls:widt {width} ms')
+              # except:
+                #  print(width)
+               #    self.log(f'Error while changing Pulse Frequency within limits.', log='important')
+                 #  error = True
+                  # return np.nan 
+           #elif (freq is not None) and (duty_cycle is not None):
+            ### writing both duty cycle and frequency
+              # writeduty_cycle = float(duty_cycle) # rounding the digits
+              # writeduty_cycle = max(self.pulsedc_limits[0], min(writeduty_cycle, self.pulsedc_limits[1])) # sets writeduty_cycle within pulsedc_limits
+              # writefreq = round(freq, self.pulsef_digits) # rounding the digits
+              # writefreq = max(self.pulsef_limits[0], min(writefreq, self.pulsef_limits[1])) # sets writeduty_cycle within pulsedc_limits
+              # try:
+                  # width = writeduty_cycle * 0.01 / writefreq # units of ms
+                  #width = max(self.pulsew_limits[0], min(width, self.pulsew_limits[1]))
+                  # width = ceil(width * 1000.0) / 1000.0
+                  # width = round(width, self.pulsew_digits)
+                   #self.eq.write(f'puls:freq {writefreq} KHz')
+                   #self.eq.write(f'puls:widt {width} ms')
+                #xcept: 
+                #  self.log(f'Error while writing Duty Cycle.', log='important')
+                 #  self.log(f'Error while writing Pulse Frequency.', log='important') 
+                  # error = True
+                  # return np.nan              
+           #y = self.pulse(log='no')
+            ### returns the actual parameters written to machine to be compared 
+           #if (freq is not None) and (error == False): 
+               ### Checker Code
+            #   if abs(y[1] - freq)< 10**(-self.pulsef_digits): self.log(f'Writing Pulse Frequency as {y[1]}.', log=log)
+             # else: self.log(f'Warning:Writing Pulse Frequency as {y[1]}, but was asked {freq}.', log='important')
+           #if (duty_cycle is not None) and (error == False):
+                ### Checker Code
+             #  if abs(y[2] - duty_cycle)<10**(-3): self.log(f'Writing Pulse duty cycle as {y[2]}.', log=log)
+              # else: self.log(f'Warning:Writing Pulse duty cycle as {y[2]}, but was asked {duty_cycle}.', log='important')
+           #if (on_off is not None):
+            #   try:
+             #      self.eq.write(f'pulm:stat {on_off}')
+              #     x = self.eq
+               #    y = self.pulse(log='no')
+                #   if y[0] == state: self.log(f'Pulse state set to {on_off}.')
+                 #  else: self.log(f'Warning: Setting Pulse state to {sstate}, but was asked for {on_off}.')
+                #xept:
+                #   self.log(f'Error while changing Pulse state.', log='important')
+                 #  error = True
+                  # return np.nan
+           #if (error == False): return y
+           #else: return np.nan
+

barsukov/logger.py

@@ -0,0 +1,123 @@
+### BEGIN Dependencies ###
+import os
+from barsukov.time import time_stamp
+### END Dependencies ###
+
+class Logger:
+    """
+    ### 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'.
+    ###
+    """
+    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)
+        
+        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.
+        
+        #
+        if start_file:
+            self.start_file()
+        else:
+            self.file = None
+        
+        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 = '_' + description
+        else:
+            description = ''
+        file_name = 'log_' + time_stamp() + description + '_.txt'
+        #print(file_name)
+        #print(full_folder_path)
+        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
+
+    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)
+            
+    
+    
+### 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,107 @@
+# This is unfinished
+
+
+#import pickle
+import os
+#import glob
+
+import obj_name, time_stamp
+
+class Obj2File:
+    def __init__(self, logger=None, log='default', script=None):
+        self.script = script
+        self.logger = logger
+        self.default_log = log
+        self.msg_deco = f'[Obj2File]'
+
+        if self.logger is None:
+            try: self.logger = self.script.logger
+            except: pass
+
+        self.mtj_calib_directory = '/Users/alexandrakorotneva/Desktop/2024-11-18 obj import test'
+        self.tosave = {}
+
+
+    def log(self, msg, log=None):
+        if log is None: log = self.default_log
+        if self.logger is not None:
+            try:
+                self.logger.log(f'{self.msg_deco} {msg}', log=log)
+                return
+            except: pass
+        print(f'{time_stamp()} {self.msg_deco} {msg}')
+        
+    def save(self, obj, directory=None, full_file=None, short_file=None, log='default'):
+        if full_file is None:
+            if directory is None: directory = self.script.full_folder_path #current measurement folder
+            if short_file is None: short_file = f'{time_stamp()}_{obj_name(obj)}.pkl'
+            full_file = os.path.join(directory, short_file)
+        try:
+            with open(full_file, 'wb') as file:
+                pickle.dump(obj, file)
+                self.log(f'Object {obj_name(obj)} is written to file {full_file}.', log=log)
+        except:
+            self.log('Error: could not write object to file.', log='important')
+
+    def load(self, directory=None, full_file=None, short_file=None, log='default'):
+        if full_file is None:
+            if directory is None:
+                directory = self.script.full_folder_path
+            if short_file is None:
+                files = [f for f in glob.glob(os.path.join(directory, '*.pkl'))]
+                short_file = files[0]
+            full_file = os.path.join(directory, short_file)
+            
+        try:
+            with open(filepath, 'rb') as file:
+                toload = pickle.load(file)
+                self.log(f'Object is uploaded from file {full_file}.', log=log)
+        except:
+            self.log('Error: could not upload object from file.', log='important')        
+        return toload
+
+ 
+    
+
+    def mtj_fieldcalib(self, directory=None, upd=False, log='default', spl_ind=None):
+        if directory is None: directory = self.mtj_calib_directory
+        else:
+            if upd: 
+                self.mtj_calib_directory = directory
+                self.log(f'MTJ station field calibration directory has been updated to {directory}', log='important')
+
+        files = [f for f in glob.glob(os.path.join(directory, '*.pkl'))]
+        if len(files)==1:
+            short_file = files[0]
+        else:
+            ##
+
+        full_file = os.path.join(directory, short_file)
+        splines = self.load(full_file=full_file, log=log)
+
+        if spl_ind is None:
+            return: splines
+        elif spl_ind=='c':
+            return: splines['cheap_to_H']
+        elif spl_ind=='v':
+            return: Vsplines['V_to_H']
+        elif spl_ind=='h':
+            return: splines['H_to_V']
+
+    def pack_tosave(self, obj, obj_name=None, overwrite=False, save=False):
+        #prepares a dictionary {'obj name':obj, ...}
+        tosave = self.tosave
+        if obj_name is None: obj_name = obj_name(obj)
+                
+        if overwrite:
+            tosave.update({obj_name : obj})
+        else: 
+            add = tosave.setdefault(obj_name, obj) #for already excisting name returns corresponding element and doesn't overwrite
+            if add!=obj:
+                print(f'Overwriting attempt!')
+       
+        self.tosave = tosave
+        if save:
+            self.save(tosave)
+        return tosave
+

barsukov/script.py

@@ -0,0 +1,82 @@
+from barsukov.time import *
+from barsukov.logger import Logger
+
+import sys
+import os
+
+class Script():
+    def __init__(self,
+        ### Please ALWAYS specify the following:
+        operator='Anon', # ib, Rundong, Sasha, Ameerah, Alex, or AlexH if ambiguous  
+        station='No Stn', # qd, ppms, mseppms, data, orange, ...
+        sample='No Sample', # Use sample name from the sample table, e.g. "cro2410a1" or "yig2207"
+        description='No Description', # Briefly: what are you doing. Sets the folder name.
+        # i.e. 'Testing modulation' or 'fH OOP long average'
+        project_folder = os.getcwd(), # Full path to your project folder. Please follow this convention:
+        # D:/Rundong/Projects/AFM sims/2024-07-06 Autooscillations
+        # Will grab the current directory if not specified.
+
+        ### Optional:
+        log='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.
+
+        ### Usually, it's better not to change these:
+        log_full_folder_path=None,
+        log_full_file_path=None 
+        ):
+        
+        self.operator = operator
+        self.station = station
+        self.sample = sample
+        self.description = description
+        self.project_folder = project_folder
+
+        self.rm = None
+        
+        ### Creating the sub-project folder
+        self.folder_name = 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)
+
+        ### Starting the logger
+        if log_full_folder_path is None:
+            self.logger = Logger(
+                description=self.operator + '_' + self.description,
+                full_file_path=log_full_file_path,
+                log=log, # Script.log becomes Logger's default
+                start_file=True)
+        else:
+            self.logger = Logger(
+                description=self.operator + '_' + self.description,
+                full_folder_path=log_full_folder_path,
+                full_file_path=log_full_file_path,
+                log=log, # Script.log becomes Logger's default
+                start_file=True) 
+        
+        self.logger.log(f'Script object initialized. Logger started.', log='both')
+        
+    def log(self, msg, log='default'): # default means the default of the logger
+        self.logger.log(msg, log=log)
+    
+
+### BEGIN: Equipment related stuff
+
+    def init_rm(self):
+    # Imports pyvisa as method library #
+        import pyvisa as visa # ----------------XXX Can this be done like this??????????????
+        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
+
+### BEGIN Equipment devices
+    
+    def mwHP(self, **kwargs):
+        from barsukov.src.exp.mwHP import mwHP as eq
+        return eq(**kwargs, script=self, logger=self.logger)

barsukov/time.py

@@ -0,0 +1,16 @@
+### BEGIN Dependencies ###
+import datetime
+from pytz import timezone
+### END Dependencies ###
+
+TIMEZONE = timezone('America/Los_Angeles')
+
+def time_stamp(): # YYYY-MM-DD_HH-MM-SSS, last digit is 1/10th of the second
+    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(): # YYYY-MM-DD
+    now = datetime.datetime.now(TIMEZONE)
+    formatted_datetime = now.strftime(f"%Y-%m-%d")
+    return formatted_datetime

barsukov-0.0.1.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.2
+Name: barsukov
+Version: 0.0.1
+Summary: Experiment Automation Package
+Author-email: Igor Barsukov <igorb@ucr.edu>
+Maintainer-email: 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.8
+Description-Content-Type: text/markdown
+Requires-Dist: pytz>=2014.10
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: scipy>=1.15.1
+
+# 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.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+barsukov/__init__.py,sha256=gFsPiZHKeV_2ssxYqUO-xAa22CpXepwuFbTghauXzo4,280
+barsukov/logger.py,sha256=kWSiJJSjI4EtCxW5fyAww-6BQAFnCk-Gv8OIdtXH5pg,5275
+barsukov/obj2file.py,sha256=kNEDM7wcAUbeg7qbztZrKsxcOQEi2JmB-qQzaOO50Cc,3879
+barsukov/script.py,sha256=R-8ai8LMO3m4quoHrKXBgoLTlDGX7AeRj6XbVZEunbA,3383
+barsukov/time.py,sha256=6YVvay-ISO5VpyHG8WGUelGfaN1N18ktRrP37MVbdyU,552
+barsukov/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+barsukov/data/fft.py,sha256=VwY1h0ZB8xy_mxoI8zPESRLM7nk5NbiGi3wC6vg6T-k,4452
+barsukov/exp/__init__.py,sha256=urLfGpap40kN9ULi53JB0NT-iMsZDSFdBmdSq3ckB0E,19
+barsukov/exp/exp_utils.py,sha256=jpmSt-4XGwK4QWR8SEi1s0JPwUavO8Smmc4y6bO0giU,4091
+barsukov/exp/mwHP.py,sha256=auZmIgxtbZyzS_x0jk5uhNHioAuJKnAUHeB-fJoSF3w,19023
+barsukov-0.0.1.dist-info/METADATA,sha256=3aX_sWC9hbJcqxKSA2eSpvIVLdKgQG0T_-XPm7RhESM,858
+barsukov-0.0.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+barsukov-0.0.1.dist-info/top_level.txt,sha256=Js5sHbNjP0UNMB9O5HtCHZqlfHabuNS8nTsHbg-1DDQ,9
+barsukov-0.0.1.dist-info/RECORD,,

barsukov-0.0.1.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.1.dist-info/top_level.txt

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