Discrete Control performance improvements based on AGV model

core/src/callback.jl

@@ -289,18 +289,23 @@
     # Get the discrete_control node to which this compound variable belongs
     discrete_control_node_id = discrete_control.node_id[compound_variable_idx]
 
-    # Get the indices of all conditions that this control node listens to
-    where_node_id = searchsorted(discrete_control.node_id, discrete_control_node_id)
-
-    # Get the truth state for this discrete_control node
-    truth_values = cat(
-        [
-            [ifelse(b, "T", "F") for b in discrete_control.condition_value[i]] for
-            i in where_node_id
-        ]...;
-        dims = 1,
-    )
-    truth_state = join(truth_values, "")
+    # Get the first index of the (compound) variables that this control node listens to
+    variable_idx = searchsortedfirst(discrete_control.node_id, discrete_control_node_id)
+    truth_value_idx = 1
+
+    # Build up the truth state from the truth values per (compound) variable per greater than
+    while variable_idx <= length(discrete_control.node_id) &&
+        discrete_control.node_id[variable_idx] == discrete_control_node_id
+        truth_values_variable = discrete_control.condition_value[variable_idx]
+        n_greater_than = length(truth_values_variable)
+        discrete_control.truth_state[truth_value_idx:(truth_value_idx + n_greater_than - 1)] .=
+            truth_values_variable
+        variable_idx += 1
+        truth_value_idx += n_greater_than
+    end
+
+    # The maximum truth state length is possibly shorter than this truth state
+    truth_state = view(discrete_control.truth_state, 1:(truth_value_idx - 1))
 
     # What the local control state should be
     control_state_new =
@@ -319,7 +324,7 @@
 
         push!(record.time, integrator.t)
         push!(record.control_node_id, Int32(discrete_control_node_id))
-        push!(record.truth_state, truth_state)
+        push!(record.truth_state, convert_truth_state(truth_state))
         push!(record.control_state, control_state_new)
 
         # Loop over nodes which are under control of this control node
@@ -393,22 +398,131 @@
     return nothing
 end
 
-function set_control_params!(p::Parameters, node_id::NodeID, control_state::String)
-    node = getfield(p, p.graph[node_id].type)
-    idx = searchsortedfirst(node.node_id, node_id)
-    new_state = node.control_mapping[(node_id, control_state)]
+function update_parameters!(pump::Pump, parameter_update::ParameterUpdate)::Nothing
+    if parameter_update.node_type != NodeType.Pump
+        return nothing
+    end
+    (; node_idx, active, flow_rate_scalar) = parameter_update
+    pump.active[node_idx] = active
+    if !isnan(flow_rate_scalar)
+        get_tmp(pump.flow_rate, 0)[node_idx] = clamp(
+            flow_rate_scalar,
+            pump.min_flow_rate[node_idx],
+            pump.max_flow_rate[node_idx],
+        )
+    end
+    return nothing
+end
 
-    for (field, value) in zip(keys(new_state), new_state)
-        if !ismissing(value)
-            vec = get_tmp(getfield(node, field), 0)
-            vec[idx] = value
-        end
+function update_parameters!(outlet::Outlet, parameter_update::ParameterUpdate)::Nothing
+    if parameter_update.node_type != NodeType.Outlet
+        return nothing
+    end
+    (; node_idx, active, flow_rate_scalar) = parameter_update
+    outlet.active[node_idx] = active
+    if !isnan(flow_rate_scalar)
+        get_tmp(outlet.flow_rate, 0)[node_idx] = clamp(
+            flow_rate_scalar,
+            outlet.min_flow_rate[node_idx],
+            outlet.max_flow_rate[node_idx],
+        )
+    end
+    return nothing
+end
 
-        # Set new fractional flow fractions in allocation problem
-        if is_active(p.allocation) && node isa FractionalFlow && field == :fraction
-            set_fractional_flow_in_allocation!(p, node_id, value)
-        end
+function update_parameters!(
+    tabulated_rating_curve::TabulatedRatingCurve,
+    parameter_update::ParameterUpdate,
+)::Nothing
+    if parameter_update.node_type != NodeType.TabulatedRatingCurve
+        return nothing
+    end
+    (; node_idx, active, table) = parameter_update
+    tabulated_rating_curve.active[node_idx] = active
+    if !isempty(table.t)
+        tabulated_rating_curve.tables[node_idx] = table
+    end
+    return nothing
+end
+
+function update_parameters!(
+    fractional_flow::FractionalFlow,
+    parameter_update::ParameterUpdate,
+    p::Parameters,
+)::Nothing
+    if parameter_update.node_type != NodeType.FractionalFlow
+        return nothing
     end
