SedSteadyState crashes

VERSION.txt

@@ -1 +1 @@
-1.20261008.0
+1.20261008.1

src/sed/sedinstancetask.cpp

@@ -92,6 +92,10 @@ SedInstanceTask::Impl::Impl(const SedAbstractTaskPtr &pTask)
     mSimulation = task->pimpl()->mSimulation;
     mSedUniformTimeCourse = mDifferentialModel ? std::dynamic_pointer_cast<SedUniformTimeCourse>(mSimulation) : nullptr;
 
+    // Note: SedTask::Impl::isValid() ensures that an ODE/DAE model is used with a uniform time course simulation.
+
+    ASSERT_EQ(mDifferentialModel, (mSedUniformTimeCourse != nullptr));
+
     const auto &odeSolver {mSimulation->odeSolver()};
     const auto &nlaSolver {mSimulation->nlaSolver()};
 

src/sed/sedsimulation.cpp

@@ -30,7 +30,7 @@ SedSimulation::Impl::Impl(const SedDocumentPtr &pDocument)
 {
 }
 
-bool SedSimulation::Impl::isValid(const SedModelPtr &pModel)
+bool SedSimulation::Impl::isValid(const SedModelPtr &pModel, bool pUniformTimeCourse)
 {
     auto modelType {pModel->pimpl()->mFile->pimpl()->mCellmlFile->type()};
     const auto &modelId = pModel->pimpl()->mId;
@@ -51,6 +51,27 @@ bool SedSimulation::Impl::isValid(const SedModelPtr &pModel)
         addError(error);
     };
 
