Generator: take into account tracked/untracked variables when generat…

…ing some code.

src/analyser.cpp

@@ -2777,7 +2777,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model)
         return;
     }
 
-    // Add a dummy equation for each of our true (i.e. non-computed) constants.
+    // Add a dummy equation for each of our true constants.
     // Note: this is so that a constant can be marked as an external variable.
 
     for (const auto &internalVariable : mInternalVariables) {
@@ -2797,9 +2797,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model)
     std::map<AnalyserInternalEquationPtr, AnalyserEquationPtr> aie2aeMappings;
 
     for (const auto &internalEquation : mInternalEquations) {
-        auto equation = AnalyserEquation::AnalyserEquationImpl::create();
-
-        aie2aeMappings.emplace(internalEquation, equation);
+        aie2aeMappings.emplace(internalEquation, AnalyserEquation::AnalyserEquationImpl::create());
     }
 
     // Start making our internal equations available through our API.
@@ -2850,11 +2848,6 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model)
 
                 break;
             default: // AnalyserEquation::Type::UNKNOWN.
-                // The equation type is unknown, which means that it is a dummy
-                // equation for a true (i.e. non-computed) constant (so that it
-                // could have been marked as an external variable), so we skip
-                // it since the constant wasn't marked as an external variable.
-
                 continue;
             }
         }
@@ -3029,6 +3022,13 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model)
             if (variable != nullptr) {
                 for (const auto &equation : variable->equations()) {
                     if (std::find(equationDependencies.begin(), equationDependencies.end(), equation) == equationDependencies.end()) {
+                        if (variable->type() == AnalyserVariable::Type::CONSTANT) {
+                            // This is a constant, so keep track of it in case it is untracked and in case we need to
+                            // generate some code for it.
+
+                            equation->mPimpl->mConstant = variable;
+                        }
+
                         equationDependencies.push_back(equation);
                     }
                 }
@@ -3080,15 +3080,13 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model)
         mModel->mPimpl->mEquations.push_back(equation);
     }
 
-    // Clean up our equations' dependencies.
-    // Note: indeed, some equations may have a dependency on the variable of
-    //       integration (for which there is no equation) and/or one or several
-    //       true (i.e. non-computed) constants (for which there are no proper
-    //       equations). So, we need to remove those dependencies, and obviously
-    //       this can only be done once all our equations are ready.
+    // Remove the dummy equations for our constants.
+    // Note: indeed, some equations may have a dependency on one or several constants (for which there are no proper
+    //       equations). So, we need to remove those dependencies, and obviously this can only be done once all our
+    //       equations are ready.
 
     for (const auto &equation : mModel->mPimpl->mEquations) {
-        equation->mPimpl->cleanUpDependencies();
+        equation->mPimpl->removeDummyDependencies();
     }
 
     // Determine whether our equations are state/rate based.

src/analyserequation.cpp

@@ -29,20 +29,26 @@ AnalyserEquationPtr AnalyserEquation::AnalyserEquationImpl::create()
     return std::shared_ptr<AnalyserEquation> {new AnalyserEquation {}};
 }
 
