lukingroup / pylabnet Goto Github PK

Client classes (dummy wrapper implementation) don't have docstrings - these are written for the low level functions. However, in practical operation of pylabnet one uses the client functions, so it is helpful to have the documentation available when using the client functions in an IDE. This should be a simple copy paste job, unless there is a more elegant solution that @cknaut knows about?

Can be useful in case some in-situ PID-tuning must be done.

This alternative non-GUI based workflow can be useful in cases where shared machines are used and a remote desktop connection can be annoying to establish with multiple users.

In order to use the log-file output functionality of the logger, it would be nice if the Launch control GUI allows the user to specify a path in which the logfiles are stored.

It would be nice to be able to select between two presets of amplitude and frequency values, say one suitable for room-temperature and one for 4K.

Create a launcher that centralizes access to all servers + logger. Should handle automatic connection to necessary servers, enabling easy "double-click" type access to scripts that involve arbitrary combinations of GUI(s), hardware servers, dummy servers, and clients, all connected to a single logger.

Software control of magnet power supplies, enabling safe ramping of fields including heat switch control, as well as an eventual network interface to provide signals to neighboring labs for reference on field status

Add a button to the GUI which captures a screenshot of the current GUI window and uploads it to the confluence (for example, a webpage like lab book/year/month/date)

Can also add functionality to store metadata on the website

Nanopositioner software crashes without throwing an error occasionally when step/walk buttons are pressed. The GUI just disconnects silently which then breaks the script.

Implement functionality to kill running servers. Current functionality requires closing the python process (e.g. by closing the shell in which it runs)

For example, to kill a GUI server when the GUI window is closed.

After #34 is done, write a handler-class which takes arbitrary pulse sequences as defined in #34 and generate the necessary ZI HDAWG sequencer commands which output said pulse sequence.

GUI control of Smaract nanopositioners for single step, continuous move (with variable amplitude/frequency), and DC voltage for all axes simulatneously

Implement pulse experiment with a gated counter for repetition based experiments

E.g. save multiple times during run, save x and y axis data.

Using a class based approach, this task encompasses:

• Easy definition of single digital pulses specified on one output bit (one 'line').
• Possibility to easily combine these single-line digital pulse-trains to multi-line pulse sequences.
• Must be able to easily add and insert pulses into single-line pulses or multi-line pulse sequences.
• Must have convenient plotting function visualizing the pulse sequence.

@mkbhaskar: Feel free to add desired specs.

The above should be implemented in a hardware agnostic way, i.e. pulses should be stored as arrays of zeros and ones. Interpreting the pulses in a hardware specific way will be handled by a different class (see also #35).

Allow users to refer to computers by host-names, rather than IP Addresses

Add convenient debugging infrastructure to easily attach debuggers to newly instantiated processes

Find, implement, and document instructions for reliably setting up and connecting pylabnet computers over a network using Windows 10

Make a GUI where the user can edit channel assignments (ideally for digital channels to be used with HDAWG, but perhaps also for other hardware channels). Should either run a server so that other software can retrieve channel assignments, or work off a config file

Should be able to connect to powermeter or counters, and use MPC320 to max/min counts.

Build a separate sub-module for implementing hardware server instantiation for easy launching, that is independent of the actual driver module itself

Add functionality to remotely and conveniently optimize Toptica laser properties (current, temperature) for desired scan range.

Includes:

• Write drivers for enabling scan remotely/set current/set temp remotely
• Potentially automated or smart routines for tuning parameters for desired scan range
• Motor box control driver (API pending)

One of the main features of pylabnet is that errors in sub-routines will not crash the entire experiment by raising exceptions, but rather just output an error message into the LogHandler. However, some errors will make the execution of scripts impossible, such as for example errors occurring during setup of HardwareDrivers.

I will for now raise explicit exceptions for all setup-related code but am opening this issue as an reminder to discuss this topic at some point and to define a guideline.

Write wrapper for:

• Access all nodes via setInt/setFloat commands.
• log all diagnostics output in LogService.
• Upload function for sequences.
• Dynamic waveform upload for changing waveforms in AWG memory directly.

Write driver for setting and getting voltages for HDAWG breakout box via ASCII commands

Generic Optimizer class that can attach to a specific experiment and optimize parameters quickly (for example to tune up laser or microwave frequency)

Automatic de-latching, any other SNSPD related functions (e.g ideal working ranges, maybe using config file)

It would be nice if the LogService could store the standard output in a log file. This will make debugging for complex experiments easier.

An automated way of checking pulse fidelity (see #45) requires a programmatic interface with a measurement tool, a good starting point is this simple scope.

Implement a generic Sweeper class that can be used to sweep experimental parameters and obtain data as a function of those parameters

Proper testing of pulse-sequence generating code should be done by code. This means that a method of comparing the desired time-trace to a measured one must be written. This can easily be done by using using the cross-correlation between measured and desired signal to overlay them and then compare them.

Driver for reading temperature and setting heater power, eventually optimized procedure

Test and implement multi-node network operation.

1. Performing basic tasks, e.g. creating a client on a separate machine and successfully connecting
2. More complicated tasks, involving transfer of convenient log/launch functionality to multi-node system. To be implemented once #25 is solved

• Option (a) centralize logger at main node. This has a natural feel in our experiment, but I'm not sure this scales well as the network size grows
• Option (b) each node has its own centralized logger.
• Option (c) some hybrid solution with a main logger and sub-loggers at other nodes

Think about ways to automate documentation, for example: https://wiki.python.org/moin/DocumentationTools

Consolidate script update and closing servers into one, with optional customized functionality (such as with the wavemeter update)

Any error in pylabnet should route a message to the logger

Have the ability to close the script nicely when the GUI is closed. Perhaps implement the functionality as an optional flag in the launcher module