+    // Make sure that we are a uniform time course simulation if our model is an ODE/DAE model.
+    //---GRY--- WE DON'T CURRENTLY SUPPORT OTHER TYPES OF SIMULATION FOR ODE/DAE MODELS.
+
+    if (((modelType == libcellml::AnalyserModel::Type::ODE)
+         || (modelType == libcellml::AnalyserModel::Type::DAE))
+        && !pUniformTimeCourse) {
+        std::string error;
+
+        error.reserve(mId.size() + modelId.size() + 96); // NOLINT
+
+        error += "Simulation '";
+        error += mId;
+        error += "' is to be used with model '";
+        error += modelId;
+        error += "' which (currently) requires a uniform time course simulation.";
+
+        addError(error);
+    }
+
+    // Make sure that we have the solver(s) required by our model.
+
     if ((modelType == libcellml::AnalyserModel::Type::ODE) && (mOdeSolver == nullptr)) {
         addMissingSolverError("ODE");
     } else if ((modelType == libcellml::AnalyserModel::Type::NLA) && (mNlaSolver == nullptr)) {

src/sed/sedsimulation_p.h

@@ -30,7 +30,7 @@ class SedSimulation::Impl: public SedBase::Impl
 
     explicit Impl(const SedDocumentPtr &pDocument);
 
-    bool isValid(const SedModelPtr &pModel);
+    bool isValid(const SedModelPtr &pModel, bool pUniformTimeCourse);
 
     const SolverOdePtr &odeSolver() const;
     void setOdeSolver(const SolverOdePtr &pOdeSolver);

src/sed/sedtask.cpp

@@ -18,6 +18,7 @@ limitations under the License.
 #include "sedmodel_p.h"
 #include "sedsimulation_p.h"
 #include "sedtask_p.h"
+#include "seduniformtimecourse_p.h"
 
 #include "utils.h"
 
@@ -78,7 +79,7 @@ bool SedTask::Impl::isValid()
 
     // Make sure that the simulation is valid for the model.
 
-    if (!mSimulation->pimpl()->isValid(mModel)) {
+    if (!mSimulation->pimpl()->isValid(mModel, std::dynamic_pointer_cast<SedUniformTimeCourse>(mSimulation) != nullptr)) {
         addIssues(mSimulation, "Simulation");
     }
 

tests/api/sed/instancetests.cpp

@@ -599,6 +599,41 @@ TEST(InstanceSedTest, odeModelWithNoOdeSolver)
     EXPECT_EQ_ISSUES(instance, EXPECTED_ISSUES);
 }
 
+TEST(InstanceSedTest, odeModelWithNonUniformTimeCourseSimulation)
+{
+    static const libOpenCOR::ExpectedIssues ONE_STEP_EXPECTED_ISSUES {{
+        {libOpenCOR::Issue::Type::ERROR, "Task | Simulation: simulation 'simulation1' is to be used with model 'model1' which (currently) requires a uniform time course simulation."},
+    }};
+    static const libOpenCOR::ExpectedIssues STEADY_STATE_EXPECTED_ISSUES {{
+        {libOpenCOR::Issue::Type::ERROR, "Task | Simulation: simulation 'simulation2' is to be used with model 'model1' which (currently) requires a uniform time course simulation."},
+    }};
+
+    auto file {libOpenCOR::File::create(libOpenCOR::resourcePath("cellml_2.cellml"))};
+    auto document {libOpenCOR::SedDocument::create()};
+    auto model {libOpenCOR::SedModel::create(document, file)};
+    auto oneStep {libOpenCOR::SedOneStep::create(document)};
+    auto steadyState {libOpenCOR::SedSteadyState::create(document)};
+    auto task {libOpenCOR::SedTask::create(document, model, oneStep)};
+
+    oneStep->setOdeSolver(libOpenCOR::SolverCvode::create());
+    steadyState->setOdeSolver(libOpenCOR::SolverCvode::create());
+
+    document->addModel(model);
+    document->addSimulation(oneStep);
+    document->addSimulation(steadyState);
+    document->addTask(task);
+
+    auto instance {document->instantiate()};
+
+    EXPECT_EQ_ISSUES(instance, ONE_STEP_EXPECTED_ISSUES);
+
+    task->setSimulation(steadyState);
+
+    instance = document->instantiate();
+
+    EXPECT_EQ_ISSUES(instance, STEADY_STATE_EXPECTED_ISSUES);
+}
+
 TEST(InstanceSedTest, nlaModel)
 {
     static const libOpenCOR::ExpectedIssues EXPECTED_ISSUES {{
@@ -690,6 +725,29 @@ TEST(InstanceSedTest, daeModelWithNoOdeOrNlaSolver)
     EXPECT_EQ_ISSUES(instance, EXPECTED_ISSUES);
 }
 
+TEST(InstanceSedTest, daeModelWithNonUniformTimeCourseSimulation)
+{
+    static const libOpenCOR::ExpectedIssues EXPECTED_ISSUES {{
+        {libOpenCOR::Issue::Type::ERROR, "Task | Simulation: simulation 'simulation1' is to be used with model 'model1' which (currently) requires a uniform time course simulation."},
+        {libOpenCOR::Issue::Type::ERROR, "Task | Simulation: simulation 'simulation1' is to be used with model 'model1' which requires an ODE solver but none is provided."},
+        {libOpenCOR::Issue::Type::ERROR, "Task | Simulation: simulation 'simulation1' is to be used with model 'model1' which requires an NLA solver but none is provided."},
+    }};
+
+    auto file {libOpenCOR::File::create(libOpenCOR::resourcePath("api/sed/dae.cellml"))};
+    auto document {libOpenCOR::SedDocument::create()};
+    auto model {libOpenCOR::SedModel::create(document, file)};
+    auto oneStep {libOpenCOR::SedOneStep::create(document)};
+    auto task {libOpenCOR::SedTask::create(document, model, oneStep)};
+
+    document->addModel(model);
+    document->addSimulation(oneStep);
+    document->addTask(task);
+
+    auto instance {document->instantiate()};
+
+    EXPECT_EQ_ISSUES(instance, EXPECTED_ISSUES);
+}
+
 TEST(InstanceSedTest, daeModelWithFailingOdeSolver)
 {
     static const libOpenCOR::ExpectedIssues EXPECTED_ISSUES {{

tests/bindings/javascript/sed.instance.test.js

@@ -653,6 +653,46 @@ test.describe('Sed instance tests', () => {
     ]);
   });
 
+  test('ODE model with non-uniform time course simulation', () => {
+    const file = new loc.File(utils.resourcePath('cellml_2.cellml'));
+
+    file.setContents(utils.fileContents(file.path));
+
+    const document = new loc.SedDocument();
+    const model = new loc.SedModel(document, file);
+    const oneStep = new loc.SedOneStep(document);
+    const steadyState = new loc.SedSteadyState(document);
+    const task = new loc.SedTask(document, model, oneStep);
+
+    oneStep.odeSolver = new loc.SolverCvode();
+    steadyState.odeSolver = new loc.SolverCvode();
+
+    document.addModel(model);
+    document.addSimulation(oneStep);
+    document.addSimulation(steadyState);
+    document.addTask(task);
+
+    let instance = document.instantiate();
+
+    assertIssues(loc, instance, [
+      [
+        loc.Issue.Type.ERROR,
+        "Task | Simulation: simulation 'simulation1' is to be used with model 'model1' which (currently) requires a uniform time course simulation."
+      ]
+    ]);
+
+    task.simulation = steadyState;
+
+    instance = document.instantiate();
+
+    assertIssues(loc, instance, [
+      [
+        loc.Issue.Type.ERROR,
+        "Task | Simulation: simulation 'simulation2' is to be used with model 'model1' which (currently) requires a uniform time course simulation."
+      ]
+    ]);
+  });
+
   test('NLA model', () => {
     const file = new loc.File(utils.resourcePath('api/sed/nla.cellml'));
 
@@ -764,6 +804,38 @@ test.describe('Sed instance tests', () => {
     ]);
   });
 
+  test('DAE model with non-uniform time course simulation', () => {
+    const file = new loc.File(utils.resourcePath('api/sed/dae.cellml'));
+
+    file.setContents(utils.fileContents(file.path));
+
+    const document = new loc.SedDocument();
+    const model = new loc.SedModel(document, file);
+    const oneStep = new loc.SedOneStep(document);
+    const task = new loc.SedTask(document, model, oneStep);
+
+    document.addModel(model);
+    document.addSimulation(oneStep);
+    document.addTask(task);
+
+    const instance = document.instantiate();
+
+    assertIssues(loc, instance, [
+      [
+        loc.Issue.Type.ERROR,
+        "Task | Simulation: simulation 'simulation1' is to be used with model 'model1' which (currently) requires a uniform time course simulation."
+      ],
+      [
+        loc.Issue.Type.ERROR,
+        "Task | Simulation: simulation 'simulation1' is to be used with model 'model1' which requires an ODE solver but none is provided."
+      ],
+      [
+        loc.Issue.Type.ERROR,
+        "Task | Simulation: simulation 'simulation1' is to be used with model 'model1' which requires an NLA solver but none is provided."
+      ]
+    ]);
+  });
+
   test('DAE model with failing ODE solver', () => {
     const file = new loc.File(utils.resourcePath('api/sed/dae.cellml'));
 

tests/bindings/python/test_sed_instance.py

@@ -580,6 +580,46 @@ def test_ode_model_with_no_ode_solver():
     assert_issues(instance, expected_issues)
 
 
+def test_ode_model_with_non_uniform_time_course_simulation():
+    one_step_expected_issues = [
+        [
+            loc.Issue.Type.Error,
+            "Task | Simulation: simulation 'simulation1' is to be used with model 'model1' which (currently) requires a uniform time course simulation.",
+        ],
+    ]
+    steady_state_expected_issues = [
+        [
+            loc.Issue.Type.Error,
+            "Task | Simulation: simulation 'simulation2' is to be used with model 'model1' which (currently) requires a uniform time course simulation.",
+        ],
+    ]
+
+    file = loc.File(utils.resource_path("cellml_2.cellml"))
+    document = loc.SedDocument()
+    model = loc.SedModel(document, file)
+    one_step = loc.SedOneStep(document)
+    steady_state = loc.SedSteadyState(document)
+    task = loc.SedTask(document, model, one_step)
+
+    one_step.ode_solver = loc.SolverCvode()
+    steady_state.ode_solver = loc.SolverCvode()
+
+    document.add_model(model)
+    document.add_simulation(one_step)
+    document.add_simulation(steady_state)
+    document.add_task(task)
+
+    instance = document.instantiate()
+
+    assert_issues(instance, one_step_expected_issues)
+
+    task.simulation = steady_state
+
+    instance = document.instantiate()
+
+    assert_issues(instance, steady_state_expected_issues)
+
+
 def test_nla_model():
     expected_issues = [
         [
@@ -682,6 +722,37 @@ def test_dae_model_with_no_ode_or_nla_solver():
     assert_issues(instance, expected_issues)
 
 
+def test_dae_model_with_non_uniform_time_course_simulation():
+    expected_issues = [
+        [
+            loc.Issue.Type.Error,
+            "Task | Simulation: simulation 'simulation1' is to be used with model 'model1' which (currently) requires a uniform time course simulation.",
+        ],
+        [
+            loc.Issue.Type.Error,
+            "Task | Simulation: simulation 'simulation1' is to be used with model 'model1' which requires an ODE solver but none is provided.",
+        ],
+        [
+            loc.Issue.Type.Error,
+            "Task | Simulation: simulation 'simulation1' is to be used with model 'model1' which requires an NLA solver but none is provided.",
+        ],
+    ]
+
+    file = loc.File(utils.resource_path("api/sed/dae.cellml"))
+    document = loc.SedDocument()
+    model = loc.SedModel(document, file)
+    one_step = loc.SedOneStep(document)
+    task = loc.SedTask(document, model, one_step)
+
+    document.add_model(model)
+    document.add_simulation(one_step)
+    document.add_task(task)
+
+    instance = document.instantiate()
+
+    assert_issues(instance, expected_issues)
+
+
 def test_dae_model_with_failing_ode_solver():
     expected_issues = [
         [