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, 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=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 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)