feat: Add a parent namespace to Parameters.

pywr-core/src/aggregated_node.rs

@@ -576,7 +576,7 @@ mod tests {
         network.connect_nodes(input_node, link_node1).unwrap();
         network.connect_nodes(link_node1, output_node1).unwrap();
 
-        let factor_profile = MonthlyProfileParameter::new("factor-profile", [2.0; 12], None);
+        let factor_profile = MonthlyProfileParameter::new("factor-profile".into(), [2.0; 12], None);
         let factor_profile_idx = network.add_simple_parameter(Box::new(factor_profile)).unwrap();
 
         let factors = Some(Factors::Ratio(vec![factor_profile_idx.into(), 1.0.into()]));

pywr-core/src/network.rs

@@ -5,7 +5,9 @@ use crate::edge::{Edge, EdgeIndex, EdgeVec};
 use crate::metric::{MetricF64, SimpleMetricF64};
 use crate::models::ModelDomain;
 use crate::node::{Node, NodeVec, StorageInitialVolume};
-use crate::parameters::{GeneralParameterType, ParameterCollection, ParameterIndex, ParameterStates, VariableConfig};
+use crate::parameters::{
+    GeneralParameterType, ParameterCollection, ParameterIndex, ParameterName, ParameterStates, VariableConfig,
+};
 use crate::recorders::{MetricSet, MetricSetIndex, MetricSetState};
 use crate::scenario::ScenarioIndex;
 use crate::solvers::{MultiStateSolver, Solver, SolverFeatures, SolverTimings};
@@ -1118,15 +1120,15 @@ impl Network {
     }
 
     /// Get a `Parameter` from a parameter's name
-    pub fn get_parameter_by_name(&self, name: &str) -> Result<&dyn parameters::Parameter, PywrError> {
+    pub fn get_parameter_by_name(&self, name: &ParameterName) -> Result<&dyn parameters::Parameter, PywrError> {
         match self.parameters.get_f64_by_name(name) {
             Some(parameter) => Ok(parameter),
             None => Err(PywrError::ParameterNotFound(name.to_string())),
         }
     }
 
     /// Get a `ParameterIndex` from a parameter's name
-    pub fn get_parameter_index_by_name(&self, name: &str) -> Result<ParameterIndex<f64>, PywrError> {
+    pub fn get_parameter_index_by_name(&self, name: &ParameterName) -> Result<ParameterIndex<f64>, PywrError> {
         match self.parameters.get_f64_index_by_name(name) {
             Some(idx) => Ok(idx),
             None => Err(PywrError::ParameterNotFound(name.to_string())),
@@ -1142,15 +1144,15 @@ impl Network {
     }
 
     /// Get a `IndexParameter` from a parameter's name
-    pub fn get_index_parameter_by_name(&self, name: &str) -> Result<&dyn parameters::Parameter, PywrError> {
+    pub fn get_index_parameter_by_name(&self, name: &ParameterName) -> Result<&dyn parameters::Parameter, PywrError> {
         match self.parameters.get_usize_by_name(name) {
             Some(parameter) => Ok(parameter),
             None => Err(PywrError::ParameterNotFound(name.to_string())),
         }
     }
 
     /// Get a `IndexParameterIndex` from a parameter's name
-    pub fn get_index_parameter_index_by_name(&self, name: &str) -> Result<ParameterIndex<usize>, PywrError> {
+    pub fn get_index_parameter_index_by_name(&self, name: &ParameterName) -> Result<ParameterIndex<usize>, PywrError> {
         match self.parameters.get_usize_index_by_name(name) {
             Some(idx) => Ok(idx),
             None => Err(PywrError::ParameterNotFound(name.to_string())),
@@ -1171,7 +1173,7 @@ impl Network {
     /// Get a `MultiValueParameterIndex` from a parameter's name
     pub fn get_multi_valued_parameter_index_by_name(
         &self,
-        name: &str,
+        name: &ParameterName,
     ) -> Result<ParameterIndex<MultiValue>, PywrError> {
         match self.parameters.get_multi_index_by_name(name) {
             Some(idx) => Ok(idx),
@@ -1729,7 +1731,7 @@ mod tests {
         let mut network = Network::default();
         let _node_index = network.add_input_node("input", None).unwrap();
 
-        let input_max_flow = parameters::ConstantParameter::new("my-constant", 10.0);
+        let input_max_flow = parameters::ConstantParameter::new("my-constant".into(), 10.0);
         let parameter = network.add_const_parameter(Box::new(input_max_flow)).unwrap();
 
         // assign the new parameter to one of the nodes.
@@ -1788,7 +1790,10 @@ mod tests {
         let recorder = AssertionRecorder::new("output-flow", MetricF64::NodeInFlow(idx), expected, None, None);
         model.network_mut().add_recorder(Box::new(recorder)).unwrap();
 
-        let idx = model.network().get_parameter_index_by_name("total-demand").unwrap();
+        let idx = model
+            .network()
+            .get_parameter_index_by_name(&"total-demand".into())
+            .unwrap();
         let expected = Array2::from_elem((366, 10), 12.0);
         let recorder = AssertionRecorder::new("total-demand", idx.into(), expected, None, None);
         model.network_mut().add_recorder(Box::new(recorder)).unwrap();
@@ -1846,7 +1851,7 @@ mod tests {
         // Set-up a control curve that uses the proportional volume
         // This should be use the initial proportion (100%) on the first time-step, and then the previous day's end value
         let cc = ControlCurveInterpolatedParameter::new(
-            "interp",
+            "interp".into(),
             MetricF64::DerivedMetric(dm_idx),
             vec![],
             vec![100.0.into(), 0.0.into()],
@@ -1967,7 +1972,7 @@ mod tests {
         let mut model = simple_model(1);
 
         let variable = ActivationFunction::Unit { min: 0.0, max: 10.0 };
-        let input_max_flow = parameters::ConstantParameter::new("my-constant", 10.0);
+        let input_max_flow = parameters::ConstantParameter::new("my-constant".into(), 10.0);
 
         assert!(input_max_flow.can_be_f64_variable());
 

pywr-core/src/parameters/aggregated.rs

@@ -1,4 +1,4 @@
-use super::{Parameter, ParameterState, PywrError, SimpleParameter};
+use super::{Parameter, ParameterName, ParameterState, PywrError, SimpleParameter};
 use crate::metric::{MetricF64, SimpleMetricF64};
 use crate::network::Network;
 use crate::parameters::{GeneralParameter, ParameterMeta};
@@ -41,7 +41,7 @@ impl<M> AggregatedParameter<M>
 where
     M: Send + Sync + Clone,
 {
-    pub fn new(name: &str, metrics: &[M], agg_func: AggFunc) -> Self {
+    pub fn new(name: ParameterName, metrics: &[M], agg_func: AggFunc) -> Self {
         Self {
             meta: ParameterMeta::new(name),
             metrics: metrics.to_vec(),

pywr-core/src/parameters/aggregated_index.rs

@@ -1,6 +1,6 @@
 /// AggregatedIndexParameter
 ///
-use super::{Parameter, ParameterState, PywrError};
+use super::{Parameter, ParameterName, ParameterState, PywrError};
 use crate::metric::MetricUsize;
 use crate::network::Network;
 use crate::parameters::{GeneralParameter, ParameterMeta};
@@ -41,7 +41,7 @@ pub struct AggregatedIndexParameter {
 }
 
 impl AggregatedIndexParameter {
-    pub fn new(name: &str, values: Vec<MetricUsize>, agg_func: AggIndexFunc) -> Self {
+    pub fn new(name: ParameterName, values: Vec<MetricUsize>, agg_func: AggIndexFunc) -> Self {
         Self {
             meta: ParameterMeta::new(name),
             values,

pywr-core/src/parameters/array.rs

@@ -1,5 +1,5 @@
 use crate::network::Network;
-use crate::parameters::{GeneralParameter, Parameter, ParameterMeta, ParameterState};
+use crate::parameters::{GeneralParameter, Parameter, ParameterMeta, ParameterName, ParameterState};
 use crate::scenario::ScenarioIndex;
 use crate::state::State;
 use crate::timestep::Timestep;
@@ -13,7 +13,7 @@ pub struct Array1Parameter {
 }
 
 impl Array1Parameter {
-    pub fn new(name: &str, array: Array1<f64>, timestep_offset: Option<i32>) -> Self {
+    pub fn new(name: ParameterName, array: Array1<f64>, timestep_offset: Option<i32>) -> Self {
         Self {
             meta: ParameterMeta::new(name),
             array,
@@ -60,7 +60,12 @@ pub struct Array2Parameter {
 }
 
 impl Array2Parameter {
-    pub fn new(name: &str, array: Array2<f64>, scenario_group_index: usize, timestep_offset: Option<i32>) -> Self {
+    pub fn new(
+        name: ParameterName,
+        array: Array2<f64>,
+        scenario_group_index: usize,
+        timestep_offset: Option<i32>,
+    ) -> Self {
         Self {
             meta: ParameterMeta::new(name),
             array,

pywr-core/src/parameters/asymmetric.rs

@@ -1,6 +1,8 @@
 use crate::metric::MetricUsize;
 use crate::network::Network;
-use crate::parameters::{downcast_internal_state_mut, GeneralParameter, Parameter, ParameterMeta, ParameterState};
+use crate::parameters::{
+    downcast_internal_state_mut, GeneralParameter, Parameter, ParameterMeta, ParameterName, ParameterState,
+};
 use crate::scenario::ScenarioIndex;
 use crate::state::State;
 use crate::timestep::Timestep;
@@ -13,7 +15,7 @@ pub struct AsymmetricSwitchIndexParameter {
 }
 
 impl AsymmetricSwitchIndexParameter {
-    pub fn new(name: &str, on_parameter: MetricUsize, off_parameter: MetricUsize) -> Self {
+    pub fn new(name: ParameterName, on_parameter: MetricUsize, off_parameter: MetricUsize) -> Self {
         Self {
             meta: ParameterMeta::new(name),
             on_parameter,

pywr-core/src/parameters/constant.rs

@@ -1,6 +1,6 @@
 use crate::parameters::{
     downcast_internal_state_mut, downcast_internal_state_ref, downcast_variable_config_ref, ActivationFunction,
-    ConstParameter, Parameter, ParameterMeta, ParameterState, VariableConfig, VariableParameter,
+    ConstParameter, Parameter, ParameterMeta, ParameterName, ParameterState, VariableConfig, VariableParameter,
 };
 use crate::scenario::ScenarioIndex;
 use crate::state::ConstParameterValues;
@@ -16,7 +16,7 @@ pub struct ConstantParameter {
 type InternalValue = Option<f64>;
 
 impl ConstantParameter {
-    pub fn new(name: &str, value: f64) -> Self {
+    pub fn new(name: ParameterName, value: f64) -> Self {
         Self {
             meta: ParameterMeta::new(name),
             value,
@@ -129,7 +129,7 @@ mod tests {
         let domain = default_domain();
 
         let var = ActivationFunction::Unit { min: 0.0, max: 2.0 };
-        let p = ConstantParameter::new("test", 1.0);
+        let p = ConstantParameter::new("test".into(), 1.0);
         let mut state = p
             .setup(domain.time().timesteps(), domain.scenarios().indices().first().unwrap())
             .unwrap();

pywr-core/src/parameters/control_curves/apportion.rs

@@ -1,6 +1,6 @@
 use crate::metric::MetricF64;
 use crate::network::Network;
-use crate::parameters::{GeneralParameter, Parameter, ParameterMeta, ParameterState};
+use crate::parameters::{GeneralParameter, Parameter, ParameterMeta, ParameterName, ParameterState};
 use crate::scenario::ScenarioIndex;
 use crate::state::{MultiValue, State};
 use crate::timestep::Timestep;
@@ -22,7 +22,7 @@ pub struct ApportionParameter {
 }
 
 impl ApportionParameter {
-    pub fn new(name: &str, metric: MetricF64, control_curve: MetricF64) -> Self {
+    pub fn new(name: ParameterName, metric: MetricF64, control_curve: MetricF64) -> Self {
         Self {
             meta: ParameterMeta::new(name),
             metric,

pywr-core/src/parameters/control_curves/index.rs

@@ -1,6 +1,6 @@
 use crate::metric::MetricF64;
 use crate::network::Network;
-use crate::parameters::{GeneralParameter, Parameter, ParameterMeta, ParameterState};
+use crate::parameters::{GeneralParameter, Parameter, ParameterMeta, ParameterName, ParameterState};
 use crate::scenario::ScenarioIndex;
 use crate::state::State;
 use crate::timestep::Timestep;
@@ -13,7 +13,7 @@ pub struct ControlCurveIndexParameter {
 }
 
 impl ControlCurveIndexParameter {
-    pub fn new(name: &str, metric: MetricF64, control_curves: Vec<MetricF64>) -> Self {
+    pub fn new(name: ParameterName, metric: MetricF64, control_curves: Vec<MetricF64>) -> Self {
         Self {
             meta: ParameterMeta::new(name),
             metric,

pywr-core/src/parameters/control_curves/interpolated.rs

@@ -1,7 +1,7 @@
 use crate::metric::MetricF64;
 use crate::network::Network;
 use crate::parameters::interpolate::interpolate;
-use crate::parameters::{GeneralParameter, Parameter, ParameterMeta, ParameterState};
+use crate::parameters::{GeneralParameter, Parameter, ParameterMeta, ParameterName, ParameterState};
 use crate::scenario::ScenarioIndex;
 use crate::state::State;
 use crate::timestep::Timestep;
@@ -15,7 +15,7 @@ pub struct ControlCurveInterpolatedParameter {
 }
 
 impl ControlCurveInterpolatedParameter {
-    pub fn new(name: &str, metric: MetricF64, control_curves: Vec<MetricF64>, values: Vec<MetricF64>) -> Self {
+    pub fn new(name: ParameterName, metric: MetricF64, control_curves: Vec<MetricF64>, values: Vec<MetricF64>) -> Self {
         Self {
             meta: ParameterMeta::new(name),
             metric,

pywr-core/src/parameters/control_curves/piecewise.rs

@@ -1,7 +1,7 @@
 use crate::metric::MetricF64;
 use crate::network::Network;
 use crate::parameters::interpolate::interpolate;
-use crate::parameters::{GeneralParameter, Parameter, ParameterMeta, ParameterState};
+use crate::parameters::{GeneralParameter, Parameter, ParameterMeta, ParameterName, ParameterState};
 use crate::scenario::ScenarioIndex;
 use crate::state::State;
 use crate::timestep::Timestep;
@@ -18,7 +18,7 @@ pub struct PiecewiseInterpolatedParameter {
 
 impl PiecewiseInterpolatedParameter {
     pub fn new(
-        name: &str,
+        name: ParameterName,
         metric: MetricF64,
         control_curves: Vec<MetricF64>,
         values: Vec<[f64; 2]>,
@@ -85,12 +85,12 @@ mod test {
         let mut model = simple_model(1);
 
         // Create an artificial volume series to use for the interpolation test
-        let volume = Array1Parameter::new("test-x", Array1::linspace(1.0, 0.0, 21), None);
+        let volume = Array1Parameter::new("test-x".into(), Array1::linspace(1.0, 0.0, 21), None);
 
         let volume_idx = model.network_mut().add_parameter(Box::new(volume)).unwrap();
 
         let parameter = PiecewiseInterpolatedParameter::new(
-            "test-parameter",
+            "test-parameter".into(),
             volume_idx.into(), // Interpolate with the parameter based values
             vec![0.8.into(), 0.5.into()],
             vec![[10.0, 1.0], [0.0, 0.0], [-1.0, -10.0]],

pywr-core/src/parameters/control_curves/simple.rs

@@ -1,6 +1,6 @@
 use crate::metric::MetricF64;
 use crate::network::Network;
-use crate::parameters::{GeneralParameter, Parameter, ParameterMeta, ParameterState};
+use crate::parameters::{GeneralParameter, Parameter, ParameterMeta, ParameterName, ParameterState};
 use crate::scenario::ScenarioIndex;
 use crate::state::State;
 use crate::timestep::Timestep;
@@ -14,7 +14,7 @@ pub struct ControlCurveParameter {
 }
 
 impl ControlCurveParameter {
-    pub fn new(name: &str, metric: MetricF64, control_curves: Vec<MetricF64>, values: Vec<MetricF64>) -> Self {
+    pub fn new(name: ParameterName, metric: MetricF64, control_curves: Vec<MetricF64>, values: Vec<MetricF64>) -> Self {
         Self {
             meta: ParameterMeta::new(name),
             metric,

pywr-core/src/parameters/control_curves/volume_between.rs

@@ -1,5 +1,5 @@
 use crate::metric::SimpleMetricF64;
-use crate::parameters::{Parameter, ParameterMeta, ParameterState, SimpleParameter};
+use crate::parameters::{Parameter, ParameterMeta, ParameterName, ParameterState, SimpleParameter};
 use crate::scenario::ScenarioIndex;
 use crate::state::SimpleParameterValues;
 use crate::timestep::Timestep;
@@ -14,7 +14,7 @@ pub struct VolumeBetweenControlCurvesParameter<M> {
 }
 
 impl<M> VolumeBetweenControlCurvesParameter<M> {
-    pub fn new(name: &str, total: M, upper: Option<M>, lower: Option<M>) -> Self {
+    pub fn new(name: ParameterName, total: M, upper: Option<M>, lower: Option<M>) -> Self {
         Self {
             meta: ParameterMeta::new(name),
             total,

pywr-core/src/parameters/delay.rs

@@ -1,7 +1,8 @@
 use crate::metric::{MetricF64, SimpleMetricF64};
 use crate::network::Network;
 use crate::parameters::{
-    downcast_internal_state_mut, GeneralParameter, Parameter, ParameterMeta, ParameterState, SimpleParameter,
+    downcast_internal_state_mut, GeneralParameter, Parameter, ParameterMeta, ParameterName, ParameterState,
+    SimpleParameter,
 };
 use crate::scenario::ScenarioIndex;
 use crate::state::{SimpleParameterValues, State};
@@ -17,7 +18,7 @@ pub struct DelayParameter<M> {
 }
 
 impl<M> DelayParameter<M> {
-    pub fn new(name: &str, metric: M, delay: usize, initial_value: f64) -> Self {
+    pub fn new(name: ParameterName, metric: M, delay: usize, initial_value: f64) -> Self {
         Self {
             meta: ParameterMeta::new(name),
             metric,
@@ -173,13 +174,13 @@ mod test {
 
         // Create an artificial volume series to use for the delay test
         let volumes = Array1::linspace(1.0, 0.0, 21);
-        let volume = Array1Parameter::new("test-x", volumes.clone(), None);
+        let volume = Array1Parameter::new("test-x".into(), volumes.clone(), None);
 
         let volume_idx = model.network_mut().add_parameter(Box::new(volume)).unwrap();
 
         const DELAY: usize = 3; // 3 time-step delay
         let parameter = DelayParameter::new(
-            "test-parameter",
+            "test-parameter".into(),
             volume_idx.into(), // Interpolate with the parameter based values
             DELAY,
             0.0,

pywr-core/src/parameters/discount_factor.rs

@@ -1,6 +1,6 @@
 use crate::metric::MetricF64;
 use crate::network::Network;
-use crate::parameters::{GeneralParameter, Parameter, ParameterMeta, ParameterState};
+use crate::parameters::{GeneralParameter, Parameter, ParameterMeta, ParameterName, ParameterState};
 use crate::scenario::ScenarioIndex;
 use crate::state::State;
 use crate::timestep::Timestep;
@@ -14,7 +14,7 @@ pub struct DiscountFactorParameter {
 }
 
 impl DiscountFactorParameter {
-    pub fn new(name: &str, discount_rate: MetricF64, base_year: i32) -> Self {
+    pub fn new(name: ParameterName, discount_rate: MetricF64, base_year: i32) -> Self {
         Self {
             meta: ParameterMeta::new(name),
             discount_rate,
@@ -66,12 +66,12 @@ mod test {
 
         // Create an artificial volume series to use for the delay test
         let volumes = Array1::linspace(1.0, 0.0, 21);
-        let volume = Array1Parameter::new("test-x", volumes.clone(), None);
+        let volume = Array1Parameter::new("test-x".into(), volumes.clone(), None);
 
         let _volume_idx = network.add_parameter(Box::new(volume)).unwrap();
 
         let parameter = DiscountFactorParameter::new(
-            "test-parameter",
+            "test-parameter".into(),
             0.03.into(), // Interpolate with the parameter based values
             2020,
         );