Thermo sensor with group alarm.

Author: altavir

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/ConstructorElement.kt

@@ -157,6 +157,20 @@ public fun <T1, T2, R> StateContainer.combineState(
     transformation: (T1, T2) -> R,
 ): DeviceState<R> = registerState(DeviceState.combine(first, second, transformation))
 
+/**
+ * Combines multiple device states into a single state by applying a transformation function.
+ *
+ * @param T the type of the individual state values.
+ * @param R the type of the combined state value.
+ * @param states a collection of [DeviceState] instances to be combined.
+ * @param transformation a function that takes an array of individual state values and maps it to a combined value.
+ * @return a new [DeviceState] representing the combined state, with the value computed by the transformation function.
+ */
+public inline fun <reified T, R> StateContainer.combineState(
+    states: Collection<DeviceState<T>>,
+    crossinline transformation: (Array<T>) -> R,
+): DeviceState<R> = registerState(DeviceState.combine(states, transformation))
+
 /**
  * Create and start binding between [sourceState] and [targetState]. Changes made to [sourceState] are automatically
  * transferred onto [targetState], but not vise versa.
@@ -210,7 +224,7 @@ public fun <T1, T2, R> StateContainer.combineTo(
 ): Job {
     val descriptor = ConnectionConstructorElement(setOf(sourceState1, sourceState2), setOf(targetState))
     registerElement(descriptor)
-    return kotlinx.coroutines.flow.combine(sourceState1.valueFlow, sourceState2.valueFlow, transformation).onEach {
+    return combine(sourceState1.valueFlow, sourceState2.valueFlow, transformation).onEach {
         targetState.value = it
     }.launchIn(this).apply {
         invokeOnCompletion {
@@ -231,7 +245,7 @@ public inline fun <reified T, R> StateContainer.combineTo(
 ): Job {
     val descriptor = ConnectionConstructorElement(sourceStates, setOf(targetState))
     registerElement(descriptor)
-    return kotlinx.coroutines.flow.combine(sourceStates.map { it.valueFlow }, transformation).onEach {
+    return combine(sourceStates.map { it.valueFlow }, transformation).onEach {
         targetState.value = it
     }.launchIn(this).apply {
         invokeOnCompletion {

controls-constructor/src/commonMain/kotlin/space/kscience/controls/constructor/DeviceState.kt

@@ -2,10 +2,7 @@ package space.kscience.controls.constructor
 
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.*
 import space.kscience.controls.constructor.units.NumericalValue
 import space.kscience.controls.constructor.units.UnitsOfMeasurement
 import kotlin.reflect.KProperty
@@ -97,7 +94,85 @@ public fun <T1, T2, R> DeviceState.Companion.combine(
 
     override val value: R get() = mapper(state1.value, state2.value)
 
-    override val valueFlow: Flow<R> = kotlinx.coroutines.flow.combine(state1.valueFlow, state2.valueFlow, mapper)
+    override val valueFlow: Flow<R> = combine(state1.valueFlow, state2.valueFlow, mapper)
 
     override fun toString(): String = "DeviceState.combine(state1=$state1, state2=$state2)"
+}
+
+/**
+ * Combines three device states into a single device state by applying a mapping function.
+ *
+ * @param state1 The first device state to combine.
+ * @param state2 The second device state to combine.
+ * @param state3 The third device state to combine.
+ * @param mapper The mapping function that combines the values of the three states into a resulting value.
+ * @return A new device state whose value depends on the combined values of the provided states.
+ */
+public fun <T1, T2, T3, R> DeviceState.Companion.combine(
+    state1: DeviceState<T1>,
+    state2: DeviceState<T2>,
+    state3: DeviceState<T3>,
+    mapper: (T1, T2, T3) -> R,
+): DeviceStateWithDependencies<R> = object : DeviceStateWithDependencies<R> {
+    override val dependencies = listOf(state1, state2, state3)
+
+    override val value: R get() = mapper(state1.value, state2.value, state3.value)
+
+    override val valueFlow: Flow<R> = combine(state1.valueFlow, state2.valueFlow, state3.valueFlow, mapper)
+
+    override fun toString(): String = "DeviceState.combine(state1=$state1, state2=$state2, state3=$state3)"
+}
+
+/**
+ * Combines multiple [DeviceState] instances into a single [DeviceStateWithDependencies].
+ * The combined state value is derived by applying the provided [mapper] function to the collection of individual state values.
+ *
+ * @param T the type of the individual state values.
+ * @param R the type of the combined state value.
+ * @param states a collection of [DeviceState] instances whose values are to be combined.
+ * @param mapper a function that takes a collection of state values and maps it to a combined value.
+ * @return a [DeviceStateWithDependencies] representing the combined state, which has dependencies on the input [states].
+ */
+public inline fun <reified T, R> DeviceState.Companion.combine(
+    states: Collection<DeviceState<T>>,
+    crossinline mapper: (Array<T>) -> R,
+): DeviceStateWithDependencies<R> = object : DeviceStateWithDependencies<R> {
+    override val dependencies = states
+
+    override val value: R get() = mapper(states.map { it.value }.toTypedArray())
+
+    override val valueFlow: Flow<R> = combine<T, R>(states.map { it.valueFlow }, mapper)
+
+    override fun toString(): String = "DeviceState.combine(states=${states.joinToString()})"
+}
+
+/**
+ * Combines multiple `DeviceState` instances into a single `DeviceStateWithDependencies`.
+ * The combined state is derived by applying the provided `mapper` function to the values of the input states.
+ *
+ * @param T the type of individual states' values.
+ * @param K the type of the keys in the input state map.
+ * @param R the type of the resulting combined state value.
+ * @param states a map of keys to `DeviceState` instances representing the individual states to be combined.
+ * @param mapper a function that takes a map of key-value pairs (where keys are from `states` and values are the current
+ *        values of the corresponding `DeviceState` instances) and produces the value for the combined state.
+ * @return a `DeviceStateWithDependencies` instance representing the combined state, with its value computed
+ *         dynamically based on the input states and the `mapper` function.
+ */
+public inline fun <reified T, K, R> DeviceState.Companion.combine(
+    states: Map<K, DeviceState<T>>,
+    crossinline mapper: (Map<K, T>) -> R,
+): DeviceStateWithDependencies<R> = object : DeviceStateWithDependencies<R> {
+    override val dependencies = states.values
+
+    override val value: R get() = mapper(states.mapValues { it.value.value })
+
+    private val entries = states.entries.toList()
+
+    override val valueFlow: Flow<R> = combine<T, R>(entries.map { it.value.valueFlow }) { array: Array<T> ->
+        // restore mapping
+        mapper(entries.indices.associate { entries[it].key to array[it] })
+    }
+
+    override fun toString(): String = "DeviceState.associate(states=${states})"
 }

