From 6f9107eecfa41d73e3b68ab15f0fc43a149fc247 Mon Sep 17 00:00:00 2001 From: Changgang Li Date: Mon, 5 Feb 2024 16:29:51 +0800 Subject: [PATCH] minor --- code/steps/STEPS.cbp | 10 +- code/steps/STEPS.depend | 37 +- .../converter_common_models/vrt_model/hvrt.h | 4 +- .../converter_common_models/vrt_model/lvrt.h | 4 +- .../vrt_model/vrt_control_model.h | 61 + .../{vrt_model.h => vrt_relay_model.h} | 16 +- .../wtg_models/wt_electrical_model/wt3evrt.h | 159 ++ .../converter_common_model/vrt_model/hvrt.cpp | 6 +- .../converter_common_model/vrt_model/lvrt.cpp | 6 +- .../vrt_model/vrt_control_model.cpp | 100 ++ .../{vrt_model.cpp => vrt_relay_model.cpp} | 52 +- .../wt_electrical_model/wt3evrt.cpp | 1460 +++++++++++++++++ 12 files changed, 1862 insertions(+), 53 deletions(-) create mode 100644 code/steps/header/model/converter_common_models/vrt_model/vrt_control_model.h rename code/steps/header/model/converter_common_models/vrt_model/{vrt_model.h => vrt_relay_model.h} (86%) create mode 100644 code/steps/header/model/wtg_models/wt_electrical_model/wt3evrt.h create mode 100644 code/steps/source/model/converter_common_model/vrt_model/vrt_control_model.cpp rename code/steps/source/model/converter_common_model/vrt_model/{vrt_model.cpp => vrt_relay_model.cpp} (53%) create mode 100644 code/steps/source/model/wtg_models/wt_electrical_model/wt3evrt.cpp diff --git a/code/steps/STEPS.cbp b/code/steps/STEPS.cbp index a7740760..9b0580bb 100644 --- a/code/steps/STEPS.cbp +++ b/code/steps/STEPS.cbp @@ -184,14 +184,13 @@ - - - + + @@ -371,6 +370,7 @@ + @@ -621,7 +621,8 @@ - + + @@ -786,6 +787,7 @@ + diff --git a/code/steps/STEPS.depend b/code/steps/STEPS.depend index 3602bb2e..3b79211e 100644 --- a/code/steps/STEPS.depend +++ b/code/steps/STEPS.depend @@ -56786,7 +56786,7 @@ -1707111092 source:d:\steps\code\steps\source\model\wtg_models\wt_relay_model\vrtrly0.cpp +1707117374 source:d:\steps\code\steps\source\model\wtg_models\wt_relay_model\vrtrly0.cpp "header/model/wtg_models/wt_relay_model/vrtrly0.h" "header/basic/utility.h" "header/STEPS.h" @@ -56814,8 +56814,8 @@ -1707114258 d:\steps\code\steps\header\model\converter_common_models\vrt_model\hvrt.h - "header/model/converter_common_models/vrt_model/vrt_model.h" +1707117778 d:\steps\code\steps\header\model\converter_common_models\vrt_model\hvrt.h + "header/model/converter_common_models/vrt_model/vrt_relay_model.h" "header/block/integral_block.h" 1707113611 d:\steps\code\steps\header\model\converter_common_models\vrt_model\vrt_model.h @@ -56831,8 +56831,8 @@ -1707113013 d:\steps\code\steps\header\model\converter_common_models\vrt_model\lvrt.h - "header/model/converter_common_models/vrt_model/vrt_model.h" +1707117782 d:\steps\code\steps\header\model\converter_common_models\vrt_model\lvrt.h + "header/model/converter_common_models/vrt_model/vrt_relay_model.h" "header/block/integral_block.h" 1707115094 source:d:\steps\code\steps\source\model\converter_common_model\vrt_model\vrt_model.cpp @@ -56919,3 +56919,30 @@ "header/power_system_database.h" "header/STEPS.h" +1707117770 source:d:\steps\code\steps\source\model\converter_common_model\vrt_model\vrt_relay_model.cpp + "header/model/converter_common_models/vrt_model/vrt_relay_model.h" + "header/power_system_database.h" + "header/basic/utility.h" + + + +1707117770 d:\steps\code\steps\header\model\converter_common_models\vrt_model\vrt_relay_model.h + "header/STEPS.h" + "header/basic/constants.h" + "header/basic/multi_point_line.h" + +1707117524 source:d:\steps\code\steps\source\model\wtg_models\wt_electrical_model\wt3evrt.cpp + "header/model/wtg_models/wt_electrical_model/wt3evrt.h" + "header/device/wt_generator.h" + "header/power_system_database.h" + "header/STEPS.h" + "header/basic/utility.h" + "header/steps_namespace.h" + + +1707117526 d:\steps\code\steps\header\model\wtg_models\wt_electrical_model\wt3evrt.h + "header/model/wtg_models/wt_electrical_model/wt_electrical_model.h" + "header/block/first_order_block.h" + "header/block/pi_block.h" + "header/block/integral_block.h" + diff --git a/code/steps/header/model/converter_common_models/vrt_model/hvrt.h b/code/steps/header/model/converter_common_models/vrt_model/hvrt.h index 71ec1b9c..fe6ac2df 100644 --- a/code/steps/header/model/converter_common_models/vrt_model/hvrt.h +++ b/code/steps/header/model/converter_common_models/vrt_model/hvrt.h @@ -1,10 +1,10 @@ #ifndef HVRT_H #define HVRT_H -#include "header/model/converter_common_models/vrt_model/vrt_model.h" +#include "header/model/converter_common_models/vrt_model/vrt_relay_model.h" #include "header/block/integral_block.h" -class HVRT : public VRT_MODEL +class HVRT : public VRT_RELAY_MODEL { public: HVRT(STEPS& toolkit); diff --git a/code/steps/header/model/converter_common_models/vrt_model/lvrt.h b/code/steps/header/model/converter_common_models/vrt_model/lvrt.h index 448b26e2..08c6687b 100644 --- a/code/steps/header/model/converter_common_models/vrt_model/lvrt.h +++ b/code/steps/header/model/converter_common_models/vrt_model/lvrt.h @@ -1,10 +1,10 @@ #ifndef LVRT_H #define LVRT_H -#include "header/model/converter_common_models/vrt_model/vrt_model.h" +#include "header/model/converter_common_models/vrt_model/vrt_relay_model.h" #include "header/block/integral_block.h" -class LVRT : public VRT_MODEL +class LVRT : public VRT_RELAY_MODEL { public: LVRT(STEPS& toolkit); diff --git a/code/steps/header/model/converter_common_models/vrt_model/vrt_control_model.h b/code/steps/header/model/converter_common_models/vrt_model/vrt_control_model.h new file mode 100644 index 00000000..e976bd7f --- /dev/null +++ b/code/steps/header/model/converter_common_models/vrt_model/vrt_control_model.h @@ -0,0 +1,61 @@ +#ifndef VRT_CONTROL_MODEL_H +#define VRT_CONTROL_MODEL_H + +#include "header/STEPS.h" +#include "header/basic/constants.h" +#include "header/basic/multi_point_line.h" + +class BUS; + +class VRT_CONTROL_MODEL +{ + public: + VRT_CONTROL_MODEL(STEPS& toolkit); + ~VRT_CONTROL_MODEL(); + void set_toolkit(STEPS& toolkit); + STEPS& get_toolkit() const; + + void set_bus_pointer(BUS* bus); + BUS* get_bus_pointer() const; + unsigned int get_bus() const; + double get_bus_voltage(); + + void set_vrt_voltage_threshold(double v); + void set_P0_pu(double P); + void set_Q0_pu(double Q); + void set_Ip0_pu(double I); + void set_Iq0_pu(double I); + + double get_vrt_voltage_threshold() const; + double get_P0_pu() const; + double get_Q0_pu() const; + double get_Ip0_pu() const; + double get_Iq0_pu() const; + + void set_vrt_status(VRT_STATUS status); + double get_vrt_activation_time() const; + double get_vrt_start2recover_time() const; + VRT_STATUS get_vrt_status() const; + + double get_vrt_P_command(); + double get_vrt_Q_command(); + double get_vrt_Ip_command(); + double get_vrt_Iq_command(); + public: + void copy_from_const_model(const VRT_CONTROL_MODEL& model); + virtual void check_vrt_status() = 0; + private: + STEPS* toolkit; + BUS* bus_ptr; + + double vrt_voltage_threshold; + double t0_vrt_activated; + double t0_vrt_start2recover; + VRT_STATUS status; + + double P0, Q0; + double Ip0, Iq0; + double K, Kp, K; +}; + +#endif // VRT_CONTROL_MODEL_H diff --git a/code/steps/header/model/converter_common_models/vrt_model/vrt_model.h b/code/steps/header/model/converter_common_models/vrt_model/vrt_relay_model.h similarity index 86% rename from code/steps/header/model/converter_common_models/vrt_model/vrt_model.h rename to code/steps/header/model/converter_common_models/vrt_model/vrt_relay_model.h index 8d64f8b6..a8fa7348 100644 --- a/code/steps/header/model/converter_common_models/vrt_model/vrt_model.h +++ b/code/steps/header/model/converter_common_models/vrt_model/vrt_relay_model.h @@ -1,5 +1,5 @@ -#ifndef VRT_MODEL_H -#define VRT_MODEL_H +#ifndef VRT_RELAY_MODEL_H +#define VRT_RELAY_MODEL_H #include "header/STEPS.h" #include "header/basic/constants.h" @@ -7,11 +7,11 @@ class BUS; -class VRT_MODEL +class VRT_RELAY_MODEL { public: - VRT_MODEL(STEPS& toolkit); - ~VRT_MODEL(); + VRT_RELAY_MODEL(STEPS& toolkit); + ~VRT_RELAY_MODEL(); void set_toolkit(STEPS& toolkit); STEPS& get_toolkit() const; @@ -40,19 +40,19 @@ class VRT_MODEL double get_vrt_activation_time() const; VRT_STATUS get_vrt_status() const; public: - void copy_from_const_model(const VRT_MODEL& model); + void copy_from_const_model(const VRT_RELAY_MODEL& model); virtual void check_vrt_status() = 0; private: STEPS* toolkit; BUS* bus_ptr; NONBUS_DEVICE* device; - TIMER vrt_trip_timer; MULTI_POINT_LINE vrt_line; + TIMER vrt_trip_timer; double vrt_trip_scale; double t0_vrt_activated; VRT_STATUS status; }; -#endif // VRT_MODEL_H +#endif // VRT_RELAY_MODEL_H diff --git a/code/steps/header/model/wtg_models/wt_electrical_model/wt3evrt.h b/code/steps/header/model/wtg_models/wt_electrical_model/wt3evrt.h new file mode 100644 index 00000000..2b858111 --- /dev/null +++ b/code/steps/header/model/wtg_models/wt_electrical_model/wt3evrt.h @@ -0,0 +1,159 @@ +#ifndef WT3EVRT_H +#define WT3EVRT_H + +#include "header/model/wtg_models/wt_electrical_model/wt_electrical_model.h" +#include "header/block/first_order_block.h" +#include "header/block/pi_block.h" +#include "header/block/integral_block.h" + +class WT3EVRT: public WT_ELECTRICAL_MODEL +{ + public: + WT3EVRT(STEPS& toolkit); + WT3EVRT(const WT3EVRT& model); + virtual ~WT3EVRT(); + virtual WT3EVRT& operator=(const WT3EVRT& model); + public: // specific exciter + virtual string get_model_name() const; + + void set_Xcomp_in_pu(double Xc); + void set_TRV_in_s(double T); + void set_Fn(double Fn); + void set_KIV(double K); + void set_Qmax_in_pu(double q); + void set_Qmin_in_pu(double q); + void set_KPV(double K); + void set_TV_in_s(double T); + void set_TFV_in_s(double T); + void set_TP_in_s(double T); + void set_KQI(double K); + void set_Vmax_in_pu(double v); + void set_Vmin_in_pu(double v); + void set_voltage_flag(unsigned int flag); + void set_KQV(double K); + void set_EQmax_in_pu(double I); + void set_EQmin_in_pu(double I); + + void set_Tspeed_in_s(double T); + void set_KPP(double K); + void set_KIP(double K); + void set_Kvi(double K); + void set_Tvi_in_s(double T); + void set_Kdroop(double K); + void set_Tdroop_in_s(double T); + void set_frequency_deviation_upper_deadband_in_pu(double f); + void set_frequency_deviation_lower_deadband_in_pu(double f); + void set_Kfint(double K); + void set_rPmax_in_pu(double r); + void set_rPmin_in_pu(double r); + void set_TFP_in_s(double T); + void set_Pmax_in_pu(double p); + void set_Pmin_in_pu(double p); + void set_IPmax_in_pu(double I); + + double get_Xcomp_in_pu() const; + double get_TRV_in_s() const; + double get_Fn() const; + double get_KIV() const; + double get_Qmax_in_pu() const; + double get_Qmin_in_pu() const; + double get_KPV() const; + double get_TV_in_s() const; + double get_TFV_in_s() const; + double get_TP_in_s() const; + double get_KQI() const; + double get_Vmax_in_pu() const; + double get_Vmin_in_pu() const; + unsigned int get_voltage_flag() const; + double get_KQV() const; + double get_EQmax_in_pu() const; + double get_EQmin_in_pu() const; + + double get_Tspeed_in_s() const; + double get_KPP() const; + double get_KIP() const; + double get_Kvi() const; + double get_Tvi_in_s() const; + double get_Kdroop() const; + double get_Tdroop_in_s() const; + double get_frequency_deviation_upper_deadband_in_pu() const; + double get_frequency_deviation_lower_deadband_in_pu() const; + double get_Kfint() const; + double get_TFP_in_s() const; + double get_rPmax_in_pu() const; + double get_rPmin_in_pu() const; + double get_Pmax_in_pu() const; + double get_Pmin_in_pu() const; + double get_IPmax_in_pu() const; + + bool is_frequency_regulation_enabled() const; + + void set_speed_reference_bias_in_pu(double bias); + double get_speed_reference_bias_in_pu() const; + public: + virtual bool setup_model_with_steps_string_vector(vector& data); + virtual bool setup_model_with_psse_string(string data); + virtual bool setup_model_with_bpa_string(string data); + + virtual void prepare_model_data_table(); + virtual void prepare_model_internal_variable_table(); + + virtual void setup_block_toolkit_and_parameters(); + + virtual void initialize(); + virtual void run(DYNAMIC_MODE mode); + virtual double get_active_current_command_in_pu_based_on_mbase(); + virtual double get_active_power_command_in_pu_based_on_mbase() const; + virtual double get_reactive_current_command_in_pu_based_on_mbase(); + virtual double get_reactive_power_command_in_pu_based_on_mbase(); + virtual double get_reactive_voltage_command_in_pu() const; + + + virtual void check(); + virtual void clear(); + virtual void report(); + virtual void save(); + virtual string get_standard_psse_string(bool export_internal_bus_number=false) const; + + virtual double get_model_data_with_name(string par_name) const; + virtual void set_model_data_with_name(string par_name, double value); + virtual double get_minimum_nonzero_time_constant_in_s(); + virtual double get_model_internal_variable_with_name(string var_name); + + virtual string get_dynamic_data_in_psse_format() const; + virtual string get_dynamic_data_in_bpa_format() const; + virtual string get_dynamic_data_in_steps_format() const; + private: + void copy_from_const_model(const WT3EVRT& model); + + void trip_frequency_regulation(); + + double Xcomp; + FIRST_ORDER_BLOCK voltage_sensor; + double Fn; + FIRST_ORDER_BLOCK voltage_regulator_first_order_block; + INTEGRAL_BLOCK voltage_regulator_integrator; + FIRST_ORDER_BLOCK voltage_regulator_filter; + FIRST_ORDER_BLOCK active_power_sensor; + INTEGRAL_BLOCK Q_error_integrator; + unsigned int Voltage_Flag; + INTEGRAL_BLOCK V_error_integrator; + double EQmax, EQmin; + + FIRST_ORDER_BLOCK wind_turbine_speed_reference_sensor; + PI_BLOCK torque_PI_regulator; + DIFFERENTIAL_BLOCK virtual_inertia_emulator; + FIRST_ORDER_BLOCK frequency_droop_controller; + + double f_upper_pu, f_lower_pu; + INTEGRAL_BLOCK frequency_integral_controller; + double max_torque_rate, min_torque_rate; + INTEGRAL_BLOCK power_order_integrator; + double IPmax; + + bool frequency_regulation_enabled; + + double speedref_bias; +}; + +#endif // EXCITER_MODEL_H diff --git a/code/steps/source/model/converter_common_model/vrt_model/hvrt.cpp b/code/steps/source/model/converter_common_model/vrt_model/hvrt.cpp index dd5ce8c0..6e1bc995 100644 --- a/code/steps/source/model/converter_common_model/vrt_model/hvrt.cpp +++ b/code/steps/source/model/converter_common_model/vrt_model/hvrt.cpp @@ -7,7 +7,7 @@ using namespace std; -HVRT::HVRT(STEPS& toolkit) : VRT_MODEL(toolkit) +HVRT::HVRT(STEPS& toolkit) : VRT_RELAY_MODEL(toolkit) { clear(); } @@ -17,7 +17,7 @@ HVRT::~HVRT() ; } -HVRT::HVRT(const HVRT& model) : VRT_MODEL(model.get_toolkit()) +HVRT::HVRT(const HVRT& model) : VRT_RELAY_MODEL(model.get_toolkit()) { copy_from_const_model(model); } @@ -39,7 +39,7 @@ void HVRT::clear() void HVRT::copy_from_const_model(const HVRT& model) { clear(); - VRT_MODEL::copy_from_const_model(model); + VRT_RELAY_MODEL::copy_from_const_model(model); } void HVRT::initialize_vrt() diff --git a/code/steps/source/model/converter_common_model/vrt_model/lvrt.cpp b/code/steps/source/model/converter_common_model/vrt_model/lvrt.cpp index 5c1594fa..344b3ca0 100644 --- a/code/steps/source/model/converter_common_model/vrt_model/lvrt.cpp +++ b/code/steps/source/model/converter_common_model/vrt_model/lvrt.cpp @@ -7,7 +7,7 @@ using namespace std; -LVRT::LVRT(STEPS& toolkit) : VRT_MODEL(toolkit) +LVRT::LVRT(STEPS& toolkit) : VRT_RELAY_MODEL(toolkit) { clear(); } @@ -17,7 +17,7 @@ LVRT::~LVRT() ; } -LVRT::LVRT(const LVRT& model) : VRT_MODEL(model.get_toolkit()) +LVRT::LVRT(const LVRT& model) : VRT_RELAY_MODEL(model.get_toolkit()) { copy_from_const_model(model); } @@ -39,7 +39,7 @@ void LVRT::clear() void LVRT::copy_from_const_model(const LVRT& model) { clear(); - VRT_MODEL::copy_from_const_model(model); + VRT_RELAY_MODEL::copy_from_const_model(model); } void LVRT::initialize_vrt() diff --git a/code/steps/source/model/converter_common_model/vrt_model/vrt_control_model.cpp b/code/steps/source/model/converter_common_model/vrt_model/vrt_control_model.cpp new file mode 100644 index 00000000..448421fb --- /dev/null +++ b/code/steps/source/model/converter_common_model/vrt_model/vrt_control_model.cpp @@ -0,0 +1,100 @@ +#include "header/model/converter_common_models/vrt_model/vrt_control_model.h" +#include "header/power_system_database.h" +#include "header/basic/utility.h" +#include +#include + +using namespace std; + +VRT_CONTROL_MODEL::VRT_CONTROL_MODEL(STEPS& toolkit) +{ + set_toolkit(toolkit); + bus_ptr = NULL; + set_vrt_status(VRT_NORMAL_MODE); +} + +VRT_CONTROL_MODEL::~VRT_CONTROL_MODEL() +{ + ; +} + +void VRT_CONTROL_MODEL::set_toolkit(STEPS& toolkit) +{ + this->toolkit = (&toolkit); +} + +STEPS& VRT_CONTROL_MODEL::get_toolkit() const +{ + return *toolkit; +} + +void VRT_CONTROL_MODEL::set_bus_pointer(BUS* bus) +{ + bus_ptr = bus; +} + +BUS* VRT_CONTROL_MODEL::get_bus_pointer() const +{ + return bus_ptr; +} + +unsigned int VRT_CONTROL_MODEL::get_bus() const +{ + return bus_ptr->get_bus_number(); +} + +double VRT_CONTROL_MODEL::get_bus_voltage() +{ + return bus_ptr->get_positive_sequence_voltage_in_pu(); +} + + +void VRT_CONTROL_MODEL::set_vrt_voltage_threshold(double v) +{ + vrt_voltage_threshold = v; +} + +double VRT_CONTROL_MODEL::get_vrt_voltage_threshold() const +{ + return vrt_voltage_threshold; +} + +void VRT_CONTROL_MODEL::set_vrt_status(VRT_STATUS status) +{ + this->status = status; + if(status==LVRT_DRURING_MODE or status==HVRT_DRURING_MODE) + { + STEPS& toolkit = get_toolkit(); + t0_vrt_activated = toolkit.get_dynamic_simulation_time_in_s(); + } + else + { + if(status==LVRT_RECOVER_MODE or status==HVRT_RECOVER_MODE) + { + STEPS& toolkit = get_toolkit(); + t0_vrt_start2recover = toolkit.get_dynamic_simulation_time_in_s(); + } + else + t0_vrt_activated = INFINITE_THRESHOLD; + } +} + +double VRT_CONTROL_MODEL::get_vrt_activation_time() const +{ + return t0_vrt_activated; +} + +double VRT_CONTROL_MODEL::get_vrt_start2recover_time() const +{ + return t0_vrt_start2recover; +} + +VRT_STATUS VRT_CONTROL_MODEL::get_vrt_status() const +{ + return status; +} +void VRT_CONTROL_MODEL::copy_from_const_model(const VRT_CONTROL_MODEL& model) +{ + set_vrt_status(model.get_vrt_status()); + set_vrt_voltage_threshold(model.get_vrt_voltage_threshold()); +} diff --git a/code/steps/source/model/converter_common_model/vrt_model/vrt_model.cpp b/code/steps/source/model/converter_common_model/vrt_model/vrt_relay_model.cpp similarity index 53% rename from code/steps/source/model/converter_common_model/vrt_model/vrt_model.cpp rename to code/steps/source/model/converter_common_model/vrt_model/vrt_relay_model.cpp index 2d666142..b481ae06 100644 --- a/code/steps/source/model/converter_common_model/vrt_model/vrt_model.cpp +++ b/code/steps/source/model/converter_common_model/vrt_model/vrt_relay_model.cpp @@ -1,4 +1,4 @@ -#include "header/model/converter_common_models/vrt_model/vrt_model.h" +#include "header/model/converter_common_models/vrt_model/vrt_relay_model.h" #include "header/power_system_database.h" #include "header/basic/utility.h" #include @@ -6,7 +6,7 @@ using namespace std; -VRT_MODEL::VRT_MODEL(STEPS& toolkit) +VRT_RELAY_MODEL::VRT_RELAY_MODEL(STEPS& toolkit) { set_toolkit(toolkit); bus_ptr = NULL; @@ -14,108 +14,108 @@ VRT_MODEL::VRT_MODEL(STEPS& toolkit) vrt_trip_timer.set_toolkit(toolkit); } -VRT_MODEL::~VRT_MODEL() +VRT_RELAY_MODEL::~VRT_RELAY_MODEL() { ; } -void VRT_MODEL::set_toolkit(STEPS& toolkit) +void VRT_RELAY_MODEL::set_toolkit(STEPS& toolkit) { this->toolkit = (&toolkit); vrt_trip_timer.set_toolkit(toolkit); } -STEPS& VRT_MODEL::get_toolkit() const +STEPS& VRT_RELAY_MODEL::get_toolkit() const { return *toolkit; } -void VRT_MODEL::set_device_pointer(NONBUS_DEVICE* device) +void VRT_RELAY_MODEL::set_device_pointer(NONBUS_DEVICE* device) { this->device = device; } -void VRT_MODEL::set_bus_pointer(BUS* bus) +void VRT_RELAY_MODEL::set_bus_pointer(BUS* bus) { bus_ptr = bus; } -NONBUS_DEVICE* VRT_MODEL::get_device_pointer() const +NONBUS_DEVICE* VRT_RELAY_MODEL::get_device_pointer() const { return device; } -BUS* VRT_MODEL::get_bus_pointer() const +BUS* VRT_RELAY_MODEL::get_bus_pointer() const { return bus_ptr; } -unsigned int VRT_MODEL::get_bus() const +unsigned int VRT_RELAY_MODEL::get_bus() const { return bus_ptr->get_bus_number(); } -double VRT_MODEL::get_bus_voltage() +double VRT_RELAY_MODEL::get_bus_voltage() { return bus_ptr->get_positive_sequence_voltage_in_pu(); } -void VRT_MODEL::set_vrt_trip_time_delay_in_s(double t) +void VRT_RELAY_MODEL::set_vrt_trip_time_delay_in_s(double t) { vrt_trip_timer.set_timer_interval_in_s(t); } -void VRT_MODEL::set_vrt_point_number(unsigned int n) +void VRT_RELAY_MODEL::set_vrt_point_number(unsigned int n) { vrt_line.set_point_number(n); } -void VRT_MODEL::set_vrt_time_volt_threshold_pair(unsigned int index, double t, double v) +void VRT_RELAY_MODEL::set_vrt_time_volt_threshold_pair(unsigned int index, double t, double v) { vrt_line.set_point(index, t, v); } -void VRT_MODEL::set_vrt_trip_scale(double scale) +void VRT_RELAY_MODEL::set_vrt_trip_scale(double scale) { vrt_trip_scale = scale; } -MULTI_POINT_LINE& VRT_MODEL::get_vrt_line() +MULTI_POINT_LINE& VRT_RELAY_MODEL::get_vrt_line() { return vrt_line; } -TIMER& VRT_MODEL::get_vrt_trip_timer() +TIMER& VRT_RELAY_MODEL::get_vrt_trip_timer() { return vrt_trip_timer; } -double VRT_MODEL::get_vrt_trip_time_delay_in_s() const +double VRT_RELAY_MODEL::get_vrt_trip_time_delay_in_s() const { return vrt_trip_timer.get_timer_interval_in_s(); } -unsigned int VRT_MODEL::get_vrt_point_number() const +unsigned int VRT_RELAY_MODEL::get_vrt_point_number() const { return vrt_line.get_point_number(); } -double VRT_MODEL::get_vrt_time_threshold(unsigned int index) const +double VRT_RELAY_MODEL::get_vrt_time_threshold(unsigned int index) const { return vrt_line.get_point_x(index); } -double VRT_MODEL::get_vrt_volt_threshold(unsigned int index) const +double VRT_RELAY_MODEL::get_vrt_volt_threshold(unsigned int index) const { return vrt_line.get_point_y(index); } -double VRT_MODEL::get_vrt_trip_scale() const +double VRT_RELAY_MODEL::get_vrt_trip_scale() const { return vrt_trip_scale; } -void VRT_MODEL::set_vrt_status(VRT_STATUS status) +void VRT_RELAY_MODEL::set_vrt_status(VRT_STATUS status) { this->status = status; if(status==LVRT_DRURING_MODE or status==HVRT_DRURING_MODE) @@ -127,16 +127,16 @@ void VRT_MODEL::set_vrt_status(VRT_STATUS status) t0_vrt_activated = INFINITE_THRESHOLD; } -double VRT_MODEL::get_vrt_activation_time() const +double VRT_RELAY_MODEL::get_vrt_activation_time() const { return t0_vrt_activated; } -VRT_STATUS VRT_MODEL::get_vrt_status() const +VRT_STATUS VRT_RELAY_MODEL::get_vrt_status() const { return status; } -void VRT_MODEL::copy_from_const_model(const VRT_MODEL& model) +void VRT_RELAY_MODEL::copy_from_const_model(const VRT_RELAY_MODEL& model) { set_vrt_status(model.get_vrt_status()); diff --git a/code/steps/source/model/wtg_models/wt_electrical_model/wt3evrt.cpp b/code/steps/source/model/wtg_models/wt_electrical_model/wt3evrt.cpp new file mode 100644 index 00000000..a2dca009 --- /dev/null +++ b/code/steps/source/model/wtg_models/wt_electrical_model/wt3evrt.cpp @@ -0,0 +1,1460 @@ +#include "header/model/wtg_models/wt_electrical_model/wt3evrt.h" +#include "header/device/wt_generator.h" +#include "header/power_system_database.h" +#include "header/STEPS.h" +#include "header/basic/utility.h" +#include "header/steps_namespace.h" +#include + +using namespace std; + +WT3EVRT::WT3EVRT(STEPS& toolkit) : WT_ELECTRICAL_MODEL(toolkit), + voltage_sensor(toolkit), + voltage_regulator_first_order_block(toolkit), + voltage_regulator_integrator(toolkit), + voltage_regulator_filter(toolkit), + active_power_sensor(toolkit), + Q_error_integrator(toolkit), + V_error_integrator(toolkit), + wind_turbine_speed_reference_sensor(toolkit), + torque_PI_regulator(toolkit), + virtual_inertia_emulator(toolkit), + frequency_droop_controller(toolkit), + frequency_integral_controller(toolkit), + power_order_integrator(toolkit) +{ + clear(); +} + +WT3EVRT::WT3EVRT(const WT3EVRT& model) : WT_ELECTRICAL_MODEL(model.get_toolkit()), + voltage_sensor(model.get_toolkit()), + voltage_regulator_first_order_block(model.get_toolkit()), + voltage_regulator_integrator(model.get_toolkit()), + voltage_regulator_filter(model.get_toolkit()), + active_power_sensor(model.get_toolkit()), + Q_error_integrator(model.get_toolkit()), + V_error_integrator(model.get_toolkit()), + wind_turbine_speed_reference_sensor(model.get_toolkit()), + torque_PI_regulator(model.get_toolkit()), + virtual_inertia_emulator(model.get_toolkit()), + frequency_droop_controller(model.get_toolkit()), + frequency_integral_controller(model.get_toolkit()), + power_order_integrator(model.get_toolkit()) +{ + copy_from_const_model(model); +} + +WT3EVRT::~WT3EVRT() +{ + ; +} + +WT3EVRT& WT3EVRT::operator=(const WT3EVRT& model) +{ + if(this==(&model)) return *this; + + copy_from_const_model(model); + + return *this; +} + +void WT3EVRT::clear() +{ + set_model_float_parameter_count(35); + + set_voltage_flag(0); + + voltage_regulator_integrator.set_limiter_type(NON_WINDUP_LIMITER); + Q_error_integrator.set_limiter_type(NON_WINDUP_LIMITER); + V_error_integrator.set_limiter_type(NON_WINDUP_LIMITER); + + power_order_integrator.set_limiter_type(NON_WINDUP_LIMITER); + frequency_integral_controller.set_limiter_type(NO_LIMITER); + + frequency_regulation_enabled = true; +} + +void WT3EVRT::copy_from_const_model(const WT3EVRT& model) +{ + STEPS& toolkit = model.get_toolkit(); + set_toolkit(toolkit); + voltage_sensor.set_toolkit(toolkit); + voltage_regulator_first_order_block.set_toolkit(toolkit); + voltage_regulator_integrator.set_toolkit(toolkit); + voltage_regulator_filter.set_toolkit(toolkit); + active_power_sensor.set_toolkit(toolkit); + Q_error_integrator.set_toolkit(toolkit); + V_error_integrator.set_toolkit(toolkit); + + wind_turbine_speed_reference_sensor.set_toolkit(toolkit); + torque_PI_regulator.set_toolkit(toolkit); + virtual_inertia_emulator.set_toolkit(toolkit); + frequency_droop_controller.set_toolkit(toolkit); + + frequency_integral_controller.set_toolkit(toolkit); + power_order_integrator.set_toolkit(toolkit); + + clear(); + + set_bus_to_regulate(model.get_bus_to_regulate()); + set_var_control_mode(model.get_var_control_mode()); + set_wind_turbine_power_speed_lookup_table(model.get_wind_turbine_power_speed_lookup_table()); + + set_Xcomp_in_pu(model.get_Xcomp_in_pu()); + set_TRV_in_s(model.get_TRV_in_s()); + set_Fn(model.get_Fn()); + set_KIV(model.get_KIV()); + set_Qmax_in_pu(model.get_Qmax_in_pu()); + set_Qmin_in_pu(model.get_Qmin_in_pu()); + set_KPV(model.get_KPV()); + set_TV_in_s(model.get_TV_in_s()); + set_TFV_in_s(model.get_TFV_in_s()); + set_TP_in_s(model.get_TP_in_s()); + set_KQI(model.get_KQI()); + set_Vmax_in_pu(model.get_Vmax_in_pu()); + set_Vmin_in_pu(model.get_Vmin_in_pu()); + set_voltage_flag(model.get_voltage_flag()); + set_KQV(model.get_KQV()); + set_EQmax_in_pu(model.get_EQmax_in_pu()); + set_EQmin_in_pu(model.get_EQmin_in_pu()); + set_Tspeed_in_s(model.get_Tspeed_in_s()); + set_KPP(model.get_KPP()); + set_KIP(model.get_KIP()); + set_Kvi(model.get_Kvi()); + set_Tvi_in_s(model.get_Tvi_in_s()); + set_Kdroop(model.get_Kdroop()); + set_Tdroop_in_s(model.get_Tdroop_in_s()); + set_frequency_deviation_upper_deadband_in_pu(model.get_frequency_deviation_upper_deadband_in_pu()); + set_frequency_deviation_lower_deadband_in_pu(model.get_frequency_deviation_lower_deadband_in_pu()); + set_Kfint(model.get_Kfint()); + set_rPmax_in_pu(model.get_rPmax_in_pu()); + set_rPmin_in_pu(model.get_rPmin_in_pu()); + set_TFP_in_s(model.get_TFP_in_s()); + set_Pmax_in_pu(model.get_Pmax_in_pu()); + set_Pmin_in_pu(model.get_Pmin_in_pu()); + set_IPmax_in_pu(model.get_IPmax_in_pu()); +} + +string WT3EVRT::get_model_name() const +{ + return "WT3EVRT"; +} + +void WT3EVRT::set_Xcomp_in_pu(double Xc) +{ + Xcomp = Xc; +} + +void WT3EVRT::set_TRV_in_s(double T) +{ + voltage_sensor.set_T_in_s(T); +} + +void WT3EVRT::set_Fn(double Fn) +{ + this->Fn = Fn; +} + +void WT3EVRT::set_KIV(double K) +{ + if(K!=0.0) + voltage_regulator_integrator.set_T_in_s(1.0/K); +} + +void WT3EVRT::set_Qmax_in_pu(double q) +{ + voltage_regulator_integrator.set_upper_limit(q); +} + +void WT3EVRT::set_Qmin_in_pu(double q) +{ + voltage_regulator_integrator.set_lower_limit(q); +} + +void WT3EVRT::set_KPV(double K) +{ + voltage_regulator_first_order_block.set_K(K); +} + +void WT3EVRT::set_TV_in_s(double T) +{ + voltage_regulator_first_order_block.set_T_in_s(T); +} + +void WT3EVRT::set_TFV_in_s(double T) +{ + voltage_regulator_filter.set_T_in_s(T); +} + +void WT3EVRT::set_TP_in_s(double T) +{ + active_power_sensor.set_T_in_s(T); +} + +void WT3EVRT::set_KQI(double K) +{ + if(K!=0.0) + Q_error_integrator.set_T_in_s(1.0/K); +} + +void WT3EVRT::set_Vmax_in_pu(double v) +{ + Q_error_integrator.set_upper_limit(v); +} + +void WT3EVRT::set_Vmin_in_pu(double v) +{ + Q_error_integrator.set_lower_limit(v); +} + +void WT3EVRT::set_voltage_flag(unsigned int flag) +{ + if(flag<3) + Voltage_Flag = flag; + else + { + ostringstream osstream; + osstream<<"Error. "<& data) +{ + bool is_successful = false; + if(data.size()>=38) + { + string model_name = get_string_data(data[0],""); + if(model_name==get_model_name()) + { + unsigned int bus, voltage_flag; + int var_control_flag; + double tfv, kpv, kiv, xc, tfp, kpp, kip, pmax, pmin, qmax, qmin, + ipmax, trv, rpmax, rpmin, tspeed, kqi, vmax, vmin, + kqv, eqmax, eqmin, tv, tp, fn, + kvi, tvi, kdroop, tdroop, fupper, flower, kint; + + unsigned int i=3; + bus = get_integer_data(data[i],"0"); i++; + var_control_flag = get_integer_data(data[i],"0"); i++; + voltage_flag = (unsigned int)(get_integer_data(data[i],"0")); i++; + xc = get_double_data(data[i],"0.0"); i++; + trv = get_double_data(data[i],"0.0"); i++; + fn = get_double_data(data[i],"0.0"); i++; + kpv = get_double_data(data[i],"0.0"); i++; + tv = get_double_data(data[i],"0.0"); i++; + kiv = get_double_data(data[i],"0.0"); i++; + qmin = get_double_data(data[i],"0.0"); i++; + qmax = get_double_data(data[i],"0.0"); i++; + tfv = get_double_data(data[i],"0.0"); i++; + tp = get_double_data(data[i],"0.0"); i++; + kqi = get_double_data(data[i],"0.0"); i++; + vmin = get_double_data(data[i],"0.0"); i++; + vmax = get_double_data(data[i],"0.0"); i++; + kqv = get_double_data(data[i],"0.0"); i++; + eqmin = get_double_data(data[i],"0.0"); i++; + eqmax = get_double_data(data[i],"0.0"); i++; + tspeed = get_double_data(data[i],"0.0"); i++; + kpp = get_double_data(data[i],"0.0"); i++; + kip = get_double_data(data[i],"0.0"); i++; + kvi = get_double_data(data[i],"0.0"); i++; + tvi = get_double_data(data[i],"0.0"); i++; + kdroop = get_double_data(data[i],"0.0"); i++; + tdroop = get_double_data(data[i],"0.0"); i++; + flower = get_double_data(data[i],"0.0"); i++; + fupper = get_double_data(data[i],"0.0"); i++; + kint = get_double_data(data[i],"0.0"); i++; + rpmin = get_double_data(data[i],"0.0"); i++; + rpmax = get_double_data(data[i],"0.0"); i++; + tfp = get_double_data(data[i],"0.0"); i++; + pmin = get_double_data(data[i],"0.0"); i++; + pmax = get_double_data(data[i],"0.0"); i++; + ipmax = get_double_data(data[i],"0.0"); + + set_bus_to_regulate(bus); + PE_VAR_CONTROL_MODE mode; + switch(var_control_flag) + { + case 0: + { + mode = CONSTANT_VAR_MODE; + break; + } + case 1: + { + mode = CONSTANT_VOLTAGE_MODE; + break; + } + case -1: + { + mode = CONSTANT_POWER_FACTOR_MODE; + break; + } + default: + { + mode = CONSTANT_VAR_MODE; + break; + } + } + + set_var_control_mode(mode); + set_Xcomp_in_pu(xc); + set_TRV_in_s(trv); + set_Fn(fn); + set_KPV(kpv); + set_TV_in_s(tv); + set_KIV(kiv); + set_Qmin_in_pu(qmin); + set_Qmax_in_pu(qmax); + set_TFV_in_s(tfv); + set_TP_in_s(tp); + set_KQI(kqi); + set_Vmin_in_pu(vmin); + set_Vmax_in_pu(vmax); + + if(voltage_flag>2) + voltage_flag = 2; + set_voltage_flag(voltage_flag); + set_KQV(kqv); + set_EQmin_in_pu(eqmin); + set_EQmax_in_pu(eqmax); + set_Tspeed_in_s(tspeed); + set_KPP(kpp); + set_KIP(kip); + set_Kvi(kvi); + set_Tvi_in_s(tvi); + set_Kdroop(kdroop); + set_Tdroop_in_s(tdroop); + set_frequency_deviation_lower_deadband_in_pu(flower); + set_frequency_deviation_upper_deadband_in_pu(fupper); + set_Kfint(kint); + set_rPmin_in_pu(rpmin); + set_rPmax_in_pu(rpmax); + set_TFP_in_s(tfp); + set_Pmin_in_pu(pmin); + set_Pmax_in_pu(pmax); + set_IPmax_in_pu(ipmax); + + is_successful = true; + + return is_successful; + } + else + return is_successful; + } + else + return is_successful; +} + +bool WT3EVRT::setup_model_with_psse_string(string data) +{ + vector record = psse_dyr_string2steps_string_vector(data); + return setup_model_with_steps_string_vector(record); +} + +bool WT3EVRT::setup_model_with_bpa_string(string data) +{ + ostringstream osstream; + osstream<get_wt_generator_model(); + + if(not wtgenmodel->is_model_initialized()) + wtgenmodel->initialize(); + + WT_AERODYNAMIC_MODEL* aerdmodel = wt_generator->get_wt_aerodynamic_model(); + if(aerdmodel!=NULL) + { + if(not aerdmodel->is_model_initialized()) + aerdmodel->initialize(); + + WT_TURBINE_MODEL* turbine_model = wt_generator->get_wt_turbine_model(); + if(turbine_model!=NULL) + { + if(not turbine_model->is_model_initialized()) + turbine_model->initialize(); + + setup_block_toolkit_and_parameters(); + + STEPS& toolkit = get_toolkit(); + + double vterm = get_terminal_bus_voltage_in_pu(); + double iterm = get_wt_generator_terminal_current_in_pu(); + //double mbase = get_mbase_in_MVA(); + complex selec = get_wt_generator_terminal_generation_in_pu_based_on_mbase(); + double pelec = selec.real(); + double qelec = selec.imag(); + double speed = get_wt_generator_speed_in_pu(); + + double ipcmd = wtgenmodel->get_initial_active_current_command_in_pu_based_on_mbase(); + double ipmax = get_IPmax_in_pu(); + if(ipcmd>ipmax) + { + osstream<<"Initialization error. IPcmd (Active current command) of '"<pmax) + { + osstream<<"Initialization error. Porder (Active power order) of '"<get_initial_reactive_current_command_in_pu_based_on_mbase(); + double xsource = get_source_impedance_in_pu_based_on_mbase().imag(); + double eqcmd = iqcmd*(-xsource); + + double verror = 0.0; + unsigned int vflag = get_voltage_flag(); + if(vflag == 0) + { + V_error_integrator.set_output(0.0); + V_error_integrator.initialize(); + + verror = eqcmd; + } + else + { + if(vflag == 1) + { + V_error_integrator.set_upper_limit(vterm+get_EQmax_in_pu()); + V_error_integrator.set_lower_limit(vterm+get_EQmin_in_pu()); + } + else + { + V_error_integrator.set_upper_limit(get_EQmax_in_pu()); + V_error_integrator.set_lower_limit(get_EQmin_in_pu()); + } + double vmax = V_error_integrator.get_upper_limit(); + double vmin = V_error_integrator.get_lower_limit(); + + V_error_integrator.set_output(eqcmd); + if(eqcmd>vmax) + { + osstream<<"Initialization error. Eqcmd (reactive voltage command) of '"<qmax) + { + osstream<<"Initialization error. Qcmd (reactive power command) of '"<0? pf:-pf); + set_power_factor_reference_in_pu(pf); + + voltage_regulator_filter.set_output(qcmd); + voltage_regulator_filter.initialize(); + + voltage_regulator_integrator.set_output(qcmd); + voltage_regulator_integrator.initialize(); + + voltage_regulator_first_order_block.set_output(0.0); + voltage_regulator_first_order_block.initialize(); + + double xcomp = get_Xcomp_in_pu(); + double vref = vterm+iterm*xcomp; + + voltage_sensor.set_output(vref); + voltage_sensor.initialize(); + + set_voltage_reference_in_pu(vref); + //show_information_with_leading_time_stamp(osstream); + + set_flag_model_initialized_as_true(); + if(toolkit.is_detailed_log_enabled()) + { + osstream< selec = get_wt_generator_terminal_generation_in_pu_based_on_mbase(); + double pelec = selec.real(); + double qelec = selec.imag(); + + double speed = get_wt_generator_speed_in_pu(); + double speed_ref = get_wt_generator_speed_referance_in_pu(); + //double speedref_bias = get_speed_reference_bias_in_pu(); + + wind_turbine_speed_reference_sensor.set_input(speed_ref); + wind_turbine_speed_reference_sensor.run(mode); + //osstream<<"wind_turbine_speed_reference_sensor input = "<wmax*1.1: "<"<get_rPmax_in_pu()) + input = get_rPmax_in_pu(); + if(inputget_identifier()+"'"; + + string model_name = "'"+get_model_name()+"'"; + + unsigned int bus_reg = get_bus_to_regulate(); + PE_VAR_CONTROL_MODE mode = get_var_control_mode(); + int var_mode = (mode==CONSTANT_VAR_MODE)? 0: (mode==CONSTANT_POWER_FACTOR_MODE? -1 : 1); + unsigned int voltage_flag = get_voltage_flag(); + double xc = get_Xcomp_in_pu(); + double trv = get_TRV_in_s(); + double fn = get_Fn(); + double kpv = get_KPV(); + double tv = get_TV_in_s(); + double kiv = get_KIV(); + double qmax = get_Qmax_in_pu(); + double qmin = get_Qmin_in_pu(); + double tfv = get_TFV_in_s(); + double tp = get_TP_in_s(); + double kqi = get_KQI(); + double vmin = get_Vmin_in_pu(); + double vmax = get_Vmax_in_pu(); + double kqv = get_KQV(); + double eqmin = get_EQmin_in_pu(); + double eqmax = get_EQmax_in_pu(); + double tspeed = get_Tspeed_in_s(); + double kpp = get_KPP(); + double kip = get_KIP(); + double kvi = get_Kvi(); + double tvi = get_Tvi_in_s(); + double kdroop = get_Kdroop(); + double tdroop = get_Tdroop_in_s(); + double flower = get_frequency_deviation_lower_deadband_in_pu(); + double fupper = get_frequency_deviation_upper_deadband_in_pu(); + double kint = get_Kfint(); + double rpmin = get_rPmin_in_pu(); + double rpmax = get_rPmax_in_pu(); + double tfp = get_TFP_in_s(); + double pmin = get_Pmin_in_pu(); + double pmax = get_Pmax_in_pu(); + double ipmax = get_IPmax_in_pu(); + + STEPS& toolkit = get_toolkit(); + NETWORK_MATRIX& network = toolkit.get_network_matrix(); + if(export_internal_bus_number==true) + { + bus = network.get_internal_bus_number_of_physical_bus(bus)+1; + if(bus_reg!=0) bus_reg = network.get_internal_bus_number_of_physical_bus(bus_reg)+1; + } + + osstream<get_TRV_in_s()) + mint = get_TRV_in_s(); + if(get_TV_in_s()!=0.0 and mint>get_TV_in_s()) + mint = get_TV_in_s(); + if(get_TFV_in_s()!=0.0 and mint>get_TFV_in_s()) + mint = get_TFV_in_s(); + if(get_TP_in_s()!=0.0 and mint>get_TP_in_s()) + mint = get_TP_in_s(); + if(get_Tspeed_in_s()!=0.0 and mint>get_Tspeed_in_s()) + mint = get_Tspeed_in_s(); + if(get_Tvi_in_s()!=0.0 and mint>get_Tvi_in_s()) + mint = get_Tvi_in_s(); + if(get_Tdroop_in_s()!=0.0 and mint>get_Tdroop_in_s()) + mint = get_Tdroop_in_s(); + if(get_TFP_in_s()!=0.0 and mint>get_TFP_in_s()) + mint = get_TFP_in_s(); + return mint; +} + +void WT3EVRT::prepare_model_internal_variable_table() +{ + clear_model_internal_variable_table(); + unsigned int i=0; + add_model_internal_variable_name_and_index_pair("STATE@SPEED REFERENCE SENSOR", i); i++; + add_model_internal_variable_name_and_index_pair("STATE@TORQUE REGULATOR", i); i++; + add_model_internal_variable_name_and_index_pair("STATE@VIRTUAL INERTIA CONTROL", i); i++; + add_model_internal_variable_name_and_index_pair("STATE@PRIMARY FREQUENCY CONTROL", i); i++; + add_model_internal_variable_name_and_index_pair("STATE@SECONDARY FREQUENCY CONTROL", i); i++; + add_model_internal_variable_name_and_index_pair("VIRTUAL INERTIA CONTROL COMMAND", i); i++; + add_model_internal_variable_name_and_index_pair("PRIMARY FREQUENCY CONTROL COMMAND", i); i++; + add_model_internal_variable_name_and_index_pair("SECONDARY FREQUENCY CONTROL COMMAND", i); i++; +} + +double WT3EVRT::get_model_internal_variable_with_name(string var_name) +{ + var_name = string2upper(var_name); + + if(var_name == "STATE@SPEED REFERENCE SENSOR") return wind_turbine_speed_reference_sensor.get_state(); + if(var_name == "STATE@TORQUE REGULATOR") return torque_PI_regulator.get_state(); + if(var_name == "STATE@VIRTUAL INERTIA CONTROL") return virtual_inertia_emulator.get_state(); + if(var_name == "STATE@PRIMARY FREQUENCY CONTROL") return frequency_droop_controller.get_state(); + if(var_name == "STATE@SECONDARY FREQUENCY CONTROL") return frequency_integral_controller.get_state(); + if(var_name == "VIRTUAL INERTIA CONTROL COMMAND") return virtual_inertia_emulator.get_output(); + if(var_name == "PRIMARY FREQUENCY CONTROL COMMAND") return frequency_droop_controller.get_output(); + if(var_name == "SECONDARY FREQUENCY CONTROL COMMAND") return frequency_integral_controller.get_output(); + return 0.0; +} + +string WT3EVRT::get_dynamic_data_in_psse_format() const +{ + return get_standard_psse_string(); +} + +string WT3EVRT::get_dynamic_data_in_bpa_format() const +{ + return get_dynamic_data_in_psse_format(); +} + +string WT3EVRT::get_dynamic_data_in_steps_format() const +{ + return get_dynamic_data_in_psse_format(); +}