fix iv inference

Author: TorkelE

src/chemistry_functionality.jl

@@ -56,28 +56,22 @@ function make_compound(expr)
 
     # Extracts the composite species name, as well as the expression which creates it (with e.g. meta data and default values included).
     species_expr = expr.args[2]                                                             # E.g. :(CO2 = 1.0, [metadata=true])
-    iv_expr = :(unique(reduce(vcat, arguments.(ModelingToolkit.unwrap.($(components))))))   # Expression which, when evaluated, becoems a list of all the independent variables the compound should depend on.
-    species_expr = insert_independent_variable(species_expr, iv_expr)                       # Add independent variable (e.g. goes from `CO2` to `CO2(t)`).
+    species_expr = insert_independent_variable(species_expr, :(..))                         # Prepare iv addition, i.e. turns CO to CO(..).
     species_name = find_varname_in_declaration(expr.args[2])                                # E.g. :CO2
+    ivs_get_expr = :(unique(reduce(vcat,[arguments(ModelingToolkit.unwrap(iv)) for iv in $components])))    # Expression which when evaluated gives a vector with all the ivs of the components.
 
-
     # Creates the found expressions that will create the compound species.
-    # The `Expr(:escape, :(...))` is required so that teh expressions are evaluated in the scope the users use the macro in (to e.g. detect already exiting species).                                                                                        # E.g. `@species CO2(t)`
-    species_declaration_expr = Expr(:escape, :(@species $species_expr))                                                                                         # E.g. `@species CO2(t)`
+    # The `Expr(:escape, :(...))` is required so that the expressions are evaluated in the scope the users use the macro in (to e.g. detect already exiting species).                                                                                        
+    species_declaration_expr = Expr(:escape, :(@species $species_expr))                                                                                         # E.g. `@species CO2(..)`
+    iv_designation_expression = Expr(:escape, :($species_name = $(species_name)($(ivs_get_expr)...)))                                                           # E.g. `CO2 = CO2([...]..)` where [...] is something which evaluates to a vector with all the ivs of the components.
     compound_designation_expr = Expr(:escape, :($species_name = ModelingToolkit.setmetadata($species_name, Catalyst.CompoundSpecies, true)))                    # E.g. `CO2 = ModelingToolkit.setmetadata(CO2, Catalyst.CompoundSpecies, true)`
     components_designation_expr = Expr(:escape, :($species_name = ModelingToolkit.setmetadata($species_name, Catalyst.CompoundComponents, $components)))        # E.g. `CO2 = ModelingToolkit.setmetadata(CO2, Catalyst.CompoundSpecies, [C, O])`
     coefficients_designation_expr = Expr(:escape, :($species_name = ModelingToolkit.setmetadata($species_name, Catalyst.CompoundCoefficients, $coefficients)))  # E.g. `CO2 = ModelingToolkit.setmetadata(CO2, Catalyst.CompoundSpecies, [1, 2])`
 
-    println(quote
-        $species_declaration_expr
-        $compound_designation_expr
-        $components_designation_expr
-        $coefficients_designation_expr
-    end)
-
     # Returns the rephrased expression.
     return quote
         $species_declaration_expr
+        $iv_designation_expression
         $compound_designation_expr
         $components_designation_expr
         $coefficients_designation_expr
@@ -128,6 +122,9 @@ function make_compounds(expr)
     end
     push!(compound_declarations.args, :($(Expr(:escape, :($(compound_syms))))))
 
+    # The output needs to be converted to Vector{Num} (from  Vector{SymbolicUtils.BasicSymbolic{Real}}) to be consistent with e.g. @variables.
+    compound_declarations.args[end] = :([ModelingToolkit.wrap(cmp) for cmp in $(compound_declarations.args[end])])
+
     # Returns output that.
     return compound_declarations
 end

src/expression_utils.jl

