ROCK-IT Bluesky Workshop

5 Nov 2025, 08:30 → 7 Nov 2025, 23:00 Europe/Berlin

CFEL (Building 99) (Deutsches Elektronen-Synchrotron DESY)

Devin Burke (FS-EC (Experimente Control))

The ROCK-IT project (https://www.rock-it-project.de/) is holding a three day Bluesky Workshop at DESY for purposes of training and knowledge sharing within the controls community this November. We are extending an open invitation to the entirety of the scientific controls community regardless of preferred control system or experience with Bluesky.

 

The ROCK-IT project is a Helmholtz funded project that aims to develop all the necessary tools for automation and remote access of in-situ and operando experiments while producing FAIR data. The project has identified Bluesky and its community tools as an excellent framework for accomplishing its goals. We hope that this workshop will create opportunities to share community knowledge and collaborate on shared solutions to solve community problems.

 

Planned sessions include:

- Bridging Bluesky tools into the Bluesky ecosystem (and vice-versa)

- Bluesky and Ophyd(-Async) tutorial sessions

- Tool specific sessions (eg. Bluesky Queueserver)

- Poster sessions

- Presentations from attendees and ROCK-IT representatives

- Breakout sessions to discuss new ideas and points of connection

Wednesday 5 November

08:30 → 09:00 Welcome

welcome.odp

09:00 → 10:30 Community Talks: Session 1

Convener: Dr Alexander Schoekel (DESY)

09:00 Scalable Bluesky Deployment: Orchestrating Experiments at HZB

The Helmholtz-Zentrum Berlin (HZB) has actively implemented and deployed the Bluesky framework as part of its modernization effort for the experimental control system at the BESSY II photon facility. The Bluesky environment at HZB is designed to orchestrate data acquisition and experiment control, leveraging the Ophyd library for hardware abstraction and EPICS for the control layer. This environment supports scalable and robust real-time device control across various beamlines and instruments at BESSY II.

The deployment includes a range of Bluesky ecosystem elements: clients such as IPython shell, Graphical User Interface or Web Interface, ZeroMQ (ØMQ) for rebroadcasting documents, Tiled as a data access service, and Bluesky Queueserver. This contribution will focus on the architecture of the services that are deployed at the BESSY II beamlines.

Speaker: Marcel Bajdel (Helmholtz Zentrum Berlin)

Scalable Bluesky Deployment: Orchestrating Experiments at HZB%0A.pdf

09:20 P65 - The ROCK-IT Operando Catalysis Demonstrator Beamline

We will present the current status of the Bluesky based control system developed for operando catalysis x-ray fluorescence experiments at Petra-III beamline P65. We will include presentation of results and discussion on progress on aspects of Tango device control and orchestration via Bluesky and Ophyd-Async, automation via the Bluesky Queueserver, and browser based remote control/access via Daiquiri.

Speaker: Devin Burke (FS-EC (Experimente Control))

p65_workshop.odp

09:40 Integrating NOMAD Lab into a Bluesky Beamline

It is an ongoing challenge to adhere to FAIR data principles in experiments at the HZB EMIL endstations. Data reusability and accessibility are particularly hard to achieve with tiled databases on a segmented network architecture.

To remedy this, we are in the early stages of using a NOMAD oasis. NOMAD is a free and open source database packaged with a dynamic web client. It supports indexing with custom schema and can host analysis software ran from jupyter notebooks. The API allows bluesky output to be uploaded directly via callbacks or a tiled subscription and metadata can be pulled out of the documents or supplied from a sample questionnaire completed by the user at the start of the experiment.

In this talk I will share the current state of this project at EMIL, and discuss the potential improvements to user experience that NOMAD can deliver on our bluesky endstations.

Speaker: Eva Lott (HZB)

nomad-presentation-2.pdf

10:00 BEC – A Beamline and Experiment Control System for the SLS

The Swiss Light Source (SLS) has successfully completed its major upgrade under the SLS 2.0 program, with beamlines now back in user operation. Alongside this hardware renewal, the new Beamline and Experiment Control system (BEC) has been deployed across the facility, providing a unified solution for beamline control. BEC addresses long-standing challenges of fragmented interfaces as well as limited collaboration and re-use, offering a flexible client–server architecture based on Redis and modular services.
The BEC ecosystem encompasses several complementary components. BEC Widgets, a graphical interface framework built on PySide6/Qt6, is becoming the main entry point for beamline scientists, providing customizable and reusable tools for graphical experiment control. Deployment across a diverse set of beamlines is managed using Ansible, with beamline-specific plugins ensuring flexibility and maintainability. Looking ahead, BEC Atlas is under development to provide centralized access to the metadata database and access-control management. It will also serve as the entry point for remote operation.
This talk will present the BEC architecture, its ecosystem of components, and the strategy that enabled a smooth rollout and successful operation of BEC during the SLS 2.0 comeback, along with an outlook on upcoming developments.

Speaker: Klaus Wakonig (Paul Scherrer Institute, Switzerland)

BEC_ROCK-IT_export.pptx

10:30 → 11:00 Poster Session / Coffee Break

11:00 → 12:30 Community Talks: Session 2

Convener: Klaus Wakonig (Paul Scherrer Institute, Switzerland)

11:00 The Python Accelerator Middle Layer Project

Many synchrotron light sources use the software Matlab Middle Layer (MML) for commissioning, operation and accelerator tuning. MML was initiated in the 1990s and has since then been widely adopted because of key features like control system agnostic hardware abstraction, independence of naming conventions and the possibility to group devices together. MML allows running on both the live machine and a simulator, making it feasible to develop and test new procedures before machine shifts. MML also both supports simple scripting for quick viability tests of new methods and running complex applications for standard procedures with demands on reliability.

However, over time MML has become outdated and fragmented, making it difficult to extend and maintain. In addition, Matlab is a propriety software with decreasing user base among accelerator physicists. This has highlighted the need for a new, modern open-source solution which meets the requirements of the 4th and future generations of light sources as well as other type of accelerators. A world-wide collaboration to develop a Python Accelerator Middle Layer (pyAML) has therefore been initiated. The project is now in a prototype phase that will be finished by the end of 2025.

Many requirements for pyAML are similar to MML, but it should also provide integration with existing Python packages (allowing use of high-performance computing, optimisation algorithms and machine learning), a digital twin and better data management. Essential for the success of the software is that it needs to support a wide experience range of users and that it should facilitate the research process going from an idea quickly tested during a machine shift to a robust application run during user operation which can be shared with other facilities.

Speaker: Teresia Olsson (Helmholtz-Zentrum Berlin)

python-accelerator-middle-layer.pdf

11:20 Daiquiri: a general overview, extensibility, and current integrations

Daiquiri[1] is a web based User Interface (UI) framework for control system monitoring and data acquisition. It provides simple, intuitive, and responsive interfaces to control and monitor hardware, launch acquisition sequences, and manage associated metadata. Daiquiri concerns itself only with the UI layer, it does not provide a scan engine or controls system but can be easily integrated with existing systems. Daiquiri is implemented with a traditional client / server methodology with the intention of producing a generic extensible framework for acquisition. The server is implemented in Python 3 and provides a REST API and SocketIO service for real-time feedback. The client is implemented in javascript es6 making use of the popular front end framework React along with Redux.

Daiquiri is increasingly being used outside of the ESRF. Current integrations and investigations include SOLEIL and the RockIT project at DESY. DESY have taken the approach of integrating blissdata[2] with their controls systems (bluesky and sardana), allowing access to scan data in real time. In addition to this a REST API for BLISS[3] has recently been developed. Migrating daiquiri to use this API has essentially involved integrating a new controls system, allowing the relevant interfaces to be refined and documented. New interfaces have also been added for authentication, and a standalone project has been released allowing the demonstration of daiquiri completely separately from BLISS.

Further information can be found at https://ui.gitlab-pages.esrf.fr/daiquiri-landing

[1] Daiquiri, Fisher et al., J. Synchrotron Rad. (2021). 28, 1996-2002
[2] blissdata: https://gitlab.esrf.fr/bliss/blissdata
[3] BLISS REST API https://bliss.gitlab-pages.esrf.fr/bliss/master/blissapi.html

Speaker: Stuart Fisher

daiquiri: a general overview, extensibility, and current integrations

11:40 Tamarin UI: Building a Reusable Web Frontend for Bluesky Measurements at HZDR

Controlling and monitoring experiments in the Bluesky ecosystem can be challenging for non‑expert users. Tamarin UI is a lightweight web application that provides an accessible, role‑aware frontend for executing Bluesky plans via the Bluesky Queue Server. It visualizes live readbacks from Ophyd devices in real time and uses Tiled for browsing and retrieving historical runs. Designed as a reusable application, Tamarin UI can be deployed for different projects at HZDR without rewriting core logic.

This presentation provides an overview of Tamarin UI's key features, demonstrates how it integrates with the existing Bluesky ecosystem (including the Bluesky Queue Server and Tiled), and highlights additional services designed to enhance the user experience for automated measurements.

Speaker: Mr Jonas Gorgis (HZDR)

Tamarin_UI-Jonas_Gorgis.pdf

12:00 Expanding the QueueServer use case to further experiment

While the Bluesky QueueServer was originally developed as an alternative
method for executing Bluesky plans, we have explored its usability with
other experiment orchestration engines. At its core, the QueueServer enables
the execution of a dedicated server-side Python process—by default managing
the Bluesky Run Engine—and facilitates communication with this process via
ZeroMQ and an HTTP REST API.
Here, we evaluate the possibility of not only connecting to the Bluesky Run
Engine through the QueueServer, but also accessing Sardana (the experiment
orchestration system used at PETRA III) via the QueueServer and its API.
Looking ahead, we consider this approach a potential option for unified,
API-based access to experiment controls. This could be particularly
beneficial for cross-facility GUI-development and users conducting
experiments across multiple facilities and for (ML-based) closed-loop
feedback applications.

Speaker: Linus Pithan (FS-EC (Experimente Control))

20251105_queue-server-pithan.pptx

12:30 → 13:30 Catered Lunch

13:30 → 15:00 Tutorials: Bluesky and Ophyd(-Async)

Online tutorials on using Bluesky and Ophyd(-Async). You only require a laptop with a modern web browser.

Convener: Devin Burke (FS-EC (Experimente Control))

13:30 → 15:00 Working Groups: Containers and Deployment

We will decide on and break into working groups to collaborate on Bluesky and related tools/processes.

Convener: Marcel Bajdel (Helmholtz Zentrum Berlin)

Deployment and containerization working group.md

15:00 → 15:30 Poster Session / Coffee Break

15:30 → 17:00 LEAPS Experiment control SIG strategy discussion

Convener: Linus Pithan (FS-EC (Experimente Control))

15:30 → 17:00 Working Groups: Common needs in novel projects

We will decide on and break into working groups to collaborate on Bluesky and related tools/processes.

Deployment and containerization working group.md

Thursday 6 November

09:00 → 10:30 Tutorials: Queueserver and serialization

Online tutorials on using Bluesky and Ophyd(-Async). You only require a laptop with a modern web browser.

Convener: Devin Burke (FS-EC (Experimente Control))

09:00 → 10:30 Working Groups: Queueserver and APIs

We will decide on and break into working groups to collaborate on Bluesky and related tools/processes.

Convener: Linus Pithan (FS-EC (Experimente Control))

Deployment and containerization working group.md

10:30 → 11:00 Poster Session / Coffee Break: Post Session

11:00 → 12:30 Working Groups: Queueserver and APIs

We will decide on and break into working groups to collaborate on Bluesky and related tools/processes.

Deployment and containerization working group.md

12:30 → 13:30 Lunch

13:30 → 14:30 Community Talks: Session 3

Convener: Linus Pithan (FS-EC (Experimente Control))

13:30 Toward a Unified Data Acquisition Framework for Beamline Instrumentation Using Bluesky and NATS Jetstream

We present the current status of the data acquisition (DAQ) project at the Canadian Light Source, designed to provide a generic, scalable solution for beamline instrumentation, minimizing the need for bespoke implementations. Built on the bluesky ecosystem, the framework orchestrates data collection from EPICS-controlled devices and PandABox hardware, streaming structured documents through a persistent NATS Jetstream message queue with beamline-specific subjects.

Data is ingested via Tiled into a PostgreSQL backend, enabling efficient indexing, querying, and future extensibility. The system leverages pixi for reproducible beamline-specific environments and CI/CD workflows, ensuring maintainability and deployment consistency.

A key integration challenge has been the reliable execution of Python-based DAQ processes within a systemd-managed environment, which we address through operating system package built in CI/CD-pipelines. While the backend is production-ready, frontend development is ongoing, with a full rollout planned for early 2026.

This talk will outline the architecture, integration lessons, and future roadmap, including live visualization, metadata enrichment, and broader device compatibility.

Speaker: Dr Niko Kivel (Canadian Light Source Inc.)

ROCK-IT_Nov_2025_kivel.pdf

ROCK-IT_Nov_2025_kivel.pptx

13:50 Running an ultra-high throughput MX beamline entirely through Bluesky

Diamond Light Source is undergoing a major facility upgrade. One of the flagship beamlines included in this upgrade, called K04, has the ambitious target of collecting data from 10,000 samples per day and will be ran through an entirely automated unattended data collection (UDC) process. Over the last 4 years, the MX data acquisition software team have been developing the Bluesky-based system, called Hyperion, to orchestrate this UDC loop, and it is currently deployed on an existing MX beamline at DLS. Running the beamline using Hyperion already reduces the time taken per sample by approximately a factor of eight relative to the predecessor acquisition software. This talk will present a brief technical overview of the UDC loop as well as the developmental processes being used, before reflecting on the effectiveness of Bluesky for this project.

Speaker: Ollie Silvester (Diamond Light Source)

ollie_silvester.pptx

14:30 → 15:00 Poster Session / Coffee Break

15:00 → 16:30 Community Talks: Session 4

Convener: Devin Burke (FS-EC (Experimente Control))

15:00 Streaming Data Anywhere Securely with Tiled Websockets

New work on Tiled provides streaming access to data. Existing tools, including EPICS and various streaming detector interfaces, satisfy this use case for raw data in an "edge computing" scenario where the consumer is on the same local network as the producer. But to extend this to remote networks—or to stream processed and analyzed data—has typically required building specialized software infrastructure and obtaining special cybersecurity accommodations (exceptions). Tiled streams scientific data structures through the industry-standard protocol Websockets that can flow securely through firewalls and proxies. This was used in July for a user experiment at NSLS-II (SMI 12-ID) in which data was streamed into an ML model running on a compute cluster located on the opposite coast, at the Advanced Light Source. This model provided a live view of features during a time resolved scattering experiment.Accessible Python interfaces make this a promising tool for scientists to build streaming pipelines of processed and analyzed data that can flow securely anywhere there is an Internet connection.

Speaker: Dan Allan (Brookhaven National Laboratory)

Tiled Websockets ROCKIT.pdf

15:15 Exploring Bluesky Data with PyMca and Tiled

With growing adoption of Bluesky at scientific user facilities for collecting and storing experiment data, graphical data explorers can now leverage the rich metadata and structure provided by Bluesky. At NSLS-II many beamlines use PyMca, an open-source graphical desktop application (“app”) for viewing and analyzing datasets during beamtimes. The datasets are generally loaded from HDF5 files and then processed by hand or in batches with specialized plugins. Missing from this workflow has been a mechanism to retrieve data directly from Bluesky’s Tiled data service.

The Data Analysis and Workflow Integration group at NSLS-II has streamlined this process by embedding a Tiled data client into the PyMca Qt app as a recognized data source. When the app is launched, it connects to a Tiled server and presents the user with the available catalogs of Bluesky runs. Search and filtering of metadata from the Bluesky runs facilitate locating the datasets of interest. Tabular data columns can be selected and hooked into the existing PyMca framework for plotting and inspecting multiple one-dimensional data traces. All functionality is accompanied by unit tests of the logic and graphical elements to ensure reliability.

Complex Scattering beamlines at NSLS-II are integrating PyMca with Tiled into user workflows. The app is deployed on virtual desktop infrastructure so that any facility user or staff can remotely process their data. Environment variables and Tiled “profiles” simplify customization of deployments for each beamline or remote user. Live-streaming of data from Tiled into PyMca plots will provide decision-making feedback during beamtimes. These strategic developments deliver data remotely and securely into analysis apps that are already familiar to facility users.

Speaker: Padraic Shafer (National Synchrotron Light Source II, Brookhaven National Laboratory)

ROCK-IT PyMca-Tiled (Shafer) 2025-11-06.pptx

15:30 NOMAD CAMELS: Configurable Application for Measurements, Experiments and Laboratory Systems

NOMAD CAMELS is an open-source configurable measurement software. It is designed for controlling experiments while recording fully self-describing measurement data including rich metadata. It originates in the field of experimental physics, where a wide variety of measurement instruments are used in frequently changing home-built experimental setups and measurement protocols. NOMAD CAMELS provides an intuitive easy-to-use graphical user interface (GUI), allowing users to configure experiments without requiring programming skills or a deep understanding of instrument communication.

From a technical perspective, CAMELS translates user-defined measurement protocols into standalone executable Python code, providing full transparency of the actual measurement sequences. This Python code utilizes bluesky plans and ophyd devices to perform the actual measurement routine and instrument communication. Inflow of metadata from Electronic Lab Notebooks (ELNs) and upload of data to such notebooks is well supported, enabling a seamless research data workflow. When shared with others, data produced with CAMELS allows for a full understanding and reproducibility of the measurement and the resulting data, in accordance with the FAIR principles.

We will present NOMAD CAMELS, its concepts and discuss the implementation of the bluesky framework. We will demonstrate the benefit of an automated FAIR research data workflow from the source, the experiment, to the highly structured data repository NOMAD Oasis.

Speaker: Alexander Fuchs (Consortium FAIRmat, Humboldt-Universität zu Berlin)

CAMELS_ROCK-IT_Hamburg_2025.pptx

15:45 Facilitating user code inclusion in Beamline Experiment Control software at PSI

Beamline control system software is complex: it provides a common interface to a diverse range of hardware components, data services, and output file formats, any of which may not have been designed for ease of software integration. It should provide operation levels suitable for both new and advanced users. The Beamline Experiment Control (BEC) software for SLS 2.0 at PSI is intended to allow beamline scientists to develop their own experimental routines, abstracting some of this complexity. This presentation will focus on two of the tools developed for BEC, how they address some of the same challenges addressed in the Bluesky ecosystem, and highlight some of their parallels and differences.

First, a plugin system, mainly intended for beamline staff: BEC plugins can be new ophyd devices, scan routines, data output formats, and GUI widgets. They can be managed through a bespoke plugin-creation application which provides the user with the required boilerplate. It is based on highly configurable code templating, allowing us to update the template without exposing users to the peculiarities of the underlying libraries or the difficulties of resolving merge conflicts.

Second, a system to run arbitrary user-supplied scripts, designed to limit the security issues this would normally entail. Scripts are executed in a container permissioned only to access the central message broker. The execution environment closely mimics the beamline iPython terminal environment, so that a procedure can be interactively developed, then submitted to the server.

Speaker: David Perl (Paul Scherrer Institut)

david_perl_rockit_workshop_presentation.odp

david_perl_rockit_workshop_presentation.pdf

16:30 → 17:00 Poster Session / Coffee Break

17:00 → 18:00 Community Talks: Session 5

Convener: Devin Burke (FS-EC (Experimente Control))

17:00 Blop: beamline optimization package

Blop is a BeamLine OPtimization package built on top of BoTorch, a Bayesian Optimization framework, with Bluesky in mind [1]. It proved to be very useful to align and tune synchrotron and electron beamlines at the NSLS-II and ATF user facilities of the Brookhaven National Laboratory, ALS of the Lawrence Berkeley National Laboratory, and LCLS of the SLAC National Accelerator Laboratory. The tool is particularly useful for the beamlines which already have the Bluesky/Ophyd setup – the integration of Blop there is very straightforward.

Recent developments in Blop are making significant progress. The default backend framework for Bayesian optimization will soon be based upon Meta’s Ax platform [2]. This provides an adaptive experimentation framework with many built-in features for deployment, visualization, performance tracking, logging, and automatic model selection. In addition, Blop will soon have standard support for Tiled, Ophyd-Async, and Bluesky Adaptive built-in. Future developments will focus on solving complex beamline optimization problems through simulation via XRT, making safe Bluesky optimization routines, and enabling collaborative optimization between users and Blop agents.

References
[1] T. W. Morris, M. Rakitin, et al. “A general Bayesian algorithm for the autonomous alignment of beamlines,”
Journal of Synchrotron Radiation, vol. 31, no. 6, pp. 1446–1456, Nov 2024.
https://doi.org/10.1107/S1600577524008993
[2] M. Olson, E. Santorella, et al. “Ax: A Platform for Adaptive Experimentation,” AutoML 2025 ABCD Track,
2025. https://ax.dev/

Speakers: Mr Thomas Hopkins (NSLS-II, Brookhaven National Laboratory, Upton, NY 11973, USA), Dr Max Rakitin (NSLS-II, Brookhaven National Laboratory, Upton, NY 11973, USA)

Blop-ROCK-IT-DESY-virtual-20251106-thopkins-mrakitin.pdf

17:20 From MongoDB to SQL: Efficient and Scalable Data Management with Tiled

Tiled is a general-purpose data access service that unifies heterogeneous scientific data stores behind a structured interface. By mapping diverse storage backends (CSV, HDF5, TIFF, Zarr, Parquet, relational and NoSQL databases) onto a concise set of logical abstractions—tables, arrays, and hierarchical containers—Tiled hides backend details while enabling efficient, sliceable, chunked access. Its HTTP-based architecture supports deployment as a public or private service, modern authentication, fine-grained authorization, caching, and fast data streaming via WebSockets for real-time acquisition.

Developed in the context of the Bluesky project, Tiled provides first-class support for the Bluesky event document model through the TiledWriter callback. This allows to ingest Bluesky run documents into a Tiled catalog, storing scalar data as tables while registering external binary data (e.g. detector images) via StreamResource/StreamDatum documents aligned to a common time index. TiledWriter includes a RunNormalizer that upgrades legacy schemas, can run asynchronously to avoid disrupting experiments, and buffers data during temporary outages.

We present the architecture and performance of the Bluesky–Tiled integration, emphasizing preprocessing and consolidation before data writing. These steps flatten and reindex streaming documents to accelerate later queries. We compare SQL-backed Tiled catalogs with the legacy NoSQL storage solution, demonstrating the improved support of scalable, low-latency lookup, fast random access, and array slicing. Finally, we share experience migrating existing Bluesky datasets from MongoDB to PostgreSQL, quantifying performance gains on representative beamline use cases.

Speaker: Dr Yevgen Matviychuk (Brookhaven National Laboratory -- NSLS-II)

DESY_Bluesky_Workshop_2025 (2).pdf

18:00 → 19:00 Workshop Dinner

Friday 7 November

09:00 → 10:30 Community Talks: Session 6

Convener: William Smith (Helmholtz-Zentrum Berlin)

09:00 Devices in BEC - Ophyd as a Service at the SLS

Beamline Experiment Control (BEC) is the experiment control layer for the Swiss Light Source (SLS) following its upgrade to a fourth-generation synchrotron. It has a service-oriented client–server architecture where services communicate via Redis, acting as message broker and in-memory database. On the hardware side, BEC relies on the Bluesky’s ophyd v1 library as its abstraction layer.
This contribution presents how devices are managed in a centralized service: the device server, PSI’s implementation of ophyd-as-a-service. Beamlines configure device sessions for upcoming experiments using descriptive YAML files, which are used to instantiate ophyd objects. Devices are exposed to other services, including user clients, through BEC’s event system in Redis, providing access to device signals as well as the Bluesky interface (read/trigger/stage/unstage). Using simple examples, we illustrate how step and fly scans can be implemented at the SLS with standard EPICS and custom hardware. We further detail the data flow during a scan, highlighting how other services such as the GUI and file writer can visualize data in real time or start writing during acquisition.
In addition, we present PSI’s toolbox developed around ophyd v1 that enables devices in BEC to act or react autonomously to specific events. While scans are implemented slightly different in BEC, the core concept of Bluesky plans, scans as lists of instructions, remains. We also demonstrate extensions to the BlueskyInterface that reduce integration time at the beamline, such as custom file-event signals, progress updates, and preview data from large-area detectors using a custom data backend. Together, these developments streamline experiment setup, improve flexibility, and enhance user experience at the upgraded SLS.

Speaker: Christian Appel (PSI Center for Scientific Computing, Theory and Data, Paul Scherrer Institute, 5232 Villigen PSI, Switzerland)

BEC_Device_Management_RockIT.pptx

09:20 Redsun: composition-based application

In the field of microscopy, software control and hardware orchestration has becoming a blunder for many scientists: it is easy to build a new experimental setup but there are very few customizable software solutions that can adapt to the specifics of new implementations. On the other hand, Bluesky has greatly simplified the design of experiments through the usage of generator plans, and it shifted hardware integration from an inheritance-based approach (very common in microscopy) through a composition-based one by leveraging Python protocols - providing an enhanced flexibility in define the scope of a hardware device. Redsun is an attempt to address the gap in orchestrating hardware components and real-time data processing for lab-bench setups, adopting the same strategies and philosophies but from a software architecture perspective. Inheriting the Model-View-Presenter of its spiritual predecessor, ImSwitch, and following the plugin system implemented in napari, Redsun is designed to build dynamic applications that combine different software components, each shipped independently, with clear and documented input/output communication interfaces, and that leverage the Bluesky event model to share data between different points of the application.

Speaker: Jacopo Abramo (Leibniz-IPHT)

jacopo_abramo_redsun_rock_it_desy_workshop.pptx

09:40 Sardana overview and ongoing developments

The Sardana suite is a community-driven, open-source SCADA solution that has been successfully used for over a decade in scientific facilities, including synchrotrons (ALBA, DESY, MAX IV, SOLARIS) and laser laboratories (MBI-Berlin). It comprises two main components: Sardana [1] and Taurus [2]. Sardana is an experiment orchestration framework that provides both low-level hardware interfaces and high-level abstractions through a powerful sequencing engine, following a client–server architecture built on top of the TANGO control system. Taurus is a Python framework for building graphical and command-line user interfaces.

Sardana has continuously evolved to meet new user requirements, adding new features that have been discussed and prioritized in community workshops. Recent efforts have focused on enhancing continuous scans, introducing multiple synchronization descriptions to handle passive elements (e.g., shutters) and detectors operating at different acquisition rates. Morover, to improve data accessibility and decouple acquisition from storage, the ESRF Blissdata library has been integrated, enabling scan data to be stored and retrieved from a Redis database.

Ongoing developments include the redesign and consolidation of the Continuous Scan API, improvements to the MacroServer environment and configuration tool, and extended support for motor trajectories and archiving events.

[1] https://sardana-controls.org/
[2] https://taurus-scada.org/

Speaker: Oriol Vallcorba

Sardana overview and ongoing developments - Bluesky Workshop Nov25 DESY.pdf

10:30 → 11:00 Poster Session / Coffee Break

11:00 → 12:00 Working Groups: Final discussion and farewell

We will decide on and break into working groups to collaborate on Bluesky and related tools/processes.

Convener: Devin Burke (FS-EC (Experimente Control))

Deployment and containerization working group.md

13:00 → 16:00 DESY Tour

1. Building #1 / DESY in miniature
2. HERA
3. FLASH
4. CSSB (Structural Biology)
5. Petra