Documentation

1 - Architecture

Distributed services

Quatm is distributed: drivers, data managers, property logging, message routing, web access and the GUI run as independent operating-system processes connected by local IPC or TCP.

flowchart TB
    subgraph Clients[Clients]
        GUI[Desktop GUI<br/>PySide6]
        WEB[Web console<br/>browser / mobile]
    end

    BUS[(ZeroMQ event bus<br/>data · images · commands · properties)]

    subgraph Control[Control]
        PM[Process & task supervision]
        EXP[Experiment runtime<br/>Experiment · scans · queue · looper]
    end

    subgraph Services[Services]
        DATA[Data & image managers]
        PROP[Property logger]
        MSG[Message hub / logger]
        HEALTH[Device health & leases]
        WEBHUB[Web hub]
    end

    subgraph Hardware[Hardware]
        DRV[Device drivers<br/>VISA · serial · TCP · USB · GPIB · DLL]
        RT[FPGA / ADwin / real-time controllers]
    end

    GUI --> BUS
    WEB --> BUS
    BUS --> PM
    BUS --> EXP
    EXP --> DATA
    EXP --> PROP
    PM --> MSG
    PM --> HEALTH
    DATA --> DRV
    EXP --> RT
    DRV --> Hardware
    WEBHUB --> WEB
    MSG --> BUS
    HEALTH --> DRV

Failure isolation and network transparency

Every major component can run as an independent operating-system process. Clients and services communicate over local IPC or TCP, so a control PC, a data-analysis machine and a remote laptop can share one experiment without sharing one process. The architecture is intentionally fail-isolated and network-transparent: image processing does not block timing, and a slow browser cannot stall acquisition.

For the deeper architecture description, see Communication layer and the repository’s quatm/docs/ directory.

2 - Getting started

This guide takes you from a clean machine to a running experiment. You do not need any hardware: Quatm’s simulation mode exercises the same runtime and data path as a real device.

Edition note. The installation commands below set up Quatm Core, the open-source runtime. The desktop GUI, browser console and commercial driver catalogue are provided with Quatm Platform; contact sales@quatm.com for the platform distribution.

What you will do

• Install the framework and create a laboratory project.
• Understand the project directory and device_db.py.
• Write a small Experiment class with parameters.
• Run it from the desktop GUI or the web console.
• Inspect the generated HDF5 data and analysis.

Requirements

• Python 3.9 or newer.
• Windows 10 (1809+) or Windows 11 on x86-64; macOS 13 or newer; Linux x86-64 (Ubuntu 22.04/24.04, Debian 12, or an equivalent environment). ARM64 desktop support is limited; consult the Qt 6.11 supported-platform matrix.
• Optional: a supported FPGA/ADwin controller or VISA/serial/TCP/USB/GPIB instruments for real experiments.

Install

git clone https://github.com/quatm-team/quatm-core.git
cd quatm-core
python -m venv python_venv
source python_venv/bin/activate        # Windows: python_venv\Scripts\activate
pip install -e .
pip install -e ".[hardware]"           # optional hardware dependencies

Verify

from quatm.experiment import Experiment

class HelloQuatm(Experiment):
    def build(self):
        print("Quatm ready")

    def run(self):
        print("Hello, Quatm!")

HelloQuatm().run()

Create or open a project

A Quatm project contains configuration/, experiments/ and Data/. With Quatm Platform, a project normally includes a launcher; run it to open the laboratory environment.

If you start from an empty project, use the platform launcher:

python -m quatm.GUI.entries.start_quatm --root <project>

The first run creates a minimal configuration and opens the Operations Console. Open-source core users can also use the Python API directly and organise configuration/ and experiments/ in their own project.

Next steps

1. Basic configuration — connect devices and understand the project files.
2. Your first experiment — parameters, sequencing and execution.
3. Experiment editing — the full runtime model.
4. Device drivers — driver modes and custom instruments.
5. FAQ — installation, device, data and upgrade questions.

2.1 - Basic configuration

Project root

Quatm resolves the project root in this order:

1. QUATM_PROJECT_ROOT (set by the project launcher);
2. the nearest parent directory containing configuration/configfile/configfile.json or a .quatm_project marker;
3. the legacy repository layout.

A project keeps its own configuration and data; the framework package is installed separately. This lets several laboratories share one installation while keeping their files independent.

Directory layout

<project>/
├── configuration/
│   ├── configfile/configfile.json   # services and GUI entries to launch
│   ├── device_db.py                 # instruments used by experiments
│   └── properties/                  # persisted property tree
├── experiments/                     # experiment scripts
├── Data/                            # HDF5 acquisition files
├── drivers/                         # optional project-local drivers
├── monitor/                         # optional monitors
└── analysis/                        # optional analysis scripts

Device database

configuration/device_db.py maps logical names to drivers. An experiment refers to these names, never to vendor APIs directly.

DEVICE_DB = {
    'mot_coils': {
        'type': 'attr',
        'module': 'quatm.drivers.xxx',
        'class': 'XxxDriver',
        'address': 'tcp://192.168.1.50:5025',
        'arguments': {'channel': 1},
    },
    'probe_laser': {
        'type': 'local',
        'module': 'drivers.probe_laser',
        'class': 'ProbeLaser',
        'arguments': {'port': 'COM4'},
    },
}

The three modes are:

A project-local module (for example drivers.probe_laser) takes precedence over a bundled driver with the same suffix. local_only / analysis_local_only can enforce that no bundled fallback is used.

Services

configuration/configfile/configfile.json declares the services and GUI programs for the project. The Operations Console reads this file, starts selected entries and tracks their state. Service processes are ordinary operating-system processes, so a crash is isolated and can be restarted independently.

Verify the setup

from quatm.servers.configreader import PROJECT_ROOT
print(PROJECT_ROOT)

Then open the Device Manager, select a device and use Test connection with simulation enabled. No hardware is required for this step.

2.2 - Your first experiment

A minimal experiment

Put this file under the project’s experiments/ directory. Quatm discovers experiment classes from that tree.

from quatm.experiment import Experiment


class FirstExperiment(Experiment):
    def build(self):
        self.duration = self.NumberValue(100.0, unit='ms')
        self.enabled = self.BoolValue(True)
        self.phase = self.StringCombo('A', options=['A', 'B'])

    def run(self):
        if not self.enabled:
            return
        self.delay(self.duration)

build() is called once per experiment instance and declares the parameter panel. run() is called once per repetition.

