def __init__(self,
instruments,
scripts=None,
name=None,
settings=None,
log_function=None,
data_path=None):
"""
Example of a script that emits a QT signal for the gui
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self,
name,
settings,
instruments,
scripts,
log_function=log_function,
data_path=data_path)
# defines which daqs contain the input and output based on user selection of daq interface
if self.settings['daq_type'] == 'PCI':
self.daq_in = self.instruments['NI6259']['instance']
self.daq_out = self.instruments['NI6259']['instance']
elif self.settings['daq_type'] == 'cDAQ':
self.daq_in = self.instruments['NI9402']['instance']
self.daq_out = self.instruments['NI9263']['instance']
def __init__(self,
instruments=None,
scripts=None,
name=None,
settings=None,
log_function=None,
data_path=None):
"""
Sets up script and sends width and height settings to camera
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self,
name,
settings=settings,
instruments=instruments,
scripts=scripts,
log_function=log_function,
data_path=data_path)
self.instruments['Camera']['instance'].update({
'width':
self.settings['width'],
'height':
self.settings['height']
})
def __init__(self,
instruments,
name=None,
settings=None,
log_function=None,
timeout=1000000000,
data_path=None):
self._recording = False
self._timeout = timeout
Script.__init__(self,
name,
settings,
instruments,
log_function=log_function,
data_path=data_path)
self.sweeper = self.instruments['zihf2']['instance'].daq.sweep(
self._timeout)
self.sweeper.set('sweep/device',
self.instruments['zihf2']['instance'].device)
self.data = deque()
# todo: clean this up! and plot data in gui!
self._sweep_values = list({
'frequency': [],
'x': [],
'y': [],
'phase': [],
'r': []
}.keys())
def __init__(self,
instruments,
scripts=None,
name=None,
settings=None,
log_function=None,
data_path=None):
"""
Example of a script that emits a QT signal for the gui
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self,
name,
settings=settings,
scripts=scripts,
instruments=instruments,
log_function=log_function,
data_path=data_path)
self.data = {
'plant_output': deque(maxlen=self.settings['buffer_length']),
'control_output': deque(maxlen=self.settings['buffer_length'])
}
def __init__(self,
scripts,
name=None,
settings=None,
log_function=None,
timeout=1000000000,
data_path=None):
self._recording = False
self._timeout = timeout
Script.__init__(self,
name,
settings,
scripts=scripts,
log_function=log_function,
data_path=data_path)
self.data = deque()
self._sweep_values = list({
'frequency': [],
'x': [],
'y': [],
'phase': [],
'r': []
}.keys())
def __init__(self,
instruments=None,
name=None,
settings=None,
scripts=None,
log_function=None,
data_path=None):
Script.__init__(self,
name,
settings=settings,
instruments=instruments,
scripts=scripts,
log_function=log_function,
data_path=data_path)
self.data = {
'baseline_image': [],
'baseline_extent': [],
'new_image': [],
'new_image_extent': [],
'initial_galvo_position': [],
'shift': [],
'correlation_image': []
}
self.baseline_processed_image = self.data['baseline_image']
self.new_processed_image = self.data['new_image']
self.count_executions = 0 # counts how often the script has been updated
def __init__(self,
instruments=None,
name=None,
settings=None,
scripts=None,
log_function=None,
data_path=None):
"""
Example of a script that emits a QT signal for the gui
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self,
name,
settings=settings,
instruments=instruments,
scripts=scripts,
log_function=log_function,
data_path=data_path)
self.data = {
'baseline_image': [],
'new_image': [],
'image_extent': [],
'correlation_image': []
}
def __init__(self,
instruments,
scripts=None,
name=None,
settings=None,
log_function=None,
data_path=None):
"""
Example of a script that emits a QT signal for the gui
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self,
name,
settings=settings,
scripts=scripts,
instruments=instruments,
log_function=log_function,
data_path=data_path)
self.data_to_plot = {
'voltage': deque(maxlen=self.settings['max_len_to_plot'])
}
self.data['voltage'] = list()
def __init__(self,
instruments,
scripts=None,
name=None,
settings=None,
log_function=None,
data_path=None):
"""
Example of a script that emits a QT signal for the gui
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self,
name,
settings=settings,
scripts=scripts,
instruments=instruments,
log_function=log_function,
data_path=data_path)
self.data = {
'counts': deque(),
'laser_power': deque(),
'normalized_counts': deque(),
'laser_power2': deque()
}
def __init__(self, scripts, instruments = None, name = None, settings = None, log_function = None, data_path = None):
"""
Example of a script that emits a QT signal for the gui
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self, name, settings, instruments, scripts, log_function= log_function, data_path = data_path)
def __init__(self, name=None, settings=None, log_function = None, data_path = None):
"""
Example of a script
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self, name, settings, log_function= log_function, data_path = data_path)
def __init__(self, name=None, settings=None, log_function = None, data_path = None):
"""
Example of a script
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self, name, settings, log_function= log_function, data_path = data_path)
def __init__(self, instruments = None, scripts = None, name = None, settings = None, log_function = None, data_path = None):
"""
Example of a script that emits a QT signal for the gui
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self, name, settings = settings, instruments = instruments, scripts = scripts, log_function= log_function, data_path = data_path)
def __init__(self, instruments, scripts=None, name=None, settings=None, log_function=None, data_path=None):
"""
init script function see superclass for details on the parameters
"""
Script.__init__(self, name, settings=settings, scripts=scripts, instruments=instruments,
log_function=log_function, data_path=data_path)
self.data = None
def __init__(self, scripts, instruments = None, name = None, settings = None, log_function = None, data_path = None):
"""
Initializes the script
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
self.scan_label = 'Motor Position [um]'
Script.__init__(self, name, settings, instruments, scripts, log_function= log_function, data_path = data_path)
def __init__(self, instruments, scripts = None, name=None, settings=None, log_function=None, data_path = None):
Script.__init__(self, name, settings=settings, scripts=scripts, instruments=instruments, log_function=log_function, data_path = data_path)
# defines which daqs contain the input and output based on user selection of daq interface
if self.settings['daq_type'] == 'PCI':
self.daq_in = self.instruments['NI6259']['instance']
self.daq_out = self.instruments['NI6259']['instance']
elif self.settings['daq_type'] == 'cDAQ':
self.daq_in = self.instruments['NI9402']['instance']
self.daq_out = self.instruments['NI9263']['instance']
def __init__(self, instruments = None, scripts = None, name = None, settings = None, log_function = None, data_path = None):
"""
Sets up script and sends width and height settings to camera
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self, name, settings = settings, instruments = instruments, scripts = scripts, log_function= log_function, data_path = data_path)
self.instruments['Camera']['instance'].update({'width': self.settings['width'], 'height': self.settings['height']})
def __init__(self, scripts, name = None, settings = None, log_function = None, timeout = 1000000000, data_path = None):
self._recording = False
self._timeout = timeout
Script.__init__(self, name, settings, scripts = scripts, log_function= log_function, data_path = data_path)
self.data = deque()
self._sweep_values = list({'frequency' : [], 'x' : [], 'y' : [], 'phase': [], 'r':[]}.keys())
def __init__(self, instruments = None, name = None, settings = None, scripts = None, log_function = None, data_path = None):
"""
Example of a script that emits a QT signal for the gui
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self, name, settings = settings, instruments = instruments, scripts = scripts, log_function= log_function, data_path = data_path)
self.data = {'baseline_image': [], 'new_image': [], 'image_extent': [], 'correlation_image': []}
def __init__(self, instruments, scripts, name=None, settings=None, log_function=None, data_path=None):
"""
Standard script initialization
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
self._DEFAULT_SETTINGS += PulsedExperimentBaseScript._DEFAULT_SETTINGS
Script.__init__(self, name, settings=settings, scripts=scripts, instruments=instruments,
log_function=log_function, data_path=data_path)
def __init__(self, instruments, scripts=None, name=None, settings=None, log_function=None, data_path=None):
"""
Example of a script that emits a QT signal for the gui
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self, name, settings=settings, scripts=scripts, instruments=instruments,
log_function=log_function, data_path=data_path)
self.data = {'counts': deque(), 'laser_power': deque(), 'normalized_counts': deque(), 'laser_power2': deque()}
def __init__(self, instruments, name = None, settings = None, log_function = None, data_path = None):
"""
Example of a script that makes use of an instrument
Args:
instruments: instruments the script will make use of
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
# call init of superclass
Script.__init__(self, name, settings, instruments, log_function= log_function, data_path = data_path)
def __init__(self, instruments, scripts=None, name=None, settings=None, log_function=None, data_path=None):
"""
Example of a script that emits a QT signal for the gui
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self, name, settings=settings, scripts=scripts, instruments=instruments,
log_function=log_function, data_path=data_path)
self.data_to_plot = {'voltage': deque(maxlen = self.settings['max_len_to_plot'])}
self.data['voltage'] = list()
def __init__(self, instruments = None, scripts = None, name = None, settings = None, log_function = None, data_path = None):
"""
Example of a script that emits a QT signal for the gui
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self, name, settings = settings, instruments = instruments, scripts = scripts, log_function= log_function, data_path = data_path)
if self.settings['daq_type'] == 'PCI':
self.daq_out = self.instruments['NI6259_laser_power']['instance']
elif self.settings['daq_type'] == 'cDAQ':
self.daq_out = self.instruments['NI9263_laser_power']['instance']
def __init__(self, scripts, instruments = None, name = None, settings = None, log_function = None, data_path = None):
"""
Example of a script that emits a QT signal for the gui
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
Script.__init__(self, name, settings, instruments, scripts, log_function= log_function, data_path = data_path)
#always want to use the autofocus's location
self.scripts['find_NV'].settings['center_on_current_location'] = True
self.scripts['set_laser'].settings['point'] = self.scripts['take_image'].settings['point_a']
self.scripts['set_laser'].run()
def __init__(self, scripts, name=None, settings=None, log_function=None, data_path=None):
'''
Initializes GalvoScan script for use in gui
Args:
instruments: list of instrument objects
name: name to give to instantiated script object
settings: dictionary of new settings to pass in to override defaults
log_function: log function passed from the gui to direct log calls to the gui log
data_path: path to save data
'''
self._DEFAULT_SETTINGS = self._DEFAULT_SETTINGS + GalvoScanGeneric._DEFAULT_SETTINGS
Script.__init__(self, name, settings=settings, scripts=scripts, log_function=log_function, data_path = data_path)
def __init__(self,
instruments,
scripts=None,
name=None,
settings=None,
log_function=None,
data_path=None):
Script.__init__(self,
name,
settings=settings,
scripts=scripts,
instruments=instruments,
log_function=log_function,
data_path=data_path)
def __init__(self, instruments, name = None, settings = None, log_function = None, timeout = 1000000000, data_path = None):
self._recording = False
self._timeout = timeout
Script.__init__(self, name, settings, instruments, log_function= log_function, data_path = data_path)
self.sweeper = self.instruments['zihf2']['instance'].daq.sweep(self._timeout)
self.sweeper.set('sweep/device', self.instruments['zihf2']['instance'].device)
self.data = deque()
# todo: clean this up! and plot data in gui!
self._sweep_values = list({'frequency' : [], 'x' : [], 'y' : [], 'phase': [], 'r':[]}.keys())
def __init__(self,
scripts,
name=None,
settings=None,
log_function=None,
timeout=1000000000,
data_path=None):
Script.__init__(self,
name,
scripts=scripts,
settings=settings,
log_function=log_function,
data_path=data_path)
def __init__(self, instruments = None, name = None, settings = None, scripts = None, log_function = None, data_path = None):
Script.__init__(self, name, settings = settings, instruments = instruments, scripts = scripts, log_function= log_function, data_path = data_path)
self.data = {'baseline_image': [],
'baseline_extent':[],
'new_image': [],
'new_image_extent': [],
'initial_galvo_position':[],
'shift': [],
'correlation_image': []
}
self.baseline_processed_image = self.data['baseline_image']
self.new_processed_image = self.data['new_image']
self.count_executions = 0 # counts how often the script has been updated
def export_default_scripts(target_folder,
source_folder=None,
raise_errors=False,
verbose=False):
"""
tries to instantiate all the scripts that are imported in /scripts/__init__.py
saves each script that could be instantiated into a .b26 file in the folder path
Args:
target_folder: target path for .b26 files
source_folder: location of python script files
"""
scripts_to_load = get_classes_in_folder(source_folder, Script)
if verbose:
print(('attempt to load {:d} scripts: '.format(len(scripts_to_load))))
loaded_scripts, failed, loaded_instruments = Script.load_and_append(
scripts_to_load, raise_errors=raise_errors)
for name, value in loaded_scripts.items():
filename = os.path.join(target_folder, '{:s}.b26'.format(name))
value.save_b26(filename)
if verbose:
print('\n================================================')
print('================================================')
print(
('saved {:d} scripts, {:d} failed'.format(len(loaded_scripts),
len(failed))))
if failed != {}:
for error_name, error in failed.items():
print(('failed to create script: ', error_name, error))
def __init__(self,
instruments=None,
name=None,
settings=None,
log_function=None,
data_path=None):
"""
Default script initialization
"""
Script.__init__(self,
name,
settings=settings,
instruments=instruments,
log_function=log_function,
data_path=data_path)
def test_loading_and_saving(self):
from pylabcontrol.core.read_write_functions import load_b26_file
filename = "Z:\Lab\Cantilever\Measurements\\__tmp\\XYX.b26"
scripts, loaded_failed, instruments = Script.load_and_append(
{"some script": 'ScriptDummyWithInstrument'})
script = scripts['some script']
script.save_b26(filename)
data = load_b26_file(filename)
scripts = {}
instruments = {}
scripts, scripts_failed, instruments_2 = Script.load_and_append(
data['scripts'], scripts, instruments)
def test_load_and_append_from_file(self):
from pylabcontrol.core.read_write_functions import load_b26_file
filename = 'C:\\Users\Experiment\PycharmProjects\\user_data\pythonlab_config_lev_test.b26'
in_data = load_b26_file(filename)
instruments = in_data[
'instruments'] if 'instruments' in in_data else {}
scripts = in_data['scripts'] if 'scripts' in in_data else {}
probes = in_data['probes'] if 'probes' in in_data else {}
script_info = list(scripts.values())[0]
module, script_class_name, script_settings, script_instruments, script_sub_scripts, script_doc, package = Script.get_script_information(
script_info)
print(('module', module.__name__.split('.')[0]))
print(('script_class_name', script_class_name))
print(('package', script_info['package']))
assert module.__name__.split('.')[0] == script_info['package']
instruments_loaded, failed = Instrument.load_and_append(instruments)
if len(failed) > 0:
print(('WARNING! Following instruments could not be loaded: ',
failed))
print(
'========================================================================\n\n'
)
scripts_loaded, failed, instruments_loaded = Script.load_and_append(
script_dict=scripts, instruments=instruments_loaded)
def __init__(self, scripts, instruments = None, name = None, settings = None, log_function = None, data_path = None):
"""
Example of a script that emits a QT signal for the gui
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
self.scan_label = 'Piezo Voltage [V]'
try:
Script.__init__(self, name, settings, instruments, scripts, log_function= log_function, data_path = data_path)
except:
import sys
import traceback
exc_type, exc_value, exc_traceback = sys.exc_info()
print("*** print_exception:")
traceback.print_exception(exc_type, exc_value, exc_traceback,
limit=2, file=sys.stdout)
def to_dict(self):
"""
Returns: itself as a dictionary
"""
dictator = Script.to_dict(self)
# the dynamically created ScriptIterator classes have a generic name
# replace this with ScriptIterator to indicate that this class is of type ScriptIterator
dictator[self.name]['class'] = 'ScriptIterator'
return dictator
def __init__(self,
instruments,
scripts=None,
name=None,
settings=None,
log_function=None,
data_path=None):
"""
init script function see superclass for details on the parameters
"""
Script.__init__(self,
name,
settings=settings,
scripts=scripts,
instruments=instruments,
log_function=log_function,
data_path=data_path)
self.data = None
def __init__(self,
instruments=None,
scripts=None,
name=None,
settings=None,
log_function=None,
data_path=None):
"""
Select points by clicking on an image
"""
Script.__init__(self,
name,
settings=settings,
instruments=instruments,
scripts=scripts,
log_function=log_function,
data_path=data_path)
self.last_execution = None
def get_iterator_default_script(iterator_type):
"""
Returns:
sub_scripts: a dictionary with the default scripts for the script_iterator
script_settings: a dictionary with the script_settingsfor the default scripts
"""
sub_scripts = {}
script_settings = {}
package = 'b26_toolkit' # todo JG: mabye find a dynamic whay to get this
# for point iteration we add some default scripts
if iterator_type == 'iter nvs':
module = Script.get_script_module('SelectPoints')# Select points is actually in pylabcontrol
sub_scripts.update(
{'select_points': getattr(module, 'SelectPoints')}
)
module = Script.get_script_module('FindNV', package)
sub_scripts.update(
# {'find_nv': getattr(module, 'FindNV_cDAQ')}
{'find_nv': getattr(module, 'FindNV')}
)
module = Script.get_script_module('Take_And_Correlate_Images', package)
sub_scripts.update(
{'correlate_iter': getattr(module, 'Take_And_Correlate_Images', package)}
)
script_settings['script_order'] = {'select_points': -3, 'correlate_iter': -2, 'find_nv': -1}
elif iterator_type == 'iter points':
module = Script.get_script_module('SelectPoints', 'pylabcontrol')
sub_scripts.update(
{'select_points': getattr(module, 'SelectPoints')}
)
module = Script.get_script_module('SetLaser', package)
sub_scripts.update(
{'set_laser': getattr(module, 'SetLaser')}
)
module = Script.get_script_module('Take_And_Correlate_Images', package)
sub_scripts.update(
{'correlate_iter': getattr(module, 'Take_And_Correlate_Images')}
)
script_settings['script_order']={'select_points': -3, 'correlate_iter': -2, 'set_laser': -1}
elif iterator_type == 'test':
module = Script.get_script_module('Wait', 'pylabcontrol')
sub_scripts.update(
{'wait': getattr(module, 'Wait')}
)
return sub_scripts, script_settings
def __init__(self,
scripts,
name=None,
settings=None,
log_function=None,
data_path=None):
"""
Default script initialization
"""
Script.__init__(self,
name,
scripts=scripts,
settings=settings,
log_function=log_function,
data_path=data_path)
self.iterator_type = self.get_iterator_type(self.settings, scripts)
self._current_subscript_stage = None
self._skippable = True
def __init__(self,
instruments=None,
scripts=None,
name=None,
settings=None,
log_function=None,
data_path=None):
"""
Select points by clicking on an image
"""
Script.__init__(self,
name,
settings=settings,
instruments=instruments,
scripts=scripts,
log_function=log_function,
data_path=data_path)
self.text = []
self.patch_collection = None
self.plot_settings = {}
def plot(self, figure_list):
'''
Plots a dot on top of each selected NV, with a corresponding number denoting the order in which the NVs are
listed.
Precondition: must have an existing image in figure_list[0] to plot over
Args:
figure_list:
'''
# if there is not image data get it from the current plot
if not self.data == {} and self.data['image_data'] is None:
axes = figure_list[0].axes[0]
if len(axes.images) > 0:
self.data['image_data'] = np.array(axes.images[0].get_array())
self.data['extent'] = np.array(axes.images[0].get_extent())
self.plot_settings['cmap'] = axes.images[0].get_cmap().name
self.plot_settings['xlabel'] = axes.get_xlabel()
self.plot_settings['ylabel'] = axes.get_ylabel()
self.plot_settings['title'] = axes.get_title()
self.plot_settings['interpol'] = axes.images[
0].get_interpolation()
Script.plot(self, figure_list)
def test_xy8_double_init(self):
updated_scripts, load_failed, updated_instruments = Script.load_and_append({'XY8': 'XY8_double_init'},
package='b26_toolkit')
xy8 = updated_scripts['XY8']
xy8.update({'Tracking': {
'on/off': False}}) # turn off tracking because this will cause an error if we don't run findnv
print(xy8)
xy8.is_valid()
def __init__(self,
instruments,
scripts=None,
name=None,
settings=None,
log_function=None,
data_path=None):
Script.__init__(self,
name,
settings=settings,
scripts=scripts,
instruments=instruments,
log_function=log_function,
data_path=data_path)
# defines which daqs contain the input and output based on user selection of daq interface
if self.settings['daq_type'] == 'PCI':
self.daq_in = self.instruments['NI6259']['instance']
self.daq_out = self.instruments['NI6259']['instance']
elif self.settings['daq_type'] == 'cDAQ':
self.daq_in = self.instruments['NI9402']['instance']
self.daq_out = self.instruments['NI9263']['instance']
def __init__(self,
instruments,
name=None,
settings=None,
log_function=None,
data_path=None):
"""
Example of a script that makes use of an instrument
Args:
instruments: instruments the script will make use of
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
# call init of superclass
Script.__init__(self,
name,
settings,
instruments,
log_function=log_function,
data_path=data_path)
def __init__(self,
instruments,
scripts,
name=None,
settings=None,
log_function=None,
data_path=None):
"""
Standard script initialization
Args:
name (optional): name of script, if empty same as class name
settings (optional): settings for this script, if empty same as default settings
"""
self._DEFAULT_SETTINGS += PulsedExperimentBaseScript._DEFAULT_SETTINGS
Script.__init__(self,
name,
settings=settings,
scripts=scripts,
instruments=instruments,
log_function=log_function,
data_path=data_path)
def test_xy8_double_init(self):
updated_scripts, load_failed, updated_instruments = Script.load_and_append(
{'XY8': 'XY8_double_init'}, package='b26_toolkit')
xy8 = updated_scripts['XY8']
xy8.update(
{'Tracking': {
'on/off': False
}}
) # turn off tracking because this will cause an error if we don't run findnv
print(xy8)
xy8.is_valid()
def visualize_magnetic_fields(src_folder, target_folder, manual=True):
filepath = os.path.join(target_folder, os.path.dirname(src_folder).split('./')[1])
# load the fit_data
if manual:
# df = pd.read_csv(os.path.join(target_folder, '{:s}-manual.csv'.format(folder.split('./')[1].replace('/','-'))), index_col = 'id', skipinitialspace=True)
filename = '{:s}\\data-manual.csv'.format(os.path.basename(src_folder))
else:
filename = '{:s}.csv'.format(os.path.basename(src_folder))
# df = pd.read_csv(os.path.join(target_folder, '{:s}.csv'.format(folder.split('./')[1].replace('/','-'))), index_col = 'id', skipinitialspace=True)
df = pd.read_csv(os.path.join(filepath, filename), index_col='id', skipinitialspace=True)
df = df.drop('Unnamed: 0', 1)
# include manual corrections
if manual:
for id, nv_type in enumerate(df['manual_nv_type']):
if not pd.isnull(nv_type):
df.set_value(id, 'NV type', nv_type)
if nv_type == 'split':
df.set_value(id, 'B-field (gauss)', df.get_value(id, 'manual_B_field'))
# load the image data
select_points_data = Script.load_data(get_select_points(src_folder))
image_data = select_points_data['image_data']
# points_data = select_points_data['nv_locations']
extent = select_points_data['extent']
# prepare figure
f = plt.figure(figsize=(15, 8))
gs = gridspec.GridSpec(1, 2, height_ratios=[1, 1])
ax0 = plt.subplot(gs[0])
ax1 = plt.subplot(gs[1])
ax = [ax0, ax1]
# plot the map
ax0.imshow(image_data, extent=extent, interpolation='nearest', cmap='pink')
for nv_type, color in zip(['split', 'bad', 'no_peak', 'single'], ['g', 'k', 'b', 'r']):
subset = df[df['NV type'] == nv_type]
ax0.scatter(subset['xo'], subset['yo'], c=color, label=nv_type)
ax0.legend(bbox_to_anchor=(2.3, 1))
subset = df[df['NV type'] == 'split']
for i, j, n in zip(subset['xo'], subset['yo'], subset.index):
corr = +0.005 # adds a little correction to put annotation in marker's centrum
ax0.annotate(str(n), xy=(i + corr, j + corr), fontsize=8, color='w')
ax0.set_xlabel('x (V)')
ax0.set_ylabel('y (V)')
# plot the fields on a 1D plot
subset = df[df['NV type'] == 'split']
ax1.plot(subset['xo'], subset['B-field (gauss)'] / freq_to_mag * 1e-6, 'o')
ax1.set_title('ESR Splittings')
ax1.set_xlabel('x coordinate (V)')
ax1.set_ylabel('Splitting (MHz)')
ax1.set_xlim([extent[0], extent[1]])
ax2 = ax1.twinx()
mn, mx = ax1.get_ylim()
ax2.set_ylim(mn * freq_to_mag * 1e6, mx * freq_to_mag * 1e6)
ax2.set_ylabel('Magnetic Field Projection (Gauss)')
for i, j, n in zip(subset['xo'], subset['B-field (gauss)'] / freq_to_mag * 1e-6, subset.index):
corr = 0.0005 # adds a little correction to put annotation in marker's centrum
ax1.annotate(str(n), xy=(i + corr, j + corr))
# f.set_tight_layout(True)
# f.savefig(os.path.join(target_folder, '{:s}.jpg'.format(os.path.basename(folder))),
# bbox_inches='tight',
# # transparent=True,
# pad_inches=0)
f.savefig(os.path.join(filepath, '{:s}.jpg'.format(os.path.basename(src_folder))),
bbox_inches='tight',
# transparent=True,
pad_inches=0)
def manual_correction(folder, target_folder, fit_data_set, nv_type_manual, b_field_manual, queue, current_id_queue, lower_peak_widget, upper_peak_widget, lower_fit_widget, upper_fit_widget):
"""
Backend code to display and fit ESRs, then once input has been received from front-end, incorporate the data into the
current data set
Args:
folders: folder containing the data to analyze
target_folder: target for processed data
fit_data_set: starting point data set containing automatically fitted esrs
nv_type_manual: pointer to empty array to populate with nv type manual corrections
b_field_manual: pointer to empty array to populate with b field manual corrections
queue: queue for communication with front-end in separate thread
lower_peak_widget: widget containing frequency value of lower peak
upper_peak_widget: widget containing frequency value of upper peak
Poststate: populates fit_data_set with manual corrections
"""
lower_peak_manual = [np.nan] * len(fit_data_set)
upper_peak_manual = [np.nan] * len(fit_data_set)
filepath = os.path.join(target_folder, folder[2:])
data_filepath = os.path.join(filepath, 'data-manual.csv')
if os.path.exists(data_filepath):
prev_data = pd.read_csv(data_filepath)
if 'manual_peak_1' in list(prev_data.keys()):
for i in range(0, len(prev_data['manual_B_field'])):
b_field_manual[i] = prev_data['manual_B_field'][i]
nv_type_manual[i] = prev_data['manual_nv_type'][i]
lower_peak_manual = prev_data['manual_peak_1']
upper_peak_manual = prev_data['manual_peak_2']
#TODO: Add saving as you go, add ability to start at arbitrary NV, add ability to specify a next NV number, eliminate peak/correct -> only have 'accept fit'
try:
print('STARTING')
fit_data_set_array = fit_data_set.as_matrix()
w = widgets.HTML("Event information appears here when you click on the figure")
display(w)
# loop over all the folders in the data_subscripts subfolder and retrieve fitparameters and position of NV
esr_folders = glob.glob(os.path.join(folder, '.\\data_subscripts\\*esr*'))
# create folder to save images to
# filepath_image = os.path.join(target_folder, os.path.dirname(folder).split('./')[1])
# image_folder = os.path.join(filepath_image, '{:s}\\images'.format(os.path.basename(folder)))
image_folder = os.path.join(target_folder, '{:s}\\images'.format(folder[2:]))
# image_folder = os.path.normpath(
# os.path.abspath(os.path.join(os.path.join(target_folder, 'images'), os.path.basename(folders[0]))))
if not os.path.exists(image_folder):
os.makedirs(image_folder)
if not os.path.exists(os.path.join(image_folder, 'bad_data')):
os.makedirs(os.path.join(image_folder, 'bad_data'))
f = plt.figure(figsize=(12, 6))
def onclick(event):
if event.button == 1:
if event.key == 'control':
lower_fit_widget.value = event.xdata
else:
lower_peak_widget.value = event.xdata
elif event.button == 3:
if event.key == 'control':
upper_fit_widget.value = event.xdata
else:
upper_peak_widget.value = event.xdata
cid = f.canvas.mpl_connect('button_press_event', onclick)
data_array = []
data_pos_array = []
for esr_folder in esr_folders:
print(esr_folder)
sys.stdout.flush()
data = Script.load_data(esr_folder)
data_array.append(data)
print('looping')
sys.stdout.flush()
nv_folders = glob.glob(folder + '\\data_subscripts\\*find_nv*pt_*')
for nv_folder in nv_folders:
data_pos_array.append(Script.load_data(nv_folder))
while True:
# for i, esr_folder in enumerate(esr_folders):
i = current_id_queue.queue[0]
if i >= len(data_array):
break
lower_fit_widget.value = 0
upper_fit_widget.value = 10e9
lower_peak_widget.value = 2.87e9
upper_peak_widget.value = 0
def display_data(pt_id, lower_peak_widget = None, upper_peak_widget = None, display_fit = True):
# find the NV index
# pt_id = int(os.path.basename(esr_folder).split('pt_')[-1])
# findnv_folder = glob.glob(folder + '\\data_subscripts\\*find_nv*pt_*{:d}'.format(pt_id))[0]
f.clf()
gs = gridspec.GridSpec(1, 2, width_ratios=[3, 1])
ax0 = plt.subplot(gs[0])
ax1 = plt.subplot(gs[1])
ax = [ax0, ax1]
plt.suptitle('NV #{:d}'.format(pt_id), fontsize=16)
# load data
data = data_array[i]
if lower_fit_widget.value == 0 and upper_fit_widget.value == 10e9:
freq = data['frequency']
ampl = data['data']
else:
freq = data['frequency'][np.logical_and(data['frequency'] > lower_fit_widget.value, data['frequency'] < upper_fit_widget.value)]
ampl = data['data'][np.logical_and(data['frequency'] > lower_fit_widget.value, data['frequency'] < upper_fit_widget.value)]
if lower_peak_widget is None:
fit_params = fit_data_set_array[pt_id, 2:8]
else:
lower_peak = lower_peak_widget.value
upper_peak = upper_peak_widget.value
if upper_peak == 0:
start_vals = get_lorentzian_fit_starting_values(freq, ampl)
start_vals[2] = lower_peak
start_vals[1] = ampl[np.argmin(np.abs(freq - lower_peak))] - start_vals[0]
try:
fit_params = fit_lorentzian(freq, ampl, starting_params=start_vals,
bounds=[(0, -np.inf, 0, 0), (np.inf, 0, np.inf, np.inf)])
except:
# ESR fit failed!
fit_params = [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]
else:
center_freq = np.mean(freq)
start_vals = []
start_vals.append(
get_lorentzian_fit_starting_values(freq[freq < center_freq], ampl[freq < center_freq]))
start_vals.append(
get_lorentzian_fit_starting_values(freq[freq > center_freq], ampl[freq > center_freq]))
start_vals = [
np.mean([start_vals[0][0], start_vals[1][0]]), # offset
np.sum([start_vals[0][3], start_vals[1][3]]), # FWHM
ampl[np.argmin(np.abs(freq-lower_peak))] - start_vals[0][0], ampl[np.argmin(np.abs(freq-upper_peak))]- start_vals[1][0], # amplitudes
lower_peak, upper_peak # centers
]
try:
fit_params = fit_double_lorentzian(freq, ampl, starting_params=start_vals, bounds=
[(0, 0, -np.inf, -np.inf, min(freq), min(freq)), (np.inf, np.inf, 0, 0, max(freq), max(freq))])
except:
fit_params = [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]
if len(fit_params) == 4 or np.isnan(fit_params[4]):
fit_params = fit_params[0:4]
# get nv positions
# data_pos = {'initial_point': [fit_data_set['xo'].values[pt_id]]}
data_pos = data_pos_array[i]
# pos = data_pos['maximum_point']
# pos_init = data_pos['initial_point']
# plot NV image
FindNV.plot_data([ax[1]], data_pos)
# plot data and fits
# print("fit_params: ", fit_params)
sys.stdout.flush()
if display_fit:
plot_esr(ax[0], data['frequency'], data['data'], fit_params=fit_params)
else:
plot_esr(ax[0], data['frequency'], data['data'], fit_params=[np.nan, np.nan, np.nan, np.nan, np.nan, np.nan])
plt.tight_layout()
plt.subplots_adjust(top=0.85) # Makes room at top of plot for figure suptitle
plt.draw()
plt.show()
return fit_params, pt_id
fit_params, pt_id = display_data(i)
if len(fit_params) == 6:
lower_peak_widget.value = fit_params[4]
upper_peak_widget.value = fit_params[5]
elif len(fit_params) == 4:
lower_peak_widget.value = fit_params[2]
upper_peak_widget.value = 0
while True:
if queue.empty():
time.sleep(.5)
else:
value = queue.get()
if value == -1:
fit_params, point_id = display_data(i, lower_peak_widget=lower_peak_widget, upper_peak_widget=upper_peak_widget)
if len(fit_params) == 6:
lower_peak_widget.value = fit_params[4]
upper_peak_widget.value = fit_params[5]
elif len(fit_params) == 4:
lower_peak_widget.value = fit_params[2]
upper_peak_widget.value = 0
continue
elif value == -2:
display_data(display_fit = False)
fit_params = [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]
lower_fit_widget.value = 0
upper_fit_widget.value = 10e9
else:
break
if nv_type_manual[i] == 'split':
if np.isnan(fit_params[0]):
lower_peak_manual[i] = lower_peak_widget.value
upper_peak_manual[i] = upper_peak_widget.value
b_field_manual[i] = ((upper_peak_widget.value - lower_peak_widget.value) / 5.6e6)
elif len(fit_params) == 4:
lower_peak_manual[i] = fit_params[2]
b_field_manual[i] = (np.abs(2.87e9-fit_params[2]) / 2.8e6)
else:
lower_peak_manual[i] = fit_params[4]
upper_peak_manual[i] = fit_params[5]
b_field_manual[i] = ((fit_params[5] - fit_params[4]) / 5.6e6)
elif nv_type_manual[i] == 'single':
if np.isnan(fit_params[0]):
lower_peak_manual[i] = lower_peak_widget.value
b_field_manual[i] = 0
else:
lower_peak_manual[i] = fit_params[2]
b_field_manual[i] = 0
if nv_type_manual[i] == '':
if fit_params is None:
f.savefig(os.path.join(os.path.join(image_folder, 'bad_data'), 'esr_pt_{:02d}.jpg'.format(pt_id)))
else:
f.savefig(os.path.join(image_folder, 'esr_pt_{:02d}.jpg'.format(pt_id)))
else:
if nv_type_manual[i] in ['bad', 'no_split']:
f.savefig(os.path.join(os.path.join(image_folder, 'bad_data'), 'esr_pt_{:02d}.jpg'.format(pt_id)))
else:
f.savefig(os.path.join(image_folder, 'esr_pt_{:02d}.jpg'.format(pt_id)))
if not os.path.exists(filepath):
os.makedirs(filepath)
fit_data_set['manual_B_field'] = b_field_manual
fit_data_set['manual_nv_type'] = nv_type_manual
fit_data_set['manual_peak_1'] = lower_peak_manual
fit_data_set['manual_peak_2'] = upper_peak_manual
fit_data_set.to_csv(data_filepath)
f.canvas.mpl_disconnect(cid)
fit_data_set['manual_B_field'] = b_field_manual
fit_data_set['manual_nv_type'] = nv_type_manual
fit_data_set['manual_peak_1'] = lower_peak_manual
fit_data_set['manual_peak_2'] = upper_peak_manual
# filepath = os.path.join(target_folder, folder[2:])
# data_filepath = os.path.join(filepath, 'data-manual.csv')
# filename = '{:s}\\data-manual.csv'.format(os.path.basename(folder))
# filepath = os.path.join(target_folder, os.path.dirname(folder).split('./')[1])
# data_filepath = os.path.join(filepath, filename)
if not os.path.exists(filepath):
os.makedirs(filepath)
fit_data_set.to_csv(data_filepath)
create_shortcut(os.path.abspath(os.path.join(filepath, 'to_data.lnk')), os.path.abspath(folder))
create_shortcut(os.path.join(os.path.abspath(folder), 'to_processed.lnk'), os.path.abspath(filepath))
print('DONE!')
except Exception as e:
print(e)
raise
def autofit_esrs(folder):
"""
fits the esr data, plots them and asks the user for confirmation, the fit data is saved to the folder target_folder with the same structure as folders
Args:
folders: source folder with esr data, this folder shoudl contain a subfolder data_subscripts which contains subfolders *esr* with the esr data
target_folder: target folder where the output data is saved in form of a .csv file
Returns: fitdataset as a pandas array
"""
# loop over all the folders in the data_subscripts subfolder and retrieve fitparameters and position of NV
esr_folders = glob.glob(os.path.join(folder, './data_subscripts/*esr*'))
fit_data_set = None
# classify the nvs according to the following categories
# by default we set this to na (not available) and try to figure it out based on the data and fitquality
# nv_type = 'na' # split / single / no_peak / no_nv / na
for i, esr_folder in enumerate(esr_folders):
# find the NV index
pt_id = int(os.path.basename(esr_folder).split('pt_')[-1])
findnv_folder = sorted(glob.glob(folder + '/data_subscripts/*find_nv*pt_*{:d}'.format(pt_id)))[0]
# load data
data = Script.load_data(esr_folder)
fit_params = fit_esr(data['frequency'], data['data'])
nv_type = get_nv_type(fit_params)
# get initial guess for peaks
freq_peaks, ampl_peaks = find_nv_peaks(data['frequency'], data['data'])
# get nv positions
data_pos = Script.load_data(findnv_folder)
pos = data_pos['maximum_point']
pos_init = data_pos['initial_point']
if fit_params is None:
fit_data_set_single = {}
else:
fit_data_set_single = {'fit_{:d}'.format(i): f for i, f in enumerate(fit_params)}
fit_data_set_single.update({'id': pt_id, 'NV type': nv_type})
fit_data_set_single.update({'x': pos['x'][0], 'y': pos['y'][0]})
fit_data_set_single.update({'xo': pos_init['x'][0], 'yo': pos_init['y'][0]})
fit_data_set_single.update({'B-field (gauss)': get_B_field(nv_type, fit_params)})
# convert to dataframe
fit_data_set_single = pd.DataFrame.from_dict({k: [v] for k, v in fit_data_set_single.items()})
if fit_data_set is None:
fit_data_set = pd.DataFrame(fit_data_set_single)
else:
fit_data_set = fit_data_set.append(fit_data_set_single, ignore_index=True)
return fit_data_set
def run(self):
"""
Code to run fitting routine. Should be run in a separate thread from the gui.
"""
esr_folders = glob.glob(os.path.join(self.filepath, './data_subscripts/*esr*'))
data_array = []
self.status.emit('loading data')
for esr_folder in esr_folders[:-1]:
data = Script.load_data(esr_folder)
data_array.append(data)
self.fits = self.load_fitdata()
self.status.emit('executing manual fitting')
index = 0
self.last_good = []
self.initial_fit = False
# for data in data_array:
while index < len(data_array):
data = data_array[index]
#this must be after the draw command, otherwise plot doesn't display for some reason
self.status.emit('executing manual fitting NV #' + str(index))
self.plotwidget.axes.clear()
self.plotwidget.axes.plot(data['frequency'], data['data'])
if index in self.fits['nv_id'].values:
fitdf = self.fits.loc[(self.fits['nv_id'] == index)]
offset = fitdf['offset'].as_matrix()[0]
centers = fitdf['fit_center'].as_matrix()
amplitudes = fitdf['fit_amplitude'].as_matrix()
widths = fitdf['fit_width'].as_matrix()
fit_params = np.concatenate((np.concatenate((widths, amplitudes)), centers))
self.plotwidget.axes.plot(data['frequency'], self.n_lorentzian(data['frequency'], *np.concatenate(([offset], fit_params))))
self.plotwidget.draw()
if not self.last_good == []:
self.initial_fit = True
self.queue.put('fit')
while(True):
if self.queue.empty():
time.sleep(.5)
else:
value = self.queue.get()
if value == 'next':
while not self.peak_vals == []:
self.last_good.append(self.peak_vals.pop(-1))
if self.single_fit:
to_delete = np.where(self.fits['nv_id'].values == index)
# print(self.fits[to_delete])
self.fits = self.fits.drop(self.fits.index[to_delete])
# for val in to_delete[0][::-1]:
# for key in self.fits.keys():
# del self.fits[key][val]
for peak in self.single_fit:
self.fits = self.fits.append(pd.DataFrame(peak))
index += 1
self.status.emit('saving')
self.save()
break
elif value == 'clear':
self.last_good = []
self.plotwidget.axes.clear()
self.plotwidget.axes.plot(data['frequency'], data['data'])
self.plotwidget.draw()
elif value == 'fit':
if self.initial_fit:
input = self.last_good
else:
input = self.peak_vals
if len(input) > 1:
centers, heights = list(zip(*input))
widths = 1e7 * np.ones(len(heights))
elif len(input) == 1:
centers, heights = input[0]
widths = 1e7
elif len(input) == 0:
self.single_fit = None
self.peak_locs.setText('No Peak')
self.plotwidget.axes.plot(data['frequency'],np.repeat(np.mean(data['data']), len(data['frequency'])))
self.plotwidget.draw()
continue
offset = np.mean(data['data'])
amplitudes = offset-np.array(heights)
if len(input) > 1:
fit_start_params = [[offset], np.concatenate((widths, amplitudes, centers))]
fit_start_params = [y for x in fit_start_params for y in x]
elif len(input) == 1:
fit_start_params = [offset, widths, amplitudes, centers]
try:
popt = self.fit_n_lorentzian(data['frequency'], data['data'], fit_start_params = fit_start_params)
except RuntimeError:
print('fit failed, optimal parameters not found')
break
self.plotwidget.axes.clear()
self.plotwidget.axes.plot(data['frequency'], data['data'])
self.plotwidget.axes.plot(data['frequency'], self.n_lorentzian(data['frequency'], *popt))
self.plotwidget.draw()
params = popt[1:]
widths_array = params[:len(params)/3]
amplitude_array = params[len(params)/3: 2 * len(params) / 3]
center_array = params[2 * len(params) / 3:]
positions = list(zip(center_array, amplitude_array, widths_array))
self.single_fit = []
peak_index = 0
for position in positions:
self.single_fit.append({'nv_id': [index], 'peak_id': [peak_index], 'offset': [popt[0]], 'fit_center': [position[0]], 'fit_amplitude': [position[1]], 'fit_width': [position[2]], 'manual_center': [input[peak_index][0]], 'manual_height': [input[peak_index][1]]})
peak_index += 1
self.peak_locs.setText('Peak Positions: ' + str(center_array))
self.initial_fit = False
elif value == 'prev':
index -= 1
break
elif value == 'skip':
index += 1
break
elif type(value) is int:
index = int(value)
break
self.finished.emit()
self.status.emit('dataset finished')
self.instruments['daq']['instance'].DI_stop()
diffData = np.diff(xLineData)
summedData = np.zeros(len(self.x_array) / self.clockAdjust)
for i in range(0, int((len(self.x_array) / self.clockAdjust))):
summedData[i] = np.sum(diffData[(i * self.clockAdjust + 1):(i * self.clockAdjust + self.clockAdjust - 1)])
# also normalizing to kcounts/sec
return summedData * (.001 / self.settings['time_per_pt'])
if __name__ == '__main__':
from pylabcontrol.core import Instrument
# from b26_toolkit.pylabcontrol.instruments import NI7845RMain
#
# fpga = NI7845RMain()
#
#
# g = GalvoScanFPGA(instruments={'NI7845RMain':fpga}, name='test_fpga_scan', settings=None, log_function=None, data_path=None)
# print(fpga)
# instruments, failed = Instrument.load_and_append(instrument_dict ={'NI7845RMain': 'NI7845RMain'}, raise_errors=True )
script, failed, instruments = Script.load_and_append(script_dict={'GalvoScanFPGA': 'GalvoScanFPGA'}, raise_errors=True)
#
print(script)
print(failed)
# # print(instruments)
# take settings defined in the script and update with settings for the fields
dictator = self.instruments['MagnetCoils']['settings']
dictator.update({'magnetic_fields': {'x_field': float(new_x_field), 'y_field': float(new_y_field), 'z_field': float(new_z_field)}})
self.instruments['MagnetCoils']['instance'].update(dictator)
#
self.log('Magnetic Field set to Bx={:.4}G, By={:.4}G, Bz={:.4}G'.format(self.instruments['MagnetCoils']['instance'].settings['magnetic_fields']['x_field'],
self.instruments['MagnetCoils']['instance'].settings['magnetic_fields']['y_field'],
self.instruments['MagnetCoils']['instance'].settings['magnetic_fields']['z_field'])
)
print(('requested fields', self.instruments['MagnetCoils']['instance'].requested_fields))
print(('applied fields', self.instruments['MagnetCoils']['instance'].applied_fields))
self.data['new_voltages'] = self.instruments['MagnetCoils']['instance'].new_voltages
self.data['requested_fields'] = self.instruments['MagnetCoils']['instance'].requested_fields
self.data['applied_fields'] = self.instruments['MagnetCoils']['instance'].applied_fields
if __name__ == '__main__':
from pylabcontrol.core import Instrument
instruments, instruments_failed = Instrument.load_and_append({'MagnetCoils': MagnetCoils })
script, failed, instruments = Script.load_and_append(script_dict={'SetMagneticCoils': SetMagneticCoils}, instruments = instruments)
script['SetMagneticCoils']._function()
print(script)
print(failed)
# print(instruments)
if data is None:
data = self.data
if not self.settings['track_laser_power']['on/off']:
plot_esr(axes_list[0], data['frequency'], data['data'], linestyle = 'None', marker = 'o')
elif self.settings['track_laser_power']['on/off'] and self.settings['daq_type'] == 'PCI':
plot_esr(axes_list[0], data['frequency'], data['norm_data'], linestyle = 'None', marker = 'o')
def get_axes_layout(self, figure_list):
"""
returns the axes objects the script needs to plot its data
the default creates a single axes object on each figure
This can/should be overwritten in a child script if more axes objects are needed
Args:
figure_list: a list of figure objects
Returns:
axes_list: a list of axes objects
"""
new_figure_list = [figure_list[1]]
return super(ESR_FM_Dither, self).get_axes_layout(new_figure_list)
if __name__ == '__main__':
script = {}
instr = {}
script, failed, instr = Script.load_and_append({'ESR': 'ESR_dithering'}, script, instr)
print(script)
print(failed)
print(instr)
min_volts = 0.0
max_volts = 5.0
pt = self.get_voltage(self.settings['attenuation'])
if pt < min_volts or pt > max_volts:
raise ValueError("Invalid voltage. Must be between 0 and 5 volts")
task = self.daq_out.setup_AO(self.settings['DAQ_channels'], pt)
self.daq_out.run(task)
self.daq_out.waitToFinish(task)
self.daq_out.stop(task)
self.log('laser set to attenuation'.format(self.settings['attenuation']))
def get_voltage(self, attenuation):
# this function returns the voltage needed for a given attenuation
# fit to a quartic polynomial
voltage = a4*attenuation^4 + a3*attenuation^3 + a2*attenuation^2 + a1*attenuation + a0
return voltage
if __name__ == '__main__':
from pylabcontrol.core import Instrument
# instruments, instruments_failed = Instrument.load_and_append({'daq': 'NI6259'})
script, failed, instruments = Script.load_and_append(script_dict={'SetLaserPower': 'SetLaserPower'})
print(script)
print(failed)
# print(instruments)
def __init__(self, instruments, scripts = None, name=None, settings=None, log_function=None, data_path = None):
Script.__init__(self, name, settings=settings, scripts=scripts, instruments=instruments, log_function=log_function, data_path = data_path)
def __init__(self, scripts, name = None, settings = None, log_function = None, timeout = 1000000000, data_path = None):
Script.__init__(self, name, scripts = scripts, settings=settings, log_function=log_function, data_path = data_path)
