Make it possible to interpret a model (initially algebraic and ODE models)

CMakeLists.txt

@@ -249,8 +249,10 @@ if(CLANG_FORMAT_AVAILABLE)
  ${SOURCE_FILES}
  ${HEADER_FILES}
  ${CONFIG_FILES}
- ${TESTS_HEADER_FILES}
+ ${DEBUG_SOURCE_FILES}
+ ${DEBUG_HEADER_FILES}
  ${TESTS_SOURCE_FILES}
+ ${TESTS_HEADER_FILES}
  )
 
  set(CHECK_CODE_FORMATTING_SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/cmake_command_check_code_formatting.cmake)

cmake/common.cmake

@@ -313,3 +313,13 @@ function(redhat_based _RESULT)
  endif()
  set(${_RESULT} ${_REDHAT_BASED} PARENT_SCOPE)
 endfunction()
+
+function(link_libxml2 _TARGET)
+ if(HAVE_LIBXML2_CONFIG)
+ target_link_libraries(${_TARGET} PUBLIC ${LIBXML2_TARGET_NAME})
+ else()
+ target_include_directories(${_TARGET} PUBLIC ${LIBXML2_INCLUDE_DIR} ${ZLIB_INCLUDE_DIRS})
+ target_link_libraries(${_TARGET} PUBLIC ${LIBXML2_LIBRARIES} ${ZLIB_LIBRARIES})
+ target_compile_definitions(${_TARGET} PUBLIC ${LIBXML2_DEFINITIONS})
+ endif()
+endfunction()

src/CMakeLists.txt

