# Exciter Model: REEC_D

Following checks and corrections are applied during Validation and AutoCorrection.

- If 0.0 < Tv < 0.5*Mult*TimeStep then Tv = 0, ElseIf 0.5*Mult*TimeStep < Tv < Mult*TimeStep then Tv = Mult*TimeStep
- If 0.0 < Tp < 0.5*Mult*TimeStep then Tp = 0, ElseIf 0.5*Mult*TimeStep < Tp < Mult*TimeStep then Tp = Mult*TimeStep
- If 0.0 < Tiq < 0.5*Mult*TimeStep then Tiq = 0, ElseIf 0.5*Mult*TimeStep < Tiq < Mult*TimeStep then Tiq = Mult*TimeStep
- If 0.0 < Tpord < 0.5*Mult*TimeStep then Tpord = 0, ElseIf 0.5*Mult*TimeStep < Tpord < Mult*TimeStep then Tpord = Mult*TimeStep
- If 0 < T < Mult*TimeStep then T = Mult*TimeStep
- Kpp and Kip can't be both zero. Must be corrected by user.
- If Vmax < Vmin then swap the values
- If QVmax < QVmin then swap the values
- If Pmax < Pmin then swap the values
- If RPmax < RPmin then swap the values
- If Iqh < Iql then swap the values

Mult represents the user-specified value **Minimum time constant size as multiple of time step** option on the Validation page of the Transient Stability Dialog

TimeStep represents the integration time step being used as described on TimeStep

Following treatment is handled during the transient numerical simulation

- If Q limits > QVmax, then QVmax = Q limits or if Q limits < QVmin, then QVmin = Q limits
- If PIq limits > Vmax, then Vmax = PIq limits or if PIq limits < Vmin, then Vmin = PIq limits
- If Pord > Pmax, then Pmax = Pord or if Pord < Pmin, then Pmin = Pord

Model Equations and/or Block Diagrams

**Parameters:**

