Skip to content

Commit

Permalink
[ANT-2608] add of unit tests for time dependant expression (#2597)
Browse files Browse the repository at this point in the history 
Co-authored-by: Florian OMNES <[email protected]>
  • Loading branch information
@a-zakir @flomnes
a-zakir and flomnes authored Jan 28, 2025
1 parent e62801c commit c5b5123
Showing 1 changed file with 124 additions and 6 deletions.
130 changes: 124 additions & 6 deletions src/tests/src/solver/optim-model-filler/test_componentFiller.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -75,11 +75,12 @@ struct LinearProblemBuildingFixture
Node* lb,
Node* ub,
const vector<ConstraintData>& constraintsData,
Node* objective = nullptr)
Node* objective = nullptr,
bool time_dependent = false)
{
createModel(modelId,
parameterIds,
{{varId, ValueType::FLOAT, lb, ub, false, false}},
{{varId, ValueType::FLOAT, lb, ub, time_dependent, false}},
constraintsData,
objective);
}
Expand Down Expand Up @@ -117,7 +118,13 @@ struct LinearProblemBuildingFixture
return nodes.create<NegationNode>(node);
}

void buildLinearProblem();
void buildLinearProblem(FillContext& time_scenario_ctx);

void buildLinearProblem()
{
FillContext time_scenario_ctx = {0, 0};
buildLinearProblem(time_scenario_ctx);
}
};