+    (; node_idx, fraction) = parameter_update
+    fractional_flow.fraction[node_idx] = fraction
+
+    if is_active(p.allocation)
+        set_fractional_flow_in_allocation!(p, fractional_flow.node_id[node_idx], fraction)
+    end
+    return nothing
+end
+
+function update_parameters!(
+    pid_control::PidControl,
+    parameter_update::ParameterUpdate,
+)::Nothing
+    if parameter_update.node_type != NodeType.PidControl
+        return nothing
+    end
+    (; node_idx, active, target, pid_params) = parameter_update
+    pid_control.active[node_idx] = active
+    if !isempty(target.t)
+        pid_control.target[node_idx] = target
+    end
+    if !isempty(pid_params.t)
+        pid_control.pid_params[node_idx] = pid_params
+    end
+    return nothing
+end
+
+function update_parameters!(
+    linear_resistance::LinearResistance,
+    parameter_update::ParameterUpdate,
+)::Nothing
+    if parameter_update.node_type != NodeType.LinearResistance
+        return nothing
+    end
+    (; node_idx, active, resistance) = parameter_update
+    linear_resistance.active[node_idx] = active
+    if !isnan(resistance)
+        linear_resistance.resistance[node_idx] = resistance
+    end
+    return nothing
+end
+
+function update_parameters!(
+    manning_resistance::ManningResistance,
+    parameter_update::ParameterUpdate,
+)::Nothing
+    if parameter_update.node_type != NodeType.ManningResistance
+        return nothing
+    end
+    (; node_idx, active, manning_n) = parameter_update
+    manning_resistance.active[node_idx] = active
+    if !isnan(manning_n)
+        manning_resistance.manning_n[node_idx] = manning_n
+    end
+    return nothing
+end
+
+function set_control_params!(p::Parameters, node_id::NodeID, control_state::String)::Nothing
+    parameter_update = p.discrete_control.control_mapping[(node_id, control_state)]
+
+    # Only the method corresponding to the type of the node_id actually updates parameters,
+    # but this way there is no runtime dispatch on node type
+    update_parameters!(p.pump, parameter_update)
+    update_parameters!(p.outlet, parameter_update)
+    update_parameters!(p.tabulated_rating_curve, parameter_update)
+    update_parameters!(p.fractional_flow, parameter_update, p)
+    update_parameters!(p.pid_control, parameter_update)
+    update_parameters!(p.linear_resistance, parameter_update)
+    update_parameters!(p.manning_resistance, parameter_update)
+    return nothing
 end
 
 function update_subgrid_level!(integrator)::Nothing

core/src/parameter.jl

@@ -190,6 +190,29 @@ struct Basin{T, C, V1, V2, V3} <: AbstractParameterNode
     time::StructVector{BasinTimeV1, C, Int}
 end
 
+"""
+ParameterUpdate is an object for storing the data for the
+parameter change associated with a specific control state
+used by DiscreteControl.
+"""
+struct ParameterUpdate
+    node_type::NodeType.T
+    node_idx::Int
+    active::Bool
+    flow_rate_scalar::Float64
+    flow_rate_itp::ScalarInterpolation
+    min_crest_level::Float64
+    resistance::Float64
+    manning_n::Float64
+    fraction::Float64
+    table::ScalarInterpolation
+    target::ScalarInterpolation
+    proportional::ScalarInterpolation
+    integral::ScalarInterpolation
+    derivative::ScalarInterpolation
+    pid_params::VectorInterpolation
+end
+
 """
     struct TabulatedRatingCurve{C}
 
@@ -218,7 +241,7 @@ struct TabulatedRatingCurve{C} <: AbstractParameterNode
     active::BitVector
     tables::Vector{ScalarInterpolation}
     time::StructVector{TabulatedRatingCurveTimeV1, C, Int}
-    control_mapping::Dict{Tuple{NodeID, String}, NamedTuple}
+    control_mapping::Dict{Tuple{NodeID, String}, ParameterUpdate}
 end
 
 """