controls-core/src/commonMain/kotlin/space/kscience/controls/api/descriptors.kt

@@ -1,6 +1,7 @@
 package space.kscience.controls.api
 
 import kotlinx.serialization.Serializable
+import space.kscience.dataforge.meta.ValueType
 import space.kscience.dataforge.meta.descriptors.MetaDescriptor
 import space.kscience.dataforge.meta.descriptors.MetaDescriptorBuilder
 
@@ -25,6 +26,18 @@ public fun PropertyDescriptor.metaDescriptor(block: MetaDescriptorBuilder.() ->
     }
 }
 
+/**
+ * Sets the value type and additional types for a property descriptor.
+ *
+ * @param valueType The main value type to be assigned to the property descriptor.
+ * @param otherTypes Additional value types to be assigned to the property descriptor.
+ */
+public fun PropertyDescriptor.valueType(valueType: ValueType, vararg otherTypes: ValueType) {
+    metaDescriptor {
+        valueType(valueType, *otherTypes)
+    }
+}
+
 /**
  * A descriptor for property
  */

controls-core/src/commonMain/kotlin/space/kscience/controls/manager/DeviceManager.kt

@@ -10,7 +10,6 @@ import space.kscience.dataforge.meta.MutableMeta
 import space.kscience.dataforge.names.Name
 import space.kscience.dataforge.names.get
 import space.kscience.dataforge.names.parseAsName
