diff --git a/src/analyser.cpp b/src/analyser.cpp index 1c3594e12..db451e96e 100644 --- a/src/analyser.cpp +++ b/src/analyser.cpp @@ -175,28 +175,42 @@ bool AnalyserInternalEquation::hasNonConstantVariables() return hasNonConstantVariables(mVariables) || hasNonConstantVariables(mStateVariables); } -bool AnalyserInternalEquation::variableOnLhsRhs(const AnalyserInternalVariablePtr &variable, +bool AnalyserInternalEquation::variableOnLhsRhs(const AnalyserModelPtr &analyserModel, + const AnalyserInternalVariablePtr &variable, const AnalyserEquationAstPtr &astChild) { + // Note #1: what we compute for a state variable is its rate, so a state variable is on its own on the LHS/RHS of + // an equation if its rate is (e.g., d(x)/d(t) = x), while any other variable is on its own if it itself + // is. + // Note #2: the variable of an internal variable may be any of its equivalent variables (e.g., the one of the + // component where it was first found), so we compare variables for equivalence rather than by name. + + auto isStateVariable = (variable->mType == AnalyserInternalVariable::Type::STATE) + || (variable->mType == AnalyserInternalVariable::Type::SHOULD_BE_STATE); + switch (astChild->type()) { case AnalyserEquationAst::Type::CI: - return astChild->variable()->name() == variable->mVariable->name(); + return !isStateVariable + && analyserModel->areEquivalentVariables(astChild->variable(), variable->mVariable); case AnalyserEquationAst::Type::DIFF: - return astChild->rightChild()->variable()->name() == variable->mVariable->name(); + return isStateVariable + && analyserModel->areEquivalentVariables(astChild->rightChild()->variable(), variable->mVariable); default: return false; } } -bool AnalyserInternalEquation::variableOnRhs(const AnalyserInternalVariablePtr &variable) +bool AnalyserInternalEquation::variableOnRhs(const AnalyserModelPtr &analyserModel, + const AnalyserInternalVariablePtr &variable) { - return variableOnLhsRhs(variable, mAst->rightChild()); + return variableOnLhsRhs(analyserModel, variable, mAst->rightChild()); } -bool AnalyserInternalEquation::variableOnLhsOrRhs(const AnalyserInternalVariablePtr &variable) +bool AnalyserInternalEquation::variableOnLhsOrRhs(const AnalyserModelPtr &analyserModel, + const AnalyserInternalVariablePtr &variable) { - return variableOnLhsRhs(variable, mAst->leftChild()) - || variableOnRhs(variable); + return variableOnLhsRhs(analyserModel, variable, mAst->leftChild()) + || variableOnRhs(analyserModel, variable); } bool AnalyserInternalEquation::check(const AnalyserModelPtr &analyserModel, bool checkNlaSystems) @@ -214,11 +228,22 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &analyserModel, bool mComputedVariableBasedConstant = mComputedVariableBasedConstant && !hasNonConstantVariables(); // Add, as a dependency, the variables used to compute the (new) known (state) - // variables. + // variables, and, as a rate dependency, the (new) known state variables + // which rate is used. + // Note: we keep track of internal variables rather than of their variable + // since the variable of an internal variable may change (e.g., when + // a state variable is initialised in a component and its ODE is in + // another component). for (const auto &variable : mVariables) { if (isKnownVariable(variable)) { - mDependencies.push_back(variable->mVariable); + mDependencies.push_back(variable); + } + } + + for (const auto &stateVariable : mStateVariables) { + if (isKnownStateVariable(stateVariable)) { + mRateDependencies.push_back(stateVariable); } } @@ -280,7 +305,7 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &analyserModel, bool nullptr; if (((unknownVariableLeft != nullptr) - && (checkNlaSystems || variableOnLhsOrRhs(unknownVariableLeft))) + && (checkNlaSystems || variableOnLhsOrRhs(analyserModel, unknownVariableLeft))) || !initialisedVariables.empty()) { auto variables = mVariables.empty() ? mStateVariables.empty() ? @@ -328,7 +353,7 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &analyserModel, bool // be solved as an NLA equation. if ((unknownVariableLeft == nullptr) - || !variableOnLhsOrRhs(unknownVariableLeft)) { + || !variableOnLhsOrRhs(analyserModel, unknownVariableLeft)) { mType = Type::NLA; } else { switch (unknownVariableLeft->mType) { @@ -355,9 +380,11 @@ bool AnalyserInternalEquation::check(const AnalyserModelPtr &analyserModel, bool // dx/dt = x+3). Similarly, an NLA equation will have a "dependency" on // its unknown variables. Either way, we must remove our "dependencies" // on our unknown variables or we will end up in a circular dependency. + // Note: we cannot have a rate dependency on the state of an ODE since + // we only know about that state once we know about that ODE. for (const auto &unknownVariable : mUnknownVariables) { - auto it = std::find(mDependencies.begin(), mDependencies.end(), unknownVariable->mVariable); + auto it = std::find(mDependencies.begin(), mDependencies.end(), unknownVariable); if (it != mDependencies.end()) { mDependencies.erase(it); @@ -2260,14 +2287,25 @@ bool Analyser::AnalyserImpl::isStateRateBased(const AnalyserEquationPtr &analyse checkedEquations.push_back(analyserEquation); + // An analyser equation is state/rate based if it uses a state (which is + // not a dependency since states are known) or a rate, or if one of its + // dependencies is state/rate based. + // Note: mIsStateRateBased is initially set to whether the analyser equation + // uses a state (see analyseModel()), and it is then set to its final + // value once it has been determined. Either way, if it is true then + // the analyser equation is state/rate based. + + if (analyserEquation->mPimpl->mIsStateRateBased) { + return true; + } + for (const auto &dependency : analyserEquation->dependencies()) { - // A rate is computed either through an ODE equation or through an NLA - // equation in case the rate is not on its own on either the LHS or RHS - // of the equation. + // A dependency that computes a state computes its rate (through an ODE + // equation or through an NLA equation, in case the rate is not on its + // own on either the LHS or RHS of the equation), which means that we + // use that rate. - if ((dependency->type() == AnalyserEquation::Type::ODE) - || ((dependency->type() == AnalyserEquation::Type::NLA) - && (dependency->stateCount() == 1)) + if ((dependency->stateCount() != 0) || isStateRateBased(dependency, checkedEquations)) { return true; } @@ -2382,7 +2420,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) internalVariable->mIsExternalVariable = true; for (const auto &dependency : externalVariable->dependencies()) { - internalVariable->mDependencies.push_back(Analyser::AnalyserImpl::internalVariable(dependency)->mVariable); + internalVariable->mDependencies.push_back(Analyser::AnalyserImpl::internalVariable(dependency)); } } } @@ -2928,7 +2966,6 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Make our internal variables available through our API. std::map aiv2avMappings; - std::map v2avMappings; auto stateIndex = MAX_SIZE_T; auto constantIndex = MAX_SIZE_T; auto computedConstantIndex = MAX_SIZE_T; @@ -3011,7 +3048,6 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) internalVariable->mVariable, mAnalyserModel, equations); aiv2avMappings.emplace(internalVariable, variable); - v2avMappings.emplace(internalVariable->mVariable, variable); if (variableType == AnalyserVariable::Type::STATE) { mAnalyserModel->mPimpl->mStates.push_back(variable); @@ -3062,17 +3098,21 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) // Swap the LHS and RHS of the equation if its unknown variable is // on its RHS. - if (internalEquation->variableOnRhs(internalEquation->mUnknownVariables.front())) { + if (internalEquation->variableOnRhs(mAnalyserModel, internalEquation->mUnknownVariables.front())) { internalEquation->mAst->swapLeftAndRightChildren(); } break; } - // Determine the equation's dependencies, i.e. the equations for the - // variables on which this equation depends. + // Determine the equation's dependencies, i.e. the equations that compute + // the variables and rates that this equation uses, and that must + // therefore be computed first. + // Note: the use of a state is not a dependency since states are known. + // Still, we keep track of it (see isStateRateBased()). - VariablePtrs variableDependencies; + AnalyserInternalVariablePtrs variableDependencies; + AnalyserInternalVariablePtrs rateDependencies; if (equationType == AnalyserEquation::Type::EXTERNAL) { for (const auto &unknownVariable : internalEquation->mUnknownVariables) { @@ -3082,29 +3122,42 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) } } else { variableDependencies = internalEquation->mDependencies; + rateDependencies = internalEquation->mRateDependencies; } AnalyserEquationPtrs equationDependencies; + auto usesStates = false; + auto addEquationDependencies = [&equationDependencies](const AnalyserVariablePtr &analyserVariable) { + for (const auto &analyserEquation : analyserVariable->analyserEquations()) { + if (std::find(equationDependencies.begin(), equationDependencies.end(), analyserEquation) == equationDependencies.end()) { + if (analyserVariable->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. + + analyserEquation->mPimpl->mConstant = analyserVariable; + } + + equationDependencies.push_back(analyserEquation); + } + } + }; for (const auto &variableDependency : variableDependencies) { - auto analyserVariable = v2avMappings[variableDependency]; + auto analyserVariable = aiv2avMappings[variableDependency]; if (analyserVariable != nullptr) { - for (const auto &analyserEquation : analyserVariable->analyserEquations()) { - if (std::find(equationDependencies.begin(), equationDependencies.end(), analyserEquation) == equationDependencies.end()) { - if (analyserVariable->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. - - analyserEquation->mPimpl->mConstant = analyserVariable; - } - - equationDependencies.push_back(analyserEquation); - } + if (analyserVariable->type() == AnalyserVariable::Type::STATE) { + usesStates = true; + } else { + addEquationDependencies(analyserVariable); } } } + for (const auto &rateDependency : rateDependencies) { + addEquationDependencies(aiv2avMappings[rateDependency]); + } + // Determine the equation's NLA siblings, i.e. the equations that should // be computed as part of an NLA system, should this equation be an NLA // one. @@ -3124,6 +3177,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model) nullptr : internalEquation->mAst; equation->mPimpl->mNlaSystemIndex = internalEquation->mNlaSystemIndex; + equation->mPimpl->mIsStateRateBased = usesStates; for (const auto &unknownVariable : internalEquation->mUnknownVariables) { // Keep track of the variable that the equation computes. diff --git a/src/analyser_p.h b/src/analyser_p.h index 2b821f2b8..3e8b1498b 100644 --- a/src/analyser_p.h +++ b/src/analyser_p.h @@ -64,7 +64,7 @@ struct AnalyserInternalVariable VariablePtr mInitialisingVariable; VariablePtr mVariable; - VariablePtrs mDependencies; + AnalyserInternalVariablePtrs mDependencies; static AnalyserInternalVariablePtr create(const VariablePtr &variable); @@ -90,7 +90,8 @@ struct AnalyserInternalEquation Type mType = Type::UNKNOWN; - VariablePtrs mDependencies; + AnalyserInternalVariablePtrs mDependencies; + AnalyserInternalVariablePtrs mRateDependencies; AnalyserEquationAstPtr mAst; @@ -124,10 +125,13 @@ struct AnalyserInternalEquation static bool hasNonConstantVariables(const AnalyserInternalVariablePtrs &variables); bool hasNonConstantVariables(); - bool variableOnLhsRhs(const AnalyserInternalVariablePtr &variable, + bool variableOnLhsRhs(const AnalyserModelPtr &analyserModel, + const AnalyserInternalVariablePtr &variable, const AnalyserEquationAstPtr &astChild); - bool variableOnRhs(const AnalyserInternalVariablePtr &variable); - bool variableOnLhsOrRhs(const AnalyserInternalVariablePtr &variable); + bool variableOnRhs(const AnalyserModelPtr &analyserModel, + const AnalyserInternalVariablePtr &variable); + bool variableOnLhsOrRhs(const AnalyserModelPtr &analyserModel, + const AnalyserInternalVariablePtr &variable); bool check(const AnalyserModelPtr &analyserModel, bool checkNlaSystems); }; diff --git a/src/api/libcellml/analyserequation.h b/src/api/libcellml/analyserequation.h index 7fcb8d367..b9b633f89 100644 --- a/src/api/libcellml/analyserequation.h +++ b/src/api/libcellml/analyserequation.h @@ -99,7 +99,11 @@ class LIBCELLML_EXPORT AnalyserEquation * @brief Get the list of @ref AnalyserEquation dependencies. * * Return the list of @ref AnalyserEquation items which correspond to the - * equations on which this @ref AnalyserEquation depends. + * equations on which this @ref AnalyserEquation depends, i.e. the + * equations that compute the variables and the rates that it uses, and + * that must therefore be computed before it. The use of a state is not a + * dependency since states are known, but the use of the rate of a state + * (e.g., @c dx/dt) is a dependency on the equation that computes that rate. * * @return The dependencies as a @c std::vector. */ diff --git a/src/api/libcellml/generator.h b/src/api/libcellml/generator.h index f4aa43983..352e7135a 100644 --- a/src/api/libcellml/generator.h +++ b/src/api/libcellml/generator.h @@ -25,6 +25,11 @@ namespace libcellml { * @brief The Generator class. * * The Generator class is for representing a CellML Generator. + * + * Note: for a differential model, the generated computeVariables() method doesn't recompute tracked variables produced by + * the generated computeRates() method, although untracked local dependencies may be recomputed. Therefore, computeRates() + * must be called first with the same variable of integration, state, constant, and computed constant values, reusing the + * rate, algebraic variable, and external variable arrays populated by that call when computeVariables() is called. */ class LIBCELLML_EXPORT Generator: public Logger { diff --git a/src/generator.cpp b/src/generator.cpp index 4a4ecc2ec..2c169cacd 100644 --- a/src/generator.cpp +++ b/src/generator.cpp @@ -786,29 +786,35 @@ void Generator::GeneratorImpl::addNlaSystemsCode() } // b) Initialise any untracked constant, computed constant, or algebraic variable that is needed by - // our NLA system. + // our NLA system (see nlaSystemDependencies()). + // Note: only an NLA system with one NLA equation can have constant dependencies since a constant + // is initialised and would therefore be considered as an unknown of an NLA system with + // several NLA equations. Also, we keep track of those constant dependencies so that they + // don't get generated again for one of our untracked dependencies. methodBody += "\n"; auto methodBodySize = methodBody.size(); + std::vector generatedConstantDependencies; for (const auto &constantDependency : analyserEquation->mPimpl->mConstantDependencies) { if (isTrackedVariable(constantDependency, false)) { methodBody += generateInitialisationCode(constantDependency, true); + + generatedConstantDependencies.push_back(constantDependency); } } std::vector dummyRemainingAnalyserEquations = mAnalyserModel->analyserEquations(); std::vector dummyAnalyserEquationsForDependencies; - std::vector dummyGeneratedConstantDependencies; - for (const auto &dependency : analyserEquation->dependencies()) { + for (const auto &dependency : nlaSystemDependencies(analyserEquation)) { if (((dependency->type() == AnalyserEquation::Type::COMPUTED_CONSTANT) || (dependency->type() == AnalyserEquation::Type::ALGEBRAIC)) && isTrackedEquation(dependency, false)) { methodBody += generateEquationCode(dependency, dummyRemainingAnalyserEquations, dummyAnalyserEquationsForDependencies, - dummyGeneratedConstantDependencies, false, + generatedConstantDependencies, false, GenerateEquationCodeTarget::OBJECTIVE_FUNCTION); } } @@ -1726,37 +1732,43 @@ std::string Generator::GeneratorImpl::generateCode(const AnalyserEquationAstPtr return code; } -bool Generator::GeneratorImpl::isToBeComputedAgain(const AnalyserEquationPtr &analyserEquation) +bool Generator::GeneratorImpl::isSomeConstant(const AnalyserEquationPtr &analyserEquation, + bool includeComputedConstants) const { - // NLA and algebraic equations that are state/rate-based and external equations are to be computed again (in the - // computeVariables() method) unless the variables they compute are not tracked. + return (analyserEquation->type() == AnalyserEquation::Type::CONSTANT) + || (!includeComputedConstants && (analyserEquation->type() == AnalyserEquation::Type::COMPUTED_CONSTANT)); +} - switch (analyserEquation->type()) { - case AnalyserEquation::Type::NLA: - case AnalyserEquation::Type::ALGEBRAIC: - if (analyserEquation->isStateRateBased()) { - for (const auto &analyserVariable : analyserVariables(analyserEquation)) { - if (isTrackedVariable(analyserVariable, true)) { - return true; +std::vector Generator::GeneratorImpl::nlaSystemDependencies(const AnalyserEquationPtr &analyserEquation) +{ + // Return the dependencies of the NLA system of the given NLA equation, i.e. the dependencies of the given NLA + // equation and of its NLA siblings, as well as, recursively, the dependencies of the untracked computed constant + // and algebraic equations on which they depend (since those untracked equations are computed in the objective + // function of the NLA system). + // Note: an untracked equation cannot depend on the NLA system (otherwise it would be part of it), but it may + // depend on another NLA system (e.g., an untracked computed constant may depend on an NLA system that only + // depends on constants). + + std::vector res; + auto analyserEquations = analyserEquation->nlaSiblings(); + + analyserEquations.insert(analyserEquations.begin(), analyserEquation); + + for (size_t i = 0; i < analyserEquations.size(); ++i) { + for (const auto &dependency : analyserEquations[i]->dependencies()) { + if (std::find(res.begin(), res.end(), dependency) == res.end()) { + res.push_back(dependency); + + if (((dependency->type() == AnalyserEquation::Type::COMPUTED_CONSTANT) + || (dependency->type() == AnalyserEquation::Type::ALGEBRAIC)) + && isTrackedEquation(dependency, false)) { + analyserEquations.push_back(dependency); } } - - return false; } - - return false; - case AnalyserEquation::Type::EXTERNAL: - return isTrackedEquation(analyserEquation, true); - default: - return false; } -} -bool Generator::GeneratorImpl::isSomeConstant(const AnalyserEquationPtr &analyserEquation, - bool includeComputedConstants) const -{ - return (analyserEquation->type() == AnalyserEquation::Type::CONSTANT) - || (!includeComputedConstants && (analyserEquation->type() == AnalyserEquation::Type::COMPUTED_CONSTANT)); + return res; } std::string Generator::GeneratorImpl::generateZeroInitialisationCode(const AnalyserVariablePtr &analyserVariable) @@ -1828,22 +1840,39 @@ std::string Generator::GeneratorImpl::generateEquationCode(const AnalyserEquatio } } - if (!isSomeConstant(analyserEquation, includeComputedConstants)) { - for (const auto &dependency : analyserEquation->dependencies()) { + // Note: the dependencies of an NLA equation are those of its NLA system (see nlaSystemDependencies()). Also, an + // ODE dependency means that this analyser equation uses the rate computed by that ODE equation, so we + // must generate that ODE equation first, but only when computing our rates (rates are never computed + // anywhere else). Then, when computing our variables, we only generate the dependencies that are still + // remaining (i.e. that have not been generated in computeRates() or in a previous method) since + // computeRates() must have been called first, at the same point (see + // addImplementationComputeVariablesMethodCode()). Finally, an untracked dependency is a local variable, + // so it must be computed wherever it is needed (e.g., in computeVariables() even if it was already + // computed in computeRates(), or in an objective function), and so must its own untracked dependencies + // (even if it is a computed constant). + + if (!isSomeConstant(analyserEquation, includeComputedConstants) + || ((analyserEquation->type() == AnalyserEquation::Type::COMPUTED_CONSTANT) + && isTrackedEquation(analyserEquation, false))) { + auto dependencies = (analyserEquation->type() == AnalyserEquation::Type::NLA) ? + nlaSystemDependencies(analyserEquation) : + analyserEquation->dependencies(); + + for (const auto &dependency : dependencies) { if (((analyserEquation->type() != AnalyserEquation::Type::NLA) - && (dependency->type() == AnalyserEquation::Type::COMPUTED_CONSTANT) + && ((dependency->type() == AnalyserEquation::Type::COMPUTED_CONSTANT) + || ((target == GenerateEquationCodeTarget::OBJECTIVE_FUNCTION) + && (dependency->type() == AnalyserEquation::Type::ALGEBRAIC))) && isTrackedEquation(dependency, false)) - || (((target == GenerateEquationCodeTarget::NORMAL) - || ((target == GenerateEquationCodeTarget::COMPUTE_VARIABLES) - && ((dependency->type() != AnalyserEquation::Type::NLA) - || isToBeComputedAgain(dependency) - || (std::find(analyserEquationsForDependencies.begin(), analyserEquationsForDependencies.end(), dependency) != analyserEquationsForDependencies.end())))) - && (dependency->type() != AnalyserEquation::Type::ODE) + || ((target != GenerateEquationCodeTarget::OBJECTIVE_FUNCTION) + && ((dependency->type() != AnalyserEquation::Type::ODE) + || (target == GenerateEquationCodeTarget::COMPUTE_RATES)) && (isTrackedEquation(dependency, true) || (analyserEquation->type() != AnalyserEquation::Type::NLA)) && !isSomeConstant(dependency, includeComputedConstants) - && (analyserEquationsForDependencies.empty() - || isToBeComputedAgain(dependency) + && ((target != GenerateEquationCodeTarget::COMPUTE_VARIABLES) + || ((dependency->type() == AnalyserEquation::Type::ALGEBRAIC) + && isTrackedEquation(dependency, false)) || (std::find(analyserEquationsForDependencies.begin(), analyserEquationsForDependencies.end(), dependency) != analyserEquationsForDependencies.end())))) { res += generateEquationCode(dependency, remainingAnalyserEquations, analyserEquationsForDependencies, generatedConstantDependencies, includeComputedConstants, target); @@ -2148,6 +2177,7 @@ void Generator::GeneratorImpl::addImplementationComputeRatesMethodCode(std::vect if (modelHasOdes(mAnalyserModel) && !implementationComputeRatesMethodString.empty()) { std::string methodBody; + std::vector dummyAnalyserEquationsForDependencies; std::vector generatedConstantDependencies; for (const auto &analyserEquation : mAnalyserModel->analyserEquations()) { @@ -2161,7 +2191,8 @@ void Generator::GeneratorImpl::addImplementationComputeRatesMethodCode(std::vect || ((analyserEquation->type() == AnalyserEquation::Type::NLA) && (analyserVariables.size() == 1) && (analyserVariables[0]->type() == AnalyserVariable::Type::STATE))) { - methodBody += generateEquationCode(analyserEquation, remainingAnalyserEquations, generatedConstantDependencies); + methodBody += generateEquationCode(analyserEquation, remainingAnalyserEquations, dummyAnalyserEquationsForDependencies, + generatedConstantDependencies, true, GenerateEquationCodeTarget::COMPUTE_RATES); } } @@ -2182,9 +2213,12 @@ void Generator::GeneratorImpl::addImplementationComputeVariablesMethodCode(std:: auto newRemainingAnalyserEquations = analyserEquations; std::vector generatedConstantDependencies; + // Note: computeVariables() requires computeRates() to have been called first, at the same point (i.e. with the + // same variable of integration and states). So, we only generate the (tracked) equations that are still + // remaining, i.e. that have not been generated in computeRates() (or in a previous method). + for (const auto &analyserEquation : analyserEquations) { - if (((std::find(remainingAnalyserEquations.begin(), remainingAnalyserEquations.end(), analyserEquation) != remainingAnalyserEquations.end()) - || isToBeComputedAgain(analyserEquation)) + if ((std::find(remainingAnalyserEquations.begin(), remainingAnalyserEquations.end(), analyserEquation) != remainingAnalyserEquations.end()) && isTrackedEquation(analyserEquation, true)) { methodBody += generateEquationCode(analyserEquation, newRemainingAnalyserEquations, remainingAnalyserEquations, generatedConstantDependencies, false, diff --git a/src/generator_p.h b/src/generator_p.h index 5c1a3f642..e9772ecf7 100644 --- a/src/generator_p.h +++ b/src/generator_p.h @@ -124,14 +124,15 @@ struct Generator::GeneratorImpl: public Logger::LoggerImpl std::string generatePiecewiseElseCode(const std::string &value) const; std::string generateCode(const AnalyserEquationAstPtr &ast); - bool isToBeComputedAgain(const AnalyserEquationPtr &analyserEquation); bool isSomeConstant(const AnalyserEquationPtr &analyserEquation, bool includeComputedConstants) const; + std::vector nlaSystemDependencies(const AnalyserEquationPtr &analyserEquation); enum class GenerateEquationCodeTarget { NORMAL, OBJECTIVE_FUNCTION, + COMPUTE_RATES, COMPUTE_VARIABLES }; diff --git a/tests/bindings/python/test_analyser.py b/tests/bindings/python/test_analyser.py index 0f9324bf9..54f7e431e 100644 --- a/tests/bindings/python/test_analyser.py +++ b/tests/bindings/python/test_analyser.py @@ -181,7 +181,7 @@ def test_coverage(self): self.assertEqual("algebraic", AnalyserEquation.typeAsString(ae.type())) self.assertEqual("algebraic", AnalyserEquation_typeAsString(ae.type())) self.assertIsNotNone(ae.ast()) - self.assertEqual(2, ae.dependencyCount()) + self.assertEqual(1, ae.dependencyCount()) self.assertIsNotNone(ae.dependencies()) self.assertIsNotNone(ae.dependency(0)) self.assertEqual(18446744073709551615, ae.nlaSystemIndex()) diff --git a/tests/coverage/coverage.cpp b/tests/coverage/coverage.cpp index 3a8aa192e..606e116a4 100644 --- a/tests/coverage/coverage.cpp +++ b/tests/coverage/coverage.cpp @@ -674,10 +674,10 @@ TEST(Coverage, generator) EXPECT_NE(nullptr, analyserModel->analyserEquation(0)->state(0)); EXPECT_EQ(nullptr, analyserModel->analyserEquation(0)->state(analyserModel->analyserEquation(0)->stateCount())); EXPECT_NE(nullptr, analyserModel->analyserEquation(199)); - EXPECT_NE(size_t(0), analyserModel->analyserEquation(199)->dependencyCount()); - EXPECT_NE(size_t(0), analyserModel->analyserEquation(199)->dependencies().size()); - EXPECT_NE(nullptr, analyserModel->analyserEquation(199)->dependency(0)); - EXPECT_EQ(nullptr, analyserModel->analyserEquation(199)->dependency(analyserModel->analyserEquation(199)->dependencyCount())); + EXPECT_NE(size_t(0), analyserModel->analyserEquation(200)->dependencyCount()); + EXPECT_NE(size_t(0), analyserModel->analyserEquation(200)->dependencies().size()); + EXPECT_NE(nullptr, analyserModel->analyserEquation(200)->dependency(0)); + EXPECT_EQ(nullptr, analyserModel->analyserEquation(200)->dependency(analyserModel->analyserEquation(200)->dependencyCount())); EXPECT_EQ(size_t(1), analyserModel->analyserEquation(199)->nlaSiblingCount()); EXPECT_EQ(size_t(1), analyserModel->analyserEquation(199)->nlaSiblings().size()); EXPECT_NE(nullptr, analyserModel->analyserEquation(199)->nlaSibling(0)); diff --git a/tests/generator/generator.cpp b/tests/generator/generator.cpp index 13af89e31..8ff6511be 100644 --- a/tests/generator/generator.cpp +++ b/tests/generator/generator.cpp @@ -188,6 +188,54 @@ TEST(Generator, algebraicEqnDerivativeOnRhsOneComponent) EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_derivative_on_rhs_one_component/model.py", generator->implementationCode(analyserModel, profile)); } +TEST(Generator, algebraicEqnDerivativeOnRhsUsedByOde) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.h", generator->interfaceCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.c", generator->implementationCode(analyserModel)); + + auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.py", generator->implementationCode(analyserModel, profile)); +} + +TEST(Generator, algebraicEqnDerivativeOnlyOnRhsUsedByOde) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.h", generator->interfaceCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.c", generator->implementationCode(analyserModel)); + + auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.py", generator->implementationCode(analyserModel, profile)); +} + TEST(Generator, algebraicEqnStateVarOnRhs) { auto parser = libcellml::Parser::create(); @@ -236,6 +284,60 @@ TEST(Generator, algebraicEqnStateVarOnRhsOneComponent) EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_state_var_on_rhs_one_component/model.py", generator->implementationCode(analyserModel, profile)); } +TEST(Generator, algebraicEqnStateVarOnRhsInitialisedInAnotherComponent) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_TRUE(analyserModel->analyserVariable(model->component("my_algebraic_eqn")->variable("xx"))->analyserEquation(0)->isStateRateBased()); + + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.h", generator->interfaceCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.c", generator->implementationCode(analyserModel)); + + auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.py", generator->implementationCode(analyserModel, profile)); + + // Make the algebraic variable an external variable that depends on the state variable. + + auto externalVariable = libcellml::AnalyserExternalVariable::create(model->component("my_algebraic_eqn")->variable("xx")); + + externalVariable->addDependency(model->component("my_algebraic_eqn")->variable("x")); + + analyser->addExternalVariable(externalVariable); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + analyserModel = analyser->analyserModel(); + + EXPECT_TRUE(analyserModel->analyserVariable(model->component("my_ode")->variable("y"))->analyserEquation(0)->isStateRateBased()); + + profile = libcellml::GeneratorProfile::create(); + + profile->setInterfaceFileNameString("model.external.h"); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.external.h", generator->interfaceCode(analyserModel, profile)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.external.c", generator->implementationCode(analyserModel, profile)); + + profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.external.py", generator->implementationCode(analyserModel, profile)); +} + TEST(Generator, algebraicUnknownVarOnRhs) { auto parser = libcellml::Parser::create(); @@ -314,6 +416,118 @@ TEST(Generator, algebraicEqnWithOneNonIsolatedUnknownWithExternalVariable) EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown/model.external.py", generator->implementationCode(analyserModel, profile)); } +TEST(Generator, algebraicEqnWithOneNonIsolatedUnknownAndDerivativeDependency) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.h", generator->interfaceCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.c", generator->implementationCode(analyserModel)); + + auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.py", generator->implementationCode(analyserModel, profile)); +} + +TEST(Generator, algebraicEqnWithOneNonIsolatedUnknownAndUntrackedDerivativeDependency) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + auto generatorVariableTracker = libcellml::GeneratorVariableTracker::create(); + + generatorVariableTracker->untrackVariable(analyserModel->analyserVariable(model->component("my_component")->variable("q"))); + + EXPECT_EQ(size_t(0), generatorVariableTracker->issueCount()); + + auto profile = libcellml::GeneratorProfile::create(); + + profile->setInterfaceFileNameString("model.untracked.h"); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.untracked.h", generator->interfaceCode(analyserModel, profile, generatorVariableTracker)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.untracked.c", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); + + profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.untracked.py", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); +} + +TEST(Generator, algebraicEqnWithOneNonIsolatedUnknownAndUntrackedDependencies) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + auto generatorVariableTracker = libcellml::GeneratorVariableTracker::create(); + auto component = model->component("my_component"); + + // Untrack the constant, which is used by both the NLA equation and its untracked dependency, as well as that + // untracked dependency, which depends on a tracked algebraic variable that has a derivative on its RHS. + + generatorVariableTracker->untrackVariable(analyserModel->analyserVariable(component->variable("k"))); + generatorVariableTracker->untrackVariable(analyserModel->analyserVariable(component->variable("p"))); + + EXPECT_EQ(size_t(0), generatorVariableTracker->issueCount()); + + auto profile = libcellml::GeneratorProfile::create(); + + profile->setInterfaceFileNameString("model.untracked.k.p.h"); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.h", generator->interfaceCode(analyserModel, profile, generatorVariableTracker)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.c", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); + + profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.py", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); + + // Also untrack the algebraic variable that has a derivative on its RHS. + + generatorVariableTracker->untrackVariable(analyserModel->analyserVariable(component->variable("u"))); + + EXPECT_EQ(size_t(0), generatorVariableTracker->issueCount()); + + profile = libcellml::GeneratorProfile::create(); + + profile->setInterfaceFileNameString("model.untracked.k.p.u.h"); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.u.h", generator->interfaceCode(analyserModel, profile, generatorVariableTracker)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.u.c", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); + + profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.u.py", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); +} + TEST(Generator, algebraicSystemWithThreeLinkedUnknowns) { auto parser = libcellml::Parser::create(); @@ -370,6 +584,77 @@ TEST(Generator, algebraicSystemWithThreeLinkedUnknownsWithThreeExternalVariables EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_three_linked_unknowns/model.external.py", generator->implementationCode(analyserModel, profile)); } +TEST(Generator, algebraicSystemWithDerivativeOnRhs) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/algebraic_system_with_derivative_on_rhs/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_derivative_on_rhs/model.h", generator->interfaceCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_derivative_on_rhs/model.c", generator->implementationCode(analyserModel)); + + auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_derivative_on_rhs/model.py", generator->implementationCode(analyserModel, profile)); +} + +TEST(Generator, algebraicSystemWithUntrackedDependencies) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/algebraic_system_with_untracked_dependencies/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_untracked_dependencies/model.h", generator->interfaceCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_untracked_dependencies/model.c", generator->implementationCode(analyserModel)); + + auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_untracked_dependencies/model.py", generator->implementationCode(analyserModel, profile)); + + // Untrack all the constants, computed constants, and algebraic variables, except the algebraic variable that is + // needed to compute the rate of a state variable. + + auto generatorVariableTracker = libcellml::GeneratorVariableTracker::create(); + auto component = model->component("my_component"); + + for (const auto &name : {"k", "kc", "kc2", "q", "r", "l"}) { + generatorVariableTracker->untrackVariable(analyserModel->analyserVariable(component->variable(name))); + } + + EXPECT_EQ(size_t(0), generatorVariableTracker->issueCount()); + + profile = libcellml::GeneratorProfile::create(); + + profile->setInterfaceFileNameString("model.untracked.h"); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_untracked_dependencies/model.untracked.h", generator->interfaceCode(analyserModel, profile, generatorVariableTracker)); + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_untracked_dependencies/model.untracked.c", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); + + profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/algebraic_system_with_untracked_dependencies/model.untracked.py", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); +} + TEST(Generator, algebraicSystemWithVariousDependenciesOrdered) { auto parser = libcellml::Parser::create(); @@ -570,6 +855,30 @@ TEST(Generator, odeConstantOnRhsOneComponent) EXPECT_EQ_FILE_CONTENTS("generator/ode_constant_on_rhs_one_component/model.py", generator->implementationCode(analyserModel, profile)); } +TEST(Generator, odeDerivativeOnRhs) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/ode_derivative_on_rhs/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("generator/ode_derivative_on_rhs/model.h", generator->interfaceCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/ode_derivative_on_rhs/model.c", generator->implementationCode(analyserModel)); + + auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/ode_derivative_on_rhs/model.py", generator->implementationCode(analyserModel, profile)); +} + TEST(Generator, odeMultipleDependentOdes) { auto parser = libcellml::Parser::create(); @@ -642,6 +951,60 @@ TEST(Generator, odeMultipleOdesWithSameName) EXPECT_EQ_FILE_CONTENTS("generator/ode_multiple_odes_with_same_name/model.py", generator->implementationCode(analyserModel, profile)); } +TEST(Generator, odeStateVarOnLhs) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/ode_state_var_on_lhs/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserEquation::Type::NLA, analyserModel->analyserEquation(0)->type()); + + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("generator/ode_state_var_on_lhs/model.h", generator->interfaceCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/ode_state_var_on_lhs/model.c", generator->implementationCode(analyserModel)); + + auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/ode_state_var_on_lhs/model.py", generator->implementationCode(analyserModel, profile)); +} + +TEST(Generator, odeStateVarOnRhs) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/ode_state_var_on_rhs/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserEquation::Type::ODE, analyserModel->analyserEquation(0)->type()); + + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("generator/ode_state_var_on_rhs/model.h", generator->interfaceCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/ode_state_var_on_rhs/model.c", generator->implementationCode(analyserModel)); + + auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/ode_state_var_on_rhs/model.py", generator->implementationCode(analyserModel, profile)); +} + TEST(Generator, odeUnknownVarOnRhs) { auto parser = libcellml::Parser::create(); @@ -666,6 +1029,92 @@ TEST(Generator, odeUnknownVarOnRhs) EXPECT_EQ_FILE_CONTENTS("generator/ode_unknown_var_on_rhs/model.py", generator->implementationCode(analyserModel, profile)); } +TEST(Generator, odeUntrackedDependencyUsedByAlgebraicEqn) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/ode_untracked_dependency_used_by_algebraic_eqn/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + auto generatorVariableTracker = libcellml::GeneratorVariableTracker::create(); + + // Untrack an algebraic variable that is needed to compute a rate, and which is therefore computed (as a local + // variable) in computeRates(), but which is also needed by an algebraic variable that is only computed in + // computeVariables(), which must therefore compute it again. + + generatorVariableTracker->untrackVariable(analyserModel->analyserVariable(model->component("my_component")->variable("u"))); + + EXPECT_EQ(size_t(0), generatorVariableTracker->issueCount()); + + auto profile = libcellml::GeneratorProfile::create(); + + EXPECT_EQ_FILE_CONTENTS("generator/ode_untracked_dependency_used_by_algebraic_eqn/model.h", generator->interfaceCode(analyserModel, profile, generatorVariableTracker)); + EXPECT_EQ_FILE_CONTENTS("generator/ode_untracked_dependency_used_by_algebraic_eqn/model.c", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); + + profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/ode_untracked_dependency_used_by_algebraic_eqn/model.py", generator->implementationCode(analyserModel, profile, generatorVariableTracker)); +} + +TEST(Generator, cellmlEquivalentVariablesInTheSameComponent) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/cellml_equivalent_variables_in_the_same_component/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->analyserModel(); + + EXPECT_EQ(libcellml::AnalyserEquation::Type::ODE, analyserModel->analyserVariable(model->component("my_component")->variable("xo"))->analyserEquation(0)->type()); + + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("generator/cellml_equivalent_variables_in_the_same_component/model.h", generator->interfaceCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_equivalent_variables_in_the_same_component/model.c", generator->implementationCode(analyserModel)); + + auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/cellml_equivalent_variables_in_the_same_component/model.py", generator->implementationCode(analyserModel, profile)); +} + +TEST(Generator, cellmlEquivalentVariablesWithDifferentNames) +{ + auto parser = libcellml::Parser::create(); + auto model = parser->parseModel(fileContents("generator/cellml_equivalent_variables_with_different_names/model.cellml")); + + EXPECT_EQ(size_t(0), parser->issueCount()); + + auto analyser = libcellml::Analyser::create(); + + analyser->analyseModel(model); + + EXPECT_EQ(size_t(0), analyser->errorCount()); + + auto analyserModel = analyser->analyserModel(); + auto generator = libcellml::Generator::create(); + + EXPECT_EQ_FILE_CONTENTS("generator/cellml_equivalent_variables_with_different_names/model.h", generator->interfaceCode(analyserModel)); + EXPECT_EQ_FILE_CONTENTS("generator/cellml_equivalent_variables_with_different_names/model.c", generator->implementationCode(analyserModel)); + + auto profile = libcellml::GeneratorProfile::create(libcellml::GeneratorProfile::Profile::PYTHON); + + EXPECT_EQ_FILE_CONTENTS("generator/cellml_equivalent_variables_with_different_names/model.py", generator->implementationCode(analyserModel, profile)); +} + TEST(Generator, cellmlMappingsAndEncapsulations) { auto parser = libcellml::Parser::create(); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.c b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.c new file mode 100644 index 000000000..e8b890422 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.c @@ -0,0 +1,106 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 3; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"z", "dimensionless", "my_component"}, + {"v", "dimensionless", "my_component"}, + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y", "dimensionless", "my_component"}, + {"w", "dimensionless", "my_component"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + states[1] = 0.0; + states[2] = 1.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[2] = -states[2]; + algebraicVariables[0] = 2.0*rates[2]+states[2]; + rates[0] = algebraicVariables[0]; + algebraicVariables[1] = algebraicVariables[0]+1.0; + rates[1] = algebraicVariables[1]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.cellml b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.cellml new file mode 100644 index 000000000..5070901db --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.cellml @@ -0,0 +1,84 @@ + + + + + + + + + + + + + + + + + t + + z + + y + + + + + + + t + + v + + w + + + + y + + + + + 2 + + + + t + + x + + + x + + + + + w + + + y + 1 + + + + + + + + t + + x + + + + x + + + + + diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.h b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.h new file mode 100644 index 000000000..135be52fa --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[2]; + char units[14]; + char component[13]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.py b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.py new file mode 100644 index 000000000..cacbcf2ae --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_derivative_on_rhs_used_by_ode/model.py @@ -0,0 +1,70 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 3 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 2 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_component"} + +STATE_INFO = [ + {"name": "z", "units": "dimensionless", "component": "my_component"}, + {"name": "v", "units": "dimensionless", "component": "my_component"}, + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "y", "units": "dimensionless", "component": "my_component"}, + {"name": "w", "units": "dimensionless", "component": "my_component"} +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.0 + states[2] = 1.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[2] = -states[2] + algebraic_variables[0] = 2.0*rates[2]+states[2] + rates[0] = algebraic_variables[0] + algebraic_variables[1] = algebraic_variables[0]+1.0 + rates[1] = algebraic_variables[1] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.c b/tests/resources/generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.c new file mode 100644 index 000000000..0281bb1c2 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.c @@ -0,0 +1,101 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"z", "dimensionless", "my_component"}, + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y", "dimensionless", "my_component"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + states[1] = 1.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[1] = -states[1]; + algebraicVariables[0] = rates[1]; + rates[0] = algebraicVariables[0]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.cellml b/tests/resources/generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.cellml new file mode 100644 index 000000000..07cbf3608 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.cellml @@ -0,0 +1,52 @@ + + + + + + + + + + + + + + + t + + z + + y + + + + y + + + + t + + x + + + + + + + + t + + x + + + + x + + + + + diff --git a/tests/resources/generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.h b/tests/resources/generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.h new file mode 100644 index 000000000..135be52fa --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[2]; + char units[14]; + char component[13]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.py b/tests/resources/generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.py new file mode 100644 index 000000000..2cae91922 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_derivative_only_on_rhs_used_by_ode/model.py @@ -0,0 +1,65 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_component"} + +STATE_INFO = [ + {"name": "z", "units": "dimensionless", "component": "my_component"}, + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "y", "units": "dimensionless", "component": "my_component"} +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 1.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[1] = -states[1] + algebraic_variables[0] = rates[1] + rates[0] = algebraic_variables[0] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.c new file mode 100644 index 000000000..1c884cf46 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.c @@ -0,0 +1,103 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "my_ode"}, + {"z", "dimensionless", "my_ode"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"xx", "dimensionless", "my_algebraic_eqn"}, + {"y", "dimensionless", "my_ode"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 1.0; + states[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[0] = 1.0; + algebraicVariables[0] = 2.0*states[0]; + algebraicVariables[1] = algebraicVariables[0]+1.0; + rates[1] = algebraicVariables[1]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.cellml b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.cellml new file mode 100644 index 000000000..b395a1313 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.cellml @@ -0,0 +1,80 @@ + + + + + + + + + + + + + xx + + + 2 + x + + + + + + + + + + + + + + + + + t + + x + + 1 + + + + y + + + xx + 1 + + + + + + + + t + + z + + y + + + + + + + + + + + + + + + + + diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.external.c b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.external.c new file mode 100644 index 000000000..5894ca056 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.external.c @@ -0,0 +1,118 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.external.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; +const size_t EXTERNAL_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "environment"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "my_ode"}, + {"z", "dimensionless", "my_ode"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y", "dimensionless", "my_ode"} +}; + +const VariableInfo EXTERNAL_VARIABLE_INFO[] = { + {"xx", "dimensionless", "my_algebraic_eqn"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createExternalVariablesArray() +{ + double *res = (double *) malloc(EXTERNAL_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < EXTERNAL_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 1.0; + states[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ + rates[0] = 1.0; + externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); + algebraicVariables[0] = externalVariables[0]+1.0; + rates[1] = algebraicVariables[0]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) +{ +} diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.external.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.external.h new file mode 100644 index 000000000..ecf7e99d7 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.external.h @@ -0,0 +1,42 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; +extern const size_t EXTERNAL_VARIABLE_COUNT; + +typedef struct { + char name[3]; + char units[14]; + char component[17]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; +extern const VariableInfo EXTERNAL_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); +double * createExternalVariablesArray(); + +void deleteArray(double *array); + +typedef double (* ExternalVariable)(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, size_t index); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.external.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.external.py new file mode 100644 index 000000000..50770c63e --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.external.py @@ -0,0 +1,75 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 1 +EXTERNAL_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "environment"} + +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_ode"}, + {"name": "z", "units": "dimensionless", "component": "my_ode"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "y", "units": "dimensionless", "component": "my_ode"} +] + +EXTERNAL_VARIABLE_INFO = [ + {"name": "xx", "units": "dimensionless", "component": "my_algebraic_eqn"} +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def create_external_variables_array(): + return [nan]*EXTERNAL_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 1.0 + states[1] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + rates[0] = 1.0 + external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + algebraic_variables[0] = external_variables[0]+1.0 + rates[1] = algebraic_variables[0] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): + pass diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.h b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.h new file mode 100644 index 000000000..818bdf541 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[3]; + char units[14]; + char component[17]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.py b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.py new file mode 100644 index 000000000..80fa0e785 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_state_var_on_rhs_initialised_in_another_component/model.py @@ -0,0 +1,67 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 2 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "environment"} + +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_ode"}, + {"name": "z", "units": "dimensionless", "component": "my_ode"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "xx", "units": "dimensionless", "component": "my_algebraic_eqn"}, + {"name": "y", "units": "dimensionless", "component": "my_ode"} +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 1.0 + states[1] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[0] = 1.0 + algebraic_variables[0] = 2.0*states[0] + algebraic_variables[1] = algebraic_variables[0]+1.0 + rates[1] = algebraic_variables[1] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.c new file mode 100644 index 000000000..44b77cfcf --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.c @@ -0,0 +1,144 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"z", "dimensionless", "my_component"}, + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"a", "dimensionless", "my_component"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y", "dimensionless", "my_component"}, + {"q", "dimensionless", "my_component"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +typedef struct { + double voi; + double *states; + double *rates; + double *constants; + double *computedConstants; + double *algebraicVariables; +} RootFindingInfo; + +extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), + double *u, size_t n, void *data); + +void objectiveFunction0(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[0] = u[0]; + + f[0] = algebraicVariables[0]+exp(algebraicVariables[0])-algebraicVariables[1]; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[0]; + + nlaSolve(objectiveFunction0, u, 1, &rfi); + + algebraicVariables[0] = u[0]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + states[1] = 1.0; + computedConstants[0] = 2.0; + algebraicVariables[0] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[1] = -states[1]; + algebraicVariables[1] = computedConstants[0]*rates[1]+states[1]; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + rates[0] = algebraicVariables[0]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.cellml b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.cellml new file mode 100644 index 000000000..f62f3cca5 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.cellml @@ -0,0 +1,82 @@ + + + + + + + + + + + + + + + + + t + + z + + y + + + + + + y + + + y + + + q + + + + q + + + + + a + + + + t + + x + + + x + + + + + a + 2 + + + + + + + t + + x + + + + x + + + + + diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.h new file mode 100644 index 000000000..135be52fa --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[2]; + char units[14]; + char component[13]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.py new file mode 100644 index 000000000..89e94ab97 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.py @@ -0,0 +1,96 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 2 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_component"} + +STATE_INFO = [ + {"name": "z", "units": "dimensionless", "component": "my_component"}, + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "a", "units": "dimensionless", "component": "my_component"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "y", "units": "dimensionless", "component": "my_component"}, + {"name": "q", "units": "dimensionless", "component": "my_component"} +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +from nlasolver import nla_solve + + +def objective_function_0(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraic_variables[0] = u[0] + + f[0] = algebraic_variables[0]+exp(algebraic_variables[0])-algebraic_variables[1] + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraic_variables[0] + + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraic_variables[0] = u[0] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 1.0 + computed_constants[0] = 2.0 + algebraic_variables[0] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[1] = -states[1] + algebraic_variables[1] = computed_constants[0]*rates[1]+states[1] + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + rates[0] = algebraic_variables[0] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.untracked.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.untracked.c new file mode 100644 index 000000000..f95ac37ec --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.untracked.c @@ -0,0 +1,144 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.untracked.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 1; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"z", "dimensionless", "my_component"}, + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"a", "dimensionless", "my_component"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y", "dimensionless", "my_component"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +typedef struct { + double voi; + double *states; + double *rates; + double *constants; + double *computedConstants; + double *algebraicVariables; +} RootFindingInfo; + +extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), + double *u, size_t n, void *data); + +void objectiveFunction0(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[0] = u[0]; + + double my_component_q = computedConstants[0]*rates[1]+states[1]; + + f[0] = algebraicVariables[0]+exp(algebraicVariables[0])-my_component_q; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[0]; + + nlaSolve(objectiveFunction0, u, 1, &rfi); + + algebraicVariables[0] = u[0]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + states[1] = 1.0; + computedConstants[0] = 2.0; + algebraicVariables[0] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[1] = -states[1]; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + rates[0] = algebraicVariables[0]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.untracked.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.untracked.h new file mode 100644 index 000000000..135be52fa --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.untracked.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[2]; + char units[14]; + char component[13]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.untracked.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.untracked.py new file mode 100644 index 000000000..378184775 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_derivative_dependency/model.untracked.py @@ -0,0 +1,96 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 1 +ALGEBRAIC_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_component"} + +STATE_INFO = [ + {"name": "z", "units": "dimensionless", "component": "my_component"}, + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "a", "units": "dimensionless", "component": "my_component"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "y", "units": "dimensionless", "component": "my_component"} +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +from nlasolver import nla_solve + + +def objective_function_0(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraic_variables[0] = u[0] + + my_component_q = computed_constants[0]*rates[1]+states[1] + + f[0] = algebraic_variables[0]+exp(algebraic_variables[0])-my_component_q + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraic_variables[0] + + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraic_variables[0] = u[0] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 1.0 + computed_constants[0] = 2.0 + algebraic_variables[0] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[1] = -states[1] + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + rates[0] = algebraic_variables[0] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.cellml b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.cellml new file mode 100644 index 000000000..97242894c --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.cellml @@ -0,0 +1,92 @@ + + + + + + + + + + + + + + + + + + t + + z + + y + + + + + + y + + + y + + + + + p + k + + + + + p + + + + + 2 + u + + k + + + + + u + + + + + + t + + x + + x + + + + + + + + t + + x + + + + x + + + + + diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.c new file mode 100644 index 000000000..d1eadab43 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.c @@ -0,0 +1,145 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.untracked.k.p.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"z", "dimensionless", "my_component"}, + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y", "dimensionless", "my_component"}, + {"u", "dimensionless", "my_component"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +typedef struct { + double voi; + double *states; + double *rates; + double *constants; + double *computedConstants; + double *algebraicVariables; +} RootFindingInfo; + +extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), + double *u, size_t n, void *data); + +void objectiveFunction0(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[0] = u[0]; + + double my_component_k = 2.0; + double my_component_p = 2.0*algebraicVariables[1]+my_component_k; + + f[0] = algebraicVariables[0]+exp(algebraicVariables[0])-(my_component_p+my_component_k); +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[0]; + + nlaSolve(objectiveFunction0, u, 1, &rfi); + + algebraicVariables[0] = u[0]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + states[1] = 1.0; + algebraicVariables[0] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[1] = -states[1]; + algebraicVariables[1] = rates[1]+states[1]; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + rates[0] = algebraicVariables[0]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.h new file mode 100644 index 000000000..135be52fa --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[2]; + char units[14]; + char component[13]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.py new file mode 100644 index 000000000..d934d598a --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.py @@ -0,0 +1,97 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 2 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_component"} + +STATE_INFO = [ + {"name": "z", "units": "dimensionless", "component": "my_component"}, + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "y", "units": "dimensionless", "component": "my_component"}, + {"name": "u", "units": "dimensionless", "component": "my_component"} +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +from nlasolver import nla_solve + + +def objective_function_0(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraic_variables[0] = u[0] + + my_component_k = 2.0 + my_component_p = 2.0*algebraic_variables[1]+my_component_k + + f[0] = algebraic_variables[0]+exp(algebraic_variables[0])-(my_component_p+my_component_k) + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraic_variables[0] + + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraic_variables[0] = u[0] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 1.0 + algebraic_variables[0] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[1] = -states[1] + algebraic_variables[1] = rates[1]+states[1] + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + rates[0] = algebraic_variables[0] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.u.c b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.u.c new file mode 100644 index 000000000..696b005d5 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.u.c @@ -0,0 +1,144 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.untracked.k.p.u.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"z", "dimensionless", "my_component"}, + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y", "dimensionless", "my_component"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +typedef struct { + double voi; + double *states; + double *rates; + double *constants; + double *computedConstants; + double *algebraicVariables; +} RootFindingInfo; + +extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), + double *u, size_t n, void *data); + +void objectiveFunction0(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[0] = u[0]; + + double my_component_k = 2.0; + double my_component_u = rates[1]+states[1]; + double my_component_p = 2.0*my_component_u+my_component_k; + + f[0] = algebraicVariables[0]+exp(algebraicVariables[0])-(my_component_p+my_component_k); +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[0]; + + nlaSolve(objectiveFunction0, u, 1, &rfi); + + algebraicVariables[0] = u[0]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + states[1] = 1.0; + algebraicVariables[0] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[1] = -states[1]; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + rates[0] = algebraicVariables[0]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.u.h b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.u.h new file mode 100644 index 000000000..135be52fa --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.u.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[2]; + char units[14]; + char component[13]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.u.py b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.u.py new file mode 100644 index 000000000..b94a90556 --- /dev/null +++ b/tests/resources/generator/algebraic_eqn_with_one_non_isolated_unknown_and_untracked_dependencies/model.untracked.k.p.u.py @@ -0,0 +1,96 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_component"} + +STATE_INFO = [ + {"name": "z", "units": "dimensionless", "component": "my_component"}, + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "y", "units": "dimensionless", "component": "my_component"} +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +from nlasolver import nla_solve + + +def objective_function_0(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraic_variables[0] = u[0] + + my_component_k = 2.0 + my_component_u = rates[1]+states[1] + my_component_p = 2.0*my_component_u+my_component_k + + f[0] = algebraic_variables[0]+exp(algebraic_variables[0])-(my_component_p+my_component_k) + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraic_variables[0] + + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraic_variables[0] = u[0] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 1.0 + algebraic_variables[0] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[1] = -states[1] + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + rates[0] = algebraic_variables[0] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/algebraic_system_with_derivative_on_rhs/model.c b/tests/resources/generator/algebraic_system_with_derivative_on_rhs/model.c new file mode 100644 index 000000000..a8eb78f10 --- /dev/null +++ b/tests/resources/generator/algebraic_system_with_derivative_on_rhs/model.c @@ -0,0 +1,146 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"z", "dimensionless", "my_component"}, + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y", "dimensionless", "my_component"}, + {"w", "dimensionless", "my_component"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +typedef struct { + double voi; + double *states; + double *rates; + double *constants; + double *computedConstants; + double *algebraicVariables; +} RootFindingInfo; + +extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), + double *u, size_t n, void *data); + +void objectiveFunction0(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[1] = u[0]; + algebraicVariables[0] = u[1]; + + f[0] = algebraicVariables[0]+algebraicVariables[1]-3.0*states[1]; + f[1] = algebraicVariables[0]-algebraicVariables[1]*exp(algebraicVariables[1])-(rates[1]+states[1]); +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[2]; + + u[0] = algebraicVariables[1]; + u[1] = algebraicVariables[0]; + + nlaSolve(objectiveFunction0, u, 2, &rfi); + + algebraicVariables[1] = u[0]; + algebraicVariables[0] = u[1]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + states[1] = 1.0; + algebraicVariables[0] = 0.0; + algebraicVariables[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[1] = -states[1]; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + rates[0] = algebraicVariables[0]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/algebraic_system_with_derivative_on_rhs/model.cellml b/tests/resources/generator/algebraic_system_with_derivative_on_rhs/model.cellml new file mode 100644 index 000000000..982d04e6f --- /dev/null +++ b/tests/resources/generator/algebraic_system_with_derivative_on_rhs/model.cellml @@ -0,0 +1,82 @@ + + + + + + + + + + + + + + + + t + + z + + y + + + + + + y + w + + + + 3 + x + + + + + + + y + + + w + + + w + + + + + + + + + t + + x + + x + + + + + + + + t + + x + + + + x + + + + + diff --git a/tests/resources/generator/algebraic_system_with_derivative_on_rhs/model.h b/tests/resources/generator/algebraic_system_with_derivative_on_rhs/model.h new file mode 100644 index 000000000..135be52fa --- /dev/null +++ b/tests/resources/generator/algebraic_system_with_derivative_on_rhs/model.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[2]; + char units[14]; + char component[13]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_system_with_derivative_on_rhs/model.py b/tests/resources/generator/algebraic_system_with_derivative_on_rhs/model.py new file mode 100644 index 000000000..c26c60b21 --- /dev/null +++ b/tests/resources/generator/algebraic_system_with_derivative_on_rhs/model.py @@ -0,0 +1,98 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 2 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_component"} + +STATE_INFO = [ + {"name": "z", "units": "dimensionless", "component": "my_component"}, + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "y", "units": "dimensionless", "component": "my_component"}, + {"name": "w", "units": "dimensionless", "component": "my_component"} +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +from nlasolver import nla_solve + + +def objective_function_0(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraic_variables[1] = u[0] + algebraic_variables[0] = u[1] + + f[0] = algebraic_variables[0]+algebraic_variables[1]-3.0*states[1] + f[1] = algebraic_variables[0]-algebraic_variables[1]*exp(algebraic_variables[1])-(rates[1]+states[1]) + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*2 + + u[0] = algebraic_variables[1] + u[1] = algebraic_variables[0] + + u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraic_variables[1] = u[0] + algebraic_variables[0] = u[1] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 1.0 + algebraic_variables[0] = 0.0 + algebraic_variables[1] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[1] = -states[1] + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + rates[0] = algebraic_variables[0] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.c b/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.c new file mode 100644 index 000000000..078a1178b --- /dev/null +++ b/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.c @@ -0,0 +1,163 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 3; +const size_t CONSTANT_COUNT = 1; +const size_t COMPUTED_CONSTANT_COUNT = 2; +const size_t ALGEBRAIC_VARIABLE_COUNT = 6; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"z", "dimensionless", "my_component"}, + {"v", "dimensionless", "my_component"}, + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { + {"k", "dimensionless", "my_component"} +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { + {"kc2", "dimensionless", "my_component"}, + {"kc", "dimensionless", "my_component"} +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y", "dimensionless", "my_component"}, + {"a", "dimensionless", "my_component"}, + {"l", "dimensionless", "my_component"}, + {"w", "dimensionless", "my_component"}, + {"q", "dimensionless", "my_component"}, + {"r", "dimensionless", "my_component"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +typedef struct { + double voi; + double *states; + double *rates; + double *constants; + double *computedConstants; + double *algebraicVariables; +} RootFindingInfo; + +extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), + double *u, size_t n, void *data); + +void objectiveFunction0(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[3] = u[0]; + algebraicVariables[0] = u[1]; + + f[0] = algebraicVariables[0]+algebraicVariables[3]-(3.0*states[2]+computedConstants[0]); + f[1] = algebraicVariables[0]-algebraicVariables[3]*exp(algebraicVariables[3])-(algebraicVariables[4]+states[2]); +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[2]; + + u[0] = algebraicVariables[3]; + u[1] = algebraicVariables[0]; + + nlaSolve(objectiveFunction0, u, 2, &rfi); + + algebraicVariables[3] = u[0]; + algebraicVariables[0] = u[1]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + states[1] = 0.0; + states[2] = 1.0; + constants[0] = 2.0; + algebraicVariables[0] = 0.0; + algebraicVariables[3] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + computedConstants[1] = 2.0*constants[0]; + computedConstants[0] = 3.0*computedConstants[1]; +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[2] = -states[2]; + algebraicVariables[5] = 3.0*rates[2]+states[2]; + algebraicVariables[4] = algebraicVariables[5]+1.0; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + rates[0] = algebraicVariables[0]; + algebraicVariables[2] = states[2]+1.0; + algebraicVariables[1] = 2.0*algebraicVariables[2]+algebraicVariables[0]; + rates[1] = algebraicVariables[1]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.cellml b/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.cellml new file mode 100644 index 000000000..2db085024 --- /dev/null +++ b/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.cellml @@ -0,0 +1,177 @@ + + + + + + + + + + + + + + + + + + + + + + + + t + + z + + y + + + + + + + t + + v + + a + + + + a + + + + + 2 + l + + y + + + + + l + + + x + 1 + + + + + + + y + w + + + + + + 3 + x + + kc2 + + + + + + + y + + + w + + + w + + + + + + q + x + + + + + q + + + r + 1 + + + + + r + + + + + 3 + + + + t + + x + + + x + + + + + kc + + + 2 + k + + + + + kc2 + + + 3 + kc + + + + + + + + t + + x + + + + x + + + + + diff --git a/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.h b/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.h new file mode 100644 index 000000000..6642dc9ba --- /dev/null +++ b/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[4]; + char units[14]; + char component[13]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.py b/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.py new file mode 100644 index 000000000..46a625f86 --- /dev/null +++ b/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.py @@ -0,0 +1,114 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 3 +CONSTANT_COUNT = 1 +COMPUTED_CONSTANT_COUNT = 2 +ALGEBRAIC_VARIABLE_COUNT = 6 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_component"} + +STATE_INFO = [ + {"name": "z", "units": "dimensionless", "component": "my_component"}, + {"name": "v", "units": "dimensionless", "component": "my_component"}, + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ + {"name": "k", "units": "dimensionless", "component": "my_component"} +] + +COMPUTED_CONSTANT_INFO = [ + {"name": "kc2", "units": "dimensionless", "component": "my_component"}, + {"name": "kc", "units": "dimensionless", "component": "my_component"} +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "y", "units": "dimensionless", "component": "my_component"}, + {"name": "a", "units": "dimensionless", "component": "my_component"}, + {"name": "l", "units": "dimensionless", "component": "my_component"}, + {"name": "w", "units": "dimensionless", "component": "my_component"}, + {"name": "q", "units": "dimensionless", "component": "my_component"}, + {"name": "r", "units": "dimensionless", "component": "my_component"} +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +from nlasolver import nla_solve + + +def objective_function_0(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraic_variables[3] = u[0] + algebraic_variables[0] = u[1] + + f[0] = algebraic_variables[0]+algebraic_variables[3]-(3.0*states[2]+computed_constants[0]) + f[1] = algebraic_variables[0]-algebraic_variables[3]*exp(algebraic_variables[3])-(algebraic_variables[4]+states[2]) + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*2 + + u[0] = algebraic_variables[3] + u[1] = algebraic_variables[0] + + u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraic_variables[3] = u[0] + algebraic_variables[0] = u[1] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.0 + states[2] = 1.0 + constants[0] = 2.0 + algebraic_variables[0] = 0.0 + algebraic_variables[3] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + computed_constants[1] = 2.0*constants[0] + computed_constants[0] = 3.0*computed_constants[1] + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[2] = -states[2] + algebraic_variables[5] = 3.0*rates[2]+states[2] + algebraic_variables[4] = algebraic_variables[5]+1.0 + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + rates[0] = algebraic_variables[0] + algebraic_variables[2] = states[2]+1.0 + algebraic_variables[1] = 2.0*algebraic_variables[2]+algebraic_variables[0] + rates[1] = algebraic_variables[1] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.untracked.c b/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.untracked.c new file mode 100644 index 000000000..556a25b73 --- /dev/null +++ b/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.untracked.c @@ -0,0 +1,158 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.untracked.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 3; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 3; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"z", "dimensionless", "my_component"}, + {"v", "dimensionless", "my_component"}, + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y", "dimensionless", "my_component"}, + {"a", "dimensionless", "my_component"}, + {"w", "dimensionless", "my_component"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +typedef struct { + double voi; + double *states; + double *rates; + double *constants; + double *computedConstants; + double *algebraicVariables; +} RootFindingInfo; + +extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), + double *u, size_t n, void *data); + +void objectiveFunction0(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[2] = u[0]; + algebraicVariables[0] = u[1]; + + double my_component_k = 2.0; + double my_component_kc = 2.0*my_component_k; + double my_component_kc2 = 3.0*my_component_kc; + double my_component_r = 3.0*rates[2]+states[2]; + double my_component_q = my_component_r+1.0; + + f[0] = algebraicVariables[0]+algebraicVariables[2]-(3.0*states[2]+my_component_kc2); + f[1] = algebraicVariables[0]-algebraicVariables[2]*exp(algebraicVariables[2])-(my_component_q+states[2]); +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[2]; + + u[0] = algebraicVariables[2]; + u[1] = algebraicVariables[0]; + + nlaSolve(objectiveFunction0, u, 2, &rfi); + + algebraicVariables[2] = u[0]; + algebraicVariables[0] = u[1]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 0.0; + states[1] = 0.0; + states[2] = 1.0; + algebraicVariables[0] = 0.0; + algebraicVariables[2] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[2] = -states[2]; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); + rates[0] = algebraicVariables[0]; + double my_component_l = states[2]+1.0; + algebraicVariables[1] = 2.0*my_component_l+algebraicVariables[0]; + rates[1] = algebraicVariables[1]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.untracked.h b/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.untracked.h new file mode 100644 index 000000000..135be52fa --- /dev/null +++ b/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.untracked.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[2]; + char units[14]; + char component[13]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.untracked.py b/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.untracked.py new file mode 100644 index 000000000..4b482c89f --- /dev/null +++ b/tests/resources/generator/algebraic_system_with_untracked_dependencies/model.untracked.py @@ -0,0 +1,110 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 3 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 3 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_component"} + +STATE_INFO = [ + {"name": "z", "units": "dimensionless", "component": "my_component"}, + {"name": "v", "units": "dimensionless", "component": "my_component"}, + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "y", "units": "dimensionless", "component": "my_component"}, + {"name": "a", "units": "dimensionless", "component": "my_component"}, + {"name": "w", "units": "dimensionless", "component": "my_component"} +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +from nlasolver import nla_solve + + +def objective_function_0(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraic_variables[2] = u[0] + algebraic_variables[0] = u[1] + + my_component_k = 2.0 + my_component_kc = 2.0*my_component_k + my_component_kc2 = 3.0*my_component_kc + my_component_r = 3.0*rates[2]+states[2] + my_component_q = my_component_r+1.0 + + f[0] = algebraic_variables[0]+algebraic_variables[2]-(3.0*states[2]+my_component_kc2) + f[1] = algebraic_variables[0]-algebraic_variables[2]*exp(algebraic_variables[2])-(my_component_q+states[2]) + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*2 + + u[0] = algebraic_variables[2] + u[1] = algebraic_variables[0] + + u = nla_solve(objective_function_0, u, 2, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraic_variables[2] = u[0] + algebraic_variables[0] = u[1] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 0.0 + states[1] = 0.0 + states[2] = 1.0 + algebraic_variables[0] = 0.0 + algebraic_variables[2] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[2] = -states[2] + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + rates[0] = algebraic_variables[0] + my_component_l = states[2]+1.0 + algebraic_variables[1] = 2.0*my_component_l+algebraic_variables[0] + rates[1] = algebraic_variables[1] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/cellml_equivalent_variables_in_the_same_component/model.c b/tests/resources/generator/cellml_equivalent_variables_in_the_same_component/model.c new file mode 100644 index 000000000..ab3ba57f4 --- /dev/null +++ b/tests/resources/generator/cellml_equivalent_variables_in_the_same_component/model.c @@ -0,0 +1,98 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_environment"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y", "dimensionless", "my_component"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 1.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[0] = -2.0*states[0]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[0] = 3.0*states[0]; +} diff --git a/tests/resources/generator/cellml_equivalent_variables_in_the_same_component/model.cellml b/tests/resources/generator/cellml_equivalent_variables_in_the_same_component/model.cellml new file mode 100644 index 000000000..6b3659743 --- /dev/null +++ b/tests/resources/generator/cellml_equivalent_variables_in_the_same_component/model.cellml @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + + + + + + + + t + + xo + + + + + + 2 + x + + + + + + y + + + 3 + x + + + + + + + + + + + + diff --git a/tests/resources/generator/cellml_equivalent_variables_in_the_same_component/model.h b/tests/resources/generator/cellml_equivalent_variables_in_the_same_component/model.h new file mode 100644 index 000000000..8f5bdd2ed --- /dev/null +++ b/tests/resources/generator/cellml_equivalent_variables_in_the_same_component/model.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[2]; + char units[14]; + char component[15]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_equivalent_variables_in_the_same_component/model.py b/tests/resources/generator/cellml_equivalent_variables_in_the_same_component/model.py new file mode 100644 index 000000000..35b8a9419 --- /dev/null +++ b/tests/resources/generator/cellml_equivalent_variables_in_the_same_component/model.py @@ -0,0 +1,61 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 1 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_environment"} + +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "y", "units": "dimensionless", "component": "my_component"} +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 1.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[0] = -2.0*states[0] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[0] = 3.0*states[0] diff --git a/tests/resources/generator/cellml_equivalent_variables_with_different_names/model.c b/tests/resources/generator/cellml_equivalent_variables_with_different_names/model.c new file mode 100644 index 000000000..e72f0bf43 --- /dev/null +++ b/tests/resources/generator/cellml_equivalent_variables_with_different_names/model.c @@ -0,0 +1,139 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 2; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_algebraic_eqn_and_ode"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "my_algebraic_eqn_and_ode"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"y_b", "dimensionless", "my_algebraic_eqn_and_ode"}, + {"g", "dimensionless", "my_nla_eqn"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +typedef struct { + double voi; + double *states; + double *rates; + double *constants; + double *computedConstants; + double *algebraicVariables; +} RootFindingInfo; + +extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), + double *u, size_t n, void *data); + +void objectiveFunction0(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + algebraicVariables[1] = u[0]; + + f[0] = algebraicVariables[1]+exp(algebraicVariables[1])-2.0*algebraicVariables[0]; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = algebraicVariables[1]; + + nlaSolve(objectiveFunction0, u, 1, &rfi); + + algebraicVariables[1] = u[0]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 1.0; + algebraicVariables[1] = 0.5; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[0] = -states[0]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + algebraicVariables[0] = 2.0*states[0]; + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); +} diff --git a/tests/resources/generator/cellml_equivalent_variables_with_different_names/model.cellml b/tests/resources/generator/cellml_equivalent_variables_with_different_names/model.cellml new file mode 100644 index 000000000..869cbf899 --- /dev/null +++ b/tests/resources/generator/cellml_equivalent_variables_with_different_names/model.cellml @@ -0,0 +1,63 @@ + + + + + + + + + + + + g + + + g + + + + + 2 + y_e + + + + + + + + + + + + y_b + + + 2 + x + + + + + + + + t + + x + + + + x + + + + + + + + diff --git a/tests/resources/generator/cellml_equivalent_variables_with_different_names/model.h b/tests/resources/generator/cellml_equivalent_variables_with_different_names/model.h new file mode 100644 index 000000000..3e1b584eb --- /dev/null +++ b/tests/resources/generator/cellml_equivalent_variables_with_different_names/model.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[4]; + char units[14]; + char component[25]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/cellml_equivalent_variables_with_different_names/model.py b/tests/resources/generator/cellml_equivalent_variables_with_different_names/model.py new file mode 100644 index 000000000..aad14ae2a --- /dev/null +++ b/tests/resources/generator/cellml_equivalent_variables_with_different_names/model.py @@ -0,0 +1,90 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 1 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 2 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_algebraic_eqn_and_ode"} + +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_algebraic_eqn_and_ode"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "y_b", "units": "dimensionless", "component": "my_algebraic_eqn_and_ode"}, + {"name": "g", "units": "dimensionless", "component": "my_nla_eqn"} +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +from nlasolver import nla_solve + + +def objective_function_0(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + algebraic_variables[1] = u[0] + + f[0] = algebraic_variables[1]+exp(algebraic_variables[1])-2.0*algebraic_variables[0] + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = algebraic_variables[1] + + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + algebraic_variables[1] = u[0] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 1.0 + algebraic_variables[1] = 0.5 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[0] = -states[0] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + algebraic_variables[0] = 2.0*states[0] + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.c b/tests/resources/generator/dae_cellml_1_1_model/model.c index 72c9e9908..3df649647 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.c +++ b/tests/resources/generator/dae_cellml_1_1_model/model.c @@ -182,9 +182,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraicVariables[1] = states[1]+constants[1]; - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); - algebraicVariables[3] = constants[3]*algebraicVariables[1]; - algebraicVariables[4] = states[0]/constants[2]; - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); } diff --git a/tests/resources/generator/dae_cellml_1_1_model/model.py b/tests/resources/generator/dae_cellml_1_1_model/model.py index 1e17c24d3..184f18280 100644 --- a/tests/resources/generator/dae_cellml_1_1_model/model.py +++ b/tests/resources/generator/dae_cellml_1_1_model/model.py @@ -131,8 +131,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - algebraic_variables[1] = states[1]+constants[1] - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) - algebraic_variables[3] = constants[3]*algebraic_variables[1] - algebraic_variables[4] = states[0]/constants[2] - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) + pass diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c index c8d1c6d16..78cb35118 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.c @@ -618,104 +618,9 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraicVariables[0] = states[1]; - algebraicVariables[1] = computedConstants[0]*log(constants[2]/algebraicVariables[0]); algebraicVariables[2] = 0.5*computedConstants[0]*log(constants[5]/states[0]); - algebraicVariables[8] = (constants[63] >= 1.0)?algebraicVariables[47]:states[15]; - algebraicVariables[4] = computedConstants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraicVariables[0], 1.3), -1.0)*pow(1.0+exp(-(algebraicVariables[8]-algebraicVariables[1]+110.0)/20.0), -1.0); - algebraicVariables[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraicVariables[8]/computedConstants[0])+algebraicVariables[0]/constants[19])+algebraicVariables[0]/constants[18]*(1.0+algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])); - algebraicVariables[13] = states[0]/constants[15]*exp(-constants[14]*algebraicVariables[8]/computedConstants[0])/algebraicVariables[20]; - algebraicVariables[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraicVariables[8]/computedConstants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])); - algebraicVariables[14] = constants[5]/constants[22]*exp(constants[21]*algebraicVariables[8]/computedConstants[0])/algebraicVariables[21]; - algebraicVariables[17] = exp(constants[16]*algebraicVariables[8]/(2.0*computedConstants[0])); - algebraicVariables[19] = algebraicVariables[0]/constants[18]*algebraicVariables[0]/constants[17]*(1.0+algebraicVariables[0]/constants[13])*exp(constants[16]*algebraicVariables[8]/(2.0*computedConstants[0]))/algebraicVariables[20]; - algebraicVariables[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraicVariables[8]/(2.0*computedConstants[0]))/algebraicVariables[21]; - algebraicVariables[9] = algebraicVariables[18]*computedConstants[5]*(algebraicVariables[19]+algebraicVariables[13])+algebraicVariables[19]*algebraicVariables[14]*(computedConstants[5]+algebraicVariables[17]); - algebraicVariables[16] = algebraicVariables[0]/(constants[13]+algebraicVariables[0]); - algebraicVariables[15] = exp(-constants[16]*algebraicVariables[8]/(2.0*computedConstants[0])); - algebraicVariables[10] = algebraicVariables[19]*algebraicVariables[16]*(algebraicVariables[18]+algebraicVariables[14])+algebraicVariables[13]*algebraicVariables[18]*(algebraicVariables[16]+algebraicVariables[15]); - algebraicVariables[11] = algebraicVariables[17]*algebraicVariables[16]*(algebraicVariables[19]+algebraicVariables[13])+algebraicVariables[15]*algebraicVariables[13]*(computedConstants[5]+algebraicVariables[17]); - algebraicVariables[12] = algebraicVariables[15]*computedConstants[5]*(algebraicVariables[18]+algebraicVariables[14])+algebraicVariables[14]*algebraicVariables[17]*(algebraicVariables[16]+algebraicVariables[15]); - algebraicVariables[3] = (1.0-constants[12])*constants[11]*(algebraicVariables[11]*algebraicVariables[14]-algebraicVariables[12]*algebraicVariables[13])/(algebraicVariables[12]+algebraicVariables[11]+algebraicVariables[10]+algebraicVariables[9]); - algebraicVariables[22] = constants[25]*states[3]*(states[2]-states[0]); algebraicVariables[23] = states[2]-states[0]; - algebraicVariables[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])); - algebraicVariables[25] = constants[30]/algebraicVariables[24]; - algebraicVariables[26] = constants[31]*algebraicVariables[24]; algebraicVariables[27] = states[4]+states[3]+states[6]+states[5]; - algebraicVariables[28] = (states[0]-states[7])/constants[35]; - algebraicVariables[29] = computedConstants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])); - algebraicVariables[30] = (states[8]-states[2])/constants[38]; - algebraicVariables[31] = constants[40]*states[7]*(1.0-states[9])-constants[39]*states[9]; - algebraicVariables[32] = constants[42]*states[7]*(1.0-(states[10]+states[11]))-constants[41]*states[10]; - algebraicVariables[33] = constants[45]*constants[44]*(1.0-(states[10]+states[11]))-constants[43]*states[11]; - algebraicVariables[34] = constants[47]*states[7]*(1.0-states[12])-constants[46]*states[12]; - algebraicVariables[35] = constants[47]*states[0]*(1.0-states[13])-constants[46]*states[13]; - algebraicVariables[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14]; - algebraicVariables[39] = constants[76]*states[20]*states[19]*(algebraicVariables[8]-computedConstants[1]); - algebraicVariables[40] = (constants[0] > 0.0)?constants[90]*constants[89]*(algebraicVariables[8]-computedConstants[1])*(1.0+exp((algebraicVariables[8]+20.0)/20.0))*states[32]:0.0; - algebraicVariables[37] = 2.0*constants[84]*algebraicVariables[8]/(computedConstants[0]*(1.0-exp(-1.0*algebraicVariables[8]*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*algebraicVariables[8]/computedConstants[0]))*states[25]*states[24]; - algebraicVariables[5] = 0.0000185*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0])))*(algebraicVariables[0]-constants[2]*exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraicVariables[67] = 0.000365*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraicVariables[38] = 2.0*constants[77]*(algebraicVariables[8]-0.0)/(computedConstants[0]*(1.0-exp(-1.0*(algebraicVariables[8]-0.0)*2.0/computedConstants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraicVariables[8]-0.0)/computedConstants[0]))*states[23]*states[22]*states[21]; - algebraicVariables[41] = (algebraicVariables[38]+algebraicVariables[67]+algebraicVariables[5])*(1.0-computedConstants[19])*1.0*computedConstants[18]; - algebraicVariables[51] = computedConstants[0]*log((constants[2]+0.12*constants[4])/(algebraicVariables[0]+0.12*constants[3])); - algebraicVariables[53] = constants[74]*pow(states[18], 3.0)*(algebraicVariables[8]-algebraicVariables[51]); - algebraicVariables[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraicVariables[8]-algebraicVariables[51]); - algebraicVariables[7] = algebraicVariables[52]+algebraicVariables[53]; - algebraicVariables[42] = constants[86]*(algebraicVariables[8]-computedConstants[1])*states[27]*states[26]; - algebraicVariables[93] = computedConstants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraicVariables[0])); - algebraicVariables[43] = computedConstants[22]*(algebraicVariables[8]-algebraicVariables[93])*pow(states[31], 2.0); - algebraicVariables[44] = constants[87]*(algebraicVariables[8]-computedConstants[1])*(0.9*states[30]+0.1*states[29])*states[28]; - algebraicVariables[48] = states[16]*computedConstants[15]*(algebraicVariables[8]-computedConstants[1])*(1.0-constants[71]); - algebraicVariables[6] = states[16]*computedConstants[14]*(algebraicVariables[8]-algebraicVariables[1])*(1.0-constants[71]); - algebraicVariables[45] = algebraicVariables[6]+algebraicVariables[48]; - algebraicVariables[46] = algebraicVariables[45]+algebraicVariables[44]+algebraicVariables[43]+algebraicVariables[42]+algebraicVariables[4]+algebraicVariables[3]+algebraicVariables[7]+algebraicVariables[41]+algebraicVariables[37]+algebraicVariables[40]+algebraicVariables[39]; - algebraicVariables[49] = 1.0/(0.36*(algebraicVariables[8]+148.8-computedConstants[16]-computedConstants[17])/(exp(0.066*(algebraicVariables[8]+148.8-computedConstants[16]-computedConstants[17]))-1.0)+0.1*(algebraicVariables[8]+87.3-computedConstants[16]-computedConstants[17])/(1.0-exp(-0.2*(algebraicVariables[8]+87.3-computedConstants[16]-computedConstants[17]))))-0.054; - algebraicVariables[50] = (algebraicVariables[8] < -(80.0-computedConstants[16]-computedConstants[17]-constants[72]))?0.01329+0.99921/(1.0+exp((algebraicVariables[8]+97.134-computedConstants[16]-computedConstants[17]-constants[72])/8.1752)):0.0002501*exp(-(algebraicVariables[8]-computedConstants[16]-computedConstants[17]-constants[72])/12.861); - algebraicVariables[54] = 1.0/(1.0+exp(-(algebraicVariables[8]+42.0504)/8.3106)); - algebraicVariables[55] = algebraicVariables[8]+41.0; - algebraicVariables[56] = (fabs(algebraicVariables[55]) < constants[75])?2000.0:200.0*algebraicVariables[55]/(1.0-exp(-0.1*algebraicVariables[55])); - algebraicVariables[57] = 8000.0*exp(-0.056*(algebraicVariables[8]+66.0)); - algebraicVariables[58] = 1.0/(algebraicVariables[56]+algebraicVariables[57]); - algebraicVariables[59] = 1.0/(1.0+exp((algebraicVariables[8]+69.804)/4.4565)); - algebraicVariables[60] = 20.0*exp(-0.125*(algebraicVariables[8]+75.0)); - algebraicVariables[61] = 2000.0/(320.0*exp(-0.1*(algebraicVariables[8]+75.0))+1.0); - algebraicVariables[62] = 1.0/(algebraicVariables[60]+algebraicVariables[61]); - algebraicVariables[64] = 1.0/(1.0+exp((algebraicVariables[8]+6.0)/-8.6)); - algebraicVariables[63] = 0.009/(1.0+exp((algebraicVariables[8]+5.0)/12.0))+0.0005; - algebraicVariables[66] = 1.0/(1.0+exp((algebraicVariables[8]+7.5)/10.0)); - algebraicVariables[65] = 0.59/(1.0+exp((algebraicVariables[8]+60.0)/10.0))+3.05; - algebraicVariables[68] = 1.0/(1.0+exp(-(algebraicVariables[8]-constants[79]-computedConstants[20])/(constants[78]*(1.0+computedConstants[21]/100.0)))); - algebraicVariables[73] = (algebraicVariables[8] == -1.8)?-1.80001:algebraicVariables[8]; - algebraicVariables[69] = 0.01143*(algebraicVariables[73]+1.8)/(exp((algebraicVariables[73]+1.8)/2.5)-1.0); - algebraicVariables[72] = (algebraicVariables[8] == -41.8)?-41.80001:(algebraicVariables[8] == 0.0)?0.0:(algebraicVariables[8] == -6.8)?-6.80001:algebraicVariables[8]; - algebraicVariables[70] = -0.02839*(algebraicVariables[72]+41.8)/(exp(-(algebraicVariables[72]+41.8)/2.5)-1.0)-0.0849*(algebraicVariables[72]+6.8)/(exp(-(algebraicVariables[72]+6.8)/4.8)-1.0); - algebraicVariables[71] = 0.001/(algebraicVariables[70]+algebraicVariables[69]); - algebraicVariables[74] = 1.0/(1.0+exp((algebraicVariables[8]+37.4+constants[81])/(5.3+constants[80]))); - algebraicVariables[75] = 0.001*(44.3+230.0*exp(-pow((algebraicVariables[8]+36.0)/10.0, 2.0))); - algebraicVariables[76] = constants[82]/(constants[82]+states[0]); - algebraicVariables[77] = 0.001*algebraicVariables[76]/constants[83]; - algebraicVariables[78] = 1.0/(1.0+exp(-(algebraicVariables[8]+38.3)/5.5)); - algebraicVariables[79] = 0.001/(1.068*exp((algebraicVariables[8]+38.3)/30.0)+1.068*exp(-(algebraicVariables[8]+38.3)/30.0)); - algebraicVariables[80] = 1.0/(1.0+exp((algebraicVariables[8]+58.7)/3.8)); - algebraicVariables[81] = 1.0/(16.67*exp(-(algebraicVariables[8]+75.0)/83.3)+16.67*exp((algebraicVariables[8]+75.0)/15.38))+constants[85]; - algebraicVariables[82] = 1.0/(1.0+exp((algebraicVariables[8]+49.0)/13.0)); - algebraicVariables[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraicVariables[8]+44.0))+0.065*exp(0.1*(algebraicVariables[8]+45.93)))+10.1); - algebraicVariables[84] = 1.0/(1.0+exp(-(algebraicVariables[8]-19.3)/15.0)); - algebraicVariables[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraicVariables[8]+30.61))+0.369*exp(-0.12*(algebraicVariables[8]+23.84)))+2.98); algebraicVariables[86] = 1.0/(1.0+exp(-(algebraicVariables[8]+23.2)/6.6))/(0.84655354/(37.2*exp(algebraicVariables[8]/11.9)+0.96*exp(-algebraicVariables[8]/18.5))); algebraicVariables[87] = 4.0*((37.2*exp(algebraicVariables[8]/15.9)+0.96*exp(-algebraicVariables[8]/22.5))/0.84655354-1.0/(1.0+exp(-(algebraicVariables[8]+23.2)/10.6))/(0.84655354/(37.2*exp(algebraicVariables[8]/15.9)+0.96*exp(-algebraicVariables[8]/22.5)))); - algebraicVariables[88] = 1.0/(1.0+exp(-(algebraicVariables[8]+10.0144)/7.6607)); - algebraicVariables[89] = 0.84655354/(4.2*exp(algebraicVariables[8]/17.0)+0.15*exp(-algebraicVariables[8]/21.6)); - algebraicVariables[90] = 1.0/(30.0*exp(algebraicVariables[8]/10.0)+exp(-algebraicVariables[8]/12.0)); - algebraicVariables[91] = 1.0/(100.0*exp(-algebraicVariables[8]/54.645)+656.0*exp(algebraicVariables[8]/106.157)); - algebraicVariables[92] = 1.0/(1.0+exp((algebraicVariables[8]+28.6)/17.1)); - algebraicVariables[94] = sqrt(1.0/(1.0+exp(-(algebraicVariables[8]+0.6383-computedConstants[23])/10.7071))); - algebraicVariables[95] = 1.0*exp(-(algebraicVariables[8]-computedConstants[23]-5.0)/25.0); - algebraicVariables[96] = 28.0/(1.0+exp(-(algebraicVariables[8]-40.0-computedConstants[23])/3.0)); - algebraicVariables[97] = 1.0/(algebraicVariables[96]+algebraicVariables[95]); - algebraicVariables[98] = 10.0*exp(0.0133*(algebraicVariables[8]+40.0)); - algebraicVariables[99] = computedConstants[24]/(computedConstants[24]+algebraicVariables[98]); - algebraicVariables[100] = 1.0/(computedConstants[24]+algebraicVariables[98]); } diff --git a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py index 51a394f9b..82de30f94 100644 --- a/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py +++ b/tests/resources/generator/fabbri_fantini_wilders_severi_human_san_model_2017/model.py @@ -601,103 +601,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - algebraic_variables[0] = states[1] - algebraic_variables[1] = computed_constants[0]*log(constants[2]/algebraic_variables[0]) algebraic_variables[2] = 0.5*computed_constants[0]*log(constants[5]/states[0]) - algebraic_variables[8] = algebraic_variables[47] if geq_func(constants[63], 1.0) else states[15] - algebraic_variables[4] = computed_constants[4]*constants[10]*pow(1.0+pow(constants[9]/constants[4], 1.2), -1.0)*pow(1.0+pow(constants[8]/algebraic_variables[0], 1.3), -1.0)*pow(1.0+exp(-(algebraic_variables[8]-algebraic_variables[1]+110.0)/20.0), -1.0) - algebraic_variables[20] = 1.0+states[0]/constants[15]*(1.0+exp(-constants[14]*algebraic_variables[8]/computed_constants[0])+algebraic_variables[0]/constants[19])+algebraic_variables[0]/constants[18]*(1.0+algebraic_variables[0]/constants[17]*(1.0+algebraic_variables[0]/constants[13])) - algebraic_variables[13] = states[0]/constants[15]*exp(-constants[14]*algebraic_variables[8]/computed_constants[0])/algebraic_variables[20] - algebraic_variables[21] = 1.0+constants[5]/constants[22]*(1.0+exp(constants[21]*algebraic_variables[8]/computed_constants[0]))+constants[2]/constants[24]*(1.0+constants[2]/constants[23]*(1.0+constants[2]/constants[20])) - algebraic_variables[14] = constants[5]/constants[22]*exp(constants[21]*algebraic_variables[8]/computed_constants[0])/algebraic_variables[21] - algebraic_variables[17] = exp(constants[16]*algebraic_variables[8]/(2.0*computed_constants[0])) - algebraic_variables[19] = algebraic_variables[0]/constants[18]*algebraic_variables[0]/constants[17]*(1.0+algebraic_variables[0]/constants[13])*exp(constants[16]*algebraic_variables[8]/(2.0*computed_constants[0]))/algebraic_variables[20] - algebraic_variables[18] = constants[2]/constants[24]*constants[2]/constants[23]*(1.0+constants[2]/constants[20])*exp(-constants[16]*algebraic_variables[8]/(2.0*computed_constants[0]))/algebraic_variables[21] - algebraic_variables[9] = algebraic_variables[18]*computed_constants[5]*(algebraic_variables[19]+algebraic_variables[13])+algebraic_variables[19]*algebraic_variables[14]*(computed_constants[5]+algebraic_variables[17]) - algebraic_variables[16] = algebraic_variables[0]/(constants[13]+algebraic_variables[0]) - algebraic_variables[15] = exp(-constants[16]*algebraic_variables[8]/(2.0*computed_constants[0])) - algebraic_variables[10] = algebraic_variables[19]*algebraic_variables[16]*(algebraic_variables[18]+algebraic_variables[14])+algebraic_variables[13]*algebraic_variables[18]*(algebraic_variables[16]+algebraic_variables[15]) - algebraic_variables[11] = algebraic_variables[17]*algebraic_variables[16]*(algebraic_variables[19]+algebraic_variables[13])+algebraic_variables[15]*algebraic_variables[13]*(computed_constants[5]+algebraic_variables[17]) - algebraic_variables[12] = algebraic_variables[15]*computed_constants[5]*(algebraic_variables[18]+algebraic_variables[14])+algebraic_variables[14]*algebraic_variables[17]*(algebraic_variables[16]+algebraic_variables[15]) - algebraic_variables[3] = (1.0-constants[12])*constants[11]*(algebraic_variables[11]*algebraic_variables[14]-algebraic_variables[12]*algebraic_variables[13])/(algebraic_variables[12]+algebraic_variables[11]+algebraic_variables[10]+algebraic_variables[9]) - algebraic_variables[22] = constants[25]*states[3]*(states[2]-states[0]) algebraic_variables[23] = states[2]-states[0] - algebraic_variables[24] = constants[29]-(constants[29]-constants[28])/(1.0+pow(constants[27]/states[2], constants[26])) - algebraic_variables[25] = constants[30]/algebraic_variables[24] - algebraic_variables[26] = constants[31]*algebraic_variables[24] algebraic_variables[27] = states[4]+states[3]+states[6]+states[5] - algebraic_variables[28] = (states[0]-states[7])/constants[35] - algebraic_variables[29] = computed_constants[7]/(1.0+exp((-states[7]+constants[37])/constants[36])) - algebraic_variables[30] = (states[8]-states[2])/constants[38] - algebraic_variables[31] = constants[40]*states[7]*(1.0-states[9])-constants[39]*states[9] - algebraic_variables[32] = constants[42]*states[7]*(1.0-(states[10]+states[11]))-constants[41]*states[10] - algebraic_variables[33] = constants[45]*constants[44]*(1.0-(states[10]+states[11]))-constants[43]*states[11] - algebraic_variables[34] = constants[47]*states[7]*(1.0-states[12])-constants[46]*states[12] - algebraic_variables[35] = constants[47]*states[0]*(1.0-states[13])-constants[46]*states[13] - algebraic_variables[36] = constants[49]*states[2]*(1.0-states[14])-constants[48]*states[14] - algebraic_variables[39] = constants[76]*states[20]*states[19]*(algebraic_variables[8]-computed_constants[1]) - algebraic_variables[40] = constants[90]*constants[89]*(algebraic_variables[8]-computed_constants[1])*(1.0+exp((algebraic_variables[8]+20.0)/20.0))*states[32] if gt_func(constants[0], 0.0) else 0.0 - algebraic_variables[37] = 2.0*constants[84]*algebraic_variables[8]/(computed_constants[0]*(1.0-exp(-1.0*algebraic_variables[8]*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*algebraic_variables[8]/computed_constants[0]))*states[25]*states[24] - algebraic_variables[5] = 0.0000185*constants[77]*(algebraic_variables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic_variables[8]-0.0)/computed_constants[0])))*(algebraic_variables[0]-constants[2]*exp(-1.0*(algebraic_variables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic_variables[67] = 0.000365*constants[77]*(algebraic_variables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic_variables[8]-0.0)/computed_constants[0])))*(constants[3]-constants[4]*exp(-1.0*(algebraic_variables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic_variables[38] = 2.0*constants[77]*(algebraic_variables[8]-0.0)/(computed_constants[0]*(1.0-exp(-1.0*(algebraic_variables[8]-0.0)*2.0/computed_constants[0])))*(states[0]-constants[5]*exp(-2.0*(algebraic_variables[8]-0.0)/computed_constants[0]))*states[23]*states[22]*states[21] - algebraic_variables[41] = (algebraic_variables[38]+algebraic_variables[67]+algebraic_variables[5])*(1.0-computed_constants[19])*1.0*computed_constants[18] - algebraic_variables[51] = computed_constants[0]*log((constants[2]+0.12*constants[4])/(algebraic_variables[0]+0.12*constants[3])) - algebraic_variables[53] = constants[74]*pow(states[18], 3.0)*(algebraic_variables[8]-algebraic_variables[51]) - algebraic_variables[52] = constants[73]*pow(states[18], 3.0)*states[17]*(algebraic_variables[8]-algebraic_variables[51]) - algebraic_variables[7] = algebraic_variables[52]+algebraic_variables[53] - algebraic_variables[42] = constants[86]*(algebraic_variables[8]-computed_constants[1])*states[27]*states[26] - algebraic_variables[93] = computed_constants[0]*log((constants[4]+0.12*constants[2])/(constants[3]+0.12*algebraic_variables[0])) - algebraic_variables[43] = computed_constants[22]*(algebraic_variables[8]-algebraic_variables[93])*pow(states[31], 2.0) - algebraic_variables[44] = constants[87]*(algebraic_variables[8]-computed_constants[1])*(0.9*states[30]+0.1*states[29])*states[28] - algebraic_variables[48] = states[16]*computed_constants[15]*(algebraic_variables[8]-computed_constants[1])*(1.0-constants[71]) - algebraic_variables[6] = states[16]*computed_constants[14]*(algebraic_variables[8]-algebraic_variables[1])*(1.0-constants[71]) - algebraic_variables[45] = algebraic_variables[6]+algebraic_variables[48] - algebraic_variables[46] = algebraic_variables[45]+algebraic_variables[44]+algebraic_variables[43]+algebraic_variables[42]+algebraic_variables[4]+algebraic_variables[3]+algebraic_variables[7]+algebraic_variables[41]+algebraic_variables[37]+algebraic_variables[40]+algebraic_variables[39] - algebraic_variables[49] = 1.0/(0.36*(algebraic_variables[8]+148.8-computed_constants[16]-computed_constants[17])/(exp(0.066*(algebraic_variables[8]+148.8-computed_constants[16]-computed_constants[17]))-1.0)+0.1*(algebraic_variables[8]+87.3-computed_constants[16]-computed_constants[17])/(1.0-exp(-0.2*(algebraic_variables[8]+87.3-computed_constants[16]-computed_constants[17]))))-0.054 - algebraic_variables[50] = 0.01329+0.99921/(1.0+exp((algebraic_variables[8]+97.134-computed_constants[16]-computed_constants[17]-constants[72])/8.1752)) if lt_func(algebraic_variables[8], -(80.0-computed_constants[16]-computed_constants[17]-constants[72])) else 0.0002501*exp(-(algebraic_variables[8]-computed_constants[16]-computed_constants[17]-constants[72])/12.861) - algebraic_variables[54] = 1.0/(1.0+exp(-(algebraic_variables[8]+42.0504)/8.3106)) - algebraic_variables[55] = algebraic_variables[8]+41.0 - algebraic_variables[56] = 2000.0 if lt_func(fabs(algebraic_variables[55]), constants[75]) else 200.0*algebraic_variables[55]/(1.0-exp(-0.1*algebraic_variables[55])) - algebraic_variables[57] = 8000.0*exp(-0.056*(algebraic_variables[8]+66.0)) - algebraic_variables[58] = 1.0/(algebraic_variables[56]+algebraic_variables[57]) - algebraic_variables[59] = 1.0/(1.0+exp((algebraic_variables[8]+69.804)/4.4565)) - algebraic_variables[60] = 20.0*exp(-0.125*(algebraic_variables[8]+75.0)) - algebraic_variables[61] = 2000.0/(320.0*exp(-0.1*(algebraic_variables[8]+75.0))+1.0) - algebraic_variables[62] = 1.0/(algebraic_variables[60]+algebraic_variables[61]) - algebraic_variables[64] = 1.0/(1.0+exp((algebraic_variables[8]+6.0)/-8.6)) - algebraic_variables[63] = 0.009/(1.0+exp((algebraic_variables[8]+5.0)/12.0))+0.0005 - algebraic_variables[66] = 1.0/(1.0+exp((algebraic_variables[8]+7.5)/10.0)) - algebraic_variables[65] = 0.59/(1.0+exp((algebraic_variables[8]+60.0)/10.0))+3.05 - algebraic_variables[68] = 1.0/(1.0+exp(-(algebraic_variables[8]-constants[79]-computed_constants[20])/(constants[78]*(1.0+computed_constants[21]/100.0)))) - algebraic_variables[73] = -1.80001 if eq_func(algebraic_variables[8], -1.8) else algebraic_variables[8] - algebraic_variables[69] = 0.01143*(algebraic_variables[73]+1.8)/(exp((algebraic_variables[73]+1.8)/2.5)-1.0) - algebraic_variables[72] = -41.80001 if eq_func(algebraic_variables[8], -41.8) else 0.0 if eq_func(algebraic_variables[8], 0.0) else -6.80001 if eq_func(algebraic_variables[8], -6.8) else algebraic_variables[8] - algebraic_variables[70] = -0.02839*(algebraic_variables[72]+41.8)/(exp(-(algebraic_variables[72]+41.8)/2.5)-1.0)-0.0849*(algebraic_variables[72]+6.8)/(exp(-(algebraic_variables[72]+6.8)/4.8)-1.0) - algebraic_variables[71] = 0.001/(algebraic_variables[70]+algebraic_variables[69]) - algebraic_variables[74] = 1.0/(1.0+exp((algebraic_variables[8]+37.4+constants[81])/(5.3+constants[80]))) - algebraic_variables[75] = 0.001*(44.3+230.0*exp(-pow((algebraic_variables[8]+36.0)/10.0, 2.0))) - algebraic_variables[76] = constants[82]/(constants[82]+states[0]) - algebraic_variables[77] = 0.001*algebraic_variables[76]/constants[83] - algebraic_variables[78] = 1.0/(1.0+exp(-(algebraic_variables[8]+38.3)/5.5)) - algebraic_variables[79] = 0.001/(1.068*exp((algebraic_variables[8]+38.3)/30.0)+1.068*exp(-(algebraic_variables[8]+38.3)/30.0)) - algebraic_variables[80] = 1.0/(1.0+exp((algebraic_variables[8]+58.7)/3.8)) - algebraic_variables[81] = 1.0/(16.67*exp(-(algebraic_variables[8]+75.0)/83.3)+16.67*exp((algebraic_variables[8]+75.0)/15.38))+constants[85] - algebraic_variables[82] = 1.0/(1.0+exp((algebraic_variables[8]+49.0)/13.0)) - algebraic_variables[83] = 0.001*0.6*(65.17/(0.57*exp(-0.08*(algebraic_variables[8]+44.0))+0.065*exp(0.1*(algebraic_variables[8]+45.93)))+10.1) - algebraic_variables[84] = 1.0/(1.0+exp(-(algebraic_variables[8]-19.3)/15.0)) - algebraic_variables[85] = 0.001*0.66*1.4*(15.59/(1.037*exp(0.09*(algebraic_variables[8]+30.61))+0.369*exp(-0.12*(algebraic_variables[8]+23.84)))+2.98) algebraic_variables[86] = 1.0/(1.0+exp(-(algebraic_variables[8]+23.2)/6.6))/(0.84655354/(37.2*exp(algebraic_variables[8]/11.9)+0.96*exp(-algebraic_variables[8]/18.5))) algebraic_variables[87] = 4.0*((37.2*exp(algebraic_variables[8]/15.9)+0.96*exp(-algebraic_variables[8]/22.5))/0.84655354-1.0/(1.0+exp(-(algebraic_variables[8]+23.2)/10.6))/(0.84655354/(37.2*exp(algebraic_variables[8]/15.9)+0.96*exp(-algebraic_variables[8]/22.5)))) - algebraic_variables[88] = 1.0/(1.0+exp(-(algebraic_variables[8]+10.0144)/7.6607)) - algebraic_variables[89] = 0.84655354/(4.2*exp(algebraic_variables[8]/17.0)+0.15*exp(-algebraic_variables[8]/21.6)) - algebraic_variables[90] = 1.0/(30.0*exp(algebraic_variables[8]/10.0)+exp(-algebraic_variables[8]/12.0)) - algebraic_variables[91] = 1.0/(100.0*exp(-algebraic_variables[8]/54.645)+656.0*exp(algebraic_variables[8]/106.157)) - algebraic_variables[92] = 1.0/(1.0+exp((algebraic_variables[8]+28.6)/17.1)) - algebraic_variables[94] = sqrt(1.0/(1.0+exp(-(algebraic_variables[8]+0.6383-computed_constants[23])/10.7071))) - algebraic_variables[95] = 1.0*exp(-(algebraic_variables[8]-computed_constants[23]-5.0)/25.0) - algebraic_variables[96] = 28.0/(1.0+exp(-(algebraic_variables[8]-40.0-computed_constants[23])/3.0)) - algebraic_variables[97] = 1.0/(algebraic_variables[96]+algebraic_variables[95]) - algebraic_variables[98] = 10.0*exp(0.0133*(algebraic_variables[8]+40.0)) - algebraic_variables[99] = computed_constants[24]/(computed_constants[24]+algebraic_variables[98]) - algebraic_variables[100] = 1.0/(computed_constants[24]+algebraic_variables[98]) diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c index f8f084e97..0f7a70e6f 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.c @@ -505,56 +505,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraicVariables[4] = computedConstants[3]*(states[0]-computedConstants[4]); - algebraicVariables[2] = computedConstants[5]*(states[0]-computedConstants[6]); - algebraicVariables[3] = computedConstants[7]*(states[0]-computedConstants[8]); - algebraicVariables[1] = (constants[1] == 0.0)?computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))):computedConstants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))); - algebraicVariables[0] = computedConstants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)); - algebraicVariables[17] = (constants[1] == 0.0)?0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869:0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693; - algebraicVariables[14] = (1.0-algebraicVariables[17])*states[3]+algebraicVariables[17]*states[2]; - algebraicVariables[13] = computedConstants[13]*pow(states[1], 3.0)*algebraicVariables[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computedConstants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0]; - algebraicVariables[16] = (constants[1] == 0.0)?pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0):pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0); - algebraicVariables[15] = (constants[1] == 0.0)?0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5:0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5; - algebraicVariables[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)); - algebraicVariables[21] = algebraicVariables[19]; - algebraicVariables[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977; - algebraicVariables[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556; - algebraicVariables[12] = computedConstants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]); - algebraicVariables[24] = (constants[1] == 0.0)?-28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):(constants[1] == 1.0)?-28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0):-28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0); - algebraicVariables[25] = (constants[1] == 1.0)?11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0):11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0); - algebraicVariables[22] = 2.0/(algebraicVariables[24]+algebraicVariables[25]); - algebraicVariables[23] = (constants[1] == 0.0)?1.0/(1.0+exp(-(states[0]+23.1)/6.0)):(constants[1] == 1.0)?1.0/(1.0+exp(-(states[0]+22.3+0.8*computedConstants[0])/6.0)):1.0/(1.0+exp(-(states[0]+22.2)/6.0)); - algebraicVariables[28] = (constants[1] == 1.0)?3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0):3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0); - algebraicVariables[29] = (constants[1] == 1.0)?30.0/(1.0+exp(-(states[0]+28.0)/4.0)):25.0/(1.0+exp(-(states[0]+28.0)/4.0)); - algebraicVariables[26] = (constants[1] == 1.0)?(1.2-0.2*computedConstants[0])/(algebraicVariables[28]+algebraicVariables[29]):1.0/(algebraicVariables[28]+algebraicVariables[29]); - algebraicVariables[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)); - algebraicVariables[11] = computedConstants[15]*states[7]*states[6]*(states[0]-constants[73]); - algebraicVariables[32] = 1068.0*exp((states[0]+26.3)/30.0); - algebraicVariables[33] = 1068.0*exp(-(states[0]+26.3)/30.0); - algebraicVariables[30] = 1.0/(algebraicVariables[32]+algebraicVariables[33]); - algebraicVariables[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)); - algebraicVariables[36] = (constants[1] == 1.0)?15.3*exp(-(states[0]+71.0+0.7*computedConstants[0])/83.3):15.3*exp(-(states[0]+71.7)/83.3); - algebraicVariables[37] = (constants[1] == 1.0)?15.0*exp((states[0]+71.0)/15.38):15.0*exp((states[0]+71.7)/15.38); - algebraicVariables[34] = 1.0/(algebraicVariables[36]+algebraicVariables[37]); - algebraicVariables[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)); - algebraicVariables[10] = computedConstants[16]*states[9]*states[8]*(states[0]-computedConstants[6]); - algebraicVariables[9] = computedConstants[17]*states[8]*(states[0]-computedConstants[6]); - algebraicVariables[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)); - algebraicVariables[38] = (constants[1] == 0.0)?0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)):(constants[1] == 1.0)?0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computedConstants[0]))+0.7174*exp((0.2719-0.1719*computedConstants[0])*1.0*(states[0]+40.93+10.0*computedConstants[0])))):0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))); - algebraicVariables[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)); - algebraicVariables[40] = (constants[1] == 0.0)?0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))):(constants[1] == 1.0)?0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))):0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))); - algebraicVariables[42] = 0.6*states[12]+0.4*states[11]; - algebraicVariables[8] = computedConstants[18]*algebraicVariables[42]*states[10]*(states[0]-computedConstants[6]); - algebraicVariables[44] = (constants[1] != 2.0)?1.0/(1.0+exp(-(states[0]+14.2)/10.6)):1.0/(1.0+exp(-(states[0]+13.2)/10.6)); - algebraicVariables[43] = (constants[1] != 2.0)?1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)):1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)); - algebraicVariables[46] = algebraicVariables[44]; - algebraicVariables[45] = (constants[1] != 2.0)?1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)):1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)); - algebraicVariables[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)); - algebraicVariables[7] = computedConstants[20]*pow(states[13], 2.0)*(states[0]-computedConstants[12]); - algebraicVariables[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)); - algebraicVariables[48] = 1.0*exp(-states[0]/45.0); - algebraicVariables[6] = (constants[1] != 2.0)?computedConstants[21]*states[14]*(states[0]-computedConstants[4]):computedConstants[21]*states[14]*(states[0]-77.6); - algebraicVariables[5] = (constants[1] != 2.0)?computedConstants[22]*states[14]*(states[0]-computedConstants[6]):computedConstants[22]*states[14]*(states[0]+102.0); - algebraicVariables[51] = (constants[1] == 0.0)?1.0*exp(-(states[0]+78.91)/26.62):1.0*exp(-(states[0]+78.91)/26.63); - algebraicVariables[50] = 1.0*exp((states[0]+75.13)/21.25); } diff --git a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py index c426c9122..3c4e95407 100644 --- a/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py +++ b/tests/resources/generator/garny_kohl_hunter_boyett_noble_rabbit_san_model_2003/model.py @@ -476,55 +476,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - algebraic_variables[4] = computed_constants[3]*(states[0]-computed_constants[4]) - algebraic_variables[2] = computed_constants[5]*(states[0]-computed_constants[6]) - algebraic_variables[3] = computed_constants[7]*(states[0]-computed_constants[8]) - algebraic_variables[1] = computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.0374*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) if eq_func(constants[1], 0.0) else computed_constants[9]*(pow(constants[32], 3.0)*constants[33]*exp(0.03743*states[0]*constants[37])-pow(constants[34], 3.0)*constants[35]*exp(0.03743*states[0]*(constants[37]-1.0)))/(1.0+constants[36]*(constants[35]*pow(constants[34], 3.0)+constants[33]*pow(constants[32], 3.0))) - algebraic_variables[0] = computed_constants[10]*pow(constants[32]/(constants[46]+constants[32]), 3.0)*pow(constants[44]/(constants[45]+constants[44]), 2.0)*1.6/(1.5+exp(-(states[0]+60.0)/40.0)) - algebraic_variables[17] = 0.0952*exp(-0.063*(states[0]+34.4))/(1.0+1.66*exp(-0.225*(states[0]+63.7)))+0.0869 if eq_func(constants[1], 0.0) else 0.09518*exp(-0.06306*(states[0]+34.4))/(1.0+1.662*exp(-0.2251*(states[0]+63.7)))+0.08693 - algebraic_variables[14] = (1.0-algebraic_variables[17])*states[3]+algebraic_variables[17]*states[2] - algebraic_variables[13] = computed_constants[13]*pow(states[1], 3.0)*algebraic_variables[14]*constants[34]*pow(constants[7], 2.0)/(constants[5]*constants[6])*(exp((states[0]-computed_constants[4])*constants[7]/(constants[5]*constants[6]))-1.0)/(exp(states[0]*constants[7]/(constants[5]*constants[6]))-1.0)*states[0] - algebraic_variables[16] = pow(1.0/(1.0+exp(-states[0]/5.46)), 1.0/3.0) if eq_func(constants[1], 0.0) else pow(1.0/(1.0+exp(-(states[0]+30.32)/5.46)), 1.0/3.0) - algebraic_variables[15] = 0.0006247/(0.832*exp(-0.335*(states[0]+56.7))+0.627*exp(0.082*(states[0]+65.01)))+4.0e-5 if eq_func(constants[1], 0.0) else 0.0006247/(0.8322166*exp(-0.33566*(states[0]+56.7062))+0.6274*exp(0.0823*(states[0]+65.0131)))+4.569e-5 - algebraic_variables[19] = 1.0/(1.0+exp((states[0]+66.1)/6.4)) - algebraic_variables[21] = algebraic_variables[19] - algebraic_variables[18] = 3.717e-6*exp(-0.2815*(states[0]+17.11))/(1.0+0.003732*exp(-0.3426*(states[0]+37.76)))+0.0005977 - algebraic_variables[20] = 3.186e-8*exp(-0.6219*(states[0]+18.8))/(1.0+7.189e-5*exp(-0.6683*(states[0]+34.07)))+0.003556 - algebraic_variables[12] = computed_constants[14]*(states[5]*states[4]+0.006/(1.0+exp(-(states[0]+14.1)/6.0)))*(states[0]-constants[66]) - algebraic_variables[24] = -28.38*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 0.0) else -28.39*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) if eq_func(constants[1], 1.0) else -28.4*(states[0]+35.0)/(exp(-(states[0]+35.0)/2.5)-1.0)-84.9*states[0]/(exp(-0.208*states[0])-1.0) - algebraic_variables[25] = 11.43*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) if eq_func(constants[1], 1.0) else 11.42*(states[0]-5.0)/(exp(0.4*(states[0]-5.0))-1.0) - algebraic_variables[22] = 2.0/(algebraic_variables[24]+algebraic_variables[25]) - algebraic_variables[23] = 1.0/(1.0+exp(-(states[0]+23.1)/6.0)) if eq_func(constants[1], 0.0) else 1.0/(1.0+exp(-(states[0]+22.3+0.8*computed_constants[0])/6.0)) if eq_func(constants[1], 1.0) else 1.0/(1.0+exp(-(states[0]+22.2)/6.0)) - algebraic_variables[28] = 3.75*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) if eq_func(constants[1], 1.0) else 3.12*(states[0]+28.0)/(exp((states[0]+28.0)/4.0)-1.0) - algebraic_variables[29] = 30.0/(1.0+exp(-(states[0]+28.0)/4.0)) if eq_func(constants[1], 1.0) else 25.0/(1.0+exp(-(states[0]+28.0)/4.0)) - algebraic_variables[26] = (1.2-0.2*computed_constants[0])/(algebraic_variables[28]+algebraic_variables[29]) if eq_func(constants[1], 1.0) else 1.0/(algebraic_variables[28]+algebraic_variables[29]) - algebraic_variables[27] = 1.0/(1.0+exp((states[0]+45.0)/5.0)) - algebraic_variables[11] = computed_constants[15]*states[7]*states[6]*(states[0]-constants[73]) - algebraic_variables[32] = 1068.0*exp((states[0]+26.3)/30.0) - algebraic_variables[33] = 1068.0*exp(-(states[0]+26.3)/30.0) - algebraic_variables[30] = 1.0/(algebraic_variables[32]+algebraic_variables[33]) - algebraic_variables[31] = 1.0/(1.0+exp(-(states[0]+37.0)/6.8)) - algebraic_variables[36] = 15.3*exp(-(states[0]+71.0+0.7*computed_constants[0])/83.3) if eq_func(constants[1], 1.0) else 15.3*exp(-(states[0]+71.7)/83.3) - algebraic_variables[37] = 15.0*exp((states[0]+71.0)/15.38) if eq_func(constants[1], 1.0) else 15.0*exp((states[0]+71.7)/15.38) - algebraic_variables[34] = 1.0/(algebraic_variables[36]+algebraic_variables[37]) - algebraic_variables[35] = 1.0/(1.0+exp((states[0]+71.0)/9.0)) - algebraic_variables[10] = computed_constants[16]*states[9]*states[8]*(states[0]-computed_constants[6]) - algebraic_variables[9] = computed_constants[17]*states[8]*(states[0]-computed_constants[6]) - algebraic_variables[39] = 1.0/(1.0+exp((states[0]+59.37)/13.1)) - algebraic_variables[38] = 0.0101+0.06517/(0.57*exp(-0.08*(states[0]+49.0)))+2.4e-5*exp(0.1*(states[0]+50.93)) if eq_func(constants[1], 0.0) else 0.001/3.0*(30.31+195.5/(0.5686*exp(-0.08161*(states[0]+39.0+10.0*computed_constants[0]))+0.7174*exp((0.2719-0.1719*computed_constants[0])*1.0*(states[0]+40.93+10.0*computed_constants[0])))) if eq_func(constants[1], 1.0) else 0.0101+0.06517/(0.5686*exp(-0.08161*(states[0]+39.0))+0.7174*exp(0.2719*(states[0]+40.93))) - algebraic_variables[41] = 1.0/(1.0+exp(-(states[0]-10.93)/19.7)) - algebraic_variables[40] = 0.001*(2.98+15.59/(1.037*exp(0.09*(states[0]+30.61))+0.369*exp(-0.12*(states[0]+23.84)))) if eq_func(constants[1], 0.0) else 0.0025*(1.191+7.838/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) if eq_func(constants[1], 1.0) else 0.001*(2.98+19.59/(1.037*exp(0.09012*(states[0]+30.61))+0.369*exp(-0.119*(states[0]+23.84)))) - algebraic_variables[42] = 0.6*states[12]+0.4*states[11] - algebraic_variables[8] = computed_constants[18]*algebraic_variables[42]*states[10]*(states[0]-computed_constants[6]) - algebraic_variables[44] = 1.0/(1.0+exp(-(states[0]+14.2)/10.6)) if neq_func(constants[1], 2.0) else 1.0/(1.0+exp(-(states[0]+13.2)/10.6)) - algebraic_variables[43] = 1.0/(37.2*exp((states[0]-9.0)/15.9)+0.96*exp(-(states[0]-9.0)/22.5)) if neq_func(constants[1], 2.0) else 1.0/(37.2*exp((states[0]-10.0)/15.9)+0.96*exp(-(states[0]-10.0)/22.5)) - algebraic_variables[46] = algebraic_variables[44] - algebraic_variables[45] = 1.0/(4.2*exp((states[0]-9.0)/17.0)+0.15*exp(-(states[0]-9.0)/21.6)) if neq_func(constants[1], 2.0) else 1.0/(4.2*exp((states[0]-10.0)/17.0)+0.15*exp(-(states[0]-10.0)/21.6)) - algebraic_variables[47] = 1.0/(1.0+exp((states[0]+18.6)/10.1)) - algebraic_variables[7] = computed_constants[20]*pow(states[13], 2.0)*(states[0]-computed_constants[12]) - algebraic_variables[49] = 14.0/(1.0+exp(-(states[0]-40.0)/9.0)) - algebraic_variables[48] = 1.0*exp(-states[0]/45.0) - algebraic_variables[6] = computed_constants[21]*states[14]*(states[0]-computed_constants[4]) if neq_func(constants[1], 2.0) else computed_constants[21]*states[14]*(states[0]-77.6) - algebraic_variables[5] = computed_constants[22]*states[14]*(states[0]-computed_constants[6]) if neq_func(constants[1], 2.0) else computed_constants[22]*states[14]*(states[0]+102.0) - algebraic_variables[51] = 1.0*exp(-(states[0]+78.91)/26.62) if eq_func(constants[1], 0.0) else 1.0*exp(-(states[0]+78.91)/26.63) - algebraic_variables[50] = 1.0*exp((states[0]+75.13)/21.25) + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c index 360b8600e..d7dabbb42 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.c @@ -153,14 +153,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - algebraicVariables[0] = constants[2]*(states[0]-computedConstants[0]); - algebraicVariables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraicVariables[4] = 4.0*exp(states[0]/18.0); - algebraicVariables[5] = 0.07*exp(states[0]/20.0); - algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraicVariables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraicVariables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraicVariables[8] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py index 31d17d8c6..b5dc7a634 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.algebraic.py @@ -121,13 +121,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - algebraic_variables[0] = constants[2]*(states[0]-computed_constants[0]) - algebraic_variables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic_variables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic_variables[4] = 4.0*exp(states[0]/18.0) - algebraic_variables[5] = 0.07*exp(states[0]/20.0) - algebraic_variables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic_variables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic_variables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic_variables[8] = 0.125*exp(states[0]/80.0) + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c index 30f951f73..b01ffc2b2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.c @@ -138,13 +138,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraicVariables[1] = constants[2]*(states[0]-computedConstants[0]); - algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraicVariables[5] = 4.0*exp(states[0]/18.0); - algebraicVariables[6] = 0.07*exp(states[0]/20.0); - algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraicVariables[9] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c index 0dc2048d7..f7f89e925 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.c @@ -153,14 +153,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - algebraicVariables[1] = constants[2]*(states[0]-externalVariables[0]); - algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[0]); - algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraicVariables[5] = 4.0*exp(states[0]/18.0); - algebraicVariables[6] = 0.07*exp(states[0]/20.0); - algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[1]); - algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraicVariables[9] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py index 62af5e56d..b3d193c5c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.computed.constant.py @@ -121,13 +121,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - algebraic_variables[1] = constants[2]*(states[0]-external_variables[0]) - algebraic_variables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[0]) - algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic_variables[5] = 4.0*exp(states[0]/18.0) - algebraic_variables[6] = 0.07*exp(states[0]/20.0) - algebraic_variables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic_variables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[1]) - algebraic_variables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic_variables[9] = 0.125*exp(states[0]/80.0) + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c index 2ecacc08a..e70c558df 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.c @@ -153,14 +153,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraicVariables[1] = constants[1]*(states[0]-computedConstants[0]); - algebraicVariables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraicVariables[5] = 4.0*exp(states[0]/18.0); - algebraicVariables[6] = 0.07*exp(states[0]/20.0); - algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraicVariables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraicVariables[9] = 0.125*exp(states[0]/80.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py index 3b9799fdc..4f6d6cf0b 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.constant.py @@ -121,13 +121,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - algebraic_variables[1] = constants[1]*(states[0]-computed_constants[0]) - algebraic_variables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic_variables[5] = 4.0*exp(states[0]/18.0) - algebraic_variables[6] = 0.07*exp(states[0]/20.0) - algebraic_variables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic_variables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic_variables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic_variables[9] = 0.125*exp(states[0]/80.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c index 5e0956da0..d5860a1f5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.c @@ -591,35 +591,22 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot15(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot16(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot15(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot16(voi, states, rates, constants, computedConstants, algebraicVariables); } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot15(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot16(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c index 992e358e0..2fc4f0489 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.c @@ -552,11 +552,9 @@ void computeVariables(double voi, double *states, double *rates, double *constan { findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - externalVariables[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 2); externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py index ff169a684..e25cabdc2 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.external.py @@ -469,10 +469,8 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - external_variables[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 2) external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.c index f69d3abf4..360652fa7 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.c @@ -538,34 +538,21 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); + algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.py index bc96db4da..06e76efe1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.py @@ -460,32 +460,20 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - algebraic_variables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) algebraic_variables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.c index edea396d3..d66212c40 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.c @@ -541,9 +541,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); @@ -553,22 +550,12 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.py index 301c583b4..a85ba64b5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.control.with.externals.py @@ -458,9 +458,6 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) @@ -470,20 +467,10 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.c index e6a184bfa..0e1cb57b4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.c @@ -539,32 +539,20 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.py index 947dc831a..fe6fb4a7c 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.py @@ -461,30 +461,19 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.c index 44e8739dc..408f21304 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.c @@ -541,9 +541,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); @@ -553,22 +550,12 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.py index 301c583b4..a85ba64b5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.algebraic.variables.with.externals.py @@ -458,9 +458,6 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) @@ -470,20 +467,10 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.c index 6f54b0cca..2617885cb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.c @@ -538,34 +538,21 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); + algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.py index 286e2c048..03898dfe7 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.py @@ -461,32 +461,20 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - algebraic_variables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) algebraic_variables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.c index 5efdff35a..236f94902 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.c @@ -541,9 +541,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); @@ -553,22 +550,12 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.py index 301c583b4..a85ba64b5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.computed.constants.with.externals.py @@ -458,9 +458,6 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) @@ -470,20 +467,10 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.c index 30e8d30f1..4c48c4f31 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.c @@ -541,34 +541,21 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); + algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); + findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.py index e6ad02be5..88ddea2ef 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.py @@ -463,32 +463,20 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - algebraic_variables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) algebraic_variables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.c index 681ea4aa8..e17a8bae1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.c @@ -542,9 +542,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); @@ -554,22 +551,12 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.py index 3394469a7..39825a5fb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.constants.with.externals.py @@ -459,9 +459,6 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) @@ -471,20 +468,10 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.c index a6357b62a..1a4ac7cad 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.c @@ -541,32 +541,20 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); + findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot5(voi, states, rates, constants, computedConstants, algebraicVariables); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.py index 8c7cdc908..e4106cf80 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.py @@ -464,30 +464,19 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.c index fd2ead650..81294cf8a 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.c @@ -542,9 +542,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot2(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); @@ -554,22 +551,12 @@ void computeRates(double voi, double *states, double *rates, double *constants, findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); + findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); } void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - findRoot3(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot13(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot12(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot14(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot11(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - algebraicVariables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - findRoot1(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); findRoot4(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot6(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot7(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot8(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot9(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); - findRoot10(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.py index 3394469a7..39825a5fb 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.for.tracking.untracked.variables.with.externals.py @@ -459,9 +459,6 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) @@ -471,20 +468,10 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - algebraic_variables[5] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py index f931b0892..fef1ac8f1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dae.py @@ -508,33 +508,21 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_2(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_12(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_4(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) - - -def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_3(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_13(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_7(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_6(voi, states, rates, constants, computed_constants, algebraic_variables) find_root_8(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_5(voi, states, rates, constants, computed_constants, algebraic_variables) - find_root_1(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_10(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_9(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_11(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_15(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_14(voi, states, rates, constants, computed_constants, algebraic_variables) + find_root_16(voi, states, rates, constants, computed_constants, algebraic_variables) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c index 5e2fb86b5..4ae4fe6a7 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.c @@ -153,14 +153,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - algebraicVariables[0] = constants[2]*(states[0]-computedConstants[0]); - algebraicVariables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraicVariables[4] = 4.0*exp(states[0]/18.0); - algebraicVariables[5] = 0.07*exp(states[0]/20.0); - algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraicVariables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraicVariables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py index f44297f3a..ad498cdc3 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.algebraic.py @@ -121,13 +121,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - algebraic_variables[0] = constants[2]*(states[0]-computed_constants[0]) - algebraic_variables[2] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic_variables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic_variables[4] = 4.0*exp(states[0]/18.0) - algebraic_variables[5] = 0.07*exp(states[0]/20.0) - algebraic_variables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic_variables[1] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic_variables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c index 8ddf89e56..65849a7fd 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.c @@ -153,17 +153,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - algebraicVariables[4] = externalVariables[0]-10.613; - algebraicVariables[1] = constants[1]*(states[0]-algebraicVariables[4]); - algebraicVariables[5] = externalVariables[0]-115.0; - algebraicVariables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraicVariables[5]); - algebraicVariables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraicVariables[7] = 4.0*exp(states[0]/18.0); - algebraicVariables[8] = 0.07*exp(states[0]/20.0); - algebraicVariables[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraicVariables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-externalVariables[1]); - algebraicVariables[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraicVariables[11] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py index a0daad697..82fa04289 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.computed.constant.py @@ -122,16 +122,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - algebraic_variables[4] = external_variables[0]-10.613 - algebraic_variables[1] = constants[1]*(states[0]-algebraic_variables[4]) - algebraic_variables[5] = external_variables[0]-115.0 - algebraic_variables[3] = constants[2]*pow(states[2], 3.0)*states[1]*(states[0]-algebraic_variables[5]) - algebraic_variables[6] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic_variables[7] = 4.0*exp(states[0]/18.0) - algebraic_variables[8] = 0.07*exp(states[0]/20.0) - algebraic_variables[9] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic_variables[2] = constants[3]*pow(states[3], 4.0)*(states[0]-external_variables[1]) - algebraic_variables[10] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic_variables[11] = 0.125*exp(states[0]/80.0) + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c index bec4e1093..a1d176e8d 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.c @@ -153,15 +153,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraicVariables[1] = constants[1]*(states[0]-computedConstants[0]); - externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); - algebraicVariables[3] = externalVariables[1]*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraicVariables[5] = 4.0*exp(states[0]/18.0); - algebraicVariables[6] = 0.07*exp(states[0]/20.0); - algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraicVariables[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraicVariables[9] = 0.125*exp(states[0]/80.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py index 735951e4c..d58a52130 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.constant.py @@ -121,14 +121,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - algebraic_variables[1] = constants[1]*(states[0]-computed_constants[0]) - external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) - algebraic_variables[3] = external_variables[1]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic_variables[5] = 4.0*exp(states[0]/18.0) - algebraic_variables[6] = 0.07*exp(states[0]/20.0) - algebraic_variables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic_variables[2] = constants[2]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic_variables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic_variables[9] = 0.125*exp(states[0]/80.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c index 690d86a31..1c6622699 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.c @@ -145,7 +145,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); algebraicVariables[1] = constants[2]*(externalVariables[0]-computedConstants[0]); externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); algebraicVariables[3] = constants[3]*pow(externalVariables[1], 3.0)*states[0]*(externalVariables[0]-computedConstants[1]); diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py index b4b128ea8..22a6e07d6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.dependent.state.py @@ -113,7 +113,6 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) algebraic_variables[1] = constants[2]*(external_variables[0]-computed_constants[0]) external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) algebraic_variables[3] = constants[3]*pow(external_variables[1], 3.0)*states[0]*(external_variables[0]-computed_constants[1]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c index f10c7d0b1..f11ef1b0f 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.c @@ -149,9 +149,7 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { algebraicVariables[0] = ((voi >= 10.0) && (voi <= 10.5))?-20.0:0.0; - externalVariables[1] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 1); algebraicVariables[1] = constants[2]*(externalVariables[1]-computedConstants[0]); - externalVariables[2] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 2); externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); algebraicVariables[2] = constants[4]*pow(states[2], 4.0)*(externalVariables[1]-computedConstants[2]); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py index 7b0bf1e9d..1ae8fefee 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.external.py @@ -117,8 +117,6 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): algebraic_variables[0] = -20.0 if and_func(geq_func(voi, 10.0), leq_func(voi, 10.5)) else 0.0 - external_variables[1] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 1) algebraic_variables[1] = constants[2]*(external_variables[1]-computed_constants[0]) - external_variables[2] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 2) external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) algebraic_variables[2] = constants[4]*pow(states[2], 4.0)*(external_variables[1]-computed_constants[2]) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py index ccff3e558..c3c212bd5 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.py @@ -113,12 +113,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - algebraic_variables[1] = constants[2]*(states[0]-computed_constants[0]) - algebraic_variables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic_variables[5] = 4.0*exp(states[0]/18.0) - algebraic_variables[6] = 0.07*exp(states[0]/20.0) - algebraic_variables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic_variables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic_variables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic_variables[9] = 0.125*exp(states[0]/80.0) + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c index 8a850a888..f523d1052 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.c @@ -150,14 +150,6 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraicVariables[1] = constants[2]*(states[0]-computedConstants[0]); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - algebraicVariables[3] = constants[3]*pow(externalVariables[0], 3.0)*states[1]*(states[0]-computedConstants[1]); algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); algebraicVariables[5] = 4.0*exp(states[0]/18.0); - algebraicVariables[6] = 0.07*exp(states[0]/20.0); - algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraicVariables[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computedConstants[2]); - algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraicVariables[9] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py index d2349ff2b..f1569f5a6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.state.py @@ -118,13 +118,5 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - algebraic_variables[1] = constants[2]*(states[0]-computed_constants[0]) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - algebraic_variables[3] = constants[3]*pow(external_variables[0], 3.0)*states[1]*(states[0]-computed_constants[1]) algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) algebraic_variables[5] = 4.0*exp(states[0]/18.0) - algebraic_variables[6] = 0.07*exp(states[0]/20.0) - algebraic_variables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic_variables[2] = constants[4]*pow(states[2], 4.0)*(states[0]-computed_constants[2]) - algebraic_variables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic_variables[9] = 0.125*exp(states[0]/80.0) diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.c index 54a0f3f39..87e7d70fa 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.c @@ -145,6 +145,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraicVariables[0] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.py index cecefe977..ebf0853a6 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.algebraic.variables.with.externals.py @@ -113,5 +113,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - algebraic_variables[0] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.c index d3d7f752c..d64690fde 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.c @@ -135,16 +135,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - double leakage_current_E_L = constants[1]-10.613; - algebraicVariables[1] = constants[2]*(states[0]-leakage_current_E_L); - double sodium_channel_E_Na = constants[1]-115.0; - algebraicVariables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-sodium_channel_E_Na); - algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraicVariables[5] = 4.0*exp(states[0]/18.0); - algebraicVariables[6] = 0.07*exp(states[0]/20.0); - algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - double potassium_channel_E_K = constants[1]+12.0; - algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-potassium_channel_E_K); - algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraicVariables[9] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.py index ad27a546c..f33074a34 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.py @@ -111,15 +111,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - leakage_current_E_L = constants[1]-10.613 - algebraic_variables[1] = constants[2]*(states[0]-leakage_current_E_L) - sodium_channel_E_Na = constants[1]-115.0 - algebraic_variables[3] = constants[3]*pow(states[2], 3.0)*states[1]*(states[0]-sodium_channel_E_Na) - algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic_variables[5] = 4.0*exp(states[0]/18.0) - algebraic_variables[6] = 0.07*exp(states[0]/20.0) - algebraic_variables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - potassium_channel_E_K = constants[1]+12.0 - algebraic_variables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-potassium_channel_E_K) - algebraic_variables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic_variables[9] = 0.125*exp(states[0]/80.0) + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.c index 27cca09b6..a0d8d49e4 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.c @@ -150,14 +150,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - double leakage_current_E_L = constants[1]-10.613; - algebraicVariables[1] = constants[2]*(states[0]-leakage_current_E_L); - algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - algebraicVariables[4] = 4.0*exp(states[0]/18.0); - algebraicVariables[5] = 0.07*exp(states[0]/20.0); - algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - algebraicVariables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computedConstants[0]); - algebraicVariables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraicVariables[8] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.py index b0df2d403..f552ecef7 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.computed.constants.with.externals.py @@ -118,13 +118,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - leakage_current_E_L = constants[1]-10.613 - algebraic_variables[1] = constants[2]*(states[0]-leakage_current_E_L) - algebraic_variables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - algebraic_variables[4] = 4.0*exp(states[0]/18.0) - algebraic_variables[5] = 0.07*exp(states[0]/20.0) - algebraic_variables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - algebraic_variables[2] = constants[4]*pow(states[3], 4.0)*(states[0]-computed_constants[0]) - algebraic_variables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic_variables[8] = 0.125*exp(states[0]/80.0) + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.c index 265e66a36..f63a3eb49 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.c @@ -133,16 +133,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - double leakage_current_g_L = 0.3; - algebraicVariables[1] = leakage_current_g_L*(states[0]-computedConstants[0]); - double sodium_channel_g_Na = 120.0; - algebraicVariables[3] = sodium_channel_g_Na*pow(states[2], 3.0)*states[1]*(states[0]-computedConstants[1]); - algebraicVariables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - algebraicVariables[5] = 4.0*exp(states[0]/18.0); - algebraicVariables[6] = 0.07*exp(states[0]/20.0); - algebraicVariables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - double potassium_channel_g_K = 36.0; - algebraicVariables[2] = potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraicVariables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraicVariables[9] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.py index f4e805a3f..a8d4fae39 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.py @@ -108,15 +108,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - leakage_current_g_L = 0.3 - algebraic_variables[1] = leakage_current_g_L*(states[0]-computed_constants[0]) - sodium_channel_g_Na = 120.0 - algebraic_variables[3] = sodium_channel_g_Na*pow(states[2], 3.0)*states[1]*(states[0]-computed_constants[1]) - algebraic_variables[4] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - algebraic_variables[5] = 4.0*exp(states[0]/18.0) - algebraic_variables[6] = 0.07*exp(states[0]/20.0) - algebraic_variables[7] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - potassium_channel_g_K = 36.0 - algebraic_variables[2] = potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic_variables[8] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic_variables[9] = 0.125*exp(states[0]/80.0) + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.c index 179345657..edfdf5cda 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.c @@ -148,15 +148,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - double leakage_current_g_L = 0.3; - algebraicVariables[1] = leakage_current_g_L*(states[0]-computedConstants[0]); - algebraicVariables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); - algebraicVariables[4] = 4.0*exp(states[0]/18.0); - algebraicVariables[5] = 0.07*exp(states[0]/20.0); - algebraicVariables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0); - double potassium_channel_g_K = 36.0; - algebraicVariables[2] = potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computedConstants[2]); - algebraicVariables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0); - algebraicVariables[8] = 0.125*exp(states[0]/80.0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.py index a9c5b5455..e5df65ba8 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.constants.with.externals.py @@ -116,14 +116,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - leakage_current_g_L = 0.3 - algebraic_variables[1] = leakage_current_g_L*(states[0]-computed_constants[0]) - algebraic_variables[3] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) - algebraic_variables[4] = 4.0*exp(states[0]/18.0) - algebraic_variables[5] = 0.07*exp(states[0]/20.0) - algebraic_variables[6] = 1.0/(exp((states[0]+30.0)/10.0)+1.0) - potassium_channel_g_K = 36.0 - algebraic_variables[2] = potassium_channel_g_K*pow(states[3], 4.0)*(states[0]-computed_constants[2]) - algebraic_variables[7] = 0.01*(states[0]+10.0)/(exp((states[0]+10.0)/10.0)-1.0) - algebraic_variables[8] = 0.125*exp(states[0]/80.0) + pass diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.c b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.c index aac251167..81f823737 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.c +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.c @@ -138,6 +138,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables, double *externalVariables, ExternalVariable externalVariable) { - algebraicVariables[0] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0); - externalVariables[0] = externalVariable(voi, states, rates, constants, computedConstants, algebraicVariables, externalVariables, 0); } diff --git a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.py b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.py index b8a898336..0c7bdc0f1 100644 --- a/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.py +++ b/tests/resources/generator/hodgkin_huxley_squid_axon_model_1952/model.untracked.variables.with.externals.py @@ -106,5 +106,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, external_variable): - algebraic_variables[0] = 0.1*(states[0]+25.0)/(exp((states[0]+25.0)/10.0)-1.0) - external_variables[0] = external_variable(voi, states, rates, constants, computed_constants, algebraic_variables, external_variables, 0) + pass diff --git a/tests/resources/generator/noble_model_1962/model.c b/tests/resources/generator/noble_model_1962/model.c index 183535a3c..cbff3fe3a 100644 --- a/tests/resources/generator/noble_model_1962/model.c +++ b/tests/resources/generator/noble_model_1962/model.c @@ -136,16 +136,4 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - algebraicVariables[0] = constants[2]*(states[0]-constants[1]); - algebraicVariables[3] = pow(states[2], 3.0)*states[1]*constants[3]; - algebraicVariables[2] = (algebraicVariables[3]+0.14)*(states[0]-constants[4]); - algebraicVariables[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0); - algebraicVariables[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0); - algebraicVariables[6] = 0.17*exp((-states[0]-90.0)/20.0); - algebraicVariables[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)); - algebraicVariables[8] = 1.2*pow(states[3], 4.0); - algebraicVariables[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0); - algebraicVariables[1] = (algebraicVariables[9]+algebraicVariables[8])*(states[0]+100.0); - algebraicVariables[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0); - algebraicVariables[11] = 0.002*exp((-states[0]-90.0)/80.0); } diff --git a/tests/resources/generator/noble_model_1962/model.py b/tests/resources/generator/noble_model_1962/model.py index 22e090887..5b60cb6b0 100644 --- a/tests/resources/generator/noble_model_1962/model.py +++ b/tests/resources/generator/noble_model_1962/model.py @@ -100,15 +100,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - algebraic_variables[0] = constants[2]*(states[0]-constants[1]) - algebraic_variables[3] = pow(states[2], 3.0)*states[1]*constants[3] - algebraic_variables[2] = (algebraic_variables[3]+0.14)*(states[0]-constants[4]) - algebraic_variables[4] = 0.1*(-states[0]-48.0)/(exp((-states[0]-48.0)/15.0)-1.0) - algebraic_variables[5] = 0.12*(states[0]+8.0)/(exp((states[0]+8.0)/5.0)-1.0) - algebraic_variables[6] = 0.17*exp((-states[0]-90.0)/20.0) - algebraic_variables[7] = 1.0/(1.0+exp((-states[0]-42.0)/10.0)) - algebraic_variables[8] = 1.2*pow(states[3], 4.0) - algebraic_variables[9] = 1.2*exp((-states[0]-90.0)/50.0)+0.015*exp((states[0]+90.0)/60.0) - algebraic_variables[1] = (algebraic_variables[9]+algebraic_variables[8])*(states[0]+100.0) - algebraic_variables[10] = 0.0001*(-states[0]-50.0)/(exp((-states[0]-50.0)/10.0)-1.0) - algebraic_variables[11] = 0.002*exp((-states[0]-90.0)/80.0) + pass diff --git a/tests/resources/generator/ode_derivative_on_rhs/model.c b/tests/resources/generator/ode_derivative_on_rhs/model.c new file mode 100644 index 000000000..0bc1ed99b --- /dev/null +++ b/tests/resources/generator/ode_derivative_on_rhs/model.c @@ -0,0 +1,99 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "my_component"}, + {"z", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 1.0; + states[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[0] = -states[0]; + rates[1] = 2.0*rates[0]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/ode_derivative_on_rhs/model.cellml b/tests/resources/generator/ode_derivative_on_rhs/model.cellml new file mode 100644 index 000000000..38de9f1ff --- /dev/null +++ b/tests/resources/generator/ode_derivative_on_rhs/model.cellml @@ -0,0 +1,48 @@ + + + + + + + + + + + + + + t + + z + + + + 2 + + + + t + + x + + + + + + + + + t + + x + + + + x + + + + + diff --git a/tests/resources/generator/ode_derivative_on_rhs/model.h b/tests/resources/generator/ode_derivative_on_rhs/model.h new file mode 100644 index 000000000..135be52fa --- /dev/null +++ b/tests/resources/generator/ode_derivative_on_rhs/model.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[2]; + char units[14]; + char component[13]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_derivative_on_rhs/model.py b/tests/resources/generator/ode_derivative_on_rhs/model.py new file mode 100644 index 000000000..18daef686 --- /dev/null +++ b/tests/resources/generator/ode_derivative_on_rhs/model.py @@ -0,0 +1,63 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_component"} + +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"}, + {"name": "z", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 1.0 + states[1] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[0] = -states[0] + rates[1] = 2.0*rates[0] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/ode_state_var_on_lhs/model.c b/tests/resources/generator/ode_state_var_on_lhs/model.c new file mode 100644 index 000000000..796ba7ce4 --- /dev/null +++ b/tests/resources/generator/ode_state_var_on_lhs/model.c @@ -0,0 +1,135 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +typedef struct { + double voi; + double *states; + double *rates; + double *constants; + double *computedConstants; + double *algebraicVariables; +} RootFindingInfo; + +extern void nlaSolve(void (*objectiveFunction)(double *, double *, void *), + double *u, size_t n, void *data); + +void objectiveFunction0(double *u, double *f, void *data) +{ + double voi = ((RootFindingInfo *) data)->voi; + double *states = ((RootFindingInfo *) data)->states; + double *rates = ((RootFindingInfo *) data)->rates; + double *constants = ((RootFindingInfo *) data)->constants; + double *computedConstants = ((RootFindingInfo *) data)->computedConstants; + double *algebraicVariables = ((RootFindingInfo *) data)->algebraicVariables; + + rates[0] = u[0]; + + f[0] = states[0]-2.0*rates[0]; +} + +void findRoot0(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + RootFindingInfo rfi = { voi, states, rates, constants, computedConstants, algebraicVariables }; + double u[1]; + + u[0] = rates[0]; + + nlaSolve(objectiveFunction0, u, 1, &rfi); + + rates[0] = u[0]; +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 1.0; + rates[0] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/ode_state_var_on_lhs/model.cellml b/tests/resources/generator/ode_state_var_on_lhs/model.cellml new file mode 100644 index 000000000..8101f17b5 --- /dev/null +++ b/tests/resources/generator/ode_state_var_on_lhs/model.cellml @@ -0,0 +1,28 @@ + + + + + + + + + + x + + + 2 + + + + t + + x + + + + + + diff --git a/tests/resources/generator/ode_state_var_on_lhs/model.h b/tests/resources/generator/ode_state_var_on_lhs/model.h new file mode 100644 index 000000000..135be52fa --- /dev/null +++ b/tests/resources/generator/ode_state_var_on_lhs/model.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[2]; + char units[14]; + char component[13]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_state_var_on_lhs/model.py b/tests/resources/generator/ode_state_var_on_lhs/model.py new file mode 100644 index 000000000..c57792c6d --- /dev/null +++ b/tests/resources/generator/ode_state_var_on_lhs/model.py @@ -0,0 +1,87 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 1 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_component"} + +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +from nlasolver import nla_solve + + +def objective_function_0(u, f, data): + voi = data[0] + states = data[1] + rates = data[2] + constants = data[3] + computed_constants = data[4] + algebraic_variables = data[5] + + rates[0] = u[0] + + f[0] = states[0]-2.0*rates[0] + + +def find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables): + u = [nan]*1 + + u[0] = rates[0] + + u = nla_solve(objective_function_0, u, 1, [voi, states, rates, constants, computed_constants, algebraic_variables]) + + rates[0] = u[0] + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 1.0 + rates[0] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/ode_state_var_on_rhs/model.c b/tests/resources/generator/ode_state_var_on_rhs/model.c new file mode 100644 index 000000000..2ef40a477 --- /dev/null +++ b/tests/resources/generator/ode_state_var_on_rhs/model.c @@ -0,0 +1,99 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 2; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 0; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "my_component"}, + {"y", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 1.0; + states[1] = 0.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + rates[0] = states[0]; + rates[1] = rates[0]; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} diff --git a/tests/resources/generator/ode_state_var_on_rhs/model.cellml b/tests/resources/generator/ode_state_var_on_rhs/model.cellml new file mode 100644 index 000000000..670a73319 --- /dev/null +++ b/tests/resources/generator/ode_state_var_on_rhs/model.cellml @@ -0,0 +1,44 @@ + + + + + + + + + + + + + + t + + x + + x + + + + + + + t + + y + + + + + t + + x + + + + + diff --git a/tests/resources/generator/ode_state_var_on_rhs/model.h b/tests/resources/generator/ode_state_var_on_rhs/model.h new file mode 100644 index 000000000..135be52fa --- /dev/null +++ b/tests/resources/generator/ode_state_var_on_rhs/model.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[2]; + char units[14]; + char component[13]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_state_var_on_rhs/model.py b/tests/resources/generator/ode_state_var_on_rhs/model.py new file mode 100644 index 000000000..fdcecc7db --- /dev/null +++ b/tests/resources/generator/ode_state_var_on_rhs/model.py @@ -0,0 +1,63 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 2 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 0 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_component"} + +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"}, + {"name": "y", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 1.0 + states[1] = 0.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + rates[0] = states[0] + rates[1] = rates[0] + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + pass diff --git a/tests/resources/generator/ode_untracked_dependency_used_by_algebraic_eqn/model.c b/tests/resources/generator/ode_untracked_dependency_used_by_algebraic_eqn/model.c new file mode 100644 index 000000000..33b1ac46e --- /dev/null +++ b/tests/resources/generator/ode_untracked_dependency_used_by_algebraic_eqn/model.c @@ -0,0 +1,100 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#include "model.h" + +#include +#include + +const char VERSION[] = "0.8.0"; +const char LIBCELLML_VERSION[] = "0.7.1"; + +const size_t STATE_COUNT = 1; +const size_t CONSTANT_COUNT = 0; +const size_t COMPUTED_CONSTANT_COUNT = 0; +const size_t ALGEBRAIC_VARIABLE_COUNT = 1; + +const VariableInfo VOI_INFO = {"t", "dimensionless", "my_component"}; + +const VariableInfo STATE_INFO[] = { + {"x", "dimensionless", "my_component"} +}; + +const VariableInfo CONSTANT_INFO[] = { +}; + +const VariableInfo COMPUTED_CONSTANT_INFO[] = { +}; + +const VariableInfo ALGEBRAIC_VARIABLE_INFO[] = { + {"v", "dimensionless", "my_component"} +}; + +double * createStatesArray() +{ + double *res = (double *) malloc(STATE_COUNT*sizeof(double)); + + for (size_t i = 0; i < STATE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createConstantsArray() +{ + double *res = (double *) malloc(CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createComputedConstantsArray() +{ + double *res = (double *) malloc(COMPUTED_CONSTANT_COUNT*sizeof(double)); + + for (size_t i = 0; i < COMPUTED_CONSTANT_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +double * createAlgebraicVariablesArray() +{ + double *res = (double *) malloc(ALGEBRAIC_VARIABLE_COUNT*sizeof(double)); + + for (size_t i = 0; i < ALGEBRAIC_VARIABLE_COUNT; ++i) { + res[i] = NAN; + } + + return res; +} + +void deleteArray(double *array) +{ + free(array); +} + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + states[0] = 1.0; +} + +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ +} + +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double my_component_u = 2.0*states[0]; + rates[0] = -my_component_u; +} + +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) +{ + double my_component_u = 2.0*states[0]; + algebraicVariables[0] = my_component_u+1.0; +} diff --git a/tests/resources/generator/ode_untracked_dependency_used_by_algebraic_eqn/model.cellml b/tests/resources/generator/ode_untracked_dependency_used_by_algebraic_eqn/model.cellml new file mode 100644 index 000000000..c395c8036 --- /dev/null +++ b/tests/resources/generator/ode_untracked_dependency_used_by_algebraic_eqn/model.cellml @@ -0,0 +1,26 @@ + + + + + + + + + + + tx + u + + + + u + 2x + + + + v + u1 + + + + diff --git a/tests/resources/generator/ode_untracked_dependency_used_by_algebraic_eqn/model.h b/tests/resources/generator/ode_untracked_dependency_used_by_algebraic_eqn/model.h new file mode 100644 index 000000000..135be52fa --- /dev/null +++ b/tests/resources/generator/ode_untracked_dependency_used_by_algebraic_eqn/model.h @@ -0,0 +1,37 @@ +/* The content of this file was generated using the C profile of libCellML 0.7.1. */ + +#pragma once + +#include + +extern const char VERSION[]; +extern const char LIBCELLML_VERSION[]; + +extern const size_t STATE_COUNT; +extern const size_t CONSTANT_COUNT; +extern const size_t COMPUTED_CONSTANT_COUNT; +extern const size_t ALGEBRAIC_VARIABLE_COUNT; + +typedef struct { + char name[2]; + char units[14]; + char component[13]; +} VariableInfo; + +extern const VariableInfo VOI_INFO; +extern const VariableInfo STATE_INFO[]; +extern const VariableInfo CONSTANT_INFO[]; +extern const VariableInfo COMPUTED_CONSTANT_INFO[]; +extern const VariableInfo ALGEBRAIC_VARIABLE_INFO[]; + +double * createStatesArray(); +double * createConstantsArray(); +double * createComputedConstantsArray(); +double * createAlgebraicVariablesArray(); + +void deleteArray(double *array); + +void initialiseArrays(double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeComputedConstants(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeRates(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); +void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables); diff --git a/tests/resources/generator/ode_untracked_dependency_used_by_algebraic_eqn/model.py b/tests/resources/generator/ode_untracked_dependency_used_by_algebraic_eqn/model.py new file mode 100644 index 000000000..531d450f8 --- /dev/null +++ b/tests/resources/generator/ode_untracked_dependency_used_by_algebraic_eqn/model.py @@ -0,0 +1,63 @@ +# The content of this file was generated using the Python profile of libCellML 0.7.1. + +from enum import Enum +from math import * + + +__version__ = "0.8.0" +LIBCELLML_VERSION = "0.7.1" + +STATE_COUNT = 1 +CONSTANT_COUNT = 0 +COMPUTED_CONSTANT_COUNT = 0 +ALGEBRAIC_VARIABLE_COUNT = 1 + +VOI_INFO = {"name": "t", "units": "dimensionless", "component": "my_component"} + +STATE_INFO = [ + {"name": "x", "units": "dimensionless", "component": "my_component"} +] + +CONSTANT_INFO = [ +] + +COMPUTED_CONSTANT_INFO = [ +] + +ALGEBRAIC_VARIABLE_INFO = [ + {"name": "v", "units": "dimensionless", "component": "my_component"} +] + + +def create_states_array(): + return [nan]*STATE_COUNT + + +def create_constants_array(): + return [nan]*CONSTANT_COUNT + + +def create_computed_constants_array(): + return [nan]*COMPUTED_CONSTANT_COUNT + + +def create_algebraic_variables_array(): + return [nan]*ALGEBRAIC_VARIABLE_COUNT + + +def initialise_arrays(states, rates, constants, computed_constants, algebraic_variables): + states[0] = 1.0 + + +def compute_computed_constants(voi, states, rates, constants, computed_constants, algebraic_variables): + pass + + +def compute_rates(voi, states, rates, constants, computed_constants, algebraic_variables): + my_component_u = 2.0*states[0] + rates[0] = -my_component_u + + +def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): + my_component_u = 2.0*states[0] + algebraic_variables[0] = my_component_u+1.0 diff --git a/tests/resources/generator/robertson_model_1966/model.dae.c b/tests/resources/generator/robertson_model_1966/model.dae.c index 981bc4cce..a88d0e247 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.c +++ b/tests/resources/generator/robertson_model_1966/model.dae.c @@ -144,6 +144,5 @@ void computeRates(double voi, double *states, double *rates, double *constants, void computeVariables(double voi, double *states, double *rates, double *constants, double *computedConstants, double *algebraicVariables) { - findRoot0(voi, states, rates, constants, computedConstants, algebraicVariables); algebraicVariables[1] = 10000.0*states[0]; } diff --git a/tests/resources/generator/robertson_model_1966/model.dae.py b/tests/resources/generator/robertson_model_1966/model.dae.py index 842d7b826..81e1b4767 100644 --- a/tests/resources/generator/robertson_model_1966/model.dae.py +++ b/tests/resources/generator/robertson_model_1966/model.dae.py @@ -96,5 +96,4 @@ def compute_rates(voi, states, rates, constants, computed_constants, algebraic_v def compute_variables(voi, states, rates, constants, computed_constants, algebraic_variables): - find_root_0(voi, states, rates, constants, computed_constants, algebraic_variables) algebraic_variables[1] = 10000.0*states[0]