merge main

Author: xsalonx

lib/database/migrations/v1/20250901153000-allow-more-enum-detector-types.js

@@ -0,0 +1,44 @@
+/*
+ *  @license
+ *  Copyright CERN and copyright holders of ALICE O2. This software is
+ *  distributed under the terms of the GNU General Public License v3 (GPL
+ *  Version 3), copied verbatim in the file "COPYING".
+ *
+ *  See http://alice-o2.web.cern.ch/license for full licensing information.
+ *
+ *  In applying this license CERN does not waive the privileges and immunities
+ *  granted to it by virtue of its status as an Intergovernmental Organization
+ *  or submit itself to any jurisdiction.
+ */
+
+'use strict';
+
+const { Sequelize } = require('sequelize');
+const { DETECTOR_TYPES, DetectorType } = require('../../../domain/enums/DetectorTypes.js');
+
+/** @type {import('sequelize-cli').Migration} */
+module.exports = {
+    up: async (queryInterface) => queryInterface.sequelize.transaction(async () => {
+        await queryInterface.changeColumn(
+            'detectors',
+            'type',
+            { type: Sequelize.ENUM(...DETECTOR_TYPES), allowNull: false },
+        );
+    }),
+
+    down: async (queryInterface) => queryInterface.sequelize.transaction(async () => {
+        await queryInterface.changeColumn(
+            'detectors',
+            'type',
+            {
+                type: Sequelize.ENUM([
+                    DetectorType.PHYSICAL,
+                    DetectorType.QC_ONLY,
+                    DetectorType.VIRTUAL,
+                    DetectorType.OTHER,
+                ]),
+                allowNull: false,
+            },
+        );
+    }),
+};

lib/database/seeders/20200713103855-runs.js

@@ -2777,6 +2777,50 @@ module.exports = {
                     updated_at: '2019-08-09 14:00:00',
                     created_at: '2019-08-09 14:00:00',
                 },
+
+                {
+                    id: 109,
+                    run_number: 109,
+                    time_o2_start: '2020-08-08 13:00:00',
+                    first_tf_timestamp: '2020-08-08 13:00:00',
+                    time_trg_start: '2020-08-08 13:00:00',
+                    time_trg_end: '2020-08-09 14:00:00',
+                    time_o2_end: '2020-08-09 14:00:00',
+                    run_type_id: 12,
+                    run_quality: 'good',
+                    n_detectors: 15,
+                    n_flps: 12,
+                    n_epns: 12,
+                    n_subtimeframes: 12,
+                    bytes_read_out: 64,
+                    dd_flp: true,
+                    dcs: false,
+                    epn: true,
+                    fill_number: null,
+                    epn_topology: 'quite a long topology, which will for sure require a balloon to be displayed properly',
+                    concatenated_detectors: 'CPV',
+                    lhc_period_id: 3,
+                    lhc_beam_mode: 'STABLE BEAMS',
+                    odc_topology_full_name: 'hash',
+                    pdp_workflow_parameters: 'QC,GPU,CTF,EVENT_DISPLAY',
+                    pdp_beam_type: 'OO',
+                    readout_cfg_uri: 'Repository hash',
+                    start_of_data_transfer: '2022-03-21 13:00:00',
+                    end_of_data_transfer: '2022-03-21 13:30:00',
+                    ctf_file_count: 500,
+                    ctf_file_size: '214920239535280',
+                    tf_file_count: 30,
+                    tf_file_size: '214920239535280',
+                    other_file_count: 50,
+                    other_file_size: '214920239535280',
+                    definition: RunDefinition.PHYSICS,
+                    trigger_efficiency: 1,
+                    trigger_acceptance: 0.7569974555,
+                    cross_section: 78600,
+
+                    updated_at: '2020-08-09 14:00:00',
+                    created_at: '2020-08-09 14:00:00',
+                },
             ], { transaction }),
         ])),
 

lib/database/seeders/20221005120315-detector.js

@@ -123,6 +123,23 @@ module.exports = {
                     name: 'GLO',
                     type: DetectorType.QC_ONLY,
                 },
+
+                {
+                    id: 22,
+                    name: 'VTX',
+                    type: DetectorType.AOT_GLO,
+                },
+                {
+                    id: 23,
+                    name: 'EVS',
+                    type: DetectorType.AOT_EVENT,
+                },
+                {
+                    id: 24,
+                    name: 'MUD',
+                    type: DetectorType.MUON_GLO,
+                },
+
             ], { transaction });
         }),
     down: async (queryInterface) =>

lib/database/seeders/20221006084006-run-detectors.js

@@ -699,6 +699,12 @@ module.exports = {
                             detector_id: 16,
                             quality: 'good',
                         },