@@ -49,12 +49,15 @@ set(SOURCE_FILES
  ${CMAKE_CURRENT_SOURCE_DIR}/entity.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/enums.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/generator.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/generatorinterpreter.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/generatorprofile.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/generatorprofiletools.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/importedentity.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/importer.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/importsource.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/internaltypes.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/interpreter.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/interpreterstatement.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/issue.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/logger.cpp
  ${CMAKE_CURRENT_SOURCE_DIR}/mathmldtd.cpp
@@ -94,6 +97,7 @@ set(GIT_API_HEADER_FILES
  ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/importedentity.h
  ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/importer.h
  ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/importsource.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/interpreter.h
  ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/issue.h
  ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/logger.h
  ${CMAKE_CURRENT_SOURCE_DIR}/api/libcellml/model.h
@@ -133,9 +137,14 @@ set(GIT_HEADER_FILES
  ${CMAKE_CURRENT_SOURCE_DIR}/debug.h
  ${CMAKE_CURRENT_SOURCE_DIR}/entity_p.h
  ${CMAKE_CURRENT_SOURCE_DIR}/generator_p.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/generatorinterpreter_p.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/generatorinterpreter.h
  ${CMAKE_CURRENT_SOURCE_DIR}/generatorprofilesha1values.h
  ${CMAKE_CURRENT_SOURCE_DIR}/generatorprofiletools.h
  ${CMAKE_CURRENT_SOURCE_DIR}/internaltypes.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/interpreter_p.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/interpreterstatement_p.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/interpreterstatement.h
  ${CMAKE_CURRENT_SOURCE_DIR}/issue_p.h
  ${CMAKE_CURRENT_SOURCE_DIR}/logger_p.h
  ${CMAKE_CURRENT_SOURCE_DIR}/mathmldtd.h
@@ -193,13 +202,7 @@ else()
  target_include_directories(cellml PUBLIC ${ZLIB_INCLUDE_DIRS})
 endif()
 
-if(HAVE_LIBXML2_CONFIG)
- target_link_libraries(cellml PUBLIC ${LIBXML2_TARGET_NAME})
-else()
- target_include_directories(cellml PUBLIC ${LIBXML2_INCLUDE_DIR} ${ZLIB_INCLUDE_DIRS})
- target_link_libraries(cellml PUBLIC ${LIBXML2_LIBRARIES} ${ZLIB_LIBRARIES})
- target_compile_definitions(cellml PUBLIC ${LIBXML2_DEFINITIONS})
-endif()
+link_libxml2(cellml)
 
 # Use target compile features to propagate features to consuming projects.
 target_compile_features(cellml PUBLIC cxx_std_17)
@@ -223,6 +226,8 @@ set(DEBUG_HEADER_FILES
 
 add_library(cellml_debug_utilities STATIC ${DEBUG_SOURCE_FILES} ${DEBUG_HEADER_FILES})
 
+link_libxml2(cellml_debug_utilities)
+
 target_compile_features(cellml_debug_utilities PUBLIC cxx_std_17)
 
 target_include_directories(cellml_debug_utilities
@@ -382,3 +387,6 @@ set(CONFIG_FILES
  ${LIBCELLML_VERSIONCONFIG_H_IN}
  PARENT_SCOPE
 )
+
+set(DEBUG_SOURCE_FILES ${DEBUG_SOURCE_FILES} PARENT_SCOPE)
+set(DEBUG_HEADER_FILES ${DEBUG_HEADER_FILES} PARENT_SCOPE)

src/analyser.cpp

@@ -42,7 +42,7 @@ limitations under the License.
 #include "analyservariable_p.h"
 #include "anycellmlelement_p.h"
 #include "commonutils.h"
-#include "generator_p.h"
+#include "generatorinterpreter_p.h"
 #include "issue_p.h"
 #include "logger_p.h"
 #include "utilities.h"
@@ -635,6 +635,8 @@ Analyser::AnalyserImpl::AnalyserImpl()
  mGeneratorProfile->setAbsoluteValueString("abs");
  mGeneratorProfile->setNaturalLogarithmString("ln");
  mGeneratorProfile->setCommonLogarithmString("log");
+ mGeneratorProfile->setMinString("min");
+ mGeneratorProfile->setMaxString("max");
  mGeneratorProfile->setRemString("rem");
  mGeneratorProfile->setAsinString("arcsin");
  mGeneratorProfile->setAcosString("arccos");
@@ -945,30 +947,32 @@ void Analyser::AnalyserImpl::analyseNode(const XmlNodePtr &node,
 
  ast->mPimpl->populate(AnalyserEquationAst::Type::PIECEWISE, astParent);
 
- analyseNode(mathmlChildNode(node, 0), ast->mPimpl->mOwnedLeftChild, ast, component, equation);
+ if (childCount >= 1) {
+ analyseNode(mathmlChildNode(node, 0), ast->mPimpl->mOwnedLeftChild, ast, component, equation);
 
- if (childCount >= 2) {
- AnalyserEquationAstPtr astRight;
- AnalyserEquationAstPtr tempAst;
+  if (childCount >= 2) {
+  AnalyserEquationAstPtr astRight;
+  AnalyserEquationAstPtr tempAst;
 
- analyseNode(mathmlChildNode(node, childCount - 1), astRight, nullptr, component, equation);
+  analyseNode(mathmlChildNode(node, childCount - 1), astRight, nullptr, component, equation);
 
- for (auto i = childCount - 2; i > 0; --i) {
- tempAst = AnalyserEquationAst::create();
+  for (auto i = childCount - 2; i > 0; --i) {
+  tempAst = AnalyserEquationAst::create();
 
- tempAst->mPimpl->populate(AnalyserEquationAst::Type::PIECEWISE, astParent);
+  tempAst->mPimpl->populate(AnalyserEquationAst::Type::PIECEWISE, astParent);
 
- analyseNode(mathmlChildNode(node, i), tempAst->mPimpl->mOwnedLeftChild, tempAst, component, equation);
+  analyseNode(mathmlChildNode(node, i), tempAst->mPimpl->mOwnedLeftChild, tempAst, component, equation);
 
- astRight->mPimpl->mParent = tempAst;
+  astRight->mPimpl->mParent = tempAst;
 
- tempAst->mPimpl->mOwnedRightChild = astRight;
- astRight = tempAst;
- }
+  tempAst->mPimpl->mOwnedRightChild = astRight;
+  astRight = tempAst;
+  }
 
- astRight->mPimpl->mParent = ast;
+  astRight->mPimpl->mParent = ast;
 
- ast->mPimpl->mOwnedRightChild = astRight;
+ ast->mPimpl->mOwnedRightChild = astRight;
+ }
  }
  } else if (node->isMathmlElement("piece")) {
  ast->mPimpl->populate(AnalyserEquationAst::Type::PIECE, astParent);
@@ -2686,9 +2690,9 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model)
  + "' is";
  description += hasPrimaryVariable ?
  " the" :
- (equivalentVariableCount == 1) ?
- " its corresponding" :
- " their corresponding";
+  ((equivalentVariableCount == 1) ?
+  " its corresponding" :
+  " their corresponding");
  description += " primary variable and will therefore be the one used as an external variable.";
 
  referenceRule = Issue::ReferenceRule::ANALYSER_EXTERNAL_VARIABLE_USE_PRIMARY_VARIABLE;

src/analyservariable.cpp

@@ -40,7 +40,6 @@ void AnalyserVariable::AnalyserVariableImpl::populate(AnalyserVariable::Type typ
  mIndex = index;
  mInitialisingVariable = initialisingVariable;
  mVariable = variable;
- mComponent = owningComponent(mVariable);
 
  std::copy(equations.begin(), equations.end(), back_inserter(mEquations));
 }

src/analyservariable_p.h

@@ -33,7 +33,6 @@ struct AnalyserVariable::AnalyserVariableImpl
  size_t mIndex = 0;
  VariablePtr mInitialisingVariable;
  VariablePtr mVariable;
- ComponentPtr mComponent;
  std::vector<AnalyserEquationWeakPtr> mEquations;
 
  static AnalyserVariablePtr create();

src/api/libcellml/generator.h

@@ -111,13 +111,13 @@ class LIBCELLML_EXPORT Generator
  * Return the equation code for the given @ref AnalyserEquationAst using @ref GeneratorProfile.
  *
  * @param ast The @ref AnalyserEquationAst for which we want to generate some code.
- * @param generatorProfile The @ref GeneratorProfile, if any, to use to generate the equation code. If no
+ * @param profile The @ref GeneratorProfile, if any, to use to generate the equation code. If no
  * @ref GeneratorProfile is provided then the default @ref GeneratorProfile is used.
  *
  * @return The equation code as a @c std::string.
  */
  static std::string equationCode(const AnalyserEquationAstPtr &ast,
- const GeneratorProfilePtr &generatorProfile);
+ const GeneratorProfilePtr &profile);
 
  /**
  * @brief Get the equation code for the given @ref AnalyserEquationAst using a default @ref GeneratorProfile.

src/api/libcellml/interpreter.h

@@ -0,0 +1,142 @@
+/*
+Copyright libCellML Contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http:https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#pragma once
+
+#include "libcellml/exportdefinitions.h"
+#include "libcellml/types.h"
+
+#include <vector>
+
+namespace libcellml {
+
+/**
+ * @brief The Interpreter class.
+ *
+ * The Interpreter class is for representing a CellML Interpreter.
+ *
+ * @warning The Interpreter class currently supports pure algebraic models and ODE models. NLA and DAE models are not
+ * currently supported and neither are models with external variables.
+ */
+class LIBCELLML_EXPORT Interpreter
+{
+public:
+ ~Interpreter(); /**< Destructor, @private. */
+ Interpreter(const Interpreter &rhs) = delete; /**< Copy constructor, @private. */
+ Interpreter(Interpreter &&rhs) noexcept = delete; /**< Move constructor, @private. */
+ Interpreter &operator=(Interpreter rhs) = delete; /**< Assignment operator, @private. */
+
+ /**
+ * @brief Create an @ref Interpreter object.
+ *
+ * Factory method to create an @ref Interpreter. Create an interpreter with::
+ *
+ * @code
+ * auto interpreter = libcellml::Interpreter::create();
+ * @endcode
+ *
+ * @return A smart pointer to an @ref Interpreter object.
+ */
+ static InterpreterPtr create() noexcept;
+
+ /**
+ * @brief Get the @ref AnalyserModel.
+ *
+ * Get the @ref AnalyserModel used by this @ref Interpreter.
+ *
+ * @return The @ref AnalyserModel used.
+ */
+ AnalyserModelPtr model();
+
+ /**
+ * @brief Set the @ref AnalyserModel.
+ *
+ * Set the @ref AnalyserModel to be used by this @ref Interpreter.
+ *
+ * @param model The @ref AnalyserModel to set.
+ */
+ void setModel(const AnalyserModelPtr &model);
+
+ /**
+ * @brief Initialise the model's variables.
+ *
+ * Initialise the model's variables. This method is only relevant for algebraic models.
+ *
+ * @param pVariables The array of variables to initialise.
+ */
+ void initialiseVariablesForAlgebraicModel(double *pVariables) const;
+
+ /**
+ * @brief Initialise the model's variables.
+ *
+ * Initialise the model's variables. This method is only relevant for differential models.
+ *
+ * @param pStates The array of states to initialise.
+ * @param pRates The array of rates to initialise.
+ * @param pVariables The array of variables to initialise.
+ */
+ void initialiseVariablesForDifferentialModel(double *pStates, double *pRates, double *pVariables) const;
+
+ /**
+ * @brief Compute the model's computed constants.
+ *
+ * Compute the model's computed constants.
+ *
+ * @param pVariables The array of variables to compute.
+ */
+ void computeComputedConstants(double *pVariables) const;
+
+ /**
+ * @brief Compute the model's rates.
+ *
+ * Compute the model's rates. This method is only relevant for differential models.
+ *
+ * @param pVoi The value of the variable of integration.
+ * @param pStates The array of states.
+ * @param pRates The array of rates to compute.
+ * @param pVariables The array of variables.
+ */
+ void computeRates(double pVoi, double *pStates, double *pRates, double *pVariables) const;
+
+ /**
+ * @brief Compute the model's variables.
+ *
+ * Compute the model's variables. This method is only relevant for algebraic models.
+ *
+ * @param pVariables The array of variables to compute.
+ */
+ void computeVariablesForAlgebraicModel(double *pVariables) const;
+
+ /**
+ * @brief Compute the model's variables.
+ *
+ * Compute the model's variables. This method is only relevant for differential models.
+ *
+ * @param pVoi The value of the variable of integration.
+ * @param pStates The array of states.
+ * @param pRates The array of rates.
+ * @param pVariables The array of variables to compute.
+ */
+ void computeVariablesForDifferentialModel(double pVoi, double *pStates, double *pRates, double *pVariables) const;
+
+private:
+ Interpreter(); /**< Constructor, @private. */
+
+ struct InterpreterImpl;
+ InterpreterImpl *mPimpl; /**< Private member to implementation pointer, @private. */
+};
+
+} // namespace libcellml

src/api/libcellml/module/libcellml

@@ -37,6 +37,7 @@ limitations under the License.
 #include "libcellml/generatorprofile.h"
 #include "libcellml/importer.h"
 #include "libcellml/importsource.h"
+#include "libcellml/interpreter.h"
 #include "libcellml/issue.h"
 #include "libcellml/logger.h"
 #include "libcellml/model.h"

src/api/libcellml/types.h

@@ -50,6 +50,8 @@ class GeneratorProfile; /**< Forward declaration of GeneratorProfile class. */
 using GeneratorProfilePtr = std::shared_ptr<GeneratorProfile>; /**< Type definition for shared generator variable pointer. */
 class Importer; /**< Forward declaration of Importer class. */
 using ImporterPtr = std::shared_ptr<Importer>; /**< Type definition for shared importer pointer. */
+class Interpreter; /**< Forward declaration of Interpreter class. */
+using InterpreterPtr = std::shared_ptr<Interpreter>; /**< Type definition for shared Interpreter pointer. */
 class Issue; /**< Forward declaration of Issue class. */
 using IssuePtr = std::shared_ptr<Issue>; /**< Type definition for shared issue pointer. */
 class Logger; /**< Forward declaration of Parser class. */