From 175afd6ad06cfc9db4c0cf47ff2b77fd344c2065 Mon Sep 17 00:00:00 2001 From: Alan Garny Date: Fri, 18 Oct 2024 14:46:11 +1300 Subject: [PATCH] Generator: specify tracked/untracked variables. --- src/api/libcellml/generator.h | 88 ++++++++++++ src/generator.cpp | 134 ++++++++++++++++-- src/generator_p.h | 15 +- tests/generator/generatortrackedvariables.cpp | 24 ++++ 4 files changed, 252 insertions(+), 9 deletions(-) diff --git a/src/api/libcellml/generator.h b/src/api/libcellml/generator.h index 34bf3a7a7..fae9ae639 100644 --- 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 index 2e851a5a1..ee0dc89af 100644 --- 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 &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 index c0d14e6a3..ac0d4fe02 100644 --- 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 &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 index 84dfbce85..5263575dd 100644 --- 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)); }