+
+                        {
+                            run_number: 109,
+                            detector_id: 1,
+                            quality: 'good',
+                        },
                     ],
                     { transaction },
                 ),

lib/database/seeders/20240112102011-data-passes.js

@@ -77,6 +77,15 @@ module.exports = {
                     created_at: '2024-02-11 10:00:00',
                     updated_at: '2024-02-11 10:00:00',
                 },
+
+                /** LHC23f */
+                {
+                    id: 9,
+                    name: 'LHC23f_cpass0',
+                    lhc_period_id: 3,
+                    created_at: '2024-02-11 10:00:00',
+                    updated_at: '2024-02-11 10:00:00',
+                },
             ], { transaction });
 
             await queryInterface.bulkInsert('data_pass_versions', [
@@ -144,7 +153,15 @@ module.exports = {
                     updated_at: '2024-02-15 12:00:00',
                 },
 
-            ], { transaction }),
+                {
+                    id: 9,
+                    description: 'cpass0',
+                    data_pass_id: 9,
+                    created_at: '2024-02-15 12:00:00',
+                    updated_at: '2024-02-15 12:00:00',
+                },
+
+            ], { transaction });
 
             await queryInterface.bulkInsert('data_pass_version_status_history', [
 
@@ -248,7 +265,15 @@ module.exports = {
                     created_at: '2024-02-15 12:30:00',
                     updated_at: '2024-02-15 12:30:00',
                 },
-            ], { transaction }),
+
+                {
+                    id: 14,
+                    data_pass_version_id: 9,
+                    status: DataPassVersionStatus.RUNNING,
+                    created_at: '2024-02-15 12:00:00',
+                    updated_at: '2024-02-15 12:00:00',
+                },
+            ], { transaction });
 
             await queryInterface.bulkInsert('data_passes_runs', [
                 { data_pass_id: 1, run_number: 106, ready_for_skimming: true },
@@ -274,6 +299,9 @@ module.exports = {
                 { data_pass_id: 5, run_number: 54 },
                 { data_pass_id: 5, run_number: 56 },
                 { data_pass_id: 5, run_number: 105 },
+
+                { data_pass_id: 9, run_number: 109 },
+
             ], { transaction });
         }),
 

lib/domain/enums/DetectorTypes.js

@@ -14,6 +14,9 @@
 const DetectorType = Object.freeze({
     PHYSICAL: 'PHYSICAL',
     QC_ONLY: 'QC',
+    AOT_GLO: 'AOT-GLO',
+    AOT_EVENT: 'AOT-EVENT',
+    MUON_GLO: 'MUON-GLO',
     VIRTUAL: 'VIRTUAL',
     OTHER: 'OTHER',
 });
@@ -25,8 +28,11 @@ const DETECTOR_TYPES = Object.values(DetectorType);
  */
 const DATA_TAKING_DETECTOR_TYPES = [DetectorType.PHYSICAL, DetectorType.VIRTUAL];
 
+const QC_DETECTOR_TYPES = [DetectorType.PHYSICAL, DetectorType.QC_ONLY, DetectorType.AOT_EVENT, DetectorType.AOT_GLO, DetectorType.MUON_GLO];
+
 module.exports = {
     DetectorType,
     DETECTOR_TYPES,
     DATA_TAKING_DETECTOR_TYPES,
+    QC_DETECTOR_TYPES,
 };

lib/public/components/Filters/common/FilteringModel.js

