EUDAQ—a data acquisition software framework for common beam telescopes

EUDAQ is a generic data acquisition software developed for use in conjunction with common beam telescopes at charged particle beam lines. Providing high-precision reference tracks for performance studies of new sensors, beam telescopes are essential for the research and development towards future detectors for high-energy physics. As beam time is a highly limited resource, EUDAQ has been designed with reliability and ease-of-use in mind. It enables flexible integration of different independent devices under test via their specific data acquisition systems into a top-level framework. EUDAQ controls all components globally, handles the data flow centrally and synchronises and records the data streams. Over the past decade, EUDAQ has been deployed as part of a wide range of successful test beam campaigns and detector development applications.


Introduction
Test beam campaigns with beam telescopes constitute a crucial component in the research and development of novel particle detectors.In-depth performance studies usually require simultaneous operation of different detector systems and synchronised recording of data.This often poses a significant challenge due to the necessary hardware and software integration into a common data acquisition (DAQ) system.
EUDAQ is a generic DAQ software framework that was developed to simplify this integration process.Written in C++, supporting multiple platforms such as Linux, MacOS X and Windows and distributed under the LGPLv3 [1], EUDAQ provides a high level of interoperability.As such, it is one of the few examples of common tools for test beams today and is well-received by a growing user -1 -community [2].The development of EUDAQ started as part of the EU-funded Joint Research Activity of the EUDET project "Test Beam Infrastructure" [3,4] in 2005.The goal of the project was the development of a high-precision pixel beam telescope for investigations of the tracking performance of sensor devices.To make this beam telescope a versatile tool for a broad user base and a wide variety of devices, an easy integration strategy for devices under test (DUT) and its DAQ was a priority from the beginning of the project [5].The interface that was considered to be the most flexible for the user consisted of two separate layers: on the hardware level, the different DAQ systems were to be synchronised using a simple trigger-busy communication protocol; on the software level, the full integration of the DUT into EUDAQ was foreseen as the preferred approach, yet was kept optional.
This approach determined the core architecture of EUDAQ [6] which remains today: centralised but distributed core components that communicate with so-called Producers via a custom TCP/IPbased protocol.In this scheme, the latter are responsible for implementing an interface to the individual hardware components, controlling the devices' states and feeding the data into the central data collection unit.Both the beam telescope detector planes and the DUT use the same interface, thus making the framework flexible and independent of any specific hardware.The framework architecture is described in more detail in section 2.
Historically, the most prominent application of EUDAQ is the DAQ of the EUDET-type pixel beam telescopes [7].They are based on Mimosa26 sensors [8] as telescope planes and a custom-designed trigger logic unit (TLU), the EUDET TLU [9].Today, the EUDET-type beam telescopes are accessible as common infrastructure at test beam facilities all over the world.This broad availability of beam telescopes combined with the ease-of-use, extensive documentation and user-focus of EUDAQ outlined in section 3 has led to a large number of successful EUDAQ-based test beam campaigns in the last decade: in section 4, eleven applications from a wide range of communities are described in more detail.
Since the early days of mostly user-driven development, EUDAQ has been moved to a collaborative development model with several active contributors.New features as well as many behind-the-scenes changes such as continuous integration methods paved the road towards the second major version of EUDAQ as briefly outlined in section 5.

Framework architecture
The EUDAQ framework is split into a number of different processes, usually running on several different computers connected via LAN, and communicating using a custom TCP/IP protocol, indicated by arrows between the components in figure 1.The framework is written in C++, with minimal external dependencies, in order to ensure maximal portability.It uses POSIX threads for concurrency and POSIX sockets [11] for inter-process communication over TCP/IP.
There are three separate channels for sending different types of information to the individual EUDAQ processes: the command, the data and the log channel.In the following, a brief overview of the framework architecture and its concepts is given in section 2.1, and the individual communication channels are introduced in more detail in sections 2.2, 2.3 and 2.4.The architecture overview is complemented by a description of the online monitoring tool in section 2.5 as a crucial part of the user interface.

Overview & concepts
A central Run Control provides an interface to the user for controlling the DAQ system.The Run Control monitors the state of all other processes and sends them commands to start and stop a run, configure the components etc. using the command channel indicated by the red arrows in figure 1.Here, run indicates a continuous period of data taking with typical durations ranging from a few minutes to several hours.Runs are divided into so-called events, which represent the data from all participating devices corresponding to one trigger.Triggers are synchronised between different devices at the hardware level.
Each process of the DAQ that produces data is controlled by a Producer.The EUDAQ Producer class provides a standardised interface to the rest of the framework for receiving commands and sending data and log messages.A Producer should send one event for every trigger.Each event consists of a standard header containing the run number, the trigger number and some other status information, along with the unprocessed raw data from the sensor.If a Producer has no data for certain events for example a small sensor that does not register a hit for every trigger, then it should send empty events (see section 4.11).In addition to these standard events, each Producer must also send special beginning-of-run and end-of-run events at the start and end of each run respectively.The beginning-of-run event includes the configuration data for the run, ensuring that this information is always available with the collected data.For devices that generate data much less frequently or triggerless data, for example temperature sensors, motor stages (see section 4.7 or 4.10) or other environment monitors, EUDAQ provides an alternative base class called Slow Producer.However, it is encouraged to use the standard Producers whenever feasible, since the strong synchronisation of events provided helps to ensure data integrity.
The Data Collector receives data as EUDAQ Event objects from all data-generating processes over the data channel as shown by the blue arrows in figure 1.It collates and organises them such that event data from all Producers is ordered and synchronised, and then for each trigger it combines -3 -all the relevant events and writes them to disk (Storage in figure 1).Because all Producers send one event for every trigger, along with the beginning and end of run events to mark the runs, the synchronisation between Producers to be kept simple, and any problems can be caught and rectified as early as possible.During event building the Data Collector ignores the absence of events from Slow Producers, which are distinguished from the usual Producers by the type information that is communicated during the initial connection.By default, the data files are just the serialised EUDAQ Event objects, consisting of a common header with run number, trigger number etc. and the raw binary data provided by the respective detector.By directly recording the raw detector response without online processing, all initially available information is retained and the risk posed by possible mistakes in the intermediate data processing code is mitigated.These architectural decisions have proven to provide a high degree of stability and confidence in the integrity of the collected data.If required, EUDAQ may also be configured to write in various other formats, such as the LCIO format [12,13] or its own StandardEvent format.
Log messages from all processes are collected centrally in the Log Collector, using the dedicated log channel indicated by gray arrows in figure 1.This provides a central location for the user to monitor all distributed processes for any unexpected warnings or errors.The Online Monitor reads the output data file and generates a range of plots to help the user verify that the system is operating properly.
Data is serialised using a simple EUDAQ-specific binary format.The primitive types like different-sized integers, floats etc. are serialised as a sequence of bytes using little-endian format even on big-endian CPU architectures, so that the data is compatible between different machine architectures.Strings are serialised using a 32-bit length indicator followed by the contents of the string interpreted as bytes.A range of standard types, such as std::vector and std::map are also handled by EUDAQ, using a similar scheme.Classes defined in the EUDAQ code base, or by the user, are made serializable by inheriting from the Serializable base class, and by implementing the virtual Serialize function and a constructor that takes a single Deserializer instance.In most cases, the implementation is as simple as writing each member variable to the Serializer in the Serialize method, and reading them in the same order in the constructor.All member variables of a Serializable class must also be serializable -either by inheriting from Serializable, or being explicitly handled by the Serializer class.