Parameter types

Run it

1. Open the Experiment Browser.
2. Select FirstExperiment.py.
3. Set duration and enabled in the parameter panel.
4. Press Run.
5. Watch the task in the Task Monitor; the Browser shows progress and results.

In simulation mode the run completes without hardware. Data, parameters and task metadata are archived to HDF5 under Data/.

Scans and repetitions

Use the browser’s scan controls to vary a parameter, set the number of repetitions, or submit a multi-dimensional scan. The framework expands the scan into individual runs and records the scan definition alongside the data.

Where to go next

• Experiment editing for the full lifecycle and timing API.
• Data and analysis for HDF5 layout and fitting.
• Examples for realistic MOT and ion-trap sequences.

2.3 - Known issues

Windows

FPGA controller driver

The vendor-provided SDK must be installed, and the FPGA requires the timetable to be defined and flashed according to the actual requirements. No real hardware is needed in simulation mode.

Linux

Qt GUI library dependencies

sudo apt install libxcb-cursor0 libxcb-xinerama0 libegl1-mesa

Camera permissions

Andor / BlackFly cameras require udev rules.

Windows Subsystem for Linux (WSL)

WSL users should make sure to run from a Linux filesystem mount; operating on the Windows filesystem causes unexpected errors.

Web remote control platform (quatm.web)

Upgrading from an older version leaves the quatm.web subpackage missing

When upgrading from an older version, the Web Hub reports an error at startup saying the subpackage is missing: simply re-run pip install -e . (quatm.web is installed together with the quatm core).

Operating the same process from the desktop GUI at the same time

The desktop process manager and the web process page manage the same set of services/GUIs. Before starting an entry, either entry point first terminates the instance managed by the other entry point, so that nothing is launched twice; if a process is restarted unexpectedly, check whether a start action was performed on the other side.

2.4 - Frequently asked questions

The questions below are the ones we hear most often — from a first installation to the quiet details that matter once an experiment is running.

Installation and platforms

Which operating systems are supported? Quatm uses Qt 6/PySide6; supported platforms follow the Qt 6.11 matrix: Windows 10 (1809+) and Windows 11 on x86-64, macOS 13 or newer, and Linux x86-64 (Ubuntu 22.04/24.04, Debian 12, or equivalent). ARM64 desktop support is limited; see the Qt 6.11 supported-platform matrix. Python 3.9 or newer is required.

What are the minimum requirements? A machine with at least 8 GB of memory and 4 CPU cores is recommended for the full GUI and data services. Real-time control requires an FPGA-class controller.

Devices and drivers

Do I need specific hardware? No single vendor is required, but a real-time controller with TTL/DAC outputs is needed for timed sequences. Instruments using standard protocols can be integrated by selecting or writing a driver; the effort depends on the protocol and vendor SDK.

How do I integrate a custom device? Write a driver class and register it in device_db.py as type: local (or map channels with attr / generic_attr). See Device drivers.

Which cameras are supported? Andor, FLIR/BlackFly and other scientific cameras are covered by the driver catalogue; custom cameras can be added through project-local drivers.

Data

What format is used? Experiment data is archived as HDF5, with optional streaming/export services.

How large are the files? A typical absorption-imaging run is on the order of 10–50 MB, depending on image count and resolution. Plan disk capacity and retention for long campaigns.

Updating

How do I upgrade? Update the Python environment and reinstall the package, or pull the repository and rerun the bootstrap. Check the changelog for incompatible changes.

Will my experiment scripts break? Quatm follows semantic versioning for public interfaces; major changes are documented with migration notes. Verify in simulation before a campaign.

Related

• Documentation home
• Contact and support

3 - Experiment editing

An experiment is a Python class derived from Experiment. The framework calls a small number of well-defined hooks, and provides the parameter and device model around them.

Lifecycle

Do not perform hardware work in build(): it may run while the user is editing parameters. Put all timed operations in run().

Parameters

Parameters are declared with typed values such as NumberValue, BoolValue, StringCombo, IntegerValue and ListValue. Each value carries metadata used by the GUI and by the scan engine:

• unit and display multiplier;
• minimum/maximum and step;
• whether the value is persisted;
• the list of allowed values for combos.

The same metadata drives the desktop parameter panel, the web dashboard and scan validation, so a scan cannot silently use an invalid value.

Timing

delay(seconds) advances the sequence clock. realtime() and the DAC/TTL attribute descriptors schedule outputs on the real-time controller. The experiment code describes what happens; the selected backend decides how to realise it on FPGA, ADwin or a simulated controller.

Keep hardware interactions inside run() and avoid Python-level busy loops. The runtime is designed so that a long analysis or GUI operation cannot block the timing path.

Scans and repetitions

A scan is a list of parameter values, optionally multi-dimensional, with an execution order (including randomised and snake orders). The queue turns a scan into individual task descriptions, each with the same parameter schema. Results are stored with the scan definition so the data remains self-describing.

Errors and cleanup

An exception in run() aborts the current run, executes framework cleanup, and marks the task failed. close() is called even after failures. Device leases and property clients are released deterministically; long-running experiments should rely on this cleanup rather than on process exit.

4 - Device drivers

Quatm separates experiment logic from instrument communication. Every instrument is addressed through a logical name in device_db.py; the driver decides whether that name maps to a serial port, a VISA resource, a TCP socket, a USB device or a vendor DLL.

Access modes

All modes support simulation. In simulation the same experiment code runs against a dummy backend, which is essential for developing sequences without occupying the apparatus.

Driver categories

The bundled catalogue covers:

• Real-time control — ADwin, FPGA, timing and trigger distribution.
• Lasers and light — Toptica, Moglabs, Vescent, laser locks and shutters.
• Signal generation and RF — Spectrum AWGs, Rigol, Valon, DDS boards.
• Scientific cameras — Andor, FLIR/BlackFly, PCO and generic video sources.
• Motion and positioning — PI stages, Thorlabs, piezo mirrors.
• DAQ and power supplies — NI, MCC, Keysight, Keithley.
• Environmental monitoring — temperature controllers, magnetometers, wavemeters, vacuum gauges.

The catalogue and per-driver verification status are tracked in the repository (docs/DRIVER_VERIFICATION.md). A driver is considered verified only after it has been exercised on real hardware.

Writing a driver

A driver is a normal Python class with:

