add other typeS

Author: xsalonx

lib/database/migrations/v1/20250901153000-add-aot-and-muons-qc-detectors.js

@@ -13,26 +13,31 @@
 
 'use strict';
 
-const { Op } = require('sequelize');
-const { DetectorType } = require('../../../domain/enums/DetectorTypes.js');
+const { Op, Sequelize } = require('sequelize');
+const { DetectorType, DETECTOR_TYPES } = require('../../../domain/enums/DetectorTypes.js');
 
 const NEW_QC_DETECTORS = [
-    'VTX',
-    'MTE',
-    'AOT-GLO',
-    'EVS',
-    'CEN',
-    'EVP',
-    'AOT-Event',
-    'MUD',
-    'GMU',
-    'MUON-GLO',
+    ['VTX', DetectorType.AOT_GLO],
+    ['MTE', DetectorType.AOT_GLO],
+
+    ['EVS', DetectorType.AOT_EVENT],
+    ['CEN', DetectorType.AOT_EVENT],
+    ['EVP', DetectorType.AOT_EVENT],
+
+    ['MUD', DetectorType.MUON_GLO],
+    ['GMU', DetectorType.MUON_GLO],
 ];
 
 /** @type {import('sequelize-cli').Migration} */
 module.exports = {
-    up: async (queryInterface) => queryInterface.sequelize.transaction(async () => {
-        await queryInterface.bulkInsert('detectors', NEW_QC_DETECTORS.map((name) => ({ name, type: DetectorType.QC_ONLY })));
+    up: async (queryInterface) => queryInterface.sequelize.transaction(async (transaction) => {
+        await queryInterface.changeColumn(
+            'detectors',
+            'type',
+            { type: Sequelize.ENUM(...DETECTOR_TYPES), allowNull: false },
+            { transaction },
+        );
+        await queryInterface.bulkInsert('detectors', NEW_QC_DETECTORS.map(([name, type]) => ({ name, type })), { transaction });
     }),
 
     down: async (queryInterface) => queryInterface.sequelize.transaction(async () => {

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: 'MOUN-GLO',
     VIRTUAL: 'VIRTUAL',
     OTHER: 'OTHER',
 });

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: 'MOUN-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

@@ -14,7 +14,7 @@
 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';
 
@@ -36,7 +36,7 @@ const getPhysicalDetectorsFromAllDetectors = (allDetectors) => allDetectors.filt
  * @return {Detector[]} QC detectors
  */
 const getQcDetectorsFromAllDetectors = (allDetectors) => allDetectors
-    .filter(({ type, name }) => [DetectorType.PHYSICAL, DetectorType.QC_ONLY].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
@@ -78,7 +78,10 @@ export class DetectorsProvider extends RemoteDataProvider {
             [DetectorType.OTHER]: 0,
             [DetectorType.VIRTUAL]: 1,
             [DetectorType.PHYSICAL]: 2,
-            [DetectorType.QC_ONLY]: 3,
+            [DetectorType.AOT_GLO]: 3,
+            [DetectorType.AOT_EVENT]: 4,
+            [DetectorType.MUON_GLO]: 5,
+            [DetectorType.QC_ONLY]: 6,
         });
         data.sort(({ name: name1, type: type1 }, { name: name2, type: type2 }) =>
             -(typeToOrderingKey(type1) - typeToOrderingKey(type2)) * 10 + name1.localeCompare(name2));

lib/public/views/Runs/ActiveColumns/runDetectorsAsyncQcActiveColumns.js

@@ -22,6 +22,7 @@ import errorAlert from '../../../components/common/errorAlert.js';
 import spinner from '../../../components/common/spinner.js';
 import { numericalComparisonFilter } from '../../../components/Filters/common/filters/numericalComparisonFilter.js';
 import { filtersSection } from '../../../components/Filters/common/filtersPanelPopover.js';
+import { DetectorType } from '../../../domain/enums/DetectorTypes.js';
 
 /**
  * Render QC summary for given run and detector
@@ -77,7 +78,7 @@ export const createRunDetectorsAsyncQcActiveColumns = (
         throw new Error('`dataPass` and `simulationPass` are exclusive options');
     }
 
-    let activeColumnEntries = dplDetectors?.map(({ name: detectorName, id: dplDetectorId }) => [
+    let activeColumnEntries = dplDetectors?.map(({ name: detectorName, id: dplDetectorId, type: dplDetectorType }) => [
         detectorName,
         {
             name: detectorName.toUpperCase(),
@@ -87,7 +88,7 @@ export const createRunDetectorsAsyncQcActiveColumns = (
                 Failure: (errors) => errorAlert(errors),
                 Success: (detectorUserHasAccessTo) => {
                     const detectorWasActiveDuringRun = Boolean(run.detectorsQualities.find(({ name }) => name === detectorName));
-                    if (!detectorWasActiveDuringRun) {
+                    if (dplDetectorType == DetectorType.PHYSICAL && !detectorWasActiveDuringRun) {
                         return null;
                     }