Command channel
The command channel is controlled by the Run Control component.All other components are connected to the command channel in order to keep track of the current state of the DAQ system.Components that communicate with the Run Control must inherit from the CommandReceiver class, which handles the reception of the command messages and calls the corresponding member functions.When receiving a command from the finite state machine of the Run Control, the component must execute the requested state transition and respond with its new state.
This allows the Run Control to monitor the states of individual components, and to define the global machine state.Messages on the command channel are kept simple, consisting of a single string command with an optional string parameter.This is encoded into a single string message, separated by a null byte if the optional parameter is present.The individual commands are listed in table 1.

Data channel
The data channel is used to collect all data generated during a run into a single component, where it is written to disk.This component is called Data Collector and acts as receiver for data from any of the Producers participating in the run.Usually this will include the Producer for the telescope DAQ, a Producer for the DUT DAQ, and a Producer for a system providing trigger information.
All Producers inherit from the Producer base class, which provides a SendEvent method that the inheriting class should call for each event to be sent to permanent storage.

Log channel
At runtime, every process can generate log messages containing information about the state of the component, or any unexpected occurrences.Simple access to the messages during data taking is realised by a central Log Collector, which collects messages from all Log channels.Every process inherits from the Log Sender class, enabling it to send log messages over the TCP/IP connection to the Log Collector.Each log message is an instance of the Log Message class, which contains the log message, a level such as INFO, WARNING, or ERROR, and a timestamp.Similar to other objects, it derives from the Serializable class, allowing network transmission in the usual binary encoding.

Online monitoring
An important feature of the EUDAQ framework is the ability to monitor the incoming data stream online using the Online Monitor, which is provided as a part of the framework.The Online Monitor only uses the information provided in the byte-stream and does not rely on external information.It treats every sensor unit as a plane with hits in x-y coordinates and is therefore ideally suited for pixelated detectors as well as strip-based sensors.For all planes a standard set of histograms is generated, e.g. a hit map both in 1D and 2D and the number of hits per sensor plane.The Online Monitor also implements some basic clustering routines and the possibility to perform hit correlations between individual sensor planes to enable gauging of the alignment between sensor planes and the particle beam already during data taking.Additionally, for each different type of -5 -sensor, dedicated histograms can be filled if implemented by the user.Finally, central performance monitoring histograms help to identify potential problems during data taking.
The EUDAQ Online Monitor uses the ROOT framework [14,15] both for creating histograms and rendering the graphical user interface.The initial release of the Online Monitor has been described in [16], but its performance has been significantly improved and its functionality extended by the integration of various other devices into the EUDAQ framework as will be described in sections 3 and 4.

Integration & operation
The straightforward architecture of EUDAQ allows new users to quickly integrate existing, hardware-specific DAQ systems into EUDAQ with minimal overhead.Within EUDAQ, each such integrated system is represented by a Producer.The Producer has two roles: to receive commands from Run Control and to send the acquired data to the Data Collector.As such, it provides an interface between the user's DAQ and the rest of the EUDAQ system.Producers can be implemented by deriving from a provided C++ base class, or by using ctypes-based Python bindings.For both use-cases, documentation as well as several examples are provided [6,17].
Whenever a command is received from Run Control, a corresponding member function of the Producer is invoked.By providing their own implementations of these functions, users are able to control their device's DAQ.The possible commands include OnInitialise, which is called once at startup to perform one-off initialisation; OnConfigure, which is called to configure the Producers, and may be called between runs to reconfigure with different settings; and OnStartRun and OnStopRun, which start or stop the acquisition, respectively.For the former two, Run Control includes a list of initialization or configuration parameters and their values, which are retrieved from a plain-text file in order to allow modification of parameters for individual data-taking runs.The latter two require the Producers to respond by sending begin-of-run and end-of-run events, respectively, containing specific flags.As well as ensuring synchronisation of runs between all Producers, these events also contain the full sensor configuration as well as the user-provided configuration parameters.Having this information stored alongside the actual data significantly simplifies the bookkeeping for later offline analysis and reference.A utility program called Magic Log Book can be used to extract run numbers and their associated parameters from collected data files in order to automatically generate a test beam "log book".
During a run, the data retrieved from a device may be submitted through the Producer's SendEvent method.The data is expected to be encapsulated in one of EUDAQ's event formats: usually, this is of type RawDataEvent which is a generic container for blocks of binary data.Additionally, each event can hold metadata which can be useful to record variables relating to device state changes.It is up to each Producer how the raw data is encoded, thus ensuring minimal interference by the data acquisition system and therefore reducing the potential for data corruption.The data are then serialised and sent to the Data Collector.
The Data Collector expects that all devices are synchronised through a hardware signal by a central trigger system and that their respective Producers send data on every single event.Otherwise, the Data Collector generates an error to alert the user of missing data.