• __init__ accepting the arguments declared in device_db.py;
• simulating handling for offline use;
• explicit close() releasing sockets, serial ports and vendor handles;
• optional check() / self-test hooks used by the Device Manager.

Place project-specific drivers under <project>/drivers/. They are imported before bundled drivers with the same suffix, so a laboratory can pin a local version without forking the framework.

Device health and leases

Opening a device acquires a cross-process lease, preventing two experiments from silently driving the same instrument. The Device Manager can probe instruments, verify drivers and report the current owner. Bus-level locking protects adapters that cannot be opened concurrently.

4.1 - Scientific cameras

Overview

Quatm provides a unified ICamera interface wrapper for 15 major scientific camera brands worldwide, covering EMCCD, sCMOS, high-speed CMOS and industrial cameras.

Andor series: iXon EMCCD / Zyla sCMOS / Shamrock spectrograph

Overview

Quatm provides two Andor camera drivers that deliver high-performance imaging control through the native SDKs:

All classes inherit from the io.camera interface and support ROI, binning, exposure control and frame buffer management.

Andor SDK2 (EMCCD) AndorSDK2Camera

Initialization

from quatm.drivers.andor.AndorSDK2 import AndorSDK2Camera

# connect the first camera
cam = AndorSDK2Camera(cam_id=0)

# acquisition parameters
cam.setup_acquisition(
    exposure=0.1,       # exposure time (s)
    em_gain=200,        # EM gain (0-1000)
    readout_rate="5MHz",# readout rate
    pre_amp_gain=2,     # pre-amplifier gain
    hsspeed=0,          # horizontal transfer rate
    temperature=-70,    # target temperature (°C)
)

# acquire a single frame
cam.start_acquisition(nframes=1)
image = cam.read_multiple_images(nframes=1)

Key parameters

Andor SDK3 (sCMOS) AndorSDK3Camera

Initialization

from quatm.drivers.andor.AndorSDK3 import AndorSDK3Camera

cam = AndorSDK3Camera(cam_id=0)
cam.setup_acquisition(
    exposure=0.05,
    pixel_format="Mono16",
    trigger_mode="Internal",
)

Andor Shamrock spectrograph ShamrockSpectrograph

Controls grating selection, centre wavelength and slit width:

from quatm.drivers.andor.Shamrock import ShamrockSpectrograph

spec = ShamrockSpectrograph(idx=0)
spec.set_wavelength(780.24)      # centre wavelength (nm)
spec.set_grating(2)              # select grating
spec.set_slit_width(50, port=1)  # entrance slit (µm)

Device configuration

"emccd": {
    "type": "local",
    "module": "drivers.andor.AndorSDK2",
    "class": "AndorSDK2Camera",
    "arguments": {"cam_id": 0},
}

FLIR / Teledyne / Blackfly S / Grasshopper3

Overview

Quatm wraps the Spinnaker SDK in the TeledyneSpinnakerCamera class, supporting all GenICam/GenAPI-compatible FLIR/Teledyne USB3/GigE cameras.

Initialization

from quatm.drivers.teledyne.spinnaker import TeledyneSpinnakerCamera

# list all available cameras
cam_list = TeledyneSpinnakerCamera.list_cameras()

# connect a camera by serial or index
cam = TeledyneSpinnakerCamera(cam_id="serial_xxx")
# or use an index
cam = TeledyneSpinnakerCamera(cam_id=0)

# configure and start acquisition
cam.setup_acquisition(
    exposure=0.02,          # 20 ms exposure
    pixel_format="Mono8",
    width=1920, height=1200,
    offset_x=0, offset_y=0,
)

Key methods

Common property operations

Camera parameters are read and written directly by GenAPI node name:

# Set gain
cam.set_attribute("Gain", 10.0)
# Enable auto exposure
cam.set_attribute("ExposureAuto", "Continuous")
# Get sensor temperature
temp = cam.get_attribute("DeviceTemperature")

Device configuration

"monitor_cam": {
    "type": "local",
    "module": "drivers.teledyne.spinnaker",
    "class": "TeledyneSpinnakerCamera",
    "arguments": {"cam_id": 0},
}

• stop(): Stop capturing images.

• quatm.drivers.blackfly.bfly.Camserver(name, serial)

  class quatm.drivers.blackfly.bfly.Camserver(object):
      def __init__(self, name, serial):
          pass
  
      def generateImageIndex(self):
          pass
  
      def run(self):
          pass
  
      def sendimage(self, im):
          pass
  
      def updateBusInfo(self):
          pass
  

  • generateImageIndex(): In the current measurement, count the images. If the next run has started (either task, repetition or run changes), reset the counter (imgindex).

  • run(): Run loop running forever. Sends images from the camera to the imagestream and initiates reconfiguration of the camera in case properties have changed.

  • sendimage(im): Send Blackfly camera image via the imagestream. The image is converted to numpy array, additional information like binning, timestamp, etc., is added to a dictionary and both are sent to the imagestream.

    • Args: im - Blackfly image object.
    • Returns: None

  • updateBusInfo(): Detect cameras on the bus and update info in properties if new camera has been found.

• quatm.drivers.blackfly.bfly.pc2

  class quatm.drivers.blackfly.bfly.pc2(object):
      pass
  

  • Dummy class in case driver is not installed.

Function:

• quatm.drivers.blackfly.bfly.run(name)

  def quatm.drivers.blackfly.bfly.run(name):
      pass
  

  • Initialize a Camserver and run it.

Thorlabs TSI / uc480 scientific cameras

TLCamera ThorlabsTLCamera

from quatm.drivers.thorlabs.TLCamera import ThorlabsTLCamera
cam = ThorlabsTLCamera(serial="12345678")
cam.setup_acquisition(exposure=0.01, width=1024, height=768)

Basler — Pylon SDK series

from quatm.drivers.Basler.pylon import BaslerPylonCamera

# Enumerate all cameras
cams = BaslerPylonCamera.list_cameras()
cam = BaslerPylonCamera(cam_id=cams[0])

cam.setup_acquisition(exposure=0.02)
cam.start_acquisition(nframes=1)

Hamamatsu ORCA series sCMOS

from quatm.drivers.DCAM.DCAM import DCAMCamera

cam = DCAMCamera(idx=0)
cam.setup_acquisition(exposure=0.1, pixel_format="Mono16")

Photometrics Prime / Evolve series

from quatm.drivers.Photometrics.pvcam import PVCAMCamera

