Glossary

This page documents terms that have a specific meaning in midas, or that may be unfamiliar if you are new to data acquisition (DAQ) systems.

A

Alarm: A notification raised when a condition is met, e.g. a temperature going out of range or a program stopping. Alarms are shown in a banner on every web page, and can also write a message, stop the run or run a script. See Alarms.
Alias: An extra link in the side menu of the web interface, pointing to an ODB location or an external webpage. Aliases are defined in the /Alias ODB directory. See Aliases.
Analyzer: A program that reads events (either live from an event buffer, or from a midas file) and processes them, e.g. to fill histograms. midas provides the manalyzer framework for writing analyzers. See Data analysis.

B

Bank: A named block of data inside an event, with a header that describes its name, data type and size. Each bank contains an array of a single data type. Bank names are four characters long, e.g. ADC0. See Midas data bank.
BOR / EOR: Begin-of-run and end-of-run. Often used for things that happen at the start or end of a run, e.g. the copies of the ODB that are written to midas files (these are actually written at the start and end of each file, which may be a subrun). See Begin-of-run and end-of-run events.
Buffer: Short for event buffer.

C

Class driver: The upper layer of the slow control driver system. It links ODB variables to a device, and handles features like channel limits and ramping, without knowing the details of the hardware. See also device driver. See Slow control: programming.
Client: Any program that is connected to a midas experiment. This includes built-in programs like mhttpd and mlogger, and your own frontends and analyzers. Connected clients are listed on the "Programs" webpage and in /System/Clients in the ODB. See Programs.
Custom page: A webpage that you write yourself (HTML/JavaScript), which is served by mhttpd alongside the built-in pages. Custom pages are often used for shifter instructions or experiment-specific control panels. See Custom pages: overview.
CustomScript: A button on a custom page that runs a script on the server when pressed. Scripts are defined in the /CustomScript ODB directory.

D

Data logger: The program that writes events to disk, which is mlogger. See Data logging.
Deferred transition: A run transition that a client asks to be delayed until it is ready, e.g. to wait for the end of a hardware cycle before stopping. See Deferred transitions.
Device driver: The lower layer of the slow control driver system. It talks to a specific piece of hardware, and implements only simple commands like "set channel voltage" or "read channel current". See also class driver.

E

Edit on start: Questions (e.g. "beam energy" or "write data to disk?") that are asked when a user starts a run from the web interface. See Edit on start.
EOR: See BOR / EOR.
Equipment: A part of a frontend that generates events. Often each equipment reads out one piece of hardware, but equipment can also be purely software-based. Each equipment has its own settings and statistics in /Equipment/<name> in the ODB. See Equipment types.
Equipment type: How an equipment decides when to read out an event, e.g. periodically (EQ_PERIODIC), whenever data is available (EQ_POLLED), or on request (EQ_MANUAL_TRIG). See Equipment types.
Event: The basic unit of data in midas. An event has a header (containing the event ID, trigger mask, serial number and timestamp), followed by data, usually in the form of banks. See Event data format.
Event buffer: An area of shared memory that clients can write events to and read events from. Frontends write to the SYSTEM buffer by default, and mlogger reads from it. See Event buffers.
Event builder: A program that combines events from several frontends into a single event, e.g. so that all the data from one trigger is stored together. See Event building.
Event ID: A number in the event header that identifies which equipment produced the event. Consumers of event buffers can choose to only receive events with a specific event ID. See Event header.
Experiment: A single midas DAQ setup, with its own ODB, event buffers and programs. One computer can host several experiments. Programs choose which experiment to connect to using the -e flag or the MIDAS_EXPT_NAME environment variable. See Set up your first experiment.
Experiment directory: The directory that holds an experiment's files, such as the saved ODB and the shared memory files. It is defined in the exptab, or by the MIDAS_DIR environment variable.
Experiment host: The computer where an experiment's ODB and event buffers live. Programs on other computers connect to it via mserver. See also remote host.
exptab: A text file that lists the experiments on a computer, and the experiment directory of each one. See Defining the experiment.

F

FIXED format: An older event format where the data area is a fixed C structure, rather than banks. Only supported by the mfe framework. See FIXED format event.
Frontend: A program that reads data from hardware (or generates it in software) and sends it to midas as events. Frontends are usually written by the user, using one of the frontend frameworks. See Frontends.
Frontend framework: A library that handles the parts of a frontend that are the same for every experiment (connecting to midas, handling run transitions, sending events), so that you only have to write the readout code. midas provides three: mfe (C-like C++), TMFE (object-oriented C++) and midas.frontend (Python). See Frontends: programming.
Frontend index: A number passed to a frontend with the -i flag, so that several copies of the same frontend can run at once (e.g. one per crate) with their own equipment names. See Frontend index.

H

History: The system that records values (e.g. temperatures, rates) over time, so they can be plotted on the web interface. This is separate from the main event data that is written to midas files. See History.
Hotlink: A request to be told whenever a part of the ODB changes, e.g. so that a frontend can apply new settings to its hardware immediately. Also called an "open record" or "watching" an ODB key. See Hotlinks.