JINST 15 P01038
While the data are usually written to disk in the device's native format, for online monitoring purposes and later analysis stages a conversion is usually necessary.To easily integrate into the existing tools provided by EUDAQ, the Data ConverterPlugin system was developed.For each type of RawDataEvent, a converter plugin can be registered.This plugin will be dynamically loaded and used to convert the native raw data into a format which can be parsed by EUDAQ.
Once a Producer, the RawDataEvent format and a Data ConverterPlugin have been developed, the respective device is fully integrated into the EUDAQ system and can seamlessly interact with all its components.At this point users are encouraged to submit their code for inclusion into the EUDAQ software repository [17].This centralised collection of Producers on the main repository helps prospective users in the detector R&D community by providing examples.Furthermore, the contributors benefit from the continuous integration methods employed in the EUDAQ development process.Through regular automated builds and tests, potential issues can be identified early in the process and mitigated before future releases.As EUDAQ is licensed under the GNU LGPLv3 [1], users are generally welcome to share, modify and contribute to its development.The source code of EUDAQ is hosted on GitHub, where any potential issues or feature requests can be reported through its issue tracking system.
Since interconnection between different platforms and even different architectures is often necessary when performing beam tests, EUDAQ has been developed with interoperability and easy deployment in mind.Using the CM build system, EUDAQ can be compiled on recent versions of GNU/Linux, MacOS X, and Microsoft Windows using the native compiler tools.The core library and the command-line executables of EUDAQ are self-contained and require no additional external dependencies.Optional components, such as specific Producers, can be enabled at build-time and might have additional dependencies.Commonly, these are Qt [18] for the graphical user-interface (GUI) and ROOT [14,15] for the online monitoring.
Each individual component of EUDAQ, such as the Run Control, the respective Producers and the Data Collector, run as separate processes communicating with the rest of the system via TCP/IP on configurable port numbers as described in section 2. Start-up scripts are provided that help to set up typical use-case scenarios.After starting EUDAQ, three windows are displayed as shown in figure 2: firstly, the Run Control GUI for interaction with the DAQ system and for display of the system state; secondly, the Log Collector window for listing all messages reported within the system, allowing direct searches and live filtering; lastly, the Online Monitor which reads back the data written to disk and generates live-updated histograms.Together these tools provide the detailed online feedback on the performance of the various components that is crucial to the user during test beam operations.
EUDAQ is shipped with many additional tools and ready-made Producers, a complete list of which can be found in the latest manual [19].Some of the optional components are related to the most common use-case: running within the EUDET-family of beam telescopes.From a hardware perspective, the beam telescopes consist of six planes of Mimosa26 sensors and a triggering system based around an EUDET TLU.Within the EUDAQ framework, these components are represented by their own Producers using the approach of integration into EUDAQ previously described.The NIProducer provides the interface to the Mimosa26 DAQ and is built around the National Instrument (NI) PXIe crate architecture [20,21].The TLUProducer connects via USB to the EUDET TLU to initialise, configure and operate it.Operating EUDAQ with the EUDET-type beam telescopes, the -7 - trigger or event rate is limited to 2.0 kHz in average.This limit is caused by the data read-out of the EUDET TLU and the Mimosa26 DAQ, but was also sufficient for most of the EUDAQ applications in the last decade (see section 4).For all telescope components, converter plugins are provided as part of EUDAQ allowing full online monitoring out-of-the-box.The EUDAQ converter plugins are also utilised by the beam telescope data analysis framework EUT [22][23][24] to interpret the raw data written by EUDAQ.EUT provides the user with extensive tools for clustering, alignment, track reconstruction, and data analysis.Thus, the telescope hardware with mechanical user interfaces, the EUDAQ framework, and the reconstruction framework EUT provide a unique infrastructure, which is extendible for any devices under test and covers all aspects of test beam studies.
To summarise, EUDAQ plays a central role in a wide-spread set of test beam tools, including the EUDET-type beam telescopes and the EUDET TLU: today there are seven copies of EUDET-type beam telescopes located at different test beam facilities such as PS and SPS at CERN, the DESY II Test Beam Facility, ELSA in Bonn and ESTB at SLAC.Furthermore, approximately 35 EUDET -8 -TLUs were produced and distributed to different R&D groups.Like all infrastructure around the EUDET-type beam telescopes, EUDAQ is highly modular and suited for many use-cases as shown in the following section.

Applications
EUDAQ is used by a large variety of detector systems.Many detector prototypes and DAQ systems today provide an integration with the EUDAQ system and thus greatly simplify their deployment in test beam campaigns.Especially for users of the DESY II Test Beam Facility [25], due to the close integration of the EUDET-type beam telescopes as well as the EUDET TLU described in section 3, EUDAQ has proven to be a valuable component of the test beam infrastructure.In the following, several integrations of detector prototypes with the EUDAQ system are presented in alphabetical order.Special attention is paid to the different requirements of the detector systems and the different approaches of integration into the EUDAQ framework.

ALICE Inner Tracker System: development of MAPS
The ALICE experiment [26] at the LHC is undergoing a major upgrade in the second Long Shutdown of the collider (2019-2020).During this upgrade, the Inner Tracking System (ITS) of ALICE will be completely replaced by a new silicon pixel detector.This new detector consists of seven layers of Monolithic Active Pixel Sensors (MAPS) designed specifically for the upgrade [27].This new sensor, called ALPIDE (ALICE PIxel DEtector) [28], is a 1.5 cm × 3 cm large pixel detector with 1024 × 512 pixels with a pitch of 27 µm × 29 µm.The sensor can be thinned down to a total thickness of 50 µm.
The ALPIDE sensor has been developed in a long prototyping and testing phase before arriving at the final design.First prototypes of the detector have been characterised in test beam measurements as early as 2013.This so-called Explorer chip [29] featured an analogue output, a small active matrix with approximately 12k pixels and has been tested using reference tracks from the EUDET-type beam telescope.In a next step, slightly larger prototypes with approximately 32k pixels and an ALPIDE-like architecture [30] were tested first with an EUDET-type beam telescope and later on with ALPIDE prototype-based telescopes as shown in figure 3.All these different setups have been integrated and were operated using the EUDAQ framework.
In order to efficiently conduct the many test beam campaigns for the development of the ITS with a total of approximately 20 000 runs, a high degree of automation and reliability was required.This has been achieved by implementing the necessary key features into the EUDAQ framework: automatic change of detector configuration at the end of a run; timestamp and data integrity control directly in the EUDAQ Producer; the ability to fully reconfigure the hardware during the run from within the Producer; and control of external equipment such as power supplies, rotary and translation stages as well as the cooling unit.

