Inclusion of default checks (#50)

* Changed checks and tests to `all()`
* Introduced default checks that can be reused
* Fixed error in documentation

Author: JulStraus

NEWS.md

@@ -1,5 +1,12 @@
 # Release notes
 
+## Version 0.8.3 (2024-11-29)
+
+### Reference checks possible to be called
+
+* Created function `check_node_default()`.
+* The function can be called from other `check_node` to include all default checks
+
 ## Version 0.8.2 (2024-11-27)
 
 ### Restructuring of function calls

Project.toml

@@ -1,7 +1,7 @@
 name = "EnergyModelsBase"
 uuid = "5d7e687e-f956-46f3-9045-6f5a5fd49f50"
 authors = ["Lars Hellemo <Lars.Hellemo@sintef.no>, Julian Straus <Julian.Straus@sintef.no>"]
-version = "0.8.2"
+version = "0.8.3"
 
 [deps]
 JuMP = "4076af6c-e467-56ae-b986-b466b2749572"

docs/src/library/internals/functions.md

@@ -49,6 +49,7 @@ check_data
 check_case_data
 check_model
 check_node
+check_node_default
 check_fixed_opex
 check_node_data(n::Node, data::EmissionsData, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
 check_time_structure

docs/src/manual/philosophy.md

@@ -9,7 +9,7 @@ One key aim in the development of `EnergyModelsBase` was to create an energy sys
 3. is designed in a way such that the thought process for understanding the model is straight forward.
 
 Julia as a programming language offers the flexibility required in points 1 and 2 through the concept of multiple dispatch.
-The philosophy hence focueses on only creating variables and constraintes that are used, instead of creating all potential constraints and variables and constrain a large fraction of these variables to a value of 0.
+`EnergyModelsBase` hence focuses on only creating variables and constraints that are used, instead of creating all potential constraints and variables and constrain a large fraction of these variables to a value of 0.
 In that respect, `EnergyModelsBase` moves away from a parameter driven flexibility to a type driven flexibility.
 Point 3 is achieved through a one direction flow in function calls, that is that we limit the number of required files and function calls for the individual technology constraint creations, and meaningful names of the individual functions.
 

docs/src/nodes/storage.md

@@ -143,9 +143,9 @@ Hence, if you do not have to call additional functions, but only plan to include
 
   ```math
   \begin{aligned}
-  \texttt{stor\_level\_use}[n, t] & = \texttt{stor\_level\_inst}[n, t] \\
-  \texttt{stor\_charge\_use}[n, t] & = \texttt{stor\_charge\_inst}[n, t] \\
-  \texttt{stor\_discharge\_use}[n, t] & = \texttt{stor\_discharge\_inst}[n, t]
+  \texttt{stor\_level\_use}[n, t] & \leq \texttt{stor\_level\_inst}[n, t] \\
+  \texttt{stor\_charge\_use}[n, t] & \leq \texttt{stor\_charge\_inst}[n, t] \\
+  \texttt{stor\_discharge\_use}[n, t] & \leq \texttt{stor\_discharge\_inst}[n, t]
   \end{aligned}
   ```
 

ext/EMIExt/checks.jl

@@ -145,8 +145,7 @@ function check_inv_data(
     if isa(inv_data, StartInvData)
         if bool_sp
             @assert_or_log(
-                sum(inv_data.initial[t_inv] ≤ EMI.max_installed(inv_data, t_inv) for t_inv ∈ 𝒯ᴵⁿᵛ) ==
-                    length(𝒯ᴵⁿᵛ),
+                all(inv_data.initial[t_inv] ≤ EMI.max_installed(inv_data, t_inv) for t_inv ∈ 𝒯ᴵⁿᵛ),
                 "The value for the field `initial` in the investment data " * message *
                 " can not be larger than the maximum installed constraint."
             )
@@ -158,8 +157,7 @@ function check_inv_data(
         bool_sp = EMB.check_strategic_profile(capacity_profile, submessage)
         if bool_sp
             @assert_or_log(
-                sum(capacity_profile[t_inv] ≤ EMI.max_installed(inv_data, t_inv) for t_inv ∈ 𝒯ᴵⁿᵛ) ==
-                    length(𝒯ᴵⁿᵛ),
+                all(capacity_profile[t_inv] ≤ EMI.max_installed(inv_data, t_inv) for t_inv ∈ 𝒯ᴵⁿᵛ),
                 "The existing capacity can not be larger than the maximum installed value in " *
                 "all strategic periods for the capacity coupled to the investment data " *
                 message * "."
@@ -170,7 +168,7 @@ function check_inv_data(
     # Check on the minmimum and maximum added capacities
     if isa(EMI.investment_mode(inv_data), Union{ContinuousInvestment,SemiContiInvestment})
         @assert_or_log(
-            sum(EMI.min_add(inv_data, t) ≤ EMI.max_add(inv_data, t) for t ∈ 𝒯) == length(𝒯),
+            all(EMI.min_add(inv_data, t) ≤ EMI.max_add(inv_data, t) for t ∈ 𝒯),
             "`min_add` has to be less than `max_add` in the investment data " *
             message * "."
         )

src/checks.jl

@@ -556,23 +556,37 @@ end
     check_node(n::Node, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
 
 Check that the fields of a `Node` corresponds to required structure.
+
+The default approach calls the subroutine [`check_node_default`](@ref) which provides the
+user with default checks for [`Source`](@ref), [`NetworkNode`](@ref), [`Availability`](@ref),
+[`Storage`](@ref), and [`Sink`](@ref) nodes.
+
+!!! tip "Creating a new node type"
+    When developing a new node with new checks, it is important to create a new method for
+    `check_node`. You can then call within this function the default tests for the corresponding
+    supertype through calling the function [`check_node_default`](@ref).
 """
-function check_node(n::Node, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool) end
+check_node(n::Node, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool) =
+    check_node_default(n, 𝒯, modeltype, check_timeprofiles)
 """
-    check_node(n::Availability, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
+    check_node_default(n::Node, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
 
-This method checks that an `Availability` node is valid. By default, that does not include
+This method checks that a `Node` node is valid. By default, that does not include
 any checks.
 """
-function check_node(n::Availability, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool) end
+function check_node_default(n::Node, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool) end
 """
-    check_node(n::Source, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
+    check_node_default(n::Availability, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
 
-This method checks that a `Source` node is valid.
+This method checks that an `Availability` node is valid. By default, that does not include
+any checks.
+"""
+function check_node_default(n::Availability, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool) end
+"""
+    check_node_default(n::Source, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
 
-These checks are always performed, if the user is not creating a new method. Hence, it is
-important that a new `Source` type includes at least the same fields as in the [`RefSource`](@ref)
-node or that a new `Source` type receives a new method for `check_node`.
+Subroutine that can be utilized in other packages for incorporating the standard tests for
+a [`Source`](@ref) node.
 
 ## Checks
 - The field `cap` is required to be non-negative.
@@ -581,27 +595,24 @@ node or that a new `Source` type receives a new method for `check_node`.
   accessible through a `StrategicPeriod` as outlined in the function
   [`check_fixed_opex(n, 𝒯ᴵⁿᵛ, check_timeprofiles)`](@ref).
 """
-function check_node(n::Source, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
+function check_node_default(n::Source, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
     𝒯ᴵⁿᵛ = strategic_periods(𝒯)
 
     @assert_or_log(
-        sum(capacity(n, t) ≥ 0 for t ∈ 𝒯) == length(𝒯),
+        all(capacity(n, t) ≥ 0 for t ∈ 𝒯),
         "The capacity must be non-negative."
     )
     @assert_or_log(
-        sum(outputs(n, p) ≥ 0 for p ∈ outputs(n)) == length(outputs(n)),
+        all(outputs(n, p) ≥ 0 for p ∈ outputs(n)),
         "The values for the Dictionary `output` must be non-negative."
     )
     check_fixed_opex(n, 𝒯ᴵⁿᵛ, check_timeprofiles)
 end
 """
-    check_node(n::NetworkNode, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
-
-This method checks that a `NetworkNode` node is valid.
+    check_node_default(n::NetworkNode, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
 
-These checks are always performed, if the user is not creating a new method. Hence, it is
-important that a new `NetworkNode` type includes at least the same fields as in the
-[`RefNetworkNode`(@ref) node or that a new `NetworkNode` type receives a new method for `check_node`.
+Subroutine that can be utilized in other packages for incorporating the standard tests for
+a [`NetworkNode`](@ref) node.
 
 ## Checks
 - The field `cap` is required to be non-negative.
@@ -611,31 +622,28 @@ important that a new `NetworkNode` type includes at least the same fields as in
   accessible through a `StrategicPeriod` as outlined in the function
   [`check_fixed_opex(n, 𝒯ᴵⁿᵛ, check_timeprofiles)`](@ref).
 """
-function check_node(n::NetworkNode, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
+function check_node_default(n::NetworkNode, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
     𝒯ᴵⁿᵛ = strategic_periods(𝒯)
 
     @assert_or_log(
-        sum(capacity(n, t) ≥ 0 for t ∈ 𝒯) == length(𝒯),
+        all(capacity(n, t) ≥ 0 for t ∈ 𝒯),
         "The capacity must be non-negative."
     )
     @assert_or_log(
-        sum(inputs(n, p) ≥ 0 for p ∈ inputs(n)) == length(inputs(n)),
+        all(inputs(n, p) ≥ 0 for p ∈ inputs(n)),
         "The values for the Dictionary `input` must be non-negative."
     )
     @assert_or_log(
-        sum(outputs(n, p) ≥ 0 for p ∈ outputs(n)) == length(outputs(n)),
+        all(outputs(n, p) ≥ 0 for p ∈ outputs(n)),
         "The values for the Dictionary `output` must be non-negative."
     )
     check_fixed_opex(n, 𝒯ᴵⁿᵛ, check_timeprofiles)
 end
 """
-    check_node(n::Storage, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
+    check_node_default(n::Storage, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
 
-This method checks that a `Storage` node is valid.
-
-These checks are always performed, if the user is not creating a new method. Hence, it is
-important that a new `Storage` type includes at least the same fields as in the
-[`RefStorage`](@ref) node or that a new `Storage` type receives a new method for `check_node`.
+Subroutine that can be utilized in other packages for incorporating the standard tests for
+a [`Storage`](@ref) node.
 
 ## Checks
 - The `TimeProfile` of the field `capacity` in the type in the field `charge` is required
@@ -650,69 +658,67 @@ important that a new `Storage` type includes at least the same fields as in the
 - The values of the dictionary `input` are required to be non-negative.
 - The values of the dictionary `output` are required to be non-negative.
 """
-function check_node(n::Storage, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
+function check_node_default(n::Storage, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
     𝒯ᴵⁿᵛ = strategic_periods(𝒯)
     par_charge = charge(n)
     par_level = level(n)
     par_discharge = discharge(n)
 
     if isa(par_charge, UnionCapacity)
         @assert_or_log(
-            sum(capacity(par_charge, t) ≥ 0 for t ∈ 𝒯) == length(𝒯),
+            all(capacity(par_charge, t) ≥ 0 for t ∈ 𝒯),
             "The charge capacity must be non-negative."
         )
     end
     if isa(par_charge, UnionOpexFixed)
         check_fixed_opex(par_charge, 𝒯ᴵⁿᵛ, check_timeprofiles)
     end
     @assert_or_log(
-        sum(capacity(par_level, t) ≥ 0 for t ∈ 𝒯) == length(𝒯),
+        all(capacity(par_level, t) ≥ 0 for t ∈ 𝒯),
         "The level capacity must be non-negative."
     )
     if isa(par_level, UnionOpexFixed)
         check_fixed_opex(par_level, 𝒯ᴵⁿᵛ, check_timeprofiles)
     end
     if isa(par_discharge, UnionCapacity)
         @assert_or_log(
-            sum(capacity(par_discharge, t) ≥ 0 for t ∈ 𝒯) == length(𝒯),
-            "The charge capacity must be non-negative."
+            all(capacity(par_discharge, t) ≥ 0 for t ∈ 𝒯),
+            "The discharge capacity must be non-negative."
         )
     end
     if isa(par_discharge, UnionOpexFixed)
         check_fixed_opex(par_discharge, 𝒯ᴵⁿᵛ, check_timeprofiles)
     end
-    @assert_or_log(
-        sum(inputs(n, p) ≥ 0 for p ∈ inputs(n)) == length(inputs(n)),
+    has_input(n) && @assert_or_log(
+        all(inputs(n, p) ≥ 0 for p ∈ inputs(n)),
         "The values for the Dictionary `input` must be non-negative."
     )
-    @assert_or_log(
-        sum(outputs(n, p) ≥ 0 for p ∈ outputs(n)) == length(outputs(n)),
+    has_output(n) && @assert_or_log(
+        all(outputs(n, p) ≥ 0 for p ∈ outputs(n)),
         "The values for the Dictionary `output` must be non-negative."
     )
 end
-"""
-    check_node(n::Sink, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
 
-This method checks that a `Sink` node is valid.
+"""
+    check_node_default(n::Sink, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
 
-These checks are always performed, if the user is not creating a new method. Hence, it is
-important that a new `Sink` type includes at least the same fields as in the [`RefSink`](@ref)
-node or that a new `Source` type receives a new method for `check_node`.
+Subroutine that can be utilized in other packages for incorporating the standard tests for
+a [`Sink`](@ref) node.
 
 ## Checks
 - The field `cap` is required to be non-negative.
 - The values of the dictionary `input` are required to be non-negative.
 - The dictionary `penalty` is required to have the keys `:deficit` and `:surplus`.
 - The sum of the values `:deficit` and `:surplus` in the dictionary `penalty` has to be
-  non-negative to avoid an infeasible model.
+    non-negative to avoid an infeasible model.
 """
-function check_node(n::Sink, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
+function check_node_default(n::Sink, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)
     @assert_or_log(
-        sum(capacity(n, t) ≥ 0 for t ∈ 𝒯) == length(𝒯),
+        all(capacity(n, t) ≥ 0 for t ∈ 𝒯),
         "The capacity must be non-negative."
     )
     @assert_or_log(
-        sum(inputs(n, p) ≥ 0 for p ∈ inputs(n)) == length(inputs(n)),
+        all(inputs(n, p) ≥ 0 for p ∈ inputs(n)),
         "The values for the Dictionary `input` must be non-negative."
     )
     @assert_or_log(
@@ -723,11 +729,13 @@ function check_node(n::Sink, 𝒯, modeltype::EnergyModel, check_timeprofiles::B
     if :surplus ∈ keys(n.penalty) && :deficit ∈ keys(n.penalty)
         # The if-condition was checked above.
         @assert_or_log(
-            sum(surplus_penalty(n, t) + deficit_penalty(n, t) ≥ 0 for t ∈ 𝒯) == length(𝒯),
+            all(surplus_penalty(n, t) + deficit_penalty(n, t) ≥ 0 for t ∈ 𝒯),
             "An inconsistent combination of `:surplus` and `:deficit` leads to an infeasible model."
         )
     end
 end
+
+
 """
     check_fixed_opex(n, 𝒯ᴵⁿᵛ, check_timeprofiles::Bool)
 
@@ -758,7 +766,7 @@ function check_fixed_opex(n, 𝒯ᴵⁿᵛ, check_timeprofiles::Bool)
     # Check that the value is positive in all cases
     if bool_sp
         @assert_or_log(
-            sum(opex_fixed(n, t_inv) ≥ 0 for t_inv ∈ 𝒯ᴵⁿᵛ) == length(𝒯ᴵⁿᵛ),
+            all(opex_fixed(n, t_inv) ≥ 0 for t_inv ∈ 𝒯ᴵⁿᵛ),
             "The fixed OPEX must be non-negative."
         )
     end

src/structures/resource.jl

@@ -7,7 +7,7 @@ Base.show(io::IO, r::Resource) = print(io, "$(r.id)")
 """
     ResourceEmit{T<:Real} <: Resource
 
-Resources that can can be emitted (*e.g.*, CO₂, CH₄, NOₓ).
+Resources that can be emitted (*e.g.*, CO₂, CH₄, NOₓ).
 
 These resources can be included as resources that are emitted, *e.g*, in the variable
 [`emissions_strategic`](@ref man-opt_var-emissions).

test/runtests.jl

@@ -10,7 +10,6 @@ const TS = TimeStruct
 const TEST_ATOL = 1e-6
 ENV["EMB_TEST"] = true # Set flag for example scripts to check if they are run as part of the tests
 
-
 @testset "Base" begin
     @testset "Base | General" begin
         include("test_general.jl")