Generator: specify tracked/untracked variables.

agarny · agarny · commit 9df5d4ee0c86 · 2024-10-18T13:40:34.000+13:00
diff --git a/src/analyser.cpp b/src/analyser.cpp
@@ -1049,7 +1049,7 @@ void Analyser::AnalyserImpl::analyseEquationAst(const AnalyserEquationAstPtr &as
                         mModel->mPimpl->mVoi = AnalyserVariable::AnalyserVariableImpl::create();
 
                         mModel->mPimpl->mVoi->mPimpl->populate(AnalyserVariable::Type::VARIABLE_OF_INTEGRATION,
-                                                               0, nullptr, voi, {});
+                                                               0, nullptr, voi, mModel, {});
                     }
                 }
             } while (voi == nullptr);
@@ -2945,8 +2945,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model)
                                    (variableType == AnalyserVariable::Type::EXTERNAL) ?
                                        nullptr :
                                        internalVariable->mInitialisingVariable,
-                                   internalVariable->mVariable,
-                                   equations);
+                                   internalVariable->mVariable, mModel, equations);
 
         aiv2avMappings.emplace(internalVariable, variable);
         v2avMappings.emplace(internalVariable->mVariable, variable);
diff --git a/src/analyservariable.cpp b/src/analyservariable.cpp
@@ -34,13 +34,14 @@ void AnalyserVariable::AnalyserVariableImpl::populate(AnalyserVariable::Type typ
                                                       size_t index,
                                                       const VariablePtr &initialisingVariable,
                                                       const VariablePtr &variable,
+                                                      const AnalyserModelPtr &model,
                                                       const std::vector<AnalyserEquationPtr> &equations)
 {
     mType = type;
     mIndex = index;
     mInitialisingVariable = initialisingVariable;
     mVariable = variable;
-    mComponent = owningComponent(mVariable);
+    mModel = model;
 
     std::copy(equations.begin(), equations.end(), back_inserter(mEquations));
 }
@@ -88,6 +89,11 @@ VariablePtr AnalyserVariable::variable() const
     return mPimpl->mVariable;
 }
 