ATLAS Inner Tracker: pixel detector R&D
The ATLAS pixel detector is the innermost part of the tracker subsystem of the ATLAS experiment [31].After the initial installation the pixel detector consisted of three barrel layers and two end-caps with three disks each.Its modules consist of a planar silicon n + -in-n sensor tile to which -9 - 16 FE-I3 readout chips are bump bonded.The top of the sensor has a flexible PCB attached which hosts an aggregator chip, which multiplexes the individual data streams from the ASICS.The default pixel has a size of 50 µm × 400 µm and the detector has achieved a resolution of 8 µm in the radial direction (r φ) and 75 µm along the z-axis [32].The BAT telescope [33] based on silicon-strip detectors was used during the R&D and the qualification phase [34,35] In 2010 it was decided to amend the detector with an additional layer of pixel detectors, the so-called Insertable B-Layer (IBL) [36] to improve tracking robustness and b-quark tagging.At the beginning of the sensor oriented research effort FE-I3 [37] based modules were used.Those were operated by the laboratory test system TurboDAQ [16], which has been fully integrated into the EUDAQ framework in order to allow efficient testing of the chips using the EUDET-type beam telescopes.As the development of the IBL progressed, both a new readout ASIC, FE-I4 [38], and a new generation of readout systems were introduced and integrated into the EUDAQ framework right from the beginning.In the USBpix Gen2 readout board [39] the incoming data was multiplexed and transmitted by a single Producer, while with the next-generation USBpix Gen3 [40,41] the readout was fully asynchronous using the so-called STcontrol software [42].Through this tool, data were copied from the DAQ board to the computer and sent by the Producer simultaneously.A single Comman-dReceiver is instantiated while each connected board has its own DataSender which are instantiated once the number of boards is known from the configuration.An alternative readout system used for FE-I4 based modules during test beams is the HSIO-2 system which also provides a Producer.
Different pixel sensor technologies were developed and qualified for the ATLAS IBL in multiple test beam campaigns at CERN and DESY: slim-edge 200 µm thin n + -in-n planar and, for the first time-use in high-energy physics, 3D sensors [43].The radiation hardness of these sensors beyond the required 5 × 10 15 n eq /cm 2 was successfully demonstrated.The test beam results obtained with the different readout systems and sensors [44] may be found in the summary paper [45] and the production report [46].
-10 -With the IBL installed and operating, the R&D of ATLAS pixel detector modules continued with a focus on the HL-LHC upgrade.A new all-silicon tracking detector [47] will replace the current inner detector and the pixel part will consist of five layers and corresponding end-caps.Pixel modules with slim-edge and radiation-hard thin n-in-p planar and 3D sensors were prototyped using the FE-I4 readout chip and tested up to fluences on the order of 1 × 10 16 n eq /cm 2 and beyond [48][49][50].Two prototypes of readout ASICs, FE65-P2 and RD53A [51], have been characterised in test beams and for the current stage of testing, the RD53A is used.In order to operate the new generation of readout chips also new readout systems YARR [52,53] and BDAQ53 [54] have been developed.They profited from experience with the previous DAQ generations and both are providing an EUDAQ Producer.
Two additional developments originated from within the ATLAS Pixel Detector R&D: firstly pyBAR software for the readout of FE-I4 ASICs has been developed as an alternative DAQ software using PYTHON.This has been used with several readout boards including USBpix Gen2 and USBpix Gen3 boards.It was initially developed to investigate chip tuning methods [55] and then used for hybrid pixel detector R&D [56] ranging from single-chip readout for sensor characterization [57] to multi-chip readout for operation and testing of larger-scale detectors [58][59][60].The pyBAR software uses PYTHON bindings to integrate into the EUDAQ framework and to provide a dedicated Producer which enables the complete control of pyBAR via the EUDAQ Run Control.
A second development was an additional telescope plane consisting of a FE-I4 based module read out by a USBpix board.This has been added to the EUDET-type beam telescopes to provide a reference detector which allows region-of-interest triggering and to provide track time stamps with a granularity of 25 ns [61].

ATLAS Inner Tracker: strip tracker R&D
For the High-Luminosity LHC the ATLAS experiment [31] will replace the current tracking system with an all silicon detector, the Inner Tracker (ITk), consisting of inner pixel layers and outer strip layers.The ITk Strip detector will be composed of four barrels and six end-cap disks on each side, with a total silicon area of approximately 165 m 2 .The basic building unit is the strip module, which consists of an n + -in-p silicon sensor, one or two hybrids that host the front-end ASICs, and a power board, which provides the power for the read-out chips and monitoring functionalities.The hybrids and the power board are glued directly on top of the silicon sensor [62].
Starting from 2014, several prototype modules have been tested during a series of test beam campaigns at DESY, CERN and SLAC, using EUDET-type beam telescopes [63].In 2017 the DAQ was upgraded to EUDAQ version 2 for subsequent test beams [64].The readout cycle of the DUTs corresponds to the LHC bunch-crossing frequency at 25 ns and is thus much shorter than the rolling shutter readout of the Mimosa26 sensors of EUDET-type beam telescope.In order to select only tracks passing within one readout cycle of the DUT, the integrated FE-I4 plane described in section 4.2 has been used.An entire barrel module was irradiated to the full expected dose at the HL-LHC and was characterised in 2016, which provided valuable information regarding the future performance of the modules at the end-of-lifetime of the HL-LHC.
The ITk Strip DAQ (ITSDAQ) used to operate the detector prototypes runs on an FPGA which performs the trigger-busy-handshake with the EUDET TLU.The so-called ROOT Producer has been developed to provide the interface between the EUDAQ configuration file and ITSDAQ [65].
-11 - Two data streams are sent independently to the EUDAQ Data Collector: one containing the hit information and timestamps from the front-end ASICs, and another containing the timing, trigger and control information from the FPGA.Two converters have been implemented in EUDAQ for the individual streams.It has been observed that the hit information data stream sometimes exhibits de-synchronization problems which can, however, be corrected offline during the analysis of the raw files by comparing the timestamps in the two streams on an event-by-event basis.To mitigate further problems with de-synchronization, in the latest test beam campaigns an automatic check has been implemented and deployed in ITSDAQ which allows to directly identify de-synchronised events and re-synchronise the data online.