-import kotlin.collections.set
 import kotlin.properties.ReadOnlyProperty
 
 /**
@@ -38,14 +37,16 @@ public class DeviceManager : AbstractPlugin(), DeviceHub {
     }
 }
 
-public fun <D : Device> DeviceManager.install(name: String, device: D): D {
-    registerDevice(name.parseAsName(), device)
+public fun <D : Device> DeviceManager.install(name: Name, device: D): D {
+    registerDevice(name, device)
     device.launch {
         device.start()
     }
     return device
 }
 
+public fun <D : Device> DeviceManager.install(name: String, device: D): D = install(name.parseAsName(), device)
+
 public fun <D : Device> DeviceManager.install(device: D): D = install(device.id, device)
 
 

demo/thermo/build.gradle.kts

@@ -25,6 +25,7 @@ kscience {
             }
         },
         jsConfig = {
+            //otherwise compose-bootstrap does not work
             useCommonJs()
         }
 //        development = true
@@ -38,8 +39,8 @@ kscience {
         implementation(projects.controlsCore)
         implementation(projects.controlsConstructor)
         implementation(projects.controlsVision)
+        implementation(compose.runtime)
 
-        //web UI dependencies
         implementation(libs.plotlykt.core)
     }
 
@@ -49,12 +50,6 @@ kscience {
         implementation(projects.controlsModbus)
         implementation(projects.controlsOpcua)
 
-        //compose desktop dependencies
-        implementation(projects.controlsVisualisationCompose)
-        implementation(compose.runtime)
-        implementation(compose.desktop.currentOs)
-        implementation(compose.material3)
-
         implementation(libs.visionforge.server)
         implementation("org.jetbrains.kotlin-wrappers:kotlin-css")
         implementation(spclibs.ktor.server.cio)
@@ -65,20 +60,4 @@ kscience {
     jsMain {
         implementation(libs.visionforge.compose.html)
     }
-}
-
-compose {
-    desktop {
-        application {
-            mainClass = "center.sciprog.controls.demo.thermo.ComposePanelKt"
-
-            nativeDistributions {
-                packageName = "ControlsThermoSensor"
-                packageVersion = "1.0.0"
-                windows {
-                    includeAllModules = true
-                }
-            }
-        }
-    }
-}
+}

demo/thermo/src/commonMain/kotlin/ThermoSensorAnalyzer.kt

@@ -3,10 +3,14 @@ package center.sciprog.controls.demo.thermo
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.serialization.Serializable
+import space.kscience.controls.api.valueType
 import space.kscience.controls.constructor.*
 import space.kscience.controls.time.ValueWithTime
+import space.kscience.dataforge.context.Context
 import space.kscience.dataforge.meta.MetaConverter
+import space.kscience.dataforge.meta.ValueType
 import space.kscience.dataforge.names.asName
+import kotlin.math.abs
 import kotlin.time.Duration.Companion.milliseconds
 
 @Serializable
@@ -21,14 +25,17 @@ enum class ThermoSensorStatus {
 class ThermoSensorAnalyzer(
     val sensor: ThermoSensor,
     val analyzerConfig: ThermoSensorAnalyzerConfig
-) : DeviceConstructor(sensor.context) {
+) : DeviceConstructor(sensor.context, analyzerConfig.meta) {
     init {
         install("sensor".asName(), sensor)
     }
 
     val temperature by property(
-        MetaConverter.Companion.double,
-        sensor.propertyAsState(ThermoSensor.temperature, Double.NaN)
+        converter = MetaConverter.Companion.double,
+        state = sensor.propertyAsState(ThermoSensor.temperature, Double.NaN),
+        descriptorBuilder = {
+            valueType(ValueType.NUMBER)
+        }
     )
 
     private val statusState = MutableDeviceState(ThermoSensorStatus.NotConnected)
@@ -37,13 +44,19 @@ class ThermoSensorAnalyzer(
 
     private val averagedTemperatureState = MutableDeviceState(Double.NaN)
 
-    val averageTemperature: DeviceState<Double> by property(MetaConverter.double, averagedTemperatureState)
+    val averageTemperature: DeviceState<Double> by property(
+        converter = MetaConverter.double,
+        state = averagedTemperatureState,
+        descriptorBuilder = {
+            valueType(ValueType.NUMBER)
+        }
+    )
 
     private val history = ArrayList<ValueWithTime<Double>>()
 
     private val mutex = Mutex()
 
-    val statusUpdateJob = temperature.onNext(
+    private val statusUpdateJob = temperature.onNext(
         writes = listOf(status)
     ) { next ->
         if (next.isNaN()) {
@@ -71,17 +84,54 @@ class ThermoSensorAnalyzer(
             statusState.value = newStatus
         }
     }
+}
 
-//    val status by property(
-//        converter = MetaConverter.Companion.enum<ThermoSensorStatus>(),
-//        state = temperature.map {
-//            //TODO add analysis for history data
-//            when {
-//                it < -100.0 || it == Double.NaN -> ThermoSensorStatus.NotConnected
-//                it > analyzerConfig.alarmThreshold -> ThermoSensorStatus.Alarm
-//                it > analyzerConfig.warningThreshold -> ThermoSensorStatus.Warning
-//                else -> ThermoSensorStatus.Normal
-//            }
-//        }
-//    )
+/**
+ * A group-level analyzer for multiple thermal sensors. This class aggregates and monitors
+ * the states of a collection of `ThermoSensorAnalyzer` instances, providing insights and
+ * meta-state calculations based on the group-wide behavior.
+ *
+ * @constructor Creates a new instance with the provided context, list of analyzers, and
+ * configuration settings.
+ * @param context The system context under which the analyzer operates.
+ * @param sensors A collection of `ThermoSensorAnalyzer` instances, each representing a
+ * sensor to be monitored as part of the group.
+ * @param config A configuration object defining the parameters for the group-level
+ * analysis, including thresholds and metadata.
+ *
+ * Properties:
+ * - `discrepancy`: A computed property representing the absolute maximum deviation of any
+ * sensor's temperature from the group's average temperature. Helps in identifying significant
+ * sensor outliers in the group.
+ * - `status`: A computed property reflecting the overall status of the group, based on the
+ * discrepancy between individual sensor readings. The status is determined using the
+ * discrepancy threshold defined in the `ThermoSensorGroupConfig`. Possible statuses include
+ * `Normal` and `Alarm`.
+ */
+class ThermoSensorGroupAnalyzer(
+    context: Context,
+    val sensors: List<ThermoSensorAnalyzer>,
+    val config: ThermoSensorGroupConfig
+) : DeviceConstructor(context, config.meta) {
+
+    val discrepancy by property(
+        converter = MetaConverter.double,
+        state = combineState(sensors.map { it.temperature }) { values ->
+            val average = values.average()
+            values.maxOf { abs(average - it) }
+        },
+        descriptorBuilder = {
+            valueType(ValueType.NUMBER)
+        }
+    )
+
+    val status by property(
+        converter = MetaConverter.enum<ThermoSensorStatus>(),
+        state = discrepancy.map { discrepancy ->
+            when {
+                discrepancy >= config.discrepancyThreshold -> ThermoSensorStatus.Alarm
+                else -> ThermoSensorStatus.Normal
+            }
+        }
+    )
 }

demo/thermo/src/commonMain/kotlin/ThermoSensorHub.kt

@@ -4,11 +4,15 @@ import space.kscience.controls.api.Device
 import space.kscience.controls.api.DeviceHub
 import space.kscience.dataforge.context.ContextAware
 import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.NameToken
+import space.kscience.dataforge.names.asName
 import space.kscience.dataforge.names.parseAsName
 
 
 interface ThermoSensorHub : DeviceHub, ContextAware {
     val sensors: Map<String, ThermoSensorAnalyzer>
+    val groups: Map<String, ThermoSensorGroupAnalyzer>
 
-    override val devices: Map<Name, Device> get() = sensors.mapKeys { it.key.parseAsName() }
+    override val devices: Map<Name, Device>
+        get() = sensors.mapKeys { it.key.parseAsName() } + groups.mapKeys { NameToken("group",it.key).asName() }
 }