cam = PVCAMCamera(cam_name="Prime_BSI_95B")
cam.setup_acquisition(exposure=0.05)

Princeton Instruments PIXIS / ProEM

from quatm.drivers.PrincetonInstruments.picam import PicamCamera

cam = PicamCamera(cam_id=0)
cam.setup_acquisition(exposure=1.0)  # long-exposure spectrum acquisition

PCO edge / dimax high-speed cameras

from quatm.drivers.PCO.SC2 import PCOSC2Camera

cam = PCOSC2Camera(interface="USB 3.0")
cam.setup_acquisition(exposure=0.001)  # 1 ms high-speed acquisition

Allied Vision Alvium / Mako

from quatm.drivers.AlliedVision.VimbaX import AlliedVisionVimbaXCamera

cam = AlliedVisionVimbaXCamera(cam_id=0)

IDS uEye+ / Ensenso

from quatm.drivers.IDS.peak import GenericIDSPeakCamera

cam = GenericIDSPeakCamera(cam_id=0)

Generic configuration pattern

All cameras are registered in device_db.py with type: "local":

"imaging_cam": {
    "type": "local",
    "module": "drivers.Basler.pylon",
    "class": "BaslerPylonCamera",
    "arguments": {"cam_id": 0},
}

4.2 - Signal sources and RF

Overview

Quatm supports a broad range of RF instruments, from general-purpose function generators to vector network analyzers, covering frequency synthesis, arbitrary waveforms and S-parameter measurement.

Valon 5009 dual-channel microwave frequency synthesizer

Overview

The Valon 5009 is a dual-channel frequency synthesizer (23.5 MHz – 6 GHz) controlled over a serial port. Quatm wraps it in valon, which sets the frequency and power of the two outputs independently.

Initialization

from quatm.drivers.valon.valon_quatm import valon

# Connect to Valon (default /dev/ttyUSB0)
valon = valon(port="/dev/ttyUSB0")

# Set channel 1 frequency to 500 MHz
valon.set_frequency(freq=500e6, source=1)

# Set channel 2 frequency to 9.925 GHz (external frequency multiplier required)
valon.set_frequency(freq=9.925e9, source=2)

# Send raw command
valon.sendRaw("LOCK 1 ON\r\n")

Key methods

Serial communication

Underneath, the Valon driver communicates through VSerialPort (a serial.Serial subclass). Typical parameters:

# serial parameters (driver defaults)
port = "/dev/ttyUSB0"
baudrate = 115200
timeout = 0.1

# experiment snippet: frequency scan
import numpy as np
frequencies = np.arange(9.924e9, 9.926e9, 10e3)
for f in frequencies:
    valon.set_frequency(freq=f, source=2)
    # ... run the probe sequence ...

class quatm.drivers.valon.valon_prog.Valon_Standalone(name='Valon')

Bases: object

• Standalone driver for the Valon frequency generator. Commands can be sent via the Commandhub and are processed in parallel to the experiment, thereby the experiment is not delayed by the Valon.

  • run()

• function quatm.drivers.valon.valon_prog.run()

DDS AD9959 four-channel direct digital synthesis

Overview

The AD9959 driver wraps the AD9959 evaluation board and controls four independent DDS channels over the SPI bus, providing precise frequency, amplitude and phase control.

Initialization

from quatm.drivers.dds import AD9959

dds = AD9959()

# Configure channel 0 — cooling-light AOM
dds.set_frequency(0, 80e6)       # 80 MHz
dds.set_amplitude(0, 0.5)        # 50% amplitude
dds.set_phase(0, 0)              # 0° phase

# configure channel 1 — repump AOM (+0.1 MHz offset)
dds.set_frequency(1, 80.1e6)
dds.set_amplitude(1, 0.3)

Key methods

Device configuration

"aom_dds": {
    "type": "local",
    "module": "drivers.DDS",
    "class": "AD9959",
}

Typical applications

Alternative driver

An alternative AD9959 board driver with a serial (AT command) interface is also available:

from quatm.drivers.dds.alibaba import AD9959Board

Rigol DG1020Z two-channel function generator

DG1020Z

from quatm.drivers.AWG.specific import RigolDG1020Z
fg = RigolDG1020Z(addr="USB0::...")
fg.set_frequency(80e6)
fg.set_amplitude(1.0)       # 1.0 Vpp
fg.enable_output(channel=1, enable=True)
fg.set_function(channel=1, function="SIN")

Other Rigol devices

DP1116A programmable DC power supply

from quatm.drivers.rigol.power_supply import DP1116A

ps = DP1116A(addr="USB0::0x1AB1::0x0E11::DP1A123456789::INSTR")
ps.set_voltage(12.0)       # 12V
dc.set_current(0.5)        # 500 mA current limit
ps.enable_output(True)

Oscilloscopes

Rigol DS series oscilloscopes are compatible with the Tektronix SCPI command set and are controlled through the ITektronixScope driver:

from quatm.drivers.tektronix.base import ITektronixScope

scope = ITektronixScope(addr="USB0::0x1AB1::0x04CE::DS123456789::INSTR", nchannels=4)
scope.set_timebase(scale=1e-6)     # 1 µs/div
scope.set_vertical(channel=1, scale=0.5)  # 0.5 V/div
waveform = scope.acquire(channel=1)

Agilent / Keysight 33500 series arbitrary waveform generators

from quatm.drivers.awg.specific import Agilent33500

awg = Agilent33500(addr="USB0::0x0957::0x2C07::MY52801234::INSTR")

# Configure an 80 MHz sine wave
awg.set_function(channel=1, function="SIN")
awg.set_frequency(80e6)
awg.set_amplitude(1.0)      # 1 Vpp
awg.enable_output(channel=1, enable=True)

# Burst mode — generate N cycles, then stop automatically
awg.enable_burst(channel=1, ncycles=100)

Supported models

Instek AFG2000 / AFG2225 dual channel

from quatm.drivers.awg.specific import InstekAFG2225

awg = InstekAFG2225(addr="USB0::...")
awg.set_frequency(10e6)
awg.set_amplitude(2.0)
awg.enable_output(channel=1, enable=True)
awg.enable_output(channel=2, enable=True)

Tektronix AFG1000 arbitrary waveform generator

from quatm.drivers.awg.specific import TektronixAFG1000

awg = TektronixAFG1000(addr="USB0::...")
awg.set_function(channel=1, function="ARB")
# Load a custom waveform...