@@ -239,7 +262,7 @@ struct LinearResistance <: AbstractParameterNode
     active::BitVector
     resistance::Vector{Float64}
     max_flow_rate::Vector{Float64}
-    control_mapping::Dict{Tuple{NodeID, String}, NamedTuple}
+    control_mapping::Dict{Tuple{NodeID, String}, ParameterUpdate}
 end
 
 """
@@ -291,7 +314,7 @@ struct ManningResistance <: AbstractParameterNode
     profile_slope::Vector{Float64}
     upstream_bottom::Vector{Float64}
     downstream_bottom::Vector{Float64}
-    control_mapping::Dict{Tuple{NodeID, String}, NamedTuple}
+    control_mapping::Dict{Tuple{NodeID, String}, ParameterUpdate}
 end
 
 """
@@ -308,7 +331,7 @@ struct FractionalFlow <: AbstractParameterNode
     inflow_edge::Vector{EdgeMetadata}
     outflow_edge::Vector{EdgeMetadata}
     fraction::Vector{Float64}
-    control_mapping::Dict{Tuple{NodeID, String}, NamedTuple}
+    control_mapping::Dict{Tuple{NodeID, String}, ParameterUpdate}
 end
 
 """
@@ -354,7 +377,7 @@ struct Pump{T} <: AbstractParameterNode
     flow_rate::T
     min_flow_rate::Vector{Float64}
     max_flow_rate::Vector{Float64}
-    control_mapping::Dict{Tuple{NodeID, String}, NamedTuple}
+    control_mapping::Dict{Tuple{NodeID, String}, ParameterUpdate}
     is_pid_controlled::BitVector
 
     function Pump(
@@ -408,7 +431,7 @@ struct Outlet{T} <: AbstractParameterNode
     min_flow_rate::Vector{Float64}
     max_flow_rate::Vector{Float64}
     min_crest_level::Vector{Float64}
-    control_mapping::Dict{Tuple{NodeID, String}, NamedTuple}
+    control_mapping::Dict{Tuple{NodeID, String}, ParameterUpdate}
     is_pid_controlled::BitVector
 
     function Outlet(
@@ -457,6 +480,7 @@ weight: the weight of the variables in the condition per compound variable
 look_ahead: the look ahead of variables in the condition in seconds per compound_variable
 greater_than: The threshold values per compound variable
 condition_value: The current truth value of each condition per compound_variable per greater_than
+truth_state: Memory allocated for storing the truth state
 control_state: Dictionary: node ID => (control state, control state start)
 logic_mapping: Dictionary: (control node ID, truth state) => control state
 record: Namedtuple with discrete control information for results
@@ -470,10 +494,13 @@ struct DiscreteControl <: AbstractParameterNode
     look_ahead::Vector{Vector{Float64}}
     # Definition of conditions (one or more greater_than per compound variable)
     greater_than::Vector{Vector{Float64}}
-    condition_value::Vector{BitVector}
+    condition_value::Vector{Vector{Bool}}
+    # Preallocated for storing truth state
+    truth_state::Vector{Bool}
     # Definition of logic
     control_state::Dict{NodeID, Tuple{String, Float64}}
-    logic_mapping::Dict{Tuple{NodeID, String}, String}
+    logic_mapping::Dict{Tuple{NodeID, Vector{Bool}}, String}
+    control_mapping::Dict{Tuple{NodeID, String}, ParameterUpdate}
     record::@NamedTuple{
         time::Vector{Float64},
         control_node_id::Vector{Int32},
@@ -500,7 +527,7 @@ struct PidControl{T} <: AbstractParameterNode
     target::Vector{ScalarInterpolation}
     pid_params::Vector{VectorInterpolation}
     error::T
-    control_mapping::Dict{Tuple{NodeID, String}, NamedTuple}
+    control_mapping::Dict{Tuple{NodeID, String}, ParameterUpdate}
 end
 
 """