From 072ab6735f46451e5058a828bf460ec24d8fa3f8 Mon Sep 17 00:00:00 2001 From: Tars Verschelde Date: Thu, 19 Oct 2023 16:00:44 +0200 Subject: [PATCH] include examples in unit tests --- .gitignore | 1 + examples/DAG.json | 3966 ++++++++++++ .../case_study_A5/advanced_test_systemA5.jl | 17 - examples/case_study_A5/test_systemA5.jl | 9 - examples/case_study_A5/test_systemA5.sqlite | Bin 970752 -> 0 bytes examples/reserves.json | 4024 ++++++++++++ examples/simple_system.json | 3845 ++++++++++++ examples/system_A5.json | 5401 +++++++++++++++++ examples/unit_commitment.json | 4000 ++++++++++++ test/examples/advanced_test_systemA5.jl | 16 + test/examples/examples.jl | 10 + test/runtests.jl | 3 + 12 files changed, 21266 insertions(+), 26 deletions(-) create mode 100644 examples/DAG.json delete mode 100644 examples/case_study_A5/advanced_test_systemA5.jl delete mode 100644 examples/case_study_A5/test_systemA5.jl delete mode 100644 examples/case_study_A5/test_systemA5.sqlite create mode 100644 examples/reserves.json create mode 100644 examples/simple_system.json create mode 100644 examples/system_A5.json create mode 100644 examples/unit_commitment.json create mode 100644 test/examples/advanced_test_systemA5.jl create mode 100644 test/examples/examples.jl diff --git a/.gitignore b/.gitignore index 7391dda00e..19d8559f5e 100644 --- a/.gitignore +++ b/.gitignore @@ -12,6 +12,7 @@ *.sqlite-journal *test.sqlite *test_out.sqlite +*test_systemA5.sqlite docs/build/ docs/site/ diff --git a/examples/DAG.json b/examples/DAG.json new file mode 100644 index 0000000000..5e8ee2bf99 --- /dev/null +++ b/examples/DAG.json @@ -0,0 +1,3966 @@ +{ + "object_classes": [ + [ + "commodity", + "A good or product that can be consumed, produced, traded. E.g., electricity, oil, gas, water...", + 281473533932880 + ], + [ + "connection", + "A transfer of commodities between nodes. E.g. electricity line, gas pipeline...", + 280378317271233 + ], + [ + "investment_group", + "A group of investments that need to be done together.", + 281105609585860 + ], + [ + "model", + "An instance of SpineOpt, that specifies general parameters such as the temporal horizon.", + 281107035648412 + ], + [ + "node", + "A universal aggregator of commodify flows over units and connections, with storage capabilities.", + 280740554077951 + ], + [ + "output", + "A variable name from SpineOpt that can be included in a report.", + 280743406202948 + ], + [ + "report", + "A results report from a particular SpineOpt run, including the value of specific variables.", + 281108461711708 + ], + [ + "settings", + "Internal SpineOpt settings. We kindly advise not to mess with this one.", + 280375465144798 + ], + [ + "stochastic_scenario", + "A scenario for stochastic optimisation in SpineOpt.", + 280743389491710 + ], + [ + "stochastic_structure", + "A group of stochastic scenarios that represent a structure.", + 281470681806146 + ], + [ + "temporal_block", + "A length of time with a particular resolution.", + 280376891207703 + ], + [ + "unit", + "A conversion of one/many comodities between nodes.", + 281470681805429 + ], + [ + "user_constraint", + "A generic data-driven custom constraint.", + 281473533931636 + ] + ], + "relationship_classes": [ + [ + "connection__from_node", + [ + "connection", + "node" + ], + "Defines the `nodes` the `connection` can take input from, and holds most `connection_flow` variable specific parameters.", + 280378317271897 + ], + [ + "connection__from_node__user_constraint", + [ + "connection", + "node", + "user_constraint" + ], + "when specified this relationship allows the relevant flow connection flow variable to be included in the specified user constraint", + null + ], + [ + "connection__investment_group", + [ + "connection", + "investment_group" + ], + "Indicates that a `connection` belongs in an `investment_group`.", + null + ], + [ + "connection__investment_stochastic_structure", + [ + "connection", + "stochastic_structure" + ], + "Defines the stochastic structure of the connections investments variable", + null + ], + [ + "connection__investment_temporal_block", + [ + "connection", + "temporal_block" + ], + "Defines the temporal resolution of the connections investments variable", + null + ], + [ + "connection__node__node", + [ + "connection", + "node", + "node" + ], + "Holds parameters spanning multiple `connection_flow` variables to and from multiple `nodes`.", + null + ], + [ + "connection__to_node", + [ + "connection", + "node" + ], + "Defines the `nodes` the `connection` can output to, and holds most `connection_flow` variable specific parameters.", + 280378317271898 + ], + [ + "connection__to_node__user_constraint", + [ + "connection", + "node", + "user_constraint" + ], + "when specified this relationship allows the relevant flow connection flow variable to be included in the specified user constraint", + null + ], + [ + "connection__user_constraint", + [ + "connection", + "user_constraint" + ], + "Relationship required to involve a connections investment variables in a user_constraint", + null + ], + [ + "model__default_investment_stochastic_structure", + [ + "model", + "stochastic_structure" + ], + "Defines the default stochastic structure used for investment variables, which will be replaced by more specific definitions", + null + ], + [ + "model__default_investment_temporal_block", + [ + "model", + "temporal_block" + ], + "Defines the default temporal block used for investment variables, which will be replaced by more specific definitions", + null + ], + [ + "model__default_stochastic_structure", + [ + "model", + "stochastic_structure" + ], + "Defines the default stochastic structure used for model variables, which will be replaced by more specific definitions", + null + ], + [ + "model__default_temporal_block", + [ + "model", + "temporal_block" + ], + "Defines the default temporal block used for model variables, which will be replaced by more specific definitions", + null + ], + [ + "model__report", + [ + "model", + "report" + ], + "Determines which reports are written for each model and in turn, which outputs are written for each model", + null + ], + [ + "model__stochastic_structure", + [ + "model", + "stochastic_structure" + ], + "Defines which `stochastic_structure`s are included in which `model`s.", + null + ], + [ + "model__temporal_block", + [ + "model", + "temporal_block" + ], + "Defines which `temporal_block`s are included in which `model`s.", + null + ], + [ + "node__commodity", + [ + "node", + "commodity" + ], + "Define a `commodity` for a `node`. Only a single `commodity` is permitted per `node`", + null + ], + [ + "node__investment_group", + [ + "node", + "investment_group" + ], + "Indicates that a `node` belongs in a `investment_group`.", + null + ], + [ + "node__investment_stochastic_structure", + [ + "node", + "stochastic_structure" + ], + "defines the stochastic structure for node related investments, currently only storages", + null + ], + [ + "node__investment_temporal_block", + [ + "node", + "temporal_block" + ], + "defines the temporal resolution for node related investments, currently only storages", + null + ], + [ + "node__node", + [ + "node", + "node" + ], + "Holds parameters for direct interactions between two `nodes`, e.g. `node_state` diffusion coefficients.", + null + ], + [ + "node__stochastic_structure", + [ + "node", + "stochastic_structure" + ], + "Defines which specific `stochastic_structure` is used by the `node` and all `flow` variables associated with it. Only one `stochastic_structure` is permitted per `node`.", + null + ], + [ + "node__temporal_block", + [ + "node", + "temporal_block" + ], + "Defines the `temporal_blocks` used by the `node` and all the `flow` variables associated with it.", + null + ], + [ + "node__user_constraint", + [ + "node", + "user_constraint" + ], + "specifying this relationship allows a node's demand or node_state to be included in the specified user constraint", + null + ], + [ + "parent_stochastic_scenario__child_stochastic_scenario", + [ + "stochastic_scenario", + "stochastic_scenario" + ], + "Defines the master stochastic direct acyclic graph, meaning how the `stochastic_scenarios` are related to each other.", + null + ], + [ + "report__output", + [ + "report", + "output" + ], + "Output object related to a report object are returned to the output database (if they appear in the model as variables)", + null + ], + [ + "stochastic_structure__stochastic_scenario", + [ + "stochastic_structure", + "stochastic_scenario" + ], + "Defines which `stochastic_scenarios` are included in which `stochastic_structure`, and holds the parameters required for realizing the structure in combination with the `temporal_blocks`.", + null + ], + [ + "unit__commodity", + [ + "unit", + "commodity" + ], + "Holds parameters for `commodities` used by the `unit`.", + null + ], + [ + "unit__from_node", + [ + "unit", + "node" + ], + "Defines the `nodes` the `unit` can take input from, and holds most `unit_flow` variable specific parameters.", + 281470681805657 + ], + [ + "unit__from_node__user_constraint", + [ + "unit", + "node", + "user_constraint" + ], + "Defines which input `unit_flows` are included in the `user_constraint`, and holds their parameters.", + null + ], + [ + "unit__investment_group", + [ + "unit", + "investment_group" + ], + "Indicates that a `unit` belongs in an `investment_group`.", + null + ], + [ + "unit__investment_stochastic_structure", + [ + "unit", + "stochastic_structure" + ], + "Sets the stochastic structure for investment decisions - overrides `model__default_investment_stochastic_structure`.", + null + ], + [ + "unit__investment_temporal_block", + [ + "unit", + "temporal_block" + ], + "Sets the temporal resolution of investment decisions - overrides `model__default_investment_temporal_block`", + null + ], + [ + "unit__node__node", + [ + "unit", + "node", + "node" + ], + "Holds parameters spanning multiple `unit_flow` variables to and from multiple `nodes`.", + null + ], + [ + "unit__to_node", + [ + "unit", + "node" + ], + "Defines the `nodes` the `unit` can output to, and holds most `unit_flow` variable specific parameters.", + 281470681805658 + ], + [ + "unit__to_node__user_constraint", + [ + "unit", + "node", + "user_constraint" + ], + "Defines which output `unit_flows` are included in the `user_constraint`, and holds their parameters.", + null + ], + [ + "unit__user_constraint", + [ + "unit", + "user_constraint" + ], + "Defines which `units_on` variables are included in the `user_constraint`, and holds their parameters.", + null + ], + [ + "units_on__stochastic_structure", + [ + "unit", + "stochastic_structure" + ], + "Defines which specific `stochastic_structure` is used for the `units_on` variable of the `unit`. Only one `stochastic_structure` is permitted per `unit`.", + null + ], + [ + "units_on__temporal_block", + [ + "unit", + "temporal_block" + ], + "Defines which specific `temporal_blocks` are used by the `units_on` variable of the `unit`.", + null + ] + ], + "parameter_value_lists": [ + [ + "balance_type_list", + "balance_type_group" + ], + [ + "balance_type_list", + "balance_type_node" + ], + [ + "balance_type_list", + "balance_type_none" + ], + [ + "boolean_value_list", + false + ], + [ + "boolean_value_list", + true + ], + [ + "commodity_physics_list", + "commodity_physics_lodf" + ], + [ + "commodity_physics_list", + "commodity_physics_none" + ], + [ + "commodity_physics_list", + "commodity_physics_ptdf" + ], + [ + "connection_investment_variable_type_list", + "connection_investment_variable_type_continuous" + ], + [ + "connection_investment_variable_type_list", + "connection_investment_variable_type_integer" + ], + [ + "connection_type_list", + "connection_type_lossless_bidirectional" + ], + [ + "connection_type_list", + "connection_type_normal" + ], + [ + "constraint_sense_list", + "<=" + ], + [ + "constraint_sense_list", + "==" + ], + [ + "constraint_sense_list", + ">=" + ], + [ + "db_lp_solver_list", + "KNITRO.jl" + ], + [ + "db_lp_solver_list", + "CDCS.jl" + ], + [ + "db_lp_solver_list", + "CDDLib.jl" + ], + [ + "db_lp_solver_list", + "Clp.jl" + ], + [ + "db_lp_solver_list", + "COSMO.jl" + ], + [ + "db_lp_solver_list", + "CPLEX.jl" + ], + [ + "db_lp_solver_list", + "CSDP.jl" + ], + [ + "db_lp_solver_list", + "ECOS.jl" + ], + [ + "db_lp_solver_list", + "Xpress.jl" + ], + [ + "db_lp_solver_list", + "GLPK.jl" + ], + [ + "db_lp_solver_list", + "Gurobi.jl" + ], + [ + "db_lp_solver_list", + "HiGHS.jl" + ], + [ + "db_lp_solver_list", + "Hypatia.jl" + ], + [ + "db_lp_solver_list", + "Ipopt.jl" + ], + [ + "db_lp_solver_list", + "MadNLP.jl" + ], + [ + "db_lp_solver_list", + "MosekTools.jl" + ], + [ + "db_lp_solver_list", + "NLopt.jl" + ], + [ + "db_lp_solver_list", + "OSQP.jl" + ], + [ + "db_lp_solver_list", + "ProxSDP.jl" + ], + [ + "db_lp_solver_list", + "SCIP.jl" + ], + [ + "db_lp_solver_list", + "SCS.jl" + ], + [ + "db_lp_solver_list", + "SDPA.jl" + ], + [ + "db_lp_solver_list", + "SDPNAL.jl" + ], + [ + "db_lp_solver_list", + "SDPT3.jl" + ], + [ + "db_lp_solver_list", + "SeDuMi.jl" + ], + [ + "db_mip_solver_list", + "KNITRO.jl" + ], + [ + "db_mip_solver_list", + "Cbc.jl" + ], + [ + "db_mip_solver_list", + "CPLEX.jl" + ], + [ + "db_mip_solver_list", + "HiGHS.jl" + ], + [ + "db_mip_solver_list", + "Xpress.jl" + ], + [ + "db_mip_solver_list", + "GLPK.jl" + ], + [ + "db_mip_solver_list", + "Gurobi.jl" + ], + [ + "db_mip_solver_list", + "Juniper.jl" + ], + [ + "db_mip_solver_list", + "MosekTools.jl" + ], + [ + "db_mip_solver_list", + "SCIP.jl" + ], + [ + "duration_unit_list", + "hour" + ], + [ + "duration_unit_list", + "minute" + ], + [ + "model_type_list", + "spineopt_benders" + ], + [ + "model_type_list", + "spineopt_standard" + ], + [ + "model_type_list", + "spineopt_other" + ], + [ + "model_type_list", + "spineopt_mga" + ], + [ + "node_opf_type_list", + "node_opf_type_normal" + ], + [ + "node_opf_type_list", + "node_opf_type_reference" + ], + [ + "unit_investment_variable_type_list", + "unit_investment_variable_type_continuous" + ], + [ + "unit_investment_variable_type_list", + "unit_investment_variable_type_integer" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_binary" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_integer" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_linear" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_none" + ], + [ + "variable_type_list", + "variable_type_binary" + ], + [ + "variable_type_list", + "variable_type_continuous" + ], + [ + "variable_type_list", + "variable_type_integer" + ], + [ + "write_mps_file_list", + "write_mps_always" + ], + [ + "write_mps_file_list", + "write_mps_never" + ], + [ + "write_mps_file_list", + "write_mps_on_no_solve" + ] + ], + "object_parameters": [ + [ + "commodity", + "commodity_lodf_tolerance", + 0.1, + null, + "The minimum absolute value of the line outage distribution factor (LODF) that is considered meaningful." + ], + [ + "commodity", + "commodity_physics", + "commodity_physics_none", + "commodity_physics_list", + "Defines if the `commodity` follows lodf or ptdf physics." + ], + [ + "commodity", + "commodity_ptdf_threshold", + 0.001, + null, + "The minimum absolute value of the power transfer distribution factor (PTDF) that is considered meaningful." + ], + [ + "commodity", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "commodity", + "mp_min_res_gen_to_demand_ratio", + null, + null, + "Minimum ratio of renewable generation to demand for this commodity - used in the minimum renewable generation constraint within the Benders master problem" + ], + [ + "commodity", + "mp_min_res_gen_to_demand_ratio_slack_penalty", + null, + null, + "Penalty for violating the minimum renewable generation to demand ratio." + ], + [ + "connection", + "candidate_connections", + null, + null, + "The number of connections that may be invested in" + ], + [ + "connection", + "connection_availability_factor", + 1.0, + null, + "Availability of the `connection`, acting as a multiplier on its `connection_capacity`. Typically between 0-1." + ], + [ + "connection", + "connection_contingency", + null, + "boolean_value_list", + "A boolean flag for defining a contingency `connection`." + ], + [ + "connection", + "connection_investment_cost", + null, + null, + "The per unit investment cost for the connection over the `connection_investment_lifetime`" + ], + [ + "connection", + "connection_investment_lifetime", + null, + null, + "Determines the minimum investment lifetime of a connection. Once invested, it remains in service for this long" + ], + [ + "connection", + "connection_investment_variable_type", + "variable_type_integer", + "variable_type_list", + "Determines whether the investment variable is integer `variable_type_integer` or continuous `variable_type_continuous`" + ], + [ + "connection", + "connection_monitored", + false, + "boolean_value_list", + "A boolean flag for defining a contingency `connection`." + ], + [ + "connection", + "connection_reactance", + null, + null, + "The per unit reactance of a `connection`." + ], + [ + "connection", + "connection_reactance_base", + 1, + null, + "If the reactance is given for a p.u. (e.g. p.u. = 100MW), the `connection_reactance_base` can be set to perform this conversion (e.g. *100)." + ], + [ + "connection", + "connection_resistance", + null, + null, + "The per unit resistance of a `connection`." + ], + [ + "connection", + "connection_type", + "connection_type_normal", + "connection_type_list", + "A selector between a normal and a lossless bidirectional `connection`." + ], + [ + "connection", + "connections_invested_big_m_mga", + null, + null, + "big_m_mga should be chosen as small as possible but sufficiently large. For units_invested_mga an appropriate big_m_mga would be twice the candidate connections." + ], + [ + "connection", + "connections_invested_mga", + false, + "boolean_value_list", + "Defines whether a certain variable (here: connections_invested) will be considered in the maximal-differences of the mga objective" + ], + [ + "connection", + "connections_invested_mga_weight", + 1, + null, + "Used to scale mga variables. For weightd sum mga method, the length of this weight given as an Array will determine the number of iterations." + ], + [ + "connection", + "fix_connections_invested", + null, + null, + "Setting a value fixes the connections_invested variable accordingly" + ], + [ + "connection", + "fix_connections_invested_available", + null, + null, + "Setting a value fixes the connections_invested_available variable accordingly" + ], + [ + "connection", + "forced_availability_factor", + null, + null, + "Availability factor due to outages/deratings." + ], + [ + "connection", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "connection", + "has_binary_gas_flow", + false, + "boolean_value_list", + "This parameter needs to be set to `true` in order to represent bidirectional pressure drive gas transfer." + ], + [ + "connection", + "initial_connections_invested", + null, + null, + "Setting a value fixes the connections_invested variable at the beginning" + ], + [ + "connection", + "initial_connections_invested_available", + null, + null, + "Setting a value fixes the connections_invested_available variable at the beginning" + ], + [ + "connection", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "model", + "big_m", + 1000000, + null, + "Sufficiently large number used for linearization bilinear terms, e.g. to enforce bidirectional flow for gas pipielines" + ], + [ + "model", + "db_lp_solver", + "HiGHS.jl", + "db_lp_solver_list", + "Solver for MIP problems. Solver package must be added and pre-configured in Julia. Overrides lp_solver RunSpineOpt kwarg" + ], + [ + "model", + "db_lp_solver_options", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "HiGHS.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "presolve", + "on" + ], + [ + "time_limit", + 300.01 + ] + ] + } + ], + [ + "Clp.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "LogLevel", + 0.0 + ] + ] + } + ] + ] + }, + null, + "Map parameter containing LP solver option name option value pairs. See solver documentation for supported solver options" + ], + [ + "model", + "db_mip_solver", + "HiGHS.jl", + "db_mip_solver_list", + "Solver for MIP problems. Solver package must be added and pre-configured in Julia. Overrides mip_solver RunSpineOpt kwarg" + ], + [ + "model", + "db_mip_solver_options", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "HiGHS.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "presolve", + "on" + ], + [ + "mip_rel_gap", + 0.01 + ], + [ + "threads", + 0.0 + ], + [ + "time_limit", + 300.01 + ] + ] + } + ], + [ + "Cbc.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "ratioGap", + 0.01 + ], + [ + "logLevel", + 0.0 + ] + ] + } + ], + [ + "CPLEX.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "CPX_PARAM_EPGAP", + 0.01 + ] + ] + } + ] + ] + }, + null, + "Map parameter containing MIP solver option name option value pairs for MIP. See solver documentation for supported solver options" + ], + [ + "model", + "duration_unit", + "hour", + "duration_unit_list", + "Defines the base temporal unit of the `model`. Currently supported values are either an `hour` or a `minute`." + ], + [ + "model", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "model", + "max_gap", + 0.05, + null, + "Specifies the maximum optimality gap for the model. Currently only used for the master problem within a decomposed structure" + ], + [ + "model", + "max_iterations", + 10.0, + null, + "Specifies the maximum number of iterations for the model. Currently only used for the master problem within a decomposed structure" + ], + [ + "model", + "max_mga_iterations", + null, + null, + "Define the number of mga iterations, i.e. how many alternative solutions will be generated." + ], + [ + "model", + "max_mga_slack", + 0.05, + null, + "Defines the maximum slack by which the alternative solution may differ from the original solution (e.g. 5% more than initial objective function value)" + ], + [ + "model", + "model_end", + { + "type": "date_time", + "data": "2000-01-02T00:00:00" + }, + null, + "Defines the last timestamp to be modelled. Rolling optimization terminates after passing this point." + ], + [ + "model", + "model_start", + { + "type": "date_time", + "data": "2000-01-01T00:00:00" + }, + null, + "Defines the first timestamp to be modelled. Relative `temporal_blocks` refer to this value for their start and end." + ], + [ + "model", + "model_type", + "spineopt_standard", + "model_type_list", + "Used to identify model objects as relating to the master problem or operational sub problems (default)" + ], + [ + "model", + "roll_forward", + null, + null, + "Defines how much the model moves ahead in time between solves in a rolling optimization. Without this parameter, everything is solved in as a single optimization." + ], + [ + "model", + "window_duration", + null, + null, + "The duration of the window in case it differs from roll_forward" + ], + [ + "model", + "window_weight", + 1, + null, + "The weight of the window in the rolling subproblem" + ], + [ + "model", + "write_lodf_file", + false, + "boolean_value_list", + "A boolean flag for whether the LODF values should be written to a results file." + ], + [ + "model", + "write_mps_file", + null, + "write_mps_file_list", + "A selector for writing an .mps file of the model." + ], + [ + "model", + "write_ptdf_file", + false, + "boolean_value_list", + "A boolean flag for whether the LODF values should be written to a results file." + ], + [ + "node", + "balance_type", + "balance_type_node", + "balance_type_list", + "A selector for how the `:nodal_balance` constraint should be handled." + ], + [ + "node", + "candidate_storages", + null, + null, + "Determines the maximum number of new storages which may be invested in" + ], + [ + "node", + "demand", + 0.0, + null, + "Demand for the `commodity` of a `node`. Energy gains can be represented using negative `demand`." + ], + [ + "node", + "downward_reserve", + false, + null, + "Identifier for `node`s providing downward reserves" + ], + [ + "node", + "fix_node_pressure", + null, + null, + "Fixes the corresponding `node_pressure` variable to the provided value" + ], + [ + "node", + "fix_node_state", + null, + null, + "Fixes the corresponding `node_state` variable to the provided value. Can be used for e.g. fixing boundary conditions." + ], + [ + "node", + "fix_node_voltage_angle", + null, + null, + "Fixes the corresponding `node_voltage_angle` variable to the provided value" + ], + [ + "node", + "fix_storages_invested", + null, + null, + "Used to fix the value of the storages_invested variable" + ], + [ + "node", + "fix_storages_invested_available", + null, + null, + "Used to fix the value of the storages_invested_available variable" + ], + [ + "node", + "frac_state_loss", + 0.0, + null, + "Self-discharge coefficient for `node_state` variables. Effectively, represents the *loss power per unit of state*." + ], + [ + "node", + "fractional_demand", + 0.0, + null, + "The fraction of a `node` group's `demand` applied for the `node` in question." + ], + [ + "node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "node", + "has_pressure", + false, + "boolean_value_list", + "A boolean flag for whether a `node` has a `node_pressure` variable." + ], + [ + "node", + "has_state", + false, + "boolean_value_list", + "A boolean flag for whether a `node` has a `node_state` variable." + ], + [ + "node", + "has_voltage_angle", + false, + "boolean_value_list", + "A boolean flag for whether a `node` has a `node_voltage_angle` variable." + ], + [ + "node", + "initial_node_pressure", + null, + null, + "Initializes the corresponding `node_pressure` variable to the provided value" + ], + [ + "node", + "initial_node_state", + null, + null, + "Initializes the corresponding `node_state` variable to the provided value." + ], + [ + "node", + "initial_node_voltage_angle", + null, + null, + "Initializes the corresponding `node_voltage_angle` variable to the provided value" + ], + [ + "node", + "initial_storages_invested", + null, + null, + "Used to initialze the value of the storages_invested variable" + ], + [ + "node", + "initial_storages_invested_available", + null, + null, + "Used to initialze the value of the storages_invested_available variable" + ], + [ + "node", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "node", + "is_non_spinning", + false, + "boolean_value_list", + "A boolean flag for whether a `node` is acting as a non-spinning reserve" + ], + [ + "node", + "is_reserve_node", + false, + "boolean_value_list", + "A boolean flag for whether a `node` is acting as a `reserve_node`" + ], + [ + "node", + "max_node_pressure", + null, + null, + "Maximum allowed gas pressure at `node`." + ], + [ + "node", + "max_voltage_angle", + null, + null, + "Maximum allowed voltage angle at `node`." + ], + [ + "node", + "min_node_pressure", + null, + null, + "Minimum allowed gas pressure at `node`." + ], + [ + "node", + "min_voltage_angle", + null, + null, + "Minimum allowed voltage angle at `node`. " + ], + [ + "node", + "minimum_reserve_activation_time", + null, + null, + "Duration a certain reserve product needs to be online/available" + ], + [ + "node", + "nodal_balance_sense", + "==", + "constraint_sense_list", + "A selector for `nodal_balance` constraint sense." + ], + [ + "node", + "node_opf_type", + "node_opf_type_normal", + "node_opf_type_list", + "A selector for the reference `node` (slack bus) when PTDF-based DC load-flow is enabled." + ], + [ + "node", + "node_slack_penalty", + null, + null, + "A penalty cost for `node_slack_pos` and `node_slack_neg` variables. The slack variables won't be included in the model unless there's a cost defined for them." + ], + [ + "node", + "node_state_cap", + null, + null, + "The maximum permitted value for a `node_state` variable." + ], + [ + "node", + "node_state_min", + 0.0, + null, + "The minimum permitted value for a `node_state` variable." + ], + [ + "node", + "state_coeff", + 1.0, + null, + "Represents the `commodity` content of a `node_state` variable in respect to the `unit_flow` and `connection_flow` variables. Essentially, acts as a coefficient on the `node_state` variable in the `:node_injection` constraint." + ], + [ + "node", + "storage_investment_cost", + null, + null, + "Determines the investment cost per unit state_cap over the investment life of a storage" + ], + [ + "node", + "storage_investment_lifetime", + null, + null, + "Minimum lifetime for storage investment decisions." + ], + [ + "node", + "storage_investment_variable_type", + "variable_type_integer", + "variable_type_list", + "Determines whether the storage investment variable is continuous (usually representing capacity) or integer (representing discrete units invested)" + ], + [ + "node", + "storages_invested_big_m_mga", + null, + null, + "big_m_mga should be chosen as small as possible but sufficiently large. For units_invested_mga an appropriate big_m_mga would be twice the candidate storages." + ], + [ + "node", + "storages_invested_mga", + false, + "boolean_value_list", + "Defines whether a certain variable (here: storages_invested) will be considered in the maximal-differences of the mga objective" + ], + [ + "node", + "storages_invested_mga_weight", + 1, + null, + "Used to scale mga variables. For weighted-sum mga method, the length of this weight given as an Array will determine the number of iterations." + ], + [ + "node", + "tax_in_unit_flow", + null, + null, + "Tax costs for incoming `unit_flows` on this `node`. E.g. EUR/MWh." + ], + [ + "node", + "tax_net_unit_flow", + null, + null, + "Tax costs for net incoming and outgoing `unit_flows` on this `node`. Incoming flows accrue positive net taxes, and outgoing flows accrue negative net taxes." + ], + [ + "node", + "tax_out_unit_flow", + null, + null, + "Tax costs for outgoing `unit_flows` from this `node`. E.g. EUR/MWh." + ], + [ + "node", + "upward_reserve", + false, + null, + "Identifier for `node`s providing upward reserves" + ], + [ + "output", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "output", + "output_resolution", + null, + null, + "Temporal resolution of the output variables associated with this `output`." + ], + [ + "report", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "report", + "output_db_url", + null, + null, + "Database url for SpineOpt output." + ], + [ + "settings", + "version", + 8, + null, + "Current version of the SpineOpt data structure. Modify it at your own risk (but please don't)." + ], + [ + "stochastic_scenario", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "stochastic_structure", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "temporal_block", + "block_end", + null, + null, + "The end time for the `temporal_block`. Can be given either as a `DateTime` for a static end point, or as a `Duration` for an end point relative to the start of the current optimization." + ], + [ + "temporal_block", + "block_start", + null, + null, + "The start time for the `temporal_block`. Can be given either as a `DateTime` for a static start point, or as a `Duration` for an start point relative to the start of the current optimization." + ], + [ + "temporal_block", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "temporal_block", + "representative_periods_mapping", + null, + null, + "Map from date time to representative temporal block name" + ], + [ + "temporal_block", + "resolution", + { + "type": "duration", + "data": "1h" + }, + null, + "Temporal resolution of the `temporal_block`. Essentially, divides the period between `block_start` and `block_end` into `TimeSlices` with the input `resolution`." + ], + [ + "temporal_block", + "weight", + 1.0, + null, + "Weighting factor of the temporal block associated with the objective function" + ], + [ + "unit", + "candidate_units", + null, + null, + "Number of units which may be additionally constructed" + ], + [ + "unit", + "curtailment_cost", + null, + null, + "Costs for curtailing generation. Essentially, accrues costs whenever `unit_flow` not operating at its maximum available capacity. E.g. EUR/MWh" + ], + [ + "unit", + "fix_units_invested", + null, + null, + "Fix the value of the `units_invested` variable." + ], + [ + "unit", + "fix_units_invested_available", + null, + null, + "Fix the value of the `units_invested_available` variable" + ], + [ + "unit", + "fix_units_on", + null, + null, + "Fix the value of the `units_on` variable." + ], + [ + "unit", + "fom_cost", + null, + null, + "Fixed operation and maintenance costs of a `unit`. Essentially, a cost coefficient on the existing units (incl. `number_of_units` and `units_invested_available`) and `unit_capacity` parameters. E.g. EUR/MWh" + ], + [ + "unit", + "forced_availability_factor", + null, + null, + "Availability factor due to outages/deratings." + ], + [ + "unit", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit", + "initial_units_invested", + null, + null, + "Initialize the value of the `units_invested` variable." + ], + [ + "unit", + "initial_units_invested_available", + null, + null, + "Initialize the value of the `units_invested_available` variable" + ], + [ + "unit", + "initial_units_on", + null, + null, + "Initialize the value of the `units_on` variable." + ], + [ + "unit", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "unit", + "is_renewable", + false, + "boolean_value_list", + "Whether the unit is renewable - used in the minimum renewable generation constraint within the Benders master problem" + ], + [ + "unit", + "min_down_time", + null, + null, + "Minimum downtime of a `unit` after it shuts down." + ], + [ + "unit", + "min_up_time", + null, + null, + "Minimum uptime of a `unit` after it starts up." + ], + [ + "unit", + "number_of_units", + 1.0, + null, + "Denotes the number of 'sub units' aggregated to form the modelled `unit`." + ], + [ + "unit", + "online_variable_type", + "unit_online_variable_type_linear", + "unit_online_variable_type_list", + "A selector for how the `units_on` variable is represented within the model." + ], + [ + "unit", + "shut_down_cost", + null, + null, + "Costs of shutting down a 'sub unit', e.g. EUR/shutdown." + ], + [ + "unit", + "start_up_cost", + null, + null, + "Costs of starting up a 'sub unit', e.g. EUR/startup." + ], + [ + "unit", + "unit_availability_factor", + 1.0, + null, + "Availability of the `unit`, acting as a multiplier on its `unit_capacity`. Typically between 0-1." + ], + [ + "unit", + "unit_investment_cost", + null, + null, + "Investment cost per 'sub unit' built." + ], + [ + "unit", + "unit_investment_lifetime", + null, + null, + "Minimum lifetime for unit investment decisions." + ], + [ + "unit", + "unit_investment_variable_type", + "unit_investment_variable_type_continuous", + "unit_investment_variable_type_list", + "Determines whether investment variable is integer or continuous." + ], + [ + "unit", + "units_invested_big_m_mga", + null, + null, + "big_m_mga should be chosen as small as possible but sufficiently large. For units_invested_mga an appropriate big_m_mga would be twice the candidate units." + ], + [ + "unit", + "units_invested_mga", + false, + "boolean_value_list", + "Defines whether a certain variable (here: units_invested) will be considered in the maximal-differences of the mga objective" + ], + [ + "unit", + "units_invested_mga_weight", + 1, + null, + "Used to scale mga variables. For weightd sum mga method, the length of this weight given as an Array will determine the number of iterations." + ], + [ + "unit", + "units_on_cost", + null, + null, + "Objective function coefficient on `units_on`. An idling cost, for example" + ], + [ + "unit", + "units_on_non_anticipativity_margin", + null, + null, + "Margin by which `units_on` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "unit", + "units_on_non_anticipativity_time", + null, + null, + "Period of time where the value of the `units_on` variable has to be fixed to the result from the previous window." + ], + [ + "user_constraint", + "constraint_sense", + "==", + "constraint_sense_list", + "A selector for the sense of the `user_constraint`." + ], + [ + "user_constraint", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "user_constraint", + "right_hand_side", + 0.0, + null, + "The right-hand side, constant term in a `user_constraint`. Can be time-dependent and used e.g. for complicated efficiency approximations." + ] + ], + "relationship_parameters": [ + [ + "connection__from_node", + "connection_capacity", + null, + null, + "Limits the `connection_flow` variable from the `from_node`. `from_node` can be a group of `nodes`, in which case the sum of the `connection_flow` is constrained." + ], + [ + "connection__from_node", + "connection_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `connection_capacity` unit conversions in the case that the `connection_capacity` value is incompatible with the desired `connection_flow` units." + ], + [ + "connection__from_node", + "connection_emergency_capacity", + null, + null, + "Post contingency flow capacity of a `connection`. Sometimes referred to as emergency rating" + ], + [ + "connection__from_node", + "connection_flow_cost", + null, + null, + "Variable costs of a flow through a `connection`. E.g. EUR/MWh of energy throughput." + ], + [ + "connection__from_node", + "connection_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__from_node", + "connection_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__from_node", + "connection_intact_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_intact_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__from_node", + "connection_intact_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_intact_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__from_node", + "fix_binary_gas_connection_flow", + null, + null, + "Fix the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__from_node", + "fix_connection_flow", + null, + null, + "Fix the value of the `connection_flow` variable." + ], + [ + "connection__from_node", + "fix_connection_intact_flow", + null, + null, + "Fix the value of the `connection_intact_flow` variable." + ], + [ + "connection__from_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "connection__from_node", + "initial_binary_gas_connection_flow", + null, + null, + "Initialize the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__from_node", + "initial_connection_flow", + null, + null, + "Initialize the value of the `connection_flow` variable." + ], + [ + "connection__from_node", + "initial_connection_intact_flow", + null, + null, + "Initialize the value of the `connection_intact_flow` variable." + ], + [ + "connection__from_node__user_constraint", + "connection_flow_coefficient", + 0.0, + null, + "defines the user constraint coefficient on the connection flow variable in the from direction" + ], + [ + "connection__node__node", + "compression_factor", + null, + null, + "The compression factor establishes a compression from an origin node to a receiving node, which are connected through a connection. The first node corresponds to the origin node, the second to the (compressed) destination node. Typically the value is >=1." + ], + [ + "connection__node__node", + "connection_flow_delay", + { + "type": "duration", + "data": "0h" + }, + null, + "Delays the `connection_flows` associated with the latter `node` in respect to the `connection_flows` associated with the first `node`." + ], + [ + "connection__node__node", + "connection_linepack_constant", + null, + null, + "The linepack constant is a property of gas pipelines and relates the linepack to the pressure of the adjacent nodes." + ], + [ + "connection__node__node", + "fix_ratio_out_in_connection_flow", + null, + null, + "Fix the ratio between the `connection_flow` from the first `node` and the `connection_flow` to the second `node`." + ], + [ + "connection__node__node", + "fixed_pressure_constant_0", + null, + null, + "Fixed pressure points for pipelines for the outer approximation of the Weymouth approximation. The direction of flow is the first node in the relationship to the second node in the relationship." + ], + [ + "connection__node__node", + "fixed_pressure_constant_1", + null, + null, + "Fixed pressure points for pipelines for the outer approximation of the Weymouth approximation. The direction of flow is the first node in the relationship to the second node in the relationship." + ], + [ + "connection__node__node", + "max_ratio_out_in_connection_flow", + null, + null, + "Maximum ratio between the `connection_flow` from the first `node` and the `connection_flow` to the second `node`." + ], + [ + "connection__node__node", + "min_ratio_out_in_connection_flow", + null, + null, + "Minimum ratio between the `connection_flow` from the first `node` and the `connection_flow` to the second `node`." + ], + [ + "connection__to_node", + "connection_capacity", + null, + null, + "Limits the `connection_flow` variable to the `to_node`. `to_node` can be a group of `nodes`, in which case the sum of the `connection_flow` is constrained." + ], + [ + "connection__to_node", + "connection_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `connection_capacity` unit conversions in the case the `connection_capacity` value is incompatible with the desired `connection_flow` units." + ], + [ + "connection__to_node", + "connection_emergency_capacity", + null, + null, + "The maximum post-contingency flow on a monitored `connection`." + ], + [ + "connection__to_node", + "connection_flow_cost", + null, + null, + "Variable costs of a flow through a `connection`. E.g. EUR/MWh of energy throughput." + ], + [ + "connection__to_node", + "connection_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__to_node", + "connection_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__to_node", + "connection_intact_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_intact_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__to_node", + "connection_intact_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_intact_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__to_node", + "fix_binary_gas_connection_flow", + null, + null, + "Fix the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__to_node", + "fix_connection_flow", + null, + null, + "Fix the value of the `connection_flow` variable." + ], + [ + "connection__to_node", + "fix_connection_intact_flow", + null, + null, + "Fix the value of the `connection_intact_flow` variable." + ], + [ + "connection__to_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "connection__to_node", + "initial_binary_gas_connection_flow", + null, + null, + "Initialize the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__to_node", + "initial_connection_flow", + null, + null, + "Initialize the value of the `connection_flow` variable." + ], + [ + "connection__to_node", + "initial_connection_intact_flow", + null, + null, + "Initialize the value of the `connection_intact_flow` variable." + ], + [ + "connection__to_node__user_constraint", + "connection_flow_coefficient", + 0.0, + null, + "defines the user constraint coefficient on the connection flow variable in the to direction" + ], + [ + "connection__user_constraint", + "connections_invested_available_coefficient", + 0.0, + null, + "coefficient of `connections_invested_available` in the specific `user_constraint`" + ], + [ + "connection__user_constraint", + "connections_invested_coefficient", + 0.0, + null, + "coefficient of `connections_invested` in the specific `user_constraint`" + ], + [ + "node__node", + "diff_coeff", + 0.0, + null, + "Commodity diffusion coefficient between two `nodes`. Effectively, denotes the *diffusion power per unit of state* from the first `node` to the second." + ], + [ + "node__stochastic_structure", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "node__temporal_block", + "cyclic_condition", + false, + "boolean_value_list", + "If the cyclic condition is set to true for a storage node, the `node_state` at the end of the optimization window has to be larger than or equal to the initial storage state." + ], + [ + "node__temporal_block", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "node__user_constraint", + "demand_coefficient", + 0.0, + null, + "coefficient of the specified node's demand in the specified user constraint" + ], + [ + "node__user_constraint", + "node_state_coefficient", + 0.0, + null, + "Coefficient of the specified node's state variable in the specified user constraint." + ], + [ + "node__user_constraint", + "storages_invested_available_coefficient", + 0.0, + null, + "Coefficient of the specified node's storages invested available variable in the specified user constraint." + ], + [ + "node__user_constraint", + "storages_invested_coefficient", + 0.0, + null, + "Coefficient of the specified node's storage investment variable in the specified user constraint." + ], + [ + "report__output", + "overwrite_results_on_rolling", + true, + null, + "Whether or not results from further windows should overwrite results from previous ones." + ], + [ + "stochastic_structure__stochastic_scenario", + "stochastic_scenario_end", + null, + null, + "A `Duration` for when a `stochastic_scenario` ends and its `child_stochastic_scenarios` start. Values are interpreted relative to the start of the current solve, and if no value is given, the `stochastic_scenario` is assumed to continue indefinitely." + ], + [ + "stochastic_structure__stochastic_scenario", + "weight_relative_to_parents", + 1.0, + null, + "The weight of the `stochastic_scenario` in the objective function relative to its parents." + ], + [ + "unit__commodity", + "max_cum_in_unit_flow_bound", + null, + null, + "Set a maximum cumulative upper bound for a `unit_flow`" + ], + [ + "unit__from_node", + "fix_nonspin_ramp_up_unit_flow", + null, + null, + "Fix the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "fix_nonspin_units_started_up", + null, + null, + "Fix the `nonspin_units_started_up` variable." + ], + [ + "unit__from_node", + "fix_ramp_up_unit_flow", + null, + null, + "Fix the `ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "fix_start_up_unit_flow", + null, + null, + "Fix the `start_up_unit_flow` variable." + ], + [ + "unit__from_node", + "fix_unit_flow", + null, + null, + "Fix the `unit_flow` variable." + ], + [ + "unit__from_node", + "fix_unit_flow_op", + null, + null, + "Fix the `unit_flow_op` variable." + ], + [ + "unit__from_node", + "fuel_cost", + null, + null, + "Variable fuel costs than can be attributed to a `unit_flow`. E.g. EUR/MWh" + ], + [ + "unit__from_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__from_node", + "initial_nonspin_ramp_up_unit_flow", + null, + null, + "Initialize the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "initial_nonspin_units_started_up", + null, + null, + "Initialize the `nonspin_units_started_up` variable." + ], + [ + "unit__from_node", + "initial_ramp_up_unit_flow", + null, + null, + "Initialize the `ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "initial_start_up_unit_flow", + null, + null, + "Initialize the `start_up_unit_flow` variable." + ], + [ + "unit__from_node", + "initial_unit_flow", + null, + null, + "Initialize the `unit_flow` variable." + ], + [ + "unit__from_node", + "initial_unit_flow_op", + null, + null, + "Initialize the `unit_flow_op` variable." + ], + [ + "unit__from_node", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "unit__from_node", + "max_res_shutdown_ramp", + null, + null, + "Max. downward reserve ramp for online units scheduled to shut down for reserve provision" + ], + [ + "unit__from_node", + "max_res_startup_ramp", + null, + null, + "Maximum non-spinning reserve ramp-up for startups." + ], + [ + "unit__from_node", + "max_shutdown_ramp", + null, + null, + "Max. downward ramp for units shutting down" + ], + [ + "unit__from_node", + "max_startup_ramp", + null, + null, + "Maximum ramp-up during startups." + ], + [ + "unit__from_node", + "max_total_cumulated_unit_flow_from_node", + null, + null, + "Bound on the maximum cumulated flows of a unit group from a node group e.g max consumption of certain commodity." + ], + [ + "unit__from_node", + "min_res_shutdown_ramp", + null, + null, + "Minimum non-spinning reserve ramp-down for online units providing reserves during shut-downs" + ], + [ + "unit__from_node", + "min_res_startup_ramp", + null, + null, + "Minimum non-spinning reserve ramp-up for startups." + ], + [ + "unit__from_node", + "min_shutdown_ramp", + null, + null, + "Minimum ramp-up during startups" + ], + [ + "unit__from_node", + "min_startup_ramp", + null, + null, + "Minimum ramp-up during startups." + ], + [ + "unit__from_node", + "min_total_cumulated_unit_flow_from_node", + null, + null, + "Bound on the minimum cumulated flows of a unit group from a node group." + ], + [ + "unit__from_node", + "min_unit_flow", + 0.0, + null, + "Set lower bound of the `unit_flow` variable." + ], + [ + "unit__from_node", + "minimum_operating_point", + null, + null, + "Minimum level for the `unit_flow` relative to the `units_on` online capacity." + ], + [ + "unit__from_node", + "operating_points", + null, + null, + "Operating points for piecewise-linear `unit` efficiency approximations." + ], + [ + "unit__from_node", + "ordered_unit_flow_op", + false, + "boolean_value_list", + "Defines whether the segments of this unit flow are ordered as per the rank of their operating points." + ], + [ + "unit__from_node", + "ramp_down_cost", + null, + null, + "Costs for ramping down" + ], + [ + "unit__from_node", + "ramp_down_limit", + null, + null, + "Limit the maximum ramp-down rate of an online unit, given as a fraction of the unit_capacity. [ramp_down_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__from_node", + "ramp_up_cost", + null, + null, + "Costs for ramping up" + ], + [ + "unit__from_node", + "ramp_up_limit", + null, + null, + "Limit the maximum ramp-up rate of an online unit, given as a fraction of the unit_capacity. [ramp_up_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__from_node", + "reserve_procurement_cost", + null, + null, + "Procurement cost for reserves" + ], + [ + "unit__from_node", + "unit_capacity", + null, + null, + "Maximum `unit_flow` capacity of a single 'sub_unit' of the `unit`." + ], + [ + "unit__from_node", + "unit_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `unit_capacity` unit conversions in the case the `unit_capacity` value is incompatible with the desired `unit_flow` units." + ], + [ + "unit__from_node", + "unit_flow_non_anticipativity_margin", + null, + null, + "Margin by which `unit_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "unit__from_node", + "unit_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `unit_flow` variable has to be fixed to the result from the previous window." + ], + [ + "unit__from_node", + "vom_cost", + null, + null, + "Variable operating costs of a `unit_flow` variable. E.g. EUR/MWh." + ], + [ + "unit__from_node__user_constraint", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__from_node__user_constraint", + "unit_flow_coefficient", + 0.0, + null, + "Coefficient of a `unit_flow` variable for a custom `user_constraint`." + ], + [ + "unit__node__node", + "fix_ratio_in_in_unit_flow", + null, + null, + "Fix the ratio between two `unit_flows` coming into the `unit` from the two `nodes`." + ], + [ + "unit__node__node", + "fix_ratio_in_out_unit_flow", + null, + null, + "Fix the ratio between an incoming `unit_flow` from the first `node` and an outgoing `unit_flow` to the second `node`." + ], + [ + "unit__node__node", + "fix_ratio_out_in_unit_flow", + null, + null, + "Fix the ratio between an outgoing `unit_flow` to the first `node` and an incoming `unit_flow` from the second `node`." + ], + [ + "unit__node__node", + "fix_ratio_out_out_unit_flow", + null, + null, + "Fix the ratio between two `unit_flows` going from the `unit` into the two `nodes`." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_in_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_in_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_in_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_in_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_out_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_out_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_out_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_out_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_ratio_in_in_unit_flow", + null, + null, + "Maximum ratio between two `unit_flows` coming into the `unit` from the two `nodes`." + ], + [ + "unit__node__node", + "max_ratio_in_out_unit_flow", + null, + null, + "Maximum ratio between an incoming `unit_flow` from the first `node` and an outgoing `unit_flow` to the second `node`." + ], + [ + "unit__node__node", + "max_ratio_out_in_unit_flow", + null, + null, + "Maximum ratio between an outgoing `unit_flow` to the first `node` and an incoming `unit_flow` from the second `node`." + ], + [ + "unit__node__node", + "max_ratio_out_out_unit_flow", + null, + null, + "Maximum ratio between two `unit_flows` going from the `unit` into the two `nodes`." + ], + [ + "unit__node__node", + "max_units_on_coefficient_in_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_in_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_units_on_coefficient_in_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_in_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_units_on_coefficient_out_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_out_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_units_on_coefficient_out_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_out_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_ratio_in_in_unit_flow", + null, + null, + "Minimum ratio between two `unit_flows` coming into the `unit` from the two `nodes`." + ], + [ + "unit__node__node", + "min_ratio_in_out_unit_flow", + null, + null, + "Minimum ratio between an incoming `unit_flow` from the first `node` and an outgoing `unit_flow` to the second `node`." + ], + [ + "unit__node__node", + "min_ratio_out_in_unit_flow", + null, + null, + "Minimum ratio between an outgoing `unit_flow` to the first `node` and an incoming `unit_flow` from the second `node`." + ], + [ + "unit__node__node", + "min_ratio_out_out_unit_flow", + null, + null, + "Minimum ratio between two `unit_flows` going from the `unit` into the two `nodes`." + ], + [ + "unit__node__node", + "min_units_on_coefficient_in_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_in_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_units_on_coefficient_in_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_in_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_units_on_coefficient_out_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_out_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_units_on_coefficient_out_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_out_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "unit_idle_heat_rate", + 0.0, + null, + "Flow from node1 per unit time and per `units_on` that results in no additional flow to node2" + ], + [ + "unit__node__node", + "unit_incremental_heat_rate", + null, + null, + "Standard piecewise incremental heat rate where node1 is assumed to be the fuel and node2 is assumed to be electriciy. Assumed monotonically increasing. Array type or single coefficient where the number of coefficients must match the dimensions of `unit_operating_points`" + ], + [ + "unit__node__node", + "unit_start_flow", + 0.0, + null, + "Flow from node1 that is incurred when a unit is started up." + ], + [ + "unit__to_node", + "fix_nonspin_ramp_down_unit_flow", + null, + null, + "Fix the `nonspin_ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_nonspin_ramp_up_unit_flow", + null, + null, + "Fix the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_nonspin_units_shut_down", + null, + null, + "Fix the `nonspin_units_shut_down` variable." + ], + [ + "unit__to_node", + "fix_nonspin_units_started_up", + null, + null, + "Fix the `nonspin_units_started_up` variable." + ], + [ + "unit__to_node", + "fix_ramp_down_unit_flow", + null, + null, + "Fix the `ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_ramp_up_unit_flow", + null, + null, + "Fix the `ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_shut_down_unit_flow", + null, + null, + "Fix the `shut_down_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_start_up_unit_flow", + null, + null, + "Fix the `start_up_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_unit_flow", + null, + null, + "Fix the `unit_flow` variable." + ], + [ + "unit__to_node", + "fix_unit_flow_op", + null, + null, + "Fix the `unit_flow_op` variable." + ], + [ + "unit__to_node", + "fuel_cost", + null, + null, + "Variable fuel costs than can be attributed to a `unit_flow`. E.g. EUR/MWh" + ], + [ + "unit__to_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__to_node", + "initial_nonspin_ramp_down_unit_flow", + null, + null, + "Initialize the `nonspin_ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_nonspin_ramp_up_unit_flow", + null, + null, + "Initialize the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_nonspin_units_shut_down", + null, + null, + "Initialize the `nonspin_units_shut_down` variable." + ], + [ + "unit__to_node", + "initial_nonspin_units_started_up", + null, + null, + "Initialize the `nonspin_units_started_up` variable." + ], + [ + "unit__to_node", + "initial_ramp_down_unit_flow", + null, + null, + "Initialize the `ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_ramp_up_unit_flow", + null, + null, + "Initialize the `ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_shut_down_unit_flow", + null, + null, + "Initialize the `shut_down_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_start_up_unit_flow", + null, + null, + "Initialize the `start_up_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_unit_flow", + null, + null, + "Initialize the `unit_flow` variable." + ], + [ + "unit__to_node", + "initial_unit_flow_op", + null, + null, + "Initialize the `unit_flow_op` variable." + ], + [ + "unit__to_node", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "unit__to_node", + "max_res_shutdown_ramp", + null, + null, + "Maximum non-spinning reserve ramp-down for online units providing reserves during shut-downs" + ], + [ + "unit__to_node", + "max_res_startup_ramp", + null, + null, + "Maximum non-spinning reserve ramp-up for offline units scheduled for reserve provision" + ], + [ + "unit__to_node", + "max_shutdown_ramp", + null, + null, + "Maximum ramp-down during shutdowns" + ], + [ + "unit__to_node", + "max_startup_ramp", + null, + null, + "Maximum ramp-up during startups" + ], + [ + "unit__to_node", + "max_total_cumulated_unit_flow_to_node", + null, + null, + "Bound on the maximum cumulated flows of a unit group to a node group, e.g. total GHG emissions." + ], + [ + "unit__to_node", + "min_res_shutdown_ramp", + null, + null, + "Minimum non-spinning reserve ramp-down for online units providing reserves during shut-downs" + ], + [ + "unit__to_node", + "min_res_startup_ramp", + null, + null, + "Minimum non-spinning reserve ramp-up for offline units scheduled for reserve provision" + ], + [ + "unit__to_node", + "min_shutdown_ramp", + null, + null, + "Minimum ramp-up during startups" + ], + [ + "unit__to_node", + "min_startup_ramp", + null, + null, + "Minimum ramp-up during startups" + ], + [ + "unit__to_node", + "min_total_cumulated_unit_flow_to_node", + null, + null, + "Bound on the minimum cumulated flows of a unit group to a node group, e.g. total renewable production." + ], + [ + "unit__to_node", + "min_unit_flow", + 0.0, + null, + "Set lower bound of the `unit_flow` variable." + ], + [ + "unit__to_node", + "minimum_operating_point", + null, + null, + "Minimum level for the `unit_flow` relative to the `units_on` online capacity." + ], + [ + "unit__to_node", + "operating_points", + null, + null, + "Decomposes the flow variable into a number of separate operating segment variables. Used to in conjunction with `unit_incremental_heat_rate` and/or `user_constraint`s" + ], + [ + "unit__to_node", + "ordered_unit_flow_op", + false, + "boolean_value_list", + "Defines whether the segments of this unit flow are ordered as per the rank of their operating points." + ], + [ + "unit__to_node", + "ramp_down_cost", + null, + null, + "Costs of ramping down" + ], + [ + "unit__to_node", + "ramp_down_limit", + null, + null, + "Limit the maximum ramp-down rate of an online unit, given as a fraction of the unit_capacity. [ramp_down_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__to_node", + "ramp_up_cost", + null, + null, + "Costs of ramping up" + ], + [ + "unit__to_node", + "ramp_up_limit", + null, + null, + "Limit the maximum ramp-up rate of an online unit, given as a fraction of the unit_capacity. [ramp_up_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__to_node", + "reserve_procurement_cost", + null, + null, + "Procurement cost for reserves" + ], + [ + "unit__to_node", + "unit_capacity", + null, + null, + "Maximum `unit_flow` capacity of a single 'sub_unit' of the `unit`." + ], + [ + "unit__to_node", + "unit_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `unit_capacity` unit conversions in the case the `unit_capacity` value is incompatible with the desired `unit_flow` units." + ], + [ + "unit__to_node", + "unit_flow_non_anticipativity_margin", + null, + null, + "Margin by which `unit_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "unit__to_node", + "unit_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `unit_flow` variable has to be fixed to the result from the previous window." + ], + [ + "unit__to_node", + "vom_cost", + null, + null, + "Variable operating costs of a `unit_flow` variable. E.g. EUR/MWh." + ], + [ + "unit__to_node__user_constraint", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__to_node__user_constraint", + "unit_flow_coefficient", + 0.0, + null, + "Coefficient of a `unit_flow` variable for a custom `user_constraint`." + ], + [ + "unit__user_constraint", + "units_invested_available_coefficient", + 0.0, + null, + "Coefficient of the `units_invested_available` variable in the specified `user_constraint`." + ], + [ + "unit__user_constraint", + "units_invested_coefficient", + 0.0, + null, + "Coefficient of the `units_invested` variable in the specified `user_constraint`." + ], + [ + "unit__user_constraint", + "units_on_coefficient", + 0.0, + null, + "Coefficient of a `units_on` variable for a custom `user_constraint`." + ], + [ + "unit__user_constraint", + "units_started_up_coefficient", + 0.0, + null, + "Coefficient of a `units_started_up` variable for a custom `user_constraint`." + ], + [ + "units_on__stochastic_structure", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "units_on__temporal_block", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ] + ], + "objects": [ + [ + "model", + "simple", + null + ], + [ + "node", + "electricity_node", + null + ], + [ + "node", + "fuel_node", + null + ], + [ + "output", + "binary_gas_connection_flow", + null + ], + [ + "output", + "connection_avg_intact_throughflow", + null + ], + [ + "output", + "connection_avg_throughflow", + null + ], + [ + "output", + "connection_flow", + null + ], + [ + "output", + "connection_flow_costs", + null + ], + [ + "output", + "connection_intact_flow", + null + ], + [ + "output", + "connection_investment_costs", + null + ], + [ + "output", + "connections_decommissioned", + null + ], + [ + "output", + "connections_invested", + null + ], + [ + "output", + "connections_invested_available", + null + ], + [ + "output", + "contingency_is_binding", + null + ], + [ + "output", + "fixed_om_costs", + null + ], + [ + "output", + "fuel_costs", + null + ], + [ + "output", + "mga_objective", + null + ], + [ + "output", + "mp_objective_lowerbound", + null + ], + [ + "output", + "node_injection", + null + ], + [ + "output", + "node_pressure", + null + ], + [ + "output", + "node_slack_neg", + null + ], + [ + "output", + "node_slack_pos", + null + ], + [ + "output", + "node_state", + null + ], + [ + "output", + "node_voltage_angle", + null + ], + [ + "output", + "nonspin_ramp_down_unit_flow", + null + ], + [ + "output", + "nonspin_ramp_up_unit_flow", + null + ], + [ + "output", + "nonspin_units_shut_down", + null + ], + [ + "output", + "nonspin_units_started_up", + null + ], + [ + "output", + "objective_penalties", + null + ], + [ + "output", + "ramp_costs", + null + ], + [ + "output", + "ramp_down_unit_flow", + null + ], + [ + "output", + "ramp_up_unit_flow", + null + ], + [ + "output", + "renewable_curtailment_costs", + null + ], + [ + "output", + "res_proc_costs", + null + ], + [ + "output", + "shut_down_costs", + null + ], + [ + "output", + "shut_down_unit_flow", + null + ], + [ + "output", + "start_up_costs", + null + ], + [ + "output", + "start_up_unit_flow", + null + ], + [ + "output", + "storage_investment_costs", + null + ], + [ + "output", + "storages_decommissioned", + null + ], + [ + "output", + "storages_invested", + null + ], + [ + "output", + "storages_invested_available", + null + ], + [ + "output", + "taxes", + null + ], + [ + "output", + "total_costs", + null + ], + [ + "output", + "unit_flow", + null + ], + [ + "output", + "unit_flow_op", + null + ], + [ + "output", + "unit_flow_op_active", + null + ], + [ + "output", + "unit_investment_costs", + null + ], + [ + "output", + "units_available", + null + ], + [ + "output", + "units_invested", + null + ], + [ + "output", + "units_invested_available", + null + ], + [ + "output", + "units_mothballed", + null + ], + [ + "output", + "units_on", + null + ], + [ + "output", + "units_on_costs", + null + ], + [ + "output", + "units_shut_down", + null + ], + [ + "output", + "units_started_up", + null + ], + [ + "output", + "variable_om_costs", + null + ], + [ + "report", + "report1", + null + ], + [ + "stochastic_scenario", + "forecast1", + null + ], + [ + "stochastic_scenario", + "forecast2", + null + ], + [ + "stochastic_scenario", + "forecast3", + null + ], + [ + "stochastic_scenario", + "realization", + null + ], + [ + "stochastic_structure", + "deterministic", + null + ], + [ + "temporal_block", + "flat", + null + ], + [ + "unit", + "power_plant_a", + null + ], + [ + "unit", + "power_plant_b", + null + ] + ], + "relationships": [ + [ + "model__default_stochastic_structure", + [ + "simple", + "deterministic" + ] + ], + [ + "model__default_temporal_block", + [ + "simple", + "flat" + ] + ], + [ + "model__report", + [ + "simple", + "report1" + ] + ], + [ + "model__stochastic_structure", + [ + "simple", + "deterministic" + ] + ], + [ + "model__temporal_block", + [ + "simple", + "flat" + ] + ], + [ + "parent_stochastic_scenario__child_stochastic_scenario", + [ + "realization", + "forecast1" + ] + ], + [ + "parent_stochastic_scenario__child_stochastic_scenario", + [ + "realization", + "forecast2" + ] + ], + [ + "parent_stochastic_scenario__child_stochastic_scenario", + [ + "realization", + "forecast3" + ] + ], + [ + "report__output", + [ + "report1", + "unit_flow" + ] + ], + [ + "stochastic_structure__stochastic_scenario", + [ + "deterministic", + "forecast1" + ] + ], + [ + "stochastic_structure__stochastic_scenario", + [ + "deterministic", + "forecast2" + ] + ], + [ + "stochastic_structure__stochastic_scenario", + [ + "deterministic", + "forecast3" + ] + ], + [ + "stochastic_structure__stochastic_scenario", + [ + "deterministic", + "realization" + ] + ], + [ + "unit__from_node", + [ + "power_plant_a", + "fuel_node" + ] + ], + [ + "unit__from_node", + [ + "power_plant_b", + "fuel_node" + ] + ], + [ + "unit__node__node", + [ + "power_plant_a", + "electricity_node", + "fuel_node" + ] + ], + [ + "unit__node__node", + [ + "power_plant_b", + "electricity_node", + "fuel_node" + ] + ], + [ + "unit__to_node", + [ + "power_plant_a", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "power_plant_b", + "electricity_node" + ] + ] + ], + "object_parameter_values": [ + [ + "node", + "electricity_node", + "demand", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "realization", + 150.0 + ], + [ + "forecast1", + 100.0 + ], + [ + "forecast2", + 120.0 + ], + [ + "forecast3", + 140.0 + ] + ] + }, + "Base" + ], + [ + "node", + "fuel_node", + "balance_type", + "balance_type_none", + "Base" + ], + [ + "temporal_block", + "flat", + "resolution", + { + "type": "duration", + "data": "1h" + }, + "Base" + ] + ], + "relationship_parameter_values": [ + [ + "stochastic_structure__stochastic_scenario", + [ + "deterministic", + "forecast1" + ], + "weight_relative_to_parents", + 0.3, + "Base" + ], + [ + "stochastic_structure__stochastic_scenario", + [ + "deterministic", + "forecast2" + ], + "weight_relative_to_parents", + 0.4, + "Base" + ], + [ + "stochastic_structure__stochastic_scenario", + [ + "deterministic", + "forecast3" + ], + "weight_relative_to_parents", + 0.3, + "Base" + ], + [ + "stochastic_structure__stochastic_scenario", + [ + "deterministic", + "realization" + ], + "stochastic_scenario_end", + { + "type": "duration", + "data": "6h" + }, + "Base" + ], + [ + "unit__from_node", + [ + "power_plant_a", + "fuel_node" + ], + "vom_cost", + 25, + "Base" + ], + [ + "unit__from_node", + [ + "power_plant_b", + "fuel_node" + ], + "vom_cost", + 50, + "Base" + ], + [ + "unit__node__node", + [ + "power_plant_a", + "electricity_node", + "fuel_node" + ], + "fix_ratio_out_in_unit_flow", + 0.7, + "Base" + ], + [ + "unit__node__node", + [ + "power_plant_b", + "electricity_node", + "fuel_node" + ], + "fix_ratio_out_in_unit_flow", + 0.8, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_a", + "electricity_node" + ], + "unit_capacity", + 100, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_b", + "electricity_node" + ], + "unit_capacity", + 200.0, + "Base" + ] + ], + "alternatives": [ + [ + "Base", + "Base alternative" + ] + ], + "tools": [ + [ + "object_activity_control", + "" + ] + ], + "features": [ + [ + "commodity", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "connection", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "model", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "node", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "node__stochastic_structure", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "node__temporal_block", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "output", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "report", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "stochastic_scenario", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "stochastic_structure", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "temporal_block", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "unit", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "unit__from_node", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "unit__to_node", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "units_on__stochastic_structure", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "units_on__temporal_block", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "user_constraint", + "is_active", + "boolean_value_list", + "boolean_value_list" + ] + ], + "tool_features": [ + [ + "object_activity_control", + "commodity", + "is_active", + false + ], + [ + "object_activity_control", + "connection", + "is_active", + false + ], + [ + "object_activity_control", + "model", + "is_active", + false + ], + [ + "object_activity_control", + "node", + "is_active", + false + ], + [ + "object_activity_control", + "node__stochastic_structure", + "is_active", + false + ], + [ + "object_activity_control", + "node__temporal_block", + "is_active", + false + ], + [ + "object_activity_control", + "output", + "is_active", + false + ], + [ + "object_activity_control", + "report", + "is_active", + false + ], + [ + "object_activity_control", + "stochastic_scenario", + "is_active", + false + ], + [ + "object_activity_control", + "stochastic_structure", + "is_active", + false + ], + [ + "object_activity_control", + "temporal_block", + "is_active", + false + ], + [ + "object_activity_control", + "unit", + "is_active", + false + ], + [ + "object_activity_control", + "unit__from_node", + "is_active", + false + ], + [ + "object_activity_control", + "unit__to_node", + "is_active", + false + ], + [ + "object_activity_control", + "units_on__stochastic_structure", + "is_active", + false + ], + [ + "object_activity_control", + "units_on__temporal_block", + "is_active", + false + ], + [ + "object_activity_control", + "user_constraint", + "is_active", + false + ] + ], + "tool_feature_methods": [ + [ + "object_activity_control", + "commodity", + "is_active", + true + ], + [ + "object_activity_control", + "connection", + "is_active", + true + ], + [ + "object_activity_control", + "model", + "is_active", + true + ], + [ + "object_activity_control", + "node", + "is_active", + true + ], + [ + "object_activity_control", + "node__stochastic_structure", + "is_active", + true + ], + [ + "object_activity_control", + "node__temporal_block", + "is_active", + true + ], + [ + "object_activity_control", + "output", + "is_active", + true + ], + [ + "object_activity_control", + "report", + "is_active", + true + ], + [ + "object_activity_control", + "stochastic_scenario", + "is_active", + true + ], + [ + "object_activity_control", + "stochastic_structure", + "is_active", + true + ], + [ + "object_activity_control", + "temporal_block", + "is_active", + true + ], + [ + "object_activity_control", + "unit", + "is_active", + true + ], + [ + "object_activity_control", + "unit__from_node", + "is_active", + true + ], + [ + "object_activity_control", + "unit__to_node", + "is_active", + true + ], + [ + "object_activity_control", + "units_on__stochastic_structure", + "is_active", + true + ], + [ + "object_activity_control", + "units_on__temporal_block", + "is_active", + true + ], + [ + "object_activity_control", + "user_constraint", + "is_active", + true + ] + ] +} \ No newline at end of file diff --git a/examples/case_study_A5/advanced_test_systemA5.jl b/examples/case_study_A5/advanced_test_systemA5.jl deleted file mode 100644 index 41c3ee4353..0000000000 --- a/examples/case_study_A5/advanced_test_systemA5.jl +++ /dev/null @@ -1,17 +0,0 @@ -using Dates -using SpineInterface -using SpineOpt -import SpineInterface: ScalarDuration - -db_url_in = "sqlite:///$(@__DIR__)/data/test_systemA5.sqlite" -db_url_out = "sqlite:///$(@__DIR__)/data/test_systemA5_out.sqlite" -m = run_spineopt(db_url_in, db_url_out; cleanup=false, log_level=2) - -some_week = temporal_block(:some_week) - -# Vary resolution from 1 to 24 hours and rerun -for h in 1:24 - temporal_block.parameter_values[some_week][:resolution] = - callable(db_api.from_database("""{"type": "duration", "data": "$(h) hours"}""")) - m = rerun_spineopt(db_url_out; cleanup=false, log_level=1) -end diff --git a/examples/case_study_A5/test_systemA5.jl b/examples/case_study_A5/test_systemA5.jl deleted file mode 100644 index 946bacc420..0000000000 --- a/examples/case_study_A5/test_systemA5.jl +++ /dev/null @@ -1,9 +0,0 @@ -using SpineOpt - -db_url_in = "sqlite:///$(@__DIR__)/test_systemA5.sqlite" -db_url_out = "sqlite:///$(@__DIR__)/test_systemA5_out.sqlite" -m = run_spineopt(db_url_in, db_url_out; upgrade=true, log_level=2) - -# TODO: add the 'second-segment' unit -# TODO: add minimum spillage -# TODO: add penalty for changes somehow diff --git a/examples/case_study_A5/test_systemA5.sqlite b/examples/case_study_A5/test_systemA5.sqlite deleted file mode 100644 index ceff0c536cd8d45c285749cd09aa6455c5343d54..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 970752 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 z00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY z0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4ea zAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd& z00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY z0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4ea zAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd& z00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY z0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4ea zAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd& z00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY z0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4ea zAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd& z00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY z0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4ea zAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd& z00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY z0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4ea zAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd&00JNY0w4eaAOHd& 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 diff --git a/examples/reserves.json b/examples/reserves.json new file mode 100644 index 0000000000..466288f4ad --- /dev/null +++ b/examples/reserves.json @@ -0,0 +1,4024 @@ +{ + "object_classes": [ + [ + "commodity", + "A good or product that can be consumed, produced, traded. E.g., electricity, oil, gas, water...", + 281473533932880 + ], + [ + "connection", + "A transfer of commodities between nodes. E.g. electricity line, gas pipeline...", + 280378317271233 + ], + [ + "investment_group", + "A group of investments that need to be done together.", + 281105609585860 + ], + [ + "model", + "An instance of SpineOpt, that specifies general parameters such as the temporal horizon.", + 281107035648412 + ], + [ + "node", + "A universal aggregator of commodify flows over units and connections, with storage capabilities.", + 280740554077951 + ], + [ + "output", + "A variable name from SpineOpt that can be included in a report.", + 280743406202948 + ], + [ + "report", + "A results report from a particular SpineOpt run, including the value of specific variables.", + 281108461711708 + ], + [ + "settings", + "Internal SpineOpt settings. We kindly advise not to mess with this one.", + 280375465144798 + ], + [ + "stochastic_scenario", + "A scenario for stochastic optimisation in SpineOpt.", + 280743389491710 + ], + [ + "stochastic_structure", + "A group of stochastic scenarios that represent a structure.", + 281470681806146 + ], + [ + "temporal_block", + "A length of time with a particular resolution.", + 280376891207703 + ], + [ + "unit", + "A conversion of one/many comodities between nodes.", + 281470681805429 + ], + [ + "user_constraint", + "A generic data-driven custom constraint.", + 281473533931636 + ] + ], + "relationship_classes": [ + [ + "connection__from_node", + [ + "connection", + "node" + ], + "Defines the `nodes` the `connection` can take input from, and holds most `connection_flow` variable specific parameters.", + 280378317271897 + ], + [ + "connection__from_node__user_constraint", + [ + "connection", + "node", + "user_constraint" + ], + "when specified this relationship allows the relevant flow connection flow variable to be included in the specified user constraint", + null + ], + [ + "connection__investment_group", + [ + "connection", + "investment_group" + ], + "Indicates that a `connection` belongs in an `investment_group`.", + null + ], + [ + "connection__investment_stochastic_structure", + [ + "connection", + "stochastic_structure" + ], + "Defines the stochastic structure of the connections investments variable", + null + ], + [ + "connection__investment_temporal_block", + [ + "connection", + "temporal_block" + ], + "Defines the temporal resolution of the connections investments variable", + null + ], + [ + "connection__node__node", + [ + "connection", + "node", + "node" + ], + "Holds parameters spanning multiple `connection_flow` variables to and from multiple `nodes`.", + null + ], + [ + "connection__to_node", + [ + "connection", + "node" + ], + "Defines the `nodes` the `connection` can output to, and holds most `connection_flow` variable specific parameters.", + 280378317271898 + ], + [ + "connection__to_node__user_constraint", + [ + "connection", + "node", + "user_constraint" + ], + "when specified this relationship allows the relevant flow connection flow variable to be included in the specified user constraint", + null + ], + [ + "connection__user_constraint", + [ + "connection", + "user_constraint" + ], + "Relationship required to involve a connections investment variables in a user_constraint", + null + ], + [ + "model__default_investment_stochastic_structure", + [ + "model", + "stochastic_structure" + ], + "Defines the default stochastic structure used for investment variables, which will be replaced by more specific definitions", + null + ], + [ + "model__default_investment_temporal_block", + [ + "model", + "temporal_block" + ], + "Defines the default temporal block used for investment variables, which will be replaced by more specific definitions", + null + ], + [ + "model__default_stochastic_structure", + [ + "model", + "stochastic_structure" + ], + "Defines the default stochastic structure used for model variables, which will be replaced by more specific definitions", + null + ], + [ + "model__default_temporal_block", + [ + "model", + "temporal_block" + ], + "Defines the default temporal block used for model variables, which will be replaced by more specific definitions", + null + ], + [ + "model__report", + [ + "model", + "report" + ], + "Determines which reports are written for each model and in turn, which outputs are written for each model", + null + ], + [ + "model__stochastic_structure", + [ + "model", + "stochastic_structure" + ], + "Defines which `stochastic_structure`s are included in which `model`s.", + null + ], + [ + "model__temporal_block", + [ + "model", + "temporal_block" + ], + "Defines which `temporal_block`s are included in which `model`s.", + null + ], + [ + "node__commodity", + [ + "node", + "commodity" + ], + "Define a `commodity` for a `node`. Only a single `commodity` is permitted per `node`", + null + ], + [ + "node__investment_group", + [ + "node", + "investment_group" + ], + "Indicates that a `node` belongs in a `investment_group`.", + null + ], + [ + "node__investment_stochastic_structure", + [ + "node", + "stochastic_structure" + ], + "defines the stochastic structure for node related investments, currently only storages", + null + ], + [ + "node__investment_temporal_block", + [ + "node", + "temporal_block" + ], + "defines the temporal resolution for node related investments, currently only storages", + null + ], + [ + "node__node", + [ + "node", + "node" + ], + "Holds parameters for direct interactions between two `nodes`, e.g. `node_state` diffusion coefficients.", + null + ], + [ + "node__stochastic_structure", + [ + "node", + "stochastic_structure" + ], + "Defines which specific `stochastic_structure` is used by the `node` and all `flow` variables associated with it. Only one `stochastic_structure` is permitted per `node`.", + null + ], + [ + "node__temporal_block", + [ + "node", + "temporal_block" + ], + "Defines the `temporal_blocks` used by the `node` and all the `flow` variables associated with it.", + null + ], + [ + "node__user_constraint", + [ + "node", + "user_constraint" + ], + "specifying this relationship allows a node's demand or node_state to be included in the specified user constraint", + null + ], + [ + "parent_stochastic_scenario__child_stochastic_scenario", + [ + "stochastic_scenario", + "stochastic_scenario" + ], + "Defines the master stochastic direct acyclic graph, meaning how the `stochastic_scenarios` are related to each other.", + null + ], + [ + "report__output", + [ + "report", + "output" + ], + "Output object related to a report object are returned to the output database (if they appear in the model as variables)", + null + ], + [ + "stochastic_structure__stochastic_scenario", + [ + "stochastic_structure", + "stochastic_scenario" + ], + "Defines which `stochastic_scenarios` are included in which `stochastic_structure`, and holds the parameters required for realizing the structure in combination with the `temporal_blocks`.", + null + ], + [ + "unit__commodity", + [ + "unit", + "commodity" + ], + "Holds parameters for `commodities` used by the `unit`.", + null + ], + [ + "unit__from_node", + [ + "unit", + "node" + ], + "Defines the `nodes` the `unit` can take input from, and holds most `unit_flow` variable specific parameters.", + 281470681805657 + ], + [ + "unit__from_node__user_constraint", + [ + "unit", + "node", + "user_constraint" + ], + "Defines which input `unit_flows` are included in the `user_constraint`, and holds their parameters.", + null + ], + [ + "unit__investment_group", + [ + "unit", + "investment_group" + ], + "Indicates that a `unit` belongs in an `investment_group`.", + null + ], + [ + "unit__investment_stochastic_structure", + [ + "unit", + "stochastic_structure" + ], + "Sets the stochastic structure for investment decisions - overrides `model__default_investment_stochastic_structure`.", + null + ], + [ + "unit__investment_temporal_block", + [ + "unit", + "temporal_block" + ], + "Sets the temporal resolution of investment decisions - overrides `model__default_investment_temporal_block`", + null + ], + [ + "unit__node__node", + [ + "unit", + "node", + "node" + ], + "Holds parameters spanning multiple `unit_flow` variables to and from multiple `nodes`.", + null + ], + [ + "unit__to_node", + [ + "unit", + "node" + ], + "Defines the `nodes` the `unit` can output to, and holds most `unit_flow` variable specific parameters.", + 281470681805658 + ], + [ + "unit__to_node__user_constraint", + [ + "unit", + "node", + "user_constraint" + ], + "Defines which output `unit_flows` are included in the `user_constraint`, and holds their parameters.", + null + ], + [ + "unit__user_constraint", + [ + "unit", + "user_constraint" + ], + "Defines which `units_on` variables are included in the `user_constraint`, and holds their parameters.", + null + ], + [ + "units_on__stochastic_structure", + [ + "unit", + "stochastic_structure" + ], + "Defines which specific `stochastic_structure` is used for the `units_on` variable of the `unit`. Only one `stochastic_structure` is permitted per `unit`.", + null + ], + [ + "units_on__temporal_block", + [ + "unit", + "temporal_block" + ], + "Defines which specific `temporal_blocks` are used by the `units_on` variable of the `unit`.", + null + ] + ], + "parameter_value_lists": [ + [ + "balance_type_list", + "balance_type_group" + ], + [ + "balance_type_list", + "balance_type_node" + ], + [ + "balance_type_list", + "balance_type_none" + ], + [ + "boolean_value_list", + false + ], + [ + "boolean_value_list", + true + ], + [ + "commodity_physics_list", + "commodity_physics_lodf" + ], + [ + "commodity_physics_list", + "commodity_physics_none" + ], + [ + "commodity_physics_list", + "commodity_physics_ptdf" + ], + [ + "connection_investment_variable_type_list", + "connection_investment_variable_type_continuous" + ], + [ + "connection_investment_variable_type_list", + "connection_investment_variable_type_integer" + ], + [ + "connection_type_list", + "connection_type_lossless_bidirectional" + ], + [ + "connection_type_list", + "connection_type_normal" + ], + [ + "constraint_sense_list", + "<=" + ], + [ + "constraint_sense_list", + "==" + ], + [ + "constraint_sense_list", + ">=" + ], + [ + "db_lp_solver_list", + "KNITRO.jl" + ], + [ + "db_lp_solver_list", + "CDCS.jl" + ], + [ + "db_lp_solver_list", + "CDDLib.jl" + ], + [ + "db_lp_solver_list", + "Clp.jl" + ], + [ + "db_lp_solver_list", + "COSMO.jl" + ], + [ + "db_lp_solver_list", + "CPLEX.jl" + ], + [ + "db_lp_solver_list", + "CSDP.jl" + ], + [ + "db_lp_solver_list", + "ECOS.jl" + ], + [ + "db_lp_solver_list", + "Xpress.jl" + ], + [ + "db_lp_solver_list", + "GLPK.jl" + ], + [ + "db_lp_solver_list", + "Gurobi.jl" + ], + [ + "db_lp_solver_list", + "HiGHS.jl" + ], + [ + "db_lp_solver_list", + "Hypatia.jl" + ], + [ + "db_lp_solver_list", + "Ipopt.jl" + ], + [ + "db_lp_solver_list", + "MadNLP.jl" + ], + [ + "db_lp_solver_list", + "MosekTools.jl" + ], + [ + "db_lp_solver_list", + "NLopt.jl" + ], + [ + "db_lp_solver_list", + "OSQP.jl" + ], + [ + "db_lp_solver_list", + "ProxSDP.jl" + ], + [ + "db_lp_solver_list", + "SCIP.jl" + ], + [ + "db_lp_solver_list", + "SCS.jl" + ], + [ + "db_lp_solver_list", + "SDPA.jl" + ], + [ + "db_lp_solver_list", + "SDPNAL.jl" + ], + [ + "db_lp_solver_list", + "SDPT3.jl" + ], + [ + "db_lp_solver_list", + "SeDuMi.jl" + ], + [ + "db_mip_solver_list", + "KNITRO.jl" + ], + [ + "db_mip_solver_list", + "Cbc.jl" + ], + [ + "db_mip_solver_list", + "CPLEX.jl" + ], + [ + "db_mip_solver_list", + "HiGHS.jl" + ], + [ + "db_mip_solver_list", + "Xpress.jl" + ], + [ + "db_mip_solver_list", + "GLPK.jl" + ], + [ + "db_mip_solver_list", + "Gurobi.jl" + ], + [ + "db_mip_solver_list", + "Juniper.jl" + ], + [ + "db_mip_solver_list", + "MosekTools.jl" + ], + [ + "db_mip_solver_list", + "SCIP.jl" + ], + [ + "duration_unit_list", + "hour" + ], + [ + "duration_unit_list", + "minute" + ], + [ + "model_type_list", + "spineopt_benders" + ], + [ + "model_type_list", + "spineopt_standard" + ], + [ + "model_type_list", + "spineopt_other" + ], + [ + "model_type_list", + "spineopt_mga" + ], + [ + "node_opf_type_list", + "node_opf_type_normal" + ], + [ + "node_opf_type_list", + "node_opf_type_reference" + ], + [ + "unit_investment_variable_type_list", + "unit_investment_variable_type_continuous" + ], + [ + "unit_investment_variable_type_list", + "unit_investment_variable_type_integer" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_binary" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_integer" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_linear" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_none" + ], + [ + "variable_type_list", + "variable_type_binary" + ], + [ + "variable_type_list", + "variable_type_continuous" + ], + [ + "variable_type_list", + "variable_type_integer" + ], + [ + "write_mps_file_list", + "write_mps_always" + ], + [ + "write_mps_file_list", + "write_mps_never" + ], + [ + "write_mps_file_list", + "write_mps_on_no_solve" + ] + ], + "object_parameters": [ + [ + "commodity", + "commodity_lodf_tolerance", + 0.1, + null, + "The minimum absolute value of the line outage distribution factor (LODF) that is considered meaningful." + ], + [ + "commodity", + "commodity_physics", + "commodity_physics_none", + "commodity_physics_list", + "Defines if the `commodity` follows lodf or ptdf physics." + ], + [ + "commodity", + "commodity_ptdf_threshold", + 0.001, + null, + "The minimum absolute value of the power transfer distribution factor (PTDF) that is considered meaningful." + ], + [ + "commodity", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "commodity", + "mp_min_res_gen_to_demand_ratio", + null, + null, + "Minimum ratio of renewable generation to demand for this commodity - used in the minimum renewable generation constraint within the Benders master problem" + ], + [ + "commodity", + "mp_min_res_gen_to_demand_ratio_slack_penalty", + null, + null, + "Penalty for violating the minimum renewable generation to demand ratio." + ], + [ + "connection", + "candidate_connections", + null, + null, + "The number of connections that may be invested in" + ], + [ + "connection", + "connection_availability_factor", + 1.0, + null, + "Availability of the `connection`, acting as a multiplier on its `connection_capacity`. Typically between 0-1." + ], + [ + "connection", + "connection_contingency", + null, + "boolean_value_list", + "A boolean flag for defining a contingency `connection`." + ], + [ + "connection", + "connection_investment_cost", + null, + null, + "The per unit investment cost for the connection over the `connection_investment_lifetime`" + ], + [ + "connection", + "connection_investment_lifetime", + null, + null, + "Determines the minimum investment lifetime of a connection. Once invested, it remains in service for this long" + ], + [ + "connection", + "connection_investment_variable_type", + "variable_type_integer", + "variable_type_list", + "Determines whether the investment variable is integer `variable_type_integer` or continuous `variable_type_continuous`" + ], + [ + "connection", + "connection_monitored", + false, + "boolean_value_list", + "A boolean flag for defining a contingency `connection`." + ], + [ + "connection", + "connection_reactance", + null, + null, + "The per unit reactance of a `connection`." + ], + [ + "connection", + "connection_reactance_base", + 1, + null, + "If the reactance is given for a p.u. (e.g. p.u. = 100MW), the `connection_reactance_base` can be set to perform this conversion (e.g. *100)." + ], + [ + "connection", + "connection_resistance", + null, + null, + "The per unit resistance of a `connection`." + ], + [ + "connection", + "connection_type", + "connection_type_normal", + "connection_type_list", + "A selector between a normal and a lossless bidirectional `connection`." + ], + [ + "connection", + "connections_invested_big_m_mga", + null, + null, + "big_m_mga should be chosen as small as possible but sufficiently large. For units_invested_mga an appropriate big_m_mga would be twice the candidate connections." + ], + [ + "connection", + "connections_invested_mga", + false, + "boolean_value_list", + "Defines whether a certain variable (here: connections_invested) will be considered in the maximal-differences of the mga objective" + ], + [ + "connection", + "connections_invested_mga_weight", + 1, + null, + "Used to scale mga variables. For weightd sum mga method, the length of this weight given as an Array will determine the number of iterations." + ], + [ + "connection", + "fix_connections_invested", + null, + null, + "Setting a value fixes the connections_invested variable accordingly" + ], + [ + "connection", + "fix_connections_invested_available", + null, + null, + "Setting a value fixes the connections_invested_available variable accordingly" + ], + [ + "connection", + "forced_availability_factor", + null, + null, + "Availability factor due to outages/deratings." + ], + [ + "connection", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "connection", + "has_binary_gas_flow", + false, + "boolean_value_list", + "This parameter needs to be set to `true` in order to represent bidirectional pressure drive gas transfer." + ], + [ + "connection", + "initial_connections_invested", + null, + null, + "Setting a value fixes the connections_invested variable at the beginning" + ], + [ + "connection", + "initial_connections_invested_available", + null, + null, + "Setting a value fixes the connections_invested_available variable at the beginning" + ], + [ + "connection", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "model", + "big_m", + 1000000, + null, + "Sufficiently large number used for linearization bilinear terms, e.g. to enforce bidirectional flow for gas pipielines" + ], + [ + "model", + "db_lp_solver", + "HiGHS.jl", + "db_lp_solver_list", + "Solver for MIP problems. Solver package must be added and pre-configured in Julia. Overrides lp_solver RunSpineOpt kwarg" + ], + [ + "model", + "db_lp_solver_options", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "HiGHS.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "presolve", + "on" + ], + [ + "time_limit", + 300.01 + ] + ] + } + ], + [ + "Clp.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "LogLevel", + 0.0 + ] + ] + } + ] + ] + }, + null, + "Map parameter containing LP solver option name option value pairs. See solver documentation for supported solver options" + ], + [ + "model", + "db_mip_solver", + "HiGHS.jl", + "db_mip_solver_list", + "Solver for MIP problems. Solver package must be added and pre-configured in Julia. Overrides mip_solver RunSpineOpt kwarg" + ], + [ + "model", + "db_mip_solver_options", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "HiGHS.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "presolve", + "on" + ], + [ + "mip_rel_gap", + 0.01 + ], + [ + "threads", + 0.0 + ], + [ + "time_limit", + 300.01 + ] + ] + } + ], + [ + "Cbc.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "ratioGap", + 0.01 + ], + [ + "logLevel", + 0.0 + ] + ] + } + ], + [ + "CPLEX.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "CPX_PARAM_EPGAP", + 0.01 + ] + ] + } + ] + ] + }, + null, + "Map parameter containing MIP solver option name option value pairs for MIP. See solver documentation for supported solver options" + ], + [ + "model", + "duration_unit", + "hour", + "duration_unit_list", + "Defines the base temporal unit of the `model`. Currently supported values are either an `hour` or a `minute`." + ], + [ + "model", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "model", + "max_gap", + 0.05, + null, + "Specifies the maximum optimality gap for the model. Currently only used for the master problem within a decomposed structure" + ], + [ + "model", + "max_iterations", + 10.0, + null, + "Specifies the maximum number of iterations for the model. Currently only used for the master problem within a decomposed structure" + ], + [ + "model", + "max_mga_iterations", + null, + null, + "Define the number of mga iterations, i.e. how many alternative solutions will be generated." + ], + [ + "model", + "max_mga_slack", + 0.05, + null, + "Defines the maximum slack by which the alternative solution may differ from the original solution (e.g. 5% more than initial objective function value)" + ], + [ + "model", + "model_end", + { + "type": "date_time", + "data": "2000-01-02T00:00:00" + }, + null, + "Defines the last timestamp to be modelled. Rolling optimization terminates after passing this point." + ], + [ + "model", + "model_start", + { + "type": "date_time", + "data": "2000-01-01T00:00:00" + }, + null, + "Defines the first timestamp to be modelled. Relative `temporal_blocks` refer to this value for their start and end." + ], + [ + "model", + "model_type", + "spineopt_standard", + "model_type_list", + "Used to identify model objects as relating to the master problem or operational sub problems (default)" + ], + [ + "model", + "roll_forward", + null, + null, + "Defines how much the model moves ahead in time between solves in a rolling optimization. Without this parameter, everything is solved in as a single optimization." + ], + [ + "model", + "window_duration", + null, + null, + "The duration of the window in case it differs from roll_forward" + ], + [ + "model", + "window_weight", + 1, + null, + "The weight of the window in the rolling subproblem" + ], + [ + "model", + "write_lodf_file", + false, + "boolean_value_list", + "A boolean flag for whether the LODF values should be written to a results file." + ], + [ + "model", + "write_mps_file", + null, + "write_mps_file_list", + "A selector for writing an .mps file of the model." + ], + [ + "model", + "write_ptdf_file", + false, + "boolean_value_list", + "A boolean flag for whether the LODF values should be written to a results file." + ], + [ + "node", + "balance_type", + "balance_type_node", + "balance_type_list", + "A selector for how the `:nodal_balance` constraint should be handled." + ], + [ + "node", + "candidate_storages", + null, + null, + "Determines the maximum number of new storages which may be invested in" + ], + [ + "node", + "demand", + 0.0, + null, + "Demand for the `commodity` of a `node`. Energy gains can be represented using negative `demand`." + ], + [ + "node", + "downward_reserve", + false, + null, + "Identifier for `node`s providing downward reserves" + ], + [ + "node", + "fix_node_pressure", + null, + null, + "Fixes the corresponding `node_pressure` variable to the provided value" + ], + [ + "node", + "fix_node_state", + null, + null, + "Fixes the corresponding `node_state` variable to the provided value. Can be used for e.g. fixing boundary conditions." + ], + [ + "node", + "fix_node_voltage_angle", + null, + null, + "Fixes the corresponding `node_voltage_angle` variable to the provided value" + ], + [ + "node", + "fix_storages_invested", + null, + null, + "Used to fix the value of the storages_invested variable" + ], + [ + "node", + "fix_storages_invested_available", + null, + null, + "Used to fix the value of the storages_invested_available variable" + ], + [ + "node", + "frac_state_loss", + 0.0, + null, + "Self-discharge coefficient for `node_state` variables. Effectively, represents the *loss power per unit of state*." + ], + [ + "node", + "fractional_demand", + 0.0, + null, + "The fraction of a `node` group's `demand` applied for the `node` in question." + ], + [ + "node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "node", + "has_pressure", + false, + "boolean_value_list", + "A boolean flag for whether a `node` has a `node_pressure` variable." + ], + [ + "node", + "has_state", + false, + "boolean_value_list", + "A boolean flag for whether a `node` has a `node_state` variable." + ], + [ + "node", + "has_voltage_angle", + false, + "boolean_value_list", + "A boolean flag for whether a `node` has a `node_voltage_angle` variable." + ], + [ + "node", + "initial_node_pressure", + null, + null, + "Initializes the corresponding `node_pressure` variable to the provided value" + ], + [ + "node", + "initial_node_state", + null, + null, + "Initializes the corresponding `node_state` variable to the provided value." + ], + [ + "node", + "initial_node_voltage_angle", + null, + null, + "Initializes the corresponding `node_voltage_angle` variable to the provided value" + ], + [ + "node", + "initial_storages_invested", + null, + null, + "Used to initialze the value of the storages_invested variable" + ], + [ + "node", + "initial_storages_invested_available", + null, + null, + "Used to initialze the value of the storages_invested_available variable" + ], + [ + "node", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "node", + "is_non_spinning", + false, + "boolean_value_list", + "A boolean flag for whether a `node` is acting as a non-spinning reserve" + ], + [ + "node", + "is_reserve_node", + false, + "boolean_value_list", + "A boolean flag for whether a `node` is acting as a `reserve_node`" + ], + [ + "node", + "max_node_pressure", + null, + null, + "Maximum allowed gas pressure at `node`." + ], + [ + "node", + "max_voltage_angle", + null, + null, + "Maximum allowed voltage angle at `node`." + ], + [ + "node", + "min_node_pressure", + null, + null, + "Minimum allowed gas pressure at `node`." + ], + [ + "node", + "min_voltage_angle", + null, + null, + "Minimum allowed voltage angle at `node`. " + ], + [ + "node", + "minimum_reserve_activation_time", + null, + null, + "Duration a certain reserve product needs to be online/available" + ], + [ + "node", + "nodal_balance_sense", + "==", + "constraint_sense_list", + "A selector for `nodal_balance` constraint sense." + ], + [ + "node", + "node_opf_type", + "node_opf_type_normal", + "node_opf_type_list", + "A selector for the reference `node` (slack bus) when PTDF-based DC load-flow is enabled." + ], + [ + "node", + "node_slack_penalty", + null, + null, + "A penalty cost for `node_slack_pos` and `node_slack_neg` variables. The slack variables won't be included in the model unless there's a cost defined for them." + ], + [ + "node", + "node_state_cap", + null, + null, + "The maximum permitted value for a `node_state` variable." + ], + [ + "node", + "node_state_min", + 0.0, + null, + "The minimum permitted value for a `node_state` variable." + ], + [ + "node", + "state_coeff", + 1.0, + null, + "Represents the `commodity` content of a `node_state` variable in respect to the `unit_flow` and `connection_flow` variables. Essentially, acts as a coefficient on the `node_state` variable in the `:node_injection` constraint." + ], + [ + "node", + "storage_investment_cost", + null, + null, + "Determines the investment cost per unit state_cap over the investment life of a storage" + ], + [ + "node", + "storage_investment_lifetime", + null, + null, + "Minimum lifetime for storage investment decisions." + ], + [ + "node", + "storage_investment_variable_type", + "variable_type_integer", + "variable_type_list", + "Determines whether the storage investment variable is continuous (usually representing capacity) or integer (representing discrete units invested)" + ], + [ + "node", + "storages_invested_big_m_mga", + null, + null, + "big_m_mga should be chosen as small as possible but sufficiently large. For units_invested_mga an appropriate big_m_mga would be twice the candidate storages." + ], + [ + "node", + "storages_invested_mga", + false, + "boolean_value_list", + "Defines whether a certain variable (here: storages_invested) will be considered in the maximal-differences of the mga objective" + ], + [ + "node", + "storages_invested_mga_weight", + 1, + null, + "Used to scale mga variables. For weighted-sum mga method, the length of this weight given as an Array will determine the number of iterations." + ], + [ + "node", + "tax_in_unit_flow", + null, + null, + "Tax costs for incoming `unit_flows` on this `node`. E.g. EUR/MWh." + ], + [ + "node", + "tax_net_unit_flow", + null, + null, + "Tax costs for net incoming and outgoing `unit_flows` on this `node`. Incoming flows accrue positive net taxes, and outgoing flows accrue negative net taxes." + ], + [ + "node", + "tax_out_unit_flow", + null, + null, + "Tax costs for outgoing `unit_flows` from this `node`. E.g. EUR/MWh." + ], + [ + "node", + "upward_reserve", + false, + null, + "Identifier for `node`s providing upward reserves" + ], + [ + "output", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "output", + "output_resolution", + null, + null, + "Temporal resolution of the output variables associated with this `output`." + ], + [ + "report", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "report", + "output_db_url", + null, + null, + "Database url for SpineOpt output." + ], + [ + "settings", + "version", + 8, + null, + "Current version of the SpineOpt data structure. Modify it at your own risk (but please don't)." + ], + [ + "stochastic_scenario", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "stochastic_structure", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "temporal_block", + "block_end", + null, + null, + "The end time for the `temporal_block`. Can be given either as a `DateTime` for a static end point, or as a `Duration` for an end point relative to the start of the current optimization." + ], + [ + "temporal_block", + "block_start", + null, + null, + "The start time for the `temporal_block`. Can be given either as a `DateTime` for a static start point, or as a `Duration` for an start point relative to the start of the current optimization." + ], + [ + "temporal_block", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "temporal_block", + "representative_periods_mapping", + null, + null, + "Map from date time to representative temporal block name" + ], + [ + "temporal_block", + "resolution", + { + "type": "duration", + "data": "1h" + }, + null, + "Temporal resolution of the `temporal_block`. Essentially, divides the period between `block_start` and `block_end` into `TimeSlices` with the input `resolution`." + ], + [ + "temporal_block", + "weight", + 1.0, + null, + "Weighting factor of the temporal block associated with the objective function" + ], + [ + "unit", + "candidate_units", + null, + null, + "Number of units which may be additionally constructed" + ], + [ + "unit", + "curtailment_cost", + null, + null, + "Costs for curtailing generation. Essentially, accrues costs whenever `unit_flow` not operating at its maximum available capacity. E.g. EUR/MWh" + ], + [ + "unit", + "fix_units_invested", + null, + null, + "Fix the value of the `units_invested` variable." + ], + [ + "unit", + "fix_units_invested_available", + null, + null, + "Fix the value of the `units_invested_available` variable" + ], + [ + "unit", + "fix_units_on", + null, + null, + "Fix the value of the `units_on` variable." + ], + [ + "unit", + "fom_cost", + null, + null, + "Fixed operation and maintenance costs of a `unit`. Essentially, a cost coefficient on the existing units (incl. `number_of_units` and `units_invested_available`) and `unit_capacity` parameters. E.g. EUR/MWh" + ], + [ + "unit", + "forced_availability_factor", + null, + null, + "Availability factor due to outages/deratings." + ], + [ + "unit", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit", + "initial_units_invested", + null, + null, + "Initialize the value of the `units_invested` variable." + ], + [ + "unit", + "initial_units_invested_available", + null, + null, + "Initialize the value of the `units_invested_available` variable" + ], + [ + "unit", + "initial_units_on", + null, + null, + "Initialize the value of the `units_on` variable." + ], + [ + "unit", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "unit", + "is_renewable", + false, + "boolean_value_list", + "Whether the unit is renewable - used in the minimum renewable generation constraint within the Benders master problem" + ], + [ + "unit", + "min_down_time", + null, + null, + "Minimum downtime of a `unit` after it shuts down." + ], + [ + "unit", + "min_up_time", + null, + null, + "Minimum uptime of a `unit` after it starts up." + ], + [ + "unit", + "number_of_units", + 1.0, + null, + "Denotes the number of 'sub units' aggregated to form the modelled `unit`." + ], + [ + "unit", + "online_variable_type", + "unit_online_variable_type_linear", + "unit_online_variable_type_list", + "A selector for how the `units_on` variable is represented within the model." + ], + [ + "unit", + "shut_down_cost", + null, + null, + "Costs of shutting down a 'sub unit', e.g. EUR/shutdown." + ], + [ + "unit", + "start_up_cost", + null, + null, + "Costs of starting up a 'sub unit', e.g. EUR/startup." + ], + [ + "unit", + "unit_availability_factor", + 1.0, + null, + "Availability of the `unit`, acting as a multiplier on its `unit_capacity`. Typically between 0-1." + ], + [ + "unit", + "unit_investment_cost", + null, + null, + "Investment cost per 'sub unit' built." + ], + [ + "unit", + "unit_investment_lifetime", + null, + null, + "Minimum lifetime for unit investment decisions." + ], + [ + "unit", + "unit_investment_variable_type", + "unit_investment_variable_type_continuous", + "unit_investment_variable_type_list", + "Determines whether investment variable is integer or continuous." + ], + [ + "unit", + "units_invested_big_m_mga", + null, + null, + "big_m_mga should be chosen as small as possible but sufficiently large. For units_invested_mga an appropriate big_m_mga would be twice the candidate units." + ], + [ + "unit", + "units_invested_mga", + false, + "boolean_value_list", + "Defines whether a certain variable (here: units_invested) will be considered in the maximal-differences of the mga objective" + ], + [ + "unit", + "units_invested_mga_weight", + 1, + null, + "Used to scale mga variables. For weightd sum mga method, the length of this weight given as an Array will determine the number of iterations." + ], + [ + "unit", + "units_on_cost", + null, + null, + "Objective function coefficient on `units_on`. An idling cost, for example" + ], + [ + "unit", + "units_on_non_anticipativity_margin", + null, + null, + "Margin by which `units_on` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "unit", + "units_on_non_anticipativity_time", + null, + null, + "Period of time where the value of the `units_on` variable has to be fixed to the result from the previous window." + ], + [ + "user_constraint", + "constraint_sense", + "==", + "constraint_sense_list", + "A selector for the sense of the `user_constraint`." + ], + [ + "user_constraint", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "user_constraint", + "right_hand_side", + 0.0, + null, + "The right-hand side, constant term in a `user_constraint`. Can be time-dependent and used e.g. for complicated efficiency approximations." + ] + ], + "relationship_parameters": [ + [ + "connection__from_node", + "connection_capacity", + null, + null, + "Limits the `connection_flow` variable from the `from_node`. `from_node` can be a group of `nodes`, in which case the sum of the `connection_flow` is constrained." + ], + [ + "connection__from_node", + "connection_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `connection_capacity` unit conversions in the case that the `connection_capacity` value is incompatible with the desired `connection_flow` units." + ], + [ + "connection__from_node", + "connection_emergency_capacity", + null, + null, + "Post contingency flow capacity of a `connection`. Sometimes referred to as emergency rating" + ], + [ + "connection__from_node", + "connection_flow_cost", + null, + null, + "Variable costs of a flow through a `connection`. E.g. EUR/MWh of energy throughput." + ], + [ + "connection__from_node", + "connection_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__from_node", + "connection_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__from_node", + "connection_intact_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_intact_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__from_node", + "connection_intact_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_intact_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__from_node", + "fix_binary_gas_connection_flow", + null, + null, + "Fix the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__from_node", + "fix_connection_flow", + null, + null, + "Fix the value of the `connection_flow` variable." + ], + [ + "connection__from_node", + "fix_connection_intact_flow", + null, + null, + "Fix the value of the `connection_intact_flow` variable." + ], + [ + "connection__from_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "connection__from_node", + "initial_binary_gas_connection_flow", + null, + null, + "Initialize the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__from_node", + "initial_connection_flow", + null, + null, + "Initialize the value of the `connection_flow` variable." + ], + [ + "connection__from_node", + "initial_connection_intact_flow", + null, + null, + "Initialize the value of the `connection_intact_flow` variable." + ], + [ + "connection__from_node__user_constraint", + "connection_flow_coefficient", + 0.0, + null, + "defines the user constraint coefficient on the connection flow variable in the from direction" + ], + [ + "connection__node__node", + "compression_factor", + null, + null, + "The compression factor establishes a compression from an origin node to a receiving node, which are connected through a connection. The first node corresponds to the origin node, the second to the (compressed) destination node. Typically the value is >=1." + ], + [ + "connection__node__node", + "connection_flow_delay", + { + "type": "duration", + "data": "0h" + }, + null, + "Delays the `connection_flows` associated with the latter `node` in respect to the `connection_flows` associated with the first `node`." + ], + [ + "connection__node__node", + "connection_linepack_constant", + null, + null, + "The linepack constant is a property of gas pipelines and relates the linepack to the pressure of the adjacent nodes." + ], + [ + "connection__node__node", + "fix_ratio_out_in_connection_flow", + null, + null, + "Fix the ratio between the `connection_flow` from the first `node` and the `connection_flow` to the second `node`." + ], + [ + "connection__node__node", + "fixed_pressure_constant_0", + null, + null, + "Fixed pressure points for pipelines for the outer approximation of the Weymouth approximation. The direction of flow is the first node in the relationship to the second node in the relationship." + ], + [ + "connection__node__node", + "fixed_pressure_constant_1", + null, + null, + "Fixed pressure points for pipelines for the outer approximation of the Weymouth approximation. The direction of flow is the first node in the relationship to the second node in the relationship." + ], + [ + "connection__node__node", + "max_ratio_out_in_connection_flow", + null, + null, + "Maximum ratio between the `connection_flow` from the first `node` and the `connection_flow` to the second `node`." + ], + [ + "connection__node__node", + "min_ratio_out_in_connection_flow", + null, + null, + "Minimum ratio between the `connection_flow` from the first `node` and the `connection_flow` to the second `node`." + ], + [ + "connection__to_node", + "connection_capacity", + null, + null, + "Limits the `connection_flow` variable to the `to_node`. `to_node` can be a group of `nodes`, in which case the sum of the `connection_flow` is constrained." + ], + [ + "connection__to_node", + "connection_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `connection_capacity` unit conversions in the case the `connection_capacity` value is incompatible with the desired `connection_flow` units." + ], + [ + "connection__to_node", + "connection_emergency_capacity", + null, + null, + "The maximum post-contingency flow on a monitored `connection`." + ], + [ + "connection__to_node", + "connection_flow_cost", + null, + null, + "Variable costs of a flow through a `connection`. E.g. EUR/MWh of energy throughput." + ], + [ + "connection__to_node", + "connection_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__to_node", + "connection_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__to_node", + "connection_intact_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_intact_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__to_node", + "connection_intact_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_intact_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__to_node", + "fix_binary_gas_connection_flow", + null, + null, + "Fix the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__to_node", + "fix_connection_flow", + null, + null, + "Fix the value of the `connection_flow` variable." + ], + [ + "connection__to_node", + "fix_connection_intact_flow", + null, + null, + "Fix the value of the `connection_intact_flow` variable." + ], + [ + "connection__to_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "connection__to_node", + "initial_binary_gas_connection_flow", + null, + null, + "Initialize the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__to_node", + "initial_connection_flow", + null, + null, + "Initialize the value of the `connection_flow` variable." + ], + [ + "connection__to_node", + "initial_connection_intact_flow", + null, + null, + "Initialize the value of the `connection_intact_flow` variable." + ], + [ + "connection__to_node__user_constraint", + "connection_flow_coefficient", + 0.0, + null, + "defines the user constraint coefficient on the connection flow variable in the to direction" + ], + [ + "connection__user_constraint", + "connections_invested_available_coefficient", + 0.0, + null, + "coefficient of `connections_invested_available` in the specific `user_constraint`" + ], + [ + "connection__user_constraint", + "connections_invested_coefficient", + 0.0, + null, + "coefficient of `connections_invested` in the specific `user_constraint`" + ], + [ + "node__node", + "diff_coeff", + 0.0, + null, + "Commodity diffusion coefficient between two `nodes`. Effectively, denotes the *diffusion power per unit of state* from the first `node` to the second." + ], + [ + "node__stochastic_structure", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "node__temporal_block", + "cyclic_condition", + false, + "boolean_value_list", + "If the cyclic condition is set to true for a storage node, the `node_state` at the end of the optimization window has to be larger than or equal to the initial storage state." + ], + [ + "node__temporal_block", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "node__user_constraint", + "demand_coefficient", + 0.0, + null, + "coefficient of the specified node's demand in the specified user constraint" + ], + [ + "node__user_constraint", + "node_state_coefficient", + 0.0, + null, + "Coefficient of the specified node's state variable in the specified user constraint." + ], + [ + "node__user_constraint", + "storages_invested_available_coefficient", + 0.0, + null, + "Coefficient of the specified node's storages invested available variable in the specified user constraint." + ], + [ + "node__user_constraint", + "storages_invested_coefficient", + 0.0, + null, + "Coefficient of the specified node's storage investment variable in the specified user constraint." + ], + [ + "report__output", + "overwrite_results_on_rolling", + true, + null, + "Whether or not results from further windows should overwrite results from previous ones." + ], + [ + "stochastic_structure__stochastic_scenario", + "stochastic_scenario_end", + null, + null, + "A `Duration` for when a `stochastic_scenario` ends and its `child_stochastic_scenarios` start. Values are interpreted relative to the start of the current solve, and if no value is given, the `stochastic_scenario` is assumed to continue indefinitely." + ], + [ + "stochastic_structure__stochastic_scenario", + "weight_relative_to_parents", + 1.0, + null, + "The weight of the `stochastic_scenario` in the objective function relative to its parents." + ], + [ + "unit__commodity", + "max_cum_in_unit_flow_bound", + null, + null, + "Set a maximum cumulative upper bound for a `unit_flow`" + ], + [ + "unit__from_node", + "fix_nonspin_ramp_up_unit_flow", + null, + null, + "Fix the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "fix_nonspin_units_started_up", + null, + null, + "Fix the `nonspin_units_started_up` variable." + ], + [ + "unit__from_node", + "fix_ramp_up_unit_flow", + null, + null, + "Fix the `ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "fix_start_up_unit_flow", + null, + null, + "Fix the `start_up_unit_flow` variable." + ], + [ + "unit__from_node", + "fix_unit_flow", + null, + null, + "Fix the `unit_flow` variable." + ], + [ + "unit__from_node", + "fix_unit_flow_op", + null, + null, + "Fix the `unit_flow_op` variable." + ], + [ + "unit__from_node", + "fuel_cost", + null, + null, + "Variable fuel costs than can be attributed to a `unit_flow`. E.g. EUR/MWh" + ], + [ + "unit__from_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__from_node", + "initial_nonspin_ramp_up_unit_flow", + null, + null, + "Initialize the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "initial_nonspin_units_started_up", + null, + null, + "Initialize the `nonspin_units_started_up` variable." + ], + [ + "unit__from_node", + "initial_ramp_up_unit_flow", + null, + null, + "Initialize the `ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "initial_start_up_unit_flow", + null, + null, + "Initialize the `start_up_unit_flow` variable." + ], + [ + "unit__from_node", + "initial_unit_flow", + null, + null, + "Initialize the `unit_flow` variable." + ], + [ + "unit__from_node", + "initial_unit_flow_op", + null, + null, + "Initialize the `unit_flow_op` variable." + ], + [ + "unit__from_node", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "unit__from_node", + "max_res_shutdown_ramp", + null, + null, + "Max. downward reserve ramp for online units scheduled to shut down for reserve provision" + ], + [ + "unit__from_node", + "max_res_startup_ramp", + null, + null, + "Maximum non-spinning reserve ramp-up for startups." + ], + [ + "unit__from_node", + "max_shutdown_ramp", + null, + null, + "Max. downward ramp for units shutting down" + ], + [ + "unit__from_node", + "max_startup_ramp", + null, + null, + "Maximum ramp-up during startups." + ], + [ + "unit__from_node", + "max_total_cumulated_unit_flow_from_node", + null, + null, + "Bound on the maximum cumulated flows of a unit group from a node group e.g max consumption of certain commodity." + ], + [ + "unit__from_node", + "min_res_shutdown_ramp", + null, + null, + "Minimum non-spinning reserve ramp-down for online units providing reserves during shut-downs" + ], + [ + "unit__from_node", + "min_res_startup_ramp", + null, + null, + "Minimum non-spinning reserve ramp-up for startups." + ], + [ + "unit__from_node", + "min_shutdown_ramp", + null, + null, + "Minimum ramp-up during startups" + ], + [ + "unit__from_node", + "min_startup_ramp", + null, + null, + "Minimum ramp-up during startups." + ], + [ + "unit__from_node", + "min_total_cumulated_unit_flow_from_node", + null, + null, + "Bound on the minimum cumulated flows of a unit group from a node group." + ], + [ + "unit__from_node", + "min_unit_flow", + 0.0, + null, + "Set lower bound of the `unit_flow` variable." + ], + [ + "unit__from_node", + "minimum_operating_point", + null, + null, + "Minimum level for the `unit_flow` relative to the `units_on` online capacity." + ], + [ + "unit__from_node", + "operating_points", + null, + null, + "Operating points for piecewise-linear `unit` efficiency approximations." + ], + [ + "unit__from_node", + "ordered_unit_flow_op", + false, + "boolean_value_list", + "Defines whether the segments of this unit flow are ordered as per the rank of their operating points." + ], + [ + "unit__from_node", + "ramp_down_cost", + null, + null, + "Costs for ramping down" + ], + [ + "unit__from_node", + "ramp_down_limit", + null, + null, + "Limit the maximum ramp-down rate of an online unit, given as a fraction of the unit_capacity. [ramp_down_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__from_node", + "ramp_up_cost", + null, + null, + "Costs for ramping up" + ], + [ + "unit__from_node", + "ramp_up_limit", + null, + null, + "Limit the maximum ramp-up rate of an online unit, given as a fraction of the unit_capacity. [ramp_up_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__from_node", + "reserve_procurement_cost", + null, + null, + "Procurement cost for reserves" + ], + [ + "unit__from_node", + "unit_capacity", + null, + null, + "Maximum `unit_flow` capacity of a single 'sub_unit' of the `unit`." + ], + [ + "unit__from_node", + "unit_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `unit_capacity` unit conversions in the case the `unit_capacity` value is incompatible with the desired `unit_flow` units." + ], + [ + "unit__from_node", + "unit_flow_non_anticipativity_margin", + null, + null, + "Margin by which `unit_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "unit__from_node", + "unit_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `unit_flow` variable has to be fixed to the result from the previous window." + ], + [ + "unit__from_node", + "vom_cost", + null, + null, + "Variable operating costs of a `unit_flow` variable. E.g. EUR/MWh." + ], + [ + "unit__from_node__user_constraint", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__from_node__user_constraint", + "unit_flow_coefficient", + 0.0, + null, + "Coefficient of a `unit_flow` variable for a custom `user_constraint`." + ], + [ + "unit__node__node", + "fix_ratio_in_in_unit_flow", + null, + null, + "Fix the ratio between two `unit_flows` coming into the `unit` from the two `nodes`." + ], + [ + "unit__node__node", + "fix_ratio_in_out_unit_flow", + null, + null, + "Fix the ratio between an incoming `unit_flow` from the first `node` and an outgoing `unit_flow` to the second `node`." + ], + [ + "unit__node__node", + "fix_ratio_out_in_unit_flow", + null, + null, + "Fix the ratio between an outgoing `unit_flow` to the first `node` and an incoming `unit_flow` from the second `node`." + ], + [ + "unit__node__node", + "fix_ratio_out_out_unit_flow", + null, + null, + "Fix the ratio between two `unit_flows` going from the `unit` into the two `nodes`." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_in_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_in_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_in_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_in_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_out_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_out_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_out_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_out_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_ratio_in_in_unit_flow", + null, + null, + "Maximum ratio between two `unit_flows` coming into the `unit` from the two `nodes`." + ], + [ + "unit__node__node", + "max_ratio_in_out_unit_flow", + null, + null, + "Maximum ratio between an incoming `unit_flow` from the first `node` and an outgoing `unit_flow` to the second `node`." + ], + [ + "unit__node__node", + "max_ratio_out_in_unit_flow", + null, + null, + "Maximum ratio between an outgoing `unit_flow` to the first `node` and an incoming `unit_flow` from the second `node`." + ], + [ + "unit__node__node", + "max_ratio_out_out_unit_flow", + null, + null, + "Maximum ratio between two `unit_flows` going from the `unit` into the two `nodes`." + ], + [ + "unit__node__node", + "max_units_on_coefficient_in_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_in_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_units_on_coefficient_in_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_in_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_units_on_coefficient_out_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_out_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_units_on_coefficient_out_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_out_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_ratio_in_in_unit_flow", + null, + null, + "Minimum ratio between two `unit_flows` coming into the `unit` from the two `nodes`." + ], + [ + "unit__node__node", + "min_ratio_in_out_unit_flow", + null, + null, + "Minimum ratio between an incoming `unit_flow` from the first `node` and an outgoing `unit_flow` to the second `node`." + ], + [ + "unit__node__node", + "min_ratio_out_in_unit_flow", + null, + null, + "Minimum ratio between an outgoing `unit_flow` to the first `node` and an incoming `unit_flow` from the second `node`." + ], + [ + "unit__node__node", + "min_ratio_out_out_unit_flow", + null, + null, + "Minimum ratio between two `unit_flows` going from the `unit` into the two `nodes`." + ], + [ + "unit__node__node", + "min_units_on_coefficient_in_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_in_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_units_on_coefficient_in_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_in_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_units_on_coefficient_out_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_out_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_units_on_coefficient_out_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_out_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "unit_idle_heat_rate", + 0.0, + null, + "Flow from node1 per unit time and per `units_on` that results in no additional flow to node2" + ], + [ + "unit__node__node", + "unit_incremental_heat_rate", + null, + null, + "Standard piecewise incremental heat rate where node1 is assumed to be the fuel and node2 is assumed to be electriciy. Assumed monotonically increasing. Array type or single coefficient where the number of coefficients must match the dimensions of `unit_operating_points`" + ], + [ + "unit__node__node", + "unit_start_flow", + 0.0, + null, + "Flow from node1 that is incurred when a unit is started up." + ], + [ + "unit__to_node", + "fix_nonspin_ramp_down_unit_flow", + null, + null, + "Fix the `nonspin_ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_nonspin_ramp_up_unit_flow", + null, + null, + "Fix the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_nonspin_units_shut_down", + null, + null, + "Fix the `nonspin_units_shut_down` variable." + ], + [ + "unit__to_node", + "fix_nonspin_units_started_up", + null, + null, + "Fix the `nonspin_units_started_up` variable." + ], + [ + "unit__to_node", + "fix_ramp_down_unit_flow", + null, + null, + "Fix the `ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_ramp_up_unit_flow", + null, + null, + "Fix the `ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_shut_down_unit_flow", + null, + null, + "Fix the `shut_down_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_start_up_unit_flow", + null, + null, + "Fix the `start_up_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_unit_flow", + null, + null, + "Fix the `unit_flow` variable." + ], + [ + "unit__to_node", + "fix_unit_flow_op", + null, + null, + "Fix the `unit_flow_op` variable." + ], + [ + "unit__to_node", + "fuel_cost", + null, + null, + "Variable fuel costs than can be attributed to a `unit_flow`. E.g. EUR/MWh" + ], + [ + "unit__to_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__to_node", + "initial_nonspin_ramp_down_unit_flow", + null, + null, + "Initialize the `nonspin_ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_nonspin_ramp_up_unit_flow", + null, + null, + "Initialize the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_nonspin_units_shut_down", + null, + null, + "Initialize the `nonspin_units_shut_down` variable." + ], + [ + "unit__to_node", + "initial_nonspin_units_started_up", + null, + null, + "Initialize the `nonspin_units_started_up` variable." + ], + [ + "unit__to_node", + "initial_ramp_down_unit_flow", + null, + null, + "Initialize the `ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_ramp_up_unit_flow", + null, + null, + "Initialize the `ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_shut_down_unit_flow", + null, + null, + "Initialize the `shut_down_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_start_up_unit_flow", + null, + null, + "Initialize the `start_up_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_unit_flow", + null, + null, + "Initialize the `unit_flow` variable." + ], + [ + "unit__to_node", + "initial_unit_flow_op", + null, + null, + "Initialize the `unit_flow_op` variable." + ], + [ + "unit__to_node", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "unit__to_node", + "max_res_shutdown_ramp", + null, + null, + "Maximum non-spinning reserve ramp-down for online units providing reserves during shut-downs" + ], + [ + "unit__to_node", + "max_res_startup_ramp", + null, + null, + "Maximum non-spinning reserve ramp-up for offline units scheduled for reserve provision" + ], + [ + "unit__to_node", + "max_shutdown_ramp", + null, + null, + "Maximum ramp-down during shutdowns" + ], + [ + "unit__to_node", + "max_startup_ramp", + null, + null, + "Maximum ramp-up during startups" + ], + [ + "unit__to_node", + "max_total_cumulated_unit_flow_to_node", + null, + null, + "Bound on the maximum cumulated flows of a unit group to a node group, e.g. total GHG emissions." + ], + [ + "unit__to_node", + "min_res_shutdown_ramp", + null, + null, + "Minimum non-spinning reserve ramp-down for online units providing reserves during shut-downs" + ], + [ + "unit__to_node", + "min_res_startup_ramp", + null, + null, + "Minimum non-spinning reserve ramp-up for offline units scheduled for reserve provision" + ], + [ + "unit__to_node", + "min_shutdown_ramp", + null, + null, + "Minimum ramp-up during startups" + ], + [ + "unit__to_node", + "min_startup_ramp", + null, + null, + "Minimum ramp-up during startups" + ], + [ + "unit__to_node", + "min_total_cumulated_unit_flow_to_node", + null, + null, + "Bound on the minimum cumulated flows of a unit group to a node group, e.g. total renewable production." + ], + [ + "unit__to_node", + "min_unit_flow", + 0.0, + null, + "Set lower bound of the `unit_flow` variable." + ], + [ + "unit__to_node", + "minimum_operating_point", + null, + null, + "Minimum level for the `unit_flow` relative to the `units_on` online capacity." + ], + [ + "unit__to_node", + "operating_points", + null, + null, + "Decomposes the flow variable into a number of separate operating segment variables. Used to in conjunction with `unit_incremental_heat_rate` and/or `user_constraint`s" + ], + [ + "unit__to_node", + "ordered_unit_flow_op", + false, + "boolean_value_list", + "Defines whether the segments of this unit flow are ordered as per the rank of their operating points." + ], + [ + "unit__to_node", + "ramp_down_cost", + null, + null, + "Costs of ramping down" + ], + [ + "unit__to_node", + "ramp_down_limit", + null, + null, + "Limit the maximum ramp-down rate of an online unit, given as a fraction of the unit_capacity. [ramp_down_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__to_node", + "ramp_up_cost", + null, + null, + "Costs of ramping up" + ], + [ + "unit__to_node", + "ramp_up_limit", + null, + null, + "Limit the maximum ramp-up rate of an online unit, given as a fraction of the unit_capacity. [ramp_up_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__to_node", + "reserve_procurement_cost", + null, + null, + "Procurement cost for reserves" + ], + [ + "unit__to_node", + "unit_capacity", + null, + null, + "Maximum `unit_flow` capacity of a single 'sub_unit' of the `unit`." + ], + [ + "unit__to_node", + "unit_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `unit_capacity` unit conversions in the case the `unit_capacity` value is incompatible with the desired `unit_flow` units." + ], + [ + "unit__to_node", + "unit_flow_non_anticipativity_margin", + null, + null, + "Margin by which `unit_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "unit__to_node", + "unit_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `unit_flow` variable has to be fixed to the result from the previous window." + ], + [ + "unit__to_node", + "vom_cost", + null, + null, + "Variable operating costs of a `unit_flow` variable. E.g. EUR/MWh." + ], + [ + "unit__to_node__user_constraint", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__to_node__user_constraint", + "unit_flow_coefficient", + 0.0, + null, + "Coefficient of a `unit_flow` variable for a custom `user_constraint`." + ], + [ + "unit__user_constraint", + "units_invested_available_coefficient", + 0.0, + null, + "Coefficient of the `units_invested_available` variable in the specified `user_constraint`." + ], + [ + "unit__user_constraint", + "units_invested_coefficient", + 0.0, + null, + "Coefficient of the `units_invested` variable in the specified `user_constraint`." + ], + [ + "unit__user_constraint", + "units_on_coefficient", + 0.0, + null, + "Coefficient of a `units_on` variable for a custom `user_constraint`." + ], + [ + "unit__user_constraint", + "units_started_up_coefficient", + 0.0, + null, + "Coefficient of a `units_started_up` variable for a custom `user_constraint`." + ], + [ + "units_on__stochastic_structure", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "units_on__temporal_block", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ] + ], + "objects": [ + [ + "model", + "simple", + null + ], + [ + "node", + "electricity_node", + null + ], + [ + "node", + "fuel_node", + null + ], + [ + "node", + "upward_reserve_group", + null + ], + [ + "node", + "upward_reserve_node", + null + ], + [ + "output", + "binary_gas_connection_flow", + null + ], + [ + "output", + "connection_avg_intact_throughflow", + null + ], + [ + "output", + "connection_avg_throughflow", + null + ], + [ + "output", + "connection_flow", + null + ], + [ + "output", + "connection_flow_costs", + null + ], + [ + "output", + "connection_intact_flow", + null + ], + [ + "output", + "connection_investment_costs", + null + ], + [ + "output", + "connections_decommissioned", + null + ], + [ + "output", + "connections_invested", + null + ], + [ + "output", + "connections_invested_available", + null + ], + [ + "output", + "contingency_is_binding", + null + ], + [ + "output", + "fixed_om_costs", + null + ], + [ + "output", + "fuel_costs", + null + ], + [ + "output", + "mga_objective", + null + ], + [ + "output", + "mp_objective_lowerbound", + null + ], + [ + "output", + "node_injection", + null + ], + [ + "output", + "node_pressure", + null + ], + [ + "output", + "node_slack_neg", + null + ], + [ + "output", + "node_slack_pos", + null + ], + [ + "output", + "node_state", + null + ], + [ + "output", + "node_voltage_angle", + null + ], + [ + "output", + "nonspin_ramp_down_unit_flow", + null + ], + [ + "output", + "nonspin_ramp_up_unit_flow", + null + ], + [ + "output", + "nonspin_units_shut_down", + null + ], + [ + "output", + "nonspin_units_started_up", + null + ], + [ + "output", + "objective_penalties", + null + ], + [ + "output", + "ramp_costs", + null + ], + [ + "output", + "ramp_down_unit_flow", + null + ], + [ + "output", + "ramp_up_unit_flow", + null + ], + [ + "output", + "renewable_curtailment_costs", + null + ], + [ + "output", + "res_proc_costs", + null + ], + [ + "output", + "shut_down_costs", + null + ], + [ + "output", + "shut_down_unit_flow", + null + ], + [ + "output", + "start_up_costs", + null + ], + [ + "output", + "start_up_unit_flow", + null + ], + [ + "output", + "storage_investment_costs", + null + ], + [ + "output", + "storages_decommissioned", + null + ], + [ + "output", + "storages_invested", + null + ], + [ + "output", + "storages_invested_available", + null + ], + [ + "output", + "taxes", + null + ], + [ + "output", + "total_costs", + null + ], + [ + "output", + "unit_flow", + null + ], + [ + "output", + "unit_flow_op", + null + ], + [ + "output", + "unit_flow_op_active", + null + ], + [ + "output", + "unit_investment_costs", + null + ], + [ + "output", + "units_available", + null + ], + [ + "output", + "units_invested", + null + ], + [ + "output", + "units_invested_available", + null + ], + [ + "output", + "units_mothballed", + null + ], + [ + "output", + "units_on", + null + ], + [ + "output", + "units_on_costs", + null + ], + [ + "output", + "units_shut_down", + null + ], + [ + "output", + "units_started_up", + null + ], + [ + "output", + "variable_om_costs", + null + ], + [ + "report", + "report1", + null + ], + [ + "stochastic_scenario", + "realization", + null + ], + [ + "stochastic_structure", + "deterministic", + null + ], + [ + "temporal_block", + "flat", + null + ], + [ + "unit", + "power_plant_a", + null + ], + [ + "unit", + "power_plant_b", + null + ] + ], + "relationships": [ + [ + "model__default_stochastic_structure", + [ + "simple", + "deterministic" + ] + ], + [ + "model__default_temporal_block", + [ + "simple", + "flat" + ] + ], + [ + "model__report", + [ + "simple", + "report1" + ] + ], + [ + "model__stochastic_structure", + [ + "simple", + "deterministic" + ] + ], + [ + "model__temporal_block", + [ + "simple", + "flat" + ] + ], + [ + "report__output", + [ + "report1", + "res_proc_costs" + ] + ], + [ + "report__output", + [ + "report1", + "unit_flow" + ] + ], + [ + "report__output", + [ + "report1", + "variable_om_costs" + ] + ], + [ + "stochastic_structure__stochastic_scenario", + [ + "deterministic", + "realization" + ] + ], + [ + "unit__from_node", + [ + "power_plant_a", + "fuel_node" + ] + ], + [ + "unit__from_node", + [ + "power_plant_b", + "fuel_node" + ] + ], + [ + "unit__node__node", + [ + "power_plant_a", + "electricity_node", + "fuel_node" + ] + ], + [ + "unit__node__node", + [ + "power_plant_b", + "electricity_node", + "fuel_node" + ] + ], + [ + "unit__to_node", + [ + "power_plant_a", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "power_plant_a", + "upward_reserve_group" + ] + ], + [ + "unit__to_node", + [ + "power_plant_a", + "upward_reserve_node" + ] + ], + [ + "unit__to_node", + [ + "power_plant_b", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "power_plant_b", + "upward_reserve_group" + ] + ], + [ + "unit__to_node", + [ + "power_plant_b", + "upward_reserve_node" + ] + ] + ], + "object_groups": [ + [ + "node", + "upward_reserve_group", + "electricity_node" + ], + [ + "node", + "upward_reserve_group", + "upward_reserve_node" + ] + ], + "object_parameter_values": [ + [ + "node", + "electricity_node", + "demand", + 150.0, + "Base" + ], + [ + "node", + "fuel_node", + "balance_type", + "balance_type_none", + "Base" + ], + [ + "node", + "upward_reserve_group", + "balance_type", + "balance_type_none", + "Base" + ], + [ + "node", + "upward_reserve_node", + "demand", + 20, + "Base" + ], + [ + "node", + "upward_reserve_node", + "is_reserve_node", + true, + "Base" + ], + [ + "node", + "upward_reserve_node", + "nodal_balance_sense", + ">=", + "Base" + ], + [ + "node", + "upward_reserve_node", + "upward_reserve", + true, + "Base" + ], + [ + "temporal_block", + "flat", + "resolution", + { + "type": "duration", + "data": "1D" + }, + "Base" + ] + ], + "relationship_parameter_values": [ + [ + "unit__from_node", + [ + "power_plant_a", + "fuel_node" + ], + "vom_cost", + 25, + "Base" + ], + [ + "unit__from_node", + [ + "power_plant_b", + "fuel_node" + ], + "vom_cost", + 50, + "Base" + ], + [ + "unit__node__node", + [ + "power_plant_a", + "electricity_node", + "fuel_node" + ], + "fix_ratio_out_in_unit_flow", + 0.7, + "Base" + ], + [ + "unit__node__node", + [ + "power_plant_b", + "electricity_node", + "fuel_node" + ], + "fix_ratio_out_in_unit_flow", + 0.8, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_a", + "electricity_node" + ], + "unit_capacity", + 100, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_a", + "upward_reserve_group" + ], + "ramp_up_limit", + 1, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_a", + "upward_reserve_group" + ], + "unit_capacity", + 100.0, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_a", + "upward_reserve_node" + ], + "reserve_procurement_cost", + 5, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_a", + "upward_reserve_node" + ], + "unit_capacity", + 100, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_b", + "electricity_node" + ], + "unit_capacity", + 200.0, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_b", + "upward_reserve_group" + ], + "ramp_up_limit", + 1, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_b", + "upward_reserve_group" + ], + "unit_capacity", + 200.0, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_b", + "upward_reserve_node" + ], + "reserve_procurement_cost", + 35, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_b", + "upward_reserve_node" + ], + "unit_capacity", + 200.0, + "Base" + ] + ], + "alternatives": [ + [ + "Base", + "Base alternative" + ] + ], + "tools": [ + [ + "object_activity_control", + "" + ] + ], + "features": [ + [ + "commodity", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "connection", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "model", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "node", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "node__stochastic_structure", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "node__temporal_block", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "output", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "report", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "stochastic_scenario", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "stochastic_structure", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "temporal_block", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "unit", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "unit__from_node", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "unit__to_node", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "units_on__stochastic_structure", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "units_on__temporal_block", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "user_constraint", + "is_active", + "boolean_value_list", + "boolean_value_list" + ] + ], + "tool_features": [ + [ + "object_activity_control", + "commodity", + "is_active", + false + ], + [ + "object_activity_control", + "connection", + "is_active", + false + ], + [ + "object_activity_control", + "model", + "is_active", + false + ], + [ + "object_activity_control", + "node", + "is_active", + false + ], + [ + "object_activity_control", + "node__stochastic_structure", + "is_active", + false + ], + [ + "object_activity_control", + "node__temporal_block", + "is_active", + false + ], + [ + "object_activity_control", + "output", + "is_active", + false + ], + [ + "object_activity_control", + "report", + "is_active", + false + ], + [ + "object_activity_control", + "stochastic_scenario", + "is_active", + false + ], + [ + "object_activity_control", + "stochastic_structure", + "is_active", + false + ], + [ + "object_activity_control", + "temporal_block", + "is_active", + false + ], + [ + "object_activity_control", + "unit", + "is_active", + false + ], + [ + "object_activity_control", + "unit__from_node", + "is_active", + false + ], + [ + "object_activity_control", + "unit__to_node", + "is_active", + false + ], + [ + "object_activity_control", + "units_on__stochastic_structure", + "is_active", + false + ], + [ + "object_activity_control", + "units_on__temporal_block", + "is_active", + false + ], + [ + "object_activity_control", + "user_constraint", + "is_active", + false + ] + ], + "tool_feature_methods": [ + [ + "object_activity_control", + "commodity", + "is_active", + true + ], + [ + "object_activity_control", + "connection", + "is_active", + true + ], + [ + "object_activity_control", + "model", + "is_active", + true + ], + [ + "object_activity_control", + "node", + "is_active", + true + ], + [ + "object_activity_control", + "node__stochastic_structure", + "is_active", + true + ], + [ + "object_activity_control", + "node__temporal_block", + "is_active", + true + ], + [ + "object_activity_control", + "output", + "is_active", + true + ], + [ + "object_activity_control", + "report", + "is_active", + true + ], + [ + "object_activity_control", + "stochastic_scenario", + "is_active", + true + ], + [ + "object_activity_control", + "stochastic_structure", + "is_active", + true + ], + [ + "object_activity_control", + "temporal_block", + "is_active", + true + ], + [ + "object_activity_control", + "unit", + "is_active", + true + ], + [ + "object_activity_control", + "unit__from_node", + "is_active", + true + ], + [ + "object_activity_control", + "unit__to_node", + "is_active", + true + ], + [ + "object_activity_control", + "units_on__stochastic_structure", + "is_active", + true + ], + [ + "object_activity_control", + "units_on__temporal_block", + "is_active", + true + ], + [ + "object_activity_control", + "user_constraint", + "is_active", + true + ] + ] +} \ No newline at end of file diff --git a/examples/simple_system.json b/examples/simple_system.json new file mode 100644 index 0000000000..7198600f8a --- /dev/null +++ b/examples/simple_system.json @@ -0,0 +1,3845 @@ +{ + "object_classes": [ + [ + "commodity", + "A good or product that can be consumed, produced, traded. E.g., electricity, oil, gas, water...", + 281473533932880 + ], + [ + "connection", + "A transfer of commodities between nodes. E.g. electricity line, gas pipeline...", + 280378317271233 + ], + [ + "investment_group", + "A group of investments that need to be done together.", + 281105609585860 + ], + [ + "model", + "An instance of SpineOpt, that specifies general parameters such as the temporal horizon.", + 281107035648412 + ], + [ + "node", + "A universal aggregator of commodify flows over units and connections, with storage capabilities.", + 280740554077951 + ], + [ + "output", + "A variable name from SpineOpt that can be included in a report.", + 280743406202948 + ], + [ + "report", + "A results report from a particular SpineOpt run, including the value of specific variables.", + 281108461711708 + ], + [ + "settings", + "Internal SpineOpt settings. We kindly advise not to mess with this one.", + 280375465144798 + ], + [ + "stochastic_scenario", + "A scenario for stochastic optimisation in SpineOpt.", + 280743389491710 + ], + [ + "stochastic_structure", + "A group of stochastic scenarios that represent a structure.", + 281470681806146 + ], + [ + "temporal_block", + "A length of time with a particular resolution.", + 280376891207703 + ], + [ + "unit", + "A conversion of one/many comodities between nodes.", + 281470681805429 + ], + [ + "user_constraint", + "A generic data-driven custom constraint.", + 281473533931636 + ] + ], + "relationship_classes": [ + [ + "connection__from_node", + [ + "connection", + "node" + ], + "Defines the `nodes` the `connection` can take input from, and holds most `connection_flow` variable specific parameters.", + 280378317271897 + ], + [ + "connection__from_node__user_constraint", + [ + "connection", + "node", + "user_constraint" + ], + "when specified this relationship allows the relevant flow connection flow variable to be included in the specified user constraint", + null + ], + [ + "connection__investment_group", + [ + "connection", + "investment_group" + ], + "Indicates that a `connection` belongs in an `investment_group`.", + null + ], + [ + "connection__investment_stochastic_structure", + [ + "connection", + "stochastic_structure" + ], + "Defines the stochastic structure of the connections investments variable", + null + ], + [ + "connection__investment_temporal_block", + [ + "connection", + "temporal_block" + ], + "Defines the temporal resolution of the connections investments variable", + null + ], + [ + "connection__node__node", + [ + "connection", + "node", + "node" + ], + "Holds parameters spanning multiple `connection_flow` variables to and from multiple `nodes`.", + null + ], + [ + "connection__to_node", + [ + "connection", + "node" + ], + "Defines the `nodes` the `connection` can output to, and holds most `connection_flow` variable specific parameters.", + 280378317271898 + ], + [ + "connection__to_node__user_constraint", + [ + "connection", + "node", + "user_constraint" + ], + "when specified this relationship allows the relevant flow connection flow variable to be included in the specified user constraint", + null + ], + [ + "connection__user_constraint", + [ + "connection", + "user_constraint" + ], + "Relationship required to involve a connections investment variables in a user_constraint", + null + ], + [ + "model__default_investment_stochastic_structure", + [ + "model", + "stochastic_structure" + ], + "Defines the default stochastic structure used for investment variables, which will be replaced by more specific definitions", + null + ], + [ + "model__default_investment_temporal_block", + [ + "model", + "temporal_block" + ], + "Defines the default temporal block used for investment variables, which will be replaced by more specific definitions", + null + ], + [ + "model__default_stochastic_structure", + [ + "model", + "stochastic_structure" + ], + "Defines the default stochastic structure used for model variables, which will be replaced by more specific definitions", + null + ], + [ + "model__default_temporal_block", + [ + "model", + "temporal_block" + ], + "Defines the default temporal block used for model variables, which will be replaced by more specific definitions", + null + ], + [ + "model__report", + [ + "model", + "report" + ], + "Determines which reports are written for each model and in turn, which outputs are written for each model", + null + ], + [ + "model__stochastic_structure", + [ + "model", + "stochastic_structure" + ], + "Defines which `stochastic_structure`s are included in which `model`s.", + null + ], + [ + "model__temporal_block", + [ + "model", + "temporal_block" + ], + "Defines which `temporal_block`s are included in which `model`s.", + null + ], + [ + "node__commodity", + [ + "node", + "commodity" + ], + "Define a `commodity` for a `node`. Only a single `commodity` is permitted per `node`", + null + ], + [ + "node__investment_group", + [ + "node", + "investment_group" + ], + "Indicates that a `node` belongs in a `investment_group`.", + null + ], + [ + "node__investment_stochastic_structure", + [ + "node", + "stochastic_structure" + ], + "defines the stochastic structure for node related investments, currently only storages", + null + ], + [ + "node__investment_temporal_block", + [ + "node", + "temporal_block" + ], + "defines the temporal resolution for node related investments, currently only storages", + null + ], + [ + "node__node", + [ + "node", + "node" + ], + "Holds parameters for direct interactions between two `nodes`, e.g. `node_state` diffusion coefficients.", + null + ], + [ + "node__stochastic_structure", + [ + "node", + "stochastic_structure" + ], + "Defines which specific `stochastic_structure` is used by the `node` and all `flow` variables associated with it. Only one `stochastic_structure` is permitted per `node`.", + null + ], + [ + "node__temporal_block", + [ + "node", + "temporal_block" + ], + "Defines the `temporal_blocks` used by the `node` and all the `flow` variables associated with it.", + null + ], + [ + "node__user_constraint", + [ + "node", + "user_constraint" + ], + "specifying this relationship allows a node's demand or node_state to be included in the specified user constraint", + null + ], + [ + "parent_stochastic_scenario__child_stochastic_scenario", + [ + "stochastic_scenario", + "stochastic_scenario" + ], + "Defines the master stochastic direct acyclic graph, meaning how the `stochastic_scenarios` are related to each other.", + null + ], + [ + "report__output", + [ + "report", + "output" + ], + "Output object related to a report object are returned to the output database (if they appear in the model as variables)", + null + ], + [ + "stochastic_structure__stochastic_scenario", + [ + "stochastic_structure", + "stochastic_scenario" + ], + "Defines which `stochastic_scenarios` are included in which `stochastic_structure`, and holds the parameters required for realizing the structure in combination with the `temporal_blocks`.", + null + ], + [ + "unit__commodity", + [ + "unit", + "commodity" + ], + "Holds parameters for `commodities` used by the `unit`.", + null + ], + [ + "unit__from_node", + [ + "unit", + "node" + ], + "Defines the `nodes` the `unit` can take input from, and holds most `unit_flow` variable specific parameters.", + 281470681805657 + ], + [ + "unit__from_node__user_constraint", + [ + "unit", + "node", + "user_constraint" + ], + "Defines which input `unit_flows` are included in the `user_constraint`, and holds their parameters.", + null + ], + [ + "unit__investment_group", + [ + "unit", + "investment_group" + ], + "Indicates that a `unit` belongs in an `investment_group`.", + null + ], + [ + "unit__investment_stochastic_structure", + [ + "unit", + "stochastic_structure" + ], + "Sets the stochastic structure for investment decisions - overrides `model__default_investment_stochastic_structure`.", + null + ], + [ + "unit__investment_temporal_block", + [ + "unit", + "temporal_block" + ], + "Sets the temporal resolution of investment decisions - overrides `model__default_investment_temporal_block`", + null + ], + [ + "unit__node__node", + [ + "unit", + "node", + "node" + ], + "Holds parameters spanning multiple `unit_flow` variables to and from multiple `nodes`.", + null + ], + [ + "unit__to_node", + [ + "unit", + "node" + ], + "Defines the `nodes` the `unit` can output to, and holds most `unit_flow` variable specific parameters.", + 281470681805658 + ], + [ + "unit__to_node__user_constraint", + [ + "unit", + "node", + "user_constraint" + ], + "Defines which output `unit_flows` are included in the `user_constraint`, and holds their parameters.", + null + ], + [ + "unit__user_constraint", + [ + "unit", + "user_constraint" + ], + "Defines which `units_on` variables are included in the `user_constraint`, and holds their parameters.", + null + ], + [ + "units_on__stochastic_structure", + [ + "unit", + "stochastic_structure" + ], + "Defines which specific `stochastic_structure` is used for the `units_on` variable of the `unit`. Only one `stochastic_structure` is permitted per `unit`.", + null + ], + [ + "units_on__temporal_block", + [ + "unit", + "temporal_block" + ], + "Defines which specific `temporal_blocks` are used by the `units_on` variable of the `unit`.", + null + ] + ], + "parameter_value_lists": [ + [ + "balance_type_list", + "balance_type_group" + ], + [ + "balance_type_list", + "balance_type_node" + ], + [ + "balance_type_list", + "balance_type_none" + ], + [ + "boolean_value_list", + false + ], + [ + "boolean_value_list", + true + ], + [ + "commodity_physics_list", + "commodity_physics_lodf" + ], + [ + "commodity_physics_list", + "commodity_physics_none" + ], + [ + "commodity_physics_list", + "commodity_physics_ptdf" + ], + [ + "connection_investment_variable_type_list", + "connection_investment_variable_type_continuous" + ], + [ + "connection_investment_variable_type_list", + "connection_investment_variable_type_integer" + ], + [ + "connection_type_list", + "connection_type_lossless_bidirectional" + ], + [ + "connection_type_list", + "connection_type_normal" + ], + [ + "constraint_sense_list", + "<=" + ], + [ + "constraint_sense_list", + "==" + ], + [ + "constraint_sense_list", + ">=" + ], + [ + "db_lp_solver_list", + "KNITRO.jl" + ], + [ + "db_lp_solver_list", + "CDCS.jl" + ], + [ + "db_lp_solver_list", + "CDDLib.jl" + ], + [ + "db_lp_solver_list", + "Clp.jl" + ], + [ + "db_lp_solver_list", + "COSMO.jl" + ], + [ + "db_lp_solver_list", + "CPLEX.jl" + ], + [ + "db_lp_solver_list", + "CSDP.jl" + ], + [ + "db_lp_solver_list", + "ECOS.jl" + ], + [ + "db_lp_solver_list", + "Xpress.jl" + ], + [ + "db_lp_solver_list", + "GLPK.jl" + ], + [ + "db_lp_solver_list", + "Gurobi.jl" + ], + [ + "db_lp_solver_list", + "HiGHS.jl" + ], + [ + "db_lp_solver_list", + "Hypatia.jl" + ], + [ + "db_lp_solver_list", + "Ipopt.jl" + ], + [ + "db_lp_solver_list", + "MadNLP.jl" + ], + [ + "db_lp_solver_list", + "MosekTools.jl" + ], + [ + "db_lp_solver_list", + "NLopt.jl" + ], + [ + "db_lp_solver_list", + "OSQP.jl" + ], + [ + "db_lp_solver_list", + "ProxSDP.jl" + ], + [ + "db_lp_solver_list", + "SCIP.jl" + ], + [ + "db_lp_solver_list", + "SCS.jl" + ], + [ + "db_lp_solver_list", + "SDPA.jl" + ], + [ + "db_lp_solver_list", + "SDPNAL.jl" + ], + [ + "db_lp_solver_list", + "SDPT3.jl" + ], + [ + "db_lp_solver_list", + "SeDuMi.jl" + ], + [ + "db_mip_solver_list", + "KNITRO.jl" + ], + [ + "db_mip_solver_list", + "Cbc.jl" + ], + [ + "db_mip_solver_list", + "CPLEX.jl" + ], + [ + "db_mip_solver_list", + "HiGHS.jl" + ], + [ + "db_mip_solver_list", + "Xpress.jl" + ], + [ + "db_mip_solver_list", + "GLPK.jl" + ], + [ + "db_mip_solver_list", + "Gurobi.jl" + ], + [ + "db_mip_solver_list", + "Juniper.jl" + ], + [ + "db_mip_solver_list", + "MosekTools.jl" + ], + [ + "db_mip_solver_list", + "SCIP.jl" + ], + [ + "duration_unit_list", + "hour" + ], + [ + "duration_unit_list", + "minute" + ], + [ + "model_type_list", + "spineopt_benders" + ], + [ + "model_type_list", + "spineopt_standard" + ], + [ + "model_type_list", + "spineopt_other" + ], + [ + "model_type_list", + "spineopt_mga" + ], + [ + "node_opf_type_list", + "node_opf_type_normal" + ], + [ + "node_opf_type_list", + "node_opf_type_reference" + ], + [ + "unit_investment_variable_type_list", + "unit_investment_variable_type_continuous" + ], + [ + "unit_investment_variable_type_list", + "unit_investment_variable_type_integer" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_binary" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_integer" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_linear" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_none" + ], + [ + "variable_type_list", + "variable_type_binary" + ], + [ + "variable_type_list", + "variable_type_continuous" + ], + [ + "variable_type_list", + "variable_type_integer" + ], + [ + "write_mps_file_list", + "write_mps_always" + ], + [ + "write_mps_file_list", + "write_mps_never" + ], + [ + "write_mps_file_list", + "write_mps_on_no_solve" + ] + ], + "object_parameters": [ + [ + "commodity", + "commodity_lodf_tolerance", + 0.1, + null, + "The minimum absolute value of the line outage distribution factor (LODF) that is considered meaningful." + ], + [ + "commodity", + "commodity_physics", + "commodity_physics_none", + "commodity_physics_list", + "Defines if the `commodity` follows lodf or ptdf physics." + ], + [ + "commodity", + "commodity_ptdf_threshold", + 0.001, + null, + "The minimum absolute value of the power transfer distribution factor (PTDF) that is considered meaningful." + ], + [ + "commodity", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "commodity", + "mp_min_res_gen_to_demand_ratio", + null, + null, + "Minimum ratio of renewable generation to demand for this commodity - used in the minimum renewable generation constraint within the Benders master problem" + ], + [ + "commodity", + "mp_min_res_gen_to_demand_ratio_slack_penalty", + null, + null, + "Penalty for violating the minimum renewable generation to demand ratio." + ], + [ + "connection", + "candidate_connections", + null, + null, + "The number of connections that may be invested in" + ], + [ + "connection", + "connection_availability_factor", + 1.0, + null, + "Availability of the `connection`, acting as a multiplier on its `connection_capacity`. Typically between 0-1." + ], + [ + "connection", + "connection_contingency", + null, + "boolean_value_list", + "A boolean flag for defining a contingency `connection`." + ], + [ + "connection", + "connection_investment_cost", + null, + null, + "The per unit investment cost for the connection over the `connection_investment_lifetime`" + ], + [ + "connection", + "connection_investment_lifetime", + null, + null, + "Determines the minimum investment lifetime of a connection. Once invested, it remains in service for this long" + ], + [ + "connection", + "connection_investment_variable_type", + "variable_type_integer", + "variable_type_list", + "Determines whether the investment variable is integer `variable_type_integer` or continuous `variable_type_continuous`" + ], + [ + "connection", + "connection_monitored", + false, + "boolean_value_list", + "A boolean flag for defining a contingency `connection`." + ], + [ + "connection", + "connection_reactance", + null, + null, + "The per unit reactance of a `connection`." + ], + [ + "connection", + "connection_reactance_base", + 1, + null, + "If the reactance is given for a p.u. (e.g. p.u. = 100MW), the `connection_reactance_base` can be set to perform this conversion (e.g. *100)." + ], + [ + "connection", + "connection_resistance", + null, + null, + "The per unit resistance of a `connection`." + ], + [ + "connection", + "connection_type", + "connection_type_normal", + "connection_type_list", + "A selector between a normal and a lossless bidirectional `connection`." + ], + [ + "connection", + "connections_invested_big_m_mga", + null, + null, + "big_m_mga should be chosen as small as possible but sufficiently large. For units_invested_mga an appropriate big_m_mga would be twice the candidate connections." + ], + [ + "connection", + "connections_invested_mga", + false, + "boolean_value_list", + "Defines whether a certain variable (here: connections_invested) will be considered in the maximal-differences of the mga objective" + ], + [ + "connection", + "connections_invested_mga_weight", + 1, + null, + "Used to scale mga variables. For weightd sum mga method, the length of this weight given as an Array will determine the number of iterations." + ], + [ + "connection", + "fix_connections_invested", + null, + null, + "Setting a value fixes the connections_invested variable accordingly" + ], + [ + "connection", + "fix_connections_invested_available", + null, + null, + "Setting a value fixes the connections_invested_available variable accordingly" + ], + [ + "connection", + "forced_availability_factor", + null, + null, + "Availability factor due to outages/deratings." + ], + [ + "connection", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "connection", + "has_binary_gas_flow", + false, + "boolean_value_list", + "This parameter needs to be set to `true` in order to represent bidirectional pressure drive gas transfer." + ], + [ + "connection", + "initial_connections_invested", + null, + null, + "Setting a value fixes the connections_invested variable at the beginning" + ], + [ + "connection", + "initial_connections_invested_available", + null, + null, + "Setting a value fixes the connections_invested_available variable at the beginning" + ], + [ + "connection", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "model", + "big_m", + 1000000, + null, + "Sufficiently large number used for linearization bilinear terms, e.g. to enforce bidirectional flow for gas pipielines" + ], + [ + "model", + "db_lp_solver", + "HiGHS.jl", + "db_lp_solver_list", + "Solver for MIP problems. Solver package must be added and pre-configured in Julia. Overrides lp_solver RunSpineOpt kwarg" + ], + [ + "model", + "db_lp_solver_options", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "HiGHS.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "presolve", + "on" + ], + [ + "time_limit", + 300.01 + ] + ] + } + ], + [ + "Clp.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "LogLevel", + 0.0 + ] + ] + } + ] + ] + }, + null, + "Map parameter containing LP solver option name option value pairs. See solver documentation for supported solver options" + ], + [ + "model", + "db_mip_solver", + "HiGHS.jl", + "db_mip_solver_list", + "Solver for MIP problems. Solver package must be added and pre-configured in Julia. Overrides mip_solver RunSpineOpt kwarg" + ], + [ + "model", + "db_mip_solver_options", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "HiGHS.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "presolve", + "on" + ], + [ + "mip_rel_gap", + 0.01 + ], + [ + "threads", + 0.0 + ], + [ + "time_limit", + 300.01 + ] + ] + } + ], + [ + "Cbc.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "ratioGap", + 0.01 + ], + [ + "logLevel", + 0.0 + ] + ] + } + ], + [ + "CPLEX.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "CPX_PARAM_EPGAP", + 0.01 + ] + ] + } + ] + ] + }, + null, + "Map parameter containing MIP solver option name option value pairs for MIP. See solver documentation for supported solver options" + ], + [ + "model", + "duration_unit", + "hour", + "duration_unit_list", + "Defines the base temporal unit of the `model`. Currently supported values are either an `hour` or a `minute`." + ], + [ + "model", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "model", + "max_gap", + 0.05, + null, + "Specifies the maximum optimality gap for the model. Currently only used for the master problem within a decomposed structure" + ], + [ + "model", + "max_iterations", + 10.0, + null, + "Specifies the maximum number of iterations for the model. Currently only used for the master problem within a decomposed structure" + ], + [ + "model", + "max_mga_iterations", + null, + null, + "Define the number of mga iterations, i.e. how many alternative solutions will be generated." + ], + [ + "model", + "max_mga_slack", + 0.05, + null, + "Defines the maximum slack by which the alternative solution may differ from the original solution (e.g. 5% more than initial objective function value)" + ], + [ + "model", + "model_end", + { + "type": "date_time", + "data": "2000-01-02T00:00:00" + }, + null, + "Defines the last timestamp to be modelled. Rolling optimization terminates after passing this point." + ], + [ + "model", + "model_start", + { + "type": "date_time", + "data": "2000-01-01T00:00:00" + }, + null, + "Defines the first timestamp to be modelled. Relative `temporal_blocks` refer to this value for their start and end." + ], + [ + "model", + "model_type", + "spineopt_standard", + "model_type_list", + "Used to identify model objects as relating to the master problem or operational sub problems (default)" + ], + [ + "model", + "roll_forward", + null, + null, + "Defines how much the model moves ahead in time between solves in a rolling optimization. Without this parameter, everything is solved in as a single optimization." + ], + [ + "model", + "window_duration", + null, + null, + "The duration of the window in case it differs from roll_forward" + ], + [ + "model", + "window_weight", + 1, + null, + "The weight of the window in the rolling subproblem" + ], + [ + "model", + "write_lodf_file", + false, + "boolean_value_list", + "A boolean flag for whether the LODF values should be written to a results file." + ], + [ + "model", + "write_mps_file", + null, + "write_mps_file_list", + "A selector for writing an .mps file of the model." + ], + [ + "model", + "write_ptdf_file", + false, + "boolean_value_list", + "A boolean flag for whether the LODF values should be written to a results file." + ], + [ + "node", + "balance_type", + "balance_type_node", + "balance_type_list", + "A selector for how the `:nodal_balance` constraint should be handled." + ], + [ + "node", + "candidate_storages", + null, + null, + "Determines the maximum number of new storages which may be invested in" + ], + [ + "node", + "demand", + 0.0, + null, + "Demand for the `commodity` of a `node`. Energy gains can be represented using negative `demand`." + ], + [ + "node", + "downward_reserve", + false, + null, + "Identifier for `node`s providing downward reserves" + ], + [ + "node", + "fix_node_pressure", + null, + null, + "Fixes the corresponding `node_pressure` variable to the provided value" + ], + [ + "node", + "fix_node_state", + null, + null, + "Fixes the corresponding `node_state` variable to the provided value. Can be used for e.g. fixing boundary conditions." + ], + [ + "node", + "fix_node_voltage_angle", + null, + null, + "Fixes the corresponding `node_voltage_angle` variable to the provided value" + ], + [ + "node", + "fix_storages_invested", + null, + null, + "Used to fix the value of the storages_invested variable" + ], + [ + "node", + "fix_storages_invested_available", + null, + null, + "Used to fix the value of the storages_invested_available variable" + ], + [ + "node", + "frac_state_loss", + 0.0, + null, + "Self-discharge coefficient for `node_state` variables. Effectively, represents the *loss power per unit of state*." + ], + [ + "node", + "fractional_demand", + 0.0, + null, + "The fraction of a `node` group's `demand` applied for the `node` in question." + ], + [ + "node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "node", + "has_pressure", + false, + "boolean_value_list", + "A boolean flag for whether a `node` has a `node_pressure` variable." + ], + [ + "node", + "has_state", + false, + "boolean_value_list", + "A boolean flag for whether a `node` has a `node_state` variable." + ], + [ + "node", + "has_voltage_angle", + false, + "boolean_value_list", + "A boolean flag for whether a `node` has a `node_voltage_angle` variable." + ], + [ + "node", + "initial_node_pressure", + null, + null, + "Initializes the corresponding `node_pressure` variable to the provided value" + ], + [ + "node", + "initial_node_state", + null, + null, + "Initializes the corresponding `node_state` variable to the provided value." + ], + [ + "node", + "initial_node_voltage_angle", + null, + null, + "Initializes the corresponding `node_voltage_angle` variable to the provided value" + ], + [ + "node", + "initial_storages_invested", + null, + null, + "Used to initialze the value of the storages_invested variable" + ], + [ + "node", + "initial_storages_invested_available", + null, + null, + "Used to initialze the value of the storages_invested_available variable" + ], + [ + "node", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "node", + "is_non_spinning", + false, + "boolean_value_list", + "A boolean flag for whether a `node` is acting as a non-spinning reserve" + ], + [ + "node", + "is_reserve_node", + false, + "boolean_value_list", + "A boolean flag for whether a `node` is acting as a `reserve_node`" + ], + [ + "node", + "max_node_pressure", + null, + null, + "Maximum allowed gas pressure at `node`." + ], + [ + "node", + "max_voltage_angle", + null, + null, + "Maximum allowed voltage angle at `node`." + ], + [ + "node", + "min_node_pressure", + null, + null, + "Minimum allowed gas pressure at `node`." + ], + [ + "node", + "min_voltage_angle", + null, + null, + "Minimum allowed voltage angle at `node`. " + ], + [ + "node", + "minimum_reserve_activation_time", + null, + null, + "Duration a certain reserve product needs to be online/available" + ], + [ + "node", + "nodal_balance_sense", + "==", + "constraint_sense_list", + "A selector for `nodal_balance` constraint sense." + ], + [ + "node", + "node_opf_type", + "node_opf_type_normal", + "node_opf_type_list", + "A selector for the reference `node` (slack bus) when PTDF-based DC load-flow is enabled." + ], + [ + "node", + "node_slack_penalty", + null, + null, + "A penalty cost for `node_slack_pos` and `node_slack_neg` variables. The slack variables won't be included in the model unless there's a cost defined for them." + ], + [ + "node", + "node_state_cap", + null, + null, + "The maximum permitted value for a `node_state` variable." + ], + [ + "node", + "node_state_min", + 0.0, + null, + "The minimum permitted value for a `node_state` variable." + ], + [ + "node", + "state_coeff", + 1.0, + null, + "Represents the `commodity` content of a `node_state` variable in respect to the `unit_flow` and `connection_flow` variables. Essentially, acts as a coefficient on the `node_state` variable in the `:node_injection` constraint." + ], + [ + "node", + "storage_investment_cost", + null, + null, + "Determines the investment cost per unit state_cap over the investment life of a storage" + ], + [ + "node", + "storage_investment_lifetime", + null, + null, + "Minimum lifetime for storage investment decisions." + ], + [ + "node", + "storage_investment_variable_type", + "variable_type_integer", + "variable_type_list", + "Determines whether the storage investment variable is continuous (usually representing capacity) or integer (representing discrete units invested)" + ], + [ + "node", + "storages_invested_big_m_mga", + null, + null, + "big_m_mga should be chosen as small as possible but sufficiently large. For units_invested_mga an appropriate big_m_mga would be twice the candidate storages." + ], + [ + "node", + "storages_invested_mga", + false, + "boolean_value_list", + "Defines whether a certain variable (here: storages_invested) will be considered in the maximal-differences of the mga objective" + ], + [ + "node", + "storages_invested_mga_weight", + 1, + null, + "Used to scale mga variables. For weighted-sum mga method, the length of this weight given as an Array will determine the number of iterations." + ], + [ + "node", + "tax_in_unit_flow", + null, + null, + "Tax costs for incoming `unit_flows` on this `node`. E.g. EUR/MWh." + ], + [ + "node", + "tax_net_unit_flow", + null, + null, + "Tax costs for net incoming and outgoing `unit_flows` on this `node`. Incoming flows accrue positive net taxes, and outgoing flows accrue negative net taxes." + ], + [ + "node", + "tax_out_unit_flow", + null, + null, + "Tax costs for outgoing `unit_flows` from this `node`. E.g. EUR/MWh." + ], + [ + "node", + "upward_reserve", + false, + null, + "Identifier for `node`s providing upward reserves" + ], + [ + "output", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "output", + "output_resolution", + null, + null, + "Temporal resolution of the output variables associated with this `output`." + ], + [ + "report", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "report", + "output_db_url", + null, + null, + "Database url for SpineOpt output." + ], + [ + "settings", + "version", + 8, + null, + "Current version of the SpineOpt data structure. Modify it at your own risk (but please don't)." + ], + [ + "stochastic_scenario", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "stochastic_structure", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "temporal_block", + "block_end", + null, + null, + "The end time for the `temporal_block`. Can be given either as a `DateTime` for a static end point, or as a `Duration` for an end point relative to the start of the current optimization." + ], + [ + "temporal_block", + "block_start", + null, + null, + "The start time for the `temporal_block`. Can be given either as a `DateTime` for a static start point, or as a `Duration` for an start point relative to the start of the current optimization." + ], + [ + "temporal_block", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "temporal_block", + "representative_periods_mapping", + null, + null, + "Map from date time to representative temporal block name" + ], + [ + "temporal_block", + "resolution", + { + "type": "duration", + "data": "1h" + }, + null, + "Temporal resolution of the `temporal_block`. Essentially, divides the period between `block_start` and `block_end` into `TimeSlices` with the input `resolution`." + ], + [ + "temporal_block", + "weight", + 1.0, + null, + "Weighting factor of the temporal block associated with the objective function" + ], + [ + "unit", + "candidate_units", + null, + null, + "Number of units which may be additionally constructed" + ], + [ + "unit", + "curtailment_cost", + null, + null, + "Costs for curtailing generation. Essentially, accrues costs whenever `unit_flow` not operating at its maximum available capacity. E.g. EUR/MWh" + ], + [ + "unit", + "fix_units_invested", + null, + null, + "Fix the value of the `units_invested` variable." + ], + [ + "unit", + "fix_units_invested_available", + null, + null, + "Fix the value of the `units_invested_available` variable" + ], + [ + "unit", + "fix_units_on", + null, + null, + "Fix the value of the `units_on` variable." + ], + [ + "unit", + "fom_cost", + null, + null, + "Fixed operation and maintenance costs of a `unit`. Essentially, a cost coefficient on the existing units (incl. `number_of_units` and `units_invested_available`) and `unit_capacity` parameters. E.g. EUR/MWh" + ], + [ + "unit", + "forced_availability_factor", + null, + null, + "Availability factor due to outages/deratings." + ], + [ + "unit", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit", + "initial_units_invested", + null, + null, + "Initialize the value of the `units_invested` variable." + ], + [ + "unit", + "initial_units_invested_available", + null, + null, + "Initialize the value of the `units_invested_available` variable" + ], + [ + "unit", + "initial_units_on", + null, + null, + "Initialize the value of the `units_on` variable." + ], + [ + "unit", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "unit", + "is_renewable", + false, + "boolean_value_list", + "Whether the unit is renewable - used in the minimum renewable generation constraint within the Benders master problem" + ], + [ + "unit", + "min_down_time", + null, + null, + "Minimum downtime of a `unit` after it shuts down." + ], + [ + "unit", + "min_up_time", + null, + null, + "Minimum uptime of a `unit` after it starts up." + ], + [ + "unit", + "number_of_units", + 1.0, + null, + "Denotes the number of 'sub units' aggregated to form the modelled `unit`." + ], + [ + "unit", + "online_variable_type", + "unit_online_variable_type_linear", + "unit_online_variable_type_list", + "A selector for how the `units_on` variable is represented within the model." + ], + [ + "unit", + "shut_down_cost", + null, + null, + "Costs of shutting down a 'sub unit', e.g. EUR/shutdown." + ], + [ + "unit", + "start_up_cost", + null, + null, + "Costs of starting up a 'sub unit', e.g. EUR/startup." + ], + [ + "unit", + "unit_availability_factor", + 1.0, + null, + "Availability of the `unit`, acting as a multiplier on its `unit_capacity`. Typically between 0-1." + ], + [ + "unit", + "unit_investment_cost", + null, + null, + "Investment cost per 'sub unit' built." + ], + [ + "unit", + "unit_investment_lifetime", + null, + null, + "Minimum lifetime for unit investment decisions." + ], + [ + "unit", + "unit_investment_variable_type", + "unit_investment_variable_type_continuous", + "unit_investment_variable_type_list", + "Determines whether investment variable is integer or continuous." + ], + [ + "unit", + "units_invested_big_m_mga", + null, + null, + "big_m_mga should be chosen as small as possible but sufficiently large. For units_invested_mga an appropriate big_m_mga would be twice the candidate units." + ], + [ + "unit", + "units_invested_mga", + false, + "boolean_value_list", + "Defines whether a certain variable (here: units_invested) will be considered in the maximal-differences of the mga objective" + ], + [ + "unit", + "units_invested_mga_weight", + 1, + null, + "Used to scale mga variables. For weightd sum mga method, the length of this weight given as an Array will determine the number of iterations." + ], + [ + "unit", + "units_on_cost", + null, + null, + "Objective function coefficient on `units_on`. An idling cost, for example" + ], + [ + "unit", + "units_on_non_anticipativity_margin", + null, + null, + "Margin by which `units_on` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "unit", + "units_on_non_anticipativity_time", + null, + null, + "Period of time where the value of the `units_on` variable has to be fixed to the result from the previous window." + ], + [ + "user_constraint", + "constraint_sense", + "==", + "constraint_sense_list", + "A selector for the sense of the `user_constraint`." + ], + [ + "user_constraint", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "user_constraint", + "right_hand_side", + 0.0, + null, + "The right-hand side, constant term in a `user_constraint`. Can be time-dependent and used e.g. for complicated efficiency approximations." + ] + ], + "relationship_parameters": [ + [ + "connection__from_node", + "connection_capacity", + null, + null, + "Limits the `connection_flow` variable from the `from_node`. `from_node` can be a group of `nodes`, in which case the sum of the `connection_flow` is constrained." + ], + [ + "connection__from_node", + "connection_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `connection_capacity` unit conversions in the case that the `connection_capacity` value is incompatible with the desired `connection_flow` units." + ], + [ + "connection__from_node", + "connection_emergency_capacity", + null, + null, + "Post contingency flow capacity of a `connection`. Sometimes referred to as emergency rating" + ], + [ + "connection__from_node", + "connection_flow_cost", + null, + null, + "Variable costs of a flow through a `connection`. E.g. EUR/MWh of energy throughput." + ], + [ + "connection__from_node", + "connection_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__from_node", + "connection_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__from_node", + "connection_intact_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_intact_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__from_node", + "connection_intact_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_intact_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__from_node", + "fix_binary_gas_connection_flow", + null, + null, + "Fix the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__from_node", + "fix_connection_flow", + null, + null, + "Fix the value of the `connection_flow` variable." + ], + [ + "connection__from_node", + "fix_connection_intact_flow", + null, + null, + "Fix the value of the `connection_intact_flow` variable." + ], + [ + "connection__from_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "connection__from_node", + "initial_binary_gas_connection_flow", + null, + null, + "Initialize the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__from_node", + "initial_connection_flow", + null, + null, + "Initialize the value of the `connection_flow` variable." + ], + [ + "connection__from_node", + "initial_connection_intact_flow", + null, + null, + "Initialize the value of the `connection_intact_flow` variable." + ], + [ + "connection__from_node__user_constraint", + "connection_flow_coefficient", + 0.0, + null, + "defines the user constraint coefficient on the connection flow variable in the from direction" + ], + [ + "connection__node__node", + "compression_factor", + null, + null, + "The compression factor establishes a compression from an origin node to a receiving node, which are connected through a connection. The first node corresponds to the origin node, the second to the (compressed) destination node. Typically the value is >=1." + ], + [ + "connection__node__node", + "connection_flow_delay", + { + "type": "duration", + "data": "0h" + }, + null, + "Delays the `connection_flows` associated with the latter `node` in respect to the `connection_flows` associated with the first `node`." + ], + [ + "connection__node__node", + "connection_linepack_constant", + null, + null, + "The linepack constant is a property of gas pipelines and relates the linepack to the pressure of the adjacent nodes." + ], + [ + "connection__node__node", + "fix_ratio_out_in_connection_flow", + null, + null, + "Fix the ratio between the `connection_flow` from the first `node` and the `connection_flow` to the second `node`." + ], + [ + "connection__node__node", + "fixed_pressure_constant_0", + null, + null, + "Fixed pressure points for pipelines for the outer approximation of the Weymouth approximation. The direction of flow is the first node in the relationship to the second node in the relationship." + ], + [ + "connection__node__node", + "fixed_pressure_constant_1", + null, + null, + "Fixed pressure points for pipelines for the outer approximation of the Weymouth approximation. The direction of flow is the first node in the relationship to the second node in the relationship." + ], + [ + "connection__node__node", + "max_ratio_out_in_connection_flow", + null, + null, + "Maximum ratio between the `connection_flow` from the first `node` and the `connection_flow` to the second `node`." + ], + [ + "connection__node__node", + "min_ratio_out_in_connection_flow", + null, + null, + "Minimum ratio between the `connection_flow` from the first `node` and the `connection_flow` to the second `node`." + ], + [ + "connection__to_node", + "connection_capacity", + null, + null, + "Limits the `connection_flow` variable to the `to_node`. `to_node` can be a group of `nodes`, in which case the sum of the `connection_flow` is constrained." + ], + [ + "connection__to_node", + "connection_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `connection_capacity` unit conversions in the case the `connection_capacity` value is incompatible with the desired `connection_flow` units." + ], + [ + "connection__to_node", + "connection_emergency_capacity", + null, + null, + "The maximum post-contingency flow on a monitored `connection`." + ], + [ + "connection__to_node", + "connection_flow_cost", + null, + null, + "Variable costs of a flow through a `connection`. E.g. EUR/MWh of energy throughput." + ], + [ + "connection__to_node", + "connection_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__to_node", + "connection_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__to_node", + "connection_intact_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_intact_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__to_node", + "connection_intact_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_intact_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__to_node", + "fix_binary_gas_connection_flow", + null, + null, + "Fix the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__to_node", + "fix_connection_flow", + null, + null, + "Fix the value of the `connection_flow` variable." + ], + [ + "connection__to_node", + "fix_connection_intact_flow", + null, + null, + "Fix the value of the `connection_intact_flow` variable." + ], + [ + "connection__to_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "connection__to_node", + "initial_binary_gas_connection_flow", + null, + null, + "Initialize the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__to_node", + "initial_connection_flow", + null, + null, + "Initialize the value of the `connection_flow` variable." + ], + [ + "connection__to_node", + "initial_connection_intact_flow", + null, + null, + "Initialize the value of the `connection_intact_flow` variable." + ], + [ + "connection__to_node__user_constraint", + "connection_flow_coefficient", + 0.0, + null, + "defines the user constraint coefficient on the connection flow variable in the to direction" + ], + [ + "connection__user_constraint", + "connections_invested_available_coefficient", + 0.0, + null, + "coefficient of `connections_invested_available` in the specific `user_constraint`" + ], + [ + "connection__user_constraint", + "connections_invested_coefficient", + 0.0, + null, + "coefficient of `connections_invested` in the specific `user_constraint`" + ], + [ + "node__node", + "diff_coeff", + 0.0, + null, + "Commodity diffusion coefficient between two `nodes`. Effectively, denotes the *diffusion power per unit of state* from the first `node` to the second." + ], + [ + "node__stochastic_structure", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "node__temporal_block", + "cyclic_condition", + false, + "boolean_value_list", + "If the cyclic condition is set to true for a storage node, the `node_state` at the end of the optimization window has to be larger than or equal to the initial storage state." + ], + [ + "node__temporal_block", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "node__user_constraint", + "demand_coefficient", + 0.0, + null, + "coefficient of the specified node's demand in the specified user constraint" + ], + [ + "node__user_constraint", + "node_state_coefficient", + 0.0, + null, + "Coefficient of the specified node's state variable in the specified user constraint." + ], + [ + "node__user_constraint", + "storages_invested_available_coefficient", + 0.0, + null, + "Coefficient of the specified node's storages invested available variable in the specified user constraint." + ], + [ + "node__user_constraint", + "storages_invested_coefficient", + 0.0, + null, + "Coefficient of the specified node's storage investment variable in the specified user constraint." + ], + [ + "report__output", + "overwrite_results_on_rolling", + true, + null, + "Whether or not results from further windows should overwrite results from previous ones." + ], + [ + "stochastic_structure__stochastic_scenario", + "stochastic_scenario_end", + null, + null, + "A `Duration` for when a `stochastic_scenario` ends and its `child_stochastic_scenarios` start. Values are interpreted relative to the start of the current solve, and if no value is given, the `stochastic_scenario` is assumed to continue indefinitely." + ], + [ + "stochastic_structure__stochastic_scenario", + "weight_relative_to_parents", + 1.0, + null, + "The weight of the `stochastic_scenario` in the objective function relative to its parents." + ], + [ + "unit__commodity", + "max_cum_in_unit_flow_bound", + null, + null, + "Set a maximum cumulative upper bound for a `unit_flow`" + ], + [ + "unit__from_node", + "fix_nonspin_ramp_up_unit_flow", + null, + null, + "Fix the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "fix_nonspin_units_started_up", + null, + null, + "Fix the `nonspin_units_started_up` variable." + ], + [ + "unit__from_node", + "fix_ramp_up_unit_flow", + null, + null, + "Fix the `ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "fix_start_up_unit_flow", + null, + null, + "Fix the `start_up_unit_flow` variable." + ], + [ + "unit__from_node", + "fix_unit_flow", + null, + null, + "Fix the `unit_flow` variable." + ], + [ + "unit__from_node", + "fix_unit_flow_op", + null, + null, + "Fix the `unit_flow_op` variable." + ], + [ + "unit__from_node", + "fuel_cost", + null, + null, + "Variable fuel costs than can be attributed to a `unit_flow`. E.g. EUR/MWh" + ], + [ + "unit__from_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__from_node", + "initial_nonspin_ramp_up_unit_flow", + null, + null, + "Initialize the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "initial_nonspin_units_started_up", + null, + null, + "Initialize the `nonspin_units_started_up` variable." + ], + [ + "unit__from_node", + "initial_ramp_up_unit_flow", + null, + null, + "Initialize the `ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "initial_start_up_unit_flow", + null, + null, + "Initialize the `start_up_unit_flow` variable." + ], + [ + "unit__from_node", + "initial_unit_flow", + null, + null, + "Initialize the `unit_flow` variable." + ], + [ + "unit__from_node", + "initial_unit_flow_op", + null, + null, + "Initialize the `unit_flow_op` variable." + ], + [ + "unit__from_node", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "unit__from_node", + "max_res_shutdown_ramp", + null, + null, + "Max. downward reserve ramp for online units scheduled to shut down for reserve provision" + ], + [ + "unit__from_node", + "max_res_startup_ramp", + null, + null, + "Maximum non-spinning reserve ramp-up for startups." + ], + [ + "unit__from_node", + "max_shutdown_ramp", + null, + null, + "Max. downward ramp for units shutting down" + ], + [ + "unit__from_node", + "max_startup_ramp", + null, + null, + "Maximum ramp-up during startups." + ], + [ + "unit__from_node", + "max_total_cumulated_unit_flow_from_node", + null, + null, + "Bound on the maximum cumulated flows of a unit group from a node group e.g max consumption of certain commodity." + ], + [ + "unit__from_node", + "min_res_shutdown_ramp", + null, + null, + "Minimum non-spinning reserve ramp-down for online units providing reserves during shut-downs" + ], + [ + "unit__from_node", + "min_res_startup_ramp", + null, + null, + "Minimum non-spinning reserve ramp-up for startups." + ], + [ + "unit__from_node", + "min_shutdown_ramp", + null, + null, + "Minimum ramp-up during startups" + ], + [ + "unit__from_node", + "min_startup_ramp", + null, + null, + "Minimum ramp-up during startups." + ], + [ + "unit__from_node", + "min_total_cumulated_unit_flow_from_node", + null, + null, + "Bound on the minimum cumulated flows of a unit group from a node group." + ], + [ + "unit__from_node", + "min_unit_flow", + 0.0, + null, + "Set lower bound of the `unit_flow` variable." + ], + [ + "unit__from_node", + "minimum_operating_point", + null, + null, + "Minimum level for the `unit_flow` relative to the `units_on` online capacity." + ], + [ + "unit__from_node", + "operating_points", + null, + null, + "Operating points for piecewise-linear `unit` efficiency approximations." + ], + [ + "unit__from_node", + "ordered_unit_flow_op", + false, + "boolean_value_list", + "Defines whether the segments of this unit flow are ordered as per the rank of their operating points." + ], + [ + "unit__from_node", + "ramp_down_cost", + null, + null, + "Costs for ramping down" + ], + [ + "unit__from_node", + "ramp_down_limit", + null, + null, + "Limit the maximum ramp-down rate of an online unit, given as a fraction of the unit_capacity. [ramp_down_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__from_node", + "ramp_up_cost", + null, + null, + "Costs for ramping up" + ], + [ + "unit__from_node", + "ramp_up_limit", + null, + null, + "Limit the maximum ramp-up rate of an online unit, given as a fraction of the unit_capacity. [ramp_up_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__from_node", + "reserve_procurement_cost", + null, + null, + "Procurement cost for reserves" + ], + [ + "unit__from_node", + "unit_capacity", + null, + null, + "Maximum `unit_flow` capacity of a single 'sub_unit' of the `unit`." + ], + [ + "unit__from_node", + "unit_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `unit_capacity` unit conversions in the case the `unit_capacity` value is incompatible with the desired `unit_flow` units." + ], + [ + "unit__from_node", + "unit_flow_non_anticipativity_margin", + null, + null, + "Margin by which `unit_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "unit__from_node", + "unit_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `unit_flow` variable has to be fixed to the result from the previous window." + ], + [ + "unit__from_node", + "vom_cost", + null, + null, + "Variable operating costs of a `unit_flow` variable. E.g. EUR/MWh." + ], + [ + "unit__from_node__user_constraint", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__from_node__user_constraint", + "unit_flow_coefficient", + 0.0, + null, + "Coefficient of a `unit_flow` variable for a custom `user_constraint`." + ], + [ + "unit__node__node", + "fix_ratio_in_in_unit_flow", + null, + null, + "Fix the ratio between two `unit_flows` coming into the `unit` from the two `nodes`." + ], + [ + "unit__node__node", + "fix_ratio_in_out_unit_flow", + null, + null, + "Fix the ratio between an incoming `unit_flow` from the first `node` and an outgoing `unit_flow` to the second `node`." + ], + [ + "unit__node__node", + "fix_ratio_out_in_unit_flow", + null, + null, + "Fix the ratio between an outgoing `unit_flow` to the first `node` and an incoming `unit_flow` from the second `node`." + ], + [ + "unit__node__node", + "fix_ratio_out_out_unit_flow", + null, + null, + "Fix the ratio between two `unit_flows` going from the `unit` into the two `nodes`." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_in_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_in_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_in_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_in_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_out_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_out_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_out_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_out_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_ratio_in_in_unit_flow", + null, + null, + "Maximum ratio between two `unit_flows` coming into the `unit` from the two `nodes`." + ], + [ + "unit__node__node", + "max_ratio_in_out_unit_flow", + null, + null, + "Maximum ratio between an incoming `unit_flow` from the first `node` and an outgoing `unit_flow` to the second `node`." + ], + [ + "unit__node__node", + "max_ratio_out_in_unit_flow", + null, + null, + "Maximum ratio between an outgoing `unit_flow` to the first `node` and an incoming `unit_flow` from the second `node`." + ], + [ + "unit__node__node", + "max_ratio_out_out_unit_flow", + null, + null, + "Maximum ratio between two `unit_flows` going from the `unit` into the two `nodes`." + ], + [ + "unit__node__node", + "max_units_on_coefficient_in_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_in_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_units_on_coefficient_in_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_in_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_units_on_coefficient_out_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_out_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_units_on_coefficient_out_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_out_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_ratio_in_in_unit_flow", + null, + null, + "Minimum ratio between two `unit_flows` coming into the `unit` from the two `nodes`." + ], + [ + "unit__node__node", + "min_ratio_in_out_unit_flow", + null, + null, + "Minimum ratio between an incoming `unit_flow` from the first `node` and an outgoing `unit_flow` to the second `node`." + ], + [ + "unit__node__node", + "min_ratio_out_in_unit_flow", + null, + null, + "Minimum ratio between an outgoing `unit_flow` to the first `node` and an incoming `unit_flow` from the second `node`." + ], + [ + "unit__node__node", + "min_ratio_out_out_unit_flow", + null, + null, + "Minimum ratio between two `unit_flows` going from the `unit` into the two `nodes`." + ], + [ + "unit__node__node", + "min_units_on_coefficient_in_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_in_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_units_on_coefficient_in_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_in_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_units_on_coefficient_out_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_out_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_units_on_coefficient_out_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_out_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "unit_idle_heat_rate", + 0.0, + null, + "Flow from node1 per unit time and per `units_on` that results in no additional flow to node2" + ], + [ + "unit__node__node", + "unit_incremental_heat_rate", + null, + null, + "Standard piecewise incremental heat rate where node1 is assumed to be the fuel and node2 is assumed to be electriciy. Assumed monotonically increasing. Array type or single coefficient where the number of coefficients must match the dimensions of `unit_operating_points`" + ], + [ + "unit__node__node", + "unit_start_flow", + 0.0, + null, + "Flow from node1 that is incurred when a unit is started up." + ], + [ + "unit__to_node", + "fix_nonspin_ramp_down_unit_flow", + null, + null, + "Fix the `nonspin_ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_nonspin_ramp_up_unit_flow", + null, + null, + "Fix the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_nonspin_units_shut_down", + null, + null, + "Fix the `nonspin_units_shut_down` variable." + ], + [ + "unit__to_node", + "fix_nonspin_units_started_up", + null, + null, + "Fix the `nonspin_units_started_up` variable." + ], + [ + "unit__to_node", + "fix_ramp_down_unit_flow", + null, + null, + "Fix the `ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_ramp_up_unit_flow", + null, + null, + "Fix the `ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_shut_down_unit_flow", + null, + null, + "Fix the `shut_down_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_start_up_unit_flow", + null, + null, + "Fix the `start_up_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_unit_flow", + null, + null, + "Fix the `unit_flow` variable." + ], + [ + "unit__to_node", + "fix_unit_flow_op", + null, + null, + "Fix the `unit_flow_op` variable." + ], + [ + "unit__to_node", + "fuel_cost", + null, + null, + "Variable fuel costs than can be attributed to a `unit_flow`. E.g. EUR/MWh" + ], + [ + "unit__to_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__to_node", + "initial_nonspin_ramp_down_unit_flow", + null, + null, + "Initialize the `nonspin_ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_nonspin_ramp_up_unit_flow", + null, + null, + "Initialize the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_nonspin_units_shut_down", + null, + null, + "Initialize the `nonspin_units_shut_down` variable." + ], + [ + "unit__to_node", + "initial_nonspin_units_started_up", + null, + null, + "Initialize the `nonspin_units_started_up` variable." + ], + [ + "unit__to_node", + "initial_ramp_down_unit_flow", + null, + null, + "Initialize the `ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_ramp_up_unit_flow", + null, + null, + "Initialize the `ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_shut_down_unit_flow", + null, + null, + "Initialize the `shut_down_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_start_up_unit_flow", + null, + null, + "Initialize the `start_up_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_unit_flow", + null, + null, + "Initialize the `unit_flow` variable." + ], + [ + "unit__to_node", + "initial_unit_flow_op", + null, + null, + "Initialize the `unit_flow_op` variable." + ], + [ + "unit__to_node", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "unit__to_node", + "max_res_shutdown_ramp", + null, + null, + "Maximum non-spinning reserve ramp-down for online units providing reserves during shut-downs" + ], + [ + "unit__to_node", + "max_res_startup_ramp", + null, + null, + "Maximum non-spinning reserve ramp-up for offline units scheduled for reserve provision" + ], + [ + "unit__to_node", + "max_shutdown_ramp", + null, + null, + "Maximum ramp-down during shutdowns" + ], + [ + "unit__to_node", + "max_startup_ramp", + null, + null, + "Maximum ramp-up during startups" + ], + [ + "unit__to_node", + "max_total_cumulated_unit_flow_to_node", + null, + null, + "Bound on the maximum cumulated flows of a unit group to a node group, e.g. total GHG emissions." + ], + [ + "unit__to_node", + "min_res_shutdown_ramp", + null, + null, + "Minimum non-spinning reserve ramp-down for online units providing reserves during shut-downs" + ], + [ + "unit__to_node", + "min_res_startup_ramp", + null, + null, + "Minimum non-spinning reserve ramp-up for offline units scheduled for reserve provision" + ], + [ + "unit__to_node", + "min_shutdown_ramp", + null, + null, + "Minimum ramp-up during startups" + ], + [ + "unit__to_node", + "min_startup_ramp", + null, + null, + "Minimum ramp-up during startups" + ], + [ + "unit__to_node", + "min_total_cumulated_unit_flow_to_node", + null, + null, + "Bound on the minimum cumulated flows of a unit group to a node group, e.g. total renewable production." + ], + [ + "unit__to_node", + "min_unit_flow", + 0.0, + null, + "Set lower bound of the `unit_flow` variable." + ], + [ + "unit__to_node", + "minimum_operating_point", + null, + null, + "Minimum level for the `unit_flow` relative to the `units_on` online capacity." + ], + [ + "unit__to_node", + "operating_points", + null, + null, + "Decomposes the flow variable into a number of separate operating segment variables. Used to in conjunction with `unit_incremental_heat_rate` and/or `user_constraint`s" + ], + [ + "unit__to_node", + "ordered_unit_flow_op", + false, + "boolean_value_list", + "Defines whether the segments of this unit flow are ordered as per the rank of their operating points." + ], + [ + "unit__to_node", + "ramp_down_cost", + null, + null, + "Costs of ramping down" + ], + [ + "unit__to_node", + "ramp_down_limit", + null, + null, + "Limit the maximum ramp-down rate of an online unit, given as a fraction of the unit_capacity. [ramp_down_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__to_node", + "ramp_up_cost", + null, + null, + "Costs of ramping up" + ], + [ + "unit__to_node", + "ramp_up_limit", + null, + null, + "Limit the maximum ramp-up rate of an online unit, given as a fraction of the unit_capacity. [ramp_up_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__to_node", + "reserve_procurement_cost", + null, + null, + "Procurement cost for reserves" + ], + [ + "unit__to_node", + "unit_capacity", + null, + null, + "Maximum `unit_flow` capacity of a single 'sub_unit' of the `unit`." + ], + [ + "unit__to_node", + "unit_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `unit_capacity` unit conversions in the case the `unit_capacity` value is incompatible with the desired `unit_flow` units." + ], + [ + "unit__to_node", + "unit_flow_non_anticipativity_margin", + null, + null, + "Margin by which `unit_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "unit__to_node", + "unit_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `unit_flow` variable has to be fixed to the result from the previous window." + ], + [ + "unit__to_node", + "vom_cost", + null, + null, + "Variable operating costs of a `unit_flow` variable. E.g. EUR/MWh." + ], + [ + "unit__to_node__user_constraint", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__to_node__user_constraint", + "unit_flow_coefficient", + 0.0, + null, + "Coefficient of a `unit_flow` variable for a custom `user_constraint`." + ], + [ + "unit__user_constraint", + "units_invested_available_coefficient", + 0.0, + null, + "Coefficient of the `units_invested_available` variable in the specified `user_constraint`." + ], + [ + "unit__user_constraint", + "units_invested_coefficient", + 0.0, + null, + "Coefficient of the `units_invested` variable in the specified `user_constraint`." + ], + [ + "unit__user_constraint", + "units_on_coefficient", + 0.0, + null, + "Coefficient of a `units_on` variable for a custom `user_constraint`." + ], + [ + "unit__user_constraint", + "units_started_up_coefficient", + 0.0, + null, + "Coefficient of a `units_started_up` variable for a custom `user_constraint`." + ], + [ + "units_on__stochastic_structure", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "units_on__temporal_block", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ] + ], + "objects": [ + [ + "model", + "simple", + null + ], + [ + "node", + "electricity_node", + null + ], + [ + "node", + "fuel_node", + null + ], + [ + "output", + "binary_gas_connection_flow", + null + ], + [ + "output", + "connection_avg_intact_throughflow", + null + ], + [ + "output", + "connection_avg_throughflow", + null + ], + [ + "output", + "connection_flow", + null + ], + [ + "output", + "connection_flow_costs", + null + ], + [ + "output", + "connection_intact_flow", + null + ], + [ + "output", + "connection_investment_costs", + null + ], + [ + "output", + "connections_decommissioned", + null + ], + [ + "output", + "connections_invested", + null + ], + [ + "output", + "connections_invested_available", + null + ], + [ + "output", + "contingency_is_binding", + null + ], + [ + "output", + "fixed_om_costs", + null + ], + [ + "output", + "fuel_costs", + null + ], + [ + "output", + "mga_objective", + null + ], + [ + "output", + "mp_objective_lowerbound", + null + ], + [ + "output", + "node_injection", + null + ], + [ + "output", + "node_pressure", + null + ], + [ + "output", + "node_slack_neg", + null + ], + [ + "output", + "node_slack_pos", + null + ], + [ + "output", + "node_state", + null + ], + [ + "output", + "node_voltage_angle", + null + ], + [ + "output", + "nonspin_ramp_down_unit_flow", + null + ], + [ + "output", + "nonspin_ramp_up_unit_flow", + null + ], + [ + "output", + "nonspin_units_shut_down", + null + ], + [ + "output", + "nonspin_units_started_up", + null + ], + [ + "output", + "objective_penalties", + null + ], + [ + "output", + "ramp_costs", + null + ], + [ + "output", + "ramp_down_unit_flow", + null + ], + [ + "output", + "ramp_up_unit_flow", + null + ], + [ + "output", + "renewable_curtailment_costs", + null + ], + [ + "output", + "res_proc_costs", + null + ], + [ + "output", + "shut_down_costs", + null + ], + [ + "output", + "shut_down_unit_flow", + null + ], + [ + "output", + "start_up_costs", + null + ], + [ + "output", + "start_up_unit_flow", + null + ], + [ + "output", + "storage_investment_costs", + null + ], + [ + "output", + "storages_decommissioned", + null + ], + [ + "output", + "storages_invested", + null + ], + [ + "output", + "storages_invested_available", + null + ], + [ + "output", + "taxes", + null + ], + [ + "output", + "total_costs", + null + ], + [ + "output", + "unit_flow", + null + ], + [ + "output", + "unit_flow_op", + null + ], + [ + "output", + "unit_flow_op_active", + null + ], + [ + "output", + "unit_investment_costs", + null + ], + [ + "output", + "units_available", + null + ], + [ + "output", + "units_invested", + null + ], + [ + "output", + "units_invested_available", + null + ], + [ + "output", + "units_mothballed", + null + ], + [ + "output", + "units_on", + null + ], + [ + "output", + "units_on_costs", + null + ], + [ + "output", + "units_shut_down", + null + ], + [ + "output", + "units_started_up", + null + ], + [ + "output", + "variable_om_costs", + null + ], + [ + "report", + "report1", + null + ], + [ + "stochastic_scenario", + "realization", + null + ], + [ + "stochastic_structure", + "deterministic", + null + ], + [ + "temporal_block", + "flat", + null + ], + [ + "unit", + "power_plant_a", + null + ], + [ + "unit", + "power_plant_b", + null + ] + ], + "relationships": [ + [ + "model__default_stochastic_structure", + [ + "simple", + "deterministic" + ] + ], + [ + "model__default_temporal_block", + [ + "simple", + "flat" + ] + ], + [ + "model__report", + [ + "simple", + "report1" + ] + ], + [ + "model__stochastic_structure", + [ + "simple", + "deterministic" + ] + ], + [ + "model__temporal_block", + [ + "simple", + "flat" + ] + ], + [ + "report__output", + [ + "report1", + "unit_flow" + ] + ], + [ + "stochastic_structure__stochastic_scenario", + [ + "deterministic", + "realization" + ] + ], + [ + "unit__from_node", + [ + "power_plant_a", + "fuel_node" + ] + ], + [ + "unit__from_node", + [ + "power_plant_b", + "fuel_node" + ] + ], + [ + "unit__node__node", + [ + "power_plant_a", + "electricity_node", + "fuel_node" + ] + ], + [ + "unit__node__node", + [ + "power_plant_b", + "electricity_node", + "fuel_node" + ] + ], + [ + "unit__to_node", + [ + "power_plant_a", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "power_plant_b", + "electricity_node" + ] + ] + ], + "object_parameter_values": [ + [ + "node", + "electricity_node", + "demand", + 150.0, + "Base" + ], + [ + "node", + "fuel_node", + "balance_type", + "balance_type_none", + "Base" + ], + [ + "temporal_block", + "flat", + "resolution", + { + "type": "duration", + "data": "1D" + }, + "Base" + ] + ], + "relationship_parameter_values": [ + [ + "unit__from_node", + [ + "power_plant_a", + "fuel_node" + ], + "vom_cost", + 25, + "Base" + ], + [ + "unit__from_node", + [ + "power_plant_b", + "fuel_node" + ], + "vom_cost", + 50, + "Base" + ], + [ + "unit__node__node", + [ + "power_plant_a", + "electricity_node", + "fuel_node" + ], + "fix_ratio_out_in_unit_flow", + 0.7, + "Base" + ], + [ + "unit__node__node", + [ + "power_plant_b", + "electricity_node", + "fuel_node" + ], + "fix_ratio_out_in_unit_flow", + 0.8, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_a", + "electricity_node" + ], + "unit_capacity", + 100, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_b", + "electricity_node" + ], + "unit_capacity", + 200.0, + "Base" + ] + ], + "alternatives": [ + [ + "Base", + "Base alternative" + ] + ], + "tools": [ + [ + "object_activity_control", + "" + ] + ], + "features": [ + [ + "commodity", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "connection", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "model", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "node", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "node__stochastic_structure", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "node__temporal_block", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "output", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "report", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "stochastic_scenario", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "stochastic_structure", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "temporal_block", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "unit", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "unit__from_node", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "unit__to_node", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "units_on__stochastic_structure", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "units_on__temporal_block", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "user_constraint", + "is_active", + "boolean_value_list", + "boolean_value_list" + ] + ], + "tool_features": [ + [ + "object_activity_control", + "commodity", + "is_active", + false + ], + [ + "object_activity_control", + "connection", + "is_active", + false + ], + [ + "object_activity_control", + "model", + "is_active", + false + ], + [ + "object_activity_control", + "node", + "is_active", + false + ], + [ + "object_activity_control", + "node__stochastic_structure", + "is_active", + false + ], + [ + "object_activity_control", + "node__temporal_block", + "is_active", + false + ], + [ + "object_activity_control", + "output", + "is_active", + false + ], + [ + "object_activity_control", + "report", + "is_active", + false + ], + [ + "object_activity_control", + "stochastic_scenario", + "is_active", + false + ], + [ + "object_activity_control", + "stochastic_structure", + "is_active", + false + ], + [ + "object_activity_control", + "temporal_block", + "is_active", + false + ], + [ + "object_activity_control", + "unit", + "is_active", + false + ], + [ + "object_activity_control", + "unit__from_node", + "is_active", + false + ], + [ + "object_activity_control", + "unit__to_node", + "is_active", + false + ], + [ + "object_activity_control", + "units_on__stochastic_structure", + "is_active", + false + ], + [ + "object_activity_control", + "units_on__temporal_block", + "is_active", + false + ], + [ + "object_activity_control", + "user_constraint", + "is_active", + false + ] + ], + "tool_feature_methods": [ + [ + "object_activity_control", + "commodity", + "is_active", + true + ], + [ + "object_activity_control", + "connection", + "is_active", + true + ], + [ + "object_activity_control", + "model", + "is_active", + true + ], + [ + "object_activity_control", + "node", + "is_active", + true + ], + [ + "object_activity_control", + "node__stochastic_structure", + "is_active", + true + ], + [ + "object_activity_control", + "node__temporal_block", + "is_active", + true + ], + [ + "object_activity_control", + "output", + "is_active", + true + ], + [ + "object_activity_control", + "report", + "is_active", + true + ], + [ + "object_activity_control", + "stochastic_scenario", + "is_active", + true + ], + [ + "object_activity_control", + "stochastic_structure", + "is_active", + true + ], + [ + "object_activity_control", + "temporal_block", + "is_active", + true + ], + [ + "object_activity_control", + "unit", + "is_active", + true + ], + [ + "object_activity_control", + "unit__from_node", + "is_active", + true + ], + [ + "object_activity_control", + "unit__to_node", + "is_active", + true + ], + [ + "object_activity_control", + "units_on__stochastic_structure", + "is_active", + true + ], + [ + "object_activity_control", + "units_on__temporal_block", + "is_active", + true + ], + [ + "object_activity_control", + "user_constraint", + "is_active", + true + ] + ] +} \ No newline at end of file diff --git a/examples/system_A5.json b/examples/system_A5.json new file mode 100644 index 0000000000..8810e92d55 --- /dev/null +++ b/examples/system_A5.json @@ -0,0 +1,5401 @@ +{ + "object_classes": [ + [ + "commodity", + "A commodity", + 281473533932880 + ], + [ + "connection", + "An entity where an energy transfer takes place", + 280378317271233 + ], + [ + "model", + null, + 61874 + ], + [ + "node", + "An entity where an energy balance takes place", + 280740554077951 + ], + [ + "output", + null, + 61874 + ], + [ + "report", + null, + 61874 + ], + [ + "temporal_block", + "A temporal block", + 280376891207703 + ], + [ + "unit", + "An entity where an energy conversion process takes place", + 281470681805429 + ] + ], + "relationship_classes": [ + [ + "commodity_group__commodity", + [ + "commodity", + "commodity" + ], + null, + null + ], + [ + "commodity_group__node_group", + [ + "commodity", + "node" + ], + null, + null + ], + [ + "connection__from_node", + [ + "connection", + "node" + ], + null, + null + ], + [ + "connection__node__node", + [ + "connection", + "node", + "node" + ], + null, + null + ], + [ + "connection__to_node", + [ + "connection", + "node" + ], + null, + null + ], + [ + "node__commodity", + [ + "node", + "commodity" + ], + null, + null + ], + [ + "node__node", + [ + "node", + "node" + ], + null, + null + ], + [ + "node__temporal_block", + [ + "node", + "temporal_block" + ], + null, + null + ], + [ + "node_group__node", + [ + "node", + "node" + ], + null, + null + ], + [ + "report__output", + [ + "report", + "output" + ], + null, + null + ], + [ + "unit__from_node", + [ + "unit", + "node" + ], + null, + null + ], + [ + "unit__node__node", + [ + "unit", + "node", + "node" + ], + null, + null + ], + [ + "unit__to_node", + [ + "unit", + "node" + ], + null, + null + ], + [ + "unit_group__commodity_group", + [ + "unit", + "commodity" + ], + null, + null + ], + [ + "unit_group__unit", + [ + "unit", + "unit" + ], + null, + null + ], + [ + "units_on_resolution", + [ + "unit", + "node" + ], + null, + null + ] + ], + "object_parameters": [ + [ + "connection", + "connection_availability_factor", + 1, + null, + null + ], + [ + "connection", + "graph_view_position", + 0, + null, + null + ], + [ + "model", + "duration_unit", + 0, + null, + null + ], + [ + "model", + "model_end", + 0, + null, + null + ], + [ + "model", + "model_start", + 0, + null, + null + ], + [ + "model", + "roll_forward", + null, + null, + null + ], + [ + "node", + "demand", + 0, + null, + null + ], + [ + "node", + "fix_node_state", + null, + null, + null + ], + [ + "node", + "frac_state_loss", + 0, + null, + null + ], + [ + "node", + "graph_view_position", + 0, + null, + null + ], + [ + "node", + "has_state", + "value_false", + null, + null + ], + [ + "node", + "node_state_cap", + null, + null, + null + ], + [ + "node", + "node_state_min", + 0, + null, + null + ], + [ + "node", + "state_coeff", + 1, + null, + null + ], + [ + "report", + "output_db_url", + null, + null, + null + ], + [ + "temporal_block", + "block_end", + null, + null, + null + ], + [ + "temporal_block", + "block_start", + null, + null, + null + ], + [ + "temporal_block", + "resolution", + null, + null, + null + ], + [ + "unit", + "fix_units_on", + null, + null, + null + ], + [ + "unit", + "fom_cost", + null, + null, + null + ], + [ + "unit", + "min_down_time", + null, + null, + null + ], + [ + "unit", + "min_up_time", + null, + null, + null + ], + [ + "unit", + "number_of_units", + 1, + null, + null + ], + [ + "unit", + "online_variable_type", + "unit_online_variable_type_integer", + null, + null + ], + [ + "unit", + "shut_down_cost", + null, + null, + null + ], + [ + "unit", + "start_up_cost", + null, + null, + null + ], + [ + "unit", + "unit_availability_factor", + 1, + null, + null + ] + ], + "relationship_parameters": [ + [ + "commodity_group__node_group", + "tax_in_unit_flow", + null, + null, + null + ], + [ + "commodity_group__node_group", + "tax_net_unit_flow", + null, + null, + null + ], + [ + "commodity_group__node_group", + "tax_out_unit_flow", + null, + null, + null + ], + [ + "connection__from_node", + "connection_capacity", + null, + null, + null + ], + [ + "connection__from_node", + "connection_conv_cap_to_flow", + null, + null, + null + ], + [ + "connection__from_node", + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ] + }, + null, + null + ], + [ + "connection__from_node", + "graph_view_position", + 0, + null, + null + ], + [ + "connection__node__node", + "connection_flow_delay", + { + "type": "duration", + "data": "0h" + }, + null, + null + ], + [ + "connection__node__node", + "fix_ratio_out_in_connection_flow", + 1, + null, + null + ], + [ + "connection__node__node", + "max_ratio_out_in_connection_flow", + null, + null, + null + ], + [ + "connection__node__node", + "min_ratio_out_in_connection_flow", + null, + null, + null + ], + [ + "connection__to_node", + "connection_capacity", + null, + null, + null + ], + [ + "connection__to_node", + "connection_conv_cap_to_flow", + null, + null, + null + ], + [ + "connection__to_node", + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ] + }, + null, + null + ], + [ + "connection__to_node", + "graph_view_position", + 0, + null, + null + ], + [ + "node__node", + "diff_coeff", + 0, + null, + null + ], + [ + "unit__from_node", + "fix_unit_flow", + null, + null, + null + ], + [ + "unit__from_node", + "fuel_cost", + null, + null, + null + ], + [ + "unit__from_node", + "minimum_operating_point", + null, + null, + null + ], + [ + "unit__from_node", + "operating_cost", + null, + null, + null + ], + [ + "unit__from_node", + "unit_capacity", + null, + null, + null + ], + [ + "unit__from_node", + "unit_conv_cap_to_flow", + 1, + null, + null + ], + [ + "unit__from_node", + "vom_cost", + null, + null, + null + ], + [ + "unit__node__node", + "fix_ratio_in_in_unit_flow", + null, + null, + null + ], + [ + "unit__node__node", + "fix_ratio_out_in_unit_flow", + 1, + null, + null + ], + [ + "unit__node__node", + "fix_ratio_out_out_unit_flow", + null, + null, + null + ], + [ + "unit__node__node", + "max_ratio_in_in_unit_flow", + null, + null, + null + ], + [ + "unit__node__node", + "max_ratio_out_in_unit_flow", + null, + null, + null + ], + [ + "unit__node__node", + "max_ratio_out_out_unit_flow", + null, + null, + null + ], + [ + "unit__node__node", + "min_ratio_in_in_unit_flow", + null, + null, + null + ], + [ + "unit__node__node", + "min_ratio_out_in_unit_flow", + null, + null, + null + ], + [ + "unit__node__node", + "min_ratio_out_out_unit_flow", + null, + null, + null + ], + [ + "unit__to_node", + "fix_unit_flow", + null, + null, + null + ], + [ + "unit__to_node", + "fuel_cost", + null, + null, + null + ], + [ + "unit__to_node", + "minimum_operating_point", + null, + null, + null + ], + [ + "unit__to_node", + "operating_cost", + null, + null, + null + ], + [ + "unit__to_node", + "unit_capacity", + null, + null, + null + ], + [ + "unit__to_node", + "unit_conv_cap_to_flow", + 1, + null, + null + ], + [ + "unit__to_node", + "vom_cost", + null, + null, + null + ], + [ + "unit_group__commodity_group", + "max_cum_in_unit_flow_bound", + null, + null, + null + ] + ], + "objects": [ + [ + "commodity", + "electricity", + null + ], + [ + "commodity", + "water", + null + ], + [ + "connection", + "Bastusel_to_Grytfors_disch", + null + ], + [ + "connection", + "Bastusel_to_Grytfors_spill", + null + ], + [ + "connection", + "Bergn\u00e4s_to_Slagn\u00e4s_disch", + null + ], + [ + "connection", + "Bergn\u00e4s_to_Slagn\u00e4s_spill", + null + ], + [ + "connection", + "B\u00e5tfors_to_Finnfors_disch", + null + ], + [ + "connection", + "B\u00e5tfors_to_Finnfors_spill", + null + ], + [ + "connection", + "Finnfors_to_Granfors_disch", + null + ], + [ + "connection", + "Finnfors_to_Granfors_spill", + null + ], + [ + "connection", + "Gallejaur_to_Vargfors_disch", + null + ], + [ + "connection", + "Gallejaur_to_Vargfors_spill", + null + ], + [ + "connection", + "Granfors_to_Kr\u00e5ngfors_disch", + null + ], + [ + "connection", + "Granfors_to_Kr\u00e5ngfors_spill", + null + ], + [ + "connection", + "Grytfors_to_Gallejaur_disch", + null + ], + [ + "connection", + "Grytfors_to_Gallejaur_spill", + null + ], + [ + "connection", + "Kr\u00e5ngfors_to_Selsfors_disch", + null + ], + [ + "connection", + "Kr\u00e5ngfors_to_Selsfors_spill", + null + ], + [ + "connection", + "Kvistforsen_to_downstream_disch", + null + ], + [ + "connection", + "Kvistforsen_to_downstream_spill", + null + ], + [ + "connection", + "Rebnis_to_Bergn\u00e4s_disch", + null + ], + [ + "connection", + "Rebnis_to_Bergn\u00e4s_spill", + null + ], + [ + "connection", + "Reng\u00e5rd_to_B\u00e5tfors_disch", + null + ], + [ + "connection", + "Reng\u00e5rd_to_B\u00e5tfors_spill", + null + ], + [ + "connection", + "Sadva_to_Bergn\u00e4s_disch", + null + ], + [ + "connection", + "Sadva_to_Bergn\u00e4s_spill", + null + ], + [ + "connection", + "Selsfors_to_Kvistforsen_disch", + null + ], + [ + "connection", + "Selsfors_to_Kvistforsen_spill", + null + ], + [ + "connection", + "Slagn\u00e4s_to_Bastusel_disch", + null + ], + [ + "connection", + "Slagn\u00e4s_to_Bastusel_spill", + null + ], + [ + "connection", + "Vargfors_to_Reng\u00e5rd_disch", + null + ], + [ + "connection", + "Vargfors_to_Reng\u00e5rd_spill", + null + ], + [ + "model", + "instance", + null + ], + [ + "node", + "Bastusel_lower", + null + ], + [ + "node", + "Bastusel_upper", + null + ], + [ + "node", + "Bergn\u00e4s_lower", + null + ], + [ + "node", + "Bergn\u00e4s_upper", + null + ], + [ + "node", + "B\u00e5tfors_lower", + null + ], + [ + "node", + "B\u00e5tfors_upper", + null + ], + [ + "node", + "Finnfors_lower", + null + ], + [ + "node", + "Finnfors_upper", + null + ], + [ + "node", + "Gallejaur_lower", + null + ], + [ + "node", + "Gallejaur_upper", + null + ], + [ + "node", + "Granfors_lower", + null + ], + [ + "node", + "Granfors_upper", + null + ], + [ + "node", + "Grytfors_lower", + null + ], + [ + "node", + "Grytfors_upper", + null + ], + [ + "node", + "Kr\u00e5ngfors_lower", + null + ], + [ + "node", + "Kr\u00e5ngfors_upper", + null + ], + [ + "node", + "Kvistforsen_lower", + null + ], + [ + "node", + "Kvistforsen_upper", + null + ], + [ + "node", + "Rebnis_lower", + null + ], + [ + "node", + "Rebnis_upper", + null + ], + [ + "node", + "Reng\u00e5rd_lower", + null + ], + [ + "node", + "Reng\u00e5rd_upper", + null + ], + [ + "node", + "Sadva_lower", + null + ], + [ + "node", + "Sadva_upper", + null + ], + [ + "node", + "Selsfors_lower", + null + ], + [ + "node", + "Selsfors_upper", + null + ], + [ + "node", + "Slagn\u00e4s_lower", + null + ], + [ + "node", + "Slagn\u00e4s_upper", + null + ], + [ + "node", + "Vargfors_lower", + null + ], + [ + "node", + "Vargfors_upper", + null + ], + [ + "node", + "electricity_node", + null + ], + [ + "node", + "units_on_resolution", + null + ], + [ + "output", + "node_state", + null + ], + [ + "output", + "unit_flow", + null + ], + [ + "output", + "units_on", + null + ], + [ + "report", + "report_a", + null + ], + [ + "temporal_block", + "some_week", + null + ], + [ + "unit", + "Bastusel_pwr_plant", + null + ], + [ + "unit", + "Bergn\u00e4s_pwr_plant", + null + ], + [ + "unit", + "B\u00e5tfors_pwr_plant", + null + ], + [ + "unit", + "Finnfors_pwr_plant", + null + ], + [ + "unit", + "Gallejaur_pwr_plant", + null + ], + [ + "unit", + "Granfors_pwr_plant", + null + ], + [ + "unit", + "Grytfors_pwr_plant", + null + ], + [ + "unit", + "Kr\u00e5ngfors_pwr_plant", + null + ], + [ + "unit", + "Kvistforsen_pwr_plant", + null + ], + [ + "unit", + "Rebnis_pwr_plant", + null + ], + [ + "unit", + "Reng\u00e5rd_pwr_plant", + null + ], + [ + "unit", + "Sadva_pwr_plant", + null + ], + [ + "unit", + "Selsfors_pwr_plant", + null + ], + [ + "unit", + "Slagn\u00e4s_pwr_plant", + null + ], + [ + "unit", + "Vargfors_pwr_plant", + null + ], + [ + "unit", + "all_units", + null + ], + [ + "unit", + "electricity_load", + null + ] + ], + "relationships": [ + [ + "connection__from_node", + [ + "Bastusel_to_Grytfors_disch", + "Bastusel_lower" + ] + ], + [ + "connection__from_node", + [ + "Bastusel_to_Grytfors_spill", + "Bastusel_upper" + ] + ], + [ + "connection__from_node", + [ + "Bergn\u00e4s_to_Slagn\u00e4s_disch", + "Bergn\u00e4s_lower" + ] + ], + [ + "connection__from_node", + [ + "Bergn\u00e4s_to_Slagn\u00e4s_spill", + "Bergn\u00e4s_upper" + ] + ], + [ + "connection__from_node", + [ + "B\u00e5tfors_to_Finnfors_disch", + "B\u00e5tfors_lower" + ] + ], + [ + "connection__from_node", + [ + "B\u00e5tfors_to_Finnfors_spill", + "B\u00e5tfors_upper" + ] + ], + [ + "connection__from_node", + [ + "Finnfors_to_Granfors_disch", + "Finnfors_lower" + ] + ], + [ + "connection__from_node", + [ + "Finnfors_to_Granfors_spill", + "Finnfors_upper" + ] + ], + [ + "connection__from_node", + [ + "Gallejaur_to_Vargfors_disch", + "Gallejaur_lower" + ] + ], + [ + "connection__from_node", + [ + "Gallejaur_to_Vargfors_spill", + "Gallejaur_upper" + ] + ], + [ + "connection__from_node", + [ + "Granfors_to_Kr\u00e5ngfors_disch", + "Granfors_lower" + ] + ], + [ + "connection__from_node", + [ + "Granfors_to_Kr\u00e5ngfors_spill", + "Granfors_upper" + ] + ], + [ + "connection__from_node", + [ + "Grytfors_to_Gallejaur_disch", + "Grytfors_lower" + ] + ], + [ + "connection__from_node", + [ + "Grytfors_to_Gallejaur_spill", + "Grytfors_upper" + ] + ], + [ + "connection__from_node", + [ + "Kr\u00e5ngfors_to_Selsfors_disch", + "Kr\u00e5ngfors_lower" + ] + ], + [ + "connection__from_node", + [ + "Kr\u00e5ngfors_to_Selsfors_spill", + "Kr\u00e5ngfors_upper" + ] + ], + [ + "connection__from_node", + [ + "Kvistforsen_to_downstream_disch", + "Kvistforsen_lower" + ] + ], + [ + "connection__from_node", + [ + "Kvistforsen_to_downstream_spill", + "Kvistforsen_upper" + ] + ], + [ + "connection__from_node", + [ + "Rebnis_to_Bergn\u00e4s_disch", + "Rebnis_lower" + ] + ], + [ + "connection__from_node", + [ + "Rebnis_to_Bergn\u00e4s_spill", + "Rebnis_upper" + ] + ], + [ + "connection__from_node", + [ + "Reng\u00e5rd_to_B\u00e5tfors_disch", + "Reng\u00e5rd_lower" + ] + ], + [ + "connection__from_node", + [ + "Reng\u00e5rd_to_B\u00e5tfors_spill", + "Reng\u00e5rd_upper" + ] + ], + [ + "connection__from_node", + [ + "Sadva_to_Bergn\u00e4s_disch", + "Sadva_lower" + ] + ], + [ + "connection__from_node", + [ + "Sadva_to_Bergn\u00e4s_spill", + "Sadva_upper" + ] + ], + [ + "connection__from_node", + [ + "Selsfors_to_Kvistforsen_disch", + "Selsfors_lower" + ] + ], + [ + "connection__from_node", + [ + "Selsfors_to_Kvistforsen_spill", + "Selsfors_upper" + ] + ], + [ + "connection__from_node", + [ + "Slagn\u00e4s_to_Bastusel_disch", + "Slagn\u00e4s_lower" + ] + ], + [ + "connection__from_node", + [ + "Slagn\u00e4s_to_Bastusel_spill", + "Slagn\u00e4s_upper" + ] + ], + [ + "connection__from_node", + [ + "Vargfors_to_Reng\u00e5rd_disch", + "Vargfors_lower" + ] + ], + [ + "connection__from_node", + [ + "Vargfors_to_Reng\u00e5rd_spill", + "Vargfors_upper" + ] + ], + [ + "connection__node__node", + [ + "Bastusel_to_Grytfors_disch", + "Grytfors_upper", + "Bastusel_lower" + ] + ], + [ + "connection__node__node", + [ + "Bastusel_to_Grytfors_spill", + "Grytfors_upper", + "Bastusel_upper" + ] + ], + [ + "connection__node__node", + [ + "Bergn\u00e4s_to_Slagn\u00e4s_disch", + "Slagn\u00e4s_upper", + "Bergn\u00e4s_lower" + ] + ], + [ + "connection__node__node", + [ + "Bergn\u00e4s_to_Slagn\u00e4s_spill", + "Slagn\u00e4s_upper", + "Bergn\u00e4s_upper" + ] + ], + [ + "connection__node__node", + [ + "B\u00e5tfors_to_Finnfors_disch", + "Finnfors_upper", + "B\u00e5tfors_lower" + ] + ], + [ + "connection__node__node", + [ + "B\u00e5tfors_to_Finnfors_spill", + "Finnfors_upper", + "B\u00e5tfors_upper" + ] + ], + [ + "connection__node__node", + [ + "Finnfors_to_Granfors_disch", + "Granfors_upper", + "Finnfors_lower" + ] + ], + [ + "connection__node__node", + [ + "Finnfors_to_Granfors_spill", + "Granfors_upper", + "Finnfors_upper" + ] + ], + [ + "connection__node__node", + [ + "Gallejaur_to_Vargfors_disch", + "Vargfors_upper", + "Gallejaur_lower" + ] + ], + [ + "connection__node__node", + [ + "Gallejaur_to_Vargfors_spill", + "Vargfors_upper", + "Gallejaur_upper" + ] + ], + [ + "connection__node__node", + [ + "Granfors_to_Kr\u00e5ngfors_disch", + "Kr\u00e5ngfors_upper", + "Granfors_lower" + ] + ], + [ + "connection__node__node", + [ + "Granfors_to_Kr\u00e5ngfors_spill", + "Kr\u00e5ngfors_upper", + "Granfors_upper" + ] + ], + [ + "connection__node__node", + [ + "Grytfors_to_Gallejaur_disch", + "Gallejaur_upper", + "Grytfors_lower" + ] + ], + [ + "connection__node__node", + [ + "Grytfors_to_Gallejaur_spill", + "Gallejaur_upper", + "Grytfors_upper" + ] + ], + [ + "connection__node__node", + [ + "Kr\u00e5ngfors_to_Selsfors_disch", + "Selsfors_upper", + "Kr\u00e5ngfors_lower" + ] + ], + [ + "connection__node__node", + [ + "Kr\u00e5ngfors_to_Selsfors_spill", + "Selsfors_upper", + "Kr\u00e5ngfors_upper" + ] + ], + [ + "connection__node__node", + [ + "Rebnis_to_Bergn\u00e4s_disch", + "Bergn\u00e4s_upper", + "Rebnis_lower" + ] + ], + [ + "connection__node__node", + [ + "Rebnis_to_Bergn\u00e4s_spill", + "Bergn\u00e4s_upper", + "Rebnis_upper" + ] + ], + [ + "connection__node__node", + [ + "Reng\u00e5rd_to_B\u00e5tfors_disch", + "B\u00e5tfors_upper", + "Reng\u00e5rd_lower" + ] + ], + [ + "connection__node__node", + [ + "Reng\u00e5rd_to_B\u00e5tfors_spill", + "B\u00e5tfors_upper", + "Reng\u00e5rd_upper" + ] + ], + [ + "connection__node__node", + [ + "Sadva_to_Bergn\u00e4s_disch", + "Bergn\u00e4s_upper", + "Sadva_lower" + ] + ], + [ + "connection__node__node", + [ + "Sadva_to_Bergn\u00e4s_spill", + "Bergn\u00e4s_upper", + "Sadva_upper" + ] + ], + [ + "connection__node__node", + [ + "Selsfors_to_Kvistforsen_disch", + "Kvistforsen_upper", + "Selsfors_lower" + ] + ], + [ + "connection__node__node", + [ + "Selsfors_to_Kvistforsen_spill", + "Kvistforsen_upper", + "Selsfors_upper" + ] + ], + [ + "connection__node__node", + [ + "Slagn\u00e4s_to_Bastusel_disch", + "Bastusel_upper", + "Slagn\u00e4s_lower" + ] + ], + [ + "connection__node__node", + [ + "Slagn\u00e4s_to_Bastusel_spill", + "Bastusel_upper", + "Slagn\u00e4s_upper" + ] + ], + [ + "connection__node__node", + [ + "Vargfors_to_Reng\u00e5rd_disch", + "Reng\u00e5rd_upper", + "Vargfors_lower" + ] + ], + [ + "connection__node__node", + [ + "Vargfors_to_Reng\u00e5rd_spill", + "Reng\u00e5rd_upper", + "Vargfors_upper" + ] + ], + [ + "connection__to_node", + [ + "Bastusel_to_Grytfors_disch", + "Grytfors_upper" + ] + ], + [ + "connection__to_node", + [ + "Bastusel_to_Grytfors_spill", + "Grytfors_upper" + ] + ], + [ + "connection__to_node", + [ + "Bergn\u00e4s_to_Slagn\u00e4s_disch", + "Slagn\u00e4s_upper" + ] + ], + [ + "connection__to_node", + [ + "Bergn\u00e4s_to_Slagn\u00e4s_spill", + "Slagn\u00e4s_upper" + ] + ], + [ + "connection__to_node", + [ + "B\u00e5tfors_to_Finnfors_disch", + "Finnfors_upper" + ] + ], + [ + "connection__to_node", + [ + "B\u00e5tfors_to_Finnfors_spill", + "Finnfors_upper" + ] + ], + [ + "connection__to_node", + [ + "Finnfors_to_Granfors_disch", + "Granfors_upper" + ] + ], + [ + "connection__to_node", + [ + "Finnfors_to_Granfors_spill", + "Granfors_upper" + ] + ], + [ + "connection__to_node", + [ + "Gallejaur_to_Vargfors_disch", + "Vargfors_upper" + ] + ], + [ + "connection__to_node", + [ + "Gallejaur_to_Vargfors_spill", + "Vargfors_upper" + ] + ], + [ + "connection__to_node", + [ + "Granfors_to_Kr\u00e5ngfors_disch", + "Kr\u00e5ngfors_upper" + ] + ], + [ + "connection__to_node", + [ + "Granfors_to_Kr\u00e5ngfors_spill", + "Kr\u00e5ngfors_upper" + ] + ], + [ + "connection__to_node", + [ + "Grytfors_to_Gallejaur_disch", + "Gallejaur_upper" + ] + ], + [ + "connection__to_node", + [ + "Grytfors_to_Gallejaur_spill", + "Gallejaur_upper" + ] + ], + [ + "connection__to_node", + [ + "Kr\u00e5ngfors_to_Selsfors_disch", + "Selsfors_upper" + ] + ], + [ + "connection__to_node", + [ + "Kr\u00e5ngfors_to_Selsfors_spill", + "Selsfors_upper" + ] + ], + [ + "connection__to_node", + [ + "Rebnis_to_Bergn\u00e4s_disch", + "Bergn\u00e4s_upper" + ] + ], + [ + "connection__to_node", + [ + "Rebnis_to_Bergn\u00e4s_spill", + "Bergn\u00e4s_upper" + ] + ], + [ + "connection__to_node", + [ + "Reng\u00e5rd_to_B\u00e5tfors_disch", + "B\u00e5tfors_upper" + ] + ], + [ + "connection__to_node", + [ + "Reng\u00e5rd_to_B\u00e5tfors_spill", + "B\u00e5tfors_upper" + ] + ], + [ + "connection__to_node", + [ + "Sadva_to_Bergn\u00e4s_disch", + "Bergn\u00e4s_upper" + ] + ], + [ + "connection__to_node", + [ + "Sadva_to_Bergn\u00e4s_spill", + "Bergn\u00e4s_upper" + ] + ], + [ + "connection__to_node", + [ + "Selsfors_to_Kvistforsen_disch", + "Kvistforsen_upper" + ] + ], + [ + "connection__to_node", + [ + "Selsfors_to_Kvistforsen_spill", + "Kvistforsen_upper" + ] + ], + [ + "connection__to_node", + [ + "Slagn\u00e4s_to_Bastusel_disch", + "Bastusel_upper" + ] + ], + [ + "connection__to_node", + [ + "Slagn\u00e4s_to_Bastusel_spill", + "Bastusel_upper" + ] + ], + [ + "connection__to_node", + [ + "Vargfors_to_Reng\u00e5rd_disch", + "Reng\u00e5rd_upper" + ] + ], + [ + "connection__to_node", + [ + "Vargfors_to_Reng\u00e5rd_spill", + "Reng\u00e5rd_upper" + ] + ], + [ + "node__commodity", + [ + "Bastusel_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "Bastusel_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "Bergn\u00e4s_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "Bergn\u00e4s_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "B\u00e5tfors_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "B\u00e5tfors_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "Finnfors_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "Finnfors_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "Gallejaur_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "Gallejaur_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "Granfors_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "Granfors_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "Grytfors_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "Grytfors_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "Kr\u00e5ngfors_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "Kr\u00e5ngfors_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "Kvistforsen_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "Kvistforsen_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "Rebnis_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "Rebnis_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "Reng\u00e5rd_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "Reng\u00e5rd_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "Sadva_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "Sadva_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "Selsfors_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "Selsfors_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "Slagn\u00e4s_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "Slagn\u00e4s_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "Vargfors_lower", + "water" + ] + ], + [ + "node__commodity", + [ + "Vargfors_upper", + "water" + ] + ], + [ + "node__commodity", + [ + "electricity_node", + "electricity" + ] + ], + [ + "node__temporal_block", + [ + "Bastusel_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Bastusel_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Bergn\u00e4s_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Bergn\u00e4s_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "B\u00e5tfors_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "B\u00e5tfors_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Finnfors_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Finnfors_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Gallejaur_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Gallejaur_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Granfors_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Granfors_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Grytfors_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Grytfors_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Kr\u00e5ngfors_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Kr\u00e5ngfors_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Kvistforsen_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Kvistforsen_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Rebnis_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Rebnis_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Reng\u00e5rd_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Reng\u00e5rd_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Sadva_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Sadva_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Selsfors_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Selsfors_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Slagn\u00e4s_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Slagn\u00e4s_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Vargfors_lower", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "Vargfors_upper", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "electricity_node", + "some_week" + ] + ], + [ + "node__temporal_block", + [ + "units_on_resolution", + "some_week" + ] + ], + [ + "report__output", + [ + "report_a", + "node_state" + ] + ], + [ + "report__output", + [ + "report_a", + "unit_flow" + ] + ], + [ + "unit__from_node", + [ + "Bastusel_pwr_plant", + "Bastusel_upper" + ] + ], + [ + "unit__from_node", + [ + "Bergn\u00e4s_pwr_plant", + "Bergn\u00e4s_upper" + ] + ], + [ + "unit__from_node", + [ + "B\u00e5tfors_pwr_plant", + "B\u00e5tfors_upper" + ] + ], + [ + "unit__from_node", + [ + "Finnfors_pwr_plant", + "Finnfors_upper" + ] + ], + [ + "unit__from_node", + [ + "Gallejaur_pwr_plant", + "Gallejaur_upper" + ] + ], + [ + "unit__from_node", + [ + "Granfors_pwr_plant", + "Granfors_upper" + ] + ], + [ + "unit__from_node", + [ + "Grytfors_pwr_plant", + "Grytfors_upper" + ] + ], + [ + "unit__from_node", + [ + "Kr\u00e5ngfors_pwr_plant", + "Kr\u00e5ngfors_upper" + ] + ], + [ + "unit__from_node", + [ + "Kvistforsen_pwr_plant", + "Kvistforsen_upper" + ] + ], + [ + "unit__from_node", + [ + "Rebnis_pwr_plant", + "Rebnis_upper" + ] + ], + [ + "unit__from_node", + [ + "Reng\u00e5rd_pwr_plant", + "Reng\u00e5rd_upper" + ] + ], + [ + "unit__from_node", + [ + "Sadva_pwr_plant", + "Sadva_upper" + ] + ], + [ + "unit__from_node", + [ + "Selsfors_pwr_plant", + "Selsfors_upper" + ] + ], + [ + "unit__from_node", + [ + "Slagn\u00e4s_pwr_plant", + "Slagn\u00e4s_upper" + ] + ], + [ + "unit__from_node", + [ + "Vargfors_pwr_plant", + "Vargfors_upper" + ] + ], + [ + "unit__from_node", + [ + "electricity_load", + "electricity_node" + ] + ], + [ + "unit__node__node", + [ + "Bastusel_pwr_plant", + "Bastusel_lower", + "Bastusel_upper" + ] + ], + [ + "unit__node__node", + [ + "Bastusel_pwr_plant", + "electricity_node", + "Bastusel_upper" + ] + ], + [ + "unit__node__node", + [ + "Bergn\u00e4s_pwr_plant", + "Bergn\u00e4s_lower", + "Bergn\u00e4s_upper" + ] + ], + [ + "unit__node__node", + [ + "Bergn\u00e4s_pwr_plant", + "electricity_node", + "Bergn\u00e4s_upper" + ] + ], + [ + "unit__node__node", + [ + "B\u00e5tfors_pwr_plant", + "B\u00e5tfors_lower", + "B\u00e5tfors_upper" + ] + ], + [ + "unit__node__node", + [ + "B\u00e5tfors_pwr_plant", + "electricity_node", + "B\u00e5tfors_upper" + ] + ], + [ + "unit__node__node", + [ + "Finnfors_pwr_plant", + "Finnfors_lower", + "Finnfors_upper" + ] + ], + [ + "unit__node__node", + [ + "Finnfors_pwr_plant", + "electricity_node", + "Finnfors_upper" + ] + ], + [ + "unit__node__node", + [ + "Gallejaur_pwr_plant", + "Gallejaur_lower", + "Gallejaur_upper" + ] + ], + [ + "unit__node__node", + [ + "Gallejaur_pwr_plant", + "electricity_node", + "Gallejaur_upper" + ] + ], + [ + "unit__node__node", + [ + "Granfors_pwr_plant", + "Granfors_lower", + "Granfors_upper" + ] + ], + [ + "unit__node__node", + [ + "Granfors_pwr_plant", + "electricity_node", + "Granfors_upper" + ] + ], + [ + "unit__node__node", + [ + "Grytfors_pwr_plant", + "Grytfors_lower", + "Grytfors_upper" + ] + ], + [ + "unit__node__node", + [ + "Grytfors_pwr_plant", + "electricity_node", + "Grytfors_upper" + ] + ], + [ + "unit__node__node", + [ + "Kr\u00e5ngfors_pwr_plant", + "Kr\u00e5ngfors_lower", + "Kr\u00e5ngfors_upper" + ] + ], + [ + "unit__node__node", + [ + "Kr\u00e5ngfors_pwr_plant", + "electricity_node", + "Kr\u00e5ngfors_upper" + ] + ], + [ + "unit__node__node", + [ + "Kvistforsen_pwr_plant", + "Kvistforsen_lower", + "Kvistforsen_upper" + ] + ], + [ + "unit__node__node", + [ + "Kvistforsen_pwr_plant", + "electricity_node", + "Kvistforsen_upper" + ] + ], + [ + "unit__node__node", + [ + "Rebnis_pwr_plant", + "Rebnis_lower", + "Rebnis_upper" + ] + ], + [ + "unit__node__node", + [ + "Rebnis_pwr_plant", + "electricity_node", + "Rebnis_upper" + ] + ], + [ + "unit__node__node", + [ + "Reng\u00e5rd_pwr_plant", + "Reng\u00e5rd_lower", + "Reng\u00e5rd_upper" + ] + ], + [ + "unit__node__node", + [ + "Reng\u00e5rd_pwr_plant", + "electricity_node", + "Reng\u00e5rd_upper" + ] + ], + [ + "unit__node__node", + [ + "Sadva_pwr_plant", + "Sadva_lower", + "Sadva_upper" + ] + ], + [ + "unit__node__node", + [ + "Sadva_pwr_plant", + "electricity_node", + "Sadva_upper" + ] + ], + [ + "unit__node__node", + [ + "Selsfors_pwr_plant", + "Selsfors_lower", + "Selsfors_upper" + ] + ], + [ + "unit__node__node", + [ + "Selsfors_pwr_plant", + "electricity_node", + "Selsfors_upper" + ] + ], + [ + "unit__node__node", + [ + "Slagn\u00e4s_pwr_plant", + "Slagn\u00e4s_lower", + "Slagn\u00e4s_upper" + ] + ], + [ + "unit__node__node", + [ + "Slagn\u00e4s_pwr_plant", + "electricity_node", + "Slagn\u00e4s_upper" + ] + ], + [ + "unit__node__node", + [ + "Vargfors_pwr_plant", + "Vargfors_lower", + "Vargfors_upper" + ] + ], + [ + "unit__node__node", + [ + "Vargfors_pwr_plant", + "electricity_node", + "Vargfors_upper" + ] + ], + [ + "unit__to_node", + [ + "Bastusel_pwr_plant", + "Bastusel_lower" + ] + ], + [ + "unit__to_node", + [ + "Bastusel_pwr_plant", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "Bergn\u00e4s_pwr_plant", + "Bergn\u00e4s_lower" + ] + ], + [ + "unit__to_node", + [ + "Bergn\u00e4s_pwr_plant", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "B\u00e5tfors_pwr_plant", + "B\u00e5tfors_lower" + ] + ], + [ + "unit__to_node", + [ + "B\u00e5tfors_pwr_plant", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "Finnfors_pwr_plant", + "Finnfors_lower" + ] + ], + [ + "unit__to_node", + [ + "Finnfors_pwr_plant", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "Gallejaur_pwr_plant", + "Gallejaur_lower" + ] + ], + [ + "unit__to_node", + [ + "Gallejaur_pwr_plant", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "Granfors_pwr_plant", + "Granfors_lower" + ] + ], + [ + "unit__to_node", + [ + "Granfors_pwr_plant", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "Grytfors_pwr_plant", + "Grytfors_lower" + ] + ], + [ + "unit__to_node", + [ + "Grytfors_pwr_plant", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "Kr\u00e5ngfors_pwr_plant", + "Kr\u00e5ngfors_lower" + ] + ], + [ + "unit__to_node", + [ + "Kr\u00e5ngfors_pwr_plant", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "Kvistforsen_pwr_plant", + "Kvistforsen_lower" + ] + ], + [ + "unit__to_node", + [ + "Kvistforsen_pwr_plant", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "Rebnis_pwr_plant", + "Rebnis_lower" + ] + ], + [ + "unit__to_node", + [ + "Rebnis_pwr_plant", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "Reng\u00e5rd_pwr_plant", + "Reng\u00e5rd_lower" + ] + ], + [ + "unit__to_node", + [ + "Reng\u00e5rd_pwr_plant", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "Sadva_pwr_plant", + "Sadva_lower" + ] + ], + [ + "unit__to_node", + [ + "Sadva_pwr_plant", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "Selsfors_pwr_plant", + "Selsfors_lower" + ] + ], + [ + "unit__to_node", + [ + "Selsfors_pwr_plant", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "Slagn\u00e4s_pwr_plant", + "Slagn\u00e4s_lower" + ] + ], + [ + "unit__to_node", + [ + "Slagn\u00e4s_pwr_plant", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "Vargfors_pwr_plant", + "Vargfors_lower" + ] + ], + [ + "unit__to_node", + [ + "Vargfors_pwr_plant", + "electricity_node" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "Bastusel_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "Bergn\u00e4s_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "B\u00e5tfors_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "Finnfors_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "Gallejaur_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "Granfors_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "Grytfors_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "Kr\u00e5ngfors_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "Kvistforsen_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "Rebnis_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "Reng\u00e5rd_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "Sadva_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "Selsfors_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "Slagn\u00e4s_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "Vargfors_pwr_plant" + ] + ], + [ + "unit_group__unit", + [ + "all_units", + "electricity_load" + ] + ], + [ + "units_on_resolution", + [ + "all_units", + "units_on_resolution" + ] + ] + ], + "object_parameter_values": [ + [ + "model", + "instance", + "duration_unit", + "hour", + "Base" + ], + [ + "model", + "instance", + "model_end", + { + "type": "date_time", + "data": "2019-01-08T00:00:00" + }, + "Base" + ], + [ + "model", + "instance", + "model_start", + { + "type": "date_time", + "data": "2019-01-01T00:00:00" + }, + "Base" + ], + [ + "node", + "Bastusel_upper", + "demand", + -0.2579768519, + "Base" + ], + [ + "node", + "Bastusel_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 5581.44, + "2019-01-07T23:00:00.000000": 5417.28 + } + }, + "Base" + ], + [ + "node", + "Bastusel_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "Bastusel_upper", + "node_state_cap", + 8208, + "Base" + ], + [ + "node", + "Bergn\u00e4s_upper", + "demand", + -22.29, + "Base" + ], + [ + "node", + "Bergn\u00e4s_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 114543.6, + "2019-01-07T23:00:00.000000": 105898.8 + } + }, + "Base" + ], + [ + "node", + "Bergn\u00e4s_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "Bergn\u00e4s_upper", + "node_state_cap", + 216120, + "Base" + ], + [ + "node", + "B\u00e5tfors_upper", + "demand", + -2, + "Base" + ], + [ + "node", + "B\u00e5tfors_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 1117.2, + "2019-01-07T23:00:00.000000": 891.1 + } + }, + "Base" + ], + [ + "node", + "B\u00e5tfors_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "B\u00e5tfors_upper", + "node_state_cap", + 1330, + "Base" + ], + [ + "node", + "Finnfors_upper", + "demand", + 0, + "Base" + ], + [ + "node", + "Finnfors_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 234.0, + "2019-01-07T23:00:00.000000": 234.0 + } + }, + "Base" + ], + [ + "node", + "Finnfors_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "Finnfors_upper", + "node_state_cap", + 300, + "Base" + ], + [ + "node", + "Gallejaur_upper", + "demand", + 15.356962963, + "Base" + ], + [ + "node", + "Gallejaur_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 1224.0, + "2019-01-07T23:00:00.000000": 2808.0 + } + }, + "Base" + ], + [ + "node", + "Gallejaur_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "Gallejaur_upper", + "node_state_cap", + 3600, + "Base" + ], + [ + "node", + "Granfors_upper", + "demand", + 0, + "Base" + ], + [ + "node", + "Granfors_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 232.4, + "2019-01-07T23:00:00.000000": 212.8 + } + }, + "Base" + ], + [ + "node", + "Granfors_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "Granfors_upper", + "node_state_cap", + 280, + "Base" + ], + [ + "node", + "Grytfors_upper", + "demand", + -3.78, + "Base" + ], + [ + "node", + "Grytfors_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 1060.8, + "2019-01-07T23:00:00.000000": 1110.72 + } + }, + "Base" + ], + [ + "node", + "Grytfors_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "Grytfors_upper", + "node_state_cap", + 1248, + "Base" + ], + [ + "node", + "Kr\u00e5ngfors_upper", + "demand", + 0, + "Base" + ], + [ + "node", + "Kr\u00e5ngfors_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 201.3, + "2019-01-07T23:00:00.000000": 207.9 + } + }, + "Base" + ], + [ + "node", + "Kr\u00e5ngfors_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "Kr\u00e5ngfors_upper", + "node_state_cap", + 330, + "Base" + ], + [ + "node", + "Kvistforsen_upper", + "demand", + -1.3273809524, + "Base" + ], + [ + "node", + "Kvistforsen_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 769.066666704, + "2019-01-07T23:00:00.000000": 560.0 + } + }, + "Base" + ], + [ + "node", + "Kvistforsen_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "Kvistforsen_upper", + "node_state_cap", + 1120, + "Base" + ], + [ + "node", + "Rebnis_upper", + "demand", + -3.68, + "Base" + ], + [ + "node", + "Rebnis_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 70243.509200184, + "2019-01-07T23:00:00.000000": 59524.122689676 + } + }, + "Base" + ], + [ + "node", + "Rebnis_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "Rebnis_upper", + "node_state_cap", + 205560, + "Base" + ], + [ + "node", + "Reng\u00e5rd_upper", + "demand", + -10.37, + "Base" + ], + [ + "node", + "Reng\u00e5rd_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 1022.0, + "2019-01-07T23:00:00.000000": 770.0 + } + }, + "Base" + ], + [ + "node", + "Reng\u00e5rd_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "Reng\u00e5rd_upper", + "node_state_cap", + 1400, + "Base" + ], + [ + "node", + "Sadva_upper", + "demand", + -5.43, + "Base" + ], + [ + "node", + "Sadva_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 99057.7777728, + "2019-01-07T23:00:00.000000": 93831.111108 + } + }, + "Base" + ], + [ + "node", + "Sadva_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "Sadva_upper", + "node_state_cap", + 168000, + "Base" + ], + [ + "node", + "Selsfors_upper", + "demand", + 0, + "Base" + ], + [ + "node", + "Selsfors_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 40.0, + "2019-01-07T23:00:00.000000": 200.0 + } + }, + "Base" + ], + [ + "node", + "Selsfors_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "Selsfors_upper", + "node_state_cap", + 500, + "Base" + ], + [ + "node", + "Slagn\u00e4s_upper", + "demand", + 0, + "Base" + ], + [ + "node", + "Slagn\u00e4s_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 384.0, + "2019-01-07T23:00:00.000000": 537.6 + } + }, + "Base" + ], + [ + "node", + "Slagn\u00e4s_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "Slagn\u00e4s_upper", + "node_state_cap", + 768, + "Base" + ], + [ + "node", + "Vargfors_upper", + "demand", + -3.5584953704, + "Base" + ], + [ + "node", + "Vargfors_upper", + "fix_node_state", + { + "type": "time_series", + "data": { + "2018-12-31T23:00:00.000000": 3386.76, + "2019-01-07T23:00:00.000000": 3847.68 + } + }, + "Base" + ], + [ + "node", + "Vargfors_upper", + "has_state", + "value_true", + "Base" + ], + [ + "node", + "Vargfors_upper", + "node_state_cap", + 4008, + "Base" + ], + [ + "temporal_block", + "some_week", + "resolution", + { + "type": "duration", + "data": "1h" + }, + "Base" + ] + ], + "relationship_parameter_values": [ + [ + "connection__from_node", + [ + "Bastusel_to_Grytfors_disch", + "Bastusel_lower" + ], + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219, + 110.69999694824219 + ] + }, + "Base" + ], + [ + "connection__from_node", + [ + "Bergn\u00e4s_to_Slagn\u00e4s_disch", + "Bergn\u00e4s_lower" + ], + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0, + 105.0 + ] + }, + "Base" + ], + [ + "connection__from_node", + [ + "B\u00e5tfors_to_Finnfors_disch", + "B\u00e5tfors_lower" + ], + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422, + 150.1999969482422 + ] + }, + "Base" + ], + [ + "connection__from_node", + [ + "Finnfors_to_Granfors_disch", + "Finnfors_lower" + ], + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578, + 155.3000030517578 + ] + }, + "Base" + ], + [ + "connection__from_node", + [ + "Gallejaur_to_Vargfors_disch", + "Gallejaur_lower" + ], + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219, + 118.19999694824219 + ] + }, + "Base" + ], + [ + "connection__from_node", + [ + "Granfors_to_Kr\u00e5ngfors_disch", + "Granfors_lower" + ], + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562, + 155.60000610351562 + ] + }, + "Base" + ], + [ + "connection__from_node", + [ + "Grytfors_to_Gallejaur_disch", + "Grytfors_lower" + ], + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219, + 117.19999694824219 + ] + }, + "Base" + ], + [ + "connection__from_node", + [ + "Kr\u00e5ngfors_to_Selsfors_disch", + "Kr\u00e5ngfors_lower" + ], + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0, + 156.0 + ] + }, + "Base" + ], + [ + "connection__from_node", + [ + "Rebnis_to_Bergn\u00e4s_disch", + "Rebnis_lower" + ], + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5, + 21.5 + ] + }, + "Base" + ], + [ + "connection__from_node", + [ + "Reng\u00e5rd_to_B\u00e5tfors_disch", + "Reng\u00e5rd_lower" + ], + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5, + 141.5 + ] + }, + "Base" + ], + [ + "connection__from_node", + [ + "Sadva_to_Bergn\u00e4s_disch", + "Sadva_lower" + ], + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094, + 34.599998474121094 + ] + }, + "Base" + ], + [ + "connection__from_node", + [ + "Selsfors_to_Kvistforsen_disch", + "Selsfors_lower" + ], + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438, + 158.39999389648438 + ] + }, + "Base" + ], + [ + "connection__from_node", + [ + "Slagn\u00e4s_to_Bastusel_disch", + "Slagn\u00e4s_lower" + ], + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211, + 106.5999984741211 + ] + }, + "Base" + ], + [ + "connection__from_node", + [ + "Vargfors_to_Reng\u00e5rd_disch", + "Vargfors_lower" + ], + "fix_connection_flow", + { + "type": "time_series", + "index": { + "start": "2018-12-30 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211, + 119.5999984741211 + ] + }, + "Base" + ], + [ + "connection__node__node", + [ + "Bastusel_to_Grytfors_disch", + "Grytfors_upper", + "Bastusel_lower" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "1h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Bastusel_to_Grytfors_spill", + "Grytfors_upper", + "Bastusel_upper" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "150m" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Bergn\u00e4s_to_Slagn\u00e4s_disch", + "Slagn\u00e4s_upper", + "Bergn\u00e4s_lower" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "1h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Bergn\u00e4s_to_Slagn\u00e4s_spill", + "Slagn\u00e4s_upper", + "Bergn\u00e4s_upper" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "1h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "B\u00e5tfors_to_Finnfors_disch", + "Finnfors_upper", + "B\u00e5tfors_lower" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "3h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "B\u00e5tfors_to_Finnfors_spill", + "Finnfors_upper", + "B\u00e5tfors_upper" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "3h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Finnfors_to_Granfors_disch", + "Granfors_upper", + "Finnfors_lower" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "3h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Finnfors_to_Granfors_spill", + "Granfors_upper", + "Finnfors_upper" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "3h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Gallejaur_to_Vargfors_disch", + "Vargfors_upper", + "Gallejaur_lower" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "30m" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Gallejaur_to_Vargfors_spill", + "Vargfors_upper", + "Gallejaur_upper" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "150m" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Granfors_to_Kr\u00e5ngfors_disch", + "Kr\u00e5ngfors_upper", + "Granfors_lower" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "3h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Granfors_to_Kr\u00e5ngfors_spill", + "Kr\u00e5ngfors_upper", + "Granfors_upper" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "3h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Grytfors_to_Gallejaur_disch", + "Gallejaur_upper", + "Grytfors_lower" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "15m" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Grytfors_to_Gallejaur_spill", + "Gallejaur_upper", + "Grytfors_upper" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "15m" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Kr\u00e5ngfors_to_Selsfors_disch", + "Selsfors_upper", + "Kr\u00e5ngfors_lower" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "3h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Kr\u00e5ngfors_to_Selsfors_spill", + "Selsfors_upper", + "Kr\u00e5ngfors_upper" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "3h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Rebnis_to_Bergn\u00e4s_disch", + "Bergn\u00e4s_upper", + "Rebnis_lower" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "48h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Rebnis_to_Bergn\u00e4s_spill", + "Bergn\u00e4s_upper", + "Rebnis_upper" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "48h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Reng\u00e5rd_to_B\u00e5tfors_disch", + "B\u00e5tfors_upper", + "Reng\u00e5rd_lower" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "3h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Reng\u00e5rd_to_B\u00e5tfors_spill", + "B\u00e5tfors_upper", + "Reng\u00e5rd_upper" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "3h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Sadva_to_Bergn\u00e4s_disch", + "Bergn\u00e4s_upper", + "Sadva_lower" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "48h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Sadva_to_Bergn\u00e4s_spill", + "Bergn\u00e4s_upper", + "Sadva_upper" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "48h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Selsfors_to_Kvistforsen_disch", + "Kvistforsen_upper", + "Selsfors_lower" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "3h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Selsfors_to_Kvistforsen_spill", + "Kvistforsen_upper", + "Selsfors_upper" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "3h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Slagn\u00e4s_to_Bastusel_disch", + "Bastusel_upper", + "Slagn\u00e4s_lower" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "4h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Slagn\u00e4s_to_Bastusel_spill", + "Bastusel_upper", + "Slagn\u00e4s_upper" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "4h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Vargfors_to_Reng\u00e5rd_disch", + "Reng\u00e5rd_upper", + "Vargfors_lower" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "3h" + }, + "Base" + ], + [ + "connection__node__node", + [ + "Vargfors_to_Reng\u00e5rd_spill", + "Reng\u00e5rd_upper", + "Vargfors_upper" + ], + "connection_flow_delay", + { + "type": "duration", + "data": "3h" + }, + "Base" + ], + [ + "unit__from_node", + [ + "Bastusel_pwr_plant", + "Bastusel_upper" + ], + "unit_capacity", + 127.5, + "Base" + ], + [ + "unit__from_node", + [ + "Bergn\u00e4s_pwr_plant", + "Bergn\u00e4s_upper" + ], + "unit_capacity", + 120, + "Base" + ], + [ + "unit__from_node", + [ + "B\u00e5tfors_pwr_plant", + "B\u00e5tfors_upper" + ], + "unit_capacity", + 210, + "Base" + ], + [ + "unit__from_node", + [ + "Finnfors_pwr_plant", + "Finnfors_upper" + ], + "unit_capacity", + 176.25, + "Base" + ], + [ + "unit__from_node", + [ + "Gallejaur_pwr_plant", + "Gallejaur_upper" + ], + "unit_capacity", + 228.75, + "Base" + ], + [ + "unit__from_node", + [ + "Granfors_pwr_plant", + "Granfors_upper" + ], + "unit_capacity", + 180, + "Base" + ], + [ + "unit__from_node", + [ + "Grytfors_pwr_plant", + "Grytfors_upper" + ], + "unit_capacity", + 123.75, + "Base" + ], + [ + "unit__from_node", + [ + "Kr\u00e5ngfors_pwr_plant", + "Kr\u00e5ngfors_upper" + ], + "unit_capacity", + 180, + "Base" + ], + [ + "unit__from_node", + [ + "Kvistforsen_pwr_plant", + "Kvistforsen_upper" + ], + "minimum_operating_point", + 0.0888888888889, + "Base" + ], + [ + "unit__from_node", + [ + "Kvistforsen_pwr_plant", + "Kvistforsen_upper" + ], + "unit_capacity", + 225, + "Base" + ], + [ + "unit__from_node", + [ + "Rebnis_pwr_plant", + "Rebnis_upper" + ], + "unit_capacity", + 60, + "Base" + ], + [ + "unit__from_node", + [ + "Reng\u00e5rd_pwr_plant", + "Reng\u00e5rd_upper" + ], + "unit_capacity", + 165, + "Base" + ], + [ + "unit__from_node", + [ + "Sadva_pwr_plant", + "Sadva_upper" + ], + "unit_capacity", + 52.5, + "Base" + ], + [ + "unit__from_node", + [ + "Selsfors_pwr_plant", + "Selsfors_upper" + ], + "unit_capacity", + 225, + "Base" + ], + [ + "unit__from_node", + [ + "Slagn\u00e4s_pwr_plant", + "Slagn\u00e4s_upper" + ], + "unit_capacity", + 120, + "Base" + ], + [ + "unit__from_node", + [ + "Vargfors_pwr_plant", + "Vargfors_upper" + ], + "unit_capacity", + 232.5, + "Base" + ], + [ + "unit__from_node", + [ + "electricity_load", + "electricity_node" + ], + "vom_cost", + { + "type": "time_series", + "index": { + "start": "2019-01-01T00:00", + "resolution": "1 hour" + }, + "data": [ + -162.03, + -156.36, + -151.06, + -153.52, + -158.91, + -164.02, + -175.56, + -283.11, + -278.76, + -299.57, + -285.28, + -207.34, + -194.95, + -190.41, + -185.4, + -183.41, + -191.54, + -202.9, + -197.69, + -195.33, + -186.72, + -178.87, + -174.71, + -168.75, + -172.89, + -172.13, + -171.66, + -173.27, + -176.97, + -179.63, + -226.41, + -271.96, + -399.3, + -402.53, + -353.28, + -330.79, + -294.54, + -271.29, + -248.71, + -226.79, + -240.93, + -374.44, + -255.54, + -210.47, + -186.65, + -178.21, + -173.18, + -166.44, + -165.09, + -162.91, + -161.11, + -162.53, + -166.04, + -169.16, + -174.28, + -185.37, + -195.79, + -189.92, + -187.74, + -181.96, + -179.12, + -178.36, + -177.13, + -177.03, + -177.69, + -184.8, + -187.27, + -179.49, + -175.23, + -172.67, + -169.07, + -165.37, + -170.06, + -171.48, + -171.58, + -174.14, + -180.3, + -185.89, + -195.37, + -328.65, + -365.91, + -315, + -242.68, + -230.73, + -225.33, + -225.8, + -213.38, + -207.32, + -215.37, + -243.81, + -243.53, + -215.56, + -192.05, + -187.88, + -181.15, + -172.15, + -174.16, + -171.05, + -170.77, + -174.82, + -179.62, + -178.87, + -191.49, + -229.64, + -336.07, + -242.07, + -228.5, + -201.85, + -196.67, + -192.34, + -190.36, + -187.44, + -186.68, + -190.26, + -191.21, + -187.53, + -179.34, + -171.9, + -166.53, + -160.59, + -166.08, + -157.74, + -145.36, + -145.64, + -147.42, + -149.77, + -153.33, + -141.33, + -145.08, + -150.52, + -153.42, + -159.43, + -159.05, + -149.49, + -147.89, + -150.52, + -157.08, + -172.37, + -174.06, + -171.15, + -160.46, + -147.8, + -141.61, + -134.39, + -144.41, + -140.19, + -138.59, + -140, + -139.53, + -140.28, + -144.03, + -146.57, + -149.39, + -156.24, + -157.93, + -156.43, + -155.21, + -149.86, + -148.07, + -147.13, + -148.82, + -162.53, + -174.74, + -170.89, + -163.94, + -157.93, + -150.7, + -143.94 + ] + }, + "Base" + ], + [ + "unit__node__node", + [ + "Bastusel_pwr_plant", + "electricity_node", + "Bastusel_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.577810871184, + "Base" + ], + [ + "unit__node__node", + [ + "Bergn\u00e4s_pwr_plant", + "electricity_node", + "Bergn\u00e4s_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.0506329113924, + "Base" + ], + [ + "unit__node__node", + [ + "B\u00e5tfors_pwr_plant", + "electricity_node", + "B\u00e5tfors_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.148282097649, + "Base" + ], + [ + "unit__node__node", + [ + "Finnfors_pwr_plant", + "electricity_node", + "Finnfors_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.180985725828, + "Base" + ], + [ + "unit__node__node", + [ + "Gallejaur_pwr_plant", + "electricity_node", + "Gallejaur_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.730442000415, + "Base" + ], + [ + "unit__node__node", + [ + "Granfors_pwr_plant", + "electricity_node", + "Granfors_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.164556962025, + "Base" + ], + [ + "unit__node__node", + [ + "Grytfors_pwr_plant", + "electricity_node", + "Grytfors_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.190257000384, + "Base" + ], + [ + "unit__node__node", + [ + "Kr\u00e5ngfors_pwr_plant", + "electricity_node", + "Kr\u00e5ngfors_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.274261603376, + "Base" + ], + [ + "unit__node__node", + [ + "Kvistforsen_pwr_plant", + "electricity_node", + "Kvistforsen_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.472573839662, + "Base" + ], + [ + "unit__node__node", + [ + "Rebnis_pwr_plant", + "electricity_node", + "Rebnis_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.810126582278, + "Base" + ], + [ + "unit__node__node", + [ + "Reng\u00e5rd_pwr_plant", + "electricity_node", + "Reng\u00e5rd_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.165707710012, + "Base" + ], + [ + "unit__node__node", + [ + "Sadva_pwr_plant", + "electricity_node", + "Sadva_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.448462929476, + "Base" + ], + [ + "unit__node__node", + [ + "Selsfors_pwr_plant", + "electricity_node", + "Selsfors_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.209282700422, + "Base" + ], + [ + "unit__node__node", + [ + "Slagn\u00e4s_pwr_plant", + "electricity_node", + "Slagn\u00e4s_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.0443037974684, + "Base" + ], + [ + "unit__node__node", + [ + "Vargfors_pwr_plant", + "electricity_node", + "Vargfors_upper" + ], + "fix_ratio_out_in_unit_flow", + 0.34299714169, + "Base" + ] + ], + "alternatives": [ + [ + "Base", + "Base alternative" + ] + ] +} \ No newline at end of file diff --git a/examples/unit_commitment.json b/examples/unit_commitment.json new file mode 100644 index 0000000000..c03bb0d1a6 --- /dev/null +++ b/examples/unit_commitment.json @@ -0,0 +1,4000 @@ +{ + "object_classes": [ + [ + "commodity", + "A good or product that can be consumed, produced, traded. E.g., electricity, oil, gas, water...", + 281473533932880 + ], + [ + "connection", + "A transfer of commodities between nodes. E.g. electricity line, gas pipeline...", + 280378317271233 + ], + [ + "investment_group", + "A group of investments that need to be done together.", + 281105609585860 + ], + [ + "model", + "An instance of SpineOpt, that specifies general parameters such as the temporal horizon.", + 281107035648412 + ], + [ + "node", + "A universal aggregator of commodify flows over units and connections, with storage capabilities.", + 280740554077951 + ], + [ + "output", + "A variable name from SpineOpt that can be included in a report.", + 280743406202948 + ], + [ + "report", + "A results report from a particular SpineOpt run, including the value of specific variables.", + 281108461711708 + ], + [ + "settings", + "Internal SpineOpt settings. We kindly advise not to mess with this one.", + 280375465144798 + ], + [ + "stochastic_scenario", + "A scenario for stochastic optimisation in SpineOpt.", + 280743389491710 + ], + [ + "stochastic_structure", + "A group of stochastic scenarios that represent a structure.", + 281470681806146 + ], + [ + "temporal_block", + "A length of time with a particular resolution.", + 280376891207703 + ], + [ + "unit", + "A conversion of one/many comodities between nodes.", + 281470681805429 + ], + [ + "user_constraint", + "A generic data-driven custom constraint.", + 281473533931636 + ] + ], + "relationship_classes": [ + [ + "connection__from_node", + [ + "connection", + "node" + ], + "Defines the `nodes` the `connection` can take input from, and holds most `connection_flow` variable specific parameters.", + 280378317271897 + ], + [ + "connection__from_node__user_constraint", + [ + "connection", + "node", + "user_constraint" + ], + "when specified this relationship allows the relevant flow connection flow variable to be included in the specified user constraint", + null + ], + [ + "connection__investment_group", + [ + "connection", + "investment_group" + ], + "Indicates that a `connection` belongs in an `investment_group`.", + null + ], + [ + "connection__investment_stochastic_structure", + [ + "connection", + "stochastic_structure" + ], + "Defines the stochastic structure of the connections investments variable", + null + ], + [ + "connection__investment_temporal_block", + [ + "connection", + "temporal_block" + ], + "Defines the temporal resolution of the connections investments variable", + null + ], + [ + "connection__node__node", + [ + "connection", + "node", + "node" + ], + "Holds parameters spanning multiple `connection_flow` variables to and from multiple `nodes`.", + null + ], + [ + "connection__to_node", + [ + "connection", + "node" + ], + "Defines the `nodes` the `connection` can output to, and holds most `connection_flow` variable specific parameters.", + 280378317271898 + ], + [ + "connection__to_node__user_constraint", + [ + "connection", + "node", + "user_constraint" + ], + "when specified this relationship allows the relevant flow connection flow variable to be included in the specified user constraint", + null + ], + [ + "connection__user_constraint", + [ + "connection", + "user_constraint" + ], + "Relationship required to involve a connections investment variables in a user_constraint", + null + ], + [ + "model__default_investment_stochastic_structure", + [ + "model", + "stochastic_structure" + ], + "Defines the default stochastic structure used for investment variables, which will be replaced by more specific definitions", + null + ], + [ + "model__default_investment_temporal_block", + [ + "model", + "temporal_block" + ], + "Defines the default temporal block used for investment variables, which will be replaced by more specific definitions", + null + ], + [ + "model__default_stochastic_structure", + [ + "model", + "stochastic_structure" + ], + "Defines the default stochastic structure used for model variables, which will be replaced by more specific definitions", + null + ], + [ + "model__default_temporal_block", + [ + "model", + "temporal_block" + ], + "Defines the default temporal block used for model variables, which will be replaced by more specific definitions", + null + ], + [ + "model__report", + [ + "model", + "report" + ], + "Determines which reports are written for each model and in turn, which outputs are written for each model", + null + ], + [ + "model__stochastic_structure", + [ + "model", + "stochastic_structure" + ], + "Defines which `stochastic_structure`s are included in which `model`s.", + null + ], + [ + "model__temporal_block", + [ + "model", + "temporal_block" + ], + "Defines which `temporal_block`s are included in which `model`s.", + null + ], + [ + "node__commodity", + [ + "node", + "commodity" + ], + "Define a `commodity` for a `node`. Only a single `commodity` is permitted per `node`", + null + ], + [ + "node__investment_group", + [ + "node", + "investment_group" + ], + "Indicates that a `node` belongs in a `investment_group`.", + null + ], + [ + "node__investment_stochastic_structure", + [ + "node", + "stochastic_structure" + ], + "defines the stochastic structure for node related investments, currently only storages", + null + ], + [ + "node__investment_temporal_block", + [ + "node", + "temporal_block" + ], + "defines the temporal resolution for node related investments, currently only storages", + null + ], + [ + "node__node", + [ + "node", + "node" + ], + "Holds parameters for direct interactions between two `nodes`, e.g. `node_state` diffusion coefficients.", + null + ], + [ + "node__stochastic_structure", + [ + "node", + "stochastic_structure" + ], + "Defines which specific `stochastic_structure` is used by the `node` and all `flow` variables associated with it. Only one `stochastic_structure` is permitted per `node`.", + null + ], + [ + "node__temporal_block", + [ + "node", + "temporal_block" + ], + "Defines the `temporal_blocks` used by the `node` and all the `flow` variables associated with it.", + null + ], + [ + "node__user_constraint", + [ + "node", + "user_constraint" + ], + "specifying this relationship allows a node's demand or node_state to be included in the specified user constraint", + null + ], + [ + "parent_stochastic_scenario__child_stochastic_scenario", + [ + "stochastic_scenario", + "stochastic_scenario" + ], + "Defines the master stochastic direct acyclic graph, meaning how the `stochastic_scenarios` are related to each other.", + null + ], + [ + "report__output", + [ + "report", + "output" + ], + "Output object related to a report object are returned to the output database (if they appear in the model as variables)", + null + ], + [ + "stochastic_structure__stochastic_scenario", + [ + "stochastic_structure", + "stochastic_scenario" + ], + "Defines which `stochastic_scenarios` are included in which `stochastic_structure`, and holds the parameters required for realizing the structure in combination with the `temporal_blocks`.", + null + ], + [ + "unit__commodity", + [ + "unit", + "commodity" + ], + "Holds parameters for `commodities` used by the `unit`.", + null + ], + [ + "unit__from_node", + [ + "unit", + "node" + ], + "Defines the `nodes` the `unit` can take input from, and holds most `unit_flow` variable specific parameters.", + 281470681805657 + ], + [ + "unit__from_node__user_constraint", + [ + "unit", + "node", + "user_constraint" + ], + "Defines which input `unit_flows` are included in the `user_constraint`, and holds their parameters.", + null + ], + [ + "unit__investment_group", + [ + "unit", + "investment_group" + ], + "Indicates that a `unit` belongs in an `investment_group`.", + null + ], + [ + "unit__investment_stochastic_structure", + [ + "unit", + "stochastic_structure" + ], + "Sets the stochastic structure for investment decisions - overrides `model__default_investment_stochastic_structure`.", + null + ], + [ + "unit__investment_temporal_block", + [ + "unit", + "temporal_block" + ], + "Sets the temporal resolution of investment decisions - overrides `model__default_investment_temporal_block`", + null + ], + [ + "unit__node__node", + [ + "unit", + "node", + "node" + ], + "Holds parameters spanning multiple `unit_flow` variables to and from multiple `nodes`.", + null + ], + [ + "unit__to_node", + [ + "unit", + "node" + ], + "Defines the `nodes` the `unit` can output to, and holds most `unit_flow` variable specific parameters.", + 281470681805658 + ], + [ + "unit__to_node__user_constraint", + [ + "unit", + "node", + "user_constraint" + ], + "Defines which output `unit_flows` are included in the `user_constraint`, and holds their parameters.", + null + ], + [ + "unit__user_constraint", + [ + "unit", + "user_constraint" + ], + "Defines which `units_on` variables are included in the `user_constraint`, and holds their parameters.", + null + ], + [ + "units_on__stochastic_structure", + [ + "unit", + "stochastic_structure" + ], + "Defines which specific `stochastic_structure` is used for the `units_on` variable of the `unit`. Only one `stochastic_structure` is permitted per `unit`.", + null + ], + [ + "units_on__temporal_block", + [ + "unit", + "temporal_block" + ], + "Defines which specific `temporal_blocks` are used by the `units_on` variable of the `unit`.", + null + ] + ], + "parameter_value_lists": [ + [ + "balance_type_list", + "balance_type_group" + ], + [ + "balance_type_list", + "balance_type_node" + ], + [ + "balance_type_list", + "balance_type_none" + ], + [ + "boolean_value_list", + false + ], + [ + "boolean_value_list", + true + ], + [ + "commodity_physics_list", + "commodity_physics_lodf" + ], + [ + "commodity_physics_list", + "commodity_physics_none" + ], + [ + "commodity_physics_list", + "commodity_physics_ptdf" + ], + [ + "connection_investment_variable_type_list", + "connection_investment_variable_type_continuous" + ], + [ + "connection_investment_variable_type_list", + "connection_investment_variable_type_integer" + ], + [ + "connection_type_list", + "connection_type_lossless_bidirectional" + ], + [ + "connection_type_list", + "connection_type_normal" + ], + [ + "constraint_sense_list", + "<=" + ], + [ + "constraint_sense_list", + "==" + ], + [ + "constraint_sense_list", + ">=" + ], + [ + "db_lp_solver_list", + "KNITRO.jl" + ], + [ + "db_lp_solver_list", + "CDCS.jl" + ], + [ + "db_lp_solver_list", + "CDDLib.jl" + ], + [ + "db_lp_solver_list", + "Clp.jl" + ], + [ + "db_lp_solver_list", + "COSMO.jl" + ], + [ + "db_lp_solver_list", + "CPLEX.jl" + ], + [ + "db_lp_solver_list", + "CSDP.jl" + ], + [ + "db_lp_solver_list", + "ECOS.jl" + ], + [ + "db_lp_solver_list", + "Xpress.jl" + ], + [ + "db_lp_solver_list", + "GLPK.jl" + ], + [ + "db_lp_solver_list", + "Gurobi.jl" + ], + [ + "db_lp_solver_list", + "HiGHS.jl" + ], + [ + "db_lp_solver_list", + "Hypatia.jl" + ], + [ + "db_lp_solver_list", + "Ipopt.jl" + ], + [ + "db_lp_solver_list", + "MadNLP.jl" + ], + [ + "db_lp_solver_list", + "MosekTools.jl" + ], + [ + "db_lp_solver_list", + "NLopt.jl" + ], + [ + "db_lp_solver_list", + "OSQP.jl" + ], + [ + "db_lp_solver_list", + "ProxSDP.jl" + ], + [ + "db_lp_solver_list", + "SCIP.jl" + ], + [ + "db_lp_solver_list", + "SCS.jl" + ], + [ + "db_lp_solver_list", + "SDPA.jl" + ], + [ + "db_lp_solver_list", + "SDPNAL.jl" + ], + [ + "db_lp_solver_list", + "SDPT3.jl" + ], + [ + "db_lp_solver_list", + "SeDuMi.jl" + ], + [ + "db_mip_solver_list", + "KNITRO.jl" + ], + [ + "db_mip_solver_list", + "Cbc.jl" + ], + [ + "db_mip_solver_list", + "CPLEX.jl" + ], + [ + "db_mip_solver_list", + "HiGHS.jl" + ], + [ + "db_mip_solver_list", + "Xpress.jl" + ], + [ + "db_mip_solver_list", + "GLPK.jl" + ], + [ + "db_mip_solver_list", + "Gurobi.jl" + ], + [ + "db_mip_solver_list", + "Juniper.jl" + ], + [ + "db_mip_solver_list", + "MosekTools.jl" + ], + [ + "db_mip_solver_list", + "SCIP.jl" + ], + [ + "duration_unit_list", + "hour" + ], + [ + "duration_unit_list", + "minute" + ], + [ + "model_type_list", + "spineopt_benders" + ], + [ + "model_type_list", + "spineopt_standard" + ], + [ + "model_type_list", + "spineopt_other" + ], + [ + "model_type_list", + "spineopt_mga" + ], + [ + "node_opf_type_list", + "node_opf_type_normal" + ], + [ + "node_opf_type_list", + "node_opf_type_reference" + ], + [ + "unit_investment_variable_type_list", + "unit_investment_variable_type_continuous" + ], + [ + "unit_investment_variable_type_list", + "unit_investment_variable_type_integer" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_binary" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_integer" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_linear" + ], + [ + "unit_online_variable_type_list", + "unit_online_variable_type_none" + ], + [ + "variable_type_list", + "variable_type_binary" + ], + [ + "variable_type_list", + "variable_type_continuous" + ], + [ + "variable_type_list", + "variable_type_integer" + ], + [ + "write_mps_file_list", + "write_mps_always" + ], + [ + "write_mps_file_list", + "write_mps_never" + ], + [ + "write_mps_file_list", + "write_mps_on_no_solve" + ] + ], + "object_parameters": [ + [ + "commodity", + "commodity_lodf_tolerance", + 0.1, + null, + "The minimum absolute value of the line outage distribution factor (LODF) that is considered meaningful." + ], + [ + "commodity", + "commodity_physics", + "commodity_physics_none", + "commodity_physics_list", + "Defines if the `commodity` follows lodf or ptdf physics." + ], + [ + "commodity", + "commodity_ptdf_threshold", + 0.001, + null, + "The minimum absolute value of the power transfer distribution factor (PTDF) that is considered meaningful." + ], + [ + "commodity", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "commodity", + "mp_min_res_gen_to_demand_ratio", + null, + null, + "Minimum ratio of renewable generation to demand for this commodity - used in the minimum renewable generation constraint within the Benders master problem" + ], + [ + "commodity", + "mp_min_res_gen_to_demand_ratio_slack_penalty", + null, + null, + "Penalty for violating the minimum renewable generation to demand ratio." + ], + [ + "connection", + "candidate_connections", + null, + null, + "The number of connections that may be invested in" + ], + [ + "connection", + "connection_availability_factor", + 1.0, + null, + "Availability of the `connection`, acting as a multiplier on its `connection_capacity`. Typically between 0-1." + ], + [ + "connection", + "connection_contingency", + null, + "boolean_value_list", + "A boolean flag for defining a contingency `connection`." + ], + [ + "connection", + "connection_investment_cost", + null, + null, + "The per unit investment cost for the connection over the `connection_investment_lifetime`" + ], + [ + "connection", + "connection_investment_lifetime", + null, + null, + "Determines the minimum investment lifetime of a connection. Once invested, it remains in service for this long" + ], + [ + "connection", + "connection_investment_variable_type", + "variable_type_integer", + "variable_type_list", + "Determines whether the investment variable is integer `variable_type_integer` or continuous `variable_type_continuous`" + ], + [ + "connection", + "connection_monitored", + false, + "boolean_value_list", + "A boolean flag for defining a contingency `connection`." + ], + [ + "connection", + "connection_reactance", + null, + null, + "The per unit reactance of a `connection`." + ], + [ + "connection", + "connection_reactance_base", + 1, + null, + "If the reactance is given for a p.u. (e.g. p.u. = 100MW), the `connection_reactance_base` can be set to perform this conversion (e.g. *100)." + ], + [ + "connection", + "connection_resistance", + null, + null, + "The per unit resistance of a `connection`." + ], + [ + "connection", + "connection_type", + "connection_type_normal", + "connection_type_list", + "A selector between a normal and a lossless bidirectional `connection`." + ], + [ + "connection", + "connections_invested_big_m_mga", + null, + null, + "big_m_mga should be chosen as small as possible but sufficiently large. For units_invested_mga an appropriate big_m_mga would be twice the candidate connections." + ], + [ + "connection", + "connections_invested_mga", + false, + "boolean_value_list", + "Defines whether a certain variable (here: connections_invested) will be considered in the maximal-differences of the mga objective" + ], + [ + "connection", + "connections_invested_mga_weight", + 1, + null, + "Used to scale mga variables. For weightd sum mga method, the length of this weight given as an Array will determine the number of iterations." + ], + [ + "connection", + "fix_connections_invested", + null, + null, + "Setting a value fixes the connections_invested variable accordingly" + ], + [ + "connection", + "fix_connections_invested_available", + null, + null, + "Setting a value fixes the connections_invested_available variable accordingly" + ], + [ + "connection", + "forced_availability_factor", + null, + null, + "Availability factor due to outages/deratings." + ], + [ + "connection", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "connection", + "has_binary_gas_flow", + false, + "boolean_value_list", + "This parameter needs to be set to `true` in order to represent bidirectional pressure drive gas transfer." + ], + [ + "connection", + "initial_connections_invested", + null, + null, + "Setting a value fixes the connections_invested variable at the beginning" + ], + [ + "connection", + "initial_connections_invested_available", + null, + null, + "Setting a value fixes the connections_invested_available variable at the beginning" + ], + [ + "connection", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "model", + "big_m", + 1000000, + null, + "Sufficiently large number used for linearization bilinear terms, e.g. to enforce bidirectional flow for gas pipielines" + ], + [ + "model", + "db_lp_solver", + "HiGHS.jl", + "db_lp_solver_list", + "Solver for MIP problems. Solver package must be added and pre-configured in Julia. Overrides lp_solver RunSpineOpt kwarg" + ], + [ + "model", + "db_lp_solver_options", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "HiGHS.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "presolve", + "on" + ], + [ + "time_limit", + 300.01 + ] + ] + } + ], + [ + "Clp.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "LogLevel", + 0.0 + ] + ] + } + ] + ] + }, + null, + "Map parameter containing LP solver option name option value pairs. See solver documentation for supported solver options" + ], + [ + "model", + "db_mip_solver", + "HiGHS.jl", + "db_mip_solver_list", + "Solver for MIP problems. Solver package must be added and pre-configured in Julia. Overrides mip_solver RunSpineOpt kwarg" + ], + [ + "model", + "db_mip_solver_options", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "HiGHS.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "presolve", + "on" + ], + [ + "mip_rel_gap", + 0.01 + ], + [ + "threads", + 0.0 + ], + [ + "time_limit", + 300.01 + ] + ] + } + ], + [ + "Cbc.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "ratioGap", + 0.01 + ], + [ + "logLevel", + 0.0 + ] + ] + } + ], + [ + "CPLEX.jl", + { + "type": "map", + "index_type": "str", + "data": [ + [ + "CPX_PARAM_EPGAP", + 0.01 + ] + ] + } + ] + ] + }, + null, + "Map parameter containing MIP solver option name option value pairs for MIP. See solver documentation for supported solver options" + ], + [ + "model", + "duration_unit", + "hour", + "duration_unit_list", + "Defines the base temporal unit of the `model`. Currently supported values are either an `hour` or a `minute`." + ], + [ + "model", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "model", + "max_gap", + 0.05, + null, + "Specifies the maximum optimality gap for the model. Currently only used for the master problem within a decomposed structure" + ], + [ + "model", + "max_iterations", + 10.0, + null, + "Specifies the maximum number of iterations for the model. Currently only used for the master problem within a decomposed structure" + ], + [ + "model", + "max_mga_iterations", + null, + null, + "Define the number of mga iterations, i.e. how many alternative solutions will be generated." + ], + [ + "model", + "max_mga_slack", + 0.05, + null, + "Defines the maximum slack by which the alternative solution may differ from the original solution (e.g. 5% more than initial objective function value)" + ], + [ + "model", + "model_end", + { + "type": "date_time", + "data": "2000-01-02T00:00:00" + }, + null, + "Defines the last timestamp to be modelled. Rolling optimization terminates after passing this point." + ], + [ + "model", + "model_start", + { + "type": "date_time", + "data": "2000-01-01T00:00:00" + }, + null, + "Defines the first timestamp to be modelled. Relative `temporal_blocks` refer to this value for their start and end." + ], + [ + "model", + "model_type", + "spineopt_standard", + "model_type_list", + "Used to identify model objects as relating to the master problem or operational sub problems (default)" + ], + [ + "model", + "roll_forward", + null, + null, + "Defines how much the model moves ahead in time between solves in a rolling optimization. Without this parameter, everything is solved in as a single optimization." + ], + [ + "model", + "window_duration", + null, + null, + "The duration of the window in case it differs from roll_forward" + ], + [ + "model", + "window_weight", + 1, + null, + "The weight of the window in the rolling subproblem" + ], + [ + "model", + "write_lodf_file", + false, + "boolean_value_list", + "A boolean flag for whether the LODF values should be written to a results file." + ], + [ + "model", + "write_mps_file", + null, + "write_mps_file_list", + "A selector for writing an .mps file of the model." + ], + [ + "model", + "write_ptdf_file", + false, + "boolean_value_list", + "A boolean flag for whether the LODF values should be written to a results file." + ], + [ + "node", + "balance_type", + "balance_type_node", + "balance_type_list", + "A selector for how the `:nodal_balance` constraint should be handled." + ], + [ + "node", + "candidate_storages", + null, + null, + "Determines the maximum number of new storages which may be invested in" + ], + [ + "node", + "demand", + 0.0, + null, + "Demand for the `commodity` of a `node`. Energy gains can be represented using negative `demand`." + ], + [ + "node", + "downward_reserve", + false, + null, + "Identifier for `node`s providing downward reserves" + ], + [ + "node", + "fix_node_pressure", + null, + null, + "Fixes the corresponding `node_pressure` variable to the provided value" + ], + [ + "node", + "fix_node_state", + null, + null, + "Fixes the corresponding `node_state` variable to the provided value. Can be used for e.g. fixing boundary conditions." + ], + [ + "node", + "fix_node_voltage_angle", + null, + null, + "Fixes the corresponding `node_voltage_angle` variable to the provided value" + ], + [ + "node", + "fix_storages_invested", + null, + null, + "Used to fix the value of the storages_invested variable" + ], + [ + "node", + "fix_storages_invested_available", + null, + null, + "Used to fix the value of the storages_invested_available variable" + ], + [ + "node", + "frac_state_loss", + 0.0, + null, + "Self-discharge coefficient for `node_state` variables. Effectively, represents the *loss power per unit of state*." + ], + [ + "node", + "fractional_demand", + 0.0, + null, + "The fraction of a `node` group's `demand` applied for the `node` in question." + ], + [ + "node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "node", + "has_pressure", + false, + "boolean_value_list", + "A boolean flag for whether a `node` has a `node_pressure` variable." + ], + [ + "node", + "has_state", + false, + "boolean_value_list", + "A boolean flag for whether a `node` has a `node_state` variable." + ], + [ + "node", + "has_voltage_angle", + false, + "boolean_value_list", + "A boolean flag for whether a `node` has a `node_voltage_angle` variable." + ], + [ + "node", + "initial_node_pressure", + null, + null, + "Initializes the corresponding `node_pressure` variable to the provided value" + ], + [ + "node", + "initial_node_state", + null, + null, + "Initializes the corresponding `node_state` variable to the provided value." + ], + [ + "node", + "initial_node_voltage_angle", + null, + null, + "Initializes the corresponding `node_voltage_angle` variable to the provided value" + ], + [ + "node", + "initial_storages_invested", + null, + null, + "Used to initialze the value of the storages_invested variable" + ], + [ + "node", + "initial_storages_invested_available", + null, + null, + "Used to initialze the value of the storages_invested_available variable" + ], + [ + "node", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "node", + "is_non_spinning", + false, + "boolean_value_list", + "A boolean flag for whether a `node` is acting as a non-spinning reserve" + ], + [ + "node", + "is_reserve_node", + false, + "boolean_value_list", + "A boolean flag for whether a `node` is acting as a `reserve_node`" + ], + [ + "node", + "max_node_pressure", + null, + null, + "Maximum allowed gas pressure at `node`." + ], + [ + "node", + "max_voltage_angle", + null, + null, + "Maximum allowed voltage angle at `node`." + ], + [ + "node", + "min_node_pressure", + null, + null, + "Minimum allowed gas pressure at `node`." + ], + [ + "node", + "min_voltage_angle", + null, + null, + "Minimum allowed voltage angle at `node`. " + ], + [ + "node", + "minimum_reserve_activation_time", + null, + null, + "Duration a certain reserve product needs to be online/available" + ], + [ + "node", + "nodal_balance_sense", + "==", + "constraint_sense_list", + "A selector for `nodal_balance` constraint sense." + ], + [ + "node", + "node_opf_type", + "node_opf_type_normal", + "node_opf_type_list", + "A selector for the reference `node` (slack bus) when PTDF-based DC load-flow is enabled." + ], + [ + "node", + "node_slack_penalty", + null, + null, + "A penalty cost for `node_slack_pos` and `node_slack_neg` variables. The slack variables won't be included in the model unless there's a cost defined for them." + ], + [ + "node", + "node_state_cap", + null, + null, + "The maximum permitted value for a `node_state` variable." + ], + [ + "node", + "node_state_min", + 0.0, + null, + "The minimum permitted value for a `node_state` variable." + ], + [ + "node", + "state_coeff", + 1.0, + null, + "Represents the `commodity` content of a `node_state` variable in respect to the `unit_flow` and `connection_flow` variables. Essentially, acts as a coefficient on the `node_state` variable in the `:node_injection` constraint." + ], + [ + "node", + "storage_investment_cost", + null, + null, + "Determines the investment cost per unit state_cap over the investment life of a storage" + ], + [ + "node", + "storage_investment_lifetime", + null, + null, + "Minimum lifetime for storage investment decisions." + ], + [ + "node", + "storage_investment_variable_type", + "variable_type_integer", + "variable_type_list", + "Determines whether the storage investment variable is continuous (usually representing capacity) or integer (representing discrete units invested)" + ], + [ + "node", + "storages_invested_big_m_mga", + null, + null, + "big_m_mga should be chosen as small as possible but sufficiently large. For units_invested_mga an appropriate big_m_mga would be twice the candidate storages." + ], + [ + "node", + "storages_invested_mga", + false, + "boolean_value_list", + "Defines whether a certain variable (here: storages_invested) will be considered in the maximal-differences of the mga objective" + ], + [ + "node", + "storages_invested_mga_weight", + 1, + null, + "Used to scale mga variables. For weighted-sum mga method, the length of this weight given as an Array will determine the number of iterations." + ], + [ + "node", + "tax_in_unit_flow", + null, + null, + "Tax costs for incoming `unit_flows` on this `node`. E.g. EUR/MWh." + ], + [ + "node", + "tax_net_unit_flow", + null, + null, + "Tax costs for net incoming and outgoing `unit_flows` on this `node`. Incoming flows accrue positive net taxes, and outgoing flows accrue negative net taxes." + ], + [ + "node", + "tax_out_unit_flow", + null, + null, + "Tax costs for outgoing `unit_flows` from this `node`. E.g. EUR/MWh." + ], + [ + "node", + "upward_reserve", + false, + null, + "Identifier for `node`s providing upward reserves" + ], + [ + "output", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "output", + "output_resolution", + null, + null, + "Temporal resolution of the output variables associated with this `output`." + ], + [ + "report", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "report", + "output_db_url", + null, + null, + "Database url for SpineOpt output." + ], + [ + "settings", + "version", + 8, + null, + "Current version of the SpineOpt data structure. Modify it at your own risk (but please don't)." + ], + [ + "stochastic_scenario", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "stochastic_structure", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "temporal_block", + "block_end", + null, + null, + "The end time for the `temporal_block`. Can be given either as a `DateTime` for a static end point, or as a `Duration` for an end point relative to the start of the current optimization." + ], + [ + "temporal_block", + "block_start", + null, + null, + "The start time for the `temporal_block`. Can be given either as a `DateTime` for a static start point, or as a `Duration` for an start point relative to the start of the current optimization." + ], + [ + "temporal_block", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "temporal_block", + "representative_periods_mapping", + null, + null, + "Map from date time to representative temporal block name" + ], + [ + "temporal_block", + "resolution", + { + "type": "duration", + "data": "1h" + }, + null, + "Temporal resolution of the `temporal_block`. Essentially, divides the period between `block_start` and `block_end` into `TimeSlices` with the input `resolution`." + ], + [ + "temporal_block", + "weight", + 1.0, + null, + "Weighting factor of the temporal block associated with the objective function" + ], + [ + "unit", + "candidate_units", + null, + null, + "Number of units which may be additionally constructed" + ], + [ + "unit", + "curtailment_cost", + null, + null, + "Costs for curtailing generation. Essentially, accrues costs whenever `unit_flow` not operating at its maximum available capacity. E.g. EUR/MWh" + ], + [ + "unit", + "fix_units_invested", + null, + null, + "Fix the value of the `units_invested` variable." + ], + [ + "unit", + "fix_units_invested_available", + null, + null, + "Fix the value of the `units_invested_available` variable" + ], + [ + "unit", + "fix_units_on", + null, + null, + "Fix the value of the `units_on` variable." + ], + [ + "unit", + "fom_cost", + null, + null, + "Fixed operation and maintenance costs of a `unit`. Essentially, a cost coefficient on the existing units (incl. `number_of_units` and `units_invested_available`) and `unit_capacity` parameters. E.g. EUR/MWh" + ], + [ + "unit", + "forced_availability_factor", + null, + null, + "Availability factor due to outages/deratings." + ], + [ + "unit", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit", + "initial_units_invested", + null, + null, + "Initialize the value of the `units_invested` variable." + ], + [ + "unit", + "initial_units_invested_available", + null, + null, + "Initialize the value of the `units_invested_available` variable" + ], + [ + "unit", + "initial_units_on", + null, + null, + "Initialize the value of the `units_on` variable." + ], + [ + "unit", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "unit", + "is_renewable", + false, + "boolean_value_list", + "Whether the unit is renewable - used in the minimum renewable generation constraint within the Benders master problem" + ], + [ + "unit", + "min_down_time", + null, + null, + "Minimum downtime of a `unit` after it shuts down." + ], + [ + "unit", + "min_up_time", + null, + null, + "Minimum uptime of a `unit` after it starts up." + ], + [ + "unit", + "number_of_units", + 1.0, + null, + "Denotes the number of 'sub units' aggregated to form the modelled `unit`." + ], + [ + "unit", + "online_variable_type", + "unit_online_variable_type_linear", + "unit_online_variable_type_list", + "A selector for how the `units_on` variable is represented within the model." + ], + [ + "unit", + "shut_down_cost", + null, + null, + "Costs of shutting down a 'sub unit', e.g. EUR/shutdown." + ], + [ + "unit", + "start_up_cost", + null, + null, + "Costs of starting up a 'sub unit', e.g. EUR/startup." + ], + [ + "unit", + "unit_availability_factor", + 1.0, + null, + "Availability of the `unit`, acting as a multiplier on its `unit_capacity`. Typically between 0-1." + ], + [ + "unit", + "unit_investment_cost", + null, + null, + "Investment cost per 'sub unit' built." + ], + [ + "unit", + "unit_investment_lifetime", + null, + null, + "Minimum lifetime for unit investment decisions." + ], + [ + "unit", + "unit_investment_variable_type", + "unit_investment_variable_type_continuous", + "unit_investment_variable_type_list", + "Determines whether investment variable is integer or continuous." + ], + [ + "unit", + "units_invested_big_m_mga", + null, + null, + "big_m_mga should be chosen as small as possible but sufficiently large. For units_invested_mga an appropriate big_m_mga would be twice the candidate units." + ], + [ + "unit", + "units_invested_mga", + false, + "boolean_value_list", + "Defines whether a certain variable (here: units_invested) will be considered in the maximal-differences of the mga objective" + ], + [ + "unit", + "units_invested_mga_weight", + 1, + null, + "Used to scale mga variables. For weightd sum mga method, the length of this weight given as an Array will determine the number of iterations." + ], + [ + "unit", + "units_on_cost", + null, + null, + "Objective function coefficient on `units_on`. An idling cost, for example" + ], + [ + "unit", + "units_on_non_anticipativity_margin", + null, + null, + "Margin by which `units_on` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "unit", + "units_on_non_anticipativity_time", + null, + null, + "Period of time where the value of the `units_on` variable has to be fixed to the result from the previous window." + ], + [ + "user_constraint", + "constraint_sense", + "==", + "constraint_sense_list", + "A selector for the sense of the `user_constraint`." + ], + [ + "user_constraint", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "user_constraint", + "right_hand_side", + 0.0, + null, + "The right-hand side, constant term in a `user_constraint`. Can be time-dependent and used e.g. for complicated efficiency approximations." + ] + ], + "relationship_parameters": [ + [ + "connection__from_node", + "connection_capacity", + null, + null, + "Limits the `connection_flow` variable from the `from_node`. `from_node` can be a group of `nodes`, in which case the sum of the `connection_flow` is constrained." + ], + [ + "connection__from_node", + "connection_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `connection_capacity` unit conversions in the case that the `connection_capacity` value is incompatible with the desired `connection_flow` units." + ], + [ + "connection__from_node", + "connection_emergency_capacity", + null, + null, + "Post contingency flow capacity of a `connection`. Sometimes referred to as emergency rating" + ], + [ + "connection__from_node", + "connection_flow_cost", + null, + null, + "Variable costs of a flow through a `connection`. E.g. EUR/MWh of energy throughput." + ], + [ + "connection__from_node", + "connection_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__from_node", + "connection_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__from_node", + "connection_intact_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_intact_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__from_node", + "connection_intact_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_intact_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__from_node", + "fix_binary_gas_connection_flow", + null, + null, + "Fix the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__from_node", + "fix_connection_flow", + null, + null, + "Fix the value of the `connection_flow` variable." + ], + [ + "connection__from_node", + "fix_connection_intact_flow", + null, + null, + "Fix the value of the `connection_intact_flow` variable." + ], + [ + "connection__from_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "connection__from_node", + "initial_binary_gas_connection_flow", + null, + null, + "Initialize the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__from_node", + "initial_connection_flow", + null, + null, + "Initialize the value of the `connection_flow` variable." + ], + [ + "connection__from_node", + "initial_connection_intact_flow", + null, + null, + "Initialize the value of the `connection_intact_flow` variable." + ], + [ + "connection__from_node__user_constraint", + "connection_flow_coefficient", + 0.0, + null, + "defines the user constraint coefficient on the connection flow variable in the from direction" + ], + [ + "connection__node__node", + "compression_factor", + null, + null, + "The compression factor establishes a compression from an origin node to a receiving node, which are connected through a connection. The first node corresponds to the origin node, the second to the (compressed) destination node. Typically the value is >=1." + ], + [ + "connection__node__node", + "connection_flow_delay", + { + "type": "duration", + "data": "0h" + }, + null, + "Delays the `connection_flows` associated with the latter `node` in respect to the `connection_flows` associated with the first `node`." + ], + [ + "connection__node__node", + "connection_linepack_constant", + null, + null, + "The linepack constant is a property of gas pipelines and relates the linepack to the pressure of the adjacent nodes." + ], + [ + "connection__node__node", + "fix_ratio_out_in_connection_flow", + null, + null, + "Fix the ratio between the `connection_flow` from the first `node` and the `connection_flow` to the second `node`." + ], + [ + "connection__node__node", + "fixed_pressure_constant_0", + null, + null, + "Fixed pressure points for pipelines for the outer approximation of the Weymouth approximation. The direction of flow is the first node in the relationship to the second node in the relationship." + ], + [ + "connection__node__node", + "fixed_pressure_constant_1", + null, + null, + "Fixed pressure points for pipelines for the outer approximation of the Weymouth approximation. The direction of flow is the first node in the relationship to the second node in the relationship." + ], + [ + "connection__node__node", + "max_ratio_out_in_connection_flow", + null, + null, + "Maximum ratio between the `connection_flow` from the first `node` and the `connection_flow` to the second `node`." + ], + [ + "connection__node__node", + "min_ratio_out_in_connection_flow", + null, + null, + "Minimum ratio between the `connection_flow` from the first `node` and the `connection_flow` to the second `node`." + ], + [ + "connection__to_node", + "connection_capacity", + null, + null, + "Limits the `connection_flow` variable to the `to_node`. `to_node` can be a group of `nodes`, in which case the sum of the `connection_flow` is constrained." + ], + [ + "connection__to_node", + "connection_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `connection_capacity` unit conversions in the case the `connection_capacity` value is incompatible with the desired `connection_flow` units." + ], + [ + "connection__to_node", + "connection_emergency_capacity", + null, + null, + "The maximum post-contingency flow on a monitored `connection`." + ], + [ + "connection__to_node", + "connection_flow_cost", + null, + null, + "Variable costs of a flow through a `connection`. E.g. EUR/MWh of energy throughput." + ], + [ + "connection__to_node", + "connection_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__to_node", + "connection_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__to_node", + "connection_intact_flow_non_anticipativity_margin", + null, + null, + "Margin by which `connection_intact_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "connection__to_node", + "connection_intact_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `connection_intact_flow` variable has to be fixed to the result from the previous window." + ], + [ + "connection__to_node", + "fix_binary_gas_connection_flow", + null, + null, + "Fix the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__to_node", + "fix_connection_flow", + null, + null, + "Fix the value of the `connection_flow` variable." + ], + [ + "connection__to_node", + "fix_connection_intact_flow", + null, + null, + "Fix the value of the `connection_intact_flow` variable." + ], + [ + "connection__to_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "connection__to_node", + "initial_binary_gas_connection_flow", + null, + null, + "Initialize the value of the `connection_flow_binary` variable, and hence pre-determine the direction of flow in the connection." + ], + [ + "connection__to_node", + "initial_connection_flow", + null, + null, + "Initialize the value of the `connection_flow` variable." + ], + [ + "connection__to_node", + "initial_connection_intact_flow", + null, + null, + "Initialize the value of the `connection_intact_flow` variable." + ], + [ + "connection__to_node__user_constraint", + "connection_flow_coefficient", + 0.0, + null, + "defines the user constraint coefficient on the connection flow variable in the to direction" + ], + [ + "connection__user_constraint", + "connections_invested_available_coefficient", + 0.0, + null, + "coefficient of `connections_invested_available` in the specific `user_constraint`" + ], + [ + "connection__user_constraint", + "connections_invested_coefficient", + 0.0, + null, + "coefficient of `connections_invested` in the specific `user_constraint`" + ], + [ + "node__node", + "diff_coeff", + 0.0, + null, + "Commodity diffusion coefficient between two `nodes`. Effectively, denotes the *diffusion power per unit of state* from the first `node` to the second." + ], + [ + "node__stochastic_structure", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "node__temporal_block", + "cyclic_condition", + false, + "boolean_value_list", + "If the cyclic condition is set to true for a storage node, the `node_state` at the end of the optimization window has to be larger than or equal to the initial storage state." + ], + [ + "node__temporal_block", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "node__user_constraint", + "demand_coefficient", + 0.0, + null, + "coefficient of the specified node's demand in the specified user constraint" + ], + [ + "node__user_constraint", + "node_state_coefficient", + 0.0, + null, + "Coefficient of the specified node's state variable in the specified user constraint." + ], + [ + "node__user_constraint", + "storages_invested_available_coefficient", + 0.0, + null, + "Coefficient of the specified node's storages invested available variable in the specified user constraint." + ], + [ + "node__user_constraint", + "storages_invested_coefficient", + 0.0, + null, + "Coefficient of the specified node's storage investment variable in the specified user constraint." + ], + [ + "report__output", + "overwrite_results_on_rolling", + true, + null, + "Whether or not results from further windows should overwrite results from previous ones." + ], + [ + "stochastic_structure__stochastic_scenario", + "stochastic_scenario_end", + null, + null, + "A `Duration` for when a `stochastic_scenario` ends and its `child_stochastic_scenarios` start. Values are interpreted relative to the start of the current solve, and if no value is given, the `stochastic_scenario` is assumed to continue indefinitely." + ], + [ + "stochastic_structure__stochastic_scenario", + "weight_relative_to_parents", + 1.0, + null, + "The weight of the `stochastic_scenario` in the objective function relative to its parents." + ], + [ + "unit__commodity", + "max_cum_in_unit_flow_bound", + null, + null, + "Set a maximum cumulative upper bound for a `unit_flow`" + ], + [ + "unit__from_node", + "fix_nonspin_ramp_up_unit_flow", + null, + null, + "Fix the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "fix_nonspin_units_started_up", + null, + null, + "Fix the `nonspin_units_started_up` variable." + ], + [ + "unit__from_node", + "fix_ramp_up_unit_flow", + null, + null, + "Fix the `ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "fix_start_up_unit_flow", + null, + null, + "Fix the `start_up_unit_flow` variable." + ], + [ + "unit__from_node", + "fix_unit_flow", + null, + null, + "Fix the `unit_flow` variable." + ], + [ + "unit__from_node", + "fix_unit_flow_op", + null, + null, + "Fix the `unit_flow_op` variable." + ], + [ + "unit__from_node", + "fuel_cost", + null, + null, + "Variable fuel costs than can be attributed to a `unit_flow`. E.g. EUR/MWh" + ], + [ + "unit__from_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__from_node", + "initial_nonspin_ramp_up_unit_flow", + null, + null, + "Initialize the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "initial_nonspin_units_started_up", + null, + null, + "Initialize the `nonspin_units_started_up` variable." + ], + [ + "unit__from_node", + "initial_ramp_up_unit_flow", + null, + null, + "Initialize the `ramp_up_unit_flow` variable." + ], + [ + "unit__from_node", + "initial_start_up_unit_flow", + null, + null, + "Initialize the `start_up_unit_flow` variable." + ], + [ + "unit__from_node", + "initial_unit_flow", + null, + null, + "Initialize the `unit_flow` variable." + ], + [ + "unit__from_node", + "initial_unit_flow_op", + null, + null, + "Initialize the `unit_flow_op` variable." + ], + [ + "unit__from_node", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "unit__from_node", + "max_res_shutdown_ramp", + null, + null, + "Max. downward reserve ramp for online units scheduled to shut down for reserve provision" + ], + [ + "unit__from_node", + "max_res_startup_ramp", + null, + null, + "Maximum non-spinning reserve ramp-up for startups." + ], + [ + "unit__from_node", + "max_shutdown_ramp", + null, + null, + "Max. downward ramp for units shutting down" + ], + [ + "unit__from_node", + "max_startup_ramp", + null, + null, + "Maximum ramp-up during startups." + ], + [ + "unit__from_node", + "max_total_cumulated_unit_flow_from_node", + null, + null, + "Bound on the maximum cumulated flows of a unit group from a node group e.g max consumption of certain commodity." + ], + [ + "unit__from_node", + "min_res_shutdown_ramp", + null, + null, + "Minimum non-spinning reserve ramp-down for online units providing reserves during shut-downs" + ], + [ + "unit__from_node", + "min_res_startup_ramp", + null, + null, + "Minimum non-spinning reserve ramp-up for startups." + ], + [ + "unit__from_node", + "min_shutdown_ramp", + null, + null, + "Minimum ramp-up during startups" + ], + [ + "unit__from_node", + "min_startup_ramp", + null, + null, + "Minimum ramp-up during startups." + ], + [ + "unit__from_node", + "min_total_cumulated_unit_flow_from_node", + null, + null, + "Bound on the minimum cumulated flows of a unit group from a node group." + ], + [ + "unit__from_node", + "min_unit_flow", + 0.0, + null, + "Set lower bound of the `unit_flow` variable." + ], + [ + "unit__from_node", + "minimum_operating_point", + null, + null, + "Minimum level for the `unit_flow` relative to the `units_on` online capacity." + ], + [ + "unit__from_node", + "operating_points", + null, + null, + "Operating points for piecewise-linear `unit` efficiency approximations." + ], + [ + "unit__from_node", + "ordered_unit_flow_op", + false, + "boolean_value_list", + "Defines whether the segments of this unit flow are ordered as per the rank of their operating points." + ], + [ + "unit__from_node", + "ramp_down_cost", + null, + null, + "Costs for ramping down" + ], + [ + "unit__from_node", + "ramp_down_limit", + null, + null, + "Limit the maximum ramp-down rate of an online unit, given as a fraction of the unit_capacity. [ramp_down_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__from_node", + "ramp_up_cost", + null, + null, + "Costs for ramping up" + ], + [ + "unit__from_node", + "ramp_up_limit", + null, + null, + "Limit the maximum ramp-up rate of an online unit, given as a fraction of the unit_capacity. [ramp_up_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__from_node", + "reserve_procurement_cost", + null, + null, + "Procurement cost for reserves" + ], + [ + "unit__from_node", + "unit_capacity", + null, + null, + "Maximum `unit_flow` capacity of a single 'sub_unit' of the `unit`." + ], + [ + "unit__from_node", + "unit_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `unit_capacity` unit conversions in the case the `unit_capacity` value is incompatible with the desired `unit_flow` units." + ], + [ + "unit__from_node", + "unit_flow_non_anticipativity_margin", + null, + null, + "Margin by which `unit_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "unit__from_node", + "unit_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `unit_flow` variable has to be fixed to the result from the previous window." + ], + [ + "unit__from_node", + "vom_cost", + null, + null, + "Variable operating costs of a `unit_flow` variable. E.g. EUR/MWh." + ], + [ + "unit__from_node__user_constraint", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__from_node__user_constraint", + "unit_flow_coefficient", + 0.0, + null, + "Coefficient of a `unit_flow` variable for a custom `user_constraint`." + ], + [ + "unit__node__node", + "fix_ratio_in_in_unit_flow", + null, + null, + "Fix the ratio between two `unit_flows` coming into the `unit` from the two `nodes`." + ], + [ + "unit__node__node", + "fix_ratio_in_out_unit_flow", + null, + null, + "Fix the ratio between an incoming `unit_flow` from the first `node` and an outgoing `unit_flow` to the second `node`." + ], + [ + "unit__node__node", + "fix_ratio_out_in_unit_flow", + null, + null, + "Fix the ratio between an outgoing `unit_flow` to the first `node` and an incoming `unit_flow` from the second `node`." + ], + [ + "unit__node__node", + "fix_ratio_out_out_unit_flow", + null, + null, + "Fix the ratio between two `unit_flows` going from the `unit` into the two `nodes`." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_in_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_in_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_in_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_in_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_out_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_out_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "fix_units_on_coefficient_out_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `fix_ratio_out_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_ratio_in_in_unit_flow", + null, + null, + "Maximum ratio between two `unit_flows` coming into the `unit` from the two `nodes`." + ], + [ + "unit__node__node", + "max_ratio_in_out_unit_flow", + null, + null, + "Maximum ratio between an incoming `unit_flow` from the first `node` and an outgoing `unit_flow` to the second `node`." + ], + [ + "unit__node__node", + "max_ratio_out_in_unit_flow", + null, + null, + "Maximum ratio between an outgoing `unit_flow` to the first `node` and an incoming `unit_flow` from the second `node`." + ], + [ + "unit__node__node", + "max_ratio_out_out_unit_flow", + null, + null, + "Maximum ratio between two `unit_flows` going from the `unit` into the two `nodes`." + ], + [ + "unit__node__node", + "max_units_on_coefficient_in_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_in_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_units_on_coefficient_in_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_in_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_units_on_coefficient_out_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_out_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "max_units_on_coefficient_out_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `max_ratio_out_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_ratio_in_in_unit_flow", + null, + null, + "Minimum ratio between two `unit_flows` coming into the `unit` from the two `nodes`." + ], + [ + "unit__node__node", + "min_ratio_in_out_unit_flow", + null, + null, + "Minimum ratio between an incoming `unit_flow` from the first `node` and an outgoing `unit_flow` to the second `node`." + ], + [ + "unit__node__node", + "min_ratio_out_in_unit_flow", + null, + null, + "Minimum ratio between an outgoing `unit_flow` to the first `node` and an incoming `unit_flow` from the second `node`." + ], + [ + "unit__node__node", + "min_ratio_out_out_unit_flow", + null, + null, + "Minimum ratio between two `unit_flows` going from the `unit` into the two `nodes`." + ], + [ + "unit__node__node", + "min_units_on_coefficient_in_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_in_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_units_on_coefficient_in_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_in_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_units_on_coefficient_out_in", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_out_in_unit_flow` constraint." + ], + [ + "unit__node__node", + "min_units_on_coefficient_out_out", + 0.0, + null, + "Optional coefficient for the `units_on` variable impacting the `min_ratio_out_out_unit_flow` constraint." + ], + [ + "unit__node__node", + "unit_idle_heat_rate", + 0.0, + null, + "Flow from node1 per unit time and per `units_on` that results in no additional flow to node2" + ], + [ + "unit__node__node", + "unit_incremental_heat_rate", + null, + null, + "Standard piecewise incremental heat rate where node1 is assumed to be the fuel and node2 is assumed to be electriciy. Assumed monotonically increasing. Array type or single coefficient where the number of coefficients must match the dimensions of `unit_operating_points`" + ], + [ + "unit__node__node", + "unit_start_flow", + 0.0, + null, + "Flow from node1 that is incurred when a unit is started up." + ], + [ + "unit__to_node", + "fix_nonspin_ramp_down_unit_flow", + null, + null, + "Fix the `nonspin_ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_nonspin_ramp_up_unit_flow", + null, + null, + "Fix the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_nonspin_units_shut_down", + null, + null, + "Fix the `nonspin_units_shut_down` variable." + ], + [ + "unit__to_node", + "fix_nonspin_units_started_up", + null, + null, + "Fix the `nonspin_units_started_up` variable." + ], + [ + "unit__to_node", + "fix_ramp_down_unit_flow", + null, + null, + "Fix the `ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_ramp_up_unit_flow", + null, + null, + "Fix the `ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_shut_down_unit_flow", + null, + null, + "Fix the `shut_down_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_start_up_unit_flow", + null, + null, + "Fix the `start_up_unit_flow` variable." + ], + [ + "unit__to_node", + "fix_unit_flow", + null, + null, + "Fix the `unit_flow` variable." + ], + [ + "unit__to_node", + "fix_unit_flow_op", + null, + null, + "Fix the `unit_flow_op` variable." + ], + [ + "unit__to_node", + "fuel_cost", + null, + null, + "Variable fuel costs than can be attributed to a `unit_flow`. E.g. EUR/MWh" + ], + [ + "unit__to_node", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__to_node", + "initial_nonspin_ramp_down_unit_flow", + null, + null, + "Initialize the `nonspin_ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_nonspin_ramp_up_unit_flow", + null, + null, + "Initialize the `nonspin_ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_nonspin_units_shut_down", + null, + null, + "Initialize the `nonspin_units_shut_down` variable." + ], + [ + "unit__to_node", + "initial_nonspin_units_started_up", + null, + null, + "Initialize the `nonspin_units_started_up` variable." + ], + [ + "unit__to_node", + "initial_ramp_down_unit_flow", + null, + null, + "Initialize the `ramp_down_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_ramp_up_unit_flow", + null, + null, + "Initialize the `ramp_up_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_shut_down_unit_flow", + null, + null, + "Initialize the `shut_down_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_start_up_unit_flow", + null, + null, + "Initialize the `start_up_unit_flow` variable." + ], + [ + "unit__to_node", + "initial_unit_flow", + null, + null, + "Initialize the `unit_flow` variable." + ], + [ + "unit__to_node", + "initial_unit_flow_op", + null, + null, + "Initialize the `unit_flow_op` variable." + ], + [ + "unit__to_node", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "unit__to_node", + "max_res_shutdown_ramp", + null, + null, + "Maximum non-spinning reserve ramp-down for online units providing reserves during shut-downs" + ], + [ + "unit__to_node", + "max_res_startup_ramp", + null, + null, + "Maximum non-spinning reserve ramp-up for offline units scheduled for reserve provision" + ], + [ + "unit__to_node", + "max_shutdown_ramp", + null, + null, + "Maximum ramp-down during shutdowns" + ], + [ + "unit__to_node", + "max_startup_ramp", + null, + null, + "Maximum ramp-up during startups" + ], + [ + "unit__to_node", + "max_total_cumulated_unit_flow_to_node", + null, + null, + "Bound on the maximum cumulated flows of a unit group to a node group, e.g. total GHG emissions." + ], + [ + "unit__to_node", + "min_res_shutdown_ramp", + null, + null, + "Minimum non-spinning reserve ramp-down for online units providing reserves during shut-downs" + ], + [ + "unit__to_node", + "min_res_startup_ramp", + null, + null, + "Minimum non-spinning reserve ramp-up for offline units scheduled for reserve provision" + ], + [ + "unit__to_node", + "min_shutdown_ramp", + null, + null, + "Minimum ramp-up during startups" + ], + [ + "unit__to_node", + "min_startup_ramp", + null, + null, + "Minimum ramp-up during startups" + ], + [ + "unit__to_node", + "min_total_cumulated_unit_flow_to_node", + null, + null, + "Bound on the minimum cumulated flows of a unit group to a node group, e.g. total renewable production." + ], + [ + "unit__to_node", + "min_unit_flow", + 0.0, + null, + "Set lower bound of the `unit_flow` variable." + ], + [ + "unit__to_node", + "minimum_operating_point", + null, + null, + "Minimum level for the `unit_flow` relative to the `units_on` online capacity." + ], + [ + "unit__to_node", + "operating_points", + null, + null, + "Decomposes the flow variable into a number of separate operating segment variables. Used to in conjunction with `unit_incremental_heat_rate` and/or `user_constraint`s" + ], + [ + "unit__to_node", + "ordered_unit_flow_op", + false, + "boolean_value_list", + "Defines whether the segments of this unit flow are ordered as per the rank of their operating points." + ], + [ + "unit__to_node", + "ramp_down_cost", + null, + null, + "Costs of ramping down" + ], + [ + "unit__to_node", + "ramp_down_limit", + null, + null, + "Limit the maximum ramp-down rate of an online unit, given as a fraction of the unit_capacity. [ramp_down_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__to_node", + "ramp_up_cost", + null, + null, + "Costs of ramping up" + ], + [ + "unit__to_node", + "ramp_up_limit", + null, + null, + "Limit the maximum ramp-up rate of an online unit, given as a fraction of the unit_capacity. [ramp_up_limit] = %/t, e.g. 0.2/h" + ], + [ + "unit__to_node", + "reserve_procurement_cost", + null, + null, + "Procurement cost for reserves" + ], + [ + "unit__to_node", + "unit_capacity", + null, + null, + "Maximum `unit_flow` capacity of a single 'sub_unit' of the `unit`." + ], + [ + "unit__to_node", + "unit_conv_cap_to_flow", + 1.0, + null, + "Optional coefficient for `unit_capacity` unit conversions in the case the `unit_capacity` value is incompatible with the desired `unit_flow` units." + ], + [ + "unit__to_node", + "unit_flow_non_anticipativity_margin", + null, + null, + "Margin by which `unit_flow` variable can differ from the value in the previous window during `non_anticipativity_time`." + ], + [ + "unit__to_node", + "unit_flow_non_anticipativity_time", + null, + null, + "Period of time where the value of the `unit_flow` variable has to be fixed to the result from the previous window." + ], + [ + "unit__to_node", + "vom_cost", + null, + null, + "Variable operating costs of a `unit_flow` variable. E.g. EUR/MWh." + ], + [ + "unit__to_node__user_constraint", + "graph_view_position", + null, + null, + "An optional setting for tweaking the position of the different elements when drawing them via Spine Toolbox Graph View." + ], + [ + "unit__to_node__user_constraint", + "unit_flow_coefficient", + 0.0, + null, + "Coefficient of a `unit_flow` variable for a custom `user_constraint`." + ], + [ + "unit__user_constraint", + "units_invested_available_coefficient", + 0.0, + null, + "Coefficient of the `units_invested_available` variable in the specified `user_constraint`." + ], + [ + "unit__user_constraint", + "units_invested_coefficient", + 0.0, + null, + "Coefficient of the `units_invested` variable in the specified `user_constraint`." + ], + [ + "unit__user_constraint", + "units_on_coefficient", + 0.0, + null, + "Coefficient of a `units_on` variable for a custom `user_constraint`." + ], + [ + "unit__user_constraint", + "units_started_up_coefficient", + 0.0, + null, + "Coefficient of a `units_started_up` variable for a custom `user_constraint`." + ], + [ + "units_on__stochastic_structure", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ], + [ + "units_on__temporal_block", + "is_active", + true, + "boolean_value_list", + "If false, the object is excluded from the model if the tool filter object activity control is specified" + ] + ], + "objects": [ + [ + "model", + "simple", + null + ], + [ + "node", + "electricity_node", + null + ], + [ + "node", + "fuel_node", + null + ], + [ + "output", + "binary_gas_connection_flow", + null + ], + [ + "output", + "connection_avg_intact_throughflow", + null + ], + [ + "output", + "connection_avg_throughflow", + null + ], + [ + "output", + "connection_flow", + null + ], + [ + "output", + "connection_flow_costs", + null + ], + [ + "output", + "connection_intact_flow", + null + ], + [ + "output", + "connection_investment_costs", + null + ], + [ + "output", + "connections_decommissioned", + null + ], + [ + "output", + "connections_invested", + null + ], + [ + "output", + "connections_invested_available", + null + ], + [ + "output", + "contingency_is_binding", + null + ], + [ + "output", + "fixed_om_costs", + null + ], + [ + "output", + "fuel_costs", + null + ], + [ + "output", + "mga_objective", + null + ], + [ + "output", + "mp_objective_lowerbound", + null + ], + [ + "output", + "node_injection", + null + ], + [ + "output", + "node_pressure", + null + ], + [ + "output", + "node_slack_neg", + null + ], + [ + "output", + "node_slack_pos", + null + ], + [ + "output", + "node_state", + null + ], + [ + "output", + "node_voltage_angle", + null + ], + [ + "output", + "nonspin_ramp_down_unit_flow", + null + ], + [ + "output", + "nonspin_ramp_up_unit_flow", + null + ], + [ + "output", + "nonspin_units_shut_down", + null + ], + [ + "output", + "nonspin_units_started_up", + null + ], + [ + "output", + "objective_penalties", + null + ], + [ + "output", + "ramp_costs", + null + ], + [ + "output", + "ramp_down_unit_flow", + null + ], + [ + "output", + "ramp_up_unit_flow", + null + ], + [ + "output", + "renewable_curtailment_costs", + null + ], + [ + "output", + "res_proc_costs", + null + ], + [ + "output", + "shut_down_costs", + null + ], + [ + "output", + "shut_down_unit_flow", + null + ], + [ + "output", + "start_up_costs", + null + ], + [ + "output", + "start_up_unit_flow", + null + ], + [ + "output", + "storage_investment_costs", + null + ], + [ + "output", + "storages_decommissioned", + null + ], + [ + "output", + "storages_invested", + null + ], + [ + "output", + "storages_invested_available", + null + ], + [ + "output", + "taxes", + null + ], + [ + "output", + "total_costs", + null + ], + [ + "output", + "unit_flow", + null + ], + [ + "output", + "unit_flow_op", + null + ], + [ + "output", + "unit_flow_op_active", + null + ], + [ + "output", + "unit_investment_costs", + null + ], + [ + "output", + "units_available", + null + ], + [ + "output", + "units_invested", + null + ], + [ + "output", + "units_invested_available", + null + ], + [ + "output", + "units_mothballed", + null + ], + [ + "output", + "units_on", + null + ], + [ + "output", + "units_on_costs", + null + ], + [ + "output", + "units_shut_down", + null + ], + [ + "output", + "units_started_up", + null + ], + [ + "output", + "variable_om_costs", + null + ], + [ + "report", + "report1", + null + ], + [ + "stochastic_scenario", + "realization", + null + ], + [ + "stochastic_structure", + "deterministic", + null + ], + [ + "temporal_block", + "flat", + null + ], + [ + "unit", + "power_plant_a", + null + ], + [ + "unit", + "power_plant_b", + null + ] + ], + "relationships": [ + [ + "model__default_stochastic_structure", + [ + "simple", + "deterministic" + ] + ], + [ + "model__default_temporal_block", + [ + "simple", + "flat" + ] + ], + [ + "model__report", + [ + "simple", + "report1" + ] + ], + [ + "model__stochastic_structure", + [ + "simple", + "deterministic" + ] + ], + [ + "model__temporal_block", + [ + "simple", + "flat" + ] + ], + [ + "report__output", + [ + "report1", + "shut_down_costs" + ] + ], + [ + "report__output", + [ + "report1", + "start_up_costs" + ] + ], + [ + "report__output", + [ + "report1", + "total_costs" + ] + ], + [ + "report__output", + [ + "report1", + "unit_flow" + ] + ], + [ + "report__output", + [ + "report1", + "units_on" + ] + ], + [ + "report__output", + [ + "report1", + "units_on_costs" + ] + ], + [ + "report__output", + [ + "report1", + "units_shut_down" + ] + ], + [ + "report__output", + [ + "report1", + "units_started_up" + ] + ], + [ + "report__output", + [ + "report1", + "variable_om_costs" + ] + ], + [ + "stochastic_structure__stochastic_scenario", + [ + "deterministic", + "realization" + ] + ], + [ + "unit__from_node", + [ + "power_plant_a", + "fuel_node" + ] + ], + [ + "unit__from_node", + [ + "power_plant_b", + "fuel_node" + ] + ], + [ + "unit__node__node", + [ + "power_plant_a", + "electricity_node", + "fuel_node" + ] + ], + [ + "unit__node__node", + [ + "power_plant_b", + "electricity_node", + "fuel_node" + ] + ], + [ + "unit__to_node", + [ + "power_plant_a", + "electricity_node" + ] + ], + [ + "unit__to_node", + [ + "power_plant_b", + "electricity_node" + ] + ] + ], + "object_parameter_values": [ + [ + "node", + "electricity_node", + "demand", + { + "type": "time_series", + "index": { + "start": "2000-01-01 00:00:00", + "resolution": "1h", + "ignore_year": false, + "repeat": false + }, + "data": [ + 90.0, + 90.0, + 90.0, + 90.0, + 90.0, + 130.0, + 130.0, + 130.0, + 130.0, + 130.0, + 50.0, + 50.0, + 50.0, + 50.0, + 50.0, + 50.0, + 130.0, + 130.0, + 130.0, + 130.0, + 130.0, + 130.0, + 130.0, + 90.0 + ] + }, + "Base" + ], + [ + "node", + "fuel_node", + "balance_type", + "balance_type_none", + "Base" + ], + [ + "temporal_block", + "flat", + "resolution", + { + "type": "duration", + "data": "1h" + }, + "Base" + ], + [ + "unit", + "power_plant_b", + "initial_units_on", + 0, + "Base" + ], + [ + "unit", + "power_plant_b", + "min_down_time", + { + "type": "duration", + "data": "8h" + }, + "Base" + ], + [ + "unit", + "power_plant_b", + "min_up_time", + { + "type": "duration", + "data": "8h" + }, + "Base" + ], + [ + "unit", + "power_plant_b", + "online_variable_type", + "unit_online_variable_type_binary", + "Base" + ], + [ + "unit", + "power_plant_b", + "shut_down_cost", + 7, + "Base" + ], + [ + "unit", + "power_plant_b", + "start_up_cost", + 5, + "Base" + ], + [ + "unit", + "power_plant_b", + "units_on_cost", + 3, + "Base" + ] + ], + "relationship_parameter_values": [ + [ + "unit__from_node", + [ + "power_plant_a", + "fuel_node" + ], + "vom_cost", + 25, + "Base" + ], + [ + "unit__from_node", + [ + "power_plant_b", + "fuel_node" + ], + "vom_cost", + 50, + "Base" + ], + [ + "unit__node__node", + [ + "power_plant_a", + "electricity_node", + "fuel_node" + ], + "fix_ratio_out_in_unit_flow", + 0.7, + "Base" + ], + [ + "unit__node__node", + [ + "power_plant_b", + "electricity_node", + "fuel_node" + ], + "fix_ratio_out_in_unit_flow", + 0.8, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_a", + "electricity_node" + ], + "unit_capacity", + 100, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_b", + "electricity_node" + ], + "minimum_operating_point", + 0.1, + "Base" + ], + [ + "unit__to_node", + [ + "power_plant_b", + "electricity_node" + ], + "unit_capacity", + 200.0, + "Base" + ] + ], + "alternatives": [ + [ + "Base", + "Base alternative" + ] + ], + "tools": [ + [ + "object_activity_control", + "" + ] + ], + "features": [ + [ + "commodity", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "connection", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "model", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "node", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "node__stochastic_structure", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "node__temporal_block", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "output", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "report", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "stochastic_scenario", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "stochastic_structure", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "temporal_block", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "unit", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "unit__from_node", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "unit__to_node", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "units_on__stochastic_structure", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "units_on__temporal_block", + "is_active", + "boolean_value_list", + "boolean_value_list" + ], + [ + "user_constraint", + "is_active", + "boolean_value_list", + "boolean_value_list" + ] + ], + "tool_features": [ + [ + "object_activity_control", + "commodity", + "is_active", + false + ], + [ + "object_activity_control", + "connection", + "is_active", + false + ], + [ + "object_activity_control", + "model", + "is_active", + false + ], + [ + "object_activity_control", + "node", + "is_active", + false + ], + [ + "object_activity_control", + "node__stochastic_structure", + "is_active", + false + ], + [ + "object_activity_control", + "node__temporal_block", + "is_active", + false + ], + [ + "object_activity_control", + "output", + "is_active", + false + ], + [ + "object_activity_control", + "report", + "is_active", + false + ], + [ + "object_activity_control", + "stochastic_scenario", + "is_active", + false + ], + [ + "object_activity_control", + "stochastic_structure", + "is_active", + false + ], + [ + "object_activity_control", + "temporal_block", + "is_active", + false + ], + [ + "object_activity_control", + "unit", + "is_active", + false + ], + [ + "object_activity_control", + "unit__from_node", + "is_active", + false + ], + [ + "object_activity_control", + "unit__to_node", + "is_active", + false + ], + [ + "object_activity_control", + "units_on__stochastic_structure", + "is_active", + false + ], + [ + "object_activity_control", + "units_on__temporal_block", + "is_active", + false + ], + [ + "object_activity_control", + "user_constraint", + "is_active", + false + ] + ], + "tool_feature_methods": [ + [ + "object_activity_control", + "commodity", + "is_active", + true + ], + [ + "object_activity_control", + "connection", + "is_active", + true + ], + [ + "object_activity_control", + "model", + "is_active", + true + ], + [ + "object_activity_control", + "node", + "is_active", + true + ], + [ + "object_activity_control", + "node__stochastic_structure", + "is_active", + true + ], + [ + "object_activity_control", + "node__temporal_block", + "is_active", + true + ], + [ + "object_activity_control", + "output", + "is_active", + true + ], + [ + "object_activity_control", + "report", + "is_active", + true + ], + [ + "object_activity_control", + "stochastic_scenario", + "is_active", + true + ], + [ + "object_activity_control", + "stochastic_structure", + "is_active", + true + ], + [ + "object_activity_control", + "temporal_block", + "is_active", + true + ], + [ + "object_activity_control", + "unit", + "is_active", + true + ], + [ + "object_activity_control", + "unit__from_node", + "is_active", + true + ], + [ + "object_activity_control", + "unit__to_node", + "is_active", + true + ], + [ + "object_activity_control", + "units_on__stochastic_structure", + "is_active", + true + ], + [ + "object_activity_control", + "units_on__temporal_block", + "is_active", + true + ], + [ + "object_activity_control", + "user_constraint", + "is_active", + true + ] + ] +} \ No newline at end of file diff --git a/test/examples/advanced_test_systemA5.jl b/test/examples/advanced_test_systemA5.jl new file mode 100644 index 0000000000..58e685b45c --- /dev/null +++ b/test/examples/advanced_test_systemA5.jl @@ -0,0 +1,16 @@ +pathA5 = joinpath(@__DIR__, "..". "..", "examples", "system_A5.json") + +url_in = "sqlite://" +test_data = JSON.parsefile(pathA5) +_load_test_data(url_in, test_data) +url_out = "sqlite:///$(@__DIR__)/test_systemA5.sqlite" +run_spineopt(url_in, url_out; upgrade=true, log_level=2) + +some_week = temporal_block(:some_week) + +# Vary resolution from 1 to 24 hours and rerun +for h in 1:24 + temporal_block.parameter_values[some_week][:resolution] = + callable(db_api.from_database("""{"type": "duration", "data": "$(h) hours"}""")) + m = rerun_spineopt(url_out; cleanup=false, log_level=1) +end diff --git a/test/examples/examples.jl b/test/examples/examples.jl new file mode 100644 index 0000000000..cc78a1c671 --- /dev/null +++ b/test/examples/examples.jl @@ -0,0 +1,10 @@ +examplepath = joinpath(@__DIR__, "..", "..","examples") + +for examplefile in readdir(examplepath) + examplejson = joinpath(examplepath, examplefile) + url_in = "sqlite://" + test_data = JSON.parsefile(examplejson) + test_data = Dict(Symbol(key) => value for (key, value) in test_data) + _load_test_data(url_in, test_data) + run_spineopt(url_in) +end \ No newline at end of file diff --git a/test/runtests.jl b/test/runtests.jl index 4b1f29d38f..c570ee3e6b 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -21,6 +21,7 @@ using SpineOpt using SpineInterface using Test using Dates +using JSON using JuMP using PyCall @@ -109,6 +110,8 @@ end include("objective/objective.jl") include("util/misc.jl") include("util/docs_utils.jl") + include("examples/examples.jl") + include("examples/advanced_test_systemA5.jl") include("run_spineopt.jl") include("run_spineopt_benders.jl") end