saved progress on ivs

Author: TorkelE

src/chemistry_functionality.jl

@@ -45,34 +45,38 @@ function make_compound(expr)
         ((expr.args[2].args[1] isa Expr) && (expr.args[2].args[1].args[1] isa Expr) && expr.args[2].args[1].args[1].head == :call) && error(COMPOUND_CREATION_ERROR_DEPENDENT_VAR_GIVEN) 
     end
 
-    # Extracts the composite species name, and a Vector{ReactantStruct} of its components.
-    species_expr = expr.args[2]                                         # E.g. :(CO2(t))
-    species_expr = insert_independent_variable(species_expr, [:t])      # Add independent variable (e.g. goes from `CO2` to `CO2(t)`).
-    species_name = find_varname_in_declaration(expr.args[2])            # E.g. :CO2
-    composition = Catalyst.recursive_find_reactants!(expr.args[3], 1, Vector{ReactantStruct}(undef, 0))
-
     # Loops through all components, add the component and the coefficients to the corresponding vectors (cannot extract directly using e.g. "getfield.(composition, :reactant)" because then we get something like :([:C, :O]), rather than :([C, O]))
+    composition = Catalyst.recursive_find_reactants!(expr.args[3], 1, Vector{ReactantStruct}(undef, 0))
     components = :([])                                                  # Becomes something like :([C, O]).                                         
     coefficients = :([])                                                # Becomes something like :([1, 2]). 
     for comp in composition
         push!(components.args, comp.reactant)
         push!(coefficients.args, comp.stoichiometry)
     end
 
+    # 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_name = find_varname_in_declaration(expr.args[2])                                # E.g. :CO2
+    
+
     # 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).
-    non_t_iv_error_check_expr = Expr(:escape, :(@species $species_expr))                                                                                         # E.g. `@species CO2(t)`
+    # 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)`
     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])`
 
-    # Currently, non-t independent variables are not supported for compounds. If there are any like these, we throw an error:
-    non_t_iv_error_check_expr = Expr(:escape, :(issetequal(unique(reduce(vcat, arguments.(ModelingToolkit.unwrap.($components)))), [t]) || error("Currently, compounds depending on components that are not \"t\" are not supported.")))
+    println(quote
+        $species_declaration_expr
+        $compound_designation_expr
+        $components_designation_expr
+        $coefficients_designation_expr
+    end)
 
     # Returns the rephrased expression.
     return quote
-        $non_t_iv_error_check_expr
         $species_declaration_expr
         $compound_designation_expr
         $components_designation_expr

src/expression_utils.jl

@@ -52,21 +52,19 @@ end
 # (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, iv)
-    # If iv is a symbol (e.g. :t), we convert to vector (e.g. [:t]). This way we can handle single and multiple ivs using the same code, without needing to check at the end.    
-    (iv isa Symbol) && (iv = [iv])
+function insert_independent_variable(expr_in, ivs)
     # 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, iv...))
+    (expr_in isa Symbol) && (return Expr(:call, expr_in, :($ivs...)))
     expr = deepcopy(expr_in)
 
     if expr.head == :(=) # Case: :(X = 1.0)
-        expr.args[1] = Expr(:call, expr.args[1], iv...)
+        expr.args[1] = Expr(:call, expr.args[1], :($ivs...))
     elseif expr.head == :tuple
         if expr.args[1] isa Symbol # Case: :(X, [metadata=true])
-            expr.args[1] = Expr(:call, expr.args[1], iv...)
+            expr.args[1] = Expr(:call, expr.args[1], :($ivs...))
         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], iv...)
+            expr.args[1].args[1] = Expr(:call, expr.args[1].args[1], :($ivs...))
         end
     end
     (expr == expr_in) && error("Failed to add independent variable $(iv) to expression: $expr_in")