Belle II vertex detector: development of DEPFET sensors
The Belle II experiment [66] is a new general purpose detector operated at the new Japanese Super Flavor Factory, SuperKEKB.The new machine, working at the intensity frontier, collides electrons against positrons at intermediate energies of 10.36 GeV but delivering ultra-high luminosities, and is expected to reach 10 36 cm −2 s −1 in the early 2020s.Belle II is searching for physics beyond the standard model in B, D and τ decays through precision measurements and studies of highly suppressed or forbidden processes [67].
The main task of the Belle II vertex detector (VXD) is to provide an accurate measurement of the impact parameters that allow the precise determination of the position of the vertices of the short-lived particles.The VXD consists of two layers of DEPFET pixel detectors (PXD) and four layers of double-sided silicon strip sensors (SVD).The pixel detector is composed of eight million DEPFET pixels with 50 µm in r φ and 55-85 µm in z and operates at a readout frame rate of 50 kHz.The reduced thickness of the sensitive volume of 75 µm and the minimal services and support structures sum up to a total overall material budget of 0.21% X 0 .
The final PXD detector modules are the result of more than 10 years of testing and prototyping.The DEPFET collaboration was the first user to perform a complete integration of the devices -12 -under test into the EUDET-type pixel telescope [68] including the integration into EUDAQ.Early PXD standalone test beams with small scale prototypes focused on measuring the intrinsic spatial resolution and hit efficiency of 50 µm thick sensors and provided data to validate the detector simulation in the Belle II software [69].Several combined VXD and standalone PXD test beam campaigns have been successfully performed [70,71] at the DESY II Test Beam Facility using EUDET-type telescopes as shown in figure 4.
In order to increase the data taking efficiency for prototypes with small sensitive area, the DEPFET collaboration used the region-of-interest (ROI) trigger described in section 4.2 to select only tracks traversing the sensitive area of the device under test.The availability of this FE-I4 reference plane for triggering and timing was valuable also for a test beam with full size (12.5 mm × 44.8 mm) and 75 µm thick DEPFET sensor at DESY in November 2018.The FE-I4 hit data was read out with pyBAR (cf.section 4.2) and sent to the EUDAQ Data Collector in order to identify tracks with a resolution of 25 ns which allowed the measurement of the hit efficiency of the DEPFET devices.
Finally, a main requirement for the Belle II VXD design was to minimise the material budget as much as possible in order to reduce multiple scattering of impinging particles.The magnitude of the effect depends on the local material budget measured in units of the radiation length X 0 .The DEPFET collaboration developed a framework to compute high resolution images of the material budget of planar objects installed in the center of EUDET-type telescopes [72], similar to the material budget imaging described in section 4.10.High resolution images of mechanical prototypes of Belle II PXD and SVD ladders were obtained in a test beam at DESY in 2015 and were used to validate the G 4 model of the Belle II VXD.

CALICE: R&D of electromagnetic & hadronic calorimeter prototypes
The Silicon Tungsten Electromagnetic Calorimeter (SiW-ECAL) and the Analogue Hadronic Calorimeter (AHCAL) are two CALICE prototypes of high granularity calorimeters for future e + e − colliders.Both entered the engineering phase of prototyping where the main technological challenges, such as compactness, reduction of power consumption and embedding of the very-frontend (VFE) in the active layers, are addressed.The SiW-ECAL technological prototype [73] consists of thin layers of silicon sensors (300-650 µm) as active material alternated with tungsten plates as absorber material.The active layers are made of a matrix of 2x2 silicon sensors segmented each in matrices of 8x8 squared pixels with a pitch of 5.5 mm.The VFE consists of 16 SKIROC ASICs [74] that have been designed for the readout of silicon PIN diodes.The AHCAL prototype consists of detector layers that are made from 36 cm × 36 cm units, each equipped with 144 scintillator tiles (30 × 30 × 3 mm 3 ) individually read out by SiPMs.The VFE consists of four SPIROC ASICs [75].
The prototypes use different DAQ systems.While the AHCAL readout is based on a Labview DAQ, integrated into the EUDAQ framework by means of a Producer, the independent Calicoes software [76], based on the Pyrame framework [77], has been developed for control and data acquisition of the SiW-ECAL.Both prototypes are self-triggered and are designed for the ILC [78] timing structure with bunch trains of high activity interspersed with significant periods without beam which are used for readout and lead to dead time.Therefore the synchronization of the active periods of the detectors is very important for test beams.
-13 - The hardware synchronisation was ensured by two clocks -40 MHz and 50 MHz, derived from a single clock generator -and a shared signal to control the acquisition.The EUDAQ framework was used to integrate the two separate DAQ frameworks of the prototypes.EUDAQ producers receive data from each subsystem via a TCP/IP socket connection and send them to the Data Collector to combine them into one event in LCIO format by correlating their timestamps.LCIO collections are used to separate the individual subsystems.
In 2016, test beams of the AHCAL prototype with an externally-triggered EUDET-type beam telescope were conducted at the DESY II Test Beam Facility.Hardware synchronization was provided by an EUDET TLU running in the trigger-handshake mode.The trigger signals were recorded by the AHCAL DAQ hardware to allow correlation with the self-triggered hits from the AHCAL.Events were then combined on the basis of the trigger number and converted to LCIO.The EUDAQ online monitor provided a visual verification of the synchronization via the spatial correlation between the detectors.
EUDAQ was also used for a combined test at the CERN SPS in 2017 of the AHCAL prototype with the CMS HGCAL prototype described in section 4.7.For this, an additional EUDAQ Producer was developed to control and read out Delay Wire Chambers (DWCs) using a CAEN TDC VME module.Similar to the preceding test beams, events were built in EUDAQ using the trigger numbers recorded by all participating devices.
Since the first test beam with EUDAQ, the AHCAL group has adopted EUDAQ as DAQ framework for most test beams including the integration with the AIDA-2020 beam telescopes and the TLU.Multiple tests were performed in different test beam campaigns, which were crucial in the development of EUDAQ2, supported by the AIDA-2020 project work package for common test beam DAQ developments.The CALICE collaboration has decided to encourage all participating groups to use EUDAQ for new common test beams [79].