Tektronix DPO/MSO series oscilloscopes

from quatm.drivers.tektronix.base import ITektronixScope

scope = ITektronixScope(
    addr="USB0::0x0699::0x0401::C012345::INSTR",
    nchannels=4
)

# Configure trigger
scope.set_trigger(source=1, level=0.5, slope="POS")
scope.set_timebase(scale=1e-6)          # 1 µs/div
scope.set_vertical(channel=1, scale=0.1) # 0.1 V/div

# Acquire waveform
waveform = scope.acquire(channel=1)

Agilent E5071C vector network analyzer

from quatm.drivers.Agilent.vna import AgilentE5071C

vna = AgilentE5071C(addr="TCPIP::192.168.1.100::INSTR")
vna.set_frequency_range(start=1e6, stop=1e9, points=1001)
vna.set_if_bandwidth(100)       # 100 Hz IFBW
vna.set_averaging(count=10)

# Read S21 parameters
freq, s21 = vna.read_S_parameters(parameter="S21")

PicoVNA portable vector network analyzer

from quatm.drivers.PicoTech.vna_scpi import PicoVNA

vna = PicoVNA(addr="localhost")  # or IP address
vna.set_frequency_range(start=10e6, stop=500e6)
s_params = vna.read_S_parameters(parameter="S21")

Generic SCPI device configuration

"function_gen": {
    "type": "local",
    "module": "drivers.awg.specific",
    "class": "Agilent33500",
    "arguments": {"addr": "USB0::..."},
}

4.3 - Lasers and optics

Overview

Quatm supports diode lasers, pump lasers, tunable ring lasers and optical measurement instruments. Laser-type devices are controlled over serial ports; SCPI instruments inherit the standard interface.

Hubner Cobolt MLD / DPL single-frequency lasers

from quatm.drivers.Hubner.Cobolt import Cobolt

laser = Cobolt(conn="/dev/ttyUSB0")

# Turn on the laser
laser.set_autostart(True)
laser.set_power(50e-3)         # 50 mW

# Digital modulation (TTL)
laser.set_digital_modulation(True)
laser.set_modulation_power(100e-3)  # High power during modulation

# Read operating parameters
hours = laser.get_operating_hours()
temp = laser.get_base_temperature()

Toptica iBeam smart diode lasers

from quatm.drivers.Toptica.ibeam import TopticaIBeam

laser = TopticaIBeam(conn="/dev/ttyUSB0")
laser.set_power(channel=0, power=10e-3)
laser.enable(channel=0, enable=True)

Laser Quantum Finesse pump laser

from quatm.drivers.LaserQuantum.base import Finesse

pump = Finesse(conn="/dev/ttyUSB0")
pump.set_power(10.0)           # 10 W
pump.enable(True)
actual_power = pump.get_power()

Lighthouse Photonics Sprout G

from quatm.drivers.LighthousePhotonics.base import SproutG

sprout = SproutG(conn="/dev/ttyUSB0")
sprout.set_power(15.0)
sprout.enable(True)

Sirah Matisse tunable ring laser

from quatm.drivers.Sirah.Matisse import SirahMatisse

matisse = SirahMatisse(addr="TCPIP::192.168.1.10::INSTR")

# Set wavelength
matisse.set_birefringent_filter(wavelength=780.24)  # nm
matisse.set_thin_etalon(wavelength=780.24)
matisse.set_thick_etalon(wavelength=780.24)

# Piezo scan
matisse.set_piezo_voltage(50.0)   # 0–100 V

# Automatic tuning (requires a wavemeter)
from quatm.drivers.Sirah.tuner import MatisseTuner

tuner = MatisseTuner(laser=matisse, wavemeter=wlm)
tuner.tune_to(wavelength=780.24)  # Auto-search and lock
tuner.scan(start=780.20, stop=780.30, speed=0.01)  # nm/s

M² Solstis narrow-linewidth tunable laser

from quatm.drivers.M2.solstis import Solstis

solstis = Solstis(addr="192.168.1.20", port=8080)

# Wavelength tuning
solstis.set_wavelength(780.24)
# Etalon lock
solstis.lock_etalon()
# Terahertz scan (with the EMM module)
solstis.set_terahertz_scan(start_freq=0, stop_freq=100e9)

Optical power meters & wavemeters

Ophir Vega laser power/energy meter

from quatm.drivers.Ophir.base import VegaPowerMeter

pm = VegaPowerMeter(conn="/dev/ttyUSB0")
power = pm.get_power()

HighFinesse WS6/WS7 precision wavemeters

from quatm.drivers.HighFinesse.wlm import WLM

wlm = WLM(version=7, dll_path="C:\\wlm\\wlmData.dll")

# Read the current frequency of channel 1
freq = wlm.get_frequency(channel=1)    # THz
wavelength = wlm.get_wavelength(channel=1)  # nm

# Exposure control (auto-adapts to light intensity)
wlm.set_exposure(channel=1, mode="auto")

Thorlabs optical power meters PM100 / PM400

from quatm.drivers.Thorlabs.misc import GenericPM
pm = GenericPM(addr="USB0::0x1313::0x8078::P1234567::INSTR")
pm.set_wavelength(780.0)    # 780 nm calibration
power = pm.get_power()      # Current power (W)

4.4 - Motion and positioning

Overview

Quatm supports a wide range of motion platforms, from piezo nanopositioning to long-travel stepper motors, behind a unified IMultiaxisStage interface.

Physik Instrumente (PI) piezo nanopositioning

Overview

GenericPIController wraps serial communication with PI general-purpose controllers and controls a variety of PI piezo positioning platforms through the ASCII command set.

Initialization

from quatm.drivers.PhysikInstrumente.base import GenericPIController

# serial connection
stage = GenericPIController(conn="/dev/ttyUSB0")

# home
stage.home(axis=0)

# absolute positioning (µm)
stage.move_to(axis=0, position=50.0)

# Relative move
stage.move_by(axis=1, delta=10.0)

# query current position
pos = stage.get_position(axis=0)

Key methods

Device configuration

"objective_z": {
    "type": "local",
    "module": "drivers.PhysikInstrumente.base",
    "class": "GenericPIController",
    "arguments": {"conn": "/dev/ttyUSB0"},
}

Usage example

# In the Experiment class
self.pi_stage = self.get_device("pi_stage")

# Move to the target position (µm)
self.pi_stage.move_absolute(x=50.0, y=25.0, z=10.0)

