diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/calculation_parameters.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/calculation_parameters.hpp index e93a4e1f99..4dd947925b 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/calculation_parameters.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/calculation_parameters.hpp @@ -35,7 +35,7 @@ template struct BranchCalcParam { ComplexTensor const& ytt() const { return value[3]; } }; -template struct BranchMathOutput { +template struct BranchSolverOutput { using sym = sym_type; ComplexValue s_f{}; @@ -44,7 +44,7 @@ template struct BranchMathOutput { ComplexValue i_t{}; }; -template struct BranchShortCircuitMathOutput { +template struct BranchShortCircuitSolverOutput { using sym = sym_type; ComplexValue i_f{}; @@ -58,7 +58,7 @@ struct FaultCalcParam { FaultPhase fault_phase{}; }; -template struct FaultShortCircuitMathOutput { +template struct FaultShortCircuitSolverOutput { using sym = sym_type; ComplexValue i_fault{}; @@ -66,13 +66,13 @@ template struct FaultShortCircuitMathOutput { // appliance math output, always injection direction // s > 0, energy appliance -> node -template struct ApplianceMathOutput { +template struct ApplianceSolverOutput { using sym = sym_type; ComplexValue s{}; ComplexValue i{}; }; -template struct ApplianceShortCircuitMathOutput { +template struct ApplianceShortCircuitSolverOutput { using sym = sym_type; ComplexValue i{}; @@ -125,7 +125,7 @@ struct TransformerTapRegulatorCalcParam { DoubleComplex z_compensation{}; IntS status{}; }; -template struct TransformerTapRegulatorMathOutput { +template struct TransformerTapRegulatorOptimizerOutput { using sym = sym_type; IntS tap_pos{na_IntS}; @@ -258,72 +258,72 @@ static_assert(calculation_input_type>); static_assert(calculation_input_type>); static_assert(calculation_input_type); -struct math_output_t {}; +struct solver_output_t {}; -template struct MathOutput { - using type = math_output_t; +template struct SolverOutput { + using type = solver_output_t; using sym = sym_type; std::vector> u; std::vector> bus_injection; - std::vector> branch; - std::vector> source; - std::vector> shunt; - std::vector> load_gen; - std::vector> transformer_tap_regulator; + std::vector> branch; + std::vector> source; + std::vector> shunt; + std::vector> load_gen; + std::vector> transformer_tap_regulator; }; -template struct ShortCircuitMathOutput { - using type = math_output_t; +template struct ShortCircuitSolverOutput { + using type = solver_output_t; using sym = sym_type; std::vector> u_bus; - std::vector> fault; - std::vector> branch; - std::vector> source; - std::vector> shunt; + std::vector> fault; + std::vector> branch; + std::vector> source; + std::vector> shunt; }; template -concept math_output_type = std::derived_from; +concept solver_output_type = std::derived_from; -static_assert(math_output_type>); -static_assert(math_output_type>); -static_assert(math_output_type>); -static_assert(math_output_type>); +static_assert(solver_output_type>); +static_assert(solver_output_type>); +static_assert(solver_output_type>); +static_assert(solver_output_type>); template -concept symmetric_math_output_type = math_output_type && is_symmetric_v; +concept symmetric_solver_output_type = solver_output_type && is_symmetric_v; -static_assert(symmetric_math_output_type>); -static_assert(!symmetric_math_output_type>); -static_assert(symmetric_math_output_type>); -static_assert(!symmetric_math_output_type>); +static_assert(symmetric_solver_output_type>); +static_assert(!symmetric_solver_output_type>); +static_assert(symmetric_solver_output_type>); +static_assert(!symmetric_solver_output_type>); template -concept asymmetric_math_output_type = math_output_type && is_asymmetric_v; +concept asymmetric_solver_output_type = solver_output_type && is_asymmetric_v; -static_assert(!asymmetric_math_output_type>); -static_assert(asymmetric_math_output_type>); -static_assert(!asymmetric_math_output_type>); -static_assert(asymmetric_math_output_type>); +static_assert(!asymmetric_solver_output_type>); +static_assert(asymmetric_solver_output_type>); +static_assert(!asymmetric_solver_output_type>); +static_assert(asymmetric_solver_output_type>); template -concept steady_state_math_output_type = math_output_type && std::derived_from>; +concept steady_state_solver_output_type = solver_output_type && std::derived_from>; -static_assert(steady_state_math_output_type>); -static_assert(steady_state_math_output_type>); -static_assert(!steady_state_math_output_type>); -static_assert(!steady_state_math_output_type>); +static_assert(steady_state_solver_output_type>); +static_assert(steady_state_solver_output_type>); +static_assert(!steady_state_solver_output_type>); +static_assert(!steady_state_solver_output_type>); template -concept short_circuit_math_output_type = - math_output_type && std::derived_from>; +concept short_circuit_solver_output_type = + solver_output_type && std::derived_from>; -static_assert(!short_circuit_math_output_type>); -static_assert(!short_circuit_math_output_type>); -static_assert(short_circuit_math_output_type>); -static_assert(short_circuit_math_output_type>); +static_assert(!short_circuit_solver_output_type>); +static_assert(!short_circuit_solver_output_type>); +static_assert(short_circuit_solver_output_type>); +static_assert(short_circuit_solver_output_type>); // component indices at physical model side // from, to node indices for branches diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/component/appliance.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/component/appliance.hpp index ccb0e7dfc4..6f3cedce88 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/component/appliance.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/component/appliance.hpp @@ -60,13 +60,13 @@ class Appliance : public Base { } template - ApplianceOutput get_output(ApplianceMathOutput const& appliance_math_output) const { + ApplianceOutput get_output(ApplianceSolverOutput const& appliance_solver_output) const { ApplianceOutput output{}; static_cast(output) = base_output(energized(true)); - output.p = base_power * real(appliance_math_output.s) * injection_direction(); - output.q = base_power * imag(appliance_math_output.s) * injection_direction(); - output.s = base_power * cabs(appliance_math_output.s); - output.i = base_i_ * cabs(appliance_math_output.i); + output.p = base_power * real(appliance_solver_output.s) * injection_direction(); + output.q = base_power * imag(appliance_solver_output.s) * injection_direction(); + output.s = base_power * cabs(appliance_solver_output.s); + output.i = base_i_ * cabs(appliance_solver_output.i); // pf if constexpr (is_symmetric_v) { if (output.s < numerical_tolerance) { @@ -104,8 +104,9 @@ class Appliance : public Base { } } template - ApplianceShortCircuitOutput get_sc_output(ApplianceShortCircuitMathOutput const& appliance_math_output) const { - return get_sc_output(appliance_math_output.i); + ApplianceShortCircuitOutput + get_sc_output(ApplianceShortCircuitSolverOutput const& appliance_solver_output) const { + return get_sc_output(appliance_solver_output.i); } private: @@ -114,8 +115,8 @@ class Appliance : public Base { double base_i_; // pure virtual functions for translate from u to s/i - virtual ApplianceMathOutput sym_u2si(ComplexValue const& u) const = 0; - virtual ApplianceMathOutput asym_u2si(ComplexValue const& u) const = 0; + virtual ApplianceSolverOutput sym_u2si(ComplexValue const& u) const = 0; + virtual ApplianceSolverOutput asym_u2si(ComplexValue const& u) const = 0; virtual double injection_direction() const = 0; }; diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/component/branch.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/component/branch.hpp index 67550a716c..7af2b63f62 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/component/branch.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/component/branch.hpp @@ -89,28 +89,29 @@ class Branch : public Base { BranchOutput get_output(ComplexValue const& u_f, ComplexValue const& u_t) const { // calculate flow BranchCalcParam const param = calc_param(); - BranchMathOutput branch_math_output{}; - branch_math_output.i_f = dot(param.yff(), u_f) + dot(param.yft(), u_t); - branch_math_output.i_t = dot(param.ytf(), u_f) + dot(param.ytt(), u_t); - branch_math_output.s_f = u_f * conj(branch_math_output.i_f); - branch_math_output.s_t = u_t * conj(branch_math_output.i_t); + BranchSolverOutput branch_solver_output{}; + branch_solver_output.i_f = dot(param.yff(), u_f) + dot(param.yft(), u_t); + branch_solver_output.i_t = dot(param.ytf(), u_f) + dot(param.ytt(), u_t); + branch_solver_output.s_f = u_f * conj(branch_solver_output.i_f); + branch_solver_output.s_t = u_t * conj(branch_solver_output.i_t); // calculate result - return get_output(branch_math_output); + return get_output(branch_solver_output); } - template BranchOutput get_output(BranchMathOutput const& branch_math_output) const { + template + BranchOutput get_output(BranchSolverOutput const& branch_solver_output) const { // result object BranchOutput output{}; static_cast(output) = base_output(true); // calculate result - output.p_from = base_power * real(branch_math_output.s_f); - output.q_from = base_power * imag(branch_math_output.s_f); - output.i_from = base_i_from() * cabs(branch_math_output.i_f); - output.s_from = base_power * cabs(branch_math_output.s_f); - output.p_to = base_power * real(branch_math_output.s_t); - output.q_to = base_power * imag(branch_math_output.s_t); - output.i_to = base_i_to() * cabs(branch_math_output.i_t); - output.s_to = base_power * cabs(branch_math_output.s_t); + output.p_from = base_power * real(branch_solver_output.s_f); + output.q_from = base_power * imag(branch_solver_output.s_f); + output.i_from = base_i_from() * cabs(branch_solver_output.i_f); + output.s_from = base_power * cabs(branch_solver_output.s_f); + output.p_to = base_power * real(branch_solver_output.s_t); + output.q_to = base_power * imag(branch_solver_output.s_t); + output.i_to = base_i_to() * cabs(branch_solver_output.i_t); + output.s_to = base_power * cabs(branch_solver_output.s_t); double const max_s = std::max(sum_val(output.s_from), sum_val(output.s_to)); double const max_i = std::max(max_val(output.i_from), max_val(output.i_to)); output.loading = loading(max_s, max_i); @@ -119,28 +120,30 @@ class Branch : public Base { BranchShortCircuitOutput get_sc_output(ComplexValue const& i_f, ComplexValue const& i_t) const { - return get_sc_output(BranchShortCircuitMathOutput{.i_f = i_f, .i_t = i_t}); + return get_sc_output(BranchShortCircuitSolverOutput{.i_f = i_f, .i_t = i_t}); } BranchShortCircuitOutput get_sc_output(ComplexValue const& i_f, ComplexValue const& i_t) const { - return get_sc_output(BranchShortCircuitMathOutput{.i_f = i_f, .i_t = i_t}); + return get_sc_output(BranchShortCircuitSolverOutput{.i_f = i_f, .i_t = i_t}); } - BranchShortCircuitOutput get_sc_output(BranchShortCircuitMathOutput const& branch_math_output) const { + BranchShortCircuitOutput + get_sc_output(BranchShortCircuitSolverOutput const& branch_solver_output) const { BranchShortCircuitOutput output{}; static_cast(output) = base_output(true); // calculate result - output.i_from = base_i_from() * cabs(branch_math_output.i_f); - output.i_to = base_i_to() * cabs(branch_math_output.i_t); - output.i_from_angle = arg(branch_math_output.i_f); - output.i_to_angle = arg(branch_math_output.i_t); + output.i_from = base_i_from() * cabs(branch_solver_output.i_f); + output.i_to = base_i_to() * cabs(branch_solver_output.i_t); + output.i_from_angle = arg(branch_solver_output.i_f); + output.i_to_angle = arg(branch_solver_output.i_t); return output; } - BranchShortCircuitOutput get_sc_output(BranchShortCircuitMathOutput const& branch_math_output) const { + BranchShortCircuitOutput + get_sc_output(BranchShortCircuitSolverOutput const& branch_solver_output) const { return get_sc_output( - BranchShortCircuitMathOutput{.i_f = ComplexValue{branch_math_output.i_f}, - .i_t = ComplexValue{branch_math_output.i_t}}); + BranchShortCircuitSolverOutput{.i_f = ComplexValue{branch_solver_output.i_f}, + .i_t = ComplexValue{branch_solver_output.i_t}}); } template BranchOutput get_null_output() const { diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/component/branch3.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/component/branch3.hpp index 5414a6561a..e486f4f2f9 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/component/branch3.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/component/branch3.hpp @@ -100,27 +100,27 @@ class Branch3 : public Base { } template - Branch3Output get_output(BranchMathOutput const& branch_math_output1, - BranchMathOutput const& branch_math_output2, - BranchMathOutput const& branch_math_output3) const { + Branch3Output get_output(BranchSolverOutput const& branch_solver_output1, + BranchSolverOutput const& branch_solver_output2, + BranchSolverOutput const& branch_solver_output3) const { // result object Branch3Output output{}; static_cast(output) = base_output(true); // calculate result - output.p_1 = base_power * real(branch_math_output1.s_f); - output.q_1 = base_power * imag(branch_math_output1.s_f); - output.i_1 = base_i_1() * cabs(branch_math_output1.i_f); - output.s_1 = base_power * cabs(branch_math_output1.s_f); + output.p_1 = base_power * real(branch_solver_output1.s_f); + output.q_1 = base_power * imag(branch_solver_output1.s_f); + output.i_1 = base_i_1() * cabs(branch_solver_output1.i_f); + output.s_1 = base_power * cabs(branch_solver_output1.s_f); - output.p_2 = base_power * real(branch_math_output2.s_f); - output.q_2 = base_power * imag(branch_math_output2.s_f); - output.i_2 = base_i_2() * cabs(branch_math_output2.i_f); - output.s_2 = base_power * cabs(branch_math_output2.s_f); + output.p_2 = base_power * real(branch_solver_output2.s_f); + output.q_2 = base_power * imag(branch_solver_output2.s_f); + output.i_2 = base_i_2() * cabs(branch_solver_output2.i_f); + output.s_2 = base_power * cabs(branch_solver_output2.s_f); - output.p_3 = base_power * real(branch_math_output3.s_f); - output.q_3 = base_power * imag(branch_math_output3.s_f); - output.i_3 = base_i_3() * cabs(branch_math_output3.i_f); - output.s_3 = base_power * cabs(branch_math_output3.s_f); + output.p_3 = base_power * real(branch_solver_output3.s_f); + output.q_3 = base_power * imag(branch_solver_output3.s_f); + output.i_3 = base_i_3() * cabs(branch_solver_output3.i_f); + output.s_3 = base_power * cabs(branch_solver_output3.s_f); output.loading = loading(sum_val(output.s_1), sum_val(output.s_2), sum_val(output.s_3)); @@ -150,10 +150,10 @@ class Branch3 : public Base { return get_sc_output(iabc_1, iabc_2, iabc_3); } template - Branch3ShortCircuitOutput get_sc_output(BranchShortCircuitMathOutput const& branch_math_output1, - BranchShortCircuitMathOutput const& branch_math_output2, - BranchShortCircuitMathOutput const& branch_math_output3) const { - return get_sc_output(branch_math_output1.i_f, branch_math_output2.i_f, branch_math_output3.i_f); + Branch3ShortCircuitOutput get_sc_output(BranchShortCircuitSolverOutput const& branch_solver_output1, + BranchShortCircuitSolverOutput const& branch_solver_output2, + BranchShortCircuitSolverOutput const& branch_solver_output3) const { + return get_sc_output(branch_solver_output1.i_f, branch_solver_output2.i_f, branch_solver_output3.i_f); } template Branch3Output get_null_output() const { diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/component/fault.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/component/fault.hpp index 409448af7c..5f33e63773 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/component/fault.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/component/fault.hpp @@ -89,9 +89,9 @@ class Fault final : public Base { } template - FaultShortCircuitOutput get_sc_output(FaultShortCircuitMathOutput const& math_output, + FaultShortCircuitOutput get_sc_output(FaultShortCircuitSolverOutput const& solver_output, double const u_rated) const { - return get_sc_output(math_output.i_fault, u_rated); + return get_sc_output(solver_output.i_fault, u_rated); } // update faulted object diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/component/load_gen.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/component/load_gen.hpp index ae880e8bfd..6003b8f856 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/component/load_gen.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/component/load_gen.hpp @@ -145,16 +145,16 @@ class LoadGen final : public std::conditional_t, return piecewise_complex_value(s_specified_); } template - ApplianceMathOutput u2si(ComplexValue const& u) const { - ApplianceMathOutput appliance_math_output; - appliance_math_output.s = scale_power(u); - appliance_math_output.i = conj(appliance_math_output.s / u); - return appliance_math_output; + ApplianceSolverOutput u2si(ComplexValue const& u) const { + ApplianceSolverOutput appliance_solver_output; + appliance_solver_output.s = scale_power(u); + appliance_solver_output.i = conj(appliance_solver_output.s / u); + return appliance_solver_output; } - ApplianceMathOutput sym_u2si(ComplexValue const& u) const override { + ApplianceSolverOutput sym_u2si(ComplexValue const& u) const override { return u2si(u); } - ApplianceMathOutput asym_u2si(ComplexValue const& u) const override { + ApplianceSolverOutput asym_u2si(ComplexValue const& u) const override { return u2si(u); } diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/component/shunt.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/component/shunt.hpp index 14934eede0..adff6cd061 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/component/shunt.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/component/shunt.hpp @@ -101,18 +101,18 @@ class Shunt : public Appliance { return true; } - template ApplianceMathOutput u2si(ComplexValue const& u) const { - ApplianceMathOutput appliance_math_output; + template ApplianceSolverOutput u2si(ComplexValue const& u) const { + ApplianceSolverOutput appliance_solver_output; ComplexTensor const param = calc_param(); // return value should be injection direction, therefore a negative sign for i - appliance_math_output.i = -dot(param, u); - appliance_math_output.s = u * conj(appliance_math_output.i); - return appliance_math_output; + appliance_solver_output.i = -dot(param, u); + appliance_solver_output.s = u * conj(appliance_solver_output.i); + return appliance_solver_output; } - ApplianceMathOutput sym_u2si(ComplexValue const& u) const final { + ApplianceSolverOutput sym_u2si(ComplexValue const& u) const final { return u2si(u); } - ApplianceMathOutput asym_u2si(ComplexValue const& u) const final { + ApplianceSolverOutput asym_u2si(ComplexValue const& u) const final { return u2si(u); } diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/component/source.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/component/source.hpp index ac2a1eaf46..d88e220e98 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/component/source.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/component/source.hpp @@ -120,19 +120,19 @@ class Source : public Appliance { DoubleComplex y1_ref_{}; DoubleComplex y0_ref_{}; - template ApplianceMathOutput u2si(ComplexValue const& u) const { - ApplianceMathOutput appliance_math_output; + template ApplianceSolverOutput u2si(ComplexValue const& u) const { + ApplianceSolverOutput appliance_solver_output; ComplexValue const u_ref{u_ref_}; ComplexTensor const y_ref = math_param(); - appliance_math_output.i = dot(y_ref, u_ref - u); - appliance_math_output.s = u * conj(appliance_math_output.i); - return appliance_math_output; + appliance_solver_output.i = dot(y_ref, u_ref - u); + appliance_solver_output.s = u * conj(appliance_solver_output.i); + return appliance_solver_output; } - ApplianceMathOutput sym_u2si(ComplexValue const& u) const final { + ApplianceSolverOutput sym_u2si(ComplexValue const& u) const final { return u2si(u); } - ApplianceMathOutput asym_u2si(ComplexValue const& u) const final { + ApplianceSolverOutput asym_u2si(ComplexValue const& u) const final { return u2si(u); } diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp index 2d602de2e0..5eb2dca80b 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp @@ -91,153 +91,154 @@ constexpr ResIt produce_output(MainModelState const& state, } // namespace detail // output node -template Component, steady_state_math_output_type MathOutputType> -constexpr auto output_result(Node const& node, std::vector const& math_output, Idx2D math_id) { - using sym = typename MathOutputType::sym; +template Component, steady_state_solver_output_type SolverOutputType> +constexpr auto output_result(Node const& node, std::vector const& solver_output, Idx2D math_id) { + using sym = typename SolverOutputType::sym; if (math_id.group == -1) { return node.get_null_output(); } - return node.get_output(math_output[math_id.group].u[math_id.pos], - math_output[math_id.group].bus_injection[math_id.pos]); + return node.get_output(solver_output[math_id.group].u[math_id.pos], + solver_output[math_id.group].bus_injection[math_id.pos]); } -template Component, short_circuit_math_output_type MathOutputType> -inline auto output_result(Component const& node, std::vector const& math_output, Idx2D math_id) { +template Component, short_circuit_solver_output_type SolverOutputType> +inline auto output_result(Component const& node, std::vector const& solver_output, Idx2D math_id) { if (math_id.group == -1) { return node.get_null_sc_output(); } - return node.get_sc_output(math_output[math_id.group].u_bus[math_id.pos]); + return node.get_sc_output(solver_output[math_id.group].u_bus[math_id.pos]); } // output branch -template Component, steady_state_math_output_type MathOutputType> -constexpr auto output_result(Component const& branch, std::vector const& math_output, Idx2D math_id) { - using sym = typename MathOutputType::sym; +template Component, steady_state_solver_output_type SolverOutputType> +constexpr auto output_result(Component const& branch, std::vector const& solver_output, + Idx2D math_id) { + using sym = typename SolverOutputType::sym; if (math_id.group == -1) { return branch.template get_null_output(); } - return branch.template get_output(math_output[math_id.group].branch[math_id.pos]); + return branch.template get_output(solver_output[math_id.group].branch[math_id.pos]); } -template Component, short_circuit_math_output_type MathOutputType> -inline auto output_result(Component const& branch, std::vector const& math_output, Idx2D math_id) { +template Component, short_circuit_solver_output_type SolverOutputType> +inline auto output_result(Component const& branch, std::vector const& solver_output, Idx2D math_id) { if (math_id.group == -1) { return branch.get_null_sc_output(); } - return branch.get_sc_output(math_output[math_id.group].branch[math_id.pos]); + return branch.get_sc_output(solver_output[math_id.group].branch[math_id.pos]); } // output branch3 -template Component, steady_state_math_output_type MathOutputType> -constexpr auto output_result(Component const& branch3, std::vector const& math_output, +template Component, steady_state_solver_output_type SolverOutputType> +constexpr auto output_result(Component const& branch3, std::vector const& solver_output, Idx2DBranch3 const& math_id) { - using sym = typename MathOutputType::sym; + using sym = typename SolverOutputType::sym; if (math_id.group == -1) { return branch3.template get_null_output(); } - auto const& branches = math_output[math_id.group].branch; + auto const& branches = solver_output[math_id.group].branch; return branch3.template get_output(branches[math_id.pos[0]], branches[math_id.pos[1]], branches[math_id.pos[2]]); } -template Component, short_circuit_math_output_type MathOutputType> -inline auto output_result(Component const& branch3, std::vector const& math_output, +template Component, short_circuit_solver_output_type SolverOutputType> +inline auto output_result(Component const& branch3, std::vector const& solver_output, Idx2DBranch3 const& math_id) { if (math_id.group == -1) { return branch3.get_null_sc_output(); } - auto const& branches = math_output[math_id.group].branch; + auto const& branches = solver_output[math_id.group].branch; return branch3.get_sc_output(branches[math_id.pos[0]], branches[math_id.pos[1]], branches[math_id.pos[2]]); } // output source -template Component, steady_state_math_output_type MathOutputType> -constexpr auto output_result(Component const& source, std::vector const& math_output, +template Component, steady_state_solver_output_type SolverOutputType> +constexpr auto output_result(Component const& source, std::vector const& solver_output, Idx2D const& math_id) { - using sym = typename MathOutputType::sym; + using sym = typename SolverOutputType::sym; if (math_id.group == -1) { return source.template get_null_output(); } - return source.template get_output(math_output[math_id.group].source[math_id.pos]); + return source.template get_output(solver_output[math_id.group].source[math_id.pos]); } -template Component, short_circuit_math_output_type MathOutputType> -inline auto output_result(Component const& source, std::vector const& math_output, +template Component, short_circuit_solver_output_type SolverOutputType> +inline auto output_result(Component const& source, std::vector const& solver_output, Idx2D const& math_id) { if (math_id.group == -1) { return source.get_null_sc_output(); } - return source.get_sc_output(math_output[math_id.group].source[math_id.pos]); + return source.get_sc_output(solver_output[math_id.group].source[math_id.pos]); } // output load gen -template Component, steady_state_math_output_type MathOutputType> -constexpr auto output_result(Component const& load_gen, std::vector const& math_output, +template Component, steady_state_solver_output_type SolverOutputType> +constexpr auto output_result(Component const& load_gen, std::vector const& solver_output, Idx2D const& math_id) { - using sym = typename MathOutputType::sym; + using sym = typename SolverOutputType::sym; if (math_id.group == -1) { return load_gen.template get_null_output(); } - return load_gen.template get_output(math_output[math_id.group].load_gen[math_id.pos]); + return load_gen.template get_output(solver_output[math_id.group].load_gen[math_id.pos]); } -template Component, short_circuit_math_output_type MathOutputType> -inline auto output_result(Component const& load_gen, std::vector const& /*math_output*/, +template Component, short_circuit_solver_output_type SolverOutputType> +inline auto output_result(Component const& load_gen, std::vector const& /*solver_output*/, Idx2D const& /*math_id*/) { return load_gen.get_null_sc_output(); } // output shunt -template Component, steady_state_math_output_type MathOutputType> -constexpr auto output_result(Component const& shunt, std::vector const& math_output, +template Component, steady_state_solver_output_type SolverOutputType> +constexpr auto output_result(Component const& shunt, std::vector const& solver_output, Idx2D const& math_id) { - using sym = typename MathOutputType::sym; + using sym = typename SolverOutputType::sym; if (math_id.group == -1) { return shunt.template get_null_output(); } - return shunt.template get_output(math_output[math_id.group].shunt[math_id.pos]); + return shunt.template get_output(solver_output[math_id.group].shunt[math_id.pos]); } -template Component, short_circuit_math_output_type MathOutputType> -inline auto output_result(Component const& shunt, std::vector const& math_output, +template Component, short_circuit_solver_output_type SolverOutputType> +inline auto output_result(Component const& shunt, std::vector const& solver_output, Idx2D const& math_id) { if (math_id.group == -1) { return shunt.get_null_sc_output(); } - return shunt.get_sc_output(math_output[math_id.group].shunt[math_id.pos]); + return shunt.get_sc_output(solver_output[math_id.group].shunt[math_id.pos]); } // output voltage sensor template Component, class ComponentContainer, - steady_state_math_output_type MathOutputType> + steady_state_solver_output_type SolverOutputType> requires model_component_state_c constexpr auto output_result(Component const& voltage_sensor, MainModelState const& state, - std::vector const& math_output, Idx const node_seq) { - using sym = typename MathOutputType::sym; + std::vector const& solver_output, Idx const node_seq) { + using sym = typename SolverOutputType::sym; Idx2D const node_math_id = state.topo_comp_coup->node[node_seq]; if (node_math_id.group == -1) { return voltage_sensor.template get_null_output(); } - return voltage_sensor.template get_output(math_output[node_math_id.group].u[node_math_id.pos]); + return voltage_sensor.template get_output(solver_output[node_math_id.group].u[node_math_id.pos]); } template Component, class ComponentContainer, - short_circuit_math_output_type MathOutputType> + short_circuit_solver_output_type SolverOutputType> requires model_component_state_c inline auto output_result(Component const& voltage_sensor, MainModelState const& /* state */, - std::vector const& /* math_output */, Idx const /* node_seq */) { + std::vector const& /* solver_output */, Idx const /* node_seq */) { return voltage_sensor.get_null_sc_output(); } // output power sensor template Component, class ComponentContainer, - steady_state_math_output_type MathOutputType> + steady_state_solver_output_type SolverOutputType> requires model_component_state_c constexpr auto output_result(Component const& power_sensor, MainModelState const& state, - std::vector const& math_output, Idx const obj_seq) { - using sym = typename MathOutputType::sym; + std::vector const& solver_output, Idx const obj_seq) { + using sym = typename SolverOutputType::sym; auto const terminal_type = power_sensor.get_terminal_type(); Idx2D const obj_math_id = [&]() { @@ -282,146 +283,148 @@ constexpr auto output_result(Component const& power_sensor, MainModelState(math_output[obj_math_id.group].branch[obj_math_id.pos].s_f); + return power_sensor.template get_output(solver_output[obj_math_id.group].branch[obj_math_id.pos].s_f); case branch_to: - return power_sensor.template get_output(math_output[obj_math_id.group].branch[obj_math_id.pos].s_t); + return power_sensor.template get_output(solver_output[obj_math_id.group].branch[obj_math_id.pos].s_t); case source: - return power_sensor.template get_output(math_output[obj_math_id.group].source[obj_math_id.pos].s); + return power_sensor.template get_output(solver_output[obj_math_id.group].source[obj_math_id.pos].s); case shunt: - return power_sensor.template get_output(math_output[obj_math_id.group].shunt[obj_math_id.pos].s); + return power_sensor.template get_output(solver_output[obj_math_id.group].shunt[obj_math_id.pos].s); case load: [[fallthrough]]; case generator: - return power_sensor.template get_output(math_output[obj_math_id.group].load_gen[obj_math_id.pos].s); + return power_sensor.template get_output(solver_output[obj_math_id.group].load_gen[obj_math_id.pos].s); case node: - return power_sensor.template get_output(math_output[obj_math_id.group].bus_injection[obj_math_id.pos]); + return power_sensor.template get_output(solver_output[obj_math_id.group].bus_injection[obj_math_id.pos]); default: throw MissingCaseForEnumError(std::string(GenericPowerSensor::name) + " output_result()", terminal_type); } } template Component, class ComponentContainer, - short_circuit_math_output_type MathOutputType> + short_circuit_solver_output_type SolverOutputType> requires model_component_state_c constexpr auto output_result(Component const& power_sensor, MainModelState const& /* state */, - std::vector const& /* math_output */, Idx const /* obj_seq */) { + std::vector const& /* solver_output */, Idx const /* obj_seq */) { return power_sensor.get_null_sc_output(); } // output fault -template Component, class ComponentContainer, steady_state_math_output_type MathOutputType> +template Component, class ComponentContainer, + steady_state_solver_output_type SolverOutputType> requires model_component_state_c && model_component_state_c constexpr auto output_result(Component const& fault, MainModelState const& /* state */, - std::vector const& /* math_output */, Idx2D /* math_id */) { + std::vector const& /* solver_output */, Idx2D /* math_id */) { return fault.get_output(); } -template Component, class ComponentContainer, short_circuit_math_output_type MathOutputType> +template Component, class ComponentContainer, + short_circuit_solver_output_type SolverOutputType> requires model_component_state_c && model_component_state_c inline auto output_result(Component const& fault, MainModelState const& state, - std::vector const& math_output, Idx2D math_id) { + std::vector const& solver_output, Idx2D math_id) { if (math_id.group == -1) { return fault.get_null_sc_output(); } auto const u_rated = get_component(state, fault.get_fault_object()).u_rated(); - return fault.get_sc_output(math_output[math_id.group].fault[math_id.pos], u_rated); + return fault.get_sc_output(solver_output[math_id.group].fault[math_id.pos], u_rated); } // output transformer tap regulator template Component, class ComponentContainer, - steady_state_math_output_type MathOutputType> + steady_state_solver_output_type SolverOutputType> requires model_component_state_c constexpr auto output_result(Component const& /* transformer_tap_regulator */, MainModelState const& /* state */, - std::vector const& /* math_output */, Idx const /* obj_seq */) { + std::vector const& /* solver_output */, Idx const /* obj_seq */) { // TODO: this function is not implemented - using sym = typename MathOutputType::sym; + using sym = typename SolverOutputType::sym; return typename TransformerTapRegulator::OutputType{}; } template Component, class ComponentContainer, - short_circuit_math_output_type MathOutputType> + short_circuit_solver_output_type SolverOutputType> requires model_component_state_c inline auto output_result(Component const& transformer_tap_regulator, MainModelState const& /* state */, - std::vector const& /* math_output */, Idx const /* obj_seq */) { + std::vector const& /* solver_output */, Idx const /* obj_seq */) { return transformer_tap_regulator.get_null_sc_output(); } // output base component -template Component, class ComponentContainer, math_output_type MathOutputType, +template Component, class ComponentContainer, solver_output_type SolverOutputType, std::forward_iterator ResIt> requires model_component_state_c && - requires(Component const& component, std::vector const& math_output, Idx2D math_id) { + requires(Component const& component, std::vector const& solver_output, Idx2D math_id) { { - output_result(component, math_output, math_id) + output_result(component, solver_output, math_id) } -> std::convertible_to>; } constexpr ResIt output_result(MainModelState const& state, - std::vector const& math_output, ResIt res_it) { + std::vector const& solver_output, ResIt res_it) { return detail::produce_output( - state, res_it, [&math_output](Component const& component, Idx2D math_id) { - return output_result(component, math_output, math_id); + state, res_it, [&solver_output](Component const& component, Idx2D math_id) { + return output_result(component, solver_output, math_id); }); } -template Component, class ComponentContainer, math_output_type MathOutputType, +template Component, class ComponentContainer, solver_output_type SolverOutputType, std::forward_iterator ResIt> requires model_component_state_c && requires(Component const& component, MainModelState const& state, - std::vector const& math_output, Idx2D math_id) { + std::vector const& solver_output, Idx2D math_id) { { - output_result(component, state, math_output, math_id) + output_result(component, state, solver_output, math_id) } -> std::convertible_to>; } constexpr ResIt output_result(MainModelState const& state, - std::vector const& math_output, ResIt res_it) { + std::vector const& solver_output, ResIt res_it) { return detail::produce_output( - state, res_it, [&state, &math_output](Component const& component, Idx2D const math_id) { - return output_result(component, state, math_output, math_id); + state, res_it, [&state, &solver_output](Component const& component, Idx2D const math_id) { + return output_result(component, state, solver_output, math_id); }); } -template Component, class ComponentContainer, math_output_type MathOutputType, +template Component, class ComponentContainer, solver_output_type SolverOutputType, std::forward_iterator ResIt> requires model_component_state_c && requires(Component const& component, MainModelState const& state, - std::vector const& math_output, Idx obj_seq) { + std::vector const& solver_output, Idx obj_seq) { { - output_result(component, state, math_output, obj_seq) + output_result(component, state, solver_output, obj_seq) } -> std::convertible_to>; } constexpr ResIt output_result(MainModelState const& state, - std::vector const& math_output, ResIt res_it) { + std::vector const& solver_output, ResIt res_it) { return detail::produce_output( - state, res_it, [&state, &math_output](Component const& component, Idx const obj_seq) { - return output_result(component, state, math_output, obj_seq); + state, res_it, [&state, &solver_output](Component const& component, Idx const obj_seq) { + return output_result(component, state, solver_output, obj_seq); }); } -template Component, class ComponentContainer, math_output_type MathOutputType, +template Component, class ComponentContainer, solver_output_type SolverOutputType, std::forward_iterator ResIt> requires model_component_state_c && - requires(Component const& component, std::vector const& math_output, + requires(Component const& component, std::vector const& solver_output, Idx2DBranch3 const& math_id) { { - output_result(component, math_output, math_id) + output_result(component, solver_output, math_id) } -> std::convertible_to>; } constexpr ResIt output_result(MainModelState const& state, - std::vector const& math_output, ResIt res_it) { + std::vector const& solver_output, ResIt res_it) { return detail::produce_output( - state, res_it, [&math_output](Component const& component, Idx2DBranch3 const& math_id) { - return output_result(component, math_output, math_id); + state, res_it, [&solver_output](Component const& component, Idx2DBranch3 const& math_id) { + return output_result(component, solver_output, math_id); }); } // output source, load_gen, shunt individually -template Component, class ComponentContainer, math_output_type MathOutputType, +template Component, class ComponentContainer, solver_output_type SolverOutputType, std::forward_iterator ResIt> requires model_component_state_c constexpr ResIt output_result(MainModelState const& state, - std::vector const& math_output, ResIt res_it) { - res_it = output_result(state, math_output, res_it); - res_it = output_result(state, math_output, res_it); - res_it = output_result(state, math_output, res_it); + std::vector const& solver_output, ResIt res_it) { + res_it = output_result(state, solver_output, res_it); + res_it = output_result(state, solver_output, res_it); + res_it = output_result(state, solver_output, res_it); return res_it; } diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_model.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_model.hpp index 71aa020c33..701ddc1d6d 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_model.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_model.hpp @@ -329,15 +329,15 @@ class MainModelImpl, ComponentLis is_asym_parameter_up_to_date_ = is_asym_parameter_up_to_date_ && !changes.topo && !changes.param; } - template requires std::invocable, Idx /*n_math_solvers*/> && std::invocable, MathSolverType&, YBus const&, InputType const&> && std::same_as, std::vector> && std::same_as, - MathOutputType> - std::vector calculate_(PrepareInputFn&& prepare_input, SolveFn&& solve) { - using sym = typename MathOutputType::sym; + SolverOutputType> + std::vector calculate_(PrepareInputFn&& prepare_input, SolveFn&& solve) { + using sym = typename SolverOutputType::sym; assert(construction_complete_); calculation_info_ = CalculationInfo{}; @@ -353,19 +353,19 @@ class MainModelImpl, ComponentLis Timer const timer(calculation_info_, 2200, "Math Calculation"); auto& solvers = get_solvers(); auto& y_bus_vec = get_y_bus(); - std::vector math_output; - math_output.reserve(n_math_solvers_); + std::vector solver_output; + solver_output.reserve(n_math_solvers_); for (Idx i = 0; i != n_math_solvers_; ++i) { - math_output.emplace_back(solve(solvers[i], y_bus_vec[i], input[i])); + solver_output.emplace_back(solve(solvers[i], y_bus_vec[i], input[i])); } - return math_output; + return solver_output; }(); } template auto calculate_power_flow_(double err_tol, Idx max_iter) { return [this, err_tol, max_iter](MainModelState const& state, - CalculationMethod calculation_method) -> std::vector> { - return calculate_, MathSolver, YBus, PowerFlowInput>( + CalculationMethod calculation_method) -> std::vector> { + return calculate_, MathSolver, YBus, PowerFlowInput>( [&state](Idx n_math_solvers) { return prepare_power_flow_input(state, n_math_solvers); }, [this, err_tol, max_iter, calculation_method](MathSolver& solver, YBus const& y_bus, PowerFlowInput const& input) { @@ -377,8 +377,8 @@ class MainModelImpl, ComponentLis template auto calculate_state_estimation_(double err_tol, Idx max_iter) { return [this, err_tol, max_iter](MainModelState const& state, - CalculationMethod calculation_method) -> std::vector> { - return calculate_, MathSolver, YBus, StateEstimationInput>( + CalculationMethod calculation_method) -> std::vector> { + return calculate_, MathSolver, YBus, StateEstimationInput>( [&state](Idx n_math_solvers) { return prepare_state_estimation_input(state, n_math_solvers); }, [this, err_tol, max_iter, calculation_method](MathSolver& solver, YBus const& y_bus, StateEstimationInput const& input) { @@ -389,19 +389,19 @@ class MainModelImpl, ComponentLis } template auto calculate_short_circuit_(ShortCircuitVoltageScaling voltage_scaling) { - return - [this, voltage_scaling](MainModelState const& /*state*/, - CalculationMethod calculation_method) -> std::vector> { - return calculate_, MathSolver, YBus, ShortCircuitInput>( - [this, voltage_scaling](Idx /* n_math_solvers */) { - assert(is_topology_up_to_date_ && is_parameter_up_to_date()); - return prepare_short_circuit_input(voltage_scaling); - }, - [this, calculation_method](MathSolver& solver, YBus const& y_bus, - ShortCircuitInput const& input) { - return solver.run_short_circuit(input, calculation_info_, calculation_method, y_bus); - }); - }; + return [this, + voltage_scaling](MainModelState const& /*state*/, + CalculationMethod calculation_method) -> std::vector> { + return calculate_, MathSolver, YBus, ShortCircuitInput>( + [this, voltage_scaling](Idx /* n_math_solvers */) { + assert(is_topology_up_to_date_ && is_parameter_up_to_date()); + return prepare_short_circuit_input(voltage_scaling); + }, + [this, calculation_method](MathSolver& solver, YBus const& y_bus, + ShortCircuitInput const& input) { + return solver.run_short_circuit(input, calculation_info_, calculation_method, y_bus); + }); + }; } /* @@ -664,8 +664,8 @@ class MainModelImpl, ComponentLis } template - std::vector> calculate_power_flow(double err_tol, Idx max_iter, - CalculationMethod calculation_method) { + std::vector> calculate_power_flow(double err_tol, Idx max_iter, + CalculationMethod calculation_method) { return optimizer::get_optimizer( OptimizerType::no_optimization, OptimizerStrategy::any, calculate_power_flow_(err_tol, max_iter), @@ -678,9 +678,9 @@ class MainModelImpl, ComponentLis void calculate_power_flow(double err_tol, Idx max_iter, CalculationMethod calculation_method, Dataset const& result_data, Idx pos = 0) { assert(construction_complete_); - auto const math_output = calculate_power_flow(err_tol, max_iter, calculation_method); + auto const solver_output = calculate_power_flow(err_tol, max_iter, calculation_method); if (pos != ignore_output) { - output_result(math_output, result_data, pos); + output_result(solver_output, result_data, pos); } } @@ -701,8 +701,8 @@ class MainModelImpl, ComponentLis // Single state estimation calculation, returning math output results template - std::vector> calculate_state_estimation(double err_tol, Idx max_iter, - CalculationMethod calculation_method) { + std::vector> calculate_state_estimation(double err_tol, Idx max_iter, + CalculationMethod calculation_method) { return calculate_state_estimation_(err_tol, max_iter)(state_, calculation_method); } @@ -711,8 +711,8 @@ class MainModelImpl, ComponentLis void calculate_state_estimation(double err_tol, Idx max_iter, CalculationMethod calculation_method, Dataset const& result_data, Idx pos = 0) { assert(construction_complete_); - auto const math_output = calculate_state_estimation(err_tol, max_iter, calculation_method); - output_result(math_output, result_data, pos); + auto const solver_output = calculate_state_estimation(err_tol, max_iter, calculation_method); + output_result(solver_output, result_data, pos); } // Batch state estimation calculation, propagating the results to result_data @@ -732,8 +732,8 @@ class MainModelImpl, ComponentLis // Single short circuit calculation, returning short circuit math output results template - std::vector> calculate_short_circuit(ShortCircuitVoltageScaling voltage_scaling, - CalculationMethod calculation_method) { + std::vector> calculate_short_circuit(ShortCircuitVoltageScaling voltage_scaling, + CalculationMethod calculation_method) { return calculate_short_circuit_(voltage_scaling)(state_, calculation_method); } @@ -744,11 +744,11 @@ class MainModelImpl, ComponentLis if (std::all_of(state_.components.template citer().begin(), state_.components.template citer().end(), [](Fault const& fault) { return fault.get_fault_type() == FaultType::three_phase; })) { - auto const math_output = calculate_short_circuit(voltage_scaling, calculation_method); - output_result(math_output, result_data, pos); + auto const solver_output = calculate_short_circuit(voltage_scaling, calculation_method); + output_result(solver_output, result_data, pos); } else { - auto const math_output = calculate_short_circuit(voltage_scaling, calculation_method); - output_result(math_output, result_data, pos); + auto const solver_output = calculate_short_circuit(voltage_scaling, calculation_method); + output_result(solver_output, result_data, pos); } } @@ -765,30 +765,28 @@ class MainModelImpl, ComponentLis result_data, update_data, threading); } - template - ResIt output_result(std::vector const& math_output, ResIt res_it) const { + template + ResIt output_result(std::vector const& solver_output, ResIt res_it) const { assert(construction_complete_); - return main_core::output_result(state_, math_output, res_it); + return main_core::output_result(state_, solver_output, res_it); } - template - void output_result(std::vector const& math_output, Dataset const& result_data, Idx pos = 0) { - using OutputFunc = void (*)(MainModelImpl & x, std::vector const& math_output, + template + void output_result(std::vector const& solver_output, Dataset const& result_data, Idx pos = 0) { + using OutputFunc = void (*)(MainModelImpl & x, std::vector const& solver_output, MutableDataPointer const& data_ptr, Idx position); - static constexpr std::array get_result{[](MainModelImpl& model, - std::vector const& math_output_, - MutableDataPointer const& data_ptr, - Idx position) { - auto const begin = - data_ptr - .get_iterators< - std::conditional_t, - typename ComponentType::template OutputType, + static constexpr std::array get_result{ + [](MainModelImpl& model, std::vector const& solver_output_, + MutableDataPointer const& data_ptr, Idx position) { + auto const begin = data_ptr + .get_iterators, + typename ComponentType::template OutputType, typename ComponentType::ShortCircuitOutputType>>(position) - .first; - model.output_result(math_output_, begin); - }...}; + .first; + model.output_result(solver_output_, begin); + }...}; Timer const t_output(calculation_info_, 3000, "Produce output"); for (ComponentEntry const& entry : AllComponents::component_index_map) { @@ -798,7 +796,7 @@ class MainModelImpl, ComponentLis continue; } // update - get_result[entry.index](*this, math_output, found->second, pos); + get_result[entry.index](*this, solver_output, found->second, pos); } } diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/common_solver_functions.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/common_solver_functions.hpp index 946bba6f83..dcee71798d 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/common_solver_functions.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/common_solver_functions.hpp @@ -35,8 +35,8 @@ inline void add_linear_loads(boost::iterator_range const& load_gens_pe template inline void prepare_linear_matrix_and_rhs(YBus const& y_bus, PowerFlowInput const& input, grouped_idx_vector_type auto const& load_gens_per_bus, - grouped_idx_vector_type auto const& sources_per_bus, MathOutput& output, - ComplexTensorVector& mat_data) { + grouped_idx_vector_type auto const& sources_per_bus, + SolverOutput& output, ComplexTensorVector& mat_data) { IdxVector const& bus_entry = y_bus.lu_diag(); for (auto const& [bus_number, load_gens, sources] : enumerated_zip_sequence(load_gens_per_bus, sources_per_bus)) { Idx const diagonal_position = bus_entry[bus_number]; @@ -59,7 +59,7 @@ template inline void copy_y_bus(YBus const& y_bus, Compl template inline void calculate_source_result(IdxRange const& sources, Idx bus_number, YBus const& y_bus, - PowerFlowInput const& input, MathOutput& output) { + PowerFlowInput const& input, SolverOutput& output) { for (Idx const source : sources) { ComplexValue const u_ref{input.source[source]}; ComplexTensor const y_ref = y_bus.math_model_param().source_param[source]; @@ -72,7 +72,7 @@ template requires std::invocable, Idx> && std::same_as, LoadGenType> inline void calculate_load_gen_result(IdxRange const& load_gens, Idx bus_number, PowerFlowInput const& input, - MathOutput& output, LoadGenFunc&& load_gen_func) { + SolverOutput& output, LoadGenFunc&& load_gen_func) { for (Idx const load_gen : load_gens) { switch (LoadGenType const type = load_gen_func(load_gen); type) { using enum LoadGenType; @@ -101,13 +101,13 @@ template std::same_as, LoadGenType> inline void calculate_pf_result(YBus const& y_bus, PowerFlowInput const& input, grouped_idx_vector_type auto const& sources_per_bus, - grouped_idx_vector_type auto const& load_gens_per_bus, MathOutput& output, + grouped_idx_vector_type auto const& load_gens_per_bus, SolverOutput& output, LoadGenFunc&& load_gen_func) { assert(sources_per_bus.size() == load_gens_per_bus.size()); // call y bus - output.branch = y_bus.template calculate_branch_flow>(output.u); - output.shunt = y_bus.template calculate_shunt_flow>(output.u); + output.branch = y_bus.template calculate_branch_flow>(output.u); + output.shunt = y_bus.template calculate_shunt_flow>(output.u); // prepare source, load gen and node injection output.source.resize(sources_per_bus.element_size()); @@ -123,10 +123,10 @@ inline void calculate_pf_result(YBus const& y_bus, PowerFlowInput cons template inline void calculate_se_result(YBus const& y_bus, MeasuredValues const& measured_value, - MathOutput& output) { + SolverOutput& output) { // call y bus - output.branch = y_bus.template calculate_branch_flow>(output.u); - output.shunt = y_bus.template calculate_shunt_flow>(output.u); + output.branch = y_bus.template calculate_branch_flow>(output.u); + output.shunt = y_bus.template calculate_shunt_flow>(output.u); output.bus_injection = y_bus.calculate_injection(output.u); std::tie(output.load_gen, output.source) = measured_value.calculate_load_gen_source(output.u, output.bus_injection); } diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/iterative_current_pf_solver.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/iterative_current_pf_solver.hpp index 9e1489dcfe..00f6241fd2 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/iterative_current_pf_solver.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/iterative_current_pf_solver.hpp @@ -82,7 +82,8 @@ class IterativeCurrentPFSolver : public IterativePFSolver const& y_bus, PowerFlowInput const& input, MathOutput& output) { + void initialize_derived_solver(YBus const& y_bus, PowerFlowInput const& input, + SolverOutput& output) { make_flat_start(input, output.u); auto const& sources_per_bus = *this->sources_per_bus_; diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/iterative_linear_se_solver.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/iterative_linear_se_solver.hpp index ee0a84fede..f5ef6da473 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/iterative_linear_se_solver.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/iterative_linear_se_solver.hpp @@ -74,12 +74,12 @@ template class IterativeLinearSESolver { sparse_solver_{y_bus.shared_indptr_lu(), y_bus.shared_indices_lu(), y_bus.shared_diag_lu()}, perm_(y_bus.size()) {} - MathOutput run_state_estimation(YBus const& y_bus, StateEstimationInput const& input, double err_tol, - Idx max_iter, CalculationInfo& calculation_info) { + SolverOutput run_state_estimation(YBus const& y_bus, StateEstimationInput const& input, + double err_tol, Idx max_iter, CalculationInfo& calculation_info) { // prepare Timer main_timer; Timer sub_timer; - MathOutput output; + SolverOutput output; output.u.resize(n_bus_); output.bus_injection.resize(n_bus_); double max_dev = std::numeric_limits::max(); diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/iterative_pf_solver.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/iterative_pf_solver.hpp index f95f72969a..c4557e5499 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/iterative_pf_solver.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/iterative_pf_solver.hpp @@ -24,13 +24,13 @@ namespace power_grid_model::math_solver { template class IterativePFSolver { public: friend DerivedSolver; - MathOutput run_power_flow(YBus const& y_bus, PowerFlowInput const& input, double err_tol, - Idx max_iter, CalculationInfo& calculation_info) { + SolverOutput run_power_flow(YBus const& y_bus, PowerFlowInput const& input, double err_tol, + Idx max_iter, CalculationInfo& calculation_info) { // get derived reference for derived solver class auto derived_solver = static_cast(*this); // prepare - MathOutput output; + SolverOutput output; output.u.resize(n_bus_); double max_dev = std::numeric_limits::infinity(); @@ -81,7 +81,7 @@ template class IterativePFSolver { return output; } - void calculate_result(YBus const& y_bus, PowerFlowInput const& input, MathOutput& output) { + void calculate_result(YBus const& y_bus, PowerFlowInput const& input, SolverOutput& output) { detail::calculate_pf_result(y_bus, input, *sources_per_bus_, *load_gens_per_bus_, output, [this](Idx i) { return (*load_gen_type_)[i]; }); } diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/linear_pf_solver.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/linear_pf_solver.hpp index 4fcc381349..fbc59f91d1 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/linear_pf_solver.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/linear_pf_solver.hpp @@ -57,10 +57,10 @@ template class LinearPFSolver { sparse_solver_{y_bus.shared_indptr_lu(), y_bus.shared_indices_lu(), y_bus.shared_diag_lu()}, perm_(n_bus_) {} - MathOutput run_power_flow(YBus const& y_bus, PowerFlowInput const& input, - CalculationInfo& calculation_info) { + SolverOutput run_power_flow(YBus const& y_bus, PowerFlowInput const& input, + CalculationInfo& calculation_info) { // output - MathOutput output; + SolverOutput output; output.u.resize(n_bus_); Timer const main_timer(calculation_info, 2220, "Math solver"); @@ -94,11 +94,11 @@ template class LinearPFSolver { SparseSolverType sparse_solver_; BlockPermArray perm_; - void prepare_matrix_and_rhs(YBus const& y_bus, PowerFlowInput const& input, MathOutput& output) { + void prepare_matrix_and_rhs(YBus const& y_bus, PowerFlowInput const& input, SolverOutput& output) { detail::prepare_linear_matrix_and_rhs(y_bus, input, *load_gens_per_bus_, *sources_per_bus_, output, mat_data_); } - void calculate_result(YBus const& y_bus, PowerFlowInput const& input, MathOutput& output) { + void calculate_result(YBus const& y_bus, PowerFlowInput const& input, SolverOutput& output) { detail::calculate_pf_result(y_bus, input, *sources_per_bus_, *load_gens_per_bus_, output, [](Idx /*i*/) { return LoadGenType::const_y; }); } diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/math_solver.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/math_solver.hpp index c395bc7687..83b8bc1551 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/math_solver.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/math_solver.hpp @@ -31,9 +31,9 @@ template class MathSolver { all_const_y_{std::all_of(topo_ptr->load_gen_type.cbegin(), topo_ptr->load_gen_type.cend(), [](LoadGenType x) { return x == LoadGenType::const_y; })} {} - MathOutput run_power_flow(PowerFlowInput const& input, double err_tol, Idx max_iter, - CalculationInfo& calculation_info, CalculationMethod calculation_method, - YBus const& y_bus) { + SolverOutput run_power_flow(PowerFlowInput const& input, double err_tol, Idx max_iter, + CalculationInfo& calculation_info, CalculationMethod calculation_method, + YBus const& y_bus) { using enum CalculationMethod; // set method to always linear if all load_gens have const_y @@ -55,9 +55,9 @@ template class MathSolver { } } - MathOutput run_state_estimation(StateEstimationInput const& input, double err_tol, Idx max_iter, - CalculationInfo& calculation_info, CalculationMethod calculation_method, - YBus const& y_bus) { + SolverOutput run_state_estimation(StateEstimationInput const& input, double err_tol, Idx max_iter, + CalculationInfo& calculation_info, CalculationMethod calculation_method, + YBus const& y_bus) { using enum CalculationMethod; switch (calculation_method) { @@ -72,8 +72,8 @@ template class MathSolver { } } - ShortCircuitMathOutput run_short_circuit(ShortCircuitInput const& input, CalculationInfo& calculation_info, - CalculationMethod calculation_method, YBus const& y_bus) { + ShortCircuitSolverOutput run_short_circuit(ShortCircuitInput const& input, CalculationInfo& calculation_info, + CalculationMethod calculation_method, YBus const& y_bus) { if (calculation_method != CalculationMethod::default_method && calculation_method != CalculationMethod::iec60909) { throw InvalidCalculationMethod{}; @@ -112,8 +112,8 @@ template class MathSolver { std::optional> newton_raphson_se_solver_; std::optional> iec60909_sc_solver_; - MathOutput run_power_flow_newton_raphson(PowerFlowInput const& input, double err_tol, Idx max_iter, - CalculationInfo& calculation_info, YBus const& y_bus) { + SolverOutput run_power_flow_newton_raphson(PowerFlowInput const& input, double err_tol, Idx max_iter, + CalculationInfo& calculation_info, YBus const& y_bus) { if (!newton_raphson_pf_solver_.has_value()) { Timer const timer(calculation_info, 2210, "Create math solver"); newton_raphson_pf_solver_.emplace(y_bus, topo_ptr_); @@ -121,8 +121,8 @@ template class MathSolver { return newton_raphson_pf_solver_.value().run_power_flow(y_bus, input, err_tol, max_iter, calculation_info); } - MathOutput run_power_flow_linear(PowerFlowInput const& input, double /* err_tol */, Idx /* max_iter */, - CalculationInfo& calculation_info, YBus const& y_bus) { + SolverOutput run_power_flow_linear(PowerFlowInput const& input, double /* err_tol */, Idx /* max_iter */, + CalculationInfo& calculation_info, YBus const& y_bus) { if (!linear_pf_solver_.has_value()) { Timer const timer(calculation_info, 2210, "Create math solver"); linear_pf_solver_.emplace(y_bus, topo_ptr_); @@ -130,8 +130,8 @@ template class MathSolver { return linear_pf_solver_.value().run_power_flow(y_bus, input, calculation_info); } - MathOutput run_power_flow_iterative_current(PowerFlowInput const& input, double err_tol, Idx max_iter, - CalculationInfo& calculation_info, YBus const& y_bus) { + SolverOutput run_power_flow_iterative_current(PowerFlowInput const& input, double err_tol, Idx max_iter, + CalculationInfo& calculation_info, YBus const& y_bus) { if (!iterative_current_pf_solver_.has_value()) { Timer const timer(calculation_info, 2210, "Create math solver"); iterative_current_pf_solver_.emplace(y_bus, topo_ptr_); @@ -139,16 +139,16 @@ template class MathSolver { return iterative_current_pf_solver_.value().run_power_flow(y_bus, input, err_tol, max_iter, calculation_info); } - MathOutput run_power_flow_linear_current(PowerFlowInput const& input, double /* err_tol */, - Idx /* max_iter */, CalculationInfo& calculation_info, - YBus const& y_bus) { + SolverOutput run_power_flow_linear_current(PowerFlowInput const& input, double /* err_tol */, + Idx /* max_iter */, CalculationInfo& calculation_info, + YBus const& y_bus) { return run_power_flow_iterative_current(input, std::numeric_limits::infinity(), 1, calculation_info, y_bus); } - MathOutput run_state_estimation_iterative_linear(StateEstimationInput const& input, double err_tol, - Idx max_iter, CalculationInfo& calculation_info, - YBus const& y_bus) { + SolverOutput run_state_estimation_iterative_linear(StateEstimationInput const& input, double err_tol, + Idx max_iter, CalculationInfo& calculation_info, + YBus const& y_bus) { // construct model if needed if (!iterative_linear_se_solver_.has_value()) { Timer const timer(calculation_info, 2210, "Create math solver"); @@ -160,9 +160,9 @@ template class MathSolver { calculation_info); } - MathOutput run_state_estimation_newton_raphson(StateEstimationInput const& input, double err_tol, - Idx max_iter, CalculationInfo& calculation_info, - YBus const& y_bus) { + SolverOutput run_state_estimation_newton_raphson(StateEstimationInput const& input, double err_tol, + Idx max_iter, CalculationInfo& calculation_info, + YBus const& y_bus) { // construct model if needed if (!newton_raphson_se_solver_.has_value()) { Timer const timer(calculation_info, 2210, "Create math solver"); diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/measured_values.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/measured_values.hpp index 1d2ec7d17d..2b90c4999b 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/measured_values.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/measured_values.hpp @@ -105,13 +105,13 @@ template class MeasuredValues { // calculate load_gen and source flow // with given bus voltage and bus current injection - using FlowVector = std::vector>; + using FlowVector = std::vector>; using LoadGenSourceFlow = std::pair; LoadGenSourceFlow calculate_load_gen_source(ComplexValueVector const& u, ComplexValueVector const& s) const { - std::vector> load_gen_flow(math_topology_->n_load_gen()); - std::vector> source_flow(math_topology_->n_source()); + std::vector> load_gen_flow(math_topology_->n_load_gen()); + std::vector> source_flow(math_topology_->n_source()); // loop all buses for (auto const& [bus, load_gens, sources] : diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/newton_raphson_pf_solver.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/newton_raphson_pf_solver.hpp index c6d5f5a229..95442b8fca 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/newton_raphson_pf_solver.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/newton_raphson_pf_solver.hpp @@ -215,7 +215,8 @@ template class NewtonRaphsonPFSolver : public IterativePFSolv perm_(y_bus.size()) {} // Initilize the unknown variable in polar form - void initialize_derived_solver(YBus const& y_bus, PowerFlowInput const& input, MathOutput& output) { + void initialize_derived_solver(YBus const& y_bus, PowerFlowInput const& input, + SolverOutput& output) { using LinearSparseSolverType = SparseLUSolver, ComplexValue, ComplexValue>; ComplexTensorVector linear_mat_data(y_bus.nnz_lu()); diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/newton_raphson_se_solver.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/newton_raphson_se_solver.hpp index bc122608cd..2e550416fb 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/newton_raphson_se_solver.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/newton_raphson_se_solver.hpp @@ -138,12 +138,12 @@ template class NewtonRaphsonSESolver { sparse_solver_{y_bus.shared_indptr_lu(), y_bus.shared_indices_lu(), y_bus.shared_diag_lu()}, perm_(y_bus.size()) {} - MathOutput run_state_estimation(YBus const& y_bus, StateEstimationInput const& input, double err_tol, - Idx max_iter, CalculationInfo& calculation_info) { + SolverOutput run_state_estimation(YBus const& y_bus, StateEstimationInput const& input, + double err_tol, Idx max_iter, CalculationInfo& calculation_info) { // prepare Timer main_timer; Timer sub_timer; - MathOutput output; + SolverOutput output; output.u.resize(n_bus_); output.bus_injection.resize(n_bus_); double max_dev = std::numeric_limits::max(); diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/short_circuit_solver.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/short_circuit_solver.hpp index 7c411b5b7e..1e3c5cdb5c 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/short_circuit_solver.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/short_circuit_solver.hpp @@ -31,7 +31,7 @@ template class ShortCircuitSolver { sparse_solver_{y_bus.shared_indptr_lu(), y_bus.shared_indices_lu(), y_bus.shared_diag_lu()}, perm_{static_cast(n_bus_)} {} - ShortCircuitMathOutput run_short_circuit(YBus const& y_bus, ShortCircuitInput const& input) { + ShortCircuitSolverOutput run_short_circuit(YBus const& y_bus, ShortCircuitInput const& input) { check_input_valid(input); auto const [fault_type, fault_phase] = extract_fault_type_phase(input.faults); @@ -40,7 +40,7 @@ template class ShortCircuitSolver { auto const [phase_1, phase_2] = set_phase_index(fault_phase); // output - ShortCircuitMathOutput output; + ShortCircuitSolverOutput output; output.u_bus.resize(n_bus_); output.fault.resize(input.faults.size()); output.source.resize(n_source_); @@ -73,7 +73,7 @@ template class ShortCircuitSolver { BlockPermArray perm_; void prepare_matrix_and_rhs(YBus const& y_bus, ShortCircuitInput const& input, - ShortCircuitMathOutput& output, IdxVector& infinite_admittance_fault_counter, + ShortCircuitSolverOutput& output, IdxVector& infinite_admittance_fault_counter, FaultType const& fault_type, IntS phase_1, IntS phase_2) { IdxVector const& bus_entry = y_bus.lu_diag(); @@ -221,7 +221,7 @@ template class ShortCircuitSolver { } } - void calculate_result(YBus const& y_bus, ShortCircuitInput const& input, ShortCircuitMathOutput& output, + void calculate_result(YBus const& y_bus, ShortCircuitInput const& input, ShortCircuitSolverOutput& output, IdxVector const& infinite_admittance_fault_counter, FaultType const fault_type, int const phase_1, int const phase_2) const { using enum FaultType; @@ -354,8 +354,8 @@ template class ShortCircuitSolver { } } - output.branch = y_bus.template calculate_branch_flow>(output.u_bus); - output.shunt = y_bus.template calculate_shunt_flow>(output.u_bus); + output.branch = y_bus.template calculate_branch_flow>(output.u_bus); + output.shunt = y_bus.template calculate_shunt_flow>(output.u_bus); } static constexpr auto set_phase_index(FaultPhase fault_phase) { diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp index 47d99720f1..ee7fb2d3c9 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp @@ -443,7 +443,7 @@ template class YBus { // calculate branch flow based on voltage template - requires std::same_as> || std::same_as> + requires std::same_as> || std::same_as> std::vector calculate_branch_flow(ComplexValueVector const& u) const { std::vector branch_flow(math_topology_->branch_bus_idx.size()); std::transform(math_topology_->branch_bus_idx.cbegin(), math_topology_->branch_bus_idx.cend(), @@ -459,7 +459,7 @@ template class YBus { output.i_f = dot(param.yff(), uf) + dot(param.yft(), ut); output.i_t = dot(param.ytf(), uf) + dot(param.ytt(), ut); - if constexpr (std::same_as>) { + if constexpr (std::same_as>) { // See "Shunt Injection Flow Calculation" in "State Estimation Alliander" output.s_f = uf * conj(output.i_f); output.s_t = ut * conj(output.i_t); @@ -471,18 +471,18 @@ template class YBus { } // calculate shunt flow based on voltage, injection direction - template - requires std::same_as> || - std::same_as> - std::vector calculate_shunt_flow(ComplexValueVector const& u) const { - std::vector shunt_flow(math_topology_->n_shunt()); + template + requires std::same_as> || + std::same_as> + std::vector calculate_shunt_flow(ComplexValueVector const& u) const { + std::vector shunt_flow(math_topology_->n_shunt()); for (auto const [bus, shunts] : enumerated_zip_sequence(math_topology_->shunts_per_bus)) { for (Idx const shunt : shunts) { // See "Branch/Shunt Power Flow" in "State Estimation Alliander" // NOTE: the negative sign for injection direction! shunt_flow[shunt].i = -dot(math_model_param_->shunt_param[shunt], u[bus]); - if constexpr (std::same_as>) { + if constexpr (std::same_as>) { // See "Branch/Shunt Power Flow" in "State Estimation Alliander" shunt_flow[shunt].s = u[bus] * conj(shunt_flow[shunt].i); } diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/base_optimizer.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/base_optimizer.hpp index 8aa82b3024..23d5e2ad92 100644 --- a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/base_optimizer.hpp +++ b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/base_optimizer.hpp @@ -29,7 +29,7 @@ using state_calculator_result_t = typename state_calculator_type concept steady_state_calculator_c = - steady_state_math_output_type::value_type> && + steady_state_solver_output_type::value_type> && std::same_as, std::vector::value_type>>; 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 120730ff96..cdb2775fe9 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 @@ -458,11 +458,11 @@ inline auto regulator_mapping(State const& state, RankedTransformerGroups const& return result; } -template ComponentType, steady_state_math_output_type MathOutputType> -inline auto i_pu(std::vector const& math_output, Idx2D const& math_id, ControlSide control_side) { +template ComponentType, steady_state_solver_output_type SolverOutputType> +inline auto i_pu(std::vector const& solver_output, Idx2D const& math_id, ControlSide control_side) { using enum ControlSide; - auto const& branch_output = math_output[math_id.group].branch[math_id.pos]; + auto const& branch_output = solver_output[math_id.group].branch[math_id.pos]; switch (control_side) { case from: @@ -474,12 +474,12 @@ inline auto i_pu(std::vector const& math_output, Idx2D const& ma } } -template ComponentType, steady_state_math_output_type MathOutputType> -inline auto i_pu(std::vector const& math_output, Idx2DBranch3 const& math_id, +template ComponentType, steady_state_solver_output_type SolverOutputType> +inline auto i_pu(std::vector const& solver_output, Idx2DBranch3 const& math_id, ControlSide control_side) { using enum ControlSide; - auto const& branch_outputs = math_output[math_id.group].branch; + auto const& branch_outputs = solver_output[math_id.group].branch; switch (control_side) { case side_1: @@ -494,32 +494,32 @@ inline auto i_pu(std::vector const& math_output, Idx2DBranch3 co } template + steady_state_solver_output_type SolverOutputType> requires main_core::component_container_c inline auto i_pu_controlled_node(TapRegulatorRef const& regulator, State const& state, - std::vector const& math_output) { + std::vector const& solver_output) { auto const& branch_math_id = get_math_id(state, regulator.transformer.topology_index()); - return i_pu(math_output, branch_math_id, regulator.regulator.get().control_side()); + return i_pu(solver_output, branch_math_id, regulator.regulator.get().control_side()); } -template +template requires main_core::component_container_c && requires(State const& state, Idx const i) { { get_branch_nodes(state, i)[i] } -> std::convertible_to; } -inline auto u_pu(State const& state, std::vector const& math_output, Idx topology_index, +inline auto u_pu(State const& state, std::vector const& solver_output, Idx topology_index, ControlSide control_side) { auto const controlled_node_idx = get_topo_node(state, topology_index, control_side); auto const node_math_id = get_math_id(state, controlled_node_idx); - return math_output[node_math_id.group].u[node_math_id.pos]; + return solver_output[node_math_id.group].u[node_math_id.pos]; } template + steady_state_solver_output_type SolverOutputType> requires main_core::component_container_c inline auto u_pu_controlled_node(TapRegulatorRef const& regulator, State const& state, - std::vector const& math_output) { - return u_pu(state, math_output, regulator.transformer.topology_index(), + std::vector const& solver_output) { + return u_pu(state, solver_output, regulator.transformer.topology_index(), regulator.regulator.get().control_side()); } @@ -549,32 +549,33 @@ template struct NodeState { } }; -template -inline void create_tap_regulator_output(State const& state, std::vector& math_output) { - for (Idx const group : boost::counting_range(Idx{0}, static_cast(math_output.size()))) { - math_output[group].transformer_tap_regulator.resize(state.math_topology[group]->n_transformer_tap_regulator(), - {.tap_pos = na_IntS}); +template +inline void create_tap_regulator_output(State const& state, std::vector& solver_output) { + for (Idx const group : boost::counting_range(Idx{0}, static_cast(solver_output.size()))) { + solver_output[group].transformer_tap_regulator.resize(state.math_topology[group]->n_transformer_tap_regulator(), + {.tap_pos = na_IntS}); } } -template +template inline void add_tap_regulator_output(State const& state, TransformerTapRegulator const& regulator, IntS tap_pos, - std::vector& math_output) { + std::vector& solver_output) { Idx2D const& math_id = get_math_id(state, get_topology_index(state, regulator.id())); - math_output[math_id.group].transformer_tap_regulator[math_id.pos] = {tap_pos}; + solver_output[math_id.group].transformer_tap_regulator[math_id.pos] = {tap_pos}; } -template +template requires(main_core::component_container_c && ...) void add_tap_regulator_output(State const& state, std::vector>> const& regulator_order, - std::vector& math_output) { - create_tap_regulator_output(state, math_output); + std::vector& solver_output) { + create_tap_regulator_output(state, solver_output); for (auto const& same_rank_regulators : regulator_order) { for (auto const& regulator : same_rank_regulators) { - add_tap_regulator_output(state, regulator.regulator.get(), regulator.transformer.tap_pos(), math_output); + add_tap_regulator_output(state, regulator.regulator.get(), regulator.transformer.tap_pos(), solver_output); } } } @@ -665,7 +666,7 @@ class TapPositionOptimizerImpl, StateCalculator, return result; } - bool adjust_transformer(RegulatedTransformer const& regulator, State const& state, ResultType const& math_output, + bool adjust_transformer(RegulatedTransformer const& regulator, State const& state, ResultType const& solver_output, UpdateBuffer& update_data) const { bool tap_changed = false; @@ -675,8 +676,8 @@ class TapPositionOptimizerImpl, StateCalculator, auto const param = regulator.regulator.get().template calc_param(); auto const node_state = - NodeState{.u = u_pu_controlled_node(regulator, state, math_output), - .i = i_pu_controlled_node(regulator, state, math_output)}; + NodeState{.u = u_pu_controlled_node(regulator, state, solver_output), + .i = i_pu_controlled_node(regulator, state, solver_output)}; auto const cmp = node_state <=> param; auto new_tap_pos = [&transformer, &cmp] { diff --git a/tests/cpp_integration_tests/test_main_model.cpp b/tests/cpp_integration_tests/test_main_model.cpp index c3dc4673e7..a1cdc169e0 100644 --- a/tests/cpp_integration_tests/test_main_model.cpp +++ b/tests/cpp_integration_tests/test_main_model.cpp @@ -238,10 +238,10 @@ TEST_CASE("Test main model - power flow") { } SUBCASE("Test calculate power flow") { - auto const math_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - main_model.output_result(math_output, state.sym_node.begin()); - main_model.output_result(math_output, state.sym_branch.begin()); - main_model.output_result(math_output, state.sym_appliance.begin()); + auto const solver_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + main_model.output_result(solver_output, state.sym_node.begin()); + main_model.output_result(solver_output, state.sym_branch.begin()); + main_model.output_result(solver_output, state.sym_appliance.begin()); } } @@ -251,10 +251,10 @@ TEST_CASE("Test copy main model") { MainModel model_2{main_model}; SUBCASE("Copied - Symmetrical") { - auto const math_output = model_2.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - model_2.output_result(math_output, state.sym_node.begin()); - model_2.output_result(math_output, state.sym_branch.begin()); - model_2.output_result(math_output, state.sym_appliance.begin()); + auto const solver_output = model_2.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + model_2.output_result(solver_output, state.sym_node.begin()); + model_2.output_result(solver_output, state.sym_branch.begin()); + model_2.output_result(solver_output, state.sym_appliance.begin()); CHECK(state.sym_node[0].u_pu == doctest::Approx(1.05)); CHECK(state.sym_node[1].u_pu == doctest::Approx(test::u1)); CHECK(state.sym_node[2].u_pu == doctest::Approx(test::u1)); @@ -266,10 +266,10 @@ TEST_CASE("Test copy main model") { CHECK(state.sym_appliance[4].i == doctest::Approx(test::i_shunt)); } SUBCASE("Copied - Asymmetrical") { - auto const math_output = model_2.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - model_2.output_result(math_output, state.asym_node.begin()); - model_2.output_result(math_output, state.asym_branch.begin()); - model_2.output_result(math_output, state.asym_appliance.begin()); + auto const solver_output = model_2.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + model_2.output_result(solver_output, state.asym_node.begin()); + model_2.output_result(solver_output, state.asym_branch.begin()); + model_2.output_result(solver_output, state.asym_appliance.begin()); CHECK(state.asym_node[0].u_pu(0) == doctest::Approx(1.05)); CHECK(state.asym_node[1].u_pu(1) == doctest::Approx(test::u1)); CHECK(state.asym_node[2].u_pu(2) == doctest::Approx(test::u1)); @@ -282,10 +282,10 @@ TEST_CASE("Test copy main model") { } model_2 = main_model; SUBCASE("Assigned - Symmetrical") { - auto const math_output = model_2.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - model_2.output_result(math_output, state.sym_node.begin()); - model_2.output_result(math_output, state.sym_branch.begin()); - model_2.output_result(math_output, state.sym_appliance.begin()); + auto const solver_output = model_2.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + model_2.output_result(solver_output, state.sym_node.begin()); + model_2.output_result(solver_output, state.sym_branch.begin()); + model_2.output_result(solver_output, state.sym_appliance.begin()); // TODO: check voltage angle CHECK(state.sym_node[0].u_pu == doctest::Approx(1.05)); CHECK(state.sym_node[1].u_pu == doctest::Approx(test::u1)); @@ -298,10 +298,10 @@ TEST_CASE("Test copy main model") { CHECK(state.sym_appliance[4].i == doctest::Approx(test::i_shunt)); } SUBCASE("Assigned - Asymmetrical") { - auto const math_output = model_2.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - model_2.output_result(math_output, state.asym_node.begin()); - model_2.output_result(math_output, state.asym_branch.begin()); - model_2.output_result(math_output, state.asym_appliance.begin()); + auto const solver_output = model_2.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + model_2.output_result(solver_output, state.asym_node.begin()); + model_2.output_result(solver_output, state.asym_branch.begin()); + model_2.output_result(solver_output, state.asym_appliance.begin()); CHECK(state.asym_node[0].u_pu(0) == doctest::Approx(1.05)); CHECK(state.asym_node[1].u_pu(1) == doctest::Approx(test::u1)); CHECK(state.asym_node[2].u_pu(2) == doctest::Approx(test::u1)); @@ -313,10 +313,10 @@ TEST_CASE("Test copy main model") { CHECK(state.asym_appliance[4].i(2) == doctest::Approx(test::i_shunt)); } SUBCASE("Original - Symmetrical") { - auto const math_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - main_model.output_result(math_output, state.sym_node.begin()); - main_model.output_result(math_output, state.sym_branch.begin()); - main_model.output_result(math_output, state.sym_appliance.begin()); + auto const solver_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + main_model.output_result(solver_output, state.sym_node.begin()); + main_model.output_result(solver_output, state.sym_branch.begin()); + main_model.output_result(solver_output, state.sym_appliance.begin()); CHECK(state.sym_node[0].u_pu == doctest::Approx(1.05)); CHECK(state.sym_node[1].u_pu == doctest::Approx(test::u1)); CHECK(state.sym_node[2].u_pu == doctest::Approx(test::u1)); @@ -328,10 +328,10 @@ TEST_CASE("Test copy main model") { CHECK(state.sym_appliance[4].i == doctest::Approx(test::i_shunt)); } SUBCASE("Original - Asymmetrical") { - auto const math_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - main_model.output_result(math_output, state.asym_node.begin()); - main_model.output_result(math_output, state.asym_branch.begin()); - main_model.output_result(math_output, state.asym_appliance.begin()); + auto const solver_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + main_model.output_result(solver_output, state.asym_node.begin()); + main_model.output_result(solver_output, state.asym_branch.begin()); + main_model.output_result(solver_output, state.asym_appliance.begin()); CHECK(state.asym_node[0].u_pu(0) == doctest::Approx(1.05)); CHECK(state.asym_node[1].u_pu(1) == doctest::Approx(test::u1)); CHECK(state.asym_node[2].u_pu(2) == doctest::Approx(test::u1)); @@ -349,11 +349,11 @@ TEST_CASE("Test main model - iterative calculation") { auto main_model = default_model(state); SUBCASE("Symmetrical") { - auto const math_output = + auto const solver_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::newton_raphson); - main_model.output_result(math_output, state.sym_node.begin()); - main_model.output_result(math_output, state.sym_branch.begin()); - main_model.output_result(math_output, state.sym_appliance.begin()); + main_model.output_result(solver_output, state.sym_node.begin()); + main_model.output_result(solver_output, state.sym_branch.begin()); + main_model.output_result(solver_output, state.sym_appliance.begin()); CHECK(state.sym_node[0].u_pu == doctest::Approx(1.05)); CHECK(state.sym_node[1].u_pu == doctest::Approx(test::u1)); CHECK(state.sym_node[2].u_pu == doctest::Approx(test::u1)); @@ -365,11 +365,11 @@ TEST_CASE("Test main model - iterative calculation") { CHECK(state.sym_appliance[4].i == doctest::Approx(test::i_shunt)); } SUBCASE("Asymmetrical") { - auto const math_output = + auto const solver_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::newton_raphson); - main_model.output_result(math_output, state.asym_node.begin()); - main_model.output_result(math_output, state.asym_branch.begin()); - main_model.output_result(math_output, state.asym_appliance.begin()); + main_model.output_result(solver_output, state.asym_node.begin()); + main_model.output_result(solver_output, state.asym_branch.begin()); + main_model.output_result(solver_output, state.asym_appliance.begin()); CHECK(state.asym_node[0].u_pu(0) == doctest::Approx(1.05)); CHECK(state.asym_node[1].u_pu(1) == doctest::Approx(test::u1)); CHECK(state.asym_node[2].u_pu(2) == doctest::Approx(test::u1)); @@ -735,10 +735,10 @@ TEST_CASE("Test main model - linear calculation") { auto main_model = default_model(state); SUBCASE("Symmetrical") { - auto const math_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - main_model.output_result(math_output, state.sym_node.begin()); - main_model.output_result(math_output, state.sym_branch.begin()); - main_model.output_result(math_output, state.sym_appliance.begin()); + auto const solver_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + main_model.output_result(solver_output, state.sym_node.begin()); + main_model.output_result(solver_output, state.sym_branch.begin()); + main_model.output_result(solver_output, state.sym_appliance.begin()); CHECK(state.sym_node[0].u_pu == doctest::Approx(1.05)); CHECK(state.sym_node[1].u_pu == doctest::Approx(test::u1)); CHECK(state.sym_node[2].u_pu == doctest::Approx(test::u1)); @@ -750,10 +750,10 @@ TEST_CASE("Test main model - linear calculation") { CHECK(state.sym_appliance[4].i == doctest::Approx(test::i_shunt)); } SUBCASE("Asymmetrical") { - auto const math_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - main_model.output_result(math_output, state.asym_node.begin()); - main_model.output_result(math_output, state.asym_branch.begin()); - main_model.output_result(math_output, state.asym_appliance.begin()); + auto const solver_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + main_model.output_result(solver_output, state.asym_node.begin()); + main_model.output_result(solver_output, state.asym_branch.begin()); + main_model.output_result(solver_output, state.asym_appliance.begin()); CHECK(state.asym_node[0].u_pu(0) == doctest::Approx(1.05)); CHECK(state.asym_node[1].u_pu(1) == doctest::Approx(test::u1)); CHECK(state.asym_node[2].u_pu(2) == doctest::Approx(test::u1)); @@ -787,10 +787,10 @@ TEST_CASE_TEMPLATE("Test main model - update only load", settings, regular_updat main_model.update_component(update_data); SUBCASE("Symmetrical") { - auto const math_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - main_model.output_result(math_output, state.sym_node.begin()); - main_model.output_result(math_output, state.sym_branch.begin()); - main_model.output_result(math_output, state.sym_appliance.begin()); + auto const solver_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + main_model.output_result(solver_output, state.sym_node.begin()); + main_model.output_result(solver_output, state.sym_branch.begin()); + main_model.output_result(solver_output, state.sym_appliance.begin()); CHECK(state.sym_node[0].u_pu == doctest::Approx(1.05)); CHECK(state.sym_node[1].u_pu == doctest::Approx(test::u1)); CHECK(state.sym_node[2].u_pu == doctest::Approx(test::u1)); @@ -802,10 +802,10 @@ TEST_CASE_TEMPLATE("Test main model - update only load", settings, regular_updat CHECK(state.sym_appliance[4].i == doctest::Approx(test::i_shunt)); } SUBCASE("Asymmetrical") { - auto const math_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - main_model.output_result(math_output, state.asym_node.begin()); - main_model.output_result(math_output, state.asym_branch.begin()); - main_model.output_result(math_output, state.asym_appliance.begin()); + auto const solver_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + main_model.output_result(solver_output, state.asym_node.begin()); + main_model.output_result(solver_output, state.asym_branch.begin()); + main_model.output_result(solver_output, state.asym_appliance.begin()); CHECK(state.asym_node[0].u_pu(0) == doctest::Approx(1.05)); CHECK(state.asym_node[1].u_pu(1) == doctest::Approx(test::u1)); CHECK(state.asym_node[2].u_pu(2) == doctest::Approx(test::u1)); @@ -831,10 +831,10 @@ TEST_CASE_TEMPLATE("Test main model - update load and shunt param", settings, re main_model.update_component(update_data); SUBCASE("Symmetrical") { - auto const math_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - main_model.output_result(math_output, state.sym_node.begin()); - main_model.output_result(math_output, state.sym_branch.begin()); - main_model.output_result(math_output, state.sym_appliance.begin()); + auto const solver_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + main_model.output_result(solver_output, state.sym_node.begin()); + main_model.output_result(solver_output, state.sym_branch.begin()); + main_model.output_result(solver_output, state.sym_appliance.begin()); CHECK(state.sym_node[0].u_pu == doctest::Approx(1.05)); CHECK(state.sym_node[1].u_pu == doctest::Approx(test::u1)); CHECK(state.sym_node[2].u_pu == doctest::Approx(test::u1)); @@ -846,10 +846,10 @@ TEST_CASE_TEMPLATE("Test main model - update load and shunt param", settings, re CHECK(state.sym_appliance[4].i == doctest::Approx(0.0)); } SUBCASE("Asymmetrical") { - auto const math_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - main_model.output_result(math_output, state.asym_node.begin()); - main_model.output_result(math_output, state.asym_branch.begin()); - main_model.output_result(math_output, state.asym_appliance.begin()); + auto const solver_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + main_model.output_result(solver_output, state.asym_node.begin()); + main_model.output_result(solver_output, state.asym_branch.begin()); + main_model.output_result(solver_output, state.asym_appliance.begin()); CHECK(state.asym_node[0].u_pu(0) == doctest::Approx(1.05)); CHECK(state.asym_node[1].u_pu(1) == doctest::Approx(test::u1)); CHECK(state.asym_node[2].u_pu(2) == doctest::Approx(test::u1)); @@ -879,10 +879,10 @@ TEST_CASE_TEMPLATE("Test main model - all updates", settings, regular_update, ca main_model.update_component(update_data); SUBCASE("Symmetrical") { - auto const math_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - main_model.output_result(math_output, state.sym_node.begin()); - main_model.output_result(math_output, state.sym_branch.begin()); - main_model.output_result(math_output, state.sym_appliance.begin()); + auto const solver_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + main_model.output_result(solver_output, state.sym_node.begin()); + main_model.output_result(solver_output, state.sym_branch.begin()); + main_model.output_result(solver_output, state.sym_appliance.begin()); CHECK(state.sym_node[0].u_pu == doctest::Approx(1.05)); CHECK(state.sym_node[1].u_pu == doctest::Approx(1.05)); CHECK(state.sym_node[2].u_pu == doctest::Approx(test::u1)); @@ -894,10 +894,10 @@ TEST_CASE_TEMPLATE("Test main model - all updates", settings, regular_update, ca CHECK(state.sym_appliance[4].i == doctest::Approx(0.0)); } SUBCASE("Asymmetrical") { - auto const math_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - main_model.output_result(math_output, state.asym_node.begin()); - main_model.output_result(math_output, state.asym_branch.begin()); - main_model.output_result(math_output, state.asym_appliance.begin()); + auto const solver_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + main_model.output_result(solver_output, state.asym_node.begin()); + main_model.output_result(solver_output, state.asym_branch.begin()); + main_model.output_result(solver_output, state.asym_appliance.begin()); CHECK(state.asym_node[0].u_pu(0) == doctest::Approx(1.05)); CHECK(state.asym_node[1].u_pu(1) == doctest::Approx(1.05)); CHECK(state.asym_node[2].u_pu(2) == doctest::Approx(test::u1)); @@ -914,7 +914,7 @@ TEST_CASE_TEMPLATE("Test main model - restore components", settings, regular_upd State state; auto main_model = default_model(state); - auto const math_output_orig = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + auto const solver_output_orig = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); ConstDataset const update_data{ {"sym_load", ConstDataPointer{state.sym_load_update.data(), static_cast(state.sym_load_update.size())}}, @@ -925,11 +925,11 @@ TEST_CASE_TEMPLATE("Test main model - restore components", settings, regular_upd main_model.restore_components(main_model.get_sequence_idx_map(update_data)); SUBCASE("Symmetrical") { - auto const math_output_result = + auto const solver_output_result = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - main_model.output_result(math_output_result, state.sym_node.begin()); - main_model.output_result(math_output_result, state.sym_branch.begin()); - main_model.output_result(math_output_result, state.sym_appliance.begin()); + main_model.output_result(solver_output_result, state.sym_node.begin()); + main_model.output_result(solver_output_result, state.sym_branch.begin()); + main_model.output_result(solver_output_result, state.sym_appliance.begin()); CHECK(state.sym_node[0].u_pu == doctest::Approx(1.05)); CHECK(state.sym_node[1].u_pu == doctest::Approx(test::u1)); @@ -947,10 +947,10 @@ TEST_CASE_TEMPLATE("Test main model - restore components", settings, regular_upd CHECK(state.sym_appliance[4].i == doctest::Approx(test::i_shunt)); } SUBCASE("Asymmetrical") { - auto const math_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - main_model.output_result(math_output, state.asym_node.begin()); - main_model.output_result(math_output, state.asym_branch.begin()); - main_model.output_result(math_output, state.asym_appliance.begin()); + auto const solver_output = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + main_model.output_result(solver_output, state.asym_node.begin()); + main_model.output_result(solver_output, state.asym_branch.begin()); + main_model.output_result(solver_output, state.asym_appliance.begin()); CHECK(state.asym_node[0].u_pu(0) == doctest::Approx(1.05)); CHECK(state.asym_node[1].u_pu(1) == doctest::Approx(test::u1)); @@ -970,11 +970,12 @@ TEST_CASE_TEMPLATE("Test main model - restore components", settings, regular_upd } TEST_CASE_TEMPLATE("Test main model - updates w/ alternating compute mode", settings, regular_update, cached_update) { - constexpr auto check_sym = [](MainModel const& model_, std::vector> const& math_output_) { + constexpr auto check_sym = [](MainModel const& model_, + std::vector> const& solver_output_) { State state_; - model_.output_result(math_output_, state_.sym_node.begin()); - model_.output_result(math_output_, state_.sym_branch.begin()); - model_.output_result(math_output_, state_.sym_appliance.begin()); + model_.output_result(solver_output_, state_.sym_node.begin()); + model_.output_result(solver_output_, state_.sym_branch.begin()); + model_.output_result(solver_output_, state_.sym_appliance.begin()); CHECK(state_.sym_node[0].u_pu == doctest::Approx(1.05)); CHECK(state_.sym_node[1].u_pu == doctest::Approx(test::u1)); @@ -986,11 +987,12 @@ TEST_CASE_TEMPLATE("Test main model - updates w/ alternating compute mode", sett CHECK(state_.sym_appliance[3].i == doctest::Approx(0.0)); CHECK(state_.sym_appliance[4].i == doctest::Approx(0.0)); }; - constexpr auto check_asym = [](MainModel const& model_, std::vector> const& math_output_) { + constexpr auto check_asym = [](MainModel const& model_, + std::vector> const& solver_output_) { State state_; - model_.output_result(math_output_, state_.asym_node.begin()); - model_.output_result(math_output_, state_.asym_branch.begin()); - model_.output_result(math_output_, state_.asym_appliance.begin()); + model_.output_result(solver_output_, state_.asym_node.begin()); + model_.output_result(solver_output_, state_.asym_branch.begin()); + model_.output_result(solver_output_, state_.asym_appliance.begin()); CHECK(state_.asym_node[0].u_pu(0) == doctest::Approx(1.05)); CHECK(state_.asym_node[1].u_pu(1) == doctest::Approx(test::u1)); CHECK(state_.asym_node[2].u_pu(2) == doctest::Approx(test::u1)); @@ -1015,11 +1017,12 @@ TEST_CASE_TEMPLATE("Test main model - updates w/ alternating compute mode", sett // This will lead to no topo change but param change main_model.update_component(update_data); - auto const math_output_sym_1 = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - check_sym(main_model, math_output_sym_1); + auto const solver_output_sym_1 = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + check_sym(main_model, solver_output_sym_1); - auto const math_output_asym_1 = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - check_asym(main_model, math_output_asym_1); + auto const solver_output_asym_1 = + main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + check_asym(main_model, solver_output_asym_1); SUBCASE("No new update") { // Math state may be fully cached @@ -1036,11 +1039,12 @@ TEST_CASE_TEMPLATE("Test main model - updates w/ alternating compute mode", sett main_model.update_component(update_data); } - auto const math_output_asym_2 = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - check_asym(main_model, math_output_asym_2); + auto const solver_output_asym_2 = + main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + check_asym(main_model, solver_output_asym_2); - auto const math_output_sym_2 = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); - check_sym(main_model, math_output_sym_2); + auto const solver_output_sym_2 = main_model.calculate_power_flow(1e-8, 20, CalculationMethod::linear); + check_sym(main_model, solver_output_sym_2); main_model.restore_components(main_model.get_sequence_idx_map(update_data)); } diff --git a/tests/cpp_integration_tests/test_main_model_sc.cpp b/tests/cpp_integration_tests/test_main_model_sc.cpp index fc09f0d5f9..8cafce016c 100644 --- a/tests/cpp_integration_tests/test_main_model_sc.cpp +++ b/tests/cpp_integration_tests/test_main_model_sc.cpp @@ -40,29 +40,29 @@ TEST_CASE("Test main model - short circuit") { double const u_node_abs_pu = u_node_abs / (u_rated / sqrt3); SUBCASE("Symmetric Calculation") { - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_short_circuit(voltage_scaling, CalculationMethod::iec60909); std::vector fault_output(1); - main_model.output_result(math_output, fault_output.begin()); + main_model.output_result(solver_output, fault_output.begin()); CHECK(fault_output[0].i_f(0) == doctest::Approx(i_f_abs)); std::vector node_output(1); - main_model.output_result(math_output, node_output.begin()); + main_model.output_result(solver_output, node_output.begin()); CHECK(node_output[0].u_pu(0) == doctest::Approx(u_node_abs_pu)); } SUBCASE("Asymmetric Calculation") { - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_short_circuit(voltage_scaling, CalculationMethod::iec60909); std::vector fault_output(1); - main_model.output_result(math_output, fault_output.begin()); + main_model.output_result(solver_output, fault_output.begin()); CHECK(fault_output[0].i_f(0) == doctest::Approx(i_f_abs)); std::vector node_output(1); - main_model.output_result(math_output, node_output.begin()); + main_model.output_result(solver_output, node_output.begin()); CHECK(node_output[0].u_pu(0) == doctest::Approx(u_node_abs_pu)); } } @@ -80,29 +80,29 @@ TEST_CASE("Test main model - short circuit") { double const u_node_abs_pu = u_node_abs / (u_rated / sqrt3); SUBCASE("Symmetric Calculation") { - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_short_circuit(voltage_scaling, CalculationMethod::iec60909); std::vector fault_output(1); - main_model.output_result(math_output, fault_output.begin()); + main_model.output_result(solver_output, fault_output.begin()); CHECK(fault_output[0].i_f(0) == doctest::Approx(i_f_abs)); std::vector node_output(1); - main_model.output_result(math_output, node_output.begin()); + main_model.output_result(solver_output, node_output.begin()); CHECK(node_output[0].u_pu(0) == doctest::Approx(u_node_abs_pu)); } SUBCASE("Asymmetric Calculation") { - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_short_circuit(voltage_scaling, CalculationMethod::iec60909); std::vector fault_output(1); - main_model.output_result(math_output, fault_output.begin()); + main_model.output_result(solver_output, fault_output.begin()); CHECK(fault_output[0].i_f(0) == doctest::Approx(i_f_abs)); std::vector node_output(1); - main_model.output_result(math_output, node_output.begin()); + main_model.output_result(solver_output, node_output.begin()); CHECK(node_output[0].u_pu(0) == doctest::Approx(u_node_abs_pu)); } } @@ -121,15 +121,15 @@ TEST_CASE("Test main model - short circuit") { {{5, 2, FaultType::single_phase_to_ground, FaultPhase::default_value, 1, nan, nan}}); main_model.set_construction_complete(); - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_short_circuit(voltage_scaling, CalculationMethod::iec60909); std::vector fault_output(1); - main_model.output_result(math_output, fault_output.begin()); + main_model.output_result(solver_output, fault_output.begin()); CHECK(fault_output[0].i_f(0) == doctest::Approx(voltage_scaling_c * 10e4 / sqrt3)); std::vector node_output(2); - main_model.output_result(math_output, node_output.begin()); + main_model.output_result(solver_output, node_output.begin()); CHECK(node_output[0].u_pu(0) != doctest::Approx(voltage_scaling_c)); // influenced by fault CHECK(node_output[1].u_pu(0) == doctest::Approx(0.0)); // fault location diff --git a/tests/cpp_integration_tests/test_main_model_se.cpp b/tests/cpp_integration_tests/test_main_model_se.cpp index c9306a1eaf..1e75473e45 100644 --- a/tests/cpp_integration_tests/test_main_model_se.cpp +++ b/tests/cpp_integration_tests/test_main_model_se.cpp @@ -33,18 +33,18 @@ TEST_CASE_TEMPLATE("Test main model - state estimation", CalculationMethod, Iter main_model.add_component({{3, 1, 1e2, 12.345e3, 0.1}}); main_model.set_construction_complete(); SUBCASE("Symmetric Calculation") { - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_state_estimation(1e-8, 20, calculation_method); std::vector> node_output(1); - main_model.output_result(math_output, node_output.begin()); + main_model.output_result(solver_output, node_output.begin()); CHECK(node_output[0].u == doctest::Approx(12.345e3)); CHECK(node_output[0].u_angle == doctest::Approx(0.1)); } SUBCASE("Asymmetric Calculation") { - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_state_estimation(1e-8, 20, calculation_method); std::vector> node_output(1); - main_model.output_result(math_output, node_output.begin()); + main_model.output_result(solver_output, node_output.begin()); CHECK(node_output[0].u.x() == doctest::Approx(12.345e3 / s3)); CHECK(node_output[0].u.y() == doctest::Approx(12.345e3 / s3)); CHECK(node_output[0].u.z() == doctest::Approx(12.345e3 / s3)); @@ -57,18 +57,18 @@ TEST_CASE_TEMPLATE("Test main model - state estimation", CalculationMethod, Iter main_model.add_component({{3, 1, 1e2, 12.345e3, nan}}); main_model.set_construction_complete(); SUBCASE("Symmetric Calculation") { - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_state_estimation(1e-8, 20, calculation_method); std::vector> node_output(1); - main_model.output_result(math_output, node_output.begin()); + main_model.output_result(solver_output, node_output.begin()); CHECK(node_output[0].u == doctest::Approx(12.345e3)); CHECK(node_output[0].u_angle == doctest::Approx(0.0)); } SUBCASE("Asymmetric Calculation") { - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_state_estimation(1e-8, 20, calculation_method); std::vector> node_output(1); - main_model.output_result(math_output, node_output.begin()); + main_model.output_result(solver_output, node_output.begin()); CHECK(node_output[0].u.x() == doctest::Approx(12.345e3 / s3)); CHECK(node_output[0].u.y() == doctest::Approx(12.345e3 / s3)); CHECK(node_output[0].u.z() == doctest::Approx(12.345e3 / s3)); @@ -82,10 +82,10 @@ TEST_CASE_TEMPLATE("Test main model - state estimation", CalculationMethod, Iter {{3, 1, 1e2, {12.345e3 / s3, 12.345e3 / s3, 12.345e3 / s3}, {0.1, 0.2 - ph, 0.3 + ph}}}); main_model.set_construction_complete(); SUBCASE("Symmetric Calculation") { - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_state_estimation(1e-8, 20, calculation_method); std::vector> node_output(1); - main_model.output_result(math_output, node_output.begin()); + main_model.output_result(solver_output, node_output.begin()); double const u = (std::cos(0.1) + std::cos(0.2) + std::cos(0.3)) * 12.345e3; double const v = (std::sin(0.1) + std::sin(0.2) + std::sin(0.3)) * 12.345e3; double const expected_u = std::sqrt(u * u + v * v) / 3.0; @@ -93,10 +93,10 @@ TEST_CASE_TEMPLATE("Test main model - state estimation", CalculationMethod, Iter CHECK(node_output[0].u_angle == doctest::Approx(0.2)); } SUBCASE("Asymmetric Calculation") { - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_state_estimation(1e-8, 20, calculation_method); std::vector> node_output(1); - main_model.output_result(math_output, node_output.begin()); + main_model.output_result(solver_output, node_output.begin()); CHECK(node_output[0].u.x() == doctest::Approx(12.345e3 / s3)); CHECK(node_output[0].u.y() == doctest::Approx(12.345e3 / s3)); CHECK(node_output[0].u.z() == doctest::Approx(12.345e3 / s3)); @@ -110,18 +110,18 @@ TEST_CASE_TEMPLATE("Test main model - state estimation", CalculationMethod, Iter {{3, 1, 1e2, {12.345e3 / s3, 12.345e3 / s3, 12.345e3 / s3}, {nan, nan, nan}}}); main_model.set_construction_complete(); SUBCASE("Symmetric Calculation") { - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_state_estimation(1e-8, 20, calculation_method); std::vector> node_output(1); - main_model.output_result(math_output, node_output.begin()); + main_model.output_result(solver_output, node_output.begin()); CHECK(node_output[0].u == doctest::Approx(12.345e3)); CHECK(node_output[0].u_angle == doctest::Approx(0.0)); } SUBCASE("Asymmetric Calculation") { - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_state_estimation(1e-8, 20, calculation_method); std::vector> node_output(1); - main_model.output_result(math_output, node_output.begin()); + main_model.output_result(solver_output, node_output.begin()); CHECK(node_output[0].u.x() == doctest::Approx(12.345e3 / s3)); CHECK(node_output[0].u.y() == doctest::Approx(12.345e3 / s3)); CHECK(node_output[0].u.z() == doctest::Approx(12.345e3 / s3)); @@ -146,17 +146,17 @@ TEST_CASE_TEMPLATE("Test main model - state estimation", CalculationMethod, Iter {16, 6, MeasuredTerminalType::load, 1e2, 1800.0, 180.0, nan, nan}}); SUBCASE("Without Injection Sensor") { main_model.set_construction_complete(); - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_state_estimation(1e-8, 20, calculation_method); std::vector gen_output(1); std::vector load_output(1); std::vector node_output(2); std::vector power_sensor_output(2); - main_model.output_result(math_output, gen_output.begin()); - main_model.output_result(math_output, load_output.begin()); - main_model.output_result(math_output, node_output.begin()); - main_model.output_result(math_output, power_sensor_output.begin()); + main_model.output_result(solver_output, gen_output.begin()); + main_model.output_result(solver_output, load_output.begin()); + main_model.output_result(solver_output, node_output.begin()); + main_model.output_result(solver_output, power_sensor_output.begin()); CHECK(gen_output[0].p == doctest::Approx(900.0).scale(1e3)); CHECK(gen_output[0].q == doctest::Approx(90.0).scale(1e3)); @@ -179,17 +179,17 @@ TEST_CASE_TEMPLATE("Test main model - state estimation", CalculationMethod, Iter {{12, 2, MeasuredTerminalType::node, 2e2, -1200.0, -120.0, nan, nan}}); main_model.set_construction_complete(); - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_state_estimation(1e-8, 20, calculation_method); std::vector gen_output(1); std::vector load_output(1); std::vector node_output(2); std::vector power_sensor_output(3); - main_model.output_result(math_output, gen_output.begin()); - main_model.output_result(math_output, load_output.begin()); - main_model.output_result(math_output, node_output.begin()); - main_model.output_result(math_output, power_sensor_output.begin()); + main_model.output_result(solver_output, gen_output.begin()); + main_model.output_result(solver_output, load_output.begin()); + main_model.output_result(solver_output, node_output.begin()); + main_model.output_result(solver_output, power_sensor_output.begin()); CHECK(gen_output[0].p == doctest::Approx(850.0).scale(1e3)); CHECK(gen_output[0].q == doctest::Approx(85.0).scale(1e3)); @@ -224,17 +224,17 @@ TEST_CASE_TEMPLATE("Test main model - state estimation", CalculationMethod, Iter {16, 6, MeasuredTerminalType::shunt, 1e2, 1800.0, 180.0, nan, nan}}); SUBCASE("Line flow") { main_model.set_construction_complete(); - std::vector> const math_output = + std::vector> const solver_output = main_model.calculate_state_estimation(1e-8, 20, calculation_method); std::vector shunt_output(1); std::vector node_output(2); std::vector power_sensor_output(3); std::vector> line_output(1); - main_model.output_result(math_output, shunt_output.begin()); - main_model.output_result(math_output, node_output.begin()); - main_model.output_result(math_output, line_output.begin()); - main_model.output_result(math_output, power_sensor_output.begin()); + main_model.output_result(solver_output, shunt_output.begin()); + main_model.output_result(solver_output, node_output.begin()); + main_model.output_result(solver_output, line_output.begin()); + main_model.output_result(solver_output, power_sensor_output.begin()); CHECK(shunt_output[0].p == doctest::Approx(1800.0).epsilon(0.01)); CHECK(shunt_output[0].q == doctest::Approx(180.0).epsilon(0.01)); diff --git a/tests/cpp_integration_tests/test_math_solver.cpp b/tests/cpp_integration_tests/test_math_solver.cpp index b5bff870cf..79921273b1 100644 --- a/tests/cpp_integration_tests/test_math_solver.cpp +++ b/tests/cpp_integration_tests/test_math_solver.cpp @@ -71,7 +71,7 @@ TEST_CASE("Test block") { namespace { template -void assert_output(MathOutput const& output, MathOutput const& output_ref, bool normalize_phase = false, +void assert_output(SolverOutput const& output, SolverOutput const& output_ref, bool normalize_phase = false, double tolerance = numerical_tolerance) { DoubleComplex const phase_offset = normalize_phase ? std::exp(1.0i / 180.0 * pi) : 1.0; for (size_t i = 0; i != output.u.size(); ++i) { @@ -101,7 +101,7 @@ void assert_output(MathOutput const& output, MathOutput const& output_ } template -void assert_sc_output(ShortCircuitMathOutput const& output, ShortCircuitMathOutput const& output_ref, +void assert_sc_output(ShortCircuitSolverOutput const& output, ShortCircuitSolverOutput const& output_ref, double tolerance = numerical_tolerance) { for (size_t i = 0; i != output.u_bus.size(); ++i) { check_close(output.u_bus[i], output_ref.u_bus[i], tolerance); @@ -164,7 +164,7 @@ TEST_CASE("Test math solver") { // build param, pf input, output, backwards MathModelParam param; PowerFlowInput pf_input; - MathOutput output_ref; + SolverOutput output_ref; // voltage double const vref = 1.1; double const v0 = 1.08; @@ -231,7 +231,7 @@ TEST_CASE("Test math solver") { // const z PowerFlowInput pf_input_z = pf_input; - MathOutput output_ref_z = output_ref; + SolverOutput output_ref_z = output_ref; for (size_t i = 0; i < 6; i++) { if (i % 3 == 2) { pf_input_z.s_injection[i] *= 3.0; @@ -276,7 +276,7 @@ TEST_CASE("Test math solver") { } // output - MathOutput output_ref_asym; + SolverOutput output_ref_asym; output_ref_asym.u.resize(output_ref.u.size()); for (size_t i = 0; i != output_ref.u.size(); ++i) { output_ref_asym.u[i] = ComplexValue{output_ref.u[i]}; @@ -310,7 +310,7 @@ TEST_CASE("Test math solver") { // const z PowerFlowInput pf_input_asym_z = pf_input_asym; - MathOutput output_ref_asym_z = output_ref_asym; + SolverOutput output_ref_asym_z = output_ref_asym; for (size_t i = 0; i < 6; i++) { if (i % 3 == 2) { pf_input_asym_z.s_injection[i] *= 3.0; @@ -432,7 +432,7 @@ TEST_CASE("Test math solver") { SUBCASE("Test symmetric pf solver") { MathSolver solver{topo_ptr}; CalculationInfo info; - MathOutput output = solver.run_power_flow(pf_input, 1e-12, 20, info, newton_raphson, y_bus_sym); + SolverOutput output = solver.run_power_flow(pf_input, 1e-12, 20, info, newton_raphson, y_bus_sym); assert_output(output, output_ref); // copy MathSolver solver2{solver}; @@ -448,7 +448,7 @@ TEST_CASE("Test math solver") { SUBCASE("Test symmetric iterative current pf solver") { MathSolver solver{topo_ptr}; CalculationInfo info; - MathOutput const output = + SolverOutput const output = solver.run_power_flow(pf_input, 1e-12, 20, info, iterative_current, y_bus_sym); assert_output(output, output_ref); } @@ -460,7 +460,7 @@ TEST_CASE("Test math solver") { MathSolver solver{topo_ptr}; CalculationInfo info; - MathOutput const output = + SolverOutput const output = solver.run_power_flow(pf_input, error_tolerance, 20, info, linear_current, y_bus_sym); assert_output(output, output_ref, false, result_tolerance); } @@ -479,7 +479,7 @@ TEST_CASE("Test math solver") { CalculationInfo info; // const z - MathOutput const output = solver.run_power_flow(pf_input_z, 1e-12, 20, info, linear, y_bus_sym); + SolverOutput const output = solver.run_power_flow(pf_input_z, 1e-12, 20, info, linear, y_bus_sym); assert_output(output, output_ref_z); } @@ -509,7 +509,7 @@ TEST_CASE("Test math solver") { SUBCASE("Test asymmetric pf solver") { MathSolver solver{topo_ptr}; CalculationInfo info; - MathOutput const output = + SolverOutput const output = solver.run_power_flow(pf_input_asym, 1e-12, 20, info, newton_raphson, y_bus_asym); assert_output(output, output_ref_asym); } @@ -517,7 +517,7 @@ TEST_CASE("Test math solver") { SUBCASE("Test iterative current asymmetric pf solver") { MathSolver solver{topo_ptr}; CalculationInfo info; - MathOutput const output = + SolverOutput const output = solver.run_power_flow(pf_input_asym, 1e-12, 20, info, iterative_current, y_bus_asym); assert_output(output, output_ref_asym); } @@ -526,7 +526,7 @@ TEST_CASE("Test math solver") { MathSolver solver{topo_ptr}; CalculationInfo info; // const z - MathOutput const output = + SolverOutput const output = solver.run_power_flow(pf_input_asym_z, 1e-12, 20, info, linear, y_bus_asym); assert_output(output, output_ref_asym_z); } @@ -534,7 +534,7 @@ TEST_CASE("Test math solver") { SUBCASE("Test sym se with angle") { MathSolver solver{topo_ptr}; CalculationInfo info; - MathOutput output; + SolverOutput output; SUBCASE("iterative linear") { output = solver.run_state_estimation(se_input_angle, 1e-10, 20, info, iterative_linear, y_bus_sym); @@ -549,7 +549,7 @@ TEST_CASE("Test math solver") { SUBCASE("Test sym se without angle") { MathSolver solver{topo_ptr}; CalculationInfo info; - MathOutput output; + SolverOutput output; SUBCASE("iterative linear") { output = solver.run_state_estimation(se_input_no_angle, 1e-10, 20, info, iterative_linear, y_bus_sym); @@ -564,7 +564,7 @@ TEST_CASE("Test math solver") { SUBCASE("Test sym se with angle, const z") { MathSolver solver{topo_ptr}; CalculationInfo info; - MathOutput output; + SolverOutput output; SUBCASE("iterative linear") { output = solver.run_state_estimation(se_input_angle_const_z, 1e-10, 20, info, iterative_linear, y_bus_sym); @@ -582,7 +582,7 @@ TEST_CASE("Test math solver") { auto& branch_from_power = se_input_angle.measured_branch_from_power.front(); branch_from_power.p_variance = 0.25; branch_from_power.q_variance = 0.75; - MathOutput output; + SolverOutput output; SUBCASE("iterative linear") { output = solver.run_state_estimation(se_input_angle, 1e-10, 20, info, iterative_linear, y_bus_sym); @@ -597,7 +597,7 @@ TEST_CASE("Test math solver") { SUBCASE("Test asym se with angle") { MathSolver solver{topo_ptr}; CalculationInfo info; - MathOutput output; + SolverOutput output; SUBCASE("iterative linear") { output = solver.run_state_estimation(se_input_asym_angle, 1e-10, 20, info, iterative_linear, y_bus_asym); @@ -612,7 +612,7 @@ TEST_CASE("Test math solver") { SUBCASE("Test asym se without angle") { MathSolver solver{topo_ptr}; CalculationInfo info; - MathOutput output; + SolverOutput output; SUBCASE("iterative linear") { output = solver.run_state_estimation(se_input_asym_no_angle, 1e-10, 20, info, iterative_linear, y_bus_asym); @@ -627,7 +627,7 @@ TEST_CASE("Test math solver") { SUBCASE("Test asym se with angle, const z") { MathSolver solver{topo_ptr}; CalculationInfo info; - MathOutput output; + SolverOutput output; SUBCASE("iterative linear") { output = @@ -647,7 +647,7 @@ TEST_CASE("Test math solver") { auto& branch_from_power = se_input_asym_angle.measured_branch_from_power.front(); branch_from_power.p_variance = RealValue{0.25}; branch_from_power.q_variance = RealValue{0.75}; - MathOutput output; + SolverOutput output; SUBCASE("iterative linear") { output = solver.run_state_estimation(se_input_asym_angle, 1e-10, 20, info, iterative_linear, y_bus_asym); @@ -671,30 +671,31 @@ ShortCircuitInput create_sc_test_input(FaultType fault_type, FaultPhase fault_ph return sc_input; } -template constexpr ShortCircuitMathOutput blank_sc_output(DoubleComplex vref) { - ShortCircuitMathOutput sc_output; +template constexpr ShortCircuitSolverOutput blank_sc_output(DoubleComplex vref) { + ShortCircuitSolverOutput sc_output; sc_output.u_bus = {ComplexValue(vref), ComplexValue(vref)}; sc_output.fault = {{ComplexValue{}}}; - sc_output.branch = {BranchShortCircuitMathOutput{.i_f = {ComplexValue{}}, .i_t = {ComplexValue{}}}}; + sc_output.branch = { + BranchShortCircuitSolverOutput{.i_f = {ComplexValue{}}, .i_t = {ComplexValue{}}}}; sc_output.source = {{ComplexValue{}}}; return sc_output; } template -constexpr ShortCircuitMathOutput create_math_sc_output(ComplexValue u0, ComplexValue u1, - ComplexValue if_abc) { - ShortCircuitMathOutput sc_output; +constexpr ShortCircuitSolverOutput create_math_sc_output(ComplexValue u0, ComplexValue u1, + ComplexValue if_abc) { + ShortCircuitSolverOutput sc_output; sc_output.u_bus = {u0, u1}; sc_output.fault = {{if_abc}}; - sc_output.branch = {BranchShortCircuitMathOutput{.i_f = if_abc, .i_t = -if_abc}}; + sc_output.branch = {BranchShortCircuitSolverOutput{.i_f = if_abc, .i_t = -if_abc}}; sc_output.source = {{if_abc}}; return sc_output; } template -ShortCircuitMathOutput create_sc_test_output(FaultType fault_type, DoubleComplex const& z_fault, - DoubleComplex const& z0, DoubleComplex const& z0_0, double const vref, - DoubleComplex const& zref) { +ShortCircuitSolverOutput create_sc_test_output(FaultType fault_type, DoubleComplex const& z_fault, + DoubleComplex const& z0, DoubleComplex const& z0_0, + double const vref, DoubleComplex const& zref) { if constexpr (is_symmetric_v) { DoubleComplex const if_abc = vref / (z0 + zref + z_fault); @@ -985,7 +986,7 @@ TEST_CASE("Short circuit solver") { DoubleComplex const if_c_2phg_solid = vref * a / zref; SUBCASE("Source on 3ph sym fault") { - ShortCircuitMathOutput sc_output_ref; + ShortCircuitSolverOutput sc_output_ref; sc_output_ref.u_bus = {uf_comp}; sc_output_ref.fault = {{if_comp}}; sc_output_ref.branch = {}; @@ -998,7 +999,7 @@ TEST_CASE("Short circuit solver") { } SUBCASE("Source on 3ph sym solid fault") { - ShortCircuitMathOutput sc_output_ref; + ShortCircuitSolverOutput sc_output_ref; sc_output_ref.u_bus = {DoubleComplex{uf_comp_solid}}; sc_output_ref.fault = {{if_comp_solid}}; sc_output_ref.branch = {}; @@ -1011,7 +1012,7 @@ TEST_CASE("Short circuit solver") { } SUBCASE("Source on 3ph fault") { - ShortCircuitMathOutput sc_output_ref; + ShortCircuitSolverOutput sc_output_ref; sc_output_ref.u_bus = {ComplexValue{uf_comp}}; sc_output_ref.fault = {{ComplexValue{if_comp}}}; sc_output_ref.branch = {}; @@ -1024,7 +1025,7 @@ TEST_CASE("Short circuit solver") { } SUBCASE("Source on 1phg fault") { - ShortCircuitMathOutput sc_output_ref; + ShortCircuitSolverOutput sc_output_ref; sc_output_ref.u_bus = {ComplexValue{uf_comp, vref * a * a, vref * a}}; sc_output_ref.fault = {{ComplexValue{if_comp, 0, 0}}}; sc_output_ref.branch = {}; @@ -1037,7 +1038,7 @@ TEST_CASE("Short circuit solver") { } SUBCASE("Source on 1phg solid fault") { - ShortCircuitMathOutput sc_output_ref; + ShortCircuitSolverOutput sc_output_ref; sc_output_ref.u_bus = {ComplexValue{uf_comp_solid, vref * a * a, vref * a}}; sc_output_ref.fault = {{ComplexValue{if_comp_solid, 0, 0}}}; sc_output_ref.branch = {}; @@ -1051,7 +1052,7 @@ TEST_CASE("Short circuit solver") { } SUBCASE("Source on 2ph fault") { - ShortCircuitMathOutput sc_output_ref; + ShortCircuitSolverOutput sc_output_ref; sc_output_ref.u_bus = {ComplexValue{vref, uf_b_comp, uf_c_comp}}; sc_output_ref.fault = {{ComplexValue{0.0, if_b_comp, -if_b_comp}}}; sc_output_ref.branch = {}; @@ -1064,7 +1065,7 @@ TEST_CASE("Short circuit solver") { } SUBCASE("Source on 2ph solid fault") { - ShortCircuitMathOutput sc_output_ref; + ShortCircuitSolverOutput sc_output_ref; sc_output_ref.u_bus = {ComplexValue{vref, uf_b_comp_solid, uf_c_comp_solid}}; sc_output_ref.fault = {{ComplexValue{0.0, if_b_comp_solid, -if_b_comp_solid}}}; sc_output_ref.branch = {}; @@ -1077,7 +1078,7 @@ TEST_CASE("Short circuit solver") { } SUBCASE("Source on 2phg fault") { - ShortCircuitMathOutput sc_output_ref; + ShortCircuitSolverOutput sc_output_ref; sc_output_ref.u_bus = {ComplexValue{vref, uf_b_2phg, uf_b_2phg}}; sc_output_ref.fault = {{ComplexValue{0.0, if_b_2phg, if_c_2phg}}}; sc_output_ref.branch = {}; @@ -1090,7 +1091,7 @@ TEST_CASE("Short circuit solver") { } SUBCASE("Source on 2phg solid fault") { - ShortCircuitMathOutput sc_output_ref; + ShortCircuitSolverOutput sc_output_ref; sc_output_ref.u_bus = {ComplexValue{vref, uf_b_2phg_solid, uf_b_2phg_solid}}; sc_output_ref.fault = {{ComplexValue{0.0, if_b_2phg_solid, if_c_2phg_solid}}}; sc_output_ref.branch = {}; @@ -1139,7 +1140,7 @@ TEST_CASE("Math solver, zero variance test") { MathSolver solver{topo_ptr}; CalculationInfo info; - MathOutput output; + SolverOutput output; SUBCASE("iterative linear") { output = solver.run_state_estimation(se_input, 1e-10, 20, info, iterative_linear, y_bus_sym); @@ -1187,7 +1188,7 @@ TEST_CASE("Math solver, measurements") { se_input.measured_voltage = {{1.0, 0.1}}; CalculationInfo info; - MathOutput output; + SolverOutput output; SUBCASE("Source and branch") { /* diff --git a/tests/cpp_unit_tests/test_line.cpp b/tests/cpp_unit_tests/test_line.cpp index 5786b07603..b06b3e374a 100644 --- a/tests/cpp_unit_tests/test_line.cpp +++ b/tests/cpp_unit_tests/test_line.cpp @@ -149,12 +149,12 @@ TEST_CASE("Test line") { } SUBCASE("Symmetric results with direct power and current output") { - BranchMathOutput branch_math_output{}; - branch_math_output.i_f = 1.0 - 2.0i; - branch_math_output.i_t = 2.0 - 1.0i; - branch_math_output.s_f = 1.0 - 1.5i; - branch_math_output.s_t = 1.5 - 1.5i; - BranchOutput output = branch.get_output(branch_math_output); + BranchSolverOutput branch_solver_output{}; + branch_solver_output.i_f = 1.0 - 2.0i; + branch_solver_output.i_t = 2.0 - 1.0i; + branch_solver_output.s_f = 1.0 - 1.5i; + branch_solver_output.s_t = 1.5 - 1.5i; + BranchOutput output = branch.get_output(branch_solver_output); CHECK(output.id == 1); CHECK(output.energized); CHECK(output.loading == doctest::Approx(cabs(2.0 - 1.0i) * base_i / input.i_n)); diff --git a/tests/cpp_unit_tests/test_load_gen.cpp b/tests/cpp_unit_tests/test_load_gen.cpp index e18c0e6955..0c05f2b171 100644 --- a/tests/cpp_unit_tests/test_load_gen.cpp +++ b/tests/cpp_unit_tests/test_load_gen.cpp @@ -58,19 +58,19 @@ TEST_CASE("Test load generator") { double const i_i = s_i / (1.1 * 10e3) / sqrt3; double const p_pu = 3e6 / base_power_3p; - ApplianceMathOutput appliance_math_output_sym; - appliance_math_output_sym.i = 1.0 + 2.0i; - appliance_math_output_sym.s = 3.0 + 4.0i; + ApplianceSolverOutput appliance_solver_output_sym; + appliance_solver_output_sym.i = 1.0 + 2.0i; + appliance_solver_output_sym.s = 3.0 + 4.0i; - ApplianceMathOutput appliance_math_output_sym_reverse; - appliance_math_output_sym_reverse.i = -1.0 - 2.0i; - appliance_math_output_sym_reverse.s = -3.0 - 4.0i; + ApplianceSolverOutput appliance_solver_output_sym_reverse; + appliance_solver_output_sym_reverse.i = -1.0 - 2.0i; + appliance_solver_output_sym_reverse.s = -3.0 - 4.0i; - ApplianceMathOutput appliance_math_output_asym; + ApplianceSolverOutput appliance_solver_output_asym; ComplexValue const i_a{1.0 + 2.0i}; ComplexValue const s_a{3.0 + 4.0i, 3.0 + 4.0i, 3.0 + 4.0i}; - appliance_math_output_asym.i = i_a; - appliance_math_output_asym.s = s_a; + appliance_solver_output_asym.i = i_a; + appliance_solver_output_asym.s = s_a; CHECK(sym_gen_pq.math_model_type() == ComponentType::generic_load_gen); @@ -114,7 +114,7 @@ TEST_CASE("Test load generator") { SUBCASE("Test symmetric generator with constant power; s,i as input") { GenericLoadGen const& load_gen = sym_gen_pq; // sym result - ApplianceOutput const sym_result = load_gen.get_output(appliance_math_output_sym); + ApplianceOutput const sym_result = load_gen.get_output(appliance_solver_output_sym); CHECK(sym_result.id == 1); CHECK(sym_result.energized); CHECK(sym_result.p == doctest::Approx(3.0 * base_power)); @@ -123,7 +123,8 @@ TEST_CASE("Test load generator") { CHECK(sym_result.i == doctest::Approx(cabs(1.0 + 2.0i) * base_i)); CHECK(sym_result.pf == doctest::Approx(3.0 / cabs(3.0 + 4.0i))); // asym result - ApplianceOutput const asym_result = load_gen.get_output(appliance_math_output_asym); + ApplianceOutput const asym_result = + load_gen.get_output(appliance_solver_output_asym); CHECK(asym_result.p(0) == doctest::Approx(3.0 * base_power)); CHECK(asym_result.q(1) == doctest::Approx(4.0 * base_power)); CHECK(asym_result.s(2) == doctest::Approx(5.0 * base_power)); @@ -131,7 +132,7 @@ TEST_CASE("Test load generator") { CHECK(asym_result.pf(1) == doctest::Approx(3.0 / cabs(3.0 + 4.0i))); // reverse result ApplianceOutput const reverse_result = - load_gen.get_output(appliance_math_output_sym_reverse); + load_gen.get_output(appliance_solver_output_sym_reverse); CHECK(reverse_result.id == 1); CHECK(reverse_result.energized); CHECK(reverse_result.p == doctest::Approx(-3.0 * base_power)); @@ -171,7 +172,7 @@ TEST_CASE("Test load generator") { SUBCASE("Test asymmetric load with constant power; s, i as input") { GenericLoadGen const& load_gen = asym_load_pq; // sym result - ApplianceOutput const sym_result = load_gen.get_output(appliance_math_output_sym); + ApplianceOutput const sym_result = load_gen.get_output(appliance_solver_output_sym); CHECK(sym_result.id == 1); CHECK(sym_result.energized); CHECK(sym_result.p == doctest::Approx(-3.0 * base_power)); @@ -180,7 +181,8 @@ TEST_CASE("Test load generator") { CHECK(sym_result.i == doctest::Approx(cabs(1.0 + 2.0i) * base_i)); CHECK(sym_result.pf == doctest::Approx(-3.0 / cabs(3.0 + 4.0i))); // asym result - ApplianceOutput const asym_result = load_gen.get_output(appliance_math_output_asym); + ApplianceOutput const asym_result = + load_gen.get_output(appliance_solver_output_asym); CHECK(asym_result.p(0) == doctest::Approx(-3.0 * base_power)); CHECK(asym_result.q(1) == doctest::Approx(-4.0 * base_power)); CHECK(asym_result.s(2) == doctest::Approx(5.0 * base_power)); @@ -211,7 +213,7 @@ TEST_CASE("Test load generator") { SUBCASE("Test symmetric load with constant current; s, i as input") { GenericLoadGen const& load_gen = sym_load_i; // sym result - ApplianceOutput const sym_result = load_gen.get_output(appliance_math_output_sym); + ApplianceOutput const sym_result = load_gen.get_output(appliance_solver_output_sym); CHECK(sym_result.id == 1); CHECK(sym_result.energized); CHECK(sym_result.p == doctest::Approx(-3.0 * base_power)); @@ -220,7 +222,8 @@ TEST_CASE("Test load generator") { CHECK(sym_result.i == doctest::Approx(cabs(1.0 + 2.0i) * base_i)); CHECK(sym_result.pf == doctest::Approx(-3.0 / cabs(3.0 + 4.0i))); // asym result - ApplianceOutput const asym_result = load_gen.get_output(appliance_math_output_asym); + ApplianceOutput const asym_result = + load_gen.get_output(appliance_solver_output_asym); CHECK(asym_result.p(0) == doctest::Approx(-3.0 * base_power)); CHECK(asym_result.q(1) == doctest::Approx(-4.0 * base_power)); CHECK(asym_result.s(2) == doctest::Approx(5.0 * base_power)); @@ -228,7 +231,7 @@ TEST_CASE("Test load generator") { CHECK(asym_result.pf(1) == doctest::Approx(-3.0 / cabs(3.0 + 4.0i))); // reverse direction ApplianceOutput const reverse_result = - load_gen.get_output(appliance_math_output_sym_reverse); + load_gen.get_output(appliance_solver_output_sym_reverse); CHECK(reverse_result.id == 1); CHECK(reverse_result.energized); CHECK(reverse_result.p == doctest::Approx(3.0 * base_power)); @@ -261,7 +264,7 @@ TEST_CASE("Test load generator") { SUBCASE("Test asymmetric generator with constant addmittance; s, i as input") { GenericLoadGen const& load_gen = asym_gen_y; // sym result - ApplianceOutput const sym_result = load_gen.get_output(appliance_math_output_sym); + ApplianceOutput const sym_result = load_gen.get_output(appliance_solver_output_sym); CHECK(sym_result.id == 1); CHECK(sym_result.energized); CHECK(sym_result.p == doctest::Approx(3.0 * base_power)); @@ -270,7 +273,8 @@ TEST_CASE("Test load generator") { CHECK(sym_result.i == doctest::Approx(cabs(1.0 + 2.0i) * base_i)); CHECK(sym_result.pf == doctest::Approx(3.0 / cabs(3.0 + 4.0i))); // asym result - ApplianceOutput const asym_result = load_gen.get_output(appliance_math_output_asym); + ApplianceOutput const asym_result = + load_gen.get_output(appliance_solver_output_asym); CHECK(asym_result.p(0) == doctest::Approx(3.0 * base_power)); CHECK(asym_result.q(1) == doctest::Approx(4.0 * base_power)); CHECK(asym_result.s(2) == doctest::Approx(5.0 * base_power)); diff --git a/tests/cpp_unit_tests/test_optimizer.hpp b/tests/cpp_unit_tests/test_optimizer.hpp index 5bba363e58..5d185374a8 100644 --- a/tests/cpp_unit_tests/test_optimizer.hpp +++ b/tests/cpp_unit_tests/test_optimizer.hpp @@ -57,18 +57,18 @@ constexpr auto get_math_id(State const& /* state */, Idx /* topology_sequence_id return StubTransformerMathIdType{}; } -template ComponentType, steady_state_math_output_type MathOutputType> -inline auto i_pu(std::vector const& /* math_output */, StubTransformerMathIdType const& /* math_id */, - ControlSide /* side */) { - return ComplexValue{}; +template ComponentType, steady_state_solver_output_type SolverOutputType> +inline auto i_pu(std::vector const& /* solver_output */, + StubTransformerMathIdType const& /* math_id */, ControlSide /* side */) { + return ComplexValue{}; } template ComponentType, typename State, - steady_state_math_output_type MathOutputType> + steady_state_solver_output_type SolverOutputType> requires main_core::component_container_c -inline auto u_pu(State const& /* state */, std::vector const& /* math_output */, +inline auto u_pu(State const& /* state */, std::vector const& /* solver_output */, Idx /* topology_index */, ControlSide /* control_side */) { - return ComplexValue{}; + return ComplexValue{}; } // TODO(mgovers) revert @@ -89,10 +89,10 @@ struct StubUpdateType {}; using StubStateCalculator = StubStateCalculatorResultType (*)(StubState const& /* state */, CalculationMethod /* method */); -using SymStubSteadyStateCalculator = std::vector> (*)(StubState const& /* state */, - CalculationMethod /* method */); -using AsymStubSteadyStateCalculator = std::vector> (*)(StubState const& /* state */, +using SymStubSteadyStateCalculator = std::vector> (*)(StubState const& /* state */, CalculationMethod /* method */); +using AsymStubSteadyStateCalculator = std::vector> (*)(StubState const& /* state */, + CalculationMethod /* method */); using StubUpdate = void (*)(StubUpdateType const& /* update_data */); using ConstDatasetUpdate = void (*)(ConstDataset const& /* update_data */); @@ -101,10 +101,10 @@ static_assert(std::same_as); static_assert(std::invocable); static_assert(std::same_as, - std::vector>>); + std::vector>>); static_assert(std::invocable); static_assert(std::same_as, - std::vector>>); + std::vector>>); static_assert(std::invocable); static_assert(std::invocable); @@ -119,7 +119,7 @@ static_assert(std::convertible_to constexpr auto stub_steady_state_state_calculator(StubState const& /* state */, CalculationMethod /* method */) { - return std::vector>{}; + return std::vector>{}; } static_assert( std::convertible_to), SymStubSteadyStateCalculator>); diff --git a/tests/cpp_unit_tests/test_shunt.cpp b/tests/cpp_unit_tests/test_shunt.cpp index e5e98645b3..079f726336 100644 --- a/tests/cpp_unit_tests/test_shunt.cpp +++ b/tests/cpp_unit_tests/test_shunt.cpp @@ -64,10 +64,10 @@ TEST_CASE("Test shunt") { } SUBCASE("Symmetric test results; s, i as input") { - ApplianceMathOutput appliance_math_output_sym; - appliance_math_output_sym.i = 1.0 + 2.0i; - appliance_math_output_sym.s = 3.0 + 4.0i; - ApplianceOutput sym_result = shunt.get_output(appliance_math_output_sym); + ApplianceSolverOutput appliance_solver_output_sym; + appliance_solver_output_sym.i = 1.0 + 2.0i; + appliance_solver_output_sym.s = 3.0 + 4.0i; + ApplianceOutput sym_result = shunt.get_output(appliance_solver_output_sym); CHECK(sym_result.id == 1); CHECK(sym_result.energized); CHECK(sym_result.p == doctest::Approx(-3.0 * base_power)); @@ -78,12 +78,12 @@ TEST_CASE("Test shunt") { } SUBCASE("Asymmetric test results; s, i as input") { - ApplianceMathOutput appliance_math_output_asym; + ApplianceSolverOutput appliance_solver_output_asym; ComplexValue const i_a{1.0 + 2.0i}; ComplexValue const s_a{3.0 + 4.0i, 3.0 + 4.0i, 3.0 + 4.0i}; - appliance_math_output_asym.i = i_a; - appliance_math_output_asym.s = s_a; - ApplianceOutput asym_result = shunt.get_output(appliance_math_output_asym); + appliance_solver_output_asym.i = i_a; + appliance_solver_output_asym.s = s_a; + ApplianceOutput asym_result = shunt.get_output(appliance_solver_output_asym); CHECK(asym_result.id == 1); CHECK(asym_result.energized); CHECK(asym_result.p(0) == doctest::Approx(-3.0 * base_power)); diff --git a/tests/cpp_unit_tests/test_source.cpp b/tests/cpp_unit_tests/test_source.cpp index 2b6b16cac2..ca34a6197d 100644 --- a/tests/cpp_unit_tests/test_source.cpp +++ b/tests/cpp_unit_tests/test_source.cpp @@ -104,10 +104,10 @@ TEST_CASE("Test source") { } SUBCASE("test source sym results; s, i as input") { - ApplianceMathOutput appliance_math_output_sym; - appliance_math_output_sym.i = 1.0 + 2.0i; - appliance_math_output_sym.s = 3.0 + 4.0i; - ApplianceOutput const sym_result = source.get_output(appliance_math_output_sym); + ApplianceSolverOutput appliance_solver_output_sym; + appliance_solver_output_sym.i = 1.0 + 2.0i; + appliance_solver_output_sym.s = 3.0 + 4.0i; + ApplianceOutput const sym_result = source.get_output(appliance_solver_output_sym); CHECK(sym_result.id == 1); CHECK(sym_result.energized); CHECK(sym_result.p == doctest::Approx(3.0 * base_power)); @@ -126,12 +126,12 @@ TEST_CASE("Test source") { } SUBCASE("test source asym results; s, i as input") { - ApplianceMathOutput appliance_math_output_asym; + ApplianceSolverOutput appliance_solver_output_asym; ComplexValue const i_a{1.0 + 2.0i}; ComplexValue const s_a{3.0 + 4.0i, 3.0 + 4.0i, 3.0 + 4.0i}; - appliance_math_output_asym.i = i_a; - appliance_math_output_asym.s = s_a; - ApplianceOutput const asym_result = source.get_output(appliance_math_output_asym); + appliance_solver_output_asym.i = i_a; + appliance_solver_output_asym.s = s_a; + ApplianceOutput const asym_result = source.get_output(appliance_solver_output_asym); CHECK(asym_result.id == 1); CHECK(asym_result.energized); CHECK(asym_result.p(0) == doctest::Approx(3.0 * base_power)); @@ -144,7 +144,7 @@ TEST_CASE("Test source") { SUBCASE("test asym source short circuit results") { ComplexValue const i_asym{1.0 + 2.0i}; ApplianceShortCircuitOutput const asym_sc_result = - source.get_sc_output(ApplianceShortCircuitMathOutput{i_asym}); + source.get_sc_output(ApplianceShortCircuitSolverOutput{i_asym}); CHECK(asym_sc_result.id == 1); CHECK(asym_sc_result.energized == 1); CHECK(asym_sc_result.i(0) == doctest::Approx(cabs(1.0 + 2.0i) * base_i)); @@ -158,9 +158,9 @@ TEST_CASE("Test source") { DoubleComplex const i_sym = 1.0 + 2.0i; ComplexValue const i_asym{1.0 + 2.0i}; ApplianceShortCircuitOutput const sym_sc_result = - source.get_sc_output(ApplianceShortCircuitMathOutput{i_sym}); + source.get_sc_output(ApplianceShortCircuitSolverOutput{i_sym}); ApplianceShortCircuitOutput const asym_sc_result = - source.get_sc_output(ApplianceShortCircuitMathOutput{i_asym}); + source.get_sc_output(ApplianceShortCircuitSolverOutput{i_asym}); CHECK(sym_sc_result.id == asym_sc_result.id); CHECK(sym_sc_result.energized == asym_sc_result.energized); CHECK(sym_sc_result.i(0) == doctest::Approx(asym_sc_result.i(0))); diff --git a/tests/cpp_unit_tests/test_tap_position_optimizer.cpp b/tests/cpp_unit_tests/test_tap_position_optimizer.cpp index 16ebc7e0a8..97631f9da5 100644 --- a/tests/cpp_unit_tests/test_tap_position_optimizer.cpp +++ b/tests/cpp_unit_tests/test_tap_position_optimizer.cpp @@ -288,10 +288,10 @@ using power_grid_model::optimizer::test::StubTransformerUpdate; template requires main_core::main_model_state_c> -class MockMathOutput : public MathOutput { +class MockSolverOutput : public SolverOutput { public: - using type = math_output_t; - using sym = typename MathOutput::sym; + using type = solver_output_t; + using sym = typename SolverOutput::sym; Idx call_index{-1}; CalculationMethod method; @@ -300,8 +300,8 @@ class MockMathOutput : public MathOutput { std::map output_tap_positions; template - MockMathOutput(Idx call_index_, CalculationMethod method_, - std::reference_wrapper const> state_) + MockSolverOutput(Idx call_index_, CalculationMethod method_, + std::reference_wrapper const> state_) : call_index{call_index_}, method{method_}, state{state_} { add_tap_positions(state.value().get()); } @@ -331,39 +331,39 @@ class MockMathOutput : public MathOutput { template requires main_core::main_model_state_c> inline void create_tap_regulator_output(main_core::MainModelState const& /* state */, - std::vector>& /* math_output */) {} + std::vector>& /* solver_output */) {} template requires main_core::main_model_state_c> inline void add_tap_regulator_output(main_core::MainModelState const& /* state */, TransformerTapRegulator const& regulator, IntS tap_pos, - std::vector>& math_output) { - REQUIRE(math_output.size() > 0); + std::vector>& solver_output) { + REQUIRE(solver_output.size() > 0); // state consistency - CHECK(math_output.front().state_tap_positions[regulator.regulated_object()] == tap_pos); + CHECK(solver_output.front().state_tap_positions[regulator.regulated_object()] == tap_pos); // add to output - REQUIRE(!math_output.front().output_tap_positions.contains(regulator.id())); - math_output.front().output_tap_positions[regulator.id()] = tap_pos; + REQUIRE(!solver_output.front().output_tap_positions.contains(regulator.id())); + solver_output.front().output_tap_positions[regulator.id()] = tap_pos; } template requires main_core::main_model_state_c> -inline IntS get_state_tap_pos(std::vector> const& math_output, ID id) { - REQUIRE(math_output.size() > 0); - return math_output.front().state_tap_positions.at(id); +inline IntS get_state_tap_pos(std::vector> const& solver_output, ID id) { + REQUIRE(solver_output.size() > 0); + return solver_output.front().state_tap_positions.at(id); } template requires main_core::main_model_state_c> -inline IntS get_output_tap_pos(std::vector> const& math_output, ID id) { - REQUIRE(math_output.size() > 0); - return math_output.front().output_tap_positions.at(id); +inline IntS get_output_tap_pos(std::vector> const& solver_output, ID id) { + REQUIRE(solver_output.size() > 0); + return solver_output.front().output_tap_positions.at(id); } template -using MockStateCalculator = std::vector> (*)( +using MockStateCalculator = std::vector> (*)( main_core::MainModelState const& state, CalculationMethod method); struct A {}; @@ -467,28 +467,28 @@ constexpr auto get_math_id(State const& state, Idx topology_index) { } template ComponentType, typename ContainerType> -inline auto i_pu(std::vector> const& math_output, Idx2D const& math_id, +inline auto i_pu(std::vector> const& solver_output, Idx2D const& math_id, ControlSide side) { REQUIRE(math_id.group >= 0); - REQUIRE(math_id.group < math_output.size()); - REQUIRE(math_output[math_id.group].state.has_value()); - CHECK(math_output[math_id.group].call_index >= 0); - return main_core::get_component_by_sequence(math_output[math_id.group].state.value().get(), + REQUIRE(math_id.group < solver_output.size()); + REQUIRE(solver_output[math_id.group].state.has_value()); + CHECK(solver_output[math_id.group].call_index >= 0); + return main_core::get_component_by_sequence(solver_output[math_id.group].state.value().get(), math_id.pos) .state.i_pu(side); } template ComponentType, typename State, - steady_state_math_output_type MathOutputType> + steady_state_solver_output_type SolverOutputType> requires main_core::component_container_c -inline auto u_pu(State const& state, std::vector const& /* math_output */, Idx topology_index, +inline auto u_pu(State const& state, std::vector const& /* solver_output */, Idx topology_index, ControlSide side) { return main_core::get_component_by_sequence(state, topology_index).state.u_pu(side); } template -std::vector> mock_state_calculator(main_core::MainModelState const& state, - CalculationMethod method) { +std::vector> +mock_state_calculator(main_core::MainModelState const& state, CalculationMethod method) { static Idx call_count{}; return {{call_count++, method, std::cref(state)}}; diff --git a/tests/cpp_unit_tests/test_three_winding_transformer.cpp b/tests/cpp_unit_tests/test_three_winding_transformer.cpp index 07494fb363..75cdb1487d 100644 --- a/tests/cpp_unit_tests/test_three_winding_transformer.cpp +++ b/tests/cpp_unit_tests/test_three_winding_transformer.cpp @@ -319,9 +319,9 @@ TEST_CASE("Test three winding transformer") { SUBCASE("Check output of branch 3") { // TODO asym output check // Branch initialization: s_f, s_t, i_f, i_t - BranchMathOutput const b1_output{(1.0 - 2.0i), (2.0 - 3.0i), (1.5 - 2.5i), (2.5 - 3.5i)}; - BranchMathOutput const b2_output{(2.0 - 3.0i), (-3.0 + 2.0i), (1.5 - 2.5i), (-4.0 + 1.5i)}; - BranchMathOutput const b3_output{(3.0 + 1.0i), (1.0 + 1.0i), (1.5 - 2.5i), (1.5 + 2.0i)}; + BranchSolverOutput const b1_output{(1.0 - 2.0i), (2.0 - 3.0i), (1.5 - 2.5i), (2.5 - 3.5i)}; + BranchSolverOutput const b2_output{(2.0 - 3.0i), (-3.0 + 2.0i), (1.5 - 2.5i), (-4.0 + 1.5i)}; + BranchSolverOutput const b3_output{(3.0 + 1.0i), (1.0 + 1.0i), (1.5 - 2.5i), (1.5 + 2.0i)}; Branch3Output sym_output = vec[0].get_output(b1_output, b2_output, b3_output); @@ -358,18 +358,18 @@ TEST_CASE("Test three winding transformer") { CHECK(sym_output.s_3 == doctest::Approx(out_s_3)); CHECK(sym_output.loading == doctest::Approx(out_loading)); - BranchMathOutput const asym_b1_output{{(1.0 - 2.0i), (1.0 - 2.0i), (1.0 - 2.0i)}, - {(2.0 - 3.0i), (2.0 - 3.0i), (2.0 - 3.0i)}, - {(1.5 - 2.5i), (1.5 - 2.5i), (1.5 - 2.5i)}, - {(2.5 - 3.5i), (2.5 - 3.5i), (2.5 - 3.5i)}}; - BranchMathOutput const asym_b2_output{{(2.0 - 3.0i), (2.0 - 3.0i), (2.0 - 3.0i)}, - {(-3.0 + 2.0i), (-3.0 + 2.0i), (-3.0 + 2.0i)}, - {(1.5 - 2.5i), (1.5 - 2.5i), (1.5 - 2.5i)}, - {(-4.0 + 1.5i), (-4.0 + 1.5i), (-4.0 + 1.5i)}}; - BranchMathOutput const asym_b3_output{{(3.0 + 1.0i), (3.0 + 1.0i), (3.0 + 1.0i)}, - {(1.0 + 1.0i), (1.0 + 1.0i), (1.0 + 1.0i)}, - {(1.5 - 2.5i), (1.5 - 2.5i), (1.5 - 2.5i)}, - {(1.5 + 2.0i), (1.5 + 2.0i), (1.5 + 2.0i)}}; + BranchSolverOutput const asym_b1_output{{(1.0 - 2.0i), (1.0 - 2.0i), (1.0 - 2.0i)}, + {(2.0 - 3.0i), (2.0 - 3.0i), (2.0 - 3.0i)}, + {(1.5 - 2.5i), (1.5 - 2.5i), (1.5 - 2.5i)}, + {(2.5 - 3.5i), (2.5 - 3.5i), (2.5 - 3.5i)}}; + BranchSolverOutput const asym_b2_output{{(2.0 - 3.0i), (2.0 - 3.0i), (2.0 - 3.0i)}, + {(-3.0 + 2.0i), (-3.0 + 2.0i), (-3.0 + 2.0i)}, + {(1.5 - 2.5i), (1.5 - 2.5i), (1.5 - 2.5i)}, + {(-4.0 + 1.5i), (-4.0 + 1.5i), (-4.0 + 1.5i)}}; + BranchSolverOutput const asym_b3_output{{(3.0 + 1.0i), (3.0 + 1.0i), (3.0 + 1.0i)}, + {(1.0 + 1.0i), (1.0 + 1.0i), (1.0 + 1.0i)}, + {(1.5 - 2.5i), (1.5 - 2.5i), (1.5 - 2.5i)}, + {(1.5 + 2.0i), (1.5 + 2.0i), (1.5 + 2.0i)}}; Branch3Output asym_output = vec[0].get_output(asym_b1_output, asym_b2_output, asym_b3_output); @@ -415,9 +415,9 @@ TEST_CASE("Test three winding transformer") { ComplexValue const i_2{1.0 - 2.2i}; ComplexValue const i_3{1.3 - 2.1i}; - BranchShortCircuitMathOutput const sym_b1_output{i_1, ComplexValue{}}; - BranchShortCircuitMathOutput const sym_b2_output{i_2, ComplexValue{}}; - BranchShortCircuitMathOutput const sym_b3_output{i_3, ComplexValue{}}; + BranchShortCircuitSolverOutput const sym_b1_output{i_1, ComplexValue{}}; + BranchShortCircuitSolverOutput const sym_b2_output{i_2, ComplexValue{}}; + BranchShortCircuitSolverOutput const sym_b3_output{i_3, ComplexValue{}}; Branch3ShortCircuitOutput sym_sc_output = vec[0].get_sc_output(sym_b1_output, sym_b2_output, sym_b3_output); @@ -425,9 +425,9 @@ TEST_CASE("Test three winding transformer") { ComplexValue const i_2_asym{1.0 - 2.2i}; ComplexValue const i_3_asym{1.3 - 2.1i}; - BranchShortCircuitMathOutput const asym_b1_output{i_1_asym, ComplexValue{}}; - BranchShortCircuitMathOutput const asym_b2_output{i_2_asym, ComplexValue{}}; - BranchShortCircuitMathOutput const asym_b3_output{i_3_asym, ComplexValue{}}; + BranchShortCircuitSolverOutput const asym_b1_output{i_1_asym, ComplexValue{}}; + BranchShortCircuitSolverOutput const asym_b2_output{i_2_asym, ComplexValue{}}; + BranchShortCircuitSolverOutput const asym_b3_output{i_3_asym, ComplexValue{}}; Branch3ShortCircuitOutput asym_sc_output = vec[0].get_sc_output(asym_b1_output, asym_b2_output, asym_b3_output); diff --git a/tests/cpp_unit_tests/test_y_bus.cpp b/tests/cpp_unit_tests/test_y_bus.cpp index 15fd48baf9..d180a3e5b9 100644 --- a/tests/cpp_unit_tests/test_y_bus.cpp +++ b/tests/cpp_unit_tests/test_y_bus.cpp @@ -176,7 +176,7 @@ TEST_CASE("Test y bus") { SUBCASE("Test branch flow calculation") { YBus const ybus{topo_ptr, std::make_shared const>(param_sym)}; ComplexVector const u{1.0, 2.0, 3.0, 4.0}; - auto branch_flow = ybus.calculate_branch_flow>(u); + auto branch_flow = ybus.calculate_branch_flow>(u); // branch 2, bus 2->3 // if = 3 * 9i + 4 * 10i = 67i @@ -192,7 +192,7 @@ TEST_CASE("Test y bus") { SUBCASE("Test shunt flow calculation") { YBus const ybus{topo_ptr, std::make_shared const>(param_sym)}; ComplexVector const u{1.0, 2.0, 3.0, 4.0}; - auto shunt_flow = ybus.template calculate_shunt_flow>(u); + auto shunt_flow = ybus.template calculate_shunt_flow>(u); // shunt 1 // i = -4 * 200i