CLIC vertex & tracking detectors: pixel detector R&D
The CLICdp collaboration studies available silicon pixel detector technologies, evaluates their tracking performance and identifies promising candidates for the construction of CLIC tracking and vertex detectors.Low material budget, small pixel pitch for a good spatial resolution and a few-nanoseconds timing resolution are needed to satisfy the physics requirements and cope with the experimental conditions in the CLIC detector.
In the context of this study, the Timepix readout ASIC [80] was used as a test vehicle to study the tracking characteristics of pixel sensors of various thicknesses and different polarities in order to develop simulation models to estimate the performances of future prototypes with smaller pitch and thinner substrate as required for CLIC.A series of sensors with thickness varying from 50 µm to 500 µm, with both polarities, was produced and a systematic characterization of their tracking properties using the EUDET-type telescope, the EUDAQ software and custom EUDAQ Producers was performed.
For initial studies, the proprietary readout system FITPix [81] was used.The pre-compiled libraries as well as the headers were provided by the Timepix/Medipix collaboration to allow interfacing the system with EUDAQ, but no modifications of firmware or software were possible.With the frame length of the EUDET-type beam telescopes of up to 230.4 µs being much smaller than the configured frame duration of the Timepix, a simple trigger-busy scheme providing only one -14 - track per trigger issued would have severely limited the data rate.To mitigate this, an intermediate hardware interface between the TLU and the FITPix readout hardware, The Man-In-the-Middle TLU Unit (MIM-TLU) show in figure 5, was designed.It consists of a Spartan6 FPGA evaluation board and a custom shield board providing the interface to the RJ45 DUT connection of the TLU and the Trigger-Busy interface of the FITPix.It allows the duty cycle of the Timepix detector to be maximised by accepting a configurable number of triggers from the TLU for each frame of the Timepix.The events were synchronised based on trigger IDs and the duty cycle of the system could be improved from 1.13 % to 40 % via the integration of up to 100 TLU triggers.
The Timepix EUDAQ Producer also provides interfaces to a Keithley High-Voltage power supply through a GPIB-USB interface and to a rotation stage via RS232 in order to perform automated threshold, bias and incident angle scans.The scan parameters were provided to the producer through the standard EUDAQ configuration files and the information on the system configuration was encoded in the header of the EUDAQ data files for further reference.The Magic Log Book tool was used to extract the conditions for each run and automatically populate the test beam log with the appropriate information.Finally, a decoder for online monitoring and integration to the EUT reconstruction framework was developed in order to verify data quality during test beam and to perform reconstruction of the events for further analysis.More than nine weeks of continuous test beam was performed with this setup and the substantial amount of data acquired lead to multiple publications and PhD theses [82][83][84][85][86].
Following the successful experience with the Timepix integration, a Timepix3 producer was created and the FITPix system was replaced by the SPIDR readout [87].The Timepix3 uses a data-driven acquisition model with no dead time for the readout and no additional hardware was required for operation with the EUDET-type telescope.Similarly, a Producer for the CLICPix ASIC [88] was produced, based on the µASIC system.Results of the Timepix3 and CLICPix characterisation can be found elsewhere [89].

CMS High Granularity Calorimeter for HL-LHC
For High-Luminosity LHC the CMS experiment will replace its existing end-cap (1.5<|η|<3) calorimeters with a sampling calorimeter based on a mixture of silicon sensors in the highest radiation regions, and scintillating tiles with on-tile SiPM readout.The resulting High Granularity Calorimeter (HGCAL) will have unprecedented readout and trigger granularity for particle showers, -15 -facilitating particle-flow analyses to ensure good energy resolution and particle identification in the very high pileup and radiation environment expected [90].The HGCAL will be installed during Long Shutdown 3 of the LHC, foreseen around 2024-2026.A series of beam-tests was planned in 2015, in order to validate the feasibility of the technically-challenging HGCAL design and to compare its simulated performance with that found in reality.
For the first small-scale tests of prototype hexagonal silicon modules at FNAL and CERN in 2016 [91] a proprietary DAQ system [92] was sufficient.Larger-scale tests were planned for 2017/18 using new DAQ components.In order to allow synchronous data taking with other hardware, EUDAQ was selected as central DAQ system due to its configurability, scalability, integrated Data Quality Monitoring (DQM), ease of use and relatively simple integration with different hardware.Initially three dedicated EUDAQ Producers were implemented: for the so-called RDOUT boards using the IPbus protocol [93], for CAEN v1290 TDCs, and for CAEN v1742 digitisers.The latter were incorporated for the readout of various beam-characterizing detectors at CERN such as Delay Wire Chambers (DWCs) [94], threshold Cerenkov counters and timing devices.
Following the recommended procedure, DataConverterPlugins for the online reconstruction and analysis of the HGCAL data were developed.The converted data were then visualised by suitably modifying the EUDAQ DQM to correctly display the hexagonal pixels of the CMS HGCAL modules.Independently-developed systems using EUDAQ for the readout, such as the CALICE AHCAL presented in section 4.5, could be integrated into the tests with little modifications to the triggering logic at the hardware level.It is noteworthy that for the 2018 HGCAL test at DESY, the integration of the EUDET-type telescopes and X-Y stage was straightforward and allowed exploiting the pre-installed telescope Producer, Slow Producer and the TLU provided at the DESY II Test Beam Facility.
Using EUDAQ as central DAQ framework, systems ranging from a single 128-channel hexagonal silicon module, to 94 modules plus the 39-layer 2018 CALICE AHCAL prototype, were successfully tested in beams at DESY and CERN in 2017 and 2018 for a total of more than two months.The final test at CERN in October 2018 was performed with a prototype comprising a total of 34 000 channels.The EUDAQ-based DAQ was reliable and sufficiently simple to be operated by 40 trained shifters in total.Data from up to four EUDAQ producers, the three mentioned previously plus one for the AHCAL, were acquired at a rate of around 50 Hz, limited by the DAQ hardware.In total, more than 6 million pion, electron and muon events were recorded for analysis.This in-built DQM proved very useful for ensuring good data quality, as can be seen in figure 6.Data are currently being analyzed, but initial indications are very positive.

