def launch(**kwargs):
""" Launches the WLM monitor + lock script """
logger = kwargs['logger']
clients = kwargs['clients']
config = load_script_config(script='laser_stabilizer',
config=kwargs['config'],
logger=logger)
for server in config['servers']:
if 'name' in server:
if server['name'] == 'input':
ai_client = find_client(clients=clients,
settings=config,
client_type=server['type'],
client_config=server['config'],
logger=logger)
if server['name'] == 'output':
ao_client = find_client(clients=clients,
settings=config,
client_type=server['type'],
client_config=server['config'],
logger=logger)
if server['type'] == 'zi_hdawg':
hd = find_client(clients=clients,
settings=config,
client_type='zi_hdawg',
client_config=server['config'],
logger=logger)
if config['check_aom'] == "True":
check_aom = True
else:
check_aom = False
# Instantiate Monitor script
laser_stabilizer = LaserStabilizer(config=config,
ao_client=ao_client,
ai_client=ai_client,
hd=hd,
check_aom=check_aom,
logger=logger)
update_service = Service()
update_service.assign_module(module=laser_stabilizer)
update_service.assign_logger(logger=logger)
update_server, update_port = create_server(update_service,
logger,
host=get_ip())
logger.update_data(data={'port': update_port})
laser_stabilizer.gui.set_network_info(port=update_port)
update_server.start()
# Run continuously
# Note that the actual operation inside run() can be paused using the update server
while True:
laser_stabilizer.run()
def launch(**kwargs):
logger = kwargs['logger']
clients = kwargs['clients']
config = load_script_config(script='filterwheel',
config=kwargs['config'],
logger=logger)
filterwheel1 = find_client(logger=logger,
settings=config,
clients=clients,
client_type="fw102c",
client_config='toptica_filterwheel1')
filterwheel2 = find_client(logger=logger,
settings=config,
clients=clients,
client_type="fw102c",
client_config='toptica_filterwheel2')
# Instantiate Monitor script
toptica_controller = TopticaFilterWheelController(
filterwheel1=filterwheel1,
filterwheel2=filterwheel2,
logger=logger,
port=kwargs['server_port'])
toptica_controller.gui.app.exec_()
def launch(**kwargs):
""" Launches the WLM monitor + lock script """
logger = kwargs['logger']
config = load_script_config(
script='wlm_monitor',
config=kwargs['config'],
logger=logger
)
# TODO: Generalize this for n lasers.
if config['num_lasers'] == 3:
three_lasers = True
else:
three_lasers = False
device_id = config['device_id']
wavemeter_client = find_client(
clients=kwargs['clients'],
settings=config,
client_type='high_finesse_ws7',
logger=logger )
# Get list of ao client names
ao_clients = {}
for channel in config['channels'].values():
client_name = channel['ao']['client']
device_config = channel['ao']['config']
ao_clients[(client_name, device_config)] = find_client(
kwargs['clients'],
config,
client_name,
client_config=device_config,
logger=logger
)
channel_params = [p for p in config['channels'].values()]
params = dict(channel_params=channel_params)
# Instantiate Monitor script
wlm_monitor = WlmMonitor(
wlm_client=wavemeter_client,
ao_clients=ao_clients,
logger_client=logger,
params=params,
three_lasers=three_lasers
)
update_service = kwargs['service']
update_service.assign_module(module=wlm_monitor)
logger.update_data(data=dict(device_id=device_id))
wlm_monitor.gui.set_network_info(port=kwargs['server_port'])
# Run continuously
# Note that the actual operation inside run() can be paused using the update server
while True:
wlm_monitor.run()
def launch(**kwargs):
logger = kwargs['logger']
clients = kwargs['clients']
config = load_script_config(script='thorlabs_pm320e',
config=kwargs['config'],
logger=logger)
powermeter = find_client(clients=clients,
settings=config,
client_type='thorlabs_pm320e')
pol_paddle = find_client(clients=clients,
settings=config,
client_type='thorlabs_mpc320')
def launch(**kwargs):
logger = kwargs['logger']
clients = kwargs['clients']
config = load_script_config(script='toptica_control',
config=kwargs['config'],
logger=logger)
dlc_client = find_client(clients=clients,
settings=config,
client_type='toptica_dlc_pro')
# Instantiate Monitor script
toptica_controller = Controller(dlc_client,
logger=logger,
port=kwargs['server_port'])
# Run continuously
# Note that the actual operation inside run() can be paused using the update server
start_time = time.time()
check_interval = 1
while True:
if time.time() - start_time < check_interval:
toptica_controller.run()
else:
toptica_controller.run(check_vals=True)
start_time = time.time()
def initialize_drivers(self, staticline_clients, logger_client):
# Dictionary storing {device name : dict of staticline Drivers}
self.staticlines = {}
for device_name, device_params in self.config_dict['lines'].items():
# If the device name is duplicated, we ignore this hardware client.
if device_name in self.staticlines:
self.log.error(
f"Device name {device_name} has been matched to multiple hardware clients."
"Subsequent matched hardware clients are ignored.")
continue
# Create a dict to store the staticlines for this device
else:
self.staticlines[device_name] = dict()
hardware_type = device_params['hardware_type']
hardware_config = device_params['config_name']
#Try to find if we have a matching device client in staticline_clients
try:
hardware_client = find_client(staticline_clients,
self.config_dict, hardware_type,
hardware_config, logger_client)
except NameError:
logger_client.error(
'No staticline device found for device name: ' +
device_name)
# Iterate over all staticlines for that device and create a
# driver instance for each line.
for staticline_idx in range(len(
device_params["staticline_names"])):
staticline_name = device_params["staticline_names"][
staticline_idx]
# Store the staticline driver under the specified device name
self.staticlines[device_name][
staticline_name] = staticline.Driver(
name=device_name + "_" + staticline_name,
logger=logger_client,
hardware_client=hardware_client,
hardware_type=hardware_type,
config=device_params["staticline_configs"]
[staticline_idx])
#If it has an initial default value, set that initially using set_value command
if "default" in device_params["staticline_configs"][
staticline_idx]:
defaultValue = device_params["staticline_configs"][
staticline_idx]["default"]
sl_type = device_params["staticline_configs"][
staticline_idx]['type']
if (sl_type == 'analog'):
self.staticlines[device_name][
staticline_name].set_value(defaultValue)
elif (sl_type == 'adjustable_digital'):
self.staticlines[device_name][
staticline_name].set_dig_value(defaultValue)
def launch(**kwargs):
""" Launches the full nanopositioner control + GUI script """
# Unpack and assign parameters
logger = kwargs['logger']
clients = kwargs['clients']
config = load_script_config(script='mcs2_anc300_control',
config=kwargs['config'],
logger=logger)
nanopos_client = find_client(clients=clients,
settings=config,
client_type='mcs2')
attocube_client = find_client(clients=clients,
settings=config,
client_type='anc300')
gui_client = 'positioner_control_mixed'
# Instantiate controller
control = Controller(nanopos_client,
attocube_client,
gui_client,
logger,
config=kwargs['config'],
port=kwargs['server_port'])
# Initialize parameters
for channel_index in range(control.NUM_CHANNELS):
params = control.get_GUI_parameters(channel_index)
control.initialize_parameters(channel_index, params)
try:
control.load_settings()
except Exception as e:
logger.warn(e)
logger.warn('Failed to load settings from config file')
control.gui.app.exec_()
# Mitigate warnings about unused variables
if loghost and logport and params:
pass
def __init__(self,
logger=None,
client_tuples=None,
config=None,
config_name=None):
self.log = LogHandler(logger)
self.dataset = None
# Instantiate GUI window
self.gui = Window(gui_template='data_taker', host=get_ip())
# Configure list of experiments
self.gui.config.setText(config_name)
self.config = config
self.exp_path = self.config['exp_path']
if self.exp_path is None:
self.exp_path = os.getcwd()
sys.path.insert(1, self.exp_path)
self.update_experiment_list()
# Configure list of clients
self.clients = {}
# Retrieve Clients
for client_entry in self.config['servers']:
client_type = client_entry['type']
client_config = client_entry['config']
client = find_client(clients=client_tuples,
settings=client_config,
client_type=client_type,
client_config=client_config,
logger=self.log)
self.clients[f"{client_type}_{client_config}"] = client
for client_name, client_obj in self.clients.items():
client_item = QtWidgets.QListWidgetItem(client_name)
client_item.setToolTip(str(client_obj))
self.gui.clients.addItem(client_item)
# Configure dataset menu
for name, obj in inspect.getmembers(datasets):
if inspect.isclass(obj) and issubclass(obj, datasets.Dataset):
self.gui.dataset.addItem(name)
# Configure button clicks
self.gui.configure.clicked.connect(self.configure)
self.gui.run.clicked.connect(self.run)
self.gui.save.clicked.connect(self.save)
self.gui.load_config.clicked.connect(self.reload_config)
self.gui.showMaximized()
self.gui.apply_stylesheet()
def launch(**kwargs):
logger = kwargs['logger']
clients = kwargs['clients']
config = load_script_config(script='m2_laserscan',
config=kwargs['config'],
logger=logger)
channel, ip, port, log_tcp = config['channel'], config['ip'], config[
'port'], config["log_tcp_packets"]
wavemeter_client = find_client(clients=clients,
settings=config,
client_type='high_finesse_ws7',
logger=logger)
server = MSquaredWMServer(ip, port, channel, logger, wavemeter_client,
log_tcp)
server.start()
def launch(**kwargs):
""" Launches the full fiber controll + GUI script """
# Unpack and assign parameters
logger = kwargs['logger']
clients = kwargs['clients']
logport = kwargs['logport']
# Unpack settings
settings = load_script_config('power_monitor',
kwargs['config'],
logger=logger)
# Find the client
device_config = None
for server in settings['servers']:
if 'name' in server and server['name'] == 'power_sensor':
device_type = server['type']
device_config = server['config']
break
try:
pm_client = find_client(clients, settings, device_type, device_config,
logger)
except NameError:
logger.error('No power_sensor device identified in script config file')
logger.info(f'Found PM client {pm_client}')
calibration = [settings['calibration']]
name = settings['name']
pm = PMInterface(pm_client, settings)
# Instantiate controller
control = Monitor(pm_client=pm,
logger=logger,
calibration=calibration,
name=name,
port=kwargs['server_port'])
time.sleep(2)
control.sync_settings()
control.run()
def launch(**kwargs):
""" Launches the sweeper GUI """
# logger, loghost, logport, clients, guis, params = unpack_launcher(**kwargs)
logger = kwargs['logger']
clients = kwargs['clients']
config = load_script_config(
'histogram',
kwargs['config'],
logger
)
ctr = find_client(
clients,
config,
client_type='si_tt',
client_config='standard_ctr',
logger=logger
)
# Instantiate Monitor script
trace = TimeTraceGui(
ctr=ctr,
log=logger,
config=config,
)
update_service = Service()
update_service.assign_module(module=trace)
update_service.assign_logger(logger=logger)
update_server, update_port = create_server(update_service, logger, host=get_ip())
logger.update_data(data={'port': update_port})
trace.gui.set_network_info(port=update_port)
update_server.start()
# Run continuously
# Note that the actual operation inside run() can be paused using the update server
while True:
trace.gui.force_update()
def launch(**kwargs):
""" Launches the count monitor script """
# logger, loghost, logport, clients, guis, params = unpack_launcher(**kwargs)
logger = kwargs['logger']
clients = kwargs['clients']
config = load_script_config('monitor_counts', kwargs['config'], logger)
if config['combined_channel'] == 'True':
combined_channel = True
else:
combined_channel = False
# Instantiate CountMonitor
try:
monitor = CountMonitor(ctr_client=find_client(
clients,
config,
client_type='si_tt',
client_config='standard_ctr',
logger=logger),
logger_client=logger,
server_port=kwargs['server_port'],
combined_channel=combined_channel)
except KeyError:
print(
'Please make sure the module names for required servers and GUIS are correct.'
)
time.sleep(15)
raise
# except:
# config = None
# ch_list = [7, 8]
# plot_list = [[7], [8]]
# Instantiate Pause server
# try:
# pause_logger = LogClient(
# host=loghost,
# port=logport,
# module_tag='count_monitor_pause_server'
# )
# except ConnectionRefusedError:
# logger.warn('Could not connect Count Monitor Pause server to logger')
# pause_service = PauseService()
# pause_service.assign_module(module=monitor)
# pause_service.assign_logger(logger=pause_logger)
# timeout = 0
# while timeout < 1000:
# try:
# port = np.random.randint(1, 9999)
# pause_server = GenericServer(
# host=get_ip(),
# port=port,
# service=pause_service)
# pause_logger.update_data(data=dict(port=port))
# timeout = 9999
# except ConnectionRefusedError:
# logger.warn(f'Failed to instantiate Count Monitor Pause server at port {port}')
# timeout += 1
# pause_server.start()
# Set parameters
monitor.set_params(**config['params'])
# Run
monitor.run()
def __init__(self,
logger=None,
client_tuples=None,
config=None,
config_name=None):
self.log = LogHandler(logger)
self.dataset = None
# Instantiate GUI window
self.gui = Window(gui_template='data_taker', host=get_ip())
# Configure list of experiments
self.gui.config.setText(config_name)
self.config = config
self.exp_path = self.config['exp_path']
if self.exp_path is None:
self.exp_path = os.getcwd()
sys.path.insert(1, self.exp_path)
self.update_experiment_list()
# Configure list of clients
self.clients = {}
# Configure list of missing clients
self.missing_clients = {}
# Setup Autosave
# First check whether autosave is specified in config file
if 'auto_save' in self.config:
if self.config['auto_save']:
self.gui.autosave.setChecked(True)
# Retrieve Clients
for client_entry in self.config['servers']:
client_type = client_entry['type']
client_config = client_entry['config']
client = find_client(clients=client_tuples,
settings=client_config,
client_type=client_type,
client_config=client_config,
logger=self.log)
if (client == None):
self.missing_clients[f"{client_type}_{client_config}"] = [
client_type, client_config
]
else:
self.clients[f"{client_type}_{client_config}"] = client
for client_name, client_obj in self.clients.items():
client_item = QtWidgets.QListWidgetItem(client_name)
client_item.setToolTip(str(client_obj))
self.gui.clients.addItem(client_item)
for client_name, client_config in self.missing_clients.items():
client_item = QtWidgets.QListWidgetItem(client_name)
client_item.setForeground(Qt.gray)
self.gui.clients.addItem(client_item)
self.log.error("Datataker missing client: " + client_name)
# Configure button clicks
self.gui.configure.clicked.connect(self.configure)
self.gui.run.clicked.connect(self.run)
self.gui.save.clicked.connect(self.save)
self.gui.clearData.clicked.connect(self.clear_data)
self.gui.load_config.clicked.connect(self.reload_config)
self.gui.showMaximized()
self.gui.apply_stylesheet()
def __init__(self,
logger=None,
channels=['Channel 1'],
clients={},
config=None,
fast=True):
""" Instantiates controller (only 1D data supported so far)
:param logger: instance of LogClient
:param channels: (list) list of channel names
:param config: (str) name of config file
:param fast: (bool) whether to operate in fast mode
fast mode only updates heat maps at the end of each scan (this speeds things up)
"""
self.config = load_script_config('scan1d', config, logger=logger)
if 'sweep_type' in self.config.keys():
self.sweep_type = self.config['sweep_type']
else:
self.sweep_type = 'triangle'
super().__init__(logger, channels, sweep_type=self.sweep_type)
self.module = None
# Instantiate GUI
self.gui = Window(gui_template='scan_1d', host=get_ip(), max=True)
self.widgets = get_gui_widgets(self.gui,
p_min=1,
p_max=1,
pts=1,
config=1,
graph=2,
legend=2,
clients=1,
exp=1,
exp_preview=1,
configure=1,
run=1,
autosave=1,
save_name=1,
save=1,
reps=1,
rep_tracker=1,
avg=2)
# Configure default parameters
self.min = self.widgets['p_min'].value()
self.max = self.widgets['p_max'].value()
self.pts = self.widgets['pts'].value()
self.reps = self.widgets['reps'].value()
self.data_fwd = []
self.data_fwd_2nd_reading = [] ### ADDED
self.data_bwd = []
self.avg_fwd = []
self.avg_fwd_2nd_reading = [] ### ADDED
self.avg_bwd = []
self.fit_popup = None
self.p0_fwd = None
self.p0_bwd = None
self.x_fwd = self._generate_x_axis()
if self.sweep_type != 'sawtooth':
self.x_bwd = self._generate_x_axis(backward=True)
else:
self.x_bwd = self._generate_x_axis()
self.fast = fast
# Configure list of experiments
self.widgets['config'].setText(config)
self.exp_path = self.config['exp_path']
model = QtWidgets.QFileSystemModel()
model.setRootPath(self.exp_path)
model.setNameFilterDisables(False)
model.setNameFilters(['*.py'])
self.widgets['exp'].setModel(model)
self.widgets['exp'].setRootIndex(model.index(self.exp_path))
self.widgets['exp'].hideColumn(1)
self.widgets['exp'].hideColumn(2)
self.widgets['exp'].hideColumn(3)
self.widgets['exp'].clicked.connect(self.display_experiment)
# Configure list of clients
self.clients = clients
for client_entry in self.config['servers']:
client_type = client_entry['type']
client_config = client_entry['config']
client = find_client(clients=self.clients,
settings=client_config,
client_type=client_type,
client_config=client_config,
logger=self.log)
if (client == None):
client_name_concat = client_type
client_item = QtWidgets.QListWidgetItem(client_name_concat)
client_item.setForeground(Qt.gray)
client_item.setToolTip(str("Disconnected"))
self.widgets['clients'].addItem(client_item)
else:
self.log.info(client)
client_name_concat = f"{client_type}_{client_config}"
client_item = QtWidgets.QListWidgetItem(client_name_concat)
client_item.setToolTip(str(client))
self.widgets['clients'].addItem(client_item)
#Checking for any missing clients, and adding them as greyed out on the list of clients
# Manually add logger to client
self.clients['logger'] = logger
# Configure button
self.widgets['configure'].clicked.connect(self.configure_experiment)
self.widgets['run'].clicked.connect(self.run_pressed)
self.widgets['autosave'].toggled.connect(self._update_autosave)
self.widgets['save'].pressed.connect(
lambda: self.save(filename=self.widgets['save_name'].text(),
directory=self.config['save_path']))
self.widgets['reps'].valueChanged.connect(self.set_reps)
self.widgets['avg'][0].clicked.connect(
lambda: self._clear_show_trace(0))
self.widgets['avg'][1].clicked.connect(
lambda: self._clear_show_trace(1))
self.gui.fit.clicked.connect(self.fit_config)
# Create legends
self.widgets['curve'] = []
for index in range(len(self.widgets['graph'])):
self.widgets['legend'][index] = get_legend_from_graphics_view(
self.widgets['legend'][index])
# Configure hmaps
self.widgets['hmap'] = []
for index in range(2):
# Configure Hmap to work the way we want
hmap = pg.ImageView(view=pg.PlotItem())
self.gui.graph_layout.insertWidget(2 * index + 1, hmap)
hmap.setPredefinedGradient('inferno')
hmap.show()
hmap.view.setAspectLocked(False)
hmap.view.invertY(False)
self.widgets['hmap'].append(hmap)
# Setup stylesheet.
self.gui.apply_stylesheet()