Generator: specify tracked/untracked variables.

cellml · Oct 18, 2024 · 175afd6 · 175afd6
1 parent d82485b
commit 175afd6
Show file tree

Hide file tree

Showing 4 changed files with 252 additions and 9 deletions.
diff --git a/src/api/libcellml/generator.h b/src/api/libcellml/generator.h
@@ -209,6 +209,94 @@ class LIBCELLML_EXPORT Generator
      */
     bool untrackAllVariables(const AnalyserModelPtr &model);
 
+    /**
+     * @brief Get the number of tracked constants in the given @p model.
+     *
+     * Get the number of tracked constants in the given @p model.
+     *
+     * @param model The pointer to the @ref AnalyserModel for which to get the number of tracked constants.
+     *
+     * @return The number of tracked constants in the model.
+     */
+    size_t trackedConstantCount(const AnalyserModelPtr &model);
+
+    /**
+     * @brief Get the number of untracked constants in the given @p model.
+     *
+     * Get the number of untracked constants in the given @p model.
+     *
+     * @param model The pointer to the @ref AnalyserModel for which to get the number of untracked constants.
+     *
+     * @return The number of untracked constants in the model.
+     */
+    size_t untrackedConstantCount(const AnalyserModelPtr &model);
+
+    /**
+     * @brief Get the number of tracked computed constants in the given @p model.
+     *
+     * Get the number of tracked computed constants in the given @p model.
+     *
+     * @param model The pointer to the @ref AnalyserModel for which to get the number of tracked computed constants.
+     *
+     * @return The number of tracked computed constants in the model.
+     */
+    size_t trackedComputedConstantCount(const AnalyserModelPtr &model);
+
+    /**
+     * @brief Get the number of untracked computed constants in the given @p model.
+     *
+     * Get the number of untracked computed constants in the given @p model.
+     *
+     * @param model The pointer to the @ref AnalyserModel for which to get the number of untracked computed constants.
+     *
+     * @return The number of untracked computed constants in the model.
+     */
+    size_t untrackedComputedConstantCount(const AnalyserModelPtr &model);
+
+    /**
+     * @brief Get the number of tracked algebraic variables in the given @p model.
+     *
+     * Get the number of tracked algebraic variables in the given @p model.
+     *
+     * @param model The pointer to the @ref AnalyserModel for which to get the number of tracked algebraic variables.
+     *
+     * @return The number of tracked algebraic variables in the model.
+     */
+    size_t trackedAlgebraicCount(const AnalyserModelPtr &model);
+
+    /**
+     * @brief Get the number of untracked algebraic variables in the given @p model.
+     *
+     * Get the number of untracked algebraic variables in the given @p model.
+     *
+     * @param model The pointer to the @ref AnalyserModel for which to get the number of untracked algebraic variables.
+     *
+     * @return The number of untracked algebraic variables in the model.
+     */
+    size_t untrackedAlgebraicCount(const AnalyserModelPtr &model);
+
+    /**
+     * @brief Get the number of tracked external variables in the given @p model.
+     *
+     * Get the number of tracked external variables in the given @p model.
+     *
+     * @param model The pointer to the @ref AnalyserModel for which to get the number of tracked external variables.
+     *
+     * @return The number of tracked external variables in the model.
+     */
+    size_t trackedExternalCount(const AnalyserModelPtr &model);
+
+    /**
+     * @brief Get the number of untracked external variables in the given @p model.
+     *
+     * Get the number of untracked external variables in the given @p model.
+     *
+     * @param model The pointer to the @ref AnalyserModel for which to get the number of untracked external variables.
+     *
+     * @return The number of untracked external variables in the model.
+     */
+    size_t untrackedExternalCount(const AnalyserModelPtr &model);
+
     /**
      * @brief Get the number of tracked variables in the given @p model.
      *

diff --git a/src/generator.cpp b/src/generator.cpp
@@ -187,15 +187,13 @@ bool Generator::GeneratorImpl::untrackAllVariables(const AnalyserModelPtr &model
     return doTrackAllVariables(model, false);
 }
 
-size_t Generator::GeneratorImpl::doTrackedVariableCount(const AnalyserModelPtr &model, bool tracked)
+size_t Generator::GeneratorImpl::doTrackedVariableCount(const AnalyserModelPtr &model,
+                                                        const std::vector<AnalyserVariablePtr> &variables,
+                                                        bool tracked)
 {
-    if (model == nullptr) {
-        return 0;
-    }
-
     size_t res = 0;
 
-    for (const auto &variable : variables(model, false)) {
+    for (const auto &variable : variables) {
         if (mTrackedVariables[model].find(variable) == mTrackedVariables[model].end()) {
             mTrackedVariables[model][variable] = true;
         }
@@ -208,14 +206,94 @@ size_t Generator::GeneratorImpl::doTrackedVariableCount(const AnalyserModelPtr &
     return res;
 }
 
+size_t Generator::GeneratorImpl::trackedConstantCount(const AnalyserModelPtr &model)
+{
+    if (model == nullptr) {
+        return 0;
+    }
+
+    return doTrackedVariableCount(model, model->constants(), true);
+}
+
+size_t Generator::GeneratorImpl::untrackedConstantCount(const AnalyserModelPtr &model)
+{
+    if (model == nullptr) {
+        return 0;
+    }
+
+    return doTrackedVariableCount(model, model->constants(), false);
+}
+
+size_t Generator::GeneratorImpl::trackedComputedConstantCount(const AnalyserModelPtr &model)
+{
+    if (model == nullptr) {
+        return 0;
+    }
+
+    return doTrackedVariableCount(model, model->computedConstants(), true);
+}
+
+size_t Generator::GeneratorImpl::untrackedComputedConstantCount(const AnalyserModelPtr &model)
+{
+    if (model == nullptr) {
+        return 0;
+    }
+
+    return doTrackedVariableCount(model, model->computedConstants(), false);
+}
+
+size_t Generator::GeneratorImpl::trackedAlgebraicCount(const AnalyserModelPtr &model)
+{
+    if (model == nullptr) {
+        return 0;
+    }
+
+    return doTrackedVariableCount(model, model->algebraic(), true);
+}
+
+size_t Generator::GeneratorImpl::untrackedAlgebraicCount(const AnalyserModelPtr &model)
+{
+    if (model == nullptr) {
+        return 0;
+    }
+
+    return doTrackedVariableCount(model, model->algebraic(), false);
+}
+
+size_t Generator::GeneratorImpl::trackedExternalCount(const AnalyserModelPtr &model)
+{
+    if (model == nullptr) {
+        return 0;
+    }
+
+    return doTrackedVariableCount(model, model->externals(), true);
+}
+
+size_t Generator::GeneratorImpl::untrackedExternalCount(const AnalyserModelPtr &model)
+{
+    if (model == nullptr) {
+        return 0;
+    }
+
+    return doTrackedVariableCount(model, model->externals(), false);
+}
+
 size_t Generator::GeneratorImpl::trackedVariableCount(const AnalyserModelPtr &model)
 {
-    return doTrackedVariableCount(model, true);
+    if (model == nullptr) {
+        return 0;
+    }
+
+    return doTrackedVariableCount(model, variables(model, false), true);
 }
 
 size_t Generator::GeneratorImpl::untrackedVariableCount(const AnalyserModelPtr &model)
 {
-    return doTrackedVariableCount(model, false);
+    if (model == nullptr) {
+        return 0;
+    }
+
+    return doTrackedVariableCount(model, variables(model, false), false);
 }
 
 bool Generator::GeneratorImpl::modelHasOdes(const AnalyserModelPtr &model) const
@@ -2258,6 +2336,46 @@ bool Generator::untrackAllVariables(const AnalyserModelPtr &model)
     return mPimpl->untrackAllVariables(model);
 }
 
+size_t Generator::trackedConstantCount(const AnalyserModelPtr &model)
+{
+    return mPimpl->trackedConstantCount(model);
+}
+
+size_t Generator::untrackedConstantCount(const AnalyserModelPtr &model)
+{
+    return mPimpl->untrackedConstantCount(model);
+}
+
+size_t Generator::trackedComputedConstantCount(const AnalyserModelPtr &model)
+{
+    return mPimpl->trackedComputedConstantCount(model);
+}
+
+size_t Generator::untrackedComputedConstantCount(const AnalyserModelPtr &model)
+{
+    return mPimpl->untrackedComputedConstantCount(model);
+}
+
+size_t Generator::trackedAlgebraicCount(const AnalyserModelPtr &model)
+{
+    return mPimpl->trackedAlgebraicCount(model);
+}
+
+size_t Generator::untrackedAlgebraicCount(const AnalyserModelPtr &model)
+{
+    return mPimpl->untrackedAlgebraicCount(model);
+}
+
+size_t Generator::trackedExternalCount(const AnalyserModelPtr &model)
+{
+    return mPimpl->trackedExternalCount(model);
+}
+
+size_t Generator::untrackedExternalCount(const AnalyserModelPtr &model)
+{
+    return mPimpl->untrackedExternalCount(model);
+}
+
 size_t Generator::trackedVariableCount(const AnalyserModelPtr &model)
 {
     return mPimpl->trackedVariableCount(model);

diff --git a/src/generator_p.h b/src/generator_p.h
@@ -71,7 +71,20 @@ struct Generator::GeneratorImpl
     bool trackAllVariables(const AnalyserModelPtr &model);
     bool untrackAllVariables(const AnalyserModelPtr &model);
 
-    size_t doTrackedVariableCount(const AnalyserModelPtr &model, bool tracked);
+    size_t doTrackedVariableCount(const AnalyserModelPtr &model, const std::vector<AnalyserVariablePtr> &variables,
+                                  bool tracked);
+
+    size_t trackedConstantCount(const AnalyserModelPtr &model);
+    size_t untrackedConstantCount(const AnalyserModelPtr &model);
+
+    size_t trackedComputedConstantCount(const AnalyserModelPtr &model);
+    size_t untrackedComputedConstantCount(const AnalyserModelPtr &model);
+
+    size_t trackedAlgebraicCount(const AnalyserModelPtr &model);
+    size_t untrackedAlgebraicCount(const AnalyserModelPtr &model);
+
+    size_t trackedExternalCount(const AnalyserModelPtr &model);
+    size_t untrackedExternalCount(const AnalyserModelPtr &model);
 
     size_t trackedVariableCount(const AnalyserModelPtr &model);
     size_t untrackedVariableCount(const AnalyserModelPtr &model);

diff --git a/tests/generator/generatortrackedvariables.cpp b/tests/generator/generatortrackedvariables.cpp
@@ -234,16 +234,22 @@ TEST(GeneratorTrackedVariables, trackAndUntrackAllConstants)
     auto analyserModel = analyser->model();
     auto generator = libcellml::Generator::create();
 
+    EXPECT_EQ(size_t(5), generator->trackedConstantCount(analyserModel));
+    EXPECT_EQ(size_t(0), generator->untrackedConstantCount(analyserModel));
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 
     generator->untrackAllConstants(analyserModel);
 
+    EXPECT_EQ(size_t(0), generator->trackedConstantCount(analyserModel));
+    EXPECT_EQ(size_t(5), generator->untrackedConstantCount(analyserModel));
     EXPECT_EQ(size_t(13), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(5), generator->untrackedVariableCount(analyserModel));
 
     generator->trackAllConstants(analyserModel);
 
+    EXPECT_EQ(size_t(5), generator->trackedConstantCount(analyserModel));
+    EXPECT_EQ(size_t(0), generator->untrackedConstantCount(analyserModel));
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 }
@@ -259,16 +265,22 @@ TEST(GeneratorTrackedVariables, trackAndUntrackAllComputedConstants)
     auto analyserModel = analyser->model();
     auto generator = libcellml::Generator::create();
 
+    EXPECT_EQ(size_t(3), generator->trackedComputedConstantCount(analyserModel));
+    EXPECT_EQ(size_t(0), generator->untrackedComputedConstantCount(analyserModel));
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 
     generator->untrackAllComputedConstants(analyserModel);
 
+    EXPECT_EQ(size_t(0), generator->trackedComputedConstantCount(analyserModel));
+    EXPECT_EQ(size_t(3), generator->untrackedComputedConstantCount(analyserModel));
     EXPECT_EQ(size_t(15), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(3), generator->untrackedVariableCount(analyserModel));
 
     generator->trackAllComputedConstants(analyserModel);
 
+    EXPECT_EQ(size_t(3), generator->trackedComputedConstantCount(analyserModel));
+    EXPECT_EQ(size_t(0), generator->untrackedComputedConstantCount(analyserModel));
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 }
@@ -284,16 +296,22 @@ TEST(GeneratorTrackedVariables, trackAndUntrackAllAlgebraicVariables)
     auto analyserModel = analyser->model();
     auto generator = libcellml::Generator::create();
 
+    EXPECT_EQ(size_t(10), generator->trackedAlgebraicCount(analyserModel));
+    EXPECT_EQ(size_t(0), generator->untrackedAlgebraicCount(analyserModel));
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 
     generator->untrackAllAlgebraic(analyserModel);
 
+    EXPECT_EQ(size_t(0), generator->trackedAlgebraicCount(analyserModel));
+    EXPECT_EQ(size_t(10), generator->untrackedAlgebraicCount(analyserModel));
     EXPECT_EQ(size_t(8), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(10), generator->untrackedVariableCount(analyserModel));
 
     generator->trackAllAlgebraic(analyserModel);
 
+    EXPECT_EQ(size_t(10), generator->trackedAlgebraicCount(analyserModel));
+    EXPECT_EQ(size_t(0), generator->untrackedAlgebraicCount(analyserModel));
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 }
@@ -313,16 +331,22 @@ TEST(GeneratorTrackedVariables, trackAndUntrackAllExternalVariables)
     auto analyserModel = analyser->model();
     auto generator = libcellml::Generator::create();
 
+    EXPECT_EQ(size_t(3), generator->trackedExternalCount(analyserModel));
+    EXPECT_EQ(size_t(0), generator->untrackedExternalCount(analyserModel));
     EXPECT_EQ(size_t(21), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 
     generator->untrackAllExternals(analyserModel);
 
+    EXPECT_EQ(size_t(0), generator->trackedExternalCount(analyserModel));
+    EXPECT_EQ(size_t(3), generator->untrackedExternalCount(analyserModel));
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(3), generator->untrackedVariableCount(analyserModel));
 
     generator->trackAllExternals(analyserModel);
 
+    EXPECT_EQ(size_t(3), generator->trackedExternalCount(analyserModel));
+    EXPECT_EQ(size_t(0), generator->untrackedExternalCount(analyserModel));
     EXPECT_EQ(size_t(21), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 }