+AnalyserModelPtr AnalyserVariable::model() const
+{
+    return mPimpl->mModel.lock();
+}
+
 size_t AnalyserVariable::equationCount() const
 {
     return mPimpl->mEquations.size();
diff --git a/src/analyservariable_p.h b/src/analyservariable_p.h
@@ -22,6 +22,8 @@ limitations under the License.
 
 namespace libcellml {
 
+using AnalyserModelWeakPtr = std::weak_ptr<AnalyserModel>;
+
 /**
  * @brief The AnalyserVariable::AnalyserVariableImpl struct.
  *
@@ -33,14 +35,13 @@ struct AnalyserVariable::AnalyserVariableImpl
     size_t mIndex = 0;
     VariablePtr mInitialisingVariable;
     VariablePtr mVariable;
-    ComponentPtr mComponent;
+    AnalyserModelWeakPtr mModel;
     std::vector<AnalyserEquationWeakPtr> mEquations;
 
     static AnalyserVariablePtr create();
 
-    void populate(AnalyserVariable::Type type, size_t index,
-                  const VariablePtr &initialisingVariable,
-                  const VariablePtr &variable,
+    void populate(AnalyserVariable::Type type, size_t index, const VariablePtr &initialisingVariable,
+                  const VariablePtr &variable, const AnalyserModelPtr &model,
                   const std::vector<AnalyserEquationPtr> &equations);
 };
 
diff --git a/src/api/libcellml/analyservariable.h b/src/api/libcellml/analyservariable.h
@@ -119,6 +119,15 @@ class LIBCELLML_EXPORT AnalyserVariable
      */
     VariablePtr variable() const;
 
+    /**
+     * @brief Get the @ref AnalyserModel for this @ref AnalyserVariable.
+     *
+     * Return the @ref AnalyserModel for this @ref AnalyserVariable.
+     *
+     * @return The @ref AnalyserModel.
+     */
+    AnalyserModelPtr model() const;
+
     /**
      * @brief Get the number of equations used to compute this @ref AnalyserVariable.
      *
diff --git a/src/api/libcellml/generator.h b/src/api/libcellml/generator.h
@@ -72,24 +72,22 @@ class LIBCELLML_EXPORT Generator
      *
      * Track the given @p variable. This will add the variable to the list of tracked variables.
      *
-     * @param model The pointer to the @ref AnalyserModel containing the variable to track.
-     * @param variable The pointer to the @ref Variable to track.
+     * @param variable The pointer to the @ref AnalyserVariable to track.
      *
      * @return @c true if the variable was tracked, @c false otherwise.
      */
-    bool trackVariable(const AnalyserModelPtr &model, const VariablePtr &variable);
+    bool trackVariable(const AnalyserVariablePtr &variable);
 
     /**
      * @brief Untrack the given @p variable.
      *
      * Untrack the given @p variable. This will remove the variable from the list of tracked variables.
      *
-     * @param model The pointer to the @ref AnalyserModel containing the variable to untrack.
-     * @param variable The pointer to the @ref Variable to untrack.
+     * @param variable The pointer to the @ref AnalyserVariable to untrack.
      *
      * @return @c true if the variable was untracked, @c false otherwise.
      */
-    bool untrackVariable(const AnalyserModelPtr &model, const VariablePtr &variable);
+    bool untrackVariable(const AnalyserVariablePtr &variable);
 
     /**
      * @brief Track all the variables in the given @p model.
diff --git a/src/generator.cpp b/src/generator.cpp
@@ -43,42 +43,33 @@ void Generator::GeneratorImpl::reset()
     mCode = {};
 }
 
-bool Generator::GeneratorImpl::doTrackVariable(const ModelPtr &model, const VariablePtr &variable, bool tracked)
+bool Generator::GeneratorImpl::doTrackVariable(const AnalyserVariablePtr &variable, bool tracked)
 {
-    mTrackedVariables[model][variable] = tracked;
-
-    return true;
-}
-
-bool Generator::GeneratorImpl::doTrackVariable(const AnalyserModelPtr &model, const VariablePtr &variable, bool tracked)
-{
-    if ((model == nullptr) || (variable == nullptr)) {
+    if (variable == nullptr) {
         return false;
     }
 
-    auto owningModel = libcellml::owningModel(variable);
-
-    if (owningModel == nullptr) {
-        return false;
-    }
+    auto model = variable->model();
 
     for (const auto &untrackableVariable : variables(model, false)) {
-        if (model->areEquivalentVariables(variable, untrackableVariable->variable())) {
-            return doTrackVariable(owningModel, variable, tracked);
+        if (model->areEquivalentVariables(variable->variable(), untrackableVariable->variable())) {
+            mTrackedVariables[variable->model()][variable] = tracked;
+
+            return true;
         }
     }
 
     return false;
 }
 
-bool Generator::GeneratorImpl::trackVariable(const AnalyserModelPtr &model, const VariablePtr &variable)
+bool Generator::GeneratorImpl::trackVariable(const AnalyserVariablePtr &variable)
 {
-    return doTrackVariable(model, variable, true);
+    return doTrackVariable(variable, true);
 }
 
-bool Generator::GeneratorImpl::untrackVariable(const AnalyserModelPtr &model, const VariablePtr &variable)
+bool Generator::GeneratorImpl::untrackVariable(const AnalyserVariablePtr &variable)
 {
-    return doTrackVariable(model, variable, false);
+    return doTrackVariable(variable, false);
 }
 
 bool Generator::GeneratorImpl::doTrackAllVariables(const AnalyserModelPtr &model, bool tracked)
@@ -88,7 +79,7 @@ bool Generator::GeneratorImpl::doTrackAllVariables(const AnalyserModelPtr &model
     }
 
     for (const auto &variable : variables(model, false)) {
-        doTrackVariable(model->mPimpl->mModel, variable->variable(), tracked);
+        doTrackVariable(variable, tracked);
     }
 
     return true;
@@ -113,11 +104,11 @@ size_t Generator::GeneratorImpl::doTrackedVariableCount(const AnalyserModelPtr &
     size_t res = 0;
 
     for (const auto &variable : variables(model, false)) {
-        if (mTrackedVariables[model->mPimpl->mModel].find(variable->variable()) == mTrackedVariables[model->mPimpl->mModel].end()) {
-            mTrackedVariables[model->mPimpl->mModel][variable->variable()] = true;
+        if (mTrackedVariables[model].find(variable) == mTrackedVariables[model].end()) {
+            mTrackedVariables[model][variable] = true;
         }
 
-        if (mTrackedVariables[model->mPimpl->mModel][variable->variable()] == tracked) {
+        if (mTrackedVariables[model][variable] == tracked) {
             ++res;
         }
     }
@@ -2115,14 +2106,14 @@ void Generator::setProfile(const GeneratorProfilePtr &profile)
     mPimpl->mProfile = profile;
 }
 
-bool Generator::trackVariable(const AnalyserModelPtr &model, const VariablePtr &variable)
+bool Generator::trackVariable(const AnalyserVariablePtr &variable)
 {
-    return mPimpl->trackVariable(model, variable);
+    return mPimpl->trackVariable(variable);
 }
 
-bool Generator::untrackVariable(const AnalyserModelPtr &model, const VariablePtr &variable)
+bool Generator::untrackVariable(const AnalyserVariablePtr &variable)
 {
-    return mPimpl->untrackVariable(model, variable);
+    return mPimpl->untrackVariable(variable);
 }
 
 bool Generator::trackAllVariables(const AnalyserModelPtr &model)
diff --git a/src/generator_p.h b/src/generator_p.h
@@ -37,15 +37,14 @@ struct Generator::GeneratorImpl
 
     GeneratorProfilePtr mProfile = GeneratorProfile::create();
 
-    std::map<ModelPtr, std::map<VariablePtr, bool>> mTrackedVariables;
+    std::map<AnalyserModelPtr, std::map<AnalyserVariablePtr, bool>> mTrackedVariables;
 
     void reset();
 
-    bool doTrackVariable(const ModelPtr &model, const VariablePtr &variable, bool tracked);
-    bool doTrackVariable(const AnalyserModelPtr &model, const VariablePtr &variable, bool tracked);
+    bool doTrackVariable(const AnalyserVariablePtr &variable, bool tracked);
 
-    bool trackVariable(const AnalyserModelPtr &model, const VariablePtr &variable);
-    bool untrackVariable(const AnalyserModelPtr &model, const VariablePtr &variable);
+    bool trackVariable(const AnalyserVariablePtr &variable);
+    bool untrackVariable(const AnalyserVariablePtr &variable);
 
     bool doTrackAllVariables(const AnalyserModelPtr &model, bool tracked);
 
diff --git a/tests/generator/generatortrackedvariables.cpp b/tests/generator/generatortrackedvariables.cpp
@@ -20,7 +20,7 @@ limitations under the License.
 
 #include <libcellml>
 
-TEST(GeneratorTrackedVariables, noModelAndOrVariable)
+TEST(GeneratorTrackedVariables, noModelOrVariable)
 {
     auto parser = libcellml::Parser::create();
     auto model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml"));
@@ -34,17 +34,14 @@ TEST(GeneratorTrackedVariables, noModelAndOrVariable)
     EXPECT_EQ(size_t(0), generator->trackedVariableCount(nullptr));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(nullptr));
 
-    EXPECT_FALSE(generator->trackVariable(nullptr, nullptr));
-    EXPECT_FALSE(generator->untrackVariable(nullptr, nullptr));
-
-    EXPECT_FALSE(generator->trackVariable(analyserModel, nullptr));
-    EXPECT_FALSE(generator->untrackVariable(analyserModel, nullptr));
+    EXPECT_FALSE(generator->trackVariable(nullptr));
+    EXPECT_FALSE(generator->untrackVariable(nullptr));
 
     EXPECT_FALSE(generator->trackAllVariables(nullptr));
     EXPECT_FALSE(generator->untrackAllVariables(nullptr));
 }
 
-TEST(GeneratorTrackedVariables, trackUntrackAllVariables)
+TEST(GeneratorTrackedVariables, trackAndUntrackAllVariables)
 {
     auto parser = libcellml::Parser::create();
     auto model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml"));
@@ -69,7 +66,7 @@ TEST(GeneratorTrackedVariables, trackUntrackAllVariables)
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 }
 
-TEST(GeneratorTrackedVariables, trackUntrackVariableOfIntegration)
+TEST(GeneratorTrackedVariables, tracAndkUntrackVariableOfIntegration)
 {
     auto parser = libcellml::Parser::create();
     auto model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml"));
@@ -85,18 +82,18 @@ TEST(GeneratorTrackedVariables, trackUntrackVariableOfIntegration)
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 
-    EXPECT_FALSE(generator->untrackVariable(analyserModel, variable));
+    EXPECT_FALSE(generator->untrackVariable(analyserModel->variable(variable)));
 
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 
-    EXPECT_FALSE(generator->trackVariable(analyserModel, variable));
+    EXPECT_FALSE(generator->trackVariable(analyserModel->variable(variable)));
 
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 }
 
-TEST(GeneratorTrackedVariables, trackUntrackStateVariable)
+TEST(GeneratorTrackedVariables, trackAndUntrackStateVariable)
 {
     auto parser = libcellml::Parser::create();
     auto model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml"));
@@ -112,18 +109,18 @@ TEST(GeneratorTrackedVariables, trackUntrackStateVariable)
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 
-    EXPECT_FALSE(generator->untrackVariable(analyserModel, variable));
+    EXPECT_FALSE(generator->untrackVariable(analyserModel->variable(variable)));
 
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 
-    EXPECT_FALSE(generator->trackVariable(analyserModel, variable));
+    EXPECT_FALSE(generator->trackVariable(analyserModel->variable(variable)));
 
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 }
 
-TEST(GeneratorTrackedVariables, trackUntrackConstant)
+TEST(GeneratorTrackedVariables, trackAndUntrackConstant)
 {
     auto parser = libcellml::Parser::create();
     auto model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml"));
@@ -139,18 +136,18 @@ TEST(GeneratorTrackedVariables, trackUntrackConstant)
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 
-    EXPECT_TRUE(generator->untrackVariable(analyserModel, variable));
+    EXPECT_TRUE(generator->untrackVariable(analyserModel->variable(variable)));
 
     EXPECT_EQ(size_t(17), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(1), generator->untrackedVariableCount(analyserModel));
 
-    EXPECT_TRUE(generator->trackVariable(analyserModel, variable));
+    EXPECT_TRUE(generator->trackVariable(analyserModel->variable(variable)));
 
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 }
 
-TEST(GeneratorTrackedVariables, trackUntrackComputedConstant)
+TEST(GeneratorTrackedVariables, trackAndUntrackComputedConstant)
 {
     auto parser = libcellml::Parser::create();
     auto model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml"));
@@ -166,18 +163,18 @@ TEST(GeneratorTrackedVariables, trackUntrackComputedConstant)
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 
-    EXPECT_TRUE(generator->untrackVariable(analyserModel, variable));
+    EXPECT_TRUE(generator->untrackVariable(analyserModel->variable(variable)));
 
     EXPECT_EQ(size_t(17), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(1), generator->untrackedVariableCount(analyserModel));
 
-    EXPECT_TRUE(generator->trackVariable(analyserModel, variable));
+    EXPECT_TRUE(generator->trackVariable(analyserModel->variable(variable)));
 
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 }
 
-TEST(GeneratorTrackedVariables, trackUntrackAlgebraicVariable)
+TEST(GeneratorTrackedVariables, trackAndUntrackAlgebraicVariable)
 {
     auto parser = libcellml::Parser::create();
     auto model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml"));
@@ -193,18 +190,18 @@ TEST(GeneratorTrackedVariables, trackUntrackAlgebraicVariable)
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 
-    EXPECT_TRUE(generator->untrackVariable(analyserModel, variable));
+    EXPECT_TRUE(generator->untrackVariable(analyserModel->variable(variable)));
 
     EXPECT_EQ(size_t(17), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(1), generator->untrackedVariableCount(analyserModel));
 
-    EXPECT_TRUE(generator->trackVariable(analyserModel, variable));
+    EXPECT_TRUE(generator->trackVariable(analyserModel->variable(variable)));
 
     EXPECT_EQ(size_t(18), generator->trackedVariableCount(analyserModel));
     EXPECT_EQ(size_t(0), generator->untrackedVariableCount(analyserModel));
 }
 
-TEST(GeneratorTrackedVariables, trackUntrackNonMatchingModelAndVariable)
+TEST(GeneratorTrackedVariables, trackAndUntrackVariableFromOtherModel)
 {
     auto parser = libcellml::Parser::create();
     auto model = parser->parseModel(fileContents("generator/hodgkin_huxley_squid_axon_model_1952/model.cellml"));
@@ -218,6 +215,6 @@ TEST(GeneratorTrackedVariables, trackUntrackNonMatchingModelAndVariable)
 
     auto otherVariable = otherModel->component("membrane")->variable("Cm");
 
-    EXPECT_FALSE(generator->untrackVariable(analyserModel, otherVariable));
-    EXPECT_FALSE(generator->trackVariable(analyserModel, otherVariable));
+    EXPECT_FALSE(generator->untrackVariable(analyserModel->variable(otherVariable)));
+    EXPECT_FALSE(generator->trackVariable(analyserModel->variable(otherVariable)));
 }

Original file line number	Diff line number	Diff line change
`@@ -72,24 +72,22 @@ class LIBCELLML_EXPORT Generator`
`72`	`72`	`*`
`73`	`73`	`* Track the given @p variable. This will add the variable to the list of tracked variables.`
`74`	`74`	`*`
`75`		`- * @param model The pointer to the @ref AnalyserModel containing the variable to track.`
`76`		`- * @param variable The pointer to the @ref Variable to track.`
	`75`	`+ * @param variable The pointer to the @ref AnalyserVariable to track.`
`77`	`76`	`*`
`78`	`77`	`* @return @c true if the variable was tracked, @c false otherwise.`
`79`	`78`	`*/`
`80`		`- bool trackVariable(const AnalyserModelPtr &model, const VariablePtr &variable);`
	`79`	`+ bool trackVariable(const AnalyserVariablePtr &variable);`
`81`	`80`
`82`	`81`	`/**`
`83`	`82`	`* @brief Untrack the given @p variable.`
`84`	`83`	`*`
`85`	`84`	`* Untrack the given @p variable. This will remove the variable from the list of tracked variables.`
`86`	`85`	`*`
`87`		`- * @param model The pointer to the @ref AnalyserModel containing the variable to untrack.`
`88`		`- * @param variable The pointer to the @ref Variable to untrack.`
	`86`	`+ * @param variable The pointer to the @ref AnalyserVariable to untrack.`
`89`	`87`	`*`
`90`	`88`	`* @return @c true if the variable was untracked, @c false otherwise.`
`91`	`89`	`*/`
`92`		`- bool untrackVariable(const AnalyserModelPtr &model, const VariablePtr &variable);`
	`90`	`+ bool untrackVariable(const AnalyserVariablePtr &variable);`
`93`	`91`
`94`	`92`	`/**`
`95`	`93`	`* @brief Track all the variables in the given @p model.`
Original file line number	Diff line number	Diff line change
`@@ -43,42 +43,33 @@ void Generator::GeneratorImpl::reset()`
`43`	`43`	`mCode = {};`
`44`	`44`	`}`
`45`	`45`
`46`		`-bool Generator::GeneratorImpl::doTrackVariable(const ModelPtr &model, const VariablePtr &variable, bool tracked)`
	`46`	`+bool Generator::GeneratorImpl::doTrackVariable(const AnalyserVariablePtr &variable, bool tracked)`
`47`	`47`	`{`
`48`		`- mTrackedVariables[model][variable] = tracked;`
`49`		`-`
`50`		`- return true;`
`51`		`-}`
`52`		`-`
`53`		`-bool Generator::GeneratorImpl::doTrackVariable(const AnalyserModelPtr &model, const VariablePtr &variable, bool tracked)`
`54`		`-{`
`55`		`- if ((model == nullptr) \|\| (variable == nullptr)) {`
	`48`	`+ if (variable == nullptr) {`
`56`	`49`	`return false;`
`57`	`50`	`}`
`58`	`51`
`59`		`- auto owningModel = libcellml::owningModel(variable);`
`60`		`-`
`61`		`- if (owningModel == nullptr) {`
`62`		`- return false;`
`63`		`- }`
	`52`	`+ auto model = variable->model();`
`64`	`53`
`65`	`54`	`for (const auto &untrackableVariable : variables(model, false)) {`
`66`		`- if (model->areEquivalentVariables(variable, untrackableVariable->variable())) {`
`67`		`- return doTrackVariable(owningModel, variable, tracked);`
	`55`	`+ if (model->areEquivalentVariables(variable->variable(), untrackableVariable->variable())) {`
	`56`	`+ mTrackedVariables[variable->model()][variable] = tracked;`
	`57`	`+`
	`58`	`+ return true;`
`68`	`59`	`}`
`69`	`60`	`}`
`70`	`61`
`71`	`62`	`return false;`
`72`	`63`	`}`
`73`	`64`
`74`		`-bool Generator::GeneratorImpl::trackVariable(const AnalyserModelPtr &model, const VariablePtr &variable)`
	`65`	`+bool Generator::GeneratorImpl::trackVariable(const AnalyserVariablePtr &variable)`
`75`	`66`	`{`
`76`		`- return doTrackVariable(model, variable, true);`
	`67`	`+ return doTrackVariable(variable, true);`
`77`	`68`	`}`
`78`	`69`
`79`		`-bool Generator::GeneratorImpl::untrackVariable(const AnalyserModelPtr &model, const VariablePtr &variable)`
	`70`	`+bool Generator::GeneratorImpl::untrackVariable(const AnalyserVariablePtr &variable)`
`80`	`71`	`{`
`81`		`- return doTrackVariable(model, variable, false);`
	`72`	`+ return doTrackVariable(variable, false);`
`82`	`73`	`}`
`83`	`74`
`84`	`75`	`bool Generator::GeneratorImpl::doTrackAllVariables(const AnalyserModelPtr &model, bool tracked)`
`@@ -88,7 +79,7 @@ bool Generator::GeneratorImpl::doTrackAllVariables(const AnalyserModelPtr &model`
`88`	`79`	`}`
`89`	`80`
`90`	`81`	`for (const auto &variable : variables(model, false)) {`
`91`		`- doTrackVariable(model->mPimpl->mModel, variable->variable(), tracked);`
	`82`	`+ doTrackVariable(variable, tracked);`
`92`	`83`	`}`
`93`	`84`
`94`	`85`	`return true;`
`@@ -113,11 +104,11 @@ size_t Generator::GeneratorImpl::doTrackedVariableCount(const AnalyserModelPtr &`
`113`	`104`	`size_t res = 0;`
`114`	`105`
`115`	`106`	`for (const auto &variable : variables(model, false)) {`
`116`		`- if (mTrackedVariables[model->mPimpl->mModel].find(variable->variable()) == mTrackedVariables[model->mPimpl->mModel].end()) {`
`117`		`- mTrackedVariables[model->mPimpl->mModel][variable->variable()] = true;`
	`107`	`+ if (mTrackedVariables[model].find(variable) == mTrackedVariables[model].end()) {`
	`108`	`+ mTrackedVariables[model][variable] = true;`
`118`	`109`	`}`
`119`	`110`
`120`		`- if (mTrackedVariables[model->mPimpl->mModel][variable->variable()] == tracked) {`
	`111`	`+ if (mTrackedVariables[model][variable] == tracked) {`
`121`	`112`	`++res;`
`122`	`113`	`}`
`123`	`114`	`}`
`@@ -2115,14 +2106,14 @@ void Generator::setProfile(const GeneratorProfilePtr &profile)`
`2115`	`2106`	`mPimpl->mProfile = profile;`
`2116`	`2107`	`}`
`2117`	`2108`
`2118`		`-bool Generator::trackVariable(const AnalyserModelPtr &model, const VariablePtr &variable)`
	`2109`	`+bool Generator::trackVariable(const AnalyserVariablePtr &variable)`
`2119`	`2110`	`{`
`2120`		`- return mPimpl->trackVariable(model, variable);`
	`2111`	`+ return mPimpl->trackVariable(variable);`
`2121`	`2112`	`}`
`2122`	`2113`
`2123`		`-bool Generator::untrackVariable(const AnalyserModelPtr &model, const VariablePtr &variable)`
	`2114`	`+bool Generator::untrackVariable(const AnalyserVariablePtr &variable)`
`2124`	`2115`	`{`
`2125`		`- return mPimpl->untrackVariable(model, variable);`
	`2116`	`+ return mPimpl->untrackVariable(variable);`
`2126`	`2117`	`}`
`2127`	`2118`
`2128`	`2119`	`bool Generator::trackAllVariables(const AnalyserModelPtr &model)`