@@ -49,22 +49,21 @@ end
 # X(t) = 1.0
 # X(t), [metadata=true]
 # X(t) = 1.0, [metadata=true]
-# (In this example the independent variable t was inserted).
-# Extra dispatch is to ensure so that iv is a vector (so that we can handle both single or multiple iv insertion in one function). 
-#     - This way we don't have to make a check for how to create the final expression (which is different for symbol or vector of symbols).
-function insert_independent_variable(expr_in, ivs)
+# (In this example the independent variable :t was inserted).
+# Here, the iv is a iv_expr, which can be anything, which is inserted
+function insert_independent_variable(expr_in, iv_expr)
     # If expr is a symbol, just attach the iv. If not we have to create a new expr and mutate it. 
     # Because Symbols (a possible input) cannot be mutated, this function cannot mutate the input (would have been easier if Expr input was guaranteed).
-    (expr_in isa Symbol) && (return Expr(:call, expr_in, :($ivs...)))
+    (expr_in isa Symbol) && (return Expr(:call, expr_in, iv_expr))
     expr = deepcopy(expr_in)
 
     if expr.head == :(=) # Case: :(X = 1.0)
-        expr.args[1] = Expr(:call, expr.args[1], :($ivs...))
+        expr.args[1] = Expr(:call, expr.args[1], iv_expr)
     elseif expr.head == :tuple
         if expr.args[1] isa Symbol # Case: :(X, [metadata=true])
-            expr.args[1] = Expr(:call, expr.args[1], :($ivs...))
+            expr.args[1] = Expr(:call, expr.args[1], iv_expr)
         elseif (expr.args[1].head == :(=)) && (expr.args[1].args[1] isa Symbol) # Case: :(X = 1.0, [metadata=true])
-            expr.args[1].args[1] = Expr(:call, expr.args[1].args[1], :($ivs...))
+            expr.args[1].args[1] = Expr(:call, expr.args[1].args[1], iv_expr)
         end
     end
     (expr == expr_in) && error("Failed to add independent variable $(iv) to expression: $expr_in")

test/miscellaneous_tests/compound_macro.jl

@@ -71,23 +71,20 @@ end
 let
     @variables t x y z
     @species C(t) H(x) N(x) O(t) P(t,x) S(x,y)
-
+    
+    # Creates compounds.
     @compound CO2 ~ C + 2O
-    @test issetequal(arguments(ModelingToolkit.unwrap(CO2)), [t])
+    @compound NH4, [output=true] ~ N + 4H
+    @compound (H2O = 2.0) ~ 2H + O
+    @compound PH4 ~ P + 4H
+    @compound SO2 ~ S + 2O
 
-    # These 4 tests checks currently non-supported feature.
-    @test_broken false
-    @test_broken false
-    @test_broken false
-    @test_broken false
-    # @compound NH4, [output=true] ~ N + 4H
-    # @compound (H2O = 2.0) ~ 2H + N
-    # @compound PH4 ~ P + 4H
-    # @compound SO2 ~ S + 2O
-    # @test issetequal(arguments(ModelingToolkit.unwrap(NH4)), [x])
-    # @test issetequal(arguments(ModelingToolkit.unwrap(H2O)), [t, x])
-    # @test issetequal(arguments(ModelingToolkit.unwrap(PH4)), [t, x])
-    # @test issetequal(arguments(ModelingToolkit.unwrap(SO2)), [t, x, y])
+    # Checks they have the correct independent variables.
+    @test issetequal(arguments(ModelingToolkit.unwrap(CO2)), [t])
+    @test issetequal(arguments(ModelingToolkit.unwrap(NH4)), [x])
+    @test issetequal(arguments(ModelingToolkit.unwrap(H2O)), [t, x])
+    @test issetequal(arguments(ModelingToolkit.unwrap(PH4)), [t, x])
+    @test issetequal(arguments(ModelingToolkit.unwrap(SO2)), [t, x, y])
 end
 
 ### Other Minor Tests ###