-bool AnalyserEquation::AnalyserEquationImpl::isEmptyDependency(const AnalyserEquationWeakPtr &dependency)
+bool AnalyserEquation::AnalyserEquationImpl::isDummyDependency(const AnalyserEquationWeakPtr &dependency)
 {
-    auto variables = libcellml::variables(dependency.lock());
+    return libcellml::variables(dependency.lock()).empty();
+}
+
+void AnalyserEquation::AnalyserEquationImpl::removeDummyDependencies()
+{
+    // Keep track of our constant dependencies, so that we can generate some code for them, should they be untracked.
 
-    if (std::any_of(variables.begin(), variables.end(), [](const auto &v) { return v != nullptr; })) {
-        return false;
+    for (const auto &dependency : mDependencies) {
+        auto constantDependency = dependency.lock()->mPimpl->mConstant;
+
+        if (isDummyDependency(dependency)) {
+            mConstantDependencies.push_back(constantDependency);
+        }
     }
 
-    return true;
-}
+    // Effectively remove our dummy dependencies.
 
-void AnalyserEquation::AnalyserEquationImpl::cleanUpDependencies()
-{
-    mDependencies.erase(std::remove_if(mDependencies.begin(), mDependencies.end(), isEmptyDependency), mDependencies.end());
+    mDependencies.erase(std::remove_if(mDependencies.begin(), mDependencies.end(), isDummyDependency), mDependencies.end());
 }
 
 AnalyserEquation::AnalyserEquation()

src/analyserequation_p.h

@@ -34,19 +34,22 @@ struct AnalyserEquation::AnalyserEquationImpl
     size_t mNlaSystemIndex;
     bool mIsStateRateBased = false;
 
+    AnalyserVariablePtr mConstant;
+
     std::vector<AnalyserVariablePtr> mStates;
     std::vector<AnalyserVariablePtr> mComputedConstants;
     std::vector<AnalyserVariablePtr> mAlgebraic;
     std::vector<AnalyserVariablePtr> mExternals;
 
+    std::vector<AnalyserVariablePtr> mConstantDependencies;
     std::vector<AnalyserEquationWeakPtr> mDependencies;
     std::vector<AnalyserEquationWeakPtr> mNlaSiblings;
 
     static AnalyserEquationPtr create();
 
-    static bool isEmptyDependency(const AnalyserEquationWeakPtr &dependency);
+    static bool isDummyDependency(const AnalyserEquationWeakPtr &dependency);
 
-    void cleanUpDependencies();
+    void removeDummyDependencies();
 };
 
 } // namespace libcellml

src/analysermodel.cpp

@@ -237,39 +237,9 @@ AnalyserVariablePtr AnalyserModel::variable(const VariablePtr &variable)
         return {};
     }
 
-    if (mPimpl->mVoi != nullptr) {
-        if (areEquivalentVariables(mPimpl->mVoi->variable(), variable)) {
-            return mPimpl->mVoi;
-        }
-    }
-
-    for (const auto &state : mPimpl->mStates) {
-        if (areEquivalentVariables(state->variable(), variable)) {
-            return state;
-        }
-    }
-
-    for (const auto &constant : mPimpl->mConstants) {
-        if (areEquivalentVariables(constant->variable(), variable)) {
-            return constant;
-        }
-    }
-
-    for (const auto &computedConstant : mPimpl->mComputedConstants) {
-        if (areEquivalentVariables(computedConstant->variable(), variable)) {
-            return computedConstant;
-        }
-    }
-
-    for (const auto &algebraic : mPimpl->mAlgebraic) {
-        if (areEquivalentVariables(algebraic->variable(), variable)) {
-            return algebraic;
-        }
-    }
-
-    for (const auto &external : mPimpl->mExternals) {
-        if (areEquivalentVariables(external->variable(), variable)) {
-            return external;
+    for (const auto &modelVariable : variables(shared_from_this())) {
+        if (areEquivalentVariables(variable, modelVariable->variable())) {
+            return modelVariable;
         }
     }
 

src/api/libcellml/analyserequation.h

@@ -29,6 +29,7 @@ namespace libcellml {
 class LIBCELLML_EXPORT AnalyserEquation
 {
     friend class Analyser;
+    friend class Generator;
 
 public:
     /**

src/api/libcellml/analysermodel.h

@@ -18,6 +18,10 @@ limitations under the License.
 
 #include "libcellml/analyser.h"
 
+#ifndef SWIG
+template class LIBCELLML_EXPORT std::weak_ptr<libcellml::AnalyserModel>;
+#endif
+
 namespace libcellml {
 
 /**
@@ -27,6 +31,9 @@ namespace libcellml {
  * CellML Analyser.
  */
 class LIBCELLML_EXPORT AnalyserModel
+#ifndef SWIG
+    : public std::enable_shared_from_this<AnalyserModel>
+#endif
 {
     friend class Analyser;
     friend class Generator;