void LinearProblemBuildingFixture::createModel(string modelId,
Expand Down Expand Up @@ -180,7 +187,7 @@ void LinearProblemBuildingFixture::createComponent(const string& modelId,
components.push_back(move(component));
}

void LinearProblemBuildingFixture::buildLinearProblem()
void LinearProblemBuildingFixture::buildLinearProblem(FillContext& time_scenario_ctx)
{
vector<unique_ptr<ComponentFiller>> fillers;
vector<LinearProblemFiller*> fillers_ptr;
Expand All @@ -196,8 +203,8 @@ void LinearProblemBuildingFixture::buildLinearProblem()
pb = make_unique<Antares::Solver::Modeler::OrtoolsImpl::OrtoolsLinearProblem>(false, "sirius");
LinearProblemBuilder linear_problem_builder(fillers_ptr);
LinearProblemData dummy_data;
FillContext dummy_time_scenario_ctx = {0, 0};
linear_problem_builder.build(*pb.get(), dummy_data, dummy_time_scenario_ctx);

linear_problem_builder.build(*pb, dummy_data, time_scenario_ctx);
}

BOOST_FIXTURE_TEST_SUITE(_ComponentFiller_addVariables_, LinearProblemBuildingFixture)
Expand All @@ -218,6 +225,34 @@ BOOST_AUTO_TEST_CASE(var_with_literal_bounds_to_filler__problem_contains_one_var
BOOST_CHECK_EQUAL(pb->getObjectiveCoefficient(var), 0);
}

BOOST_AUTO_TEST_CASE(ten_timesteps_var_with_literal_bounds_to_filler__problem_contains_ten_vars)
{
createModelWithOneFloatVar("some_model",
{},
"var1",
literal(-5),
literal(10),
{},
nullptr,
true);
createComponent("some_model", "some_component");
constexpr unsigned int last_time_step = 9;
FillContext ctx{0, last_time_step};
buildLinearProblem(ctx);
const auto nb_var = ctx.getNumberOfTimestep(); // = 10
BOOST_CHECK_EQUAL(pb->variableCount(), nb_var);
BOOST_CHECK_EQUAL(pb->constraintCount(), 0);
for (unsigned int i = 0; i < nb_var; i++)
{
auto* var = pb->getVariable("some_component.var1_" + to_string(i));
BOOST_REQUIRE(var);
BOOST_CHECK_EQUAL(var->getLb(), -5);
BOOST_CHECK_EQUAL(var->getUb(), 10);
BOOST_CHECK(!var->isInteger());
BOOST_CHECK_EQUAL(pb->getObjectiveCoefficient(var), 0);
}
}

BOOST_AUTO_TEST_CASE(var_with_wrong_parameter_lb__exception_is_raised)
{
createModel("my-model",
Expand Down Expand Up @@ -263,6 +298,35 @@ BOOST_AUTO_TEST_CASE(two_variables_given_to_different_fillers__LP_contains_the_t
BOOST_CHECK_EQUAL(var2->getUb(), 2.);
}

BOOST_AUTO_TEST_CASE(
two_times_10_variables_given_to_different_fillers__LP_contains_the_two_variables)
{
createModelWithOneFloatVar("m1", {}, "var1", literal(-1), literal(6), {}, nullptr, true);
createModelWithOneFloatVar("m2", {}, "var2", literal(-3), literal(2), {}, nullptr, true);
createComponent("m1", "component_1");
createComponent("m2", "component_2");
constexpr unsigned int last_time_step = 9;
FillContext ctx{0, last_time_step};
buildLinearProblem(ctx);
const auto nb_var = ctx.getNumberOfTimestep(); // = 10

BOOST_CHECK_EQUAL(pb->variableCount(), 2 * 10);
for (auto i = 0; i < nb_var; i++)
{
auto* var1 = pb->getVariable("component_1.var1_" + to_string(i));
BOOST_REQUIRE(var1);
BOOST_CHECK(!var1->isInteger());
BOOST_CHECK_EQUAL(var1->getLb(), -1.);
BOOST_CHECK_EQUAL(var1->getUb(), 6.);

auto* var2 = pb->getVariable("component_2.var2_" + to_string(i));
BOOST_REQUIRE(var2);
BOOST_CHECK(!var2->isInteger());
BOOST_CHECK_EQUAL(var2->getLb(), -3.);
BOOST_CHECK_EQUAL(var2->getUb(), 2.);
}
}

BOOST_AUTO_TEST_CASE(var_whose_bounds_are_parameters_given_to_component__problem_contains_this_var)
{
createModel("model",
Expand Down Expand Up @@ -372,6 +436,39 @@ BOOST_AUTO_TEST_CASE(ct_one_var__pb_contains_the_ct)
BOOST_CHECK_EQUAL(ct->getCoefficient(var), 1);
}

BOOST_AUTO_TEST_CASE(ct_with_ten_vars__pb_contains_ten_ct)
{
// var1 <= 3
auto var_node = variable("var1", Antares::Solver::Visitors::TimeIndex::VARYING_IN_TIME_ONLY);
auto three = literal(3);
auto ct_node = nodes.create<LessThanOrEqualNode>(var_node, three);

createModel("model",
{},
{{"var1", ValueType::BOOL, literal(-5), literal(10), true, false}},
{{"ct1", ct_node}});
createComponent("model", "componentToto");
constexpr unsigned int last_time_step = 9;
FillContext ctx{0, last_time_step};
buildLinearProblem(ctx);
const auto nb_var = ctx.getNumberOfTimestep(); // = 10

BOOST_CHECK_EQUAL(pb->variableCount(), 10);
BOOST_CHECK_EQUAL(pb->constraintCount(), 10);

for (auto i = 0; i < nb_var; i++)
{
auto ct = pb->getConstraint("componentToto.ct1_" + to_string(i));
BOOST_REQUIRE(ct);
BOOST_CHECK_EQUAL(ct->getLb(), -pb->infinity());
BOOST_CHECK_EQUAL(ct->getUb(), 3);
auto var = pb->getVariable("componentToto.var1_" + to_string(i));
BOOST_REQUIRE(var);
BOOST_CHECK(var->isInteger());
BOOST_CHECK_EQUAL(ct->getCoefficient(var), 1);
}
}

BOOST_AUTO_TEST_CASE(ct_one_var_with_coef__pb_contains_the_ct)
{
// 3 * var1 >= 5 * var1 + 5
Expand Down Expand Up @@ -512,6 +609,27 @@ BOOST_AUTO_TEST_CASE(one_var_with_objective)
BOOST_CHECK_EQUAL(pb->getObjectiveCoefficient(pb->getVariable("componentA.x")), 1);
}

BOOST_AUTO_TEST_CASE(one_time_dependent_var_with_objective)
{
auto objective = variable("x", Antares::Solver::Visitors::TimeIndex::VARYING_IN_TIME_ONLY);

createModelWithOneFloatVar("model", {}, "x", literal(-50), literal(-40), {}, objective, true);
createComponent("model", "componentA", {});

constexpr unsigned int last_time_step = 9;
FillContext ctx{0, last_time_step};
buildLinearProblem(ctx);
const auto nb_var = ctx.getNumberOfTimestep(); // = 10

BOOST_CHECK_EQUAL(pb->variableCount(), nb_var);
for (auto i = 0; i < nb_var; i++)
{
const auto var_name = "componentA.x_" + to_string(i);
BOOST_CHECK_NO_THROW(pb->getVariable(var_name));
BOOST_CHECK_EQUAL(pb->getObjectiveCoefficient(pb->getVariable(var_name)), 1);
}
}

BOOST_AUTO_TEST_CASE(two_vars_but_only_one_in_objective)
{
VariableData var1Data = {"v1", ValueType::FLOAT, literal(-50.), literal(300.), false, false};
Expand Down

0 comments on commit c5b5123

Please sign in to comment.