CMS pixel detector: test beams for the phase I upgrade
In the year-end technical stop 2016/2017, the CMS experiment has replaced its pixel detector with a new detector system in order to withstand the higher instantaneous luminosity of the LHC of L = 2 × 10 34 cm −2 s −1 expected for the following years of operation [95].This so-called Phase-I Upgrade comprised, among other changes and improvements, of a new front-end ASIC, also referred to as readout chip (ROC).This chip is an evolution of the ROC used in the first pixel detector for CMS, implementing several enhancements to allow for higher particle rates and occupancy.The chip is fabricated in a radiation-hard 250 nm process and features a pixel pitch of 100 µm × 150 µm and a matrix of 80 × 52 pixels.
-16 -  Many test beam campaigns have been conducted in order to test new ROC versions, to verify design changes and to ensure good performance of the final detector modules [96,97].These measurements have been conducted at the DESY II Test Beam Facility using positrons from the DESY II synchrotron.Assemblies with the different ROC versions have been operated as DUTs and were placed between the two arms of an EUDET-type pixel beam telescope as shown in figure 7.In addition to the DUT in the center of the beam telescope, a second ROC was placed downstream at the end of the beam telescope as a timing reference.This is necessary for efficiency measurements due to the rolling-shutter readout of the telescope detectors with an integration time of O(100 µs) and the resulting track multiplicity in the beam telescope.A dedicated readout system has been designed and built for the CMS pixel detector ROC family, consisting of a custom-designed FPGA-based readout board and the software library pxarCore [98].The system is capable of operating single ROC assemblies as well as full detector modules and has been used for test beam measurements and for the qualification of all final detector modules produced.
-17 - The software library strictly separates user inputs from hardware calls by means of a hardware abstraction layer (HAL).This concept has allowed a stable application programming interface (API) to be provided to various users and developers of user interfaces while major changes could be implemented on firmware and HAL-level without entailing additional changes to user software or breaking compatibility with older versions.Using this interface, an EUDAQ Producer (CMSPixel) was written which parses the configuration parameters obtained from the EUDAQ Run Control and calls the appropriate API functions of the pxarCore library.Providing a Data ConverterPlugin for EUDAQ ensured full integration of the detector into the online monitoring system and allowed supervision of basic detector parameters as well as correlation with telescope planes during data taking.
The test beam activities and results have been summarised in a publication [97], and the detector was successfully built, commissioned and is in operation since the LHC year-end technical stop 2016/2017.The test beam setup and its EUDAQ integration has also been used for measurements studying the performance of the ROC under the influence of radiation-induced damage [99].
In addition to the comprehensive test beam campaigns for the characterization of the new readout chip, measurements with full CMS Phase I pixel detector modules have been performed [100].Here, a telescope consisting of four detector modules with 16 ROCs each has been operated using the same readout electronics.In order to correlate the data from the different planes and to orchestrate the start and stop of a run, the EUDAQ Run Control was used together with four individual CMSPixel producers, one for each telescope plane.Owing to the flexibility of the EUDAQ framework and the underlying DAQ library, this did not require any changes to the code but provided an out-of-the-box experience for data acquisition of the new telescope, including online monitoring capabilities.

CMS outer tracker: module qualification in test beams for phase 2
For the HL-LHC, the CMS experiment will substantially upgrade its tracking detector [101].The all-new CMS Phase-2 tracker will consist of an Inner Tracker (IT) based on silicon pixel modules and an Outer Tracker (OT) made from silicon modules with strip and macro-pixel sensors.In the Outer Tracker, so-called p T modules will be utilised, which will provide input from the OT to the CMS L1 trigger.The p T modules are composed of two closely-spaced silicon sensors, which are read out by a common front-end ASIC, correlating the signals in the two sensors.With the 3.8 T field of the CMS magnet, tracks from charged particles are bent, with the helix radius depending on the p T of the particle, as shown in figure 8. Hit pairs corresponding to signals compatible with particles above the chosen p T threshold are called stubs and are sent to the L1.
Two different module types are foreseen for the OT: 2S modules comprising two strip sensors, and PS modules, where a strip sensor and a macro-pixel sensor are used.The latter are deployed at radii from 200 − 600 mm, the former at radii larger than 600 mm.
Four successful test beam campaigns investigating Outer Tracker prototype modules have been performed at DESY and CERN in 2017 and 2018 with the EUDET-type beam telescopes.The FPGA running the CMS OT DAQ performs the full trigger-busy-handshake protocol with the EUDET TLU.A custom EUDAQ Producer has been developed and interfaces the CMS OT DAQ with the EUDAQ Run Control.Whilst the initial configuration of the CMS modules is performed separately, the Producer sends the hit data of both prototype sensors to the Data Collector.Furthermore, parameters from the front-end ASICs such as TDC or stub information are added to the individual EUDAQ events for the track reconstruction and subsequent analysis.

Material budget imaging: using scattering angles to gauge material
The material budget is the ratio of the thickness of a sample and its radiation length X 0 .One of the main concerns when designing tracking detectors for particle detectors is to minimise this value -19 -in order to reduce the effect of multiple scattering which degrades the achievable track resolution of the detector.Combining the EUDET-type telescopes as high-precision tracking devices and the moderate test beam momenta of the DESY II Test Beam Facility, a high spatial resolution for material budget imaging measuring the scattering angle of each particle can be achieved.This methodology has been used by different groups and experiments to gauge the material budget of detector prototypes or other objects, for example [72,102,103].
Using this method, structures of devices can be resolved in a two-dimensional image covering the Mimosa26 active area or even in three-dimensional tomographic images by rotating the sample under test [99,104].In this case a large amount of recorded particle tracks is needed to reach a reasonable resolution and contrast in the images.With the particle fluxes in the order of 5 kHz/m 2 achievable at the DESY II Test Beam Facility, it is required to employ automatic data taking over longer time periods.EUDAQ and the DAQ of the EUDET-type beam telescopes have shown to perform stably when conducting measurement campaigns overnight using the automatic-next-run option.
The x and y linear stages can be used in order to explore samples larger than the active area of the Mimosa26 sensors.The rotational stage offers the possibility to perform tomographic studies.For this, the control over the different motor stages was implemented in EUDAQ as a Slow Producer, which allows one-dimensional scans to be performed by defining the scan range in the configuration file.For performing arbitrary two-dimensional scans, multiple configuration files for the respective coordinates can be created.After the completion of a given run, corresponding to one configuration file, the subsequent file is automatically loaded by the Run Control.This feature is extensively used for the three-dimensional tomographic imaging technique.
Owing to this fully automated data taking as well as the possibility to record even larger areas than the size of the Mimosa26 active area by stitching images, this technique is a valuable tool to gain insights into the material budget of calibration material as well as complex structures as demonstrated in figure 9.