J

JSON-RPC: The protocol that webpages use to talk to mhttpd, e.g. to read and write ODB values or start a run. See JSON-RPC.

K

Key: A single entry in the ODB. A key can be a directory, a value, an array of values, or a link. In the path /Logger/Write data, Write data is a key in the /Logger directory.

L

lazylogger: A program that copies midas files to another location (e.g. tape or a remote server) after they have been written. See Archiving.
Link: An ODB key that points to another ODB key, like a symlink in a filesystem. See Symlinks.

M

manalyzer: The midas framework for writing analyzers in C++. See manalyzer.
Message: A line of text sent by a client (e.g. an error or information message), which is shown on the "Messages" webpage and written to the message log files. See Messages.
mfe: The original C-style frontend framework, declared in mfe.h.
mhttpd: The midas web server, which provides the web interface for controlling and monitoring an experiment. See Web interface and mhttpd.
midas file: A file of events written by mlogger, with the extension .mid (or e.g. .mid.lz4 if compressed). By default a copy of the ODB is stored at the start and end of each file. See midas files.
mlogger: The midas data logger. It writes events to midas files, records history data, and writes the run log. See Data logging and mlogger.
MSCB: The midas slow control bus, a fieldbus developed at PSI for connecting low-cost slow control hardware (e.g. temperature sensors) to midas. See Slow control: MSCB.
MSL: The midas sequencer language, a simple scripting language for automating sequences of runs. See Sequencer: scripting.
mserver: The program that lets clients on other computers connect to an experiment. See Running on multiple machines and mserver.

O

ODB: The online database. A hierarchical, in-memory database that holds the configuration and current state of the experiment. All clients can read and write it, and a copy is stored in each midas file. See ODB.
ODB dump: A copy of the ODB (or part of it) saved to a file, in JSON, XML or the ASCII .odb format. See Saving and loading.
ODB path: The "address" of an ODB key, made of directory names separated by /, e.g. /Runinfo/Run number. ODB paths are not case-sensitive.
Online / offline: "Online" means while data is being taken, connected to a running experiment (e.g. online analysis). "Offline" means afterwards, working from saved midas files.

P

Periodic equipment: An equipment that reads out an event at a fixed interval, e.g. every 10 seconds. Often used for slow control and statistics. See Equipment types.
Polled equipment: An equipment where the frontend framework repeatedly asks your code whether new data is available, and reads out an event when it is. Usually used for the main data stream. See Equipment types.
PySequencer: The Python version of the sequencer, which runs sequencer scripts written in Python instead of MSL. See Sequencer.

R

Read-on flags: Equipment settings that say when an equipment should read out events, e.g. only while running (RO_RUNNING), or at every transition (RO_TRANSITIONS). See When to read data.
Remote host: A computer that runs midas clients, but is not the experiment host. Clients on a remote host connect via mserver. See Running on multiple machines.
Run: A period of data taking, from a start transition to a stop transition. Each run has a unique run number, and usually its own midas file. See Runs.
Run state: Whether the experiment is Running, Paused or Stopped. See Run states and transitions.

S

Script: A link in the side menu of the web interface that runs a script on the server when clicked. Scripts are defined in the /Script ODB directory.
Sequence number: A number that sets the order in which clients are told about a run transition, so that one program can be prepared before another. Not to be confused with the event serial number. See Sequence ordering.
Sequencer: A program that runs scripts to automate the experiment, e.g. to take a series of runs with different settings. See Sequencer.
Serial number: A number in the event header that counts the events sent by an equipment, so that lost or out-of-order events can be detected. See Event header.
Shared memory: Memory that several programs on the same computer can access at once. midas keeps the ODB and event buffers in shared memory, which is backed by .SHM files in the experiment directory (e.g. .ODB.SHM).
Slow control: Controlling and monitoring hardware that is not time-critical, such as high voltage supplies, temperature sensors and pressure gauges. Slow control values are usually recorded in the history system. See Slow control.
Status page: The main page of the web interface, showing the run state, the equipment and their event rates, and the logger status.
Subrun: A part of a run that is written to a separate midas file, so that long runs don't produce very large files. See Run and subrun duration.
SYSMSG: The built-in event buffer used for messages. See Event buffers.
SYSTEM: The built-in event buffer that frontends write events to by default, and that mlogger reads from. See Event buffers.

T

Tag: A single variable that is recorded in the history system. Tags are grouped into history "events". See Events and tags.
TMFE: The object-oriented C++ frontend framework, declared in tmfe.h.
Transition: A change from one run state to another: start, stop, pause or resume. Clients can register to be told about transitions, e.g. to configure hardware at the start of a run. See Run states and transitions.
Trigger mask: A number in the event header that programs can use to tell different kinds of event apart, e.g. physics, calibration or periodic events. See Event header.

W

Watchdog: A timeout that removes a client from the experiment if it stops responding (e.g. because it crashed). Clients reset their watchdog by regularly checking in with midas. See Watchdog timeout.
Web interface: The set of webpages served by mhttpd, used to control and monitor the experiment from a browser. See Web interface.