diff --git a/docs/examples/Transformer Examples.ipynb b/docs/examples/Transformer Examples.ipynb index e2faaa244..bf9c2d652 100644 --- a/docs/examples/Transformer Examples.ipynb +++ b/docs/examples/Transformer Examples.ipynb @@ -40,7 +40,8 @@ "import numpy as np\n", "import warnings\n", "\n", - "with warnings.catch_warnings(action=\"ignore\", category=DeprecationWarning):\n", + "with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\", category=DeprecationWarning)\n", " # suppress warning about pyarrow as future required dependency\n", " import pandas as pd\n", "\n", @@ -891,15 +892,160 @@ }, { "cell_type": "markdown", - "id": "7828a4e3", + "id": "9f1a6f30", "metadata": {}, "source": [ - "**NOTE:** the tap positions obtained using the `any_valid_tap` strategy may depend on the initial tap position of the transformers." + "You could also opt for fast_any_tap that takes advantage of binary search instead of linear search internally." ] }, { "cell_type": "code", "execution_count": 12, + "id": "1fa08adb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------node result------\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idu
029999.994675
14401.932237
26346.203709
\n", + "
" + ], + "text/plain": [ + " id u\n", + "0 2 9999.994675\n", + "1 4 401.932237\n", + "2 6 346.203709" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "------tap regulator result------\n", + "\n", + "----------fast_any_tap----------\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idenergizedtap_pos
081-1
\n", + "
" + ], + "text/plain": [ + " id energized tap_pos\n", + "0 8 1 -1" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# one-time power flow calculation with automatic tap changing\n", + "output_data6f = model5.calculate_power_flow(tap_changing_strategy=TapChangingStrategy.fast_any_tap)\n", + "\n", + "# the node at the control side of the transformer now has a voltage within the specified voltage band\n", + "print(\"------node result------\")\n", + "display(pd.DataFrame(output_data6f[ComponentType.node])[[\"id\", \"u\"]])\n", + "\n", + "print(\"\\n------tap regulator result------\")\n", + "print(\"\\n----------fast_any_tap----------\")\n", + "display(pd.DataFrame(output_data6f[ComponentType.transformer_tap_regulator]))" + ] + }, + { + "cell_type": "markdown", + "id": "7828a4e3", + "metadata": {}, + "source": [ + "**NOTE:** the tap positions obtained using the `any_valid_tap` and `fast_any_tap` strategy may depend on the initial tap position of the transformers." + ] + }, + { + "cell_type": "code", + "execution_count": 13, "id": "be276930", "metadata": {}, "outputs": [ @@ -1094,7 +1240,7 @@ "\n", "# power flow batch calculation with automatic tap changing\n", "output_data = model5.calculate_power_flow(\n", - " update_data=update_data, tap_changing_strategy=TapChangingStrategy.any_valid_tap\n", + " update_data=update_data, tap_changing_strategy=TapChangingStrategy.fast_any_tap\n", ")\n", "\n", "print(\"------node_4 batch result------\")\n", @@ -1116,7 +1262,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "21b01a77", "metadata": {}, "outputs": [ @@ -1259,7 +1405,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "c0314199", "metadata": {}, "outputs": [ @@ -1412,7 +1558,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "ac091392", "metadata": {}, "outputs": [], @@ -1437,7 +1583,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "9b66d16e", "metadata": {}, "outputs": [ @@ -1585,7 +1731,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.2" + "version": "3.10.14" }, "vscode": { "interpreter": { diff --git a/docs/user_manual/calculations.md b/docs/user_manual/calculations.md index 428d8ef69..e715d3af6 100644 --- a/docs/user_manual/calculations.md +++ b/docs/user_manual/calculations.md @@ -588,12 +588,13 @@ These {hoverxreftooltip}`user_manual/components:Transformer Tap Regulator`s try The $U_{\text{control}}$ may be compensated for the voltage drop during transport. Power flow calculations that take the behavior of these regulators into account may be toggled by providing one of the following strategies to the {py:meth}`tap_changing_strategy ` option. -| Algorithm | Default | Speed | Algorithm call | -| ---------------------------------------------------------------------- | -------- | -------- | ----------------------------------------------------------------------------------------------------------- | -| No automatic tap changing (regular power flow) | ✔ | ✔ | {py:class}`TapChangingStrategy.disabled ` | -| Optimize tap positions for any value in the voltage band | | ✔ | {py:class}`TapChangingStrategy.any_valid_tap ` | -| Optimize tap positions for lowest possible voltage in the voltage band | | | {py:class}`TapChangingStrategy.min_voltage_tap ` | -| Optimize tap positions for lowest possible voltage in the voltage band | | | {py:class}`TapChangingStrategy.max_voltage_tap ` | +| Algorithm | Default | Speed | Algorithm call | +| --------------------------------------------------------------------------- | -------- | -------- | ----------------------------------------------------------------------------------------------------------- | +| No automatic tap changing (regular power flow) | ✔ | ✔ | {py:class}`TapChangingStrategy.disabled ` | +| Optimize tap positions for any value in the voltage band | | | {py:class}`TapChangingStrategy.any_valid_tap ` | +| Optimize tap positions for lowest possible voltage in the voltage band | | | {py:class}`TapChangingStrategy.min_voltage_tap ` | +| Optimize tap positions for lowest possible voltage in the voltage band | | | {py:class}`TapChangingStrategy.max_voltage_tap ` | +| Optimize tap positions for any value in the voltage band with binary search | | ✔ | {py:class}`TapChangingStrategy.fast_any_tap ` | ##### Control logic for power flow with automatic tap changing @@ -647,11 +648,21 @@ Hence, this assumption is reflected in the requirements mentioned in {hoverxreft Internally, to achieve an optimal regulated tap position, the control algorithm sets initial tap positions and exploits neighborhoods around local optima, depending on the strategy as follows. -| strategy | initial tap position | exploitation direction | description | -| ----------------------------------------------------------------------------------------------------------- | -------------------- | ---------------------- | ------------------------------------------------------------------------------------- | -| {py:class}`TapChangingStrategy.any_valid_tap ` | current tap position | no exploitation | Find any tap position that gives a control side voltage within the `u_band` | -| {py:class}`TapChangingStrategy.min_voltage_tap ` | `tap_max` | step up | Find the tap position that gives the lowest control side voltage within the `u_band` | -| {py:class}`TapChangingStrategy.max_voltage_tap ` | `tap_min` | step down | Find the tap position that gives the highest control side voltage within the `u_band` | +| strategy | initial tap position | exploitation direction | search method | description | +| ----------------------------------------------------------------------------------------------------------- | -------------------- | ---------------------- | ------------- | ------------------------------------------------------------------------------------- | +| {py:class}`TapChangingStrategy.any_valid_tap ` | current tap position | no exploitation | linear search | Find any tap position that gives a control side voltage within the `u_band` | +| {py:class}`TapChangingStrategy.min_voltage_tap ` | `tap_max` | step up | binary search | Find the tap position that gives the lowest control side voltage within the `u_band` | +| {py:class}`TapChangingStrategy.max_voltage_tap ` | `tap_min` | step down | binary search | Find the tap position that gives the highest control side voltage within the `u_band` | +| {py:class}`TapChangingStrategy.fast_any_tap ` | current tap position | no exploitation | binary search | Find any tap position that gives a control side voltage within the `u_band` | + +##### Search methods used for tap changing optimization + +Given the discrete nature of the finite tap ranges, we use the following search methods to find the next tap position along the exploitation direction. + +| Search method | Description | +| ------------- | -------------------------------------------------------------------------------------- | +| linear search | Start with an initial guess and do a local search with step size 1 for each iteration step. | +| binary search | Start with a large search region and reduce the search region by half for every iteration step. | ## Batch Calculations diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp index 1c402bf50..da783c1e8 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp @@ -25,7 +25,7 @@ using IntS = int8_t; // struct of indexing to sub modules struct Idx2D { Idx group; // sequence number of outer module/groups - Idx pos; // sequence number inside the group + Idx pos; // sequence number inside the group friend constexpr bool operator==(Idx2D x, Idx2D y) = default; }; diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/common/enum.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/common/enum.hpp index 1636c37fd..e24291164 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/common/enum.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/common/enum.hpp @@ -118,6 +118,12 @@ enum class OptimizerStrategy : IntS { // Conventions for optimization strategies global_maximum = 2, // global_maximum = argmax{f(x) \in Range} for x in Domain local_minimum = 3, // local_minimum = Any{argmin{f(x) \in Range}} for x in Domain local_maximum = 4, // local_maximum = Any{argmax{f(x) \in Range}} for x in Domain + fast_any = 5, // fast_any = Any{f(x) \in Range} for x \in Domain, but faster +}; + +enum class SearchMethod : IntS { // Which type of tap search method for finite element optimization process + linear_search = 0, // use linear_search method: one step per iteration + binary_search = 1, // use binary search: half a tap range at a time }; } // namespace power_grid_model diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/common/exception.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/common/exception.hpp index 637dd4a05..5bcb632dc 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/common/exception.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/common/exception.hpp @@ -255,4 +255,13 @@ class UnreachableHit : public PowerGridError { } }; +class TapSearchStrategyIncompatibleError : public InvalidArguments { + public: + template + TapSearchStrategyIncompatibleError(std::string const& method, const T1& value1, const T2& value2) + : InvalidArguments{ + method, std::string{typeid(T1).name()} + " #" + detail::to_string(static_cast(value1)) + " and " + + std::string{typeid(T2).name()} + " #" + detail::to_string(static_cast(value2))} {} +}; + } // namespace power_grid_model diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_fwd.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_fwd.hpp index c2b46fc8d..907bdd4f4 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_fwd.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_fwd.hpp @@ -21,7 +21,7 @@ struct MainModelOptions { CalculationSymmetry calculation_symmetry{CalculationSymmetry::symmetric}; CalculationMethod calculation_method{CalculationMethod::default_method}; OptimizerType optimizer_type{OptimizerType::no_optimization}; - OptimizerStrategy optimizer_strategy{OptimizerStrategy::any}; + OptimizerStrategy optimizer_strategy{OptimizerStrategy::fast_any}; double err_tol{1e-8}; Idx max_iter{20}; diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp index cbd9415ca..53abd63f3 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp @@ -710,7 +710,6 @@ class MainModelImpl, ComponentLis return std::ranges::all_of(update_independent, [](bool const is_independent) { return is_independent; }); } - // Single calculation template auto calculate(Options const& options) { auto const calculator = [this, &options] { if constexpr (std::derived_from) { @@ -726,10 +725,14 @@ class MainModelImpl, ComponentLis throw UnreachableHit{"MainModelImpl::calculate", "Unknown calculation type"}; }(); + SearchMethod const& search_method = options.optimizer_strategy == OptimizerStrategy::any + ? SearchMethod::linear_search + : SearchMethod::binary_search; + return optimizer::get_optimizer( options.optimizer_type, options.optimizer_strategy, calculator, [this](ConstDataset update_data) { this->update_component(update_data); }, - *meta_data_) + *meta_data_, search_method) ->optimize(state_, options.calculation_method); } diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/optimizer.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/optimizer.hpp index 00fbc38a0..de0232bde 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/optimizer.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/optimizer.hpp @@ -18,7 +18,7 @@ template && std::invocable, UpdateType> constexpr auto get_optimizer(OptimizerType optimizer_type, OptimizerStrategy strategy, StateCalculator calculator, - StateUpdater updater, meta_data::MetaData const& meta_data) { + StateUpdater updater, meta_data::MetaData const& meta_data, SearchMethod search) { using enum OptimizerType; using namespace std::string_literals; using BaseOptimizer = detail::BaseOptimizer; @@ -31,7 +31,7 @@ constexpr auto get_optimizer(OptimizerType optimizer_type, OptimizerStrategy str std::invocable, ConstDataset const&> && main_core::component_container_c) { return BaseOptimizer::template make_shared>( - std::move(calculator), std::move(updater), strategy, meta_data); + std::move(calculator), std::move(updater), strategy, meta_data, search); } [[fallthrough]]; default: diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp index aa6bfda2e..ad72863c0 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp @@ -19,7 +19,10 @@ #include +#include #include +#include +#include #include #include #include @@ -365,7 +368,6 @@ template class TransformerWrapper { return std::abs(static_cast(t.tap_max()) - static_cast(t.tap_min())); }); } - template requires(std::invocable && ...) auto apply(Func const& func) const { @@ -598,10 +600,166 @@ class TapPositionOptimizerImpl, StateCalculator, static constexpr auto transformer_index_of = container_impl::get_cls_pos_v; static_assert(((transformer_index_of < sizeof...(TransformerTypes)) && ...)); + class BinarySearch { + public: + BinarySearch() = default; + BinarySearch(IntS tap_pos, IntS tap_min, IntS tap_max) { reset(tap_pos, tap_min, tap_max); } + + constexpr IntS get_current_tap() const { return current_; } + constexpr bool get_last_down() const { return last_down_; } + constexpr bool get_inevitable_run() const { return inevitable_run_; } + constexpr bool get_end_of_bs() const { return lower_bound_ >= upper_bound_; } + + constexpr void set_current_tap(IntS current_tap) { current_ = current_tap; } + constexpr void set_last_check(bool last_check) { last_check_ = last_check; } + constexpr void set_inevitable_run(bool inevitable_run) { inevitable_run_ = inevitable_run; } + + void recalibrate(bool strategy_max) { + // This if statement checks both conditions in the corresponding transformer + // whether the tap_max and tap_min are reversed, as well as whether the optimization + // has a max strategy. + // Lower bound should be updated to the current tap position if following is the case: + // - tap_max > tap_min && strategy_max == true + // - tap_max < tap_min && strategy_max == false + // Upper bound should be updated to the current tap position if the rest is the case. + if (tap_reverse_ == strategy_max) { + lower_bound_ = current_; + last_down_ = false; + } else { + upper_bound_ = current_; + last_down_ = true; + } + } + + void propose_new_pos(bool strategy_max, bool above_range) { + bool const is_down = above_range == tap_reverse_; + if (last_check_) { + current_ = is_down ? lower_bound_ : upper_bound_; + inevitable_run_ = true; + } else { + last_down_ = is_down; + adjust(strategy_max); + } + } + + IntS repropose_tap(bool strategy_max, bool previous_down, bool& tap_changed) { + // __prefer_higher__ indicates a preference towards higher voltage + // that is a result of both the strategy as well as whether the current + // transformer has a reversed tap_max and tap_min + bool const prefer_higher = strategy_max != tap_reverse_; + auto const tap_pos = search(prefer_higher); + auto const tap_diff = tap_pos - get_current_tap(); + if (tap_diff == 0) { + if (!inevitable_run_) { + inevitable_run_ = true; + tap_changed = true; + } else { + tap_changed = false; + } + return tap_pos; + } + if ((tap_diff == 1 && previous_down) || (tap_diff == -1 && !previous_down)) { + last_check_ = true; + } + tap_changed = true; + current_ = tap_pos; + return tap_pos; + } + + private: + void reset(IntS tap_pos, IntS tap_min, IntS tap_max) { + last_down_ = false; + last_check_ = false; + current_ = tap_pos; + inevitable_run_ = false; + lower_bound_ = std::min(tap_min, tap_max); + upper_bound_ = std::max(tap_min, tap_max); + tap_reverse_ = tap_max < tap_min; + } + + void adjust(bool strategy_max = true) { + if (get_last_down()) { + upper_bound_ = current_; + } else { + lower_bound_ = current_; + } + if (lower_bound_ < upper_bound_) { + bool const prefer_higher = strategy_max != tap_reverse_; + IntS const tap_pos = search(prefer_higher); + current_ = tap_pos; + } + } + + IntS search(bool prefer_higher = true) const { + // This logic is used to determin which of the middle points could be of interest + // given strategy used in optimization: + // Since in BinarySearch we insist on absolute upper and lower bounds, we only need to + // find the corresponding mid point. std::midpoint returns always the lower mid point + // if the range is of even length. This is why we need to adjust bounds accordingly. + // Not because upper bound and lower bound might be reversed, which is not possible. + auto const primary_bound = prefer_higher ? upper_bound_ : lower_bound_; + auto const secondary_bound = prefer_higher ? lower_bound_ : upper_bound_; + return std::midpoint(primary_bound, secondary_bound); + } + + IntS lower_bound_{}; // tap position lower bound + IntS upper_bound_{}; // tap position upper bound + IntS current_{0}; // current tap position + bool last_down_{false}; // last direction + bool last_check_{false}; // last run checked + bool tap_reverse_{false}; // tap range normal or reversed + bool inevitable_run_{false}; // inevitable run + }; + std::vector> binary_search_; + struct BinarySearchOptions { + bool strategy_max{false}; + Idx2D idx_bs{0, 0}; + }; + Idx total_iterations{0}; // metric purpose only + public: TapPositionOptimizerImpl(Calculator calculator, StateUpdater updater, OptimizerStrategy strategy, - meta_data::MetaData const& meta_data) - : meta_data_{&meta_data}, calculate_{std::move(calculator)}, update_{std::move(updater)}, strategy_{strategy} {} + meta_data::MetaData const& meta_data, + std::optional tap_search = std::nullopt) + : meta_data_{&meta_data}, calculate_{std::move(calculator)}, update_{std::move(updater)}, strategy_{strategy} { + auto const is_supported = [&strategy](std::optional const& search) { + if (!search) { + return true; + } + switch (strategy) { + case OptimizerStrategy::any: + return search == SearchMethod::linear_search; + case OptimizerStrategy::fast_any: + return search == SearchMethod::binary_search; + default: + return true; + } + }; + + if (tap_search && !is_supported(tap_search)) { + throw TapSearchStrategyIncompatibleError{ + "Search method is incompatible with optimization strategy: ", strategy, tap_search.value()}; + } + + if (!tap_search) { + switch (strategy) { + case OptimizerStrategy::any: + tap_search_ = SearchMethod::linear_search; + break; + case OptimizerStrategy::fast_any: + case OptimizerStrategy::local_maximum: + case OptimizerStrategy::global_maximum: + case OptimizerStrategy::local_minimum: + case OptimizerStrategy::global_minimum: + tap_search_ = SearchMethod::binary_search; + break; + default: + throw MissingCaseForEnumError{"TapPositionOptimizer::TapPositionOptimizerImpl", strategy}; + } + } else { + tap_search_ = tap_search.value(); + } + } auto optimize(State const& state, CalculationMethod method) -> MathOutput final { auto const order = regulator_mapping(state, TransformerRanker{}(state)); @@ -618,6 +776,7 @@ class TapPositionOptimizerImpl, StateCalculator, } constexpr auto get_strategy() const { return strategy_; } + Idx get_total_iterations() const { return total_iterations; } private: void opt_prep(std::vector> const& regulator_order) { @@ -625,6 +784,8 @@ class TapPositionOptimizerImpl, StateCalculator, return a.transformer.tap_range() < b.transformer.tap_range(); }; + bs_prep(regulator_order); + if (max_tap_ranges_per_rank.empty()) { max_tap_ranges_per_rank.reserve(regulator_order.size()); for (auto const& same_rank_regulators : regulator_order) { @@ -634,19 +795,38 @@ class TapPositionOptimizerImpl, StateCalculator, ->transformer.tap_range()); } } + + total_iterations = 0; + } + + void bs_prep(std::vector> const& regulator_order) { + if (tap_search_ == SearchMethod::linear_search) { + return; + } + + binary_search_.reserve(regulator_order.size()); + for (auto const& same_rank_regulators : regulator_order) { + std::vector binary_search_group(same_rank_regulators.size()); + std::ranges::transform(same_rank_regulators, binary_search_group.begin(), [](auto const& regulator) { + return BinarySearch{regulator.transformer.tap_pos(), regulator.transformer.tap_min(), + regulator.transformer.tap_max()}; + }); + binary_search_.push_back(std::move(binary_search_group)); + } } auto optimize(State const& state, std::vector> const& regulator_order, - CalculationMethod method) const -> MathOutput { + CalculationMethod method) -> MathOutput { pilot_run(regulator_order); - if (auto result = iterate_with_fallback(state, regulator_order, method); strategy_ == OptimizerStrategy::any) { + if (auto result = iterate_with_fallback(state, regulator_order, method, tap_search_); + strategy_ == OptimizerStrategy::any || strategy_ == OptimizerStrategy::fast_any) { return produce_output(regulator_order, std::move(result)); } - // refine solution exploit_neighborhood(regulator_order); - return produce_output(regulator_order, iterate_with_fallback(state, regulator_order, method)); + return produce_output(regulator_order, + iterate_with_fallback(state, regulator_order, method, SearchMethod::linear_search)); } auto produce_output(std::vector> const& regulator_order, @@ -667,14 +847,14 @@ class TapPositionOptimizerImpl, StateCalculator, auto iterate_with_fallback(State const& state, std::vector> const& regulator_order, - CalculationMethod method) const -> ResultType { - auto fallback = [this, &state, ®ulator_order, &method] { - std::ignore = iterate(state, regulator_order, CalculationMethod::linear); - return iterate(state, regulator_order, method); + CalculationMethod method, SearchMethod search) -> ResultType { + auto fallback = [this, &state, ®ulator_order, &method, &search] { + std::ignore = iterate(state, regulator_order, CalculationMethod::linear, search); + return iterate(state, regulator_order, method, search); }; try { - return iterate(state, regulator_order, method); + return iterate(state, regulator_order, method, search); } catch (IterationDiverge const& /* ex */) { return fallback(); } catch (SparseMatrixError const& /* ex */) { @@ -683,21 +863,28 @@ class TapPositionOptimizerImpl, StateCalculator, } auto iterate(State const& state, std::vector> const& regulator_order, - CalculationMethod method) const -> ResultType { + CalculationMethod method, SearchMethod search) -> ResultType { auto result = calculate_(state, method); + ++total_iterations; std::vector iterations_per_rank(static_cast(regulator_order.size() + 1), static_cast(0)); - + bool const strategy_max = + strategy_ == OptimizerStrategy::global_maximum || strategy_ == OptimizerStrategy::local_maximum; bool tap_changed = true; + while (tap_changed) { tap_changed = false; UpdateBuffer update_data; - size_t rank_index = 0; - - for (auto const& same_rank_regulators : regulator_order) { - for (auto const& regulator : same_rank_regulators) { - tap_changed = adjust_transformer(regulator, state, result, update_data) || tap_changed; + Idx rank_index = 0; + + for (Idx i = 0; i < static_cast(regulator_order.size()); ++i) { + auto const& same_rank_regulators = regulator_order[i]; + for (Idx j = 0; j < static_cast(same_rank_regulators.size()); ++j) { + auto const& regulator = same_rank_regulators[j]; + BinarySearchOptions const options{strategy_max, Idx2D{i, j}}; + tap_changed = + adjust_transformer(regulator, state, result, update_data, search, options) || tap_changed; } if (tap_changed) { break; @@ -711,6 +898,7 @@ class TapPositionOptimizerImpl, StateCalculator, } update_state(update_data); result = calculate_(state, method); + ++total_iterations; } } @@ -718,17 +906,37 @@ class TapPositionOptimizerImpl, StateCalculator, } bool adjust_transformer(RegulatedTransformer const& regulator, State const& state, ResultType const& solver_output, - UpdateBuffer& update_data) const { + UpdateBuffer& update_data, SearchMethod search, BinarySearchOptions const& options) { + switch (search) { + case SearchMethod::binary_search: + return adjust_transformer_bs(regulator, state, solver_output, update_data, options); + case SearchMethod::linear_search: + return adjust_transformer_scan(regulator, state, solver_output, update_data); + default: + throw MissingCaseForEnumError{"TapPositionOptimizer::adjust_transformer", search}; + } + } + + template + auto compute_node_state_and_param(Regulator const& regulator, State const& state, ResultType const& solver_output) { + using sym = typename ResultType::value_type::sym; + + auto const param = regulator.regulator.get().template calc_param(); + auto const node_state = + NodeState{.u = u_pu_controlled_node(regulator, state, solver_output), + .i = i_pu_controlled_node(regulator, state, solver_output)}; + + return std::make_pair(node_state, param); + } + + bool adjust_transformer_scan(RegulatedTransformer const& regulator, State const& state, + ResultType const& solver_output, UpdateBuffer& update_data) { bool tap_changed = false; regulator.transformer.apply([&](transformer_c auto const& transformer) { using TransformerType = std::remove_cvref_t; - using sym = typename ResultType::value_type::sym; - auto const param = regulator.regulator.get().template calc_param(); - auto const node_state = - NodeState{.u = u_pu_controlled_node(regulator, state, solver_output), - .i = i_pu_controlled_node(regulator, state, solver_output)}; + auto [node_state, param] = compute_node_state_and_param(regulator, state, solver_output); auto const cmp = node_state <=> param; auto new_tap_pos = [&transformer, &cmp] { @@ -750,6 +958,53 @@ class TapPositionOptimizerImpl, StateCalculator, return tap_changed; } + bool adjust_transformer_bs(RegulatedTransformer const& regulator, State const& state, + ResultType const& solver_output, UpdateBuffer& update_data, + BinarySearchOptions const& options) { + auto const strategy_max = options.strategy_max; + bool tap_changed = false; + auto& current_bs = binary_search_[options.idx_bs.group][options.idx_bs.pos]; + + regulator.transformer.apply([&](transformer_c auto const& transformer) { // NOSONAR + using TransformerType = std::remove_cvref_t; + + auto [node_state, param] = compute_node_state_and_param(regulator, state, solver_output); + + if (current_bs.get_end_of_bs() || current_bs.get_inevitable_run()) { + tap_changed = false; + return; + } + + auto const cmp = node_state <=> param; + if (auto new_tap_pos = + [&cmp, strategy_max, ¤t_bs] { + if (cmp != 0) { // NOLINT(modernize-use-nullptr) + current_bs.propose_new_pos(strategy_max, cmp > 0); // NOLINT(modernize-use-nullptr) + } + return current_bs.get_current_tap(); + }(); + new_tap_pos != transformer.tap_pos()) { + current_bs.set_current_tap(new_tap_pos); + add_tap_pos_update(new_tap_pos, transformer, update_data); + tap_changed = true; + return; + } + + if (strategy_ == OptimizerStrategy::fast_any) { + tap_changed = false; + return; + } + + bool const previous_down = current_bs.get_last_down(); + current_bs.recalibrate(strategy_max); + + IntS const tap_pos = current_bs.repropose_tap(strategy_max, previous_down, tap_changed); + add_tap_pos_update(tap_pos, transformer, update_data); + }); + + return tap_changed; + } + void update_state(UpdateBuffer const& update_data) const { static_assert(sizeof...(TransformerTypes) == std::tuple_size_v); @@ -767,7 +1022,21 @@ class TapPositionOptimizerImpl, StateCalculator, } } - auto pilot_run(std::vector> const& regulator_order) const { + void update_binary_search(std::vector> const& regulator_order) { + for (Idx i = 0; i < static_cast(regulator_order.size()); ++i) { + auto const& sub_order = regulator_order[i]; + for (Idx j = 0; j < static_cast(sub_order.size()); ++j) { + auto const& regulator = sub_order[j]; + if (i < static_cast(binary_search_.size()) && j < static_cast(binary_search_[i].size())) { + binary_search_[i][j].set_current_tap(regulator.transformer.tap_pos()); + binary_search_[i][j].set_last_check(false); + binary_search_[i][j].set_inevitable_run(false); + } + } + } + } + + auto pilot_run(std::vector> const& regulator_order) { using namespace std::string_literals; constexpr auto max_voltage_pos = [](transformer_c auto const& transformer) -> IntS { @@ -780,6 +1049,8 @@ class TapPositionOptimizerImpl, StateCalculator, }; switch (strategy_) { + case OptimizerStrategy::fast_any: + [[fallthrough]]; case OptimizerStrategy::any: break; case OptimizerStrategy::global_maximum: @@ -795,9 +1066,12 @@ class TapPositionOptimizerImpl, StateCalculator, default: throw MissingCaseForEnumError{"TapPositionOptimizer::pilot_run"s, strategy_}; } + if (tap_search_ == SearchMethod::binary_search) { + update_binary_search(regulator_order); + } } - void exploit_neighborhood(std::vector> const& regulator_order) const { + void exploit_neighborhood(std::vector> const& regulator_order) { using namespace std::string_literals; constexpr auto one_step_up = [](transformer_c auto const& transformer) -> IntS { @@ -808,6 +1082,8 @@ class TapPositionOptimizerImpl, StateCalculator, }; switch (strategy_) { + case OptimizerStrategy::fast_any: + [[fallthrough]]; case OptimizerStrategy::any: break; case OptimizerStrategy::global_maximum: @@ -836,13 +1112,13 @@ class TapPositionOptimizerImpl, StateCalculator, requires((std::invocable && std::same_as, IntS>) && ...) - auto regulate_transformers(Func new_tap_pos, + auto regulate_transformers(Func to_new_tap_pos, std::vector> const& regulator_order) const { UpdateBuffer update_data; - auto const get_update = [new_tap_pos = std::move(new_tap_pos), + auto const get_update = [to_new_tap_pos_func = std::move(to_new_tap_pos), &update_data](transformer_c auto const& transformer) { - add_tap_pos_update(new_tap_pos(transformer), transformer, update_data); + add_tap_pos_update(to_new_tap_pos_func(transformer), transformer, update_data); }; for (auto const& sub_order : regulator_order) { @@ -908,6 +1184,7 @@ class TapPositionOptimizerImpl, StateCalculator, Calculator calculate_; StateUpdater update_; OptimizerStrategy strategy_; + SearchMethod tap_search_; }; template { - stub_steady_state_state_calculator, stub_const_dataset_update, strategy_method.strategy, - meta_data}; - auto res = optimizer.optimize(empty_state, strategy_method.method); - CHECK(optimizer.optimize(empty_state, strategy_method.method).solver_output.empty()); + stub_steady_state_state_calculator, stub_const_dataset_update, strategy, meta_data, + search}; + auto res = optimizer.optimize(empty_state, method); + CHECK(optimizer.optimize(empty_state, method).solver_output.empty()); } } SUBCASE("asymmetric") { - for (auto strategy_method : strategies_and_methods) { - CAPTURE(strategy_method.strategy); - CAPTURE(strategy_method.method); + for (auto strategy_method_search : strategy_method_and_searches) { + auto strategy = strategy_method_search.strategy; + auto method = strategy_method_search.method; + auto search = strategy_method_search.search; + CAPTURE(strategy); + CAPTURE(method); + CAPTURE(search); auto optimizer = TapPositionOptimizer{ - stub_steady_state_state_calculator, stub_const_dataset_update, strategy_method.strategy, - meta_data}; - CHECK(optimizer.optimize(empty_state, strategy_method.method).solver_output.empty()); + stub_steady_state_state_calculator, stub_const_dataset_update, strategy, meta_data, + search}; + CHECK(optimizer.optimize(empty_state, method).solver_output.empty()); } } } @@ -61,8 +70,9 @@ TEST_CASE("Test get optimizer") { for (auto strategy_method : strategies_and_methods) { CAPTURE(strategy_method.strategy); CAPTURE(strategy_method.method); - auto optimizer = get_optimizer( - no_optimization, strategy_method.strategy, mock_state_calculator, stub_update, meta_data); + auto optimizer = get_optimizer(no_optimization, strategy_method.strategy, + mock_state_calculator, stub_update, meta_data, + SearchMethod::binary_search); CHECK(optimizer->optimize(empty_state, strategy_method.method).solver_output.x == 1); } } @@ -70,18 +80,20 @@ TEST_CASE("Test get optimizer") { SUBCASE("Not implemented type") { for (auto strategy : strategies) { CAPTURE(strategy); - CHECK_THROWS_AS((get_optimizer( - automatic_tap_adjustment, strategy, mock_state_calculator, stub_update, meta_data)), - MissingCaseForEnumError); + CHECK_THROWS_AS( + (get_optimizer(automatic_tap_adjustment, strategy, mock_state_calculator, + stub_update, meta_data, SearchMethod::binary_search)), + MissingCaseForEnumError); } } } SUBCASE("Symmetric state calculator") { - auto const get_instance = [](OptimizerType optimizer_type, OptimizerStrategy strategy) { + auto const get_instance = [](OptimizerType optimizer_type, OptimizerStrategy strategy, + SearchMethod search = SearchMethod::binary_search) { return get_optimizer(optimizer_type, strategy, stub_steady_state_state_calculator, - stub_const_dataset_update, meta_data); + stub_const_dataset_update, meta_data, search); }; SUBCASE("Noop") { @@ -93,19 +105,25 @@ TEST_CASE("Test get optimizer") { } } SUBCASE("Automatic tap adjustment") { - for (auto strategy_method : strategies_and_methods) { - CAPTURE(strategy_method.strategy); - CAPTURE(strategy_method.method); - auto optimizer = get_instance(automatic_tap_adjustment, strategy_method.strategy); + + for (auto strategy_method_search : strategy_method_and_searches) { + auto strategy = strategy_method_search.strategy; + auto method = strategy_method_search.method; + auto search = strategy_method_search.search; + CAPTURE(strategy); + CAPTURE(method); + CAPTURE(search); + + auto optimizer = get_instance(automatic_tap_adjustment, strategy, search); auto tap_optimizer = std::dynamic_pointer_cast< TapPositionOptimizer>(optimizer); REQUIRE(tap_optimizer != nullptr); - CHECK(tap_optimizer->get_strategy() == strategy_method.strategy); + CHECK(tap_optimizer->get_strategy() == strategy); StubState empty_state{}; empty_state.components.set_construction_complete(); - CHECK(optimizer->optimize(empty_state, strategy_method.method).solver_output.empty()); + CHECK(optimizer->optimize(empty_state, method).solver_output.empty()); } } } diff --git a/tests/cpp_unit_tests/test_optimizer.hpp b/tests/cpp_unit_tests/test_optimizer.hpp index 7869c7281..01404ede8 100644 --- a/tests/cpp_unit_tests/test_optimizer.hpp +++ b/tests/cpp_unit_tests/test_optimizer.hpp @@ -150,6 +150,8 @@ constexpr auto calculation_methods = [] { iterative_current, newton_raphson, iec60909}; }(); +constexpr auto tap_sides = [] { return std::array{ControlSide::side_1, ControlSide::side_2, ControlSide::side_3}; }(); + struct OptimizerStrategyMethod { OptimizerStrategy strategy{}; CalculationMethod method{}; @@ -160,11 +162,79 @@ constexpr auto strategies_and_methods = [] { size_t idx{}; for (auto strategy : strategies) { for (auto method : calculation_methods) { - result[idx++] = {strategy, method}; + result[idx++] = {strategy, method}; // NOSONAR {no more than one thing per line} + } + } + return result; +}(); + +struct OptimizerStrategySide { + OptimizerStrategy strategy{}; + ControlSide side{}; +}; + +constexpr auto strategies_and_sides = [] { + std::array result; + size_t idx{}; + for (auto strategy : strategies) { + for (auto side : tap_sides) { + result[idx++] = {strategy, side}; // NOSONAR {no more than one thing per line} + } + } + return result; +}(); + +struct OptimizerStrategySearchSide { + OptimizerStrategy strategy{}; + SearchMethod search{}; + ControlSide side{}; +}; + +constexpr auto search_methods = [] { return std::array{SearchMethod::linear_search, SearchMethod::binary_search}; }(); + +constexpr auto strategy_search_and_sides = [] { + // regular any strategy is only used in combination with linear_search search + size_t const options_size = strategies.size() * tap_sides.size() * search_methods.size() - search_methods.size(); + std::array result; + size_t idx{}; + for (auto strategy : strategies) { + for (auto search : search_methods) { + if (strategy == OptimizerStrategy::any && search == SearchMethod::binary_search) { + continue; + } + for (auto side : tap_sides) { + result[idx++] = {strategy, search, side}; // NOSONAR (no-more-than-one-thing-per-line) + } } } return result; }(); + +struct OptStrategyMethodSearch { + OptimizerStrategy strategy{}; + CalculationMethod method{}; + SearchMethod search{}; +}; + +constexpr auto strategy_method_and_searches = [] { + // regular any strategy is only used in combination with linear_search search + size_t const options_size = + strategies.size() * calculation_methods.size() * search_methods.size() - search_methods.size(); + std::array result; + size_t idx{}; + for (auto strategy : strategies) { + for (auto search : search_methods) { + if (strategy == OptimizerStrategy::any && search == SearchMethod::binary_search) { + continue; + } + for (auto method : calculation_methods) { + result[idx++] = {strategy, method, search}; // NOSONAR (no-more-than-one-thing-per-line) + } + } + } + return result; +}(); + } // namespace optimizer::test namespace meta_data { diff --git a/tests/cpp_unit_tests/test_tap_position_optimizer.cpp b/tests/cpp_unit_tests/test_tap_position_optimizer.cpp index dce324d37..11f4ff0a6 100644 --- a/tests/cpp_unit_tests/test_tap_position_optimizer.cpp +++ b/tests/cpp_unit_tests/test_tap_position_optimizer.cpp @@ -339,8 +339,12 @@ TEST_CASE("Test Transformer ranking") { namespace optimizer::tap_position_optimizer::test { namespace { using power_grid_model::optimizer::test::ConstDatasetUpdate; +using power_grid_model::optimizer::test::OptStrategyMethodSearch; +using power_grid_model::optimizer::test::search_methods; using power_grid_model::optimizer::test::strategies; using power_grid_model::optimizer::test::strategies_and_methods; +using power_grid_model::optimizer::test::strategies_and_sides; +using power_grid_model::optimizer::test::strategy_search_and_sides; using power_grid_model::optimizer::test::StubTransformer; using power_grid_model::optimizer::test::StubTransformerInput; using power_grid_model::optimizer::test::StubTransformerUpdate; @@ -639,13 +643,24 @@ TEST_CASE("Test Tap position optimizer") { using MockStateCalculator = test::MockStateCalculator; using MockTransformerRanker = test::MockTransformerRanker; - constexpr auto tap_sides = std::array{ControlSide::side_1, ControlSide::side_2, ControlSide::side_3}; auto const& meta_data = meta_gen::get_meta_data, meta_gen::dataset_mark<[] { return "update"; }, meta_data::update_getter_s>>::value; MockState state; + auto strategy_method_searches = [&] { + std::array + result; + size_t idx{}; + for (auto strategy_method : test::strategies_and_methods) { + for (auto search_method : test::search_methods) { + result[idx++] = {strategy_method.strategy, strategy_method.method, search_method}; // NOSONAR + } + } + return result; + }(); + auto const updater = [&state](ConstDataset const& update_dataset) { REQUIRE(!update_dataset.empty()); REQUIRE(update_dataset.n_components() == 1); @@ -677,14 +692,14 @@ TEST_CASE("Test Tap position optimizer") { return true; }; - auto const get_optimizer = [&](OptimizerStrategy strategy) { + auto const get_optimizer = [&](OptimizerStrategy strategy, SearchMethod tap_search) { return pgm_tap::TapPositionOptimizer{ - test::mock_state_calculator, updater, strategy, meta_data}; + test::mock_state_calculator, updater, strategy, meta_data, tap_search}; }; SUBCASE("empty state") { state.components.set_construction_complete(); - auto optimizer = get_optimizer(OptimizerStrategy::any); + auto optimizer = get_optimizer(OptimizerStrategy::any, SearchMethod::linear_search); auto result = optimizer.optimize(state, CalculationMethod::default_method); CHECK(result.solver_output.size() == 1); CHECK(result.solver_output[0].method == CalculationMethod::default_method); @@ -697,15 +712,24 @@ TEST_CASE("Test Tap position optimizer") { state, 2, MockTransformerState{.id = 2, .math_id = {.group = 0, .pos = 1}}); state.components.set_construction_complete(); - for (auto strategy_method : test::strategies_and_methods) { - CAPTURE(strategy_method.strategy); - CAPTURE(strategy_method.method); + for (auto strategy_method_search : strategy_method_searches) { + auto strategy = strategy_method_search.strategy; + auto method = strategy_method_search.method; + auto search = strategy_method_search.search; + CAPTURE(strategy); + CAPTURE(method); + CAPTURE(search); - auto optimizer = get_optimizer(strategy_method.strategy); - auto result = optimizer.optimize(state, strategy_method.method); + if (strategy == OptimizerStrategy::any && search == SearchMethod::binary_search) { + CHECK_THROWS_AS(get_optimizer(strategy, search), TapSearchStrategyIncompatibleError); - CHECK(result.solver_output.size() == 1); - CHECK(result.solver_output[0].method == strategy_method.method); + } else { + auto optimizer = get_optimizer(strategy, search); + auto result = optimizer.optimize(state, method); + + CHECK(result.solver_output.size() == 1); + CHECK(result.solver_output[0].method == method); + } } } @@ -810,7 +834,6 @@ TEST_CASE("Test Tap position optimizer") { FAIL("unreachable"); } }; - SUBCASE("normal tap range") { state_b.tap_min = 1; state_b.tap_max = 3; @@ -998,52 +1021,53 @@ TEST_CASE("Test Tap position optimizer") { auto const initial_a{transformer_a.tap_pos()}; auto const initial_b{transformer_b.tap_pos()}; - for (auto strategy : test::strategies) { + for (auto strategy_search_side : test::strategy_search_and_sides) { + auto strategy = strategy_search_side.strategy; + auto search = strategy_search_side.search; + auto tap_side = strategy_search_side.side; CAPTURE(strategy); + CAPTURE(search); + CAPTURE(tap_side); - for (auto tap_side : tap_sides) { - CAPTURE(tap_side); + state_b.tap_side = tap_side; + state_a.tap_side = tap_side; - state_b.tap_side = tap_side; - state_a.tap_side = tap_side; + auto optimizer = get_optimizer(strategy, search); + auto const result = optimizer.optimize(state, CalculationMethod::default_method); - auto optimizer = get_optimizer(strategy); - auto const result = optimizer.optimize(state, CalculationMethod::default_method); - - auto const get_state_tap_pos = [&](const ID id) { - REQUIRE(!result.solver_output.empty()); - return result.solver_output.front().state_tap_positions.at(id); - }; - auto const get_output_tap_pos = [&](const ID id) { - REQUIRE(!result.optimizer_output.transformer_tap_positions.empty()); - auto const it = std::ranges::find_if(result.optimizer_output.transformer_tap_positions, - [id](auto const& x) { return x.transformer_id == id; }); - REQUIRE(it != std::end(result.optimizer_output.transformer_tap_positions)); - CHECK(it->transformer_id == id); - return it->tap_position; - }; - - // check optimal state - CHECK(result.solver_output.size() == 1); - check_a(get_state_tap_pos(state_a.id), strategy); - check_b(get_state_tap_pos(state_b.id), strategy); + auto const get_state_tap_pos = [&](ID const id) { + REQUIRE(!result.solver_output.empty()); + return result.solver_output.front().state_tap_positions.at(id); + }; + auto const get_output_tap_pos = [&](ID const id) { + REQUIRE(!result.optimizer_output.transformer_tap_positions.empty()); + auto const it = std::ranges::find_if(result.optimizer_output.transformer_tap_positions, + [id](auto const& x) { return x.transformer_id == id; }); + REQUIRE(it != std::end(result.optimizer_output.transformer_tap_positions)); + CHECK(it->transformer_id == id); + return it->tap_position; + }; - // check optimal output - if (state_a.rank != MockTransformerState::unregulated) { - check_a(get_output_tap_pos(state_a.id), strategy); - } - if (state_b.rank != MockTransformerState::unregulated) { - check_b(get_output_tap_pos(state_b.id), strategy); - } + // check optimal state + CHECK(result.solver_output.size() == 1); + check_a(get_state_tap_pos(state_a.id), strategy); + check_b(get_state_tap_pos(state_b.id), strategy); - // reset - CHECK(transformer_a.tap_pos() == initial_a); - CHECK(transformer_b.tap_pos() == initial_b); + // check optimal output + if (state_a.rank != MockTransformerState::unregulated) { + check_a(get_output_tap_pos(state_a.id), strategy); + } + if (state_b.rank != MockTransformerState::unregulated) { + check_b(get_output_tap_pos(state_b.id), strategy); } + + // reset + CHECK(transformer_a.tap_pos() == initial_a); + CHECK(transformer_b.tap_pos() == initial_b); } } - SUBCASE("Check throw as MaxIterationReached") { + SUBCASE("Check throw as MaxIterationReached") { // This only applies to non-binary search state_b.rank = 0; state_b.u_pu = [&state_b, ®ulator_b](ControlSide side) { CHECK(side == regulator_b.control_side()); @@ -1055,27 +1079,26 @@ TEST_CASE("Test Tap position optimizer") { auto update_data = TransformerTapRegulatorUpdate{.id = 4, .u_set = 0.4, .u_band = 0.0}; - // tap pos will jump between 3 and 4 + // tap pos will jump between 3 and 4 in linear_search method state_b.tap_min = 1; state_b.tap_max = 5; state_b.tap_pos = 5; regulator_b.update(update_data); - for (auto strategy : test::strategies) { + for (auto strategy_side : test::strategies_and_sides) { + auto strategy = strategy_side.strategy; + auto tap_side = strategy_side.side; CAPTURE(strategy); + CAPTURE(tap_side); - for (auto tap_side : tap_sides) { - CAPTURE(tap_side); + state_b.tap_side = tap_side; + state_a.tap_side = tap_side; - state_b.tap_side = tap_side; - state_a.tap_side = tap_side; - - auto optimizer = get_optimizer(strategy); - auto const cached_state = state; // NOSONAR - CHECK_THROWS_AS(optimizer.optimize(state, CalculationMethod::default_method), MaxIterationReached); - CHECK(twoStatesEqual(cached_state, state)); - } + auto optimizer = get_optimizer(strategy, SearchMethod::linear_search); + auto const cached_state = state; // NOSONAR + CHECK_THROWS_AS(optimizer.optimize(state, CalculationMethod::default_method), MaxIterationReached); + CHECK(twoStatesEqual(cached_state, state)); } } } diff --git a/tests/cpp_validation_tests/test_validation.cpp b/tests/cpp_validation_tests/test_validation.cpp index 40c9d3205..d8ab6d576 100644 --- a/tests/cpp_validation_tests/test_validation.cpp +++ b/tests/cpp_validation_tests/test_validation.cpp @@ -303,7 +303,11 @@ std::map> const optimizer_strategy_m {"disabled", OptimizerStrategy::any}, {"any_valid_tap", OptimizerStrategy::any}, {"min_voltage_tap", OptimizerStrategy::global_minimum}, - {"max_voltage_tap", OptimizerStrategy::global_maximum}}; + {"max_voltage_tap", OptimizerStrategy::global_maximum}, + {"fast_any_tap", OptimizerStrategy::fast_any}}; + +std::map> const optimizer_search_mapping = { + {"linear_search", SearchMethod::linear_search}, {"binary_search", SearchMethod::binary_search}}; // case parameters struct CaseParam { @@ -313,6 +317,7 @@ struct CaseParam { std::string calculation_method; std::string short_circuit_voltage_scaling; std::string tap_changing_strategy; + std::string search_method; bool sym{}; bool is_batch{}; double rtol{}; @@ -347,6 +352,7 @@ CalculationFunc calculation_func(CaseParam const& param) { ? OptimizerType::no_optimization : OptimizerType::automatic_tap_adjustment; options.optimizer_strategy = optimizer_strategy_mapping.at(param.tap_changing_strategy); + if (param.sym) { return model.calculate_power_flow(options, dataset, update_dataset); } @@ -435,6 +441,7 @@ std::optional construct_case(std::filesystem::path const& case_dir, j } param.tap_changing_strategy = calculation_method_params.value("tap_changing_strategy", "disabled"); + param.search_method = calculation_method_params.value("search_method", "binary_search"); param.case_name += sym ? "-sym"s : "-asym"s; param.case_name += "-"s + param.calculation_method; param.case_name += is_batch ? "_batch"s : ""s; @@ -628,6 +635,7 @@ TEST_CASE("Validation test single") { TEST_CASE("Validation test batch") { std::vector const& all_cases = get_all_batch_cases(); + for (CaseParam const& param : all_cases) { SUBCASE(param.case_name.c_str()) { try { diff --git a/tests/unit/test_0Z_model_validation.py b/tests/unit/test_0Z_model_validation.py index 74e3279ab..2b76a0608 100644 --- a/tests/unit/test_0Z_model_validation.py +++ b/tests/unit/test_0Z_model_validation.py @@ -175,13 +175,23 @@ def test_batch_validation( for update_data, reference_result in zip(update_list, reference_output_list): model_copy = copy(model) model_copy.update(update_data=update_data) - result = calculation_function(model_copy, **supported_kwargs(kwargs=base_kwargs, supported=calculation_args)) - compare_result(result, reference_result, rtol, atol) + try: + result = calculation_function( + model_copy, **supported_kwargs(kwargs=base_kwargs, supported=calculation_args) + ) + except Exception as e: + print(f"An error occurred during calculation: {e}") + else: + compare_result(result, reference_result, rtol, atol) # execute in batch one go for threading in [-1, 0, 1, 2]: kwargs = dict(base_kwargs, update_data=update_batch, threading=threading) - result_batch = calculation_function(model, **supported_kwargs(kwargs=kwargs, supported=calculation_args)) - result_list = convert_batch_dataset_to_batch_list(result_batch) - for result, reference_result in zip(result_list, reference_output_list): - compare_result(result, reference_result, rtol, atol) + try: + result_batch = calculation_function(model, **supported_kwargs(kwargs=kwargs, supported=calculation_args)) + except Exception as e: + print(f"An error occurred during calculation: {e}") + else: + result_list = convert_batch_dataset_to_batch_list(result_batch) + for result, reference_result in zip(result_list, reference_output_list): + compare_result(result, reference_result, rtol, atol) diff --git a/tests/unit/test_error_handling.py b/tests/unit/test_error_handling.py index 2b9732120..730ddf865 100644 --- a/tests/unit/test_error_handling.py +++ b/tests/unit/test_error_handling.py @@ -30,6 +30,7 @@ IterationDiverge, MissingCaseForEnumError, NotObservableError, + TapSearchStrategyIncompatibleError, ) from .utils import PowerGridModelWithExt @@ -334,7 +335,7 @@ def test_transformer_tap_regulator_at_lv_tap_side(): def test_automatic_tap_changing(): model = PowerGridModel(input_data={}) - model.calculate_power_flow(tap_changing_strategy=TapChangingStrategy.any_valid_tap) + model.calculate_power_flow(tap_changing_strategy=TapChangingStrategy.min_voltage_tap) @pytest.mark.skip(reason="TODO")