# Relative move
self.pi_stage.move_relative(dx=1.0, dy=0.0, dz=0.0)

Note: piezo translation stages have a limited travel range, and exceeding it triggers hardware protection. Consult the device manual to confirm the maximum travel before use.

Thorlabs APT/Kinesis translation stages

KDC101 / K10CR1 series

from quatm.drivers.Thorlabs.kinesis import BasicKinesisDevice
stage = BasicKinesisDevice(conn="27200001")
stage.home()
stage.move_to(position=25.0)    # mm

Elliptec piezoelectric resonant motors

from quatm.drivers.Thorlabs.elliptec import ElliptecMotor
motor = ElliptecMotor(conn="/dev/ttyUSB0", addrs=[0])
motor.move_to(axis=0, position=10.0)

Motorized filter wheels FW102/FW212

from quatm.drivers.Thorlabs.serial import FW
fw = FW(conn="/dev/ttyUSB0")
fw.set_position(position=2)    # switch to filter position 2

KDC101 motorized translation stage

Control Thorlabs KDC101/T-Cube series motorized translation stages through the .NET SDK.

from quatm.drivers.thorlabs.kdc101 import KDC101

stage = KDC101("26001234")   # Serial number
stage.home()                  # Home
stage.move_absolute(10.0)     # Move to 10.0 mm
pos = stage.get_position()    # Read current position

Attocube ANC300 / ANC350 nanopositioning

from quatm.drivers.Attocube.anc300 import ANC300

anc = ANC300(conn=("192.168.1.30", 7230))

# home
anc.home(axis=0)

# Nanometer-level step
anc.move_by(axis=0, delta=0.1)  # 100 nm

# Continuous scan mode
anc.set_continuous_mode(axis=1, enable=True)
anc.set_continuous_speed(axis=1, speed=100.0)  # nm/s

from quatm.drivers.Attocube.anc350 import ANC350

anc = ANC350(conn=0)  # First USB device
anc.move_to(axis=0, position=50.0)

Newport Picomotor 8742 4-axis controller

from quatm.drivers.Newport.picomotor import Picomotor8742

# USB connection
pico = Picomotor8742(conn=0)

# Or TCP/IP
pico = Picomotor8742(conn="192.168.1.40", multiaddr=(0, 1))

pico.move_to(axis=0, position=5.0)  # mm
pico.home(axis=0)

SmarAct MCS2 / SCU3D high-precision positioning

from quatm.drivers.SmarAct.MCS2 import MCS2

mcs = MCS2(locator="usb:sn:12345678")
mcs.move_to(axis=0, position=10.0)  # mm
mcs.get_position(axis=0)

from quatm.drivers.SmarAct.scu3d import SCU3D

scu = SCU3D(idx=0)
scu.move_to(axis=1, position=25.0)

Standa 8SMC stepper motor controllers

from quatm.drivers.standa.base import Standa8SMC

stage = Standa8SMC(conn="/dev/ttyUSB0")
stage.move_to(position=50.0)  # mm
stage.home()

Arcus Performax multi-axis stepper control

from quatm.drivers.arcus.performax import GenericPerformaxStage

stage = GenericPerformaxStage(idx=0, conn="USB")
stage.move_to(axis=0, position=100.0)
stage.set_acceleration(axis=0, accel=50.0)   # mm/s²

Trinamic TMCM-1110 integrated stepper motor

from quatm.drivers.trinamic.base import TMCM1110

motor = TMCM1110(conn="/dev/ttyUSB0")
motor.move_to(position=180.0)  # Rotation (°)
motor.set_velocity(500.0)      # °/s

Generic motion platform configuration

"objective_z": {
    "type": "local",
    "module": "drivers.Attocube.anc300",
    "class": "ANC300",
    "arguments": {"conn": ("192.168.1.30", 7230)},
}

4.5 - DAQ and power supplies

Overview

Data acquisition and power equipment form the infrastructure of experiment automation. Quatm provides a unified NI-DAQmx wrapper together with SCPI/Modbus instrument drivers.

Rigol DP1116A programmable DC power supply

from quatm.drivers.rigol.power_supply import DP1116A

ps = DP1116A(addr="USB0::0x1AB1::0x0E11::DP1A123456789::INSTR")
ps.set_voltage(12.0)       # 12V
dc.set_current(0.5)        # 500 mA current limit
ps.enable_output(True)

Rigol DP932 programmable DC power supply

Provides programmable DC power for a wide range of laboratory equipment.

from quatm.drivers.rigol.dp932 import RigolDP932

psu = RigolDP932("USB0::...")
psu.set_voltage(1, 5.0)     # Channel 1: 5.0 V
psu.set_current(1, 1.0)     # Channel 1: 1.0 A current limit
psu.output_on(1)

NI-SWITCH matrix/multiplexer switches

from quatm.drivers.NI.ni_switch import NISwitch

sw = NISwitch(resource_name="PXI1Slot2")
sw.connect(channel1="ch0", channel2="com0")
sw.disconnect(channel1="ch0", channel2="com0")
all_relays = sw.get_relay_count()

NI-Digital digital waveform generator/analyzer

from quatm.drivers.NI.ni_digital import NIDigital

dig = NIDigital(resource_name="PXI1Slot3")
dig.configure_voltage_levels(voltage=3.3)
pattern = [0b10101010] * 100  # 100-cycle digital waveform
dig.burst_pattern(pattern, frequency=10e6)

NI-DAQmx multifunction data acquisition

from quatm.drivers.NI.daq import NIDAQ

daq = NIDAQ(
    dev_name="Dev1",
    rate=100_000,         # 100 kS/s
    buffer_size=10_000,
)

# Analog input (continuous acquisition)
daq.configure_ai(channels=["ai0", "ai1"], voltage_range=(-10, 10))
daq.start_ai()
data = daq.read_ai(samples=1000)

# Analog output
daq.configure_ao(channels=["ao0"], voltage_range=(0, 5))
daq.write_ao(channel="ao0", voltage=3.3)

# Digital I/O
daq.configure_di(lines=["port0/line0"])
daq.configure_do(lines=["port0/line1"])
daq.write_do(line="port0/line1", value=True)

# Counters (photon counting / frequency measurement)
daq.configure_counter(
    counter="ctr0",
    mode="edge_count",
    source="PFI0",
)
counts = daq.read_counter("ctr0")

Conrad relay board controller

