Management system for the SND experiments

TL;DR

This paper presents a new client-server management system for the SND detector experiments at VEPP-2000, featuring a web interface, role-based layers, and database interactions to streamline experiment configuration and metadata management.

Contribution

It introduces a novel web-based management system with a layered architecture and custom template engine for SND experiments, enhancing user interaction and data handling.

Findings

Implemented a web application using Node.js

Enabled configuration editing and metadata viewing

Provided a prototype for experiment log display

Abstract

A new management system for the SND detector experiments (at VEPP-2000 collider in Novosibirsk) is developed. We describe here the interaction between a user and the SND databases. These databases contain experiment configuration, conditions and metadata. The new system is designed in client-server architecture. It has several logical layers corresponding to the users roles. A new template engine is created. A web application is implemented using Node.js framework. At the time the application provides: showing and editing configuration; showing experiment metadata and experiment conditions data index; showing SND log (prototype).

Figures

Full text

1 Introduction

The SND detector [1, 2, 3] (see figure 1) operates at the VEPP-2000 collider [4] since 2008. At the time the detector produces hundreds gigabytes of stored information and dozens megabytes of metadata per day. These metadata are used in reconstruction, processing and system control. SND experiments are controlled by operators. SND subsystems are controlled by experts.

The detector has been built in the past century. Its software includes programs, scripts, frameworks, web-servers etc. that cover a lot of experiment tasks. However the current information system is quite old. So it was decided to create a new system that would have some existing features reconsidered and new ones that have not been implemented yet.

2 The information system implemented

In order to implement a new information system Node.js framework [5] has been used. A web-application is created. It allows a user to view and edit experiment configuration; to view experiment conditions data index; to view integral parameters of experiment runs. Some features (showing current SND/VEPP parameters and showing the SND event log) are at the prototype stage.

The SND collaboration consists of 20-30 physicists. It is important to design the system in the way it would require as little programming as possible. The system user may have some of the following roles: an operator (who monitors the experiments), an expert (who is responsible for some SND subsystems) and a programmer (who develops and supports the information system). An operator may need the experiment information to be properly displayed. An expert needs the same and also can define what information should be displayed. And a programmer can implement new ideas and features at expert or operator request.

We distinguish four roles and created corresponding abstraction layers of the information system:

• •

operator (web-interface layer),

• •

expert, also template editor (HTML pages templates layer),

• •

programmer (template pages variables layer),

• •

server developer (server core layer).

3 Template engine

3.1 Motivation

Using a template engine instead of conventional programming language allows experts (who are not required to be programmers) to create or modify some interfaces. Information system deals with database queries that are commonly performed asynchronously in JavaScript. Displayed items are table rows that depend on other table rows etc. All the rows result from chains of database queries. So a template engine should deal with asynchronous computations. It is very useful to have that asynchronously computed table rows values represented as simple as possible.

The existing template engines provide various styles and features. Some engines do not introduce new languages (like Plates [6] engine that operates with HTML transformations). Some engines support embedding JavaScript in HTML code (e.g. EJS [7], AJS [8]). These ones are great but non-professional programmers may use them improperly making code unclear. Some engines propose their own syntax (e.g. Pug [9], dust.js [10], Kernel [11]). Several ones don’t support asynchronous calls (e.g. Pug, EJS; though they have asynchronous counterparts). Several ones don’t introduce asynchronously computed values but may support asynchronous functions or filters.

3.2 Our engine

The new template engine is created. It allows a user to define scopes containing values and functions that may be used in templates or may be inherited by other scopes. Values may be constant or lazy. Both values and functions may be calculated either synchronously or asynchronously. Lazy values and functions may be marked as pure ones to use caching when possible.

A scope could be defined in a CommonJS module stored in a file having special file extension (for automatic loading by the server). The module should export a function that takes a set of helpers as an argument. That helpers provide a lot of features e.g. defining a scope (.scope), a lazy value (.lazy), SQL query (_.sql) etc. It is worth mentioning that the order of defining scopes, functions and values does not matter.

The example below describes scope greeting that inherits some definitions from global and also specifies function greet and values random, x and name.

⬇

module.exports = **function**(_) {

  _.scope(’greeting’, [’global’], {

    random: _.lazy(Math.random, ’sync/impure’),

    x: _.lazy(**function**(cb) { cb(0.5); }, ’async/pure’),

    greet: **function**(name){ **return** ’Hello, ’ + name; },

    name: _.SESSION(’username’)

  });

};

Once scope greeting is defined, its definitions could be used by a template:

⬇

**import** greeting

——-

∥∥header∥∥

∥∥

Template files also have the special file extension that is used for automatic loading too. Values and functions are enclosed in vertical bars. Those ones that contain HTML are enclosed in double vertical bars to prevent from escaping. There are blocks (like |#if|) that could be specified along with functions and values. Blocks are more complicated to define so a number of useful ones is predefined.

Templates hide all the differences between synchronous and asynchronous computations. It is permitted to apply a synchronous function to an asynchronously computed value and vice versa without mentioning any callbacks.

The server loads templates and scopes files automatically and detects accidental cyclic dependencies. Since declarative style is supported, expression evaluation order is undefined (except for functions that are evaluated after their arguments and compound values that are evaluated after their components). Function arguments are evaluated strictly but it is possible to define functions in a special way and evaluate arguments manually.

4 Showing the state

One important goal of the information system is to show the current parameters in some convenient way. Attention should be paid to the set of parameters to be monitored, the parameters values appearance properties.

The number of parameters observed by an operator should be limited. An operator needs to know some collider parameters (the energies, the currents, etc.) and the detector parameters (luminocity, computers temperature, etc.) including experimental runs parameters (number of events recorded, live time, etc.). We decided to divide parameters in three groups: “VEPP” (collider parameters), “SND” (detector parameters) and “RUN” (experiment run parameters for the SND).

An operator also needs to know the last event happened. So showing the SND log is worth implementing. The log contains entries concerning carrying out experiment and processing events.

Figure 2 shows prototypes of the mentioned views. The particular details of the interface, such as the parameters precision, relevance period, and highlighting, will be improved later.

Integral parameters of the experiment runs are used by the operator and experts during the experiment.

There is a paper log that embodies a table of the most important runs parameters. It was taken as a basis for a web view (see figure 3).

5 Conclusion

A new SND information system is developed. It uses client-server architecture having the four abstraction layers structure designed. The system provides web-interface. It allows a user to deal with some experiment databases and show the most important parameters. HTML pages are rendered using a new template engine.

Acknowledgments

The authors would like to thank other SND team members for help, guiding, discovering bugs and inspiration. This work is partly supported by the RFBR grants 16-02-00327 and 16-32-00542.