Vcmpflag | Vcmpflag: Vcomp Flag (<>0 means use current compensation, 0 means use reactive droop |

PfFlag | PfFlag: Power factor flag (<>0 means power factor control, 0 means Q control, which can be commanded by an external signal) |

VFlag | VFlag: Voltage control flag (<>0 means Q control, 0 mean voltage control) |

QFlag | QFlag: Reactive power control flag (<>0 means voltage/Q control, 0 means constant pf or Q control) |

Pflag | Pflag: Power Flag (<>0 means multiply Pref signal by gen speed wg, 0 means do not multiply) |

Pqflag | Pqflag: P/Q priority selection on current limit flag. (0 means Q priority, <>0 means P priority |

MVABase | MVABase: MVABase for model |

Vdip | Vdip: The voltage below which the reactive current injection (Iqinj) logic is activated (i.e. voltage_dip = 1) |

Vup | Vup: The voltage above which the reactive current injection (Iqinj) logic is activated (i.e. voltage_dip = 1) |

Trv | Trv: Filter time constant for voltage measurement |

dbd1 | dbd1: Deadband in voltage error when voltage dip logic is activated (for overvoltage – thus overvoltage response can be disabled by setting this to a large number e.g. 999) |

dbd2 | dbd2: Deadband in voltage error when voltage dip logic is activated (for undervoltage) |

kqv | kqv: Gain for reactive current injection during voltage dip (and overvoltage) conditions |

Iqh1 | Iqh1: Maximum limit of reactive current injection (Iqinj) |

Iql1 | Iql1: Minimum limit of reactive current injection (Iqinj) |

Vref0 | Vref0: The reference voltage from which the voltage error is calculated. This is set by the user. If the user does not specify a value it is initialized by the model to equal to the initial terminal voltage. |

Iqfrz | Iqfrz: Value to which reactive-current command is frozen after a voltage-dip [pu] |

Thld | Thld: Time for which reactive-current command is frozen after a voltage-dip [s]; if positive then Iqcmd is frozen to its final value during the voltage-dip; if negative then Iqcmd is frozen to Iqfrz |

Thld2 | Thld2: Time delay for which the active current limit (Ipmax) is held after voltage_dip returns to zero for Thld2 seconds at its value during the voltage dip. |

Tp | Tp: Filter time constant for electrical power measurement |

QVmax | QVmax: The maximum value of the incoming Qext or Vext [pu] |

QVmin | QVmin: The minimum value of the incoming Qext or Vext [pu] |

Vmax | Vmax: Voltage control maximum |

Vmin | Vmin: Voltage control minimum |

Kqp | Kqp: Proportional gain on Q control |

Kqi | Kqi: Integral gain on Q control |

Kvp | Kvp: Proportional gain on V control |

Kvi | Kvi: Integral gain on V control |

Vref1 | Vref1: User-define reference/bias on the inner-loop voltage control (default value is zero) |

Tiq | Tiq: Time constant on lag delay |

dPmax | dPmax: Positive Ramp rate on power reference |

dPmin | dPmin: Negative Ramp rate on power reference |

Pmax | Pmax: Maximum power reference |

Pmin | Pmin: Minimum power reference |

Imax | Imax: Maximum allowable total converter current limit |

Tpord | Tpord: Filter time constant on Pord |

Rc | Rc: Current-compensation resistance [pu] |

Xc | Xc: Current-compensation reactance [pu] |

Tr1 | Tr1: Filter time constant for voltage measurement. Can be set to zero. [s] |

Kc | Kc: Reactive-current compensation gain |

Ke | Ke: Scaling on Ipmin; set to 0 for a generator, set to a value between 0 and 1 for a storage device, as appropriate |

Vblkh | Vblkh: Voltage above which the converter is blocked (i.e. Iq = Ip = 0) |

Vblkl | Vblkl: Voltage below which the converter is blocked (i.e. Iq = Ip = 0) |

Tblkdelay | Tblkdelay: The time delay following blocking of the converter after which the converter is released from being blocked |

Vq1 | Vq1: VDLq: Voltage Point1 |

Iq1 | Iq1: VDLq: Iqmax Point1 |

Vq2 | Vq2: VDLq: Voltage Point2 |

Iq2 | Iq2: VDLq: Iqmax Point2 |

Vq3 | Vq3: VDLq: Voltage Point3 |

Iq3 | Iq3: VDLq: Iqmax Point3 |

Vq4 | Vq4: VDLq: Voltage Point4 |

Iq4 | Iq4: VDLq: Iqmax Point4 |

Vq5 | Vq5: VDLq: Voltage Point5 |

Iq5 | Iq5: VDLq: Iqmax Point5 |

Vq6 | Vq6: VDLq: Voltage Point6 |

Iq6 | Iq6: VDLq: Iqmax Point6 |

Vq7 | Vq7: VDLq: Voltage Point7 |

Iq7 | Iq7: VDLq: Iqmax Point7 |

Vq8 | Vq8: VDLq: Voltage Point8 |

Iq8 | Iq8: VDLq: Iqmax Point8 |

Vq9 | Vq9: VDLq: Voltage Point9 |

Iq9 | Iq9: VDLq: Iqmax Point9 |

Vq10 | Vq10: VDLq: Voltage Point10 |

Iq10 | Iq10: VDLq: Iqmax Point10 |

Vp1 | Vp1: VDLp: Voltage Point1 |

Ip1 | Ip1: VDLp: Ipmax Point1 |

Vp2 | Vp2: VDLp: Voltage Point2 |

Ip2 | Ip2: VDLp: Ipmax Point2 |

Vp3 | Vp3: VDLp: Voltage Point3 |

Ip3 | Ip3: VDLp: Ipmax Point3 |

Vp4 | Vp4: VDLp: Voltage Point4 |

Ip4 | Ip4: VDLp: Ipmax Point4 |

Vp5 | Vp5: VDLp: Voltage Point5 |

Ip5 | Ip5: VDLp: Ipmax Point5 |

Vp6 | Vp6: VDLp: Voltage Point6 |

Ip6 | Ip6: VDLp: Ipmax Point6 |

Vp7 | Vp7: VDLp: Voltage Point7 |

Ip7 | Ip7: VDLp: Ipmax Point7 |

Vp8 | Vp8: VDLp: Voltage Point8 |

Ip8 | Ip8: VDLp: Ipmax Point8 |

Vp9 | Vp9: VDLp: Voltage Point9 |

Ip9 | Ip9: VDLp: Ipmax Point9 |

Vp10 | Vp10: VDLp: Voltage Point10 |

Ip10 | Ip10: VDLp: Ipmax Point10 |

**Current Limit Logic Psuedo Code**

The following pseudo-code describes how the values for Ipmax, Ipmin, Iqmax, and Iqmin are updated. This is done independently of blocking logic described previously.

**If** Blocked **then begin** // see logic above for when blocking is implemented

Ipmax = **0**

Ipmin = **0**

Iqmax = **0**

Iqmin = **0**

**End**

**Else begin**

Voltage_Thld2TimerActive = special boolean related to timer

local_V = StateVtfilter // Vt State 1

**if** VDL1 table is empty **then **Iqmax = 1E10

**else **Iqmax = lookup from VL1 table using local_V

**if** not Voltage_Thld2TimerActive **then begin**

**if** VDL2 table is empty **then **Ipmax = 1E10

**else **Ipmax = lookup from VDL2 table using local_V

**end**

**if** PQFlag = **0** **then begin** // Q priority [default]

**If** Imax < Iqmax **Then **Iqmax = IMax

**if** Iqmax < **0** **then **Iqmin = Iqmax // special handling

**Else **Iqmin = -Iqmax

**if** not Voltage_Thld2TimerActive **then begin**

local_I = Sqr(Imax) - Sqr(Iqcmd)

**if** local_I < **0** **then** local_I = **0**

**else** local_I = sqrt( local_I )

**if** local_I < Ipmax **Then **Ipmax = local_I

**end**

Ipmin = -Ke*Ipmax

**end**

**else** **Begin**// P priority

**if** not Voltage_Thld2TimerActive **then begin**

**if** IMax < Ipmax **Then **Ipmax = Imax

**end**

Ipmin = -Ke*Ipmax

local_I = Sqr(Imax) - Sqr(Ipcmd)

**if** local_I < **0** **then** local_I = **0**

**else** local_I = sqrt( local_I )

**if** local_I < Iqmax **Then **Iqmax = local_I

**if **Iqmax < **0** **then **Iqmin = Iqmax // special handling

**Else **Iqmin = -Iqmax

**end**

**end**