Mu3e: development of HV-MAPS sensors
The Mu3e experiment will search for the charged lepton flavor violating decay µ + → e + e − e + .The low momenta of the decay particles requires an ultra thin pixel sensor with high rate capabilities.Additionally, the continuously decaying muons do not allow for a hardware trigger, demanding a zero suppressed streaming readout of the pixel sensors.High-voltage monolithic active pixel sensors (HV-MAPS) [105] are chosen for the Mu3e tracker, as they offer a high integration level combined with the option of thinning the sensor down to a total thickness of only 50 µm.
Four HV-MAPS prototype generations have been studied utilizing the EUDET-type telescopes during 14 test beam campaigns at the DESY II Test Beam Facility.The triggerless fast sensor readout poses a challenge for the integration into the triggered EUDAQ framework.A hit is registered and read out in less than 200 ns, compared to the rolling shutter revolution time of up to 230.4 µs of the Mimosa26 sensors.During a single Mimosa26 readout cycle, the timestamps on the MuPix laps 15 times.Additionally, the prototypes are significantly smaller than the Mimosa26 sensors, leading to events without a hit in the MuPix.To avoid several triggers without hit-data, empty blocks are sent to the Data Collector to match the trigger frequency.The full trigger-handshake with the TLU is realised on an FPGA.A custom Producer, serving as interface between the MuPix DAQ and the EUDAQ Run Control, has been developed.The flow chart of the interaction between the two systems is depicted in figure 10.The EUDAQ Producer steers the complete MuPix readout and configuration procedure.Error messages, status information and the start/stop/configure signals are forwarded to the MuPix DAQ.The Producer buffers the entire data stream of the MuPix until one TLU trigger is registered, transforms the data into an EUDAQ interpretable format and sends it to the Data Collector.

Conclusion & outlook
EUDAQ has been developed as a common data acquisition software for many different use cases and fulfills several common requirements: • Flexible and light-weight: EUDAQ is platform independent and can be operated on Linux, Windows or macOS, and comes with as few external dependencies as possible.
• Easy-to use: EUDAQ incorporates well-defined interfaces which allow data sending and control of the user's hardware and conversion of the data for monitoring or offline analysis.
• Robust data taking: the data taking strategy is to store detector-native raw binary data without additional processing by the DAQ system.This allows to retain all information initially recorded and reduces the risk of data loss through errors in the processing code.The data handling is performed by one central instance and data from different sub-detectors are synchronised on an event-by-event level, ensured by the global busy-trigger communication provided by the EUDET TLU.
Thanks to many user groups continuing to share their code integrating their own devices, EUDAQ now ships with support for many different devices.This both serves as a reference for new -21 -users and allows developers to ensure compatibility when modifying core parts of the framework.Over more than a decade, EUDAQ has thus been maintained for production and, at the same time, been constantly developed and improved.The diversity of the contributing user groups is a testament to the collaborative spirit of the test beam community and the central role that the EUDET-type beam telescopes, and in turn EUDAQ, plays.As part of the EUDET-type beam telescopes, EUDAQ was assessed by the community at the "Beam Telescope and Test Beam" workshop in 2018 [2].From the discussion and survey among the participants, it was concluded that the EUDAQ architecture and development road-map fulfills the test beam user's needs for the foreseeable future.
During the implementation phase of the AIDA framework [107], EUDAQ became a candidate for a common test beam DAQ, extending beyond its initial goal of serving as system for telescopebased test beams only.In a comparison with other DAQ frameworks such as XDAQ [108], EUDAQ was judged as "greatly simplified, and relies on as few external libraries as possible.EUDAQ is designed to be portable."Furthermore, recommendation for improvements were collected from the telescope community.These included suggestions such as parallel data streams and the possibility to acquire individual events for each particle or trigger [109].
These requirements led to the development of an improved version of EUDAQ and the new version -called EUDAQ2 -was selected as the common software framework under the work package WP5 within the AIDA-2020 framework [110].EUDAQ2 breaks with several concepts such as the event-by-event synchronization of devices and is therefore not compatible with Producers written for EUDAQ.It comes with the possibility to run multiple Data Collector instances for decentralised data taking and is therefore more scalable than EUDAQ.Together with the new AIDA TLU [111] a higher trigger rate can be achieved and events can be built either online or offline by synchronizing the individual data streams using their trigger IDs or a common clock.The framework was released in 2017 [64] and has already been applied by the ATLAS ITk Strips test beam group for the first time.Thank to these enhancements EUDAQ has become even more flexible and is ready for testing the next generation of detectors for future experiments.

Figure 1 .
Figure 1.Sketch of the EUDAQ architecture depicting the core components and the data flow.The individual communication channels are indicated by arrows: the control channel (red), the data channel (blue) and the log channel (grey).Figure from [10].

Figure 2 .
Figure2.Three graphical user interfaces from EUDAQ after a standard start-up for running the EUDET-type telescopes with six EUDAQ components.In the upper left window, the Run Control shows the global status, the control buttons, detailed status indicators, and a list of all connections.In this example, the Log Collector, Data Collector and Online Monitor as well as Producers for the Mimosa26 sensors and the EUDET TLU are connected.In the upper right window, the GUI of the Online Monitor will show data quality plots and graphs after the data-taking is started.In the bottom window, the GUI of the Log Collector shows messages of the log channel on the selected verbosity level.

Figure 3 .
Figure 3. Picture of the self-contained ALPIDE telescope setup, operated and read out using the EUDAQ framework.

Figure 4 .
Figure 4. Test beam preparation of the Belle II Vertex Detector (left) for a full functional test inside a 1 T solenoid (right).

Figure 6 .
Figure 6.Screenshot of the EUDAQ DQM, here showing the pixel occupancy in 28 single-module planes tested in 2018, due to incident 100 GeV electrons, showing good centering of the beam and the development of the electromagnetic shower.Note that the orientation of the planes in the DQM do not always represent reality.

Figure 7 .
Figure 7.The CMS pixel detector ROC mounted between the two arms of a EUDET-type beam telescope.From [10].

Figure 8 .
Figure 8. Example of the on-module p T discrimination.The left track has a higher transverse momentum, thus registering a hit on the upper sensor within the programmable search window.The low-momentum right track fails this cut.

Figure 9 .
Figure 9. Material budget imaging: (a) Calibration scan using an aluminium wedge with values ranging from 6.7 % (6 mm aluminium) to 33.7 % (30 mm aluminium) including a statistical uncertainty of approximately 0.4 %.The alternating gray and white regions indicate different measurement positions on the wedge.The measurements are based on a total sample of 470 million tracks.(b) Two-dimensional scan of a LEMO connector resolving the inner substructure.

Figure 10 .
Figure 10.Block diagram of the EUDAQ integrated MuPix DAQ.The EUDAQ Producer serves as an interface between the EUDAQ and the MuPix DAQ.The blue rectangles are EUDAQ components.The green ones are threads within the MuPix readout and the magenta ones are memories.The black arrows indicate data flows, the red ones steering and the blue ones status information.Figure from [106].

Table 1 .
The individual commands defined for distribution via the EUDAQ command channel.