from quatm.drivers.Conrad.base import RelayBoard

# Single board
rb = RelayBoard(conn="/dev/ttyUSB0", start_addr=0)
rb.set_relay(relay=0, state=True)   # Close relay 1
rb.set_relay(relay=3, state=False)  # Open relay 4

# Byte write (controls 8 channels at once)
rb.write_byte(0b10101010)

Elektro Automatik PS2000B high-power supply

from quatm.drivers.ElektroAutomatik.base import PS2000B

ps = PS2000B(conn="/dev/ttyUSB0", remote_mode=True)

# Constant-current mode — magnetic field coil
ps.set_current(50.0)      # 50 A
ps.set_voltage_limit(20.0) # 20 V voltage limit
ps.enable_output(True)

# Read actual values
actual_v = ps.get_voltage()
actual_i = ps.get_current()

Keithley 2110 benchtop digital multimeter

from quatm.drivers.Keithley.multimeter import Keithley2110

dmm = Keithley2110(addr="USB0::0x05E6::0x2110::1234567::INSTR")

# DC voltage measurement
voltage = dmm.measure_voltage(range="10V")

# 4-wire resistance measurement
resistance = dmm.measure_resistance_4wire(range="100Ω")

# Temperature (thermocouple)
temp = dmm.measure_temperature(tc_type="K")

Voltcraft VC7055 two-channel benchtop multimeter

from quatm.drivers.Voltcraft.multimeter import VC7055

dmm = VC7055(addr="/dev/ttyUSB0")

# Simultaneous two-channel measurement
v1 = dmm.measure_voltage(channel=1)
v2 = dmm.measure_voltage(channel=2)

Device configuration

"daq": {
    "type": "local",
    "module": "drivers.NI.daq",
    "class": "NIDAQ",
    "arguments": {"dev_name": "Dev1", "rate": 100_000},
},
"coil_ps": {
    "type": "local",
    "module": "drivers.ElektroAutomatik.base",
    "class": "PS2000B",
    "arguments": {"conn": "/dev/ttyUSB0", "remote_mode": True},
},
"dmm": {
    "type": "local",
    "module": "drivers.Keithley.multimeter",
    "class": "Keithley2110",
    "arguments": {"addr": "USB0::..."},
},

4.6 - Environmental monitoring

Overview

Laboratory environmental monitoring underpins the stability of quantum experiments. Quatm ships drivers for temperature, vacuum and cryogenic level monitoring with real-time data logging and anomaly alerts.

Lakeshore 218 temperature monitor

from quatm.drivers.Lakeshore.base import Lakeshore218

ls = Lakeshore218(conn="/dev/ttyUSB0")

# Configure channel 1 as a silicon diode
ls.set_sensor_type(channel=1, sensor_type="DT-670")

# Read temperature
temp = ls.get_temperature(channel=1)   # Kelvin
all_temps = ls.get_all_temperatures()  # All 8 channels

# Read raw sensor values (voltage/resistance)
raw = ls.get_reading(channel=1)

Cryocon 12C / 14C / 18C temperature controllers

from quatm.drivers.Cryocon.base import Cryocon1x

cryo = Cryocon1x(conn="/dev/ttyUSB0", nchannels=4)

# Read channel 1 temperature
temp = cryo.get_temperature(channel=1)

# PID setpoint
cryo.set_setpoint(channel=1, temperature=4.2)  # 4.2 K
cryo.set_heater_range(channel=1, range="low")
cryo.enable_heater(channel=1, enable=True)

Lumel RE72 · Omron E5_C temperature controllers

from quatm.drivers.Lumel.base import LumelRE72Controller
from quatm.drivers.Omron.base import OmronE5xCController

# Lumel RE72
lumel = LumelRE72Controller(conn="/dev/ttyUSB1", daddr=1)
temp = lumel.get_temperature()
lumel.set_setpoint(25.0)

# Omron E5_C
omron = OmronE5xCController(conn="/dev/ttyUSB1", daddr=2)
omron.set_setpoint(30.0)
omron.enable_heater(True)

Pfeiffer TPG2xx high-vacuum gauges

from quatm.drivers.Pfeiffer.base import TPG2xx

tpg = TPG2xx(conn="/dev/ttyUSB0")

# Read both pressure channels
p1 = tpg.get_pressure(channel=1)  # mbar
p2 = tpg.get_pressure(channel=2)

# Gauge type identification
gauge_type = tpg.get_gauge_type(channel=1)

Leybold ITR wide-range vacuum gauges

from quatm.drivers.Leybold.base import GenericITR

itr = GenericITR(conn="/dev/ttyUSB0")
pressure = itr.get_pressure()  # mbar

Agilent XGS-600 multi-channel vacuum controller

from quatm.drivers.Agilent.pressure import XGS600

xgs = XGS600(conn="/dev/ttyUSB0", addr=1)

# Read all channel pressures
pressures = xgs.get_all_pressures()
p1 = xgs.get_pressure(channel=1)

Cryogenic level monitoring

Cryomagnetics LM500 liquid helium/nitrogen level meter

from quatm.drivers.Cryomagnetics.base import LM500

lm = LM500(conn="/dev/ttyUSB0")

helium_level = lm.get_helium_level()    # %
nitrogen_level = lm.get_nitrogen_level() # %
sample_temp = lm.get_temperature()

American Magnetics 1700 level monitor

from quatm.drivers.AmericanMagnetics.base import AM1700

am = AM1700(conn="192.168.1.50")  # TCP/IP
# Or serial port: am = AM1700(conn="/dev/ttyUSB0")
level = am.get_helium_level()

Generic environmental monitoring configuration

"chamber_pressure": {
    "type": "local",
    "module": "drivers.Pfeiffer.base",
    "class": "TPG2xx",
    "arguments": {"conn": "/dev/ttyUSB0"},
},
"cryo_temp": {
    "type": "local",
    "module": "drivers.Lakeshore.base",
    "class": "Lakeshore218",
    "arguments": {"conn": "/dev/ttyUSB1"},
},

4.7 - Experiment control and others

Overview

FPGA controllers and auxiliary devices are an essential part of experiment automation: from nanosecond real-time timing to relay switching, Quatm provides a unified control interface. ADwin, NI-FPGA, Red Pitaya and several other brands are currently supported.

ADwin

Overview

ADwin is a family of real-time controllers from Jaeger Computergesteuerte Messtechnik, based on an FPGA/DSP architecture, that executes real-time tasks independently of the PC operating system.