@@ -108,12 +108,14 @@ export class FilteringModel extends Observable {
     /**
      * Add new filter
      *
+     * NOTE that the method has no effect if called more than once for the same key
+     *
      * @param {string} key key of a new filter
      * @param {FilterModel} filter the new filter
      */
     put(key, filter) {
         if (key in this._filters) {
-            throw new Error(`Filter under key ${key} already exists`);
+            return;
         }
 
         this._filters[key] = filter;

lib/public/domain/enums/DetectorTypes.js

@@ -14,6 +14,9 @@
 export const DetectorType = Object.freeze({
     PHYSICAL: 'PHYSICAL',
     QC_ONLY: 'QC',
+    AOT_GLO: 'AOT-GLO',
+    AOT_EVENT: 'AOT-EVENT',
+    MUON_GLO: 'MUON-GLO',
     VIRTUAL: 'VIRTUAL',
     OTHER: 'OTHER',
 });
@@ -24,3 +27,5 @@ export const DETECTOR_TYPES = Object.values(DetectorType);
  * Any detector that might be used in AliECS configuration
  */
 export const DATA_TAKING_DETECTOR_TYPES = [DetectorType.PHYSICAL, DetectorType.VIRTUAL];
+
+export const QC_DETECTORS = [DetectorType.PHYSICAL, DetectorType.QC_ONLY, DetectorType.AOT_GLO, DetectorType.AOT_EVENT, DetectorType.MUON_GLO];

lib/public/services/detectors/detectorsProvider.js

@@ -11,9 +11,10 @@
  * or submit itself to any jurisdiction.
  */
 
+import { switchCase } from '/js/src/index.js';
 import { getRemoteData } from '../../utilities/fetch/getRemoteData.js';
 import { ObservableData } from '../../utilities/ObservableData.js';
-import { DetectorType, DATA_TAKING_DETECTOR_TYPES } from '../../domain/enums/DetectorTypes.js';
+import { DetectorType, DATA_TAKING_DETECTOR_TYPES, QC_DETECTORS } from '../../domain/enums/DetectorTypes.js';
 
 import { NonPhysicalDetector } from '../../domain/enums/detectorsNames.mjs';
 
@@ -32,10 +33,10 @@ const getPhysicalDetectorsFromAllDetectors = (allDetectors) => allDetectors.filt
  * Return the QC detectors from a list of detectors
  *
  * @param {Detector[]} allDetectors the list of all detectors
- * @return {Detector[]} physical detectors
+ * @return {Detector[]} QC detectors
  */
 const getQcDetectorsFromAllDetectors = (allDetectors) => allDetectors
-    .filter(({ type, name }) => [DetectorType.PHYSICAL, DetectorType.QC].includes(type) && !DETECTORS_EXCLUDED_FROM_QC.includes(name));
+    .filter(({ type, name }) => QC_DETECTORS.includes(type) && !DETECTORS_EXCLUDED_FROM_QC.includes(name));
 
 /**
  * Service class to fetch detectors from the backend
@@ -72,9 +73,27 @@ export class DetectorsProvider extends RemoteDataProvider {
      * @inheritDoc
      */
     async getRemoteData() {
-        const { data } = await getRemoteData('/api/detectors');
-        data.sort(({ name: name1 }, { name: name2 }) => name1.localeCompare(name2));
-        return data;
+        const { data: detectors } = await getRemoteData('/api/detectors');
+        const typeToOrderingKey = (type) => switchCase(type, {
+            [DetectorType.OTHER]: 0,
+            [DetectorType.VIRTUAL]: 1,
+            [DetectorType.PHYSICAL]: 2,
+            [DetectorType.AOT_GLO]: 3,
+            [DetectorType.AOT_EVENT]: 4,
+            [DetectorType.MUON_GLO]: 5,
+            [DetectorType.QC_ONLY]: 6,
+        });
+
+        const orderingKey = (detector1, detector2) => {
+            const specialPair = ['ZDC', 'TST'];
+            if (specialPair.includes(detector1.name) && specialPair.includes(detector2.name)) {
+                return detector1.name === 'ZDC' ? 1 : -1;
+            }
+            return -(typeToOrderingKey(detector1.type) - typeToOrderingKey(detector2.type)) * 10 + detector1.name.localeCompare(detector2.name);
+        };
+
+        detectors.sort((detector1, detector2) => orderingKey(detector1, detector2));
+        return detectors;
     }
 
     /**

lib/public/utilities/ObservableData.js

@@ -117,7 +117,8 @@ class ObservableDataBuilder {
     }
 
     /**
-     * Any time the source data value change it will be reflected in the created observable data
+     * Any time the source data value changes it will be reflected in the created observable data
+     * NOTE that when this option is used, then first of optional processors must accept source.getCurrent()
      *
      * @param {ObservableData} source the source data
      * @return {this} the builder instance
@@ -127,6 +128,18 @@ class ObservableDataBuilder {
         return this;
     }
 
+    /**
+     * Any time the one of sources' data value changes it will be reflected in the created observable data
+     * NOTE that when this option is used, then first of optional processors must accept sources list mapped by #getCurrent() method
+     *
+     * @param {ObservableData[]} sources the list of source data
+     * @return {this} the builder instance
+     */
+    sources(sources) {
+        this._sources = sources;
+        return this;
+    }
+
     /**
      * Adds a processing function that will be applied to the observable data (map functions will be called in the same
      * order as they have been registered)
@@ -147,10 +160,19 @@ class ObservableDataBuilder {
     build() {
         const initialValue = this._initialValue ?? this._source?.getCurrent();
         const observableData = new ObservableDataWithProcessing(initialValue, this._processors);
+        if (this._source && this._sources) {
+            throw Error('Cannot use sources() and source() in te same builder');
+        }
+        if (this._sources) {
+            const sources = this._sources;
+            sources.forEach((source) => source.observe(() => observableData.setCurrent(sources.map((source) => source.getCurrent()))));
+        }
+
         if (this._source) {
             const source = this._source;
             source.observe(() => observableData.setCurrent(source.getCurrent()));
         }
+
         this._processors = [];
         this._initialValue = null;
         this._source = null;