How it works

PC (Quatm)                    ADwin (real-time)
┌──────────┐    PCI/USB    ┌──────────────┐
│ experiment│ ←──────────→ │ ADbasic proc │
│   .py     │  Par/Data    │ ns timing+acq│
└──────────┘               └──────────────┘

Quatm experiment scripts read and write parameters and data arrays through the ADwin driver, interacting with the ADbasic process running on the ADwin. The timing-critical parts execute on the ADwin hardware, while the Python side handles parameter setting and result readout.

Initialization

from quatm.drivers.fpga import ADwin

# Connect to ADwin (PCI bus)
adw = ADwin(device_number=1)

# Load and start the ADbasic process
adw.load_process("experiment_sequence.TB1")
adw.start_process()

# Set experiment parameters
adw.set_par(1, 100_000)     # Par_1 = 100 µs cooling time
adw.set_par(2, 50)          # Par_2 = 50 cycles
adw.set_par(3, 10_000)      # Par_3 = 10 ms detection time

# Start one experiment sequence (triggered by an event in ADbasic)
adw.trigger()

# Read acquired data
photons = adw.get_data(1, data_length=1000)  # Read photon counts from Data_1

Key methods

Typical ADbasic process structure

' ADbasic code snippet — experiment timing
Init:
  Par_1 = 100000   ' Cooling time (µs)
  Par_2 = 50       ' Number of cycles
Event:
  For i = 1 To Par_2
    P2_DAC(1, 5000)   ' Set AOM power
    P2_DAC(2, 800)    ' Set magnetic field
    ' ... wait, acquire, switch ...
  Next i

Device configuration

"fpga": {
    "type": "local",
    "module": "quatm.drivers.fpga",
    "class": "ADwin",
    "arguments": {"device_number": 1},
}

Exception:

• quatm.drivers.fpga.adwin.AdWinDriverError(message)

  class quatm.drivers.fpga.adwin.AdWinDriverError(Exception):
      pass
  

quatm.drivers.fpga.client module

Class:

• quatm.drivers.fpga.client.AdWinClient(experiment, simulating=None)

  class quatm.drivers.fpga.client.AdWinClient(object):
      def filter_cmdlist(self, combinetime=1e-08):
          pass
  
      def push(self, time, command, value, combinetime=1e-09):
          pass
  
      def start_realtime(self, processortime=0, repetitions=1):
          pass
  
      def stop(self):
          pass
  

quatm.drivers.fpga.units module

NI-FPGA LabVIEW FPGA modular instruments

from quatm.drivers.NI.ni_fpga import NIFPGA

fpga = NIFPGA(resource_name="RIO0", bitfile="custom_logic.lvbitx")
fpga.run()
fpga.write_control("pulse_width", 100)        # ns
fpga.write_control("trigger_delay", 50)
fpga.read_indicator("photon_count")

Conrad relay board

from quatm.drivers.Conrad.base import RelayBoard

rb = RelayBoard(conn="/dev/ttyUSB0", start_addr=0)
rb.set_relay(relay=0, state=True)
rb.set_relay(relay=3, state=False)
rb.write_byte(0b10101010)

5 - Data and analysis

Data path

Experiment runs publish typed data and image streams over ZeroMQ. Data clients subscribe to the channels they need; the Data Manager accumulates runs, writes HDF5 files and exposes live series to the GUI and web console. The message and property Hubs provide the same data to every client, so a plot, a notebook and a remote browser see one coherent experiment.

HDF5 structure

A run is archived with:

• the experiment and task identifiers;
• parameter values and scan definition;
• DAC/TTL settings and sequence metadata;
• scalar data series and image data;
• save-acknowledgement status and error information.

The file is self-describing: a run can be reconstructed and compared without the original GUI session.

Analysis modules

Quatm includes reusable analyses for common quantum-physics measurements:

• absorption imaging and optical density;
• ion / bright-spot detection;
• 1D and 2D Gaussian fits;
• skewed-Gaussian and multi-peak fits;
• ROI and line-profile extraction;
• averaging and histogram utilities.

Analysis can run from the Data Manager, from Python scripts, or on the analysis machine while acquisition continues. The same modules are used in the desktop GUI and in the web console.

Live monitoring

The Stream Monitor and image viewers follow data as it arrives. The history viewer, timeline and live plots are read-only clients: they cannot alter the experiment state. This makes them safe to open during operation and on remote machines.

Export

Data and fit results can be exported to CSV, images or publication-quality PDF. Export runs off the GUI thread, so large datasets do not freeze the interface.

5.1 - 2D Gaussian fit

Overview

quatm/analysis/2D_gauss_fit.py provides 2D Gaussian fit analysis (TwoDGaussFit): it subscribes to an image stream and, on receiving an image, performs a 2D Gaussian fit inside the ROI (astropy Gaussian2D + Const2D, Levenberg-Marquardt iterations), publishes the fit parameters to the data stream and sends 1/e and 1/e² contour masks back to the image stream.

A fast variant, quatm/analysis/2D_gauss_fit_fast.py, is also available: the core fit is implemented in a Cython extension, and the interface and functionality are identical.

Output parameters: center x0 / y0, widths sigma_x / sigma_y, amplitude and background.

Usage

from quatm.analysis.2D_gauss_fit import TwoDGaussFit

fitter = TwoDGaussFit(name="gauss2d")   # subscribe to the imagestreams image stream
fitter.run()

The analysis process is started from the Analysis Manager (AnalysisManager), where it is selected with a checkbox.

5.2 - 1D Gaussian fit

Overview

quatm/analysis/gaussfit.py provides 1D Gaussian fit analysis (Gaussfit): as a standalone analysis process it subscribes to data streams, fits a Gaussian to each frame of 1D data and publishes the results to the data stream.

The fit function has the form:

f(x) = A0 / (sqrt(2*pi) * sigma) * exp(-(x - pos)^2 / (2*sigma^2)) + offset

The output parameters are A0 (area), sigma (width), pos (center), offset (background) and height (peak height = A0/(sqrt(2π)·σ)).

Configuration properties

Usage

from quatm.analysis.gaussfit import Gaussfit

gf = Gaussfit(name="gauss")   # name serves as the property/data-stream namespace
gf.run()

The analysis process is started from the Analysis Manager (AnalysisManager), where it is selected with a checkbox; input streams and parameters are configured in the property tree.