From eb871efe7806d006693092c2a797edace06e9291 Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Mon, 4 Oct 2021 21:27:32 -0400 Subject: [PATCH 01/58] Build ESST1A. --- andes/models/exciter/esst1a.py | 348 +++++++++++++++++++++++++++++++++ 1 file changed, 348 insertions(+) create mode 100644 andes/models/exciter/esst1a.py diff --git a/andes/models/exciter/esst1a.py b/andes/models/exciter/esst1a.py new file mode 100644 index 000000000..34a7d906b --- /dev/null +++ b/andes/models/exciter/esst1a.py @@ -0,0 +1,348 @@ +from collections import OrderedDict + +from andes.core.param import NumParam +from andes.core.var import Algeb, ExtAlgeb + +from andes.core.service import PostInitService, ConstService +from andes.core.discrete import Switcher, Limiter +from andes.core.block import LagAntiWindup, Lag, HVGate, LVGate +from andes.core.block import Piecewise, PIDTrackAW, LeadLag, Washout + +from andes.models.exciter.excbase import ExcBase, ExcBaseData, ExcVsum, ExcACSat +from andes.core.common import dummify + +class ESST1AData(ExcBaseData): + """ + ESST1A data. + """ + + def __init__(self): + ExcBaseData.__init__(self) + self.kP = NumParam(info='PID proportional coeff.', + tex_name='k_P', + default=10, + vrange=(10, 500), + ) + self.kI = NumParam(info='PID integrative coeff.', + tex_name='k_I', + default=10, + vrange=(10, 500), + ) + self.kD = NumParam(info='PID direvative coeff.', + tex_name='k_D', + default=10, + vrange=(10, 500), + ) + self.Td = NumParam(info='PID direvative time constant.', + tex_name='T_d', + default=0.2, + vrange=(0, 0.5), + ) + + self.VPMAX = NumParam(info='PID maximum limit', + tex_name='V_{PMAX}', + default=999, + unit='p.u.') + self.VPMIN = NumParam(info='PID minimum limit', + tex_name='V_{PMIN}', + default=-999, + unit='p.u.') + + + # TODO: check default value for VFEMAX + self.VFEMAX = NumParam(info='Maximum VFE', + tex_name=r'V_{FEMAX}', + default=999, + unit='p.u.') + + # TODO: check default value for VEMIN + self.VEMIN = NumParam(info='Minimum excitation output', + tex_name=r'V_{EMIN}', + default=-999, + unit='p.u.') + + self.TE = NumParam(info='Exciter integrator time constant', + tex_name='T_E', + default=0.8, + unit='p.u.', + ) + + self.E1 = NumParam(info='First saturation point', + tex_name='E_1', + default=0., + unit='p.u.', + ) + self.SE1 = NumParam(info='Value at first saturation point', + tex_name='S_{E1}', + default=0., + unit='p.u.', + ) + self.E2 = NumParam(info='Second saturation point', + tex_name='E_2', + default=1., + unit='p.u.', + ) + self.SE2 = NumParam(info='Value at second saturation point', + tex_name='S_{E2}', + default=1., + unit='p.u.', + ) + + self.KE = NumParam(info='Gain added to saturation', + tex_name='K_E', + default=1, + unit='p.u.', + ) + self.KD = NumParam(default=0, + info='Ifd feedback gain', + tex_name='K_D', + vrange=(0, 1), + ) + + # -- cut line + self.TR = NumParam(info='Sensing time constant', + tex_name='T_R', + default=0.01, + ) + + self.VIMAX = NumParam(default=0.8, + info='Max. input voltage', + tex_name='V_{IMAX}', + ) + self.VIMIN = NumParam(default=-0.1, + info='Min. input voltage', + tex_name='V_{IMIN}', + ) + self.TB = NumParam(info='Lag time constant in lead-lag', + tex_name='T_B', + default=1, + ) + self.TC = NumParam(info='Lead time constant in lead-lag', + tex_name='T_C', + default=1, + ) + + self.VAMAX = NumParam(info='V_A upper limit', + tex_name='V_{AMAX}', + default=999, + unit='p.u.') + self.VAMIN = NumParam(info='V_A lower limit', + tex_name='V_{AMIN}', + default=-999, + unit='p.u.') + self.TB1 = NumParam(info='Lag time constant in lead-lag 1', + tex_name=r'T_{B1}', + default=1, + ) + self.TC1 = NumParam(info='Lead time constant in lead-lag 1', + tex_name=r'T_{C1}', + default=1, + ) + + self.KA = NumParam(default=80, + info='Regulator gain', + tex_name='K_A', + ) + self.TA = NumParam(info='Lag time constant in regulator', + tex_name='T_A', + default=0.04, + ) + + self.KLR = NumParam(default=1, + info='Exciter output current limiter gain', + tex_name=r'K_LR', + ) + + self.VRMAX = NumParam(info='Maximum excitation limit', + tex_name='V_{RMAX}', + default=7.3, + unit='p.u.',) + self.VRMIN = NumParam(info='Minimum excitation limit', + tex_name='V_{RMIN}', + default=1, + unit='p.u.',) + + self.KF = NumParam(default=0.1, + info='Feedback gain', + tex_name='K_F', + ) + self.TF = NumParam(info='Feedback washout time constant', + tex_name='T_{F1}', + default=1, + ) + + self.KC = NumParam(info='Rectifier loading factor proportional to commutating reactance', + tex_name='K_C', + default=0.1, + ) + + self.UELc = NumParam(info='Alternate UEL inputs, input code 1-3', + tex_name='UEL', + default=1, + ) + self.VOSc = NumParam(info='Alternate Stabilizer inputs, input code 1-2', + tex_name='VOS', + default=1, + ) + +class ESST1AModel(ExcBase, ExcVsum, ExcACSat): + """ + Implementation of the ESST1A model. + """ + + def __init__(self, system, config): + ExcBase.__init__(self, system, config) + self.flags.nr_iter = True + + self.ul = ConstService('9999') + self.ll = ConstService('-9999') + + self.SWUEL = Switcher(u=self.UELc, options=[0, 1, 2, 3], tex_name='SW_{UEL}', cache=True) + self.SWVOS = Switcher(u=self.VOSc, options=[0, 1, 2], tex_name='SW_{VOS}', cache=True) + + + # control block begin + self.LG = Lag(self.v, T=self.TR, K=1, + info='Voltage transducer', + ) + self.VOTHSG0 = ConstService(v_str='0', info='VOTHSG initial value.') + self.VOTHSG = Algeb(tex_name='VOTHSG', info='VOTHSG', + v_str='VOTHSG0', + e_str='VOTHSG0 - VOTHSG', + ) + # TODO: check v_str + self.vref0 = ConstService(info='Initial reference voltage input', + tex_name='V_{ref0}', + # v_str='v + vfe0 / KA', + v_str='1', + ) + + ExcVsum.__init__(self) + self.UEL0.v_str = '-999' + self.OEL0.v_str = '999' + + self.vi = Algeb(info='Total input voltages', + tex_name='V_i', + unit='p.u.', + e_str='ue * (-LG_y + vref - WF_y + SWUEL_s1 * UEL + SWVOS_s1 * VOTHSG + Vs - vi)', + v_str='-v + vref', + diag_eps=True, + ) + + self.vil = Limiter(u=self.vi, lower=self.VIMIN, upper=self.VIMAX, + info='Hard limiter before V_I') + + # TODO: check v_str + self.VI = Algeb(tex_name='V_I', + info='V_I', + v_str='1', + e_str='ue * (vil_zi * vi + vil_zl * VIMIN + vil_zu * VIMAX - VI)', + diag_eps=True, + ) + + self.HVG1 = HVGate(u1=dummify('SWUEL_s2 * UEL + (1 - SWUEL_s2) * ll'), + u2=self.VI, + info='HVGate after V_I', + ) + + self.LL = LeadLag(u=self.HVG1_y, + T1=self.TC, + T2=self.TB, + info='Lead-lag compensator', + zero_out=True, + ) + + self.LL1 = LeadLag(u=self.LL_y, + T1=self.TC1, + T2=self.TB1, + info='Lead-lag compensator 1', + zero_out=True, + ) + + self.LA = LagAntiWindup(u=self.LL1_y, + T=self.TA, + K=self.KA, + upper=self.VAMAX, + lower=self.VAMIN, + info='V_A, Anti-windup lag', + ) # LA_y is VA + + self.ILR0 = ConstService(v_str='0', tex_name='I_{LR0}', info='ILR initial value') + # TODO: v_str + self.ILR = Algeb(info='exciter output current limit reference', + tex_name='I_{LR}}', + v_str='1', + e_str='ILR0 - ILR', + ) + + self.zero = ConstService('0') + self.HLI = Limiter(u=dummify('ILR - XadIfd'), lower=self.zero, + upper=self.ul, no_upper=True, + info='Hard limiter for excitation current') + + # TODO: u2, KLR + self.HVG = HVGate(u1=dummify('SWUEL_s3 * UEL + (1 - SWUEL_s3) * ll'), + u2=dummify('SWVOS_s2 * VOTHSG + LA_y - (1 - HLI_zl) * KLR * (ILR - XadIfd)'), + info='HVGate for under excitation', + ) + + self.LVG = LVGate(u1=self.HVG_y, + u2=self.OEL, + info='HVGate for under excitation', + ) + + # vd, vq, Id, Iq from SynGen + self.vd = ExtAlgeb(src='vd', + model='SynGen', + indexer=self.syn, + tex_name=r'V_d', + info='d-axis machine voltage', + ) + self.vq = ExtAlgeb(src='vq', + model='SynGen', + indexer=self.syn, + tex_name=r'V_q', + info='q-axis machine voltage', + ) + + # TODO: v_str + self.efdu = Algeb(info='Output exciter voltage upper bound', + tex_name='LVG_{y}', + v_str='1', + e_str='Abs(vd + 1j*vq) * VRMAX - KC * XadIfd - efdu', + ) + # TODO: v_str + self.efdl = Algeb(info='Output exciter voltage lower bound', + tex_name='LVG_{y}', + v_str='1', + e_str='Abs(vd + 1j*vq) * VRMIN - efdl', + ) + + # TODO: lower and upper + self.vol = Limiter(u=self.LVG_y, info='vout limiter', + lower=self.efdu, upper=self.efdl, + ) + + self.WF = Washout(u=self.LVG_y, + T=self.TF, + K=self.KF, + info='V_F, Stablizing circuit feedback', + ) + + # self.vout.e_str = '1' + self.vout.e_str = 'ue * (vol_zi * LVG_y + vol_zl * efdl + vol_zu * efdu - vout)' + + +class ESST1A(ESST1AData, ESST1AModel): + """ + Exciter ESST1A model. + Reference: + [1] PowerWorld, Exciter ESST1A, [Online], + [2] NEPLAN, Exciters Models, [Online], + Available: + https://www.powerworld.com/WebHelp/Content/TransientModels_HTML/Exciter%20ESST1A.htm + https://www.neplan.ch/wp-content/uploads/2015/08/Nep_EXCITERS1.pdf + """ + def __init__(self, system, config): + ESST1AData.__init__(self) + ESST1AModel.__init__(self, system, config) From 04b9b791ee7b61e2726fa5d5d4444cf52d72bb77 Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Mon, 4 Oct 2021 21:28:18 -0400 Subject: [PATCH 02/58] Added ESST1A into init. --- andes/models/__init__.py | 2 +- andes/models/exciter/__init__.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/andes/models/__init__.py b/andes/models/__init__.py index 29a4671b5..d99b4fe9d 100644 --- a/andes/models/__init__.py +++ b/andes/models/__init__.py @@ -26,7 +26,7 @@ ('governor', ['TG2', 'TGOV1', 'TGOV1N', 'TGOV1DB', 'IEEEG1', 'IEESGO']), ('exciter', ['EXDC2', 'IEEEX1', 'ESDC2A', 'EXST1', 'ESST3A', 'SEXS', 'IEEET1', 'EXAC1', 'EXAC4', 'ESST4B', 'AC8B', 'IEEET3', - 'ESAC1A']), + 'ESAC1A', 'ESST1A']), ('pss', ['IEEEST', 'ST2CUT']), ('motor', ['Motor3', 'Motor5']), ('measurement', ['BusFreq', 'BusROCOF', 'PMU']), diff --git a/andes/models/exciter/__init__.py b/andes/models/exciter/__init__.py index 0589611bb..67ecc456a 100644 --- a/andes/models/exciter/__init__.py +++ b/andes/models/exciter/__init__.py @@ -11,5 +11,6 @@ from andes.models.exciter.ac8b import AC8B # NOQA from andes.models.exciter.ieeet3 import IEEET3 # NOQA from andes.models.exciter.esac1a import ESAC1A # NOQA +from andes.models.exciter.esst1a import ESST1A # NOQA from andes.models.exciter.saturation import ExcQuadSat, ExcExpSat # NOQA \ No newline at end of file From 92a2760573253f12c289faee800794a694fdc966 Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Mon, 4 Oct 2021 23:11:21 -0400 Subject: [PATCH 03/58] Work on ESST1A. --- andes/models/exciter/esst1a.py | 56 +++++++++++++++++++--------------- 1 file changed, 31 insertions(+), 25 deletions(-) diff --git a/andes/models/exciter/esst1a.py b/andes/models/exciter/esst1a.py index 34a7d906b..f95cd9a79 100644 --- a/andes/models/exciter/esst1a.py +++ b/andes/models/exciter/esst1a.py @@ -3,7 +3,7 @@ from andes.core.param import NumParam from andes.core.var import Algeb, ExtAlgeb -from andes.core.service import PostInitService, ConstService +from andes.core.service import PostInitService, ConstService, VarService from andes.core.discrete import Switcher, Limiter from andes.core.block import LagAntiWindup, Lag, HVGate, LVGate from andes.core.block import Piecewise, PIDTrackAW, LeadLag, Washout @@ -200,7 +200,6 @@ def __init__(self, system, config): self.SWUEL = Switcher(u=self.UELc, options=[0, 1, 2, 3], tex_name='SW_{UEL}', cache=True) self.SWVOS = Switcher(u=self.VOSc, options=[0, 1, 2], tex_name='SW_{VOS}', cache=True) - # control block begin self.LG = Lag(self.v, T=self.TR, K=1, info='Voltage transducer', @@ -240,7 +239,12 @@ def __init__(self, system, config): diag_eps=True, ) - self.HVG1 = HVGate(u1=dummify('SWUEL_s2 * UEL + (1 - SWUEL_s2) * ll'), + self.UEL2 = Algeb(tex_name='UEL_2', + info='UEL_2 as HVG1 u1', + v_str='SWUEL_s2 * UEL + (1 - SWUEL_s2) * ll', + e_str='ue * (SWUEL_s2 * UEL + (1 - SWUEL_s2) * ll - UEL2)', + ) + self.HVG1 = HVGate(u1=self.UEL2, u2=self.VI, info='HVGate after V_I', ) @@ -268,27 +272,35 @@ def __init__(self, system, config): ) # LA_y is VA self.ILR0 = ConstService(v_str='0', tex_name='I_{LR0}', info='ILR initial value') - # TODO: v_str self.ILR = Algeb(info='exciter output current limit reference', tex_name='I_{LR}}', - v_str='1', + v_str='ILR0', e_str='ILR0 - ILR', ) self.zero = ConstService('0') - self.HLI = Limiter(u=dummify('ILR - XadIfd'), lower=self.zero, - upper=self.ul, no_upper=True, + self.HLI = Limiter(u='XadIfd - ILR', + lower=self.zero, upper=self.ul, no_upper=True, info='Hard limiter for excitation current') - # TODO: u2, KLR - self.HVG = HVGate(u1=dummify('SWUEL_s3 * UEL + (1 - SWUEL_s3) * ll'), - u2=dummify('SWVOS_s2 * VOTHSG + LA_y - (1 - HLI_zl) * KLR * (ILR - XadIfd)'), + self.UEL3 = Algeb(tex_name='UEL_3', + info='UEL_3 as HVG u1', + v_str='SWUEL_s3 * UEL + (1 - SWUEL_s3) * ll', + e_str='ue * (SWUEL_s3 * UEL + (1 - SWUEL_s3) * ll - UEL3)', + ) + self.HVGu2 = Algeb(tex_name=r'HVG_{u2}', + info='HVG u2', + v_str='SWVOS_s2 * VOTHSG + LA_y - (1 - HLI_zl) * KLR * (ILR - XadIfd)', + e_str='ue * (SWVOS_s2 * VOTHSG + LA_y - (1 - HLI_zl) * KLR * (ILR - XadIfd) - HVGu2)', + ) + self.HVG = HVGate(u1=self.UEL3, + u2=self.HVGu2, info='HVGate for under excitation', ) self.LVG = LVGate(u1=self.HVG_y, u2=self.OEL, - info='HVGate for under excitation', + info='HVGate for over excitation', ) # vd, vq, Id, Iq from SynGen @@ -305,20 +317,15 @@ def __init__(self, system, config): info='q-axis machine voltage', ) - # TODO: v_str - self.efdu = Algeb(info='Output exciter voltage upper bound', - tex_name='LVG_{y}', - v_str='1', - e_str='Abs(vd + 1j*vq) * VRMAX - KC * XadIfd - efdu', - ) - # TODO: v_str - self.efdl = Algeb(info='Output exciter voltage lower bound', - tex_name='LVG_{y}', - v_str='1', - e_str='Abs(vd + 1j*vq) * VRMIN - efdl', - ) + self.efdu = VarService(info='Output exciter voltage upper bound', + tex_name='efd_{u}', + v_str='Abs(vd + 1j*vq) * VRMAX - KC * XadIfd', + ) + self.efdl = VarService(info='Output exciter voltage lower bound', + tex_name='efd_{l}', + v_str='Abs(vd + 1j*vq) * VRMIN' + ) - # TODO: lower and upper self.vol = Limiter(u=self.LVG_y, info='vout limiter', lower=self.efdu, upper=self.efdl, ) @@ -329,7 +336,6 @@ def __init__(self, system, config): info='V_F, Stablizing circuit feedback', ) - # self.vout.e_str = '1' self.vout.e_str = 'ue * (vol_zi * LVG_y + vol_zl * efdl + vol_zu * efdu - vout)' From dffda5e522088c00870ff21b3920f01224759e4b Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Mon, 4 Oct 2021 23:30:05 -0400 Subject: [PATCH 04/58] Bug with a limiter lower in ESST1A for PFlow. --- andes/models/exciter/esst1a.py | 100 ++++----------------------------- 1 file changed, 10 insertions(+), 90 deletions(-) diff --git a/andes/models/exciter/esst1a.py b/andes/models/exciter/esst1a.py index f95cd9a79..63951ca7b 100644 --- a/andes/models/exciter/esst1a.py +++ b/andes/models/exciter/esst1a.py @@ -18,88 +18,6 @@ class ESST1AData(ExcBaseData): def __init__(self): ExcBaseData.__init__(self) - self.kP = NumParam(info='PID proportional coeff.', - tex_name='k_P', - default=10, - vrange=(10, 500), - ) - self.kI = NumParam(info='PID integrative coeff.', - tex_name='k_I', - default=10, - vrange=(10, 500), - ) - self.kD = NumParam(info='PID direvative coeff.', - tex_name='k_D', - default=10, - vrange=(10, 500), - ) - self.Td = NumParam(info='PID direvative time constant.', - tex_name='T_d', - default=0.2, - vrange=(0, 0.5), - ) - - self.VPMAX = NumParam(info='PID maximum limit', - tex_name='V_{PMAX}', - default=999, - unit='p.u.') - self.VPMIN = NumParam(info='PID minimum limit', - tex_name='V_{PMIN}', - default=-999, - unit='p.u.') - - - # TODO: check default value for VFEMAX - self.VFEMAX = NumParam(info='Maximum VFE', - tex_name=r'V_{FEMAX}', - default=999, - unit='p.u.') - - # TODO: check default value for VEMIN - self.VEMIN = NumParam(info='Minimum excitation output', - tex_name=r'V_{EMIN}', - default=-999, - unit='p.u.') - - self.TE = NumParam(info='Exciter integrator time constant', - tex_name='T_E', - default=0.8, - unit='p.u.', - ) - - self.E1 = NumParam(info='First saturation point', - tex_name='E_1', - default=0., - unit='p.u.', - ) - self.SE1 = NumParam(info='Value at first saturation point', - tex_name='S_{E1}', - default=0., - unit='p.u.', - ) - self.E2 = NumParam(info='Second saturation point', - tex_name='E_2', - default=1., - unit='p.u.', - ) - self.SE2 = NumParam(info='Value at second saturation point', - tex_name='S_{E2}', - default=1., - unit='p.u.', - ) - - self.KE = NumParam(info='Gain added to saturation', - tex_name='K_E', - default=1, - unit='p.u.', - ) - self.KD = NumParam(default=0, - info='Ifd feedback gain', - tex_name='K_D', - vrange=(0, 1), - ) - - # -- cut line self.TR = NumParam(info='Sensing time constant', tex_name='T_R', default=0.01, @@ -212,8 +130,7 @@ def __init__(self, system, config): # TODO: check v_str self.vref0 = ConstService(info='Initial reference voltage input', tex_name='V_{ref0}', - # v_str='v + vfe0 / KA', - v_str='1', + v_str='v', ) ExcVsum.__init__(self) @@ -228,13 +145,14 @@ def __init__(self, system, config): diag_eps=True, ) - self.vil = Limiter(u=self.vi, lower=self.VIMIN, upper=self.VIMAX, + self.vil = Limiter(u=self.vi, + # lower=self.ll, upper=self.ul, + lower=self.VIMIN, upper=self.VIMAX, info='Hard limiter before V_I') - # TODO: check v_str self.VI = Algeb(tex_name='V_I', info='V_I', - v_str='1', + v_str='vil_zi * vi + vil_zl * VIMIN + vil_zu * VIMAX', e_str='ue * (vil_zi * vi + vil_zl * VIMIN + vil_zu * VIMAX - VI)', diag_eps=True, ) @@ -279,8 +197,9 @@ def __init__(self, system, config): ) self.zero = ConstService('0') - self.HLI = Limiter(u='XadIfd - ILR', - lower=self.zero, upper=self.ul, no_upper=True, + self.HLI = Limiter(u='XadIfd - ILR', no_upper=True, + # lower=self.zero, upper=self.ul, + lower=self.VRMIN, upper=self.VRMAX, info='Hard limiter for excitation current') self.UEL3 = Algeb(tex_name='UEL_3', @@ -327,7 +246,8 @@ def __init__(self, system, config): ) self.vol = Limiter(u=self.LVG_y, info='vout limiter', - lower=self.efdu, upper=self.efdl, + # lower=self.efdu, upper=self.efdl, + lower=self.VRMIN, upper=self.VRMAX, ) self.WF = Washout(u=self.LVG_y, From 67e1d2afbe166321afd1911b1e84118776aa3449 Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Tue, 5 Oct 2021 00:01:25 -0400 Subject: [PATCH 05/58] Revised ESST1A input file. --- andes/cases/ieee14/ieee14_esst1a.xlsx | Bin 26590 -> 26594 bytes andes/models/exciter/esst1a.py | 9 +++------ 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/andes/cases/ieee14/ieee14_esst1a.xlsx b/andes/cases/ieee14/ieee14_esst1a.xlsx index e7cadb7bec4fc86ae02caa114d4cf537b6c31155..5cd3b801175a83c25b734c874f5ce4b46264f670 100644 GIT binary patch delta 2999 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 Date: Tue, 5 Oct 2021 00:01:52 -0400 Subject: [PATCH 06/58] Fixed ESST1A, now the PFlow can start. --- andes/models/exciter/esst1a.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/andes/models/exciter/esst1a.py b/andes/models/exciter/esst1a.py index 6669374db..1a3e2dfcb 100644 --- a/andes/models/exciter/esst1a.py +++ b/andes/models/exciter/esst1a.py @@ -195,8 +195,13 @@ def __init__(self, system, config): e_str='ILR0 - ILR', ) + self.ifl = Algeb(info='exciter output current limiter input', + tex_name='I_{fl}}', + v_str='XadIfd - ILR', + e_str='XadIfd - ILR - ifl', + ) self.zero = ConstService('0') - self.HLI = Limiter(u='XadIfd - ILR', no_upper=True, + self.HLI = Limiter(u=self.ifl, no_upper=True, lower=self.zero, upper=self.ul, info='Hard limiter for excitation current') From 4fc1ddb69a604eece659800dd106f2f3c2137322 Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Tue, 5 Oct 2021 01:02:54 -0400 Subject: [PATCH 07/58] Debug ESST1A, PFlow init failed. --- andes/models/exciter/esst1a.py | 31 ++++++++++++++++++------------- 1 file changed, 18 insertions(+), 13 deletions(-) diff --git a/andes/models/exciter/esst1a.py b/andes/models/exciter/esst1a.py index 1a3e2dfcb..7b89ce913 100644 --- a/andes/models/exciter/esst1a.py +++ b/andes/models/exciter/esst1a.py @@ -111,7 +111,11 @@ class ESST1AModel(ExcBase, ExcVsum, ExcACSat): def __init__(self, system, config): ExcBase.__init__(self, system, config) self.flags.nr_iter = True - + + ExcVsum.__init__(self) + self.UEL0.v_str = '-999' + self.OEL0.v_str = '999' + self.ul = ConstService('9999') self.ll = ConstService('-9999') @@ -127,21 +131,22 @@ def __init__(self, system, config): v_str='VOTHSG0', e_str='VOTHSG0 - VOTHSG', ) + + self.ILR0 = ConstService(v_str='0', tex_name='I_{LR0}', info='ILR initial value') + self.VA0 = ConstService(tex_name='V_{A0}', + v_str='vf0 - SWVOS_s2 * VOTHSG + (1 - HLI_zl) * KLR * (XadIfd - ILR0)', + info='VA (LA_y) initial value') # TODO: check v_str self.vref0 = ConstService(info='Initial reference voltage input', tex_name='V_{ref0}', - v_str='v', + v_str='v - VA0/KA - SWVOS_s1 * VOTHSG - SWUEL_s1 * UEL', ) - ExcVsum.__init__(self) - self.UEL0.v_str = '-999' - self.OEL0.v_str = '999' - self.vi = Algeb(info='Total input voltages', tex_name='V_i', unit='p.u.', e_str='ue * (-LG_y + vref - WF_y + SWUEL_s1 * UEL + SWVOS_s1 * VOTHSG + Vs - vi)', - v_str='-v + vref', + v_str='VA0 / KA', diag_eps=True, ) @@ -151,7 +156,7 @@ def __init__(self, system, config): self.VI = Algeb(tex_name='V_I', info='V_I', - v_str='vil_zi * vi + vil_zl * VIMIN + vil_zu * VIMAX', + v_str='VA0 / KA', e_str='ue * (vil_zi * vi + vil_zl * VIMIN + vil_zu * VIMAX - VI)', diag_eps=True, ) @@ -188,7 +193,6 @@ def __init__(self, system, config): info='V_A, Anti-windup lag', ) # LA_y is VA - self.ILR0 = ConstService(v_str='0', tex_name='I_{LR0}', info='ILR initial value') self.ILR = Algeb(info='exciter output current limit reference', tex_name='I_{LR}}', v_str='ILR0', @@ -210,9 +214,10 @@ def __init__(self, system, config): v_str='SWUEL_s3 * UEL + (1 - SWUEL_s3) * ll', e_str='ue * (SWUEL_s3 * UEL + (1 - SWUEL_s3) * ll - UEL3)', ) + # TODO: v_str may need change self.HVGu2 = Algeb(tex_name=r'HVG_{u2}', info='HVG u2', - v_str='SWVOS_s2 * VOTHSG + LA_y - (1 - HLI_zl) * KLR * (ILR - XadIfd)', + v_str='vf0', e_str='ue * (SWVOS_s2 * VOTHSG + LA_y - (1 - HLI_zl) * KLR * (ILR - XadIfd) - HVGu2)', ) self.HVG = HVGate(u1=self.UEL3, @@ -240,16 +245,16 @@ def __init__(self, system, config): ) self.efdu = VarService(info='Output exciter voltage upper bound', - tex_name='efd_{u}', + tex_name=r'efd_{u}', v_str='Abs(vd + 1j*vq) * VRMAX - KC * XadIfd', ) self.efdl = VarService(info='Output exciter voltage lower bound', - tex_name='efd_{l}', + tex_name=r'efd_{l}', v_str='Abs(vd + 1j*vq) * VRMIN' ) self.vol = Limiter(u=self.LVG_y, info='vout limiter', - lower=self.efdu, upper=self.efdl, + lower=self.efdl, upper=self.efdu, ) self.WF = Washout(u=self.LVG_y, From 764f2c7666198c09b99f32c09845e1b9c4c78b79 Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Tue, 5 Oct 2021 17:58:25 -0400 Subject: [PATCH 08/58] Work on ESST1A init. --- andes/models/exciter/esst1a.py | 115 +++++++++++++++++---------------- 1 file changed, 59 insertions(+), 56 deletions(-) diff --git a/andes/models/exciter/esst1a.py b/andes/models/exciter/esst1a.py index 7b89ce913..0b789f757 100644 --- a/andes/models/exciter/esst1a.py +++ b/andes/models/exciter/esst1a.py @@ -5,7 +5,7 @@ from andes.core.service import PostInitService, ConstService, VarService from andes.core.discrete import Switcher, Limiter -from andes.core.block import LagAntiWindup, Lag, HVGate, LVGate +from andes.core.block import LagAntiWindup, Lag, HVGate, LVGate, GainLimiter from andes.core.block import Piecewise, PIDTrackAW, LeadLag, Washout from andes.models.exciter.excbase import ExcBase, ExcBaseData, ExcVsum, ExcACSat @@ -40,14 +40,6 @@ def __init__(self): default=1, ) - self.VAMAX = NumParam(info='V_A upper limit', - tex_name='V_{AMAX}', - default=999, - unit='p.u.') - self.VAMIN = NumParam(info='V_A lower limit', - tex_name='V_{AMIN}', - default=-999, - unit='p.u.') self.TB1 = NumParam(info='Lag time constant in lead-lag 1', tex_name=r'T_{B1}', default=1, @@ -57,6 +49,15 @@ def __init__(self): default=1, ) + self.VAMAX = NumParam(info='V_A upper limit', + tex_name='V_{AMAX}', + default=999, + unit='p.u.') + self.VAMIN = NumParam(info='V_A lower limit', + tex_name='V_{AMIN}', + default=-999, + unit='p.u.') + self.KA = NumParam(default=80, info='Regulator gain', tex_name='K_A', @@ -66,18 +67,22 @@ def __init__(self): default=0.04, ) + self.ILR = NumParam(default=1, + info='Exciter output current limite reference', + tex_name=r'I_{LR}', + ) self.KLR = NumParam(default=1, info='Exciter output current limiter gain', - tex_name=r'K_LR', + tex_name=r'K_{LR}', ) - self.VRMAX = NumParam(info='Maximum excitation limit', + self.VRMAX = NumParam(info='Maximum voltage regulator output limit', tex_name='V_{RMAX}', default=7.3, unit='p.u.',) - self.VRMIN = NumParam(info='Minimum excitation limit', + self.VRMIN = NumParam(info='Minimum voltage regulator output limit', tex_name='V_{RMIN}', - default=1, + default=-7.3, unit='p.u.',) self.KF = NumParam(default=0.1, @@ -85,7 +90,7 @@ def __init__(self): tex_name='K_F', ) self.TF = NumParam(info='Feedback washout time constant', - tex_name='T_{F1}', + tex_name='T_{F}', default=1, ) @@ -103,6 +108,7 @@ def __init__(self): default=1, ) + class ESST1AModel(ExcBase, ExcVsum, ExcACSat): """ Implementation of the ESST1A model. @@ -126,27 +132,37 @@ def __init__(self, system, config): self.LG = Lag(self.v, T=self.TR, K=1, info='Voltage transducer', ) - self.VOTHSG0 = ConstService(v_str='0', info='VOTHSG initial value.') - self.VOTHSG = Algeb(tex_name='VOTHSG', info='VOTHSG', - v_str='VOTHSG0', - e_str='VOTHSG0 - VOTHSG', - ) + self.SG0 = ConstService(v_str='0', info='SG initial value.') + self.SG = Algeb(tex_name='SG', info='SG', + v_str='SG0', + e_str='SG0 - SG', + ) - self.ILR0 = ConstService(v_str='0', tex_name='I_{LR0}', info='ILR initial value') - self.VA0 = ConstService(tex_name='V_{A0}', - v_str='vf0 - SWVOS_s2 * VOTHSG + (1 - HLI_zl) * KLR * (XadIfd - ILR0)', - info='VA (LA_y) initial value') - # TODO: check v_str + self.zero = ConstService('0') + self.LR = GainLimiter(u='XadIfd - ILR', + K=self.KLR, R=1, + upper=self.ul, lower=self.zero, + no_upper=True, + info='Exciter output current gain limiter', + ) + + self.VA0 = PostInitService(tex_name='V_{A0}', + v_str='vf0 - SWVOS_s2 * SG + LR_y', + info='VA (LA_y) initial value') + + self.vb0 = ConstService(info='Initial vb', + tex_name='V_{b0}', + v_str='VA0 / KA - SWVOS_s1 * SG0 - SWUEL_s1 * UEL0 + LR_y') self.vref0 = ConstService(info='Initial reference voltage input', tex_name='V_{ref0}', - v_str='v - VA0/KA - SWVOS_s1 * VOTHSG - SWUEL_s1 * UEL', + v_str='v + vb0', ) self.vi = Algeb(info='Total input voltages', tex_name='V_i', unit='p.u.', - e_str='ue * (-LG_y + vref - WF_y + SWUEL_s1 * UEL + SWVOS_s1 * VOTHSG + Vs - vi)', - v_str='VA0 / KA', + e_str='ue * (-LG_y + vref - WF_y + SWUEL_s1 * UEL + SWVOS_s1 * SG + Vs - vi)', + v_str='ue * VA0 / KA', diag_eps=True, ) @@ -156,14 +172,14 @@ def __init__(self, system, config): self.VI = Algeb(tex_name='V_I', info='V_I', - v_str='VA0 / KA', + v_str='ue * VA0 / KA', e_str='ue * (vil_zi * vi + vil_zl * VIMIN + vil_zu * VIMAX - VI)', diag_eps=True, ) self.UEL2 = Algeb(tex_name='UEL_2', info='UEL_2 as HVG1 u1', - v_str='SWUEL_s2 * UEL + (1 - SWUEL_s2) * ll', + v_str='ue * (SWUEL_s2 * UEL + (1 - SWUEL_s2) * ll)', e_str='ue * (SWUEL_s2 * UEL + (1 - SWUEL_s2) * ll - UEL2)', ) self.HVG1 = HVGate(u1=self.UEL2, @@ -193,35 +209,19 @@ def __init__(self, system, config): info='V_A, Anti-windup lag', ) # LA_y is VA - self.ILR = Algeb(info='exciter output current limit reference', - tex_name='I_{LR}}', - v_str='ILR0', - e_str='ILR0 - ILR', - ) - - self.ifl = Algeb(info='exciter output current limiter input', - tex_name='I_{fl}}', - v_str='XadIfd - ILR', - e_str='XadIfd - ILR - ifl', - ) - self.zero = ConstService('0') - self.HLI = Limiter(u=self.ifl, no_upper=True, - lower=self.zero, upper=self.ul, - info='Hard limiter for excitation current') + self.vas = Algeb(tex_name=r'V_{As}', + info='V_A after subtraction, as HVG u2', + v_str='ue * vf0', + e_str='ue * (SWVOS_s2 * SG + LA_y - LR_y - vas)', + ) self.UEL3 = Algeb(tex_name='UEL_3', info='UEL_3 as HVG u1', - v_str='SWUEL_s3 * UEL + (1 - SWUEL_s3) * ll', + v_str='ue * (SWUEL_s3 * UEL + (1 - SWUEL_s3) * ll)', e_str='ue * (SWUEL_s3 * UEL + (1 - SWUEL_s3) * ll - UEL3)', ) - # TODO: v_str may need change - self.HVGu2 = Algeb(tex_name=r'HVG_{u2}', - info='HVG u2', - v_str='vf0', - e_str='ue * (SWVOS_s2 * VOTHSG + LA_y - (1 - HLI_zl) * KLR * (ILR - XadIfd) - HVGu2)', - ) self.HVG = HVGate(u1=self.UEL3, - u2=self.HVGu2, + u2=self.vas, info='HVGate for under excitation', ) @@ -253,9 +253,12 @@ def __init__(self, system, config): v_str='Abs(vd + 1j*vq) * VRMIN' ) - self.vol = Limiter(u=self.LVG_y, info='vout limiter', - lower=self.efdl, upper=self.efdu, - ) + self.vol = GainLimiter(u=self.LVG_y, + K=1, R=1, + upper=self.efdu, + lower=self.efdl, + info='Exciter output limiter', + ) self.WF = Washout(u=self.LVG_y, T=self.TF, @@ -263,7 +266,7 @@ def __init__(self, system, config): info='V_F, Stablizing circuit feedback', ) - self.vout.e_str = 'ue * (vol_zi * LVG_y + vol_zl * efdl + vol_zu * efdu - vout)' + self.vout.e_str = 'ue * (vol_y - vout)' class ESST1A(ESST1AData, ESST1AModel): From 83e1d678c6b01a97752f17001fbdc99e736debcc Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Tue, 5 Oct 2021 20:25:10 -0400 Subject: [PATCH 09/58] Finished ESST1A. --- andes/models/exciter/esst1a.py | 51 +++++++++++++++------------------- 1 file changed, 23 insertions(+), 28 deletions(-) diff --git a/andes/models/exciter/esst1a.py b/andes/models/exciter/esst1a.py index 0b789f757..1f2a579c8 100644 --- a/andes/models/exciter/esst1a.py +++ b/andes/models/exciter/esst1a.py @@ -1,15 +1,13 @@ -from collections import OrderedDict - from andes.core.param import NumParam from andes.core.var import Algeb, ExtAlgeb from andes.core.service import PostInitService, ConstService, VarService -from andes.core.discrete import Switcher, Limiter +from andes.core.discrete import Switcher from andes.core.block import LagAntiWindup, Lag, HVGate, LVGate, GainLimiter -from andes.core.block import Piecewise, PIDTrackAW, LeadLag, Washout +from andes.core.block import LeadLag, Washout from andes.models.exciter.excbase import ExcBase, ExcBaseData, ExcVsum, ExcACSat -from andes.core.common import dummify + class ESST1AData(ExcBaseData): """ @@ -150,32 +148,28 @@ def __init__(self, system, config): v_str='vf0 - SWVOS_s2 * SG + LR_y', info='VA (LA_y) initial value') - self.vb0 = ConstService(info='Initial vb', - tex_name='V_{b0}', - v_str='VA0 / KA - SWVOS_s1 * SG0 - SWUEL_s1 * UEL0 + LR_y') - self.vref0 = ConstService(info='Initial reference voltage input', - tex_name='V_{ref0}', - v_str='v + vb0', - ) + self.vref.v_str = 'v + (vf0 - SWVOS_s2 * SG + LR_y) / KA - SWVOS_s1 * SG - SWUEL_s1 * UEL' + self.vref.v_iter = 'v + (vf0 - SWVOS_s2 * SG + LR_y) / KA - SWVOS_s1 * SG - SWUEL_s1 * UEL' + + self.vref0 = PostInitService(info='Initial reference voltage input', + tex_name='V_{ref0}', + v_str='vref', + ) self.vi = Algeb(info='Total input voltages', tex_name='V_i', unit='p.u.', e_str='ue * (-LG_y + vref - WF_y + SWUEL_s1 * UEL + SWVOS_s1 * SG + Vs - vi)', - v_str='ue * VA0 / KA', + v_iter='ue * (-LG_y + vref - WF_y + SWUEL_s1 * UEL + SWVOS_s1 * SG + Vs)', + v_str='ue * (-LG_y + vref - WF_y + SWUEL_s1 * UEL + SWVOS_s1 * SG + Vs)', diag_eps=True, ) - self.vil = Limiter(u=self.vi, - lower=self.ll, upper=self.ul, - info='Hard limiter before V_I') - - self.VI = Algeb(tex_name='V_I', - info='V_I', - v_str='ue * VA0 / KA', - e_str='ue * (vil_zi * vi + vil_zl * VIMIN + vil_zu * VIMAX - VI)', - diag_eps=True, - ) + self.vil = GainLimiter(u=self.vi, + K=1, R=1, + upper=self.VIMAX, lower=self.VIMIN, + info='Exciter voltage input limiter', + ) self.UEL2 = Algeb(tex_name='UEL_2', info='UEL_2 as HVG1 u1', @@ -183,7 +177,7 @@ def __init__(self, system, config): e_str='ue * (SWUEL_s2 * UEL + (1 - SWUEL_s2) * ll - UEL2)', ) self.HVG1 = HVGate(u1=self.UEL2, - u2=self.VI, + u2=self.vil_y, info='HVGate after V_I', ) @@ -210,10 +204,11 @@ def __init__(self, system, config): ) # LA_y is VA self.vas = Algeb(tex_name=r'V_{As}', - info='V_A after subtraction, as HVG u2', - v_str='ue * vf0', - e_str='ue * (SWVOS_s2 * SG + LA_y - LR_y - vas)', - ) + info='V_A after subtraction, as HVG u2', + v_str='ue * (SWVOS_s2 * SG + LA_y - LR_y)', + v_iter='ue * (SWVOS_s2 * SG + LA_y - LR_y)', + e_str='ue * (SWVOS_s2 * SG + LA_y - LR_y - vas)', + ) self.UEL3 = Algeb(tex_name='UEL_3', info='UEL_3 as HVG u1', From 0d8053bc256fed472d805362baaa38a1191658f8 Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Tue, 5 Oct 2021 20:29:35 -0400 Subject: [PATCH 10/58] Fixed ESST1A docstring. --- andes/models/exciter/esst1a.py | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/andes/models/exciter/esst1a.py b/andes/models/exciter/esst1a.py index 1f2a579c8..f5fd298e3 100644 --- a/andes/models/exciter/esst1a.py +++ b/andes/models/exciter/esst1a.py @@ -23,11 +23,11 @@ def __init__(self): self.VIMAX = NumParam(default=0.8, info='Max. input voltage', - tex_name='V_{IMAX}', + tex_name=r'V_{IMAX}', ) self.VIMIN = NumParam(default=-0.1, info='Min. input voltage', - tex_name='V_{IMIN}', + tex_name=r'V_{IMIN}', ) self.TB = NumParam(info='Lag time constant in lead-lag', tex_name='T_B', @@ -48,11 +48,11 @@ def __init__(self): ) self.VAMAX = NumParam(info='V_A upper limit', - tex_name='V_{AMAX}', + tex_name=r'V_{AMAX}', default=999, unit='p.u.') self.VAMIN = NumParam(info='V_A lower limit', - tex_name='V_{AMIN}', + tex_name=r'V_{AMIN}', default=-999, unit='p.u.') @@ -75,11 +75,11 @@ def __init__(self): ) self.VRMAX = NumParam(info='Maximum voltage regulator output limit', - tex_name='V_{RMAX}', + tex_name=r'V_{RMAX}', default=7.3, unit='p.u.',) self.VRMIN = NumParam(info='Minimum voltage regulator output limit', - tex_name='V_{RMIN}', + tex_name=r'V_{RMIN}', default=-7.3, unit='p.u.',) @@ -98,11 +98,11 @@ def __init__(self): ) self.UELc = NumParam(info='Alternate UEL inputs, input code 1-3', - tex_name='UEL', + tex_name='UEL_c', default=1, ) self.VOSc = NumParam(info='Alternate Stabilizer inputs, input code 1-2', - tex_name='VOS', + tex_name='VOS_c', default=1, ) @@ -267,11 +267,16 @@ def __init__(self, system, config): class ESST1A(ESST1AData, ESST1AModel): """ Exciter ESST1A model. + Reference: + [1] PowerWorld, Exciter ESST1A, [Online], + [2] NEPLAN, Exciters Models, [Online], + Available: https://www.powerworld.com/WebHelp/Content/TransientModels_HTML/Exciter%20ESST1A.htm + https://www.neplan.ch/wp-content/uploads/2015/08/Nep_EXCITERS1.pdf """ def __init__(self, system, config): From a6a45e90c6faad6664223f348781233947b6ce3b Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Tue, 5 Oct 2021 20:30:02 -0400 Subject: [PATCH 11/58] Revised ESST1A input file. --- andes/cases/ieee14/ieee14_esst1a.xlsx | Bin 26594 -> 26683 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/andes/cases/ieee14/ieee14_esst1a.xlsx b/andes/cases/ieee14/ieee14_esst1a.xlsx index 5cd3b801175a83c25b734c874f5ce4b46264f670..09bd3dffe8a65f24ddd1cf9eb122a9a7c8c0872f 100644 GIT binary patch delta 3151 zcmY*bX*kq<7ak+~m_hcTY}uK?WS5;vA-f_Pj4+JH9x>suCfh$68J>h8Qp{uv*|*A0 z_9ZkZYa^BQ?eXD#ulIcTUH5gi>wNg#=RS)AbPa=al}Rl4I_p`Q8$AeA%nSm-Kp;>U z77>aI@Im8nK8j(!*dkl!z+83i$oZTjSjwERC|Dh1plR+Fsxkt@Z4^a*>k)zb>OD8; z=nvYT|H%r;-Z7gB=MpVgDhv!BXnGe#K?JPiyht|V6c6|;mXKsba>BapRz6L8m2T}N zYxUHu6_4I+lij6Kx0+vtTIp02-w$}8XQTA~jiPu;xr7@-g`#`!nRRTDY-xP))MA-U z3dy#Mpct@T@0ZB-p21r{?1vzz7iSAv>(tcHT2cebu9tn(bkZR0JR_!~DRCN#Cm7LqcvW>(prbyciV zekDC*(Ws9(`Yqg;+S{G169}~5&SJ$|+fD?=nJOQ&^-mGXu>*cQ`rd1>IPfgBU{XXuuwnHhc`qCxLjl#uyO?MnTjBo|KxPM1nS5>j4M z3#VD?;SABbagP34tRz|vjPk)>`WnwjebFRo-) znRZY2{Mdr&123@Zqpb{zb1*8^QS$)dR20Bh$eE)TYuIo0Qw&+|OgV@v(TtV8g*Q6b zJl|C-aCwhesfFF%UyWoPW4AnLMDwh9?h~jcDLKHLHk7o`V7D!FNnC}<+?BmZqL2Mf zT}vc++XXcA<;2{^L47kp9$YzwqmfsyeN;WHi8q-xEa2H2BoVNyi!N*|ixJCT(t~#H zieAqO={_)ARxarU7@+e0{*3+J_yPrFP<4L2%-vfX5sHL32KpZpJLzGpx}LneQPL6X zV;l#5dpooeCN`a_K|nP8$L5H5RUloqx@5a>o2Sc@^0VslsoRw0zU&WUUq(r_XD4df z^~o#Ak+sdPo=id-{s|fnh(fMXiKw-XJhrn>r3Qog3aj!~n2PGtNpS+x^mB(Wz?G95 z=s|N(B-w`%?1&{}UY9?F6k`E_1b}ExUc3_OUnUZPTexWv?(TW14K0U8sR{GxVmo4) zw|&L1oo%1u@Er0|>W#WEJ-@uY*-(*(fDGb>0=%6rYUL1?(A#Iy>(20rrO+&s-8%CD zmBbrXvi{CK|Mev^2Cp<8uIxj=pPaNhRio}p$x^Twa*B6_){pV zAJrvG{p;?^XfUsXu$s&j8mj4eGRyUlzuWTLk=Mo5XW;K_o*hBa`pRiL4R%3(7S@MC zM07~iI^#?!lrt;64JZCsBAG8O&{w`(;_I9{Uy2m`Aue_P?v~_~g|*T_%uDun@6#K@i(D@j@Jm_kkxK^S(AfsYBOjHV# z@6%9HB7Th#sLM4&TOsW~>Q(q)7NRg8cfZv8ISiz)WDE2Jc6)b{KM`{by*3>cdT1?> zWk)1ErOKTVprXxwbmqx3w7(9Z5ant8@G^)pq%jaUcui zXVIh93rA2jjO@Fw&e-XDbqDN`^uPlfAIc5Ac~+MGq!bV4KTN3wG|YtY&el_U-0@pl zBPT7(@4D_**U+o$XDBD$9G+0B%aYFLTv=34%eu&|bJF`pxG)pp<>1ozHKJ&&9mB;>1H5#HY*oA=>(#bTEHQj_ZJyhjYS z^~Klu)jO1h50g6TC3BCQr_L72d!0 zJ7;8aO=A87t3F654YvlN%G~! zl#iM4G&h~-s8^kzkrWi(5J({S9L$cRVwT5IcV?@OFlVd~)vU%=kJ@Z!$)C^F2OU;82?e=~wNu4M!it*R<&f9sA4Hm)z7Ex6v& zUS#p&CyWQ;6NMe0y{hAoOG)`KhJH!7!Kw=}oOLS1zPiCM;(uS;jli?gT_=}bmWWy} zd#*6tWR4vrMlEXeZmU)&;tV+#;>Ft7jT7O?{A%3#eilAP^_|Gqon-BET)x%vg8)xB z*~sG4YOk1%;};g2eM$lBQAAIQG&asSzO%Vz1X->B2!{_AE{x?nv+H#LC? zi7L!z#BwZGSem)}Vh(iv*|%_C(#nl%OdYz-+|U(=5Sks(`Rq6DnmXYMnTCQJZbE7e zlFylybz9^0_jpqHC)^hc8Qm`d7$S>`IdW;4aVZw^PmE<{a7=}+K*14Hx)PTX#}xjp z@#JM`HayhueBj@!*h@Tx(hev{%=YNY*m?`+6ME0v*+^cg8CUx`Zdp&X?l}?4d02<4 zwoA|PgNSd*_M9%{ZoYMad9m%Y&$~ZwfWL*FKWt}oqIFYF`2N)riiP*E6%y>msO3< zR;WKy=F?u{C8*VW+zDb%@FCF3{g-aW)M-7I>-{4ldqdXFX3(Lj=)RqLCA|YEy?_z7 zrj>_b0`Oh40biP3TJ$$bsX!^u_AzExvf*viR>0xZmK7BCl|a=+UqvgwW?oB_$m6hh zV7a&M`FI{6-0_??k3U%EObO!*=%@}OMf9m+)h5#3f zokC7`1YHTB?`{mXmjnFe;DC`E2S9Nb1jiswoV9i|?yove~y&F7=nPGv!x@+$?`D`L={N#tfcX#bBgaJV)qMRqSgqj-$fTlDR|-uJy!Q9!x21VAa|PPklY%0q-4K zetPcrf`e^}&xdFKxQk;2Dhh@TWqqtN3Xs9+*X|q$YUh_$%_N?yyz%D(l=-9Qva+RJ z8|9tYH&#N@XfFg!A1(0qI=Za{Z3y)k)P_M+mD{%K^2=&OYN+Ev?FV-g#c7jij-#v` zi`@+^Loh}w*wX9F;Xjy_k2B#^W3@$2(K&6sgH2?vj`~?Q^0|HnM;)ZL_2(Q$sIlg4d0pQh$WCt`- zmpsl`lfT_Y_8mp)3N6wU_2IzAQ#kZ7w5jAWM)-+U`|HagS&^!m4^}Q*3_y!P7yft!INW1CM6~ zyrbpY<7{UO3l_+bm1~p7Gzt|lexJ~U-rGNGGi~4VS359q*7rN%Yg;ewi3C)x@eeuC z+5SFUAfcY|^KJENAnJb29rhTvzNQJDH)m*sKRYH{j&8jciOpQ^VBXuVrKnBZB z=4PBm!I%(eE5Xx;_=FC?i}L{dDs;dAhJ#@Fy8jCHD@8xFWskRrYc1l>;=7YDI`>@j zdkG#xTughu6Ei;kWE06-kwM>oMG;$KSbLkzO?%)6o9!(Qh6$TCmi2Nxuv!{DJdt0` zkkTe)1DS-fz7zjvCM;9-r#2+9?)ifHjG_0d>GN@Sx^3JdE&TwGTNy%@hJG&>9z7m9kP|tc-H&jarLvdy!txRpc5KS9U`$>&MZa_4SUO0iLw#E3PcQDb>ld~7 zFTZvxx?IfvRmh=D86jgr@E0aLoWQa_>%p({2IVZew;%kbTW*^9M&7K(0`^HwYps$C zx5eG7YNn2X@t&dK`XKu{$7^HPPq%z-~ zw-wwmPWY}Q4EC5>xHw+yKMG5~l+#rBCl{Jzo6+NXm9%eJ4FOWGcmg7>%;e|lJuoIy z@&1fuFbKrW1Ol;xfJRqNLSW{I&#*eX&V=|j|Kkbd%&0XLi%^VijL>JMPV2czs#lZJ zAJuci!{~CZ54`Hv%Sh?TZEy?qQnJLp^;tHzYkj$*G;T8DE~;W&WQD5h4)8r({_f7< zQc~ob=P?kZYCdJN{V{xjU1vyUcd>BkRj2=EOVGo817SzMbf0v2O9H2ReoXOxHfqcX zC_{@`7(Dqhtm5;bXG|#Reg9LEwe6iepkJ2se!#B^`!D0V)G(&PthE6%^suOOCZpj| z-N{hFYsSE=%Q?dCFDUX!Ke}~=Yui(kqXKJe%Km)VZG^Y)JUFy+E>v-Tm|e9xCVW9? zH7zU1`>>n&#Z!_ylL~=fkg-dCi0>pT?8B{ta;#5F6B%)rAzC^%kA62F_S?{59$d#f zSp4bZ4cV4A4b1upBKqq>lIL6Nec++XjGW!-`Qg%1v5w3w=r~8N7Id%&m$Do~J`b%i zV>Ib7Tj#>s550n9qmBXHU@rOQmdDVb?3KaYtI`kQB^L`s~tnIwD*_aI-Q50DFad)?UL9>bHPg-S$nXh+gzW!NTr z4#An^=oAfGT_lJ#Q{(A}N9x8p=GSL7f7`|CHxE*-wEPoHu+U`8eJS(J-lYU4*p1X4 zO%-5Ul%XWYBKq6i&TG>>+D7oMra<&`5xf^9RUb!#W>qZVIB$)+QNQBd?S8OG;{nc zZNWQHsMfLe89{B`9=z3lG3kWbKTew=X5D_pM4q)X>RC%ciX7NbJ}2IUU4rKz-1qxD zX(;ld6kT_{go6a8x~ZzV3)|KjZl~_5hKhF%J|bMJ`B`DRiUOpu9OP2WIx|gWR|o7S zxxikQitujCTyrF{GoKfB=kmt~vv=TC`uc@q#|`dv1Bp>7SLa7l0;IlJ#1WZPo2*`9 zA5F&>fY|@lEVX@9HK$as5gB9%weX}-REp9mo8Azdk(?X;1oTOAi8RsXzmS;oezep5 zp56KDZZ8^nFK)xB*r+9!zl-TZQX`pfGUl=PXavDIN-;LnVGyGos0mZOFoG~cfSRO# z^hWq|wwok1HZU1FpV)AvXOmM`1`jZ#>VT@rB83`+1*WZhsZff~Y44A8_?WUX0;~1% zz}in;=aRx4ZB{?AW9|N0Tv>Jyk}zWsRjtB_{E}Q%>)+&z)n{s=M15Jq7sWC0>B_`^ zQYIBT$B{SE#>X-}&4q*#w9;bqZ(o8Ml`lB$Q|9;HOpti_pPD^AiI;|cc`GDpbnc3< z>@@e}*W&~3&*uQR(-8E3Lo2ZCgaOkt0!@M(fT=SI?8*Ewc>)@+d*iV6wzyIn+{-7hK-$n`X9 US^oM?Nd{o~M~Jq@@xS7K06$Wp2LJ#7 From 4e51e20f553979f2ee0eab6e5debabf7bcf949e4 Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Tue, 5 Oct 2021 20:36:03 -0400 Subject: [PATCH 12/58] Added demo for ESST1A. --- examples/demonstration/2.3 demo_ESST1A.ipynb | 380 +++++++++++++++++++ 1 file changed, 380 insertions(+) create mode 100644 examples/demonstration/2.3 demo_ESST1A.ipynb diff --git a/examples/demonstration/2.3 demo_ESST1A.ipynb b/examples/demonstration/2.3 demo_ESST1A.ipynb new file mode 100644 index 000000000..78a01a3da --- /dev/null +++ b/examples/demonstration/2.3 demo_ESST1A.ipynb @@ -0,0 +1,380 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ANDES Demonstration of ESST1A on IEEE 14-Bus System\n", + "\n", + "Prepared by Jinning Wang. Last revised on October 5, 2021." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2021-09-26T22:41:50.949182Z", + "iopub.status.busy": "2021-09-26T22:41:50.948875Z", + "iopub.status.idle": "2021-09-26T22:41:51.715473Z", + "shell.execute_reply": "2021-09-26T22:41:51.715029Z" + } + }, + "outputs": [], + "source": [ + "import andes\n", + "from andes.utils.paths import get_case\n", + "\n", + "andes.config_logger(stream_level=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2021-09-26T22:41:51.718124Z", + "iopub.status.busy": "2021-09-26T22:41:51.717830Z", + "iopub.status.idle": "2021-09-26T22:41:52.415346Z", + "shell.execute_reply": "2021-09-26T22:41:52.415616Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Working directory: \"/Users/jinningwang/Documents/work/andes/examples/demonstration\"\n", + "Loaded config from file \"/Users/jinningwang/.andes/andes.rc\"\n", + "Loaded generated Python code in \"~/.andes/pycode\".\n", + "Parsing input file \"/Users/jinningwang/Documents/work/andes/andes/cases/ieee14/ieee14_esst1a.xlsx\"...\n", + "Input file parsed in 0.3724 seconds.\n", + "System internal structure set up in 0.0220 seconds.\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss = andes.load(get_case('ieee14/ieee14_esst1a.xlsx'),\n", + " setup=False,\n", + " no_output=True)\n", + "ss.setup()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Simulation\n", + "\n", + "Exciter ``ESST1A_1`` is connected to ``GENROU_5``, which is connected to ``Bus_8``." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2021-09-26T22:41:52.417917Z", + "iopub.status.busy": "2021-09-26T22:41:52.417501Z", + "iopub.status.idle": "2021-09-26T22:41:52.439169Z", + "shell.execute_reply": "2021-09-26T22:41:52.439419Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "-> System connectivity check results:\n", + " No islanded bus detected.\n", + " A total of 1 island(s) detected.\n", + " Each island has a slack bus correctly defined and enabled.\n", + "\n", + "-> Power flow calculation\n", + " Sparse solver: KLU\n", + " Solution method: NR method\n", + " Sparse addition: Fast in-place (kvxopt)\n", + "Power flow initialized.\n", + "0: |F(x)| = 0.5605182134\n", + "1: |F(x)| = 0.006202200332\n", + "2: |F(x)| = 5.819382825e-06\n", + "3: |F(x)| = 6.967745825e-12\n", + "Converged in 4 iterations in 0.0055 seconds.\n", + "Initialization for dynamics completed in 0.0236 seconds.\n", + "Initialization was successful.\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss.PFlow.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2021-09-26T22:41:52.442840Z", + "iopub.status.busy": "2021-09-26T22:41:52.442389Z", + "iopub.status.idle": "2021-09-26T22:41:56.170885Z", + "shell.execute_reply": "2021-09-26T22:41:56.171492Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "-> Time Domain Simulation Summary:\n", + "Sparse Solver: KLU\n", + "Simulation time: 0.0-20 s.\n", + "Fixed step size: h=33.33 ms. Shrink if not converged.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": Line.Line_1 status changed to 0 at t=1.0 sec. \n", + ": Line.Line_1 status changed to 1 at t=1.1 sec. \n", + "100%|████████████████████████████████| 100/100 [00:01<00:00, 64.81%/s]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Simulation completed in 1.5432 seconds.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss.TDS.config.tf = 20\n", + "ss.TDS.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2021-09-26T22:41:56.174327Z", + "iopub.status.busy": "2021-09-26T22:41:56.173526Z", + "iopub.status.idle": "2021-09-26T22:41:56.179960Z", + "shell.execute_reply": "2021-09-26T22:41:56.179271Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss.exit_code" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "execution": { + "iopub.execute_input": "2021-09-26T22:41:56.186528Z", + "iopub.status.busy": "2021-09-26T22:41:56.186073Z", + "iopub.status.idle": "2021-09-26T22:41:56.995950Z", + "shell.execute_reply": "2021-09-26T22:41:56.996561Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(
, )" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss.TDS.plt.plot(ss.ESST1A.vout)\n", + "ss.TDS.plt.plot(ss.GENROU.v,\n", + " a=(3,4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cleanup" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2021-09-26T22:41:57.710348Z", + "iopub.status.busy": "2021-09-26T22:41:57.709278Z", + "iopub.status.idle": "2021-09-26T22:41:58.781477Z", + "shell.execute_reply": "2021-09-26T22:41:58.781216Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r\n", + " _ _ | Version 1.4.3.post11+ga6a45e90\r\n", + " /_\\ _ _ __| |___ ___ | Python 3.7.10 on Darwin, 10/05/2021 08:35:38 PM\r\n", + " / _ \\| ' \\/ _` / -_|_-< | \r\n", + " /_/ \\_\\_||_\\__,_\\___/__/ | This program comes with ABSOLUTELY NO WARRANTY.\r\n", + "\r\n", + "No output file found in the working directory.\r\n" + ] + } + ], + "source": [ + "!andes misc -C" + ] + } + ], + "metadata": { + "hide_input": false, + "interpreter": { + "hash": "4c42303ec617988e96980582546035234a0dbb343f6614254a1d5bddbb9babb9" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.10" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From db7ba963c3981e3c02be74e5a97854008cd1eb90 Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Tue, 5 Oct 2021 22:35:15 -0400 Subject: [PATCH 13/58] Fixed docstring for AC8B, ESAC1A, IEEET3. --- andes/models/exciter/ac8b.py | 22 ++++++++++------------ andes/models/exciter/esac1a.py | 12 ++++++------ andes/models/exciter/ieeet3.py | 8 ++++---- 3 files changed, 20 insertions(+), 22 deletions(-) diff --git a/andes/models/exciter/ac8b.py b/andes/models/exciter/ac8b.py index ae7d7fc4c..2b85379c9 100644 --- a/andes/models/exciter/ac8b.py +++ b/andes/models/exciter/ac8b.py @@ -46,33 +46,31 @@ def __init__(self): ) self.VPMAX = NumParam(info='PID maximum limit', - tex_name='V_{PMAX}', + tex_name=r'V_{PMAX}', default=999, unit='p.u.') self.VPMIN = NumParam(info='PID minimum limit', - tex_name='V_{PMIN}', + tex_name=r'V_{PMIN}', default=-999, unit='p.u.') - self.VRMAX = NumParam(info='Maximum excitation limit', - tex_name='V_{RMAX}', + self.VRMAX = NumParam(info='Maximum regulator limit', + tex_name=r'V_{RMAX}', default=7.3, unit='p.u.', vrange=(1, 10)) - self.VRMIN = NumParam(info='Minimum excitation limit', - tex_name='V_{RMIN}', + self.VRMIN = NumParam(info='Minimum regulator limit', + tex_name=r'V_{RMIN}', default=1, unit='p.u.', vrange=(-1, 1.5)) - # TODO: check default value for VFEMAX - self.VFEMAX = NumParam(info='Maximum VFE', + self.VFEMAX = NumParam(info='Exciter field current limit', tex_name=r'V_{FEMAX}', default=999, unit='p.u.') - # TODO: check default value for VEMIN - self.VEMIN = NumParam(info='Minimum excitation output', + self.VEMIN = NumParam(info='Minimum exciter voltage output', tex_name=r'V_{EMIN}', default=-999, unit='p.u.') @@ -99,7 +97,7 @@ def __init__(self): unit='p.u.', ) self.SE1 = NumParam(info='Value at first saturation point', - tex_name='S_{E1}', + tex_name=r'S_{E1}', default=0., unit='p.u.', ) @@ -109,7 +107,7 @@ def __init__(self): unit='p.u.', ) self.SE2 = NumParam(info='Value at second saturation point', - tex_name='S_{E2}', + tex_name=r'S_{E2}', default=1., unit='p.u.', ) diff --git a/andes/models/exciter/esac1a.py b/andes/models/exciter/esac1a.py index e5d3caca6..6af7f0052 100644 --- a/andes/models/exciter/esac1a.py +++ b/andes/models/exciter/esac1a.py @@ -27,11 +27,11 @@ def __init__(self): unit='p.u.', ) self.VAMAX = NumParam(info='V_A upper limit', - tex_name='V_{AMAX}', + tex_name=r'V_{AMAX}', default=999, unit='p.u.') self.VAMIN = NumParam(info='V_A lower limit', - tex_name='V_{AMIN}', + tex_name=r'V_{AMIN}', default=-999, unit='p.u.') self.KA = NumParam(default=80, @@ -44,11 +44,11 @@ def __init__(self): unit='p.u.', ) self.VRMAX = NumParam(info='Max. exc. limit (0-unlimited)', - tex_name='V_{RMAX}', + tex_name=r'V_{RMAX}', default=7.3, unit='p.u.') self.VRMIN = NumParam(info='Min. excitation limit', - tex_name='V_{RMIN}', + tex_name=r'V_{RMIN}', default=-7.3, unit='p.u.') self.TE = NumParam(info='Integrator time constant', @@ -62,7 +62,7 @@ def __init__(self): unit='p.u.', ) self.SE1 = NumParam(info='Value at first saturation point', - tex_name='S_{E1}', + tex_name=r'S_{E1}', default=0., unit='p.u.', ) @@ -72,7 +72,7 @@ def __init__(self): unit='p.u.', ) self.SE2 = NumParam(info='Value at second saturation point', - tex_name='S_{E2}', + tex_name=r'S_{E2}', default=1., unit='p.u.', ) diff --git a/andes/models/exciter/ieeet3.py b/andes/models/exciter/ieeet3.py index f09aa3c15..5f6de4bc5 100644 --- a/andes/models/exciter/ieeet3.py +++ b/andes/models/exciter/ieeet3.py @@ -28,12 +28,12 @@ def __init__(self): default=0.04, unit='p.u.', ) - self.VRMAX = NumParam(info='Maximum excitation limit', - tex_name='V_{RMAX}', + self.VRMAX = NumParam(info='Maximum regulator limit', + tex_name=r'V_{RMAX}', default=7.3, unit='p.u.') - self.VRMIN = NumParam(info='Minimum excitation limit', - tex_name='V_{RMIN}', + self.VRMIN = NumParam(info='Minimum regulator limit', + tex_name=r'V_{RMIN}', default=-7.3, unit='p.u.') self.VBMAX = NumParam(info='VB upper limit', From 5b7a2b03bf7f53dcb1b5571c1d5b97c07be57a20 Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Tue, 5 Oct 2021 22:35:37 -0400 Subject: [PATCH 14/58] Revised notebook for exciters. --- examples/demonstration/2.1 demo_AC8B.ipynb | 59 ++++----------- examples/demonstration/2.2 demo_IEEET3.ipynb | 73 ++++++------------- examples/demonstration/2.3 demo_ESAC1A.ipynb | 61 +++++----------- ...emo_ESST1A.ipynb => 2.4 demo_ESST1A.ipynb} | 19 ++--- 4 files changed, 66 insertions(+), 146 deletions(-) rename examples/demonstration/{2.3 demo_ESST1A.ipynb => 2.4 demo_ESST1A.ipynb} (99%) diff --git a/examples/demonstration/2.1 demo_AC8B.ipynb b/examples/demonstration/2.1 demo_AC8B.ipynb index fe43855c4..9e9441c3d 100644 --- a/examples/demonstration/2.1 demo_AC8B.ipynb +++ b/examples/demonstration/2.1 demo_AC8B.ipynb @@ -6,7 +6,7 @@ "source": [ "# ANDES Demonstration of AC8B on IEEE 14-Bus System\n", "\n", - "Prepared by Jinning Wang. Last revised on September 22, 2021." + "Prepared by Jinning Wang. Last revised on October 5, 2021." ] }, { @@ -48,8 +48,8 @@ "Loaded config from file \"/Users/jinningwang/.andes/andes.rc\"\n", "Loaded generated Python code in \"~/.andes/pycode\".\n", "Parsing input file \"/Users/jinningwang/Documents/work/andes/andes/cases/ieee14/ieee14_ac8b.xlsx\"...\n", - "Input file parsed in 0.5439 seconds.\n", - "System internal structure set up in 0.0231 seconds.\n" + "Input file parsed in 0.3874 seconds.\n", + "System internal structure set up in 0.0215 seconds.\n" ] }, { @@ -76,7 +76,7 @@ "source": [ "## Simulation\n", "\n", - "Exciter `AC8B_1` is connected to `GENROU_5`." + "Exciter `AC8B_1` is connected to `GENROU_5`, which is connected to ``Bus_8``." ] }, { @@ -110,12 +110,12 @@ "1: |F(x)| = 0.006202200332\n", "2: |F(x)| = 5.819382825e-06\n", "3: |F(x)| = 6.967745825e-12\n", - "Converged in 4 iterations in 0.0078 seconds.\n", + "Converged in 4 iterations in 0.0069 seconds.\n", "/Users/jinningwang/.andes/pycode/AC8B.py:91: RuntimeWarning: invalid value encountered in sqrt\n", " return (array([[FEX_y*INT_y - vf0], [-FEX_y + select([less_equal(IN, 0),less_equal(IN, 0.433),less_equal(IN, 0.75),less_equal(IN, 1),greater(IN, 1)], [1,1 - 0.577*IN,sqrt(0.75 - IN**2),1.732 - 1.732*IN,0], default=nan)], [-IN*INT_y + KC*XadIfd]]))\n", "/Users/jinningwang/.andes/pycode/AC8B.py:94: RuntimeWarning: invalid value encountered in sqrt\n", " return (array([[FEX_y, INT_y, 0], [0, -1, select([less_equal(IN, 0),less_equal(IN, 0.433),less_equal(IN, 0.75),less_equal(IN, 1),True], [0,-0.577,-IN/sqrt(0.75 - IN**2),-1.732,0], default=nan)], [-IN, 0, -INT_y]]))\n", - "Initialization for dynamics completed in 0.0267 seconds.\n", + "Initialization for dynamics completed in 0.0245 seconds.\n", "Initialization was successful.\n" ] }, @@ -163,14 +163,14 @@ "text": [ ": Line.Line_1 status changed to 0 at t=1.0 sec. \n", ": Line.Line_1 status changed to 1 at t=1.1 sec. \n", - "100%|████████████████████████████████| 100/100 [00:01<00:00, 65.44%/s]" + "100%|████████████████████████████████| 100/100 [00:01<00:00, 65.22%/s]" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Simulation completed in 1.5284 seconds.\n" + "Simulation completed in 1.5336 seconds.\n" ] }, { @@ -249,35 +249,7 @@ }, { "data": { - "text/plain": [ - "(
, )" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ss.TDS.plt.plot(ss.AC8B.vout)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "execution": { - "iopub.execute_input": "2021-09-26T22:41:57.412726Z", - "iopub.status.busy": "2021-09-26T22:41:57.400721Z", - "iopub.status.idle": "2021-09-26T22:41:58.126359Z", - "shell.execute_reply": "2021-09-26T22:41:58.126769Z" - }, - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -293,14 +265,15 @@ "(
, )" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "ss.TDS.plt.plot(ss.GENROU.omega,\n", - " ycalc=lambda x: 60*x)" + "ss.TDS.plt.plot(ss.AC8B.vout)\n", + "ss.TDS.plt.plot(ss.GENROU.v,\n", + " a=(3,4))" ] }, { @@ -312,7 +285,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2021-09-26T22:41:58.130250Z", @@ -327,8 +300,8 @@ "output_type": "stream", "text": [ "\r\n", - " _ _ | Version 1.4.2.post168.dev0+gf781733e\r\n", - " /_\\ _ _ __| |___ ___ | Python 3.7.10 on Darwin, 10/04/2021 04:41:04 PM\r\n", + " _ _ | Version 1.4.3.post12.dev0+g4e51e20f\r\n", + " /_\\ _ _ __| |___ ___ | Python 3.7.10 on Darwin, 10/05/2021 09:35:10 PM\r\n", " / _ \\| ' \\/ _` / -_|_-< | \r\n", " /_/ \\_\\_||_\\__,_\\___/__/ | This program comes with ABSOLUTELY NO WARRANTY.\r\n", "\r\n", diff --git a/examples/demonstration/2.2 demo_IEEET3.ipynb b/examples/demonstration/2.2 demo_IEEET3.ipynb index 099776e9f..ae3accce9 100644 --- a/examples/demonstration/2.2 demo_IEEET3.ipynb +++ b/examples/demonstration/2.2 demo_IEEET3.ipynb @@ -6,7 +6,7 @@ "source": [ "# ANDES Demonstration of IEEET3 on IEEE 14-Bus System\n", "\n", - "Prepared by Jinning Wang. Last revised on September 22, 2021." + "Prepared by Jinning Wang. Last revised on October 5, 2021." ] }, { @@ -48,8 +48,8 @@ "Loaded config from file \"/Users/jinningwang/.andes/andes.rc\"\n", "Loaded generated Python code in \"~/.andes/pycode\".\n", "Parsing input file \"/Users/jinningwang/Documents/work/andes/andes/cases/ieee14/ieee14_ieeet3.xlsx\"...\n", - "Input file parsed in 0.4544 seconds.\n", - "System internal structure set up in 0.0229 seconds.\n" + "Input file parsed in 0.4550 seconds.\n", + "System internal structure set up in 0.0226 seconds.\n" ] }, { @@ -76,7 +76,7 @@ "source": [ "## Simulation\n", "\n", - "Exciter ``IEEET3_1`` is connected to ``GENROU_5``." + "Exciter ``IEEET3_1`` is connected to ``GENROU_5``, which is connected to ``Bus_8``." ] }, { @@ -89,7 +89,7 @@ "iopub.status.idle": "2021-09-26T22:41:52.439169Z", "shell.execute_reply": "2021-09-26T22:41:52.439419Z" }, - "scrolled": false + "scrolled": true }, "outputs": [ { @@ -110,8 +110,8 @@ "1: |F(x)| = 0.006202200332\n", "2: |F(x)| = 5.819382825e-06\n", "3: |F(x)| = 6.967745825e-12\n", - "Converged in 4 iterations in 0.0076 seconds.\n", - "Initialization for dynamics completed in 0.0203 seconds.\n", + "Converged in 4 iterations in 0.0079 seconds.\n", + "Initialization for dynamics completed in 0.0210 seconds.\n", "Initialization was successful.\n" ] }, @@ -159,14 +159,14 @@ "text": [ ": Line.Line_1 status changed to 0 at t=1.0 sec. \n", ": Line.Line_1 status changed to 1 at t=1.1 sec. \n", - "100%|████████████████████████████████| 100/100 [00:01<00:00, 70.13%/s]" + "100%|████████████████████████████████| 100/100 [00:01<00:00, 72.82%/s]" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Simulation completed in 1.4263 seconds.\n" + "Simulation completed in 1.3736 seconds.\n" ] }, { @@ -229,7 +229,7 @@ "iopub.status.idle": "2021-09-26T22:41:56.995950Z", "shell.execute_reply": "2021-09-26T22:41:56.996561Z" }, - "scrolled": true + "scrolled": false }, "outputs": [ { @@ -246,35 +246,7 @@ }, { "data": { - "text/plain": [ - "(
, )" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ss.TDS.plt.plot(ss.IEEET3.vout)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "execution": { - "iopub.execute_input": "2021-09-26T22:41:57.005397Z", - "iopub.status.busy": "2021-09-26T22:41:56.999199Z", - "iopub.status.idle": "2021-09-26T22:41:57.706889Z", - "shell.execute_reply": "2021-09-26T22:41:57.707344Z" - }, - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -290,14 +262,15 @@ "(
, )" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "ss.TDS.plt.plot(ss.GENROU.omega,\n", - " ycalc=lambda x: 60*x)" + "ss.TDS.plt.plot(ss.IEEET3.vout)\n", + "ss.TDS.plt.plot(ss.GENROU.v,\n", + " a=(3,4))" ] }, { @@ -309,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2021-09-26T22:41:57.710348Z", @@ -323,13 +296,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "\r\n", - " _ _ | Version 1.4.2.post168.dev0+gf781733e\r\n", - " /_\\ _ _ __| |___ ___ | Python 3.7.10 on Darwin, 10/04/2021 04:45:32 PM\r\n", - " / _ \\| ' \\/ _` / -_|_-< | \r\n", - " /_/ \\_\\_||_\\__,_\\___/__/ | This program comes with ABSOLUTELY NO WARRANTY.\r\n", - "\r\n", - "No output file found in the working directory.\r\n" + "\n", + " _ _ | Version 1.4.3.post12.dev0+g4e51e20f\n", + " /_\\ _ _ __| |___ ___ | Python 3.7.10 on Darwin, 10/05/2021 10:12:22 PM\n", + " / _ \\| ' \\/ _` / -_|_-< | \n", + " /_/ \\_\\_||_\\__,_\\___/__/ | This program comes with ABSOLUTELY NO WARRANTY.\n", + "\n", + "No output file found in the working directory.\n" ] } ], diff --git a/examples/demonstration/2.3 demo_ESAC1A.ipynb b/examples/demonstration/2.3 demo_ESAC1A.ipynb index 868ca4346..dd740d665 100644 --- a/examples/demonstration/2.3 demo_ESAC1A.ipynb +++ b/examples/demonstration/2.3 demo_ESAC1A.ipynb @@ -6,7 +6,7 @@ "source": [ "# ANDES Demonstration of ESAC1A on IEEE 14-Bus System\n", "\n", - "Prepared by Jinning Wang. Last revised on September 28, 2021." + "Prepared by Jinning Wang. Last revised on October 5, 2021." ] }, { @@ -48,8 +48,8 @@ "Loaded config from file \"/Users/jinningwang/.andes/andes.rc\"\n", "Loaded generated Python code in \"~/.andes/pycode\".\n", "Parsing input file \"/Users/jinningwang/Documents/work/andes/andes/cases/ieee14/ieee14_esac1a.xlsx\"...\n", - "Input file parsed in 0.4712 seconds.\n", - "System internal structure set up in 0.0230 seconds.\n" + "Input file parsed in 0.3874 seconds.\n", + "System internal structure set up in 0.0214 seconds.\n" ] }, { @@ -76,7 +76,7 @@ "source": [ "## Simulation\n", "\n", - "Exciter ``ESAC1A_1`` is connected to ``GENROU_5``." + "Exciter ``ESAC1A_1`` is connected to ``GENROU_5``, which is connected to ``Bus_8``." ] }, { @@ -110,12 +110,12 @@ "1: |F(x)| = 0.006202200332\n", "2: |F(x)| = 5.819382825e-06\n", "3: |F(x)| = 6.967745825e-12\n", - "Converged in 4 iterations in 0.0078 seconds.\n", + "Converged in 4 iterations in 0.0055 seconds.\n", "/Users/jinningwang/.andes/pycode/ESAC1A.py:91: RuntimeWarning: invalid value encountered in sqrt\n", " return (array([[FEX_y*INT_y - vf0], [-FEX_y + select([less_equal(IN, 0),less_equal(IN, 0.433),less_equal(IN, 0.75),less_equal(IN, 1),greater(IN, 1)], [1,1 - 0.577*IN,sqrt(0.75 - IN**2),1.732 - 1.732*IN,0], default=nan)], [-IN*INT_y + KC*XadIfd]]))\n", "/Users/jinningwang/.andes/pycode/ESAC1A.py:94: RuntimeWarning: invalid value encountered in sqrt\n", " return (array([[FEX_y, INT_y, 0], [0, -1, select([less_equal(IN, 0),less_equal(IN, 0.433),less_equal(IN, 0.75),less_equal(IN, 1),True], [0,-0.577,-IN/sqrt(0.75 - IN**2),-1.732,0], default=nan)], [-IN, 0, -INT_y]]))\n", - "Initialization for dynamics completed in 0.0276 seconds.\n", + "Initialization for dynamics completed in 0.0240 seconds.\n", "Initialization was successful.\n" ] }, @@ -163,14 +163,14 @@ "text": [ ": Line.Line_1 status changed to 0 at t=1.0 sec. \n", ": Line.Line_1 status changed to 1 at t=1.1 sec. \n", - "100%|████████████████████████████████| 100/100 [00:01<00:00, 67.06%/s]" + "100%|████████████████████████████████| 100/100 [00:01<00:00, 66.46%/s]" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Simulation completed in 1.4916 seconds.\n" + "Simulation completed in 1.5049 seconds.\n" ] }, { @@ -233,7 +233,7 @@ "iopub.status.idle": "2021-09-26T22:41:56.995950Z", "shell.execute_reply": "2021-09-26T22:41:56.996561Z" }, - "scrolled": true + "scrolled": false }, "outputs": [ { @@ -250,35 +250,7 @@ }, { "data": { - "text/plain": [ - "(
, )" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ss.TDS.plt.plot(ss.ESAC1A.vout)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "execution": { - "iopub.execute_input": "2021-09-26T22:41:57.005397Z", - "iopub.status.busy": "2021-09-26T22:41:56.999199Z", - "iopub.status.idle": "2021-09-26T22:41:57.706889Z", - "shell.execute_reply": "2021-09-26T22:41:57.707344Z" - }, - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -294,14 +266,15 @@ "(
, )" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "ss.TDS.plt.plot(ss.GENROU.omega,\n", - " ycalc=lambda x: 60*x)" + "ss.TDS.plt.plot(ss.ESAC1A.vout)\n", + "ss.TDS.plt.plot(ss.GENROU.v,\n", + " a=(3,4))" ] }, { @@ -313,7 +286,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2021-09-26T22:41:57.710348Z", @@ -328,8 +301,8 @@ "output_type": "stream", "text": [ "\r\n", - " _ _ | Version 1.4.2.post168.dev0+gf781733e\r\n", - " /_\\ _ _ __| |___ ___ | Python 3.7.10 on Darwin, 10/04/2021 04:45:54 PM\r\n", + " _ _ | Version 1.4.3.post12.dev0+g4e51e20f\r\n", + " /_\\ _ _ __| |___ ___ | Python 3.7.10 on Darwin, 10/05/2021 10:14:25 PM\r\n", " / _ \\| ' \\/ _` / -_|_-< | \r\n", " /_/ \\_\\_||_\\__,_\\___/__/ | This program comes with ABSOLUTELY NO WARRANTY.\r\n", "\r\n", diff --git a/examples/demonstration/2.3 demo_ESST1A.ipynb b/examples/demonstration/2.4 demo_ESST1A.ipynb similarity index 99% rename from examples/demonstration/2.3 demo_ESST1A.ipynb rename to examples/demonstration/2.4 demo_ESST1A.ipynb index 78a01a3da..9312a3722 100644 --- a/examples/demonstration/2.3 demo_ESST1A.ipynb +++ b/examples/demonstration/2.4 demo_ESST1A.ipynb @@ -37,7 +37,8 @@ "iopub.status.busy": "2021-09-26T22:41:51.717830Z", "iopub.status.idle": "2021-09-26T22:41:52.415346Z", "shell.execute_reply": "2021-09-26T22:41:52.415616Z" - } + }, + "scrolled": true }, "outputs": [ { @@ -48,8 +49,8 @@ "Loaded config from file \"/Users/jinningwang/.andes/andes.rc\"\n", "Loaded generated Python code in \"~/.andes/pycode\".\n", "Parsing input file \"/Users/jinningwang/Documents/work/andes/andes/cases/ieee14/ieee14_esst1a.xlsx\"...\n", - "Input file parsed in 0.3724 seconds.\n", - "System internal structure set up in 0.0220 seconds.\n" + "Input file parsed in 0.3120 seconds.\n", + "System internal structure set up in 0.0222 seconds.\n" ] }, { @@ -110,8 +111,8 @@ "1: |F(x)| = 0.006202200332\n", "2: |F(x)| = 5.819382825e-06\n", "3: |F(x)| = 6.967745825e-12\n", - "Converged in 4 iterations in 0.0055 seconds.\n", - "Initialization for dynamics completed in 0.0236 seconds.\n", + "Converged in 4 iterations in 0.0056 seconds.\n", + "Initialization for dynamics completed in 0.0226 seconds.\n", "Initialization was successful.\n" ] }, @@ -159,14 +160,14 @@ "text": [ ": Line.Line_1 status changed to 0 at t=1.0 sec. \n", ": Line.Line_1 status changed to 1 at t=1.1 sec. \n", - "100%|████████████████████████████████| 100/100 [00:01<00:00, 64.81%/s]" + "100%|████████████████████████████████| 100/100 [00:01<00:00, 65.48%/s]" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Simulation completed in 1.5432 seconds.\n" + "Simulation completed in 1.5276 seconds.\n" ] }, { @@ -296,8 +297,8 @@ "output_type": "stream", "text": [ "\r\n", - " _ _ | Version 1.4.3.post11+ga6a45e90\r\n", - " /_\\ _ _ __| |___ ___ | Python 3.7.10 on Darwin, 10/05/2021 08:35:38 PM\r\n", + " _ _ | Version 1.4.3.post12.dev0+g4e51e20f\r\n", + " /_\\ _ _ __| |___ ___ | Python 3.7.10 on Darwin, 10/05/2021 10:16:54 PM\r\n", " / _ \\| ' \\/ _` / -_|_-< | \r\n", " /_/ \\_\\_||_\\__,_\\___/__/ | This program comes with ABSOLUTELY NO WARRANTY.\r\n", "\r\n", From f1b76659bfdc59069412458cb8b4c92e0e8ca53b Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Wed, 6 Oct 2021 11:56:53 -0400 Subject: [PATCH 15/58] Formatted Exciter init. --- andes/models/exciter/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/andes/models/exciter/__init__.py b/andes/models/exciter/__init__.py index 67ecc456a..898585a3e 100644 --- a/andes/models/exciter/__init__.py +++ b/andes/models/exciter/__init__.py @@ -13,4 +13,4 @@ from andes.models.exciter.esac1a import ESAC1A # NOQA from andes.models.exciter.esst1a import ESST1A # NOQA -from andes.models.exciter.saturation import ExcQuadSat, ExcExpSat # NOQA \ No newline at end of file +from andes.models.exciter.saturation import ExcQuadSat, ExcExpSat # NOQA From 9a9068ed583002711df11c18122cd2bf53c4ba86 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 6 Oct 2021 15:25:58 -0500 Subject: [PATCH 16/58] Deprecated `hline1`, `hline2`, `vline1` and `vline2` in favor of `hline` and `vline`. --- andes/plot.py | 45 ++++++++++++++++++++++++++++++++++++++------- 1 file changed, 38 insertions(+), 7 deletions(-) diff --git a/andes/plot.py b/andes/plot.py index 2bb95461a..35ca69896 100644 --- a/andes/plot.py +++ b/andes/plot.py @@ -270,7 +270,7 @@ def plot(self, yidx, xidx=(0,), *, a=None, ytimes=None, ycalc=None, legend=None, grid=False, greyscale=False, latex=True, dpi=DPI, line_width=1.0, font_size=12, savefig=None, save_format=None, show=True, title=None, linestyles=None, use_bqplot=False, - hline1=None, hline2=None, vline1=None, vline2=None, + hline1=None, hline2=None, vline1=None, vline2=None, hline=None, vline=None, fig=None, ax=None, backend=None, set_xlim=True, set_ylim=True, autoscale=False, legend_bbox=None, legend_loc=None, legend_ncol=1, @@ -359,6 +359,10 @@ def plot(self, yidx, xidx=(0,), *, a=None, ytimes=None, ycalc=None, Dashed horizontal line 1 vline2: float, optional Dashed vertical line 2 + hline: float or Iterable + y-axis location of horizontal line(s) + vline: float or Iterable + x-axis location of vertical line(s) Returns ------- @@ -414,7 +418,7 @@ def plot(self, yidx, xidx=(0,), *, a=None, ytimes=None, ycalc=None, fig=fig, ax=ax, linestyles=linestyles, set_xlim=set_xlim, set_ylim=set_ylim, autoscale=autoscale, legend_bbox=legend_bbox, legend_loc=legend_loc, legend_ncol=legend_ncol, - figsize=figsize, + figsize=figsize, hline=hline, vline=vline, **kwargs) def get_call(self, backend=None): @@ -471,7 +475,8 @@ def bqplot_data(self, xdata, ydata, *, xheader=None, yheader=None, xlabel=None, def plot_data(self, xdata, ydata, *, xheader=None, yheader=None, xlabel=None, ylabel=None, linestyles=None, left=None, right=None, ymin=None, ymax=None, legend=None, grid=False, fig=None, ax=None, latex=True, dpi=DPI, line_width=1.0, font_size=12, greyscale=False, savefig=None, - save_format=None, show=True, title=None, hline1=None, hline2=None, vline1=None, + save_format=None, show=True, title=None, + hline1=None, hline2=None, vline1=None, hline=None, vline=None, vline2=None, set_xlim=True, set_ylim=True, autoscale=False, figsize=None, legend_bbox=None, legend_loc=None, legend_ncol=1, mask=True, @@ -594,14 +599,40 @@ def plot_data(self, xdata, ydata, *, xheader=None, yheader=None, xlabel=None, yl if title: ax.set_title(title) + # --- process hlines and vlines + if hline1 or hline2 or vline1 or vline2: + logger.warning("hline1, hline2, vline1, and vline2 are deprecated. Use `hline` and `vline`.") + + if isinstance(hline, (float, int, np.floating, np.integer)): + hline = [hline] + elif isinstance(hline, tuple): + hline = list(hline) + elif hline is None: + hline = [] + + if isinstance(vline, (float, int, np.floating, np.integer)): + vline = [vline] + elif isinstance(vline, tuple): + vline = list(vline) + elif vline is None: + vline = [] + + # process the legacy hline1, hline2, and vline1 and vline2 if hline1: - ax.axhline(y=hline1, linewidth=1, ls=':', color='grey') + hline.append(hline1) if hline2: - ax.axhline(y=hline2, linewidth=1, ls=':', color='grey') + hline.append(hline2) if vline1: - ax.axvline(x=vline1, linewidth=1, ls=':', color='grey') + vline.append(vline1) if vline2: - ax.axvline(x=vline2, linewidth=1, ls=':', color='grey') + vline.append(vline2) + + for loc in hline: + ax.axhline(y=loc, linewidth=1, ls=':', color='grey') + for loc in vline: + ax.axvline(x=loc, linewidth=1, ls=':', color='grey') + + # --- hline and vline finished --- plt.draw() From 9878ce8599338ab4927d5567f826c0837b64703b Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 6 Oct 2021 21:15:34 -0500 Subject: [PATCH 17/58] Update. --- docs/source/release-notes.rst | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/source/release-notes.rst b/docs/source/release-notes.rst index 293b3ae89..f758744ec 100644 --- a/docs/source/release-notes.rst +++ b/docs/source/release-notes.rst @@ -9,6 +9,10 @@ The APIs before v3.0.0 are in beta and may change without prior notice. v1.4 Notes ---------- +v1.4.4 (2021-10-05) +```````````````````` +- Bug fixes for refreshing generated code. + v1.4.3 (2021-09-25) ``````````````````` This release features parallel processing that cuts the time for From 20f6ef3d5a6571a8d5f0840cea6e9bf805d3953d Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Thu, 7 Oct 2021 12:32:23 -0500 Subject: [PATCH 18/58] Added more granular settings for EIG plots. --- andes/routines/eig.py | 66 ++++++++++++++++++++++++++++++++++++++----- 1 file changed, 59 insertions(+), 7 deletions(-) diff --git a/andes/routines/eig.py b/andes/routines/eig.py index 96336ea09..602491054 100644 --- a/andes/routines/eig.py +++ b/andes/routines/eig.py @@ -323,11 +323,53 @@ def run(self, **kwargs): system.exit_code += 1 return succeed - def plot(self, mu=None, fig=None, ax=None, left=-6, right=0.5, ymin=-8, ymax=8, damping=0.05, - line_width=0.5, dpi=100, show=True, latex=True): + def plot(self, mu=None, fig=None, ax=None, + left=-6, right=0.5, ymin=-8, ymax=8, damping=0.05, + line_width=0.5, dpi=100, figsize=None, base_color='black', + show=True, latex=True): """ Plot utility for eigenvalues in the S domain. + + Parameters + ---------- + mu : array, optional + an array of complex eigenvalues + fig : figure handl, optional + existing matplotlib figure handle + ax : axis handle, optional + existing axis handle + left : int, optional + left tick for the x-axis, by default -6 + right : float, optional + right tick, by default 0.5 + ymin : int, optional + bottom tick, by default -8 + ymax : int, optional + top tick, by default 8 + damping : float, optional + damping value for which the dash plots are drawn + line_width : float, optional + default line width, by default 0.5 + dpi : int, optional + figure dpi, by default 100 + figsize : [type], optional + default figure size, by default None + base_color : str, optional + base color for negative eigenvalues + show : bool, optional + True to show figure after plot, by default True + latex : bool, optional + True to use latex, by default True + + Returns + ------- + figure + matplotlib figure object + axis + matplotlib axis object + """ + mpl.rc('font', family='Times New Roman', size=12) if mu is None: @@ -353,24 +395,34 @@ def plot(self, mu=None, fig=None, ax=None, left=-6, right=0.5, ymin=-8, ymax=8, set_latex() if fig is None or ax is None: - fig, ax = plt.subplots(dpi=dpi) + fig = plt.figure(dpi=dpi, figsize=figsize) + ax = plt.gca() ax.scatter(z_mu_real, z_mu_imag, marker='o', s=40, linewidth=0.5, facecolors='none', edgecolors='green') - ax.scatter(n_mu_real, n_mu_imag, marker='x', s=40, linewidth=0.5, color='black') + ax.scatter(n_mu_real, n_mu_imag, marker='x', s=40, linewidth=0.5, color=base_color) ax.scatter(p_mu_real, p_mu_imag, marker='x', s=40, linewidth=0.5, color='red') + + # axes lines ax.axhline(linewidth=0.5, color='grey', linestyle='--') ax.axvline(linewidth=0.5, color='grey', linestyle='--') # TODO: Improve the damping and range - # plot 5% damping lines + # --- plot 5% damping lines --- xin = np.arange(left, 0, 0.01) yneg = xin / damping ypos = - xin / damping ax.plot(xin, yneg, color='grey', linewidth=line_width, linestyle='--') ax.plot(xin, ypos, color='grey', linewidth=line_width, linestyle='--') - ax.set_xlabel('Real') - ax.set_ylabel('Imaginary') + # --- damping lines end --- + + if latex: + ax.set_xlabel('Real [$s^{-1}$]') + ax.set_ylabel('Imaginary [$s^{-1}$]') + else: + ax.set_xlabel('Real [s -1]') + ax.set_ylabel('Imaginary [s -1]') + ax.set_xlim(left=left, right=right) ax.set_ylim(ymin, ymax) From 2037f6796548e0a9e7ae9f350374f54b2545a463 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Thu, 7 Oct 2021 12:32:39 -0500 Subject: [PATCH 19/58] Added notes. --- TODO.md | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/TODO.md b/TODO.md index 035c99a23..a7f2134ab 100644 --- a/TODO.md +++ b/TODO.md @@ -1,12 +1,15 @@ # v1.5 -# Milestones +## Milestones * Separate array-enabled parameters from NumParam into `BaseConvParam`, which implements `iconvert` and `oconvert`, and then `ListParam` * Improve the robustness of accessing the fields of `pycode` by properly handling `KeyError`s. +* Numba code generation for all models. Add a function for triggering + all the JIT compilation before simulation. +* Unit Model Test framework. # Later Versions @@ -25,11 +28,13 @@ * Eigenvalue analysis report sort options: by damping, frequency, or eigenvalue * Root loci plots -# v1.4 +# Previous + +## v1.4 * [X] Disallow linking ExtAlgeb to State and ExtState to Algeb (check in prepare). -# v1.3 +## v1.3 ## Milestones From e779408ae4c913f2e6cbebe9bf18c509c112b81f Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Thu, 7 Oct 2021 16:56:12 -0500 Subject: [PATCH 20/58] Added dummy variables `__ones` and `__zeros` to vectorize equations in `select. Currently, `g_update` compiles okay, but the corresponding derivative equations won't compile, because SymPy adds a default condition `True` that breaks the mono-typied list. --- andes/core/block.py | 5 +++-- andes/core/model.py | 6 ++++++ andes/core/symprocessor.py | 4 ++++ andes/models/exciter/esst3a.py | 6 +++++- andes/models/renewable/reeca1.py | 20 ++++++++++++-------- andes/models/renewable/regca1.py | 4 ++-- 6 files changed, 32 insertions(+), 13 deletions(-) diff --git a/andes/core/block.py b/andes/core/block.py index 10406c095..3bb227a49 100644 --- a/andes/core/block.py +++ b/andes/core/block.py @@ -211,8 +211,9 @@ def define(self): def export(self): """ - Method for exporting instances defined in this class in a dictionary. This method calls the ``define`` - method first and returns ``self.vars``. + Method for exporting instances defined in this class in a dictionary. + + This method calls the ``define`` method first and returns ``self.vars``. Returns ------- diff --git a/andes/core/model.py b/andes/core/model.py index 3bd1b36b1..d0c73cc54 100644 --- a/andes/core/model.py +++ b/andes/core/model.py @@ -955,6 +955,12 @@ def refresh_inputs(self): self._input['sys_f'] = self.system.config.freq self._input['sys_mva'] = self.system.config.mva + # two vectors with the length of the number of devices. + # Useful in the choices of `PieceWise`, which need to be vectors + # for numba to compile. + self._input['__ones'] = np.ones(self.n) + self._input['__zeros'] = np.zeros(self.n) + def refresh_inputs_arg(self): """ Refresh inputs for each function with individual argument list. diff --git a/andes/core/symprocessor.py b/andes/core/symprocessor.py index 8a0c7ad78..b5080ae34 100644 --- a/andes/core/symprocessor.py +++ b/andes/core/symprocessor.py @@ -129,10 +129,14 @@ def generate_symbols(self): if var in self.parent.__dict__ and self.parent.__dict__[var].tex_name is not None: self.tex_names[Symbol(var)] = Symbol(self.parent.__dict__[var].tex_name) + # additional variables by conventions self.inputs_dict['dae_t'] = Symbol('dae_t') self.inputs_dict['sys_f'] = Symbol('sys_f') self.inputs_dict['sys_mva'] = Symbol('sys_mva') + self.inputs_dict['__ones'] = Symbol('__ones') + self.inputs_dict['__zeros'] = Symbol('__zeros') + # custom functions self.lambdify_func[0]['Indicator'] = lambda x: x self.lambdify_func[0]['imag'] = np.imag self.lambdify_func[0]['real'] = np.real diff --git a/andes/models/exciter/esst3a.py b/andes/models/exciter/esst3a.py index 4d4251fa8..648677af4 100644 --- a/andes/models/exciter/esst3a.py +++ b/andes/models/exciter/esst3a.py @@ -196,7 +196,11 @@ def __init__(self, system, config): self.FEX = Piecewise(u=self.IN, points=(0, 0.433, 0.75, 1), - funs=('1', '1 - 0.577*IN', 'sqrt(0.75 - IN ** 2)', '1.732*(1 - IN)', 0), + funs=('__ones + (__zeros * IN)', + '__ones * (1 - 0.577*IN)', + '__ones * sqrt(0.75 - IN ** 2)', + '__ones * 1.732*(1 - IN)', + '__zeros * IN'), info='Piecewise function FEX', ) diff --git a/andes/models/renewable/reeca1.py b/andes/models/renewable/reeca1.py index 31035a357..a4692ba2e 100644 --- a/andes/models/renewable/reeca1.py +++ b/andes/models/renewable/reeca1.py @@ -532,11 +532,11 @@ def __init__(self, system, config): self.VDL1 = Piecewise(u=self.s0_y, points=('Vq1', 'Vq2', 'Vq3', 'Vq4'), - funs=('Iq1', + funs=(f'({self.s0_y.name} * __zeros) + Iq1', f'({self.s0_y.name} - Vq1) * kVq12 + Iq1', f'({self.s0_y.name} - Vq2) * kVq23 + Iq2', f'({self.s0_y.name} - Vq3) * kVq34 + Iq3', - 'Iq4'), + f'({self.s0_y.name} * __zeros) + Iq4'), tex_name='V_{DL1}', info='Piecewise linear characteristics of Vq-Iq', ) @@ -559,11 +559,11 @@ def __init__(self, system, config): self.VDL2 = Piecewise(u=self.s0_y, points=('Vp1', 'Vp2', 'Vp3', 'Vp4'), - funs=('Ip1', + funs=(f'({self.s0_y.name} * __zeros) + Ip1', f'({self.s0_y.name} - Vp1) * kVp12 + Ip1', f'({self.s0_y.name} - Vp2) * kVp23 + Ip2', f'({self.s0_y.name} - Vp3) * kVp34 + Ip3', - 'Ip4'), + f'({self.s0_y.name} * __zeros) + Ip4'), tex_name='V_{DL2}', info='Piecewise linear characteristics of Vp-Ip', ) @@ -588,11 +588,13 @@ def __init__(self, system, config): Ipmax2sq = '(Imax**2 - IqHL_y**2)' # `Ipmax20`-squared (non-negative) - self.Ipmax2sq0 = ConstService(v_str=f'Piecewise((0.0, Le({Ipmax2sq0}, 0.0)), ({Ipmax2sq0}, True))', + self.Ipmax2sq0 = ConstService(v_str=f'Piecewise((__zeros, Le({Ipmax2sq0}, 0.0)), ({Ipmax2sq0}, True), \ + evaluate=False)', tex_name='I_{pmax20,nn}^2', ) - self.Ipmax2sq = VarService(v_str=f'Piecewise((0.0, Le({Ipmax2sq}, 0.0)), ({Ipmax2sq}, True))', + self.Ipmax2sq = VarService(v_str=f'Piecewise((__zeros, Le({Ipmax2sq}, 0.0)), ({Ipmax2sq}, True), \ + evaluate=False)', tex_name='I_{pmax2}^2', ) @@ -613,11 +615,13 @@ def __init__(self, system, config): Iqmax2sq0 = '(Imax**2 - Ipcmd0**2)' # initialization equation by using `Ipcmd0` - self.Iqmax2sq0 = ConstService(v_str=f'Piecewise((0.0, Le({Iqmax2sq0}, 0.0)), ({Iqmax2sq0}, True))', + self.Iqmax2sq0 = ConstService(v_str=f'Piecewise((__zeros, Le({Iqmax2sq0}, 0.0)), ({Iqmax2sq0}, True), \ + evaluate=False)', tex_name='I_{qmax,nn}^2', ) - self.Iqmax2sq = VarService(v_str=f'Piecewise((0.0, Le({Iqmax2sq}, 0.0)), ({Iqmax2sq}, True))', + self.Iqmax2sq = VarService(v_str=f'Piecewise((__zeros, Le({Iqmax2sq}, 0.0)), ({Iqmax2sq}, True), \ + evaluate=False)', tex_name='I_{qmax2}^2') self.Iqmax = Algeb(v_str=f'(SWPQ_s0*{Iqmax1} + SWPQ_s1*sqrt(Iqmax2sq0))', diff --git a/andes/models/renewable/regca1.py b/andes/models/renewable/regca1.py index 0765eb0f3..3ea130ef3 100644 --- a/andes/models/renewable/regca1.py +++ b/andes/models/renewable/regca1.py @@ -211,7 +211,7 @@ def __init__(self, system, config): ) self.LVG = Piecewise(u=self.v, points=('Lvpnt0', 'Lvpnt1'), - funs=('0', '(v - Lvpnt0) * kLVG', '1'), + funs=('__zeros', '(v - Lvpnt0) * kLVG', '__ones'), info='Ip gain during low voltage', tex_name='L_{VG}', ) @@ -229,7 +229,7 @@ def __init__(self, system, config): points=('Zerox', 'Brkpt'), funs=('0 + 9999*(1-Lvplsw)', '(S2_y - Zerox) * kLVPL + 9999 * (1-Lvplsw)', - '9999'), + '9999 * __ones'), info='Low voltage Ipcmd upper limit', tex_name='L_{VPL}', ) From 8f9688af4fad54996751c2f78020567365a983b9 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Thu, 7 Oct 2021 17:07:38 -0500 Subject: [PATCH 21/58] Added notes on pycode writer. --- andes/core/symprocessor.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/andes/core/symprocessor.py b/andes/core/symprocessor.py index 8a0c7ad78..e39c4095d 100644 --- a/andes/core/symprocessor.py +++ b/andes/core/symprocessor.py @@ -371,6 +371,12 @@ def generate_pycode(self, pycode_path, yapf_pycode): Create output source code file for generated code. Generated code are stored at ``~/.andes/pycode``. + + Notes + ----- + In the current implementation, each model saves a ``.py`` file. + In systems with slow disk access (such as networked file systems), + this function can be the bottleneck. """ pycode_path = get_pycode_path(pycode_path, mkdir=True) From 5eba4de6543a0fd572beba9b5d0bcce3f5b81960 Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Fri, 8 Oct 2021 18:21:19 -0400 Subject: [PATCH 22/58] Built IEEEVC. --- andes/cases/ieee14/ieee14_ieeevc.xlsx | Bin 0 -> 27470 bytes andes/models/__init__.py | 1 + andes/models/group.py | 11 +++ andes/models/vcomp/__init__.py | 1 + andes/models/vcomp/ieeevc.py | 121 ++++++++++++++++++++++++++ 5 files changed, 134 insertions(+) create mode 100644 andes/cases/ieee14/ieee14_ieeevc.xlsx create mode 100644 andes/models/vcomp/__init__.py create mode 100644 andes/models/vcomp/ieeevc.py diff --git a/andes/cases/ieee14/ieee14_ieeevc.xlsx b/andes/cases/ieee14/ieee14_ieeevc.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..f1740e4a121fa80ea6d48de8ada82c6e861c8d5c GIT binary patch literal 27470 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 X4735L`}T3Lh!MvO_3p#X Date: Fri, 8 Oct 2021 18:25:28 -0400 Subject: [PATCH 23/58] Formatted IEEEVC. --- andes/models/vcomp/ieeevc.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/andes/models/vcomp/ieeevc.py b/andes/models/vcomp/ieeevc.py index 7a79483e0..e7aae63f4 100644 --- a/andes/models/vcomp/ieeevc.py +++ b/andes/models/vcomp/ieeevc.py @@ -3,10 +3,7 @@ from andes.core.param import NumParam, IdxParam, ExtParam from andes.core.var import Algeb, ExtAlgeb -from andes.core.service import ConstService, VarService - - -from andes.core.service import ExtService, ConstService +from andes.core.service import ConstService, VarService, ExtService class IEEEVCData(ModelData): @@ -88,8 +85,8 @@ def __init__(self, system, config): ) self.vct = VarService(tex_name=r'V_{CT}', - v_str='Abs((vd + 1j*vq) + (rc + 1j * xc) * (Id + 1j*Iq))', - ) + v_str='Abs((vd + 1j*vq) + (rc + 1j * xc) * (Id + 1j*Iq))', + ) self.vcomp0 = ConstService(v_str='Abs((vd + 1j*vq) + (rc + 1j * xc) * (Id + 1j*Iq))') # output voltage self.vcomp = Algeb(info='Compensator output voltage to exciter', @@ -113,7 +110,7 @@ class IEEEVC(IEEEVCData, IEEEVCModel): Available: https://www.powerworld.com/WebHelp/Content/TransientModels_HTML/Voltage%20Compensator%20IEEEVC.htm?TocPath=%7C%7C%7CIEEEVC%7C_____0 - + https://www.neplan.ch/wp-content/uploads/2015/08/Nep_EXCITERS1.pdf """ def __init__(self, system, config): From 719529665ea34ecb68a52de036125ac27a1ce694 Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Fri, 8 Oct 2021 18:33:16 -0400 Subject: [PATCH 24/58] Added test notebook for IEEEVC. --- examples/demonstration/test_IEEEVC.ipynb | 250 +++++++++++++++++++++++ 1 file changed, 250 insertions(+) create mode 100644 examples/demonstration/test_IEEEVC.ipynb diff --git a/examples/demonstration/test_IEEEVC.ipynb b/examples/demonstration/test_IEEEVC.ipynb new file mode 100644 index 000000000..6f68c61bf --- /dev/null +++ b/examples/demonstration/test_IEEEVC.ipynb @@ -0,0 +1,250 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import andes\n", + "from andes.utils.paths import get_case\n", + "\n", + "andes.config_logger(stream_level=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Working directory: \"/Users/jinningwang/Documents/work/andes/examples/demonstration\"\n", + "Loaded config from file \"/Users/jinningwang/.andes/andes.rc\"\n", + "Loaded generated Python code in \"/Users/jinningwang/.andes/pycode\".\n", + "Parsing input file \"/Users/jinningwang/Documents/work/andes/andes/cases/ieee14/ieee14_ieeevc.xlsx\"...\n", + "Input file parsed in 0.4172 seconds.\n", + "System internal structure set up in 0.0211 seconds.\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss = andes.load(get_case('ieee14/ieee14_ieeevc.xlsx'),\n", + " setup=False,\n", + " no_output=True)\n", + "\n", + "ss.setup()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "-> System connectivity check results:\n", + " No islanded bus detected.\n", + " A total of 1 island(s) detected.\n", + " Each island has a slack bus correctly defined and enabled.\n", + "\n", + "-> Power flow calculation\n", + " Sparse solver: KLU\n", + " Solution method: NR method\n", + " Sparse addition: Fast in-place (kvxopt)\n", + "Power flow initialized.\n", + "0: |F(x)| = 0.5605182134\n", + "1: |F(x)| = 0.006202200332\n", + "2: |F(x)| = 5.819382825e-06\n", + "3: |F(x)| = 6.967745825e-12\n", + "Converged in 4 iterations in 0.0080 seconds.\n", + "Suspect initialization issue! Simulation may crash!\n", + "\n", + " Name | Var. Value | Eqn. Mismatch\n", + "-------------+------------+--------------\n", + " vi IEEET1 1 | 0.294 | 0.025 \n", + "\n", + "\n", + "Initialization for dynamics completed in 0.0254 seconds.\n", + "Initialization failed!!\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss.PFlow.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Algeb: IEEEVC.vcomp, a=[214], v=[0.02460921], e=[0.]\n", + "Algeb: IEEET1.vi, a=[210], v=[0.29427554], e=[0.02460921]\n" + ] + } + ], + "source": [ + "print(ss.IEEEVC.vcomp)\n", + "print(ss.IEEET1.vi)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Algeb: IEEEVC.vcomp, a=[214], v=[0.02460921], e=[0.]\n", + "Algeb: IEEEVC.vcomp, a=[214], v=[0.02460921], e=[0.]\n" + ] + } + ], + "source": [ + "print(ss.IEEEVC.vcomp)\n", + "print(ss.IEEEVC.vcomp)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "-> Time Domain Simulation Summary:\n", + "Sparse Solver: KLU\n", + "Simulation time: 0.0-5 s.\n", + "Fixed step size: h=33.33 ms. Shrink if not converged.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": Line.Line_1 status changed to 0 at t=1.0 sec.\n", + ": Line.Line_1 status changed to 1 at t=1.1 sec.\n", + "100%|███████████████████████████████| 100/100 [00:00<00:00, 202.04%/s]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Simulation completed in 0.4953 seconds.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss.TDS.config.tf = 5\n", + "ss.TDS.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cleanup" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " _ _ | Version 1.4.4.post25+g39bd4f61\n", + " /_\\ _ _ __| |___ ___ | Python 3.7.10 on Darwin, 10/08/2021 06:31:01 PM\n", + " / _ \\| ' \\/ _` / -_|_-< | \n", + " /_/ \\_\\_||_\\__,_\\___/__/ | This program comes with ABSOLUTELY NO WARRANTY.\n", + "\n", + "No output file found in the working directory.\n" + ] + } + ], + "source": [ + "!andes misc -C" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "b8c542af61804583455bb3cc02c5acff1b7eab71b36b048085e6e502c5a0f30d" + }, + "kernelspec": { + "display_name": "Python 3.7.10 64-bit ('andes': conda)", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 8b516a8cca5bd7e5e2e25309b98fece7e8ea22fd Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 15:43:05 -0500 Subject: [PATCH 25/58] Moved `VoltComp` group to before `Exciter`. --- andes/models/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/andes/models/__init__.py b/andes/models/__init__.py index d7289643a..bcd7311b1 100644 --- a/andes/models/__init__.py +++ b/andes/models/__init__.py @@ -24,10 +24,10 @@ ('dynload', ['ZIP', 'FLoad']), ('synchronous', ['GENCLS', 'GENROU']), ('governor', ['TG2', 'TGOV1', 'TGOV1N', 'TGOV1DB', 'IEEEG1', 'IEESGO']), + ('vcomp', ['IEEEVC']), ('exciter', ['EXDC2', 'IEEEX1', 'ESDC2A', 'EXST1', 'ESST3A', 'SEXS', 'IEEET1', 'EXAC1', 'EXAC4', 'ESST4B', 'AC8B', 'IEEET3', 'ESAC1A', 'ESST1A']), - ('vcomp', ['IEEEVC']), ('pss', ['IEEEST', 'ST2CUT']), ('motor', ['Motor3', 'Motor5']), ('measurement', ['BusFreq', 'BusROCOF', 'PMU']), From 0f5e9ae069db4466fbec0b2e45be114a76505e98 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 15:44:08 -0500 Subject: [PATCH 26/58] Allow propagating `BackRef` indices through groups to models. --- andes/core/model.py | 11 +++++++++++ andes/models/exciter/excbase.py | 12 +++++++++++- andes/models/group.py | 12 ++++++++++++ andes/system.py | 31 ++++++++++++++++++++----------- 4 files changed, 54 insertions(+), 12 deletions(-) diff --git a/andes/core/model.py b/andes/core/model.py index 3bd1b36b1..d997f54da 100644 --- a/andes/core/model.py +++ b/andes/core/model.py @@ -792,6 +792,17 @@ def _one_idx2uid(self, idx): return self.uid[idx] + def set_backref(self, name, from_idx, to_idx): + """ + Helper function for setting idx-es to ``BackRef``. + """ + + if name not in self.services_ref: + return + + uid = self.idx2uid(to_idx) + self.services_ref[name].v[uid].append(from_idx) + def get(self, src: str, idx, attr: str = 'v', allow_none=False, default=0.0): """ Get the value of an attribute of a model property. diff --git a/andes/models/exciter/excbase.py b/andes/models/exciter/excbase.py index ed09ccd02..04d116aad 100644 --- a/andes/models/exciter/excbase.py +++ b/andes/models/exciter/excbase.py @@ -8,7 +8,7 @@ from andes.core.param import IdxParam, ExtParam from andes.core.var import Algeb, ExtState, ExtAlgeb -from andes.core.service import ExtService, ConstService +from andes.core.service import ExtService, ConstService, BackRef from andes.core.block import Integrator from andes.core.discrete import LessThan from andes.models.exciter.saturation import ExcQuadSat @@ -33,6 +33,9 @@ def __init__(self, system, config): self.group = 'Exciter' self.flags.tds = True + # Voltage compensator idx-es + self.VoltComp = BackRef() + # from synchronous generators, get u, Sn, Vn, bus; tm0; omega self.ug = ExtParam(src='u', model='SynGen', @@ -110,6 +113,13 @@ def __init__(self, system, config): info='Bus voltage magnitude', ) + self.vcomp = ExtAlgeb(model='VoltComp', + src='vcomp', + indexer=self.VoltComp, + tex_name=r'V_{comp}', + info='Voltage comp. output', + ) + # output excitation voltage self.vout = Algeb(info='Exciter final output voltage', tex_name='v_{out}', diff --git a/andes/models/group.py b/andes/models/group.py index 8f1bf0cd3..a6edac04b 100644 --- a/andes/models/group.py +++ b/andes/models/group.py @@ -336,6 +336,17 @@ def get_field(self, src: str, idx, field: str): return ret + def set_backref(self, name, from_idx, to_idx): + """ + Set idxes to ``BackRef`, and set them to models. + """ + + uid = self.idx2uid(to_idx) + self.services_ref[name].v[uid].append(from_idx) + + model = self.idx2model(to_idx) + model.set_backref(name, from_idx, to_idx) + def get_next_idx(self, idx=None, model_name=None): """ Get a no-conflict idx for a new device. @@ -647,6 +658,7 @@ def __init__(self): self.common_params.extend(('syn',)) self.common_vars.extend(('vout', 'vi',)) + self.VoltComp = BackRef() self.PSS = BackRef() diff --git a/andes/system.py b/andes/system.py index e13f6eb36..98ab8ad99 100644 --- a/andes/system.py +++ b/andes/system.py @@ -1598,34 +1598,43 @@ def collect_ref(self): """ models_and_groups = list(self.models.values()) + list(self.groups.values()) + # create an empty list of lists for all `BackRef` instances for model in models_and_groups: for ref in model.services_ref.values(): ref.v = [list() for _ in range(model.n)] + # `model` is the model who stores `IdxParam`s to other models + # `BackRef` is declared at other models specified by the `model` parameter + # of `IdxParam`s. + for model in models_and_groups: if model.n == 0: continue + + # skip: a group is not allowed to link to other groups if not hasattr(model, "idx_params"): - # skip: group does not link to another group continue - for ref in model.idx_params.values(): - if ref.model not in self.models and (ref.model not in self.groups): + for idxp in model.idx_params.values(): + if (idxp.model not in self.models) and (idxp.model not in self.groups): continue - dest_model = self.__dict__[ref.model] + dest = self.__dict__[idxp.model] - if dest_model.n == 0: + if dest.n == 0: continue - for n in (model.class_name, model.group): - if n not in dest_model.services_ref: + for name in (model.class_name, model.group): + # `BackRef` not requested by the linked models or groups + if name not in dest.services_ref: continue - for model_idx, dest_idx in zip(model.idx.v, ref.v): - if dest_idx not in dest_model.uid: + for model_idx, dest_idx in zip(model.idx.v, idxp.v): + if dest_idx not in dest.uid: continue - uid = dest_model.idx2uid(dest_idx) - dest_model.services_ref[n].v[uid].append(model_idx) + + dest.set_backref(name, + from_idx=model_idx, + to_idx=dest_idx) # set model ``in_use`` flag if isinstance(model, Model): From fc27f6b960da020d5ae7bb7d13066bbb854cdffe Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 16:05:45 -0500 Subject: [PATCH 27/58] Converted `vref0` into `PostInitService`. --- andes/models/exciter/exst1.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/andes/models/exciter/exst1.py b/andes/models/exciter/exst1.py index d1605af96..425b5e245 100644 --- a/andes/models/exciter/exst1.py +++ b/andes/models/exciter/exst1.py @@ -1,6 +1,6 @@ from andes.core.param import NumParam from andes.core.var import Algeb -from andes.core.service import ConstService +from andes.core.service import ConstService, PostInitService from andes.core.block import LeadLag, Washout, Lag from andes.core.discrete import HardLimiter @@ -71,18 +71,18 @@ class EXST1Model(ExcBase): def __init__(self, system, config): ExcBase.__init__(self, system, config) - self.vref0 = ConstService(info='Initial reference voltage input', - tex_name='V_{ref0}', - v_str='v + vf0 / KA', - ) - self.vref = Algeb(info='Reference voltage input', tex_name='V_{ref}', unit='p.u.', - v_str='vref0', + v_str='v + vf0 / KA', e_str='vref0 - vref' ) + self.vref0 = PostInitService(info='constant vref', + v_str='vref', + tex_name='V_{ref0}', + ) + # input excitation voltages; PSS outputs summed at vi self.vi = Algeb(info='Total input voltages', tex_name='V_i', From d30cdedb2650846290a1547a5dc6e78ebe1b7226 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 16:39:35 -0500 Subject: [PATCH 28/58] Added notes. --- andes/core/var.py | 1 + andes/models/exciter/excbase.py | 22 ++++++++++++++++------ 2 files changed, 17 insertions(+), 6 deletions(-) diff --git a/andes/core/var.py b/andes/core/var.py index 8267436b7..a230dc11f 100644 --- a/andes/core/var.py +++ b/andes/core/var.py @@ -451,6 +451,7 @@ def link_external(self, ext_model): self.parent = ext_model if isinstance(ext_model, GroupBase): + # determine the number of elements based on `indexer.v` if self.indexer.n > 0 and isinstance(self.indexer.v[0], (list, np.ndarray)): self._n = [len(i) for i in self.indexer.v] # number of elements in each sublist self._idx = np.concatenate([np.array(i) for i in self.indexer.v]) diff --git a/andes/models/exciter/excbase.py b/andes/models/exciter/excbase.py index 04d116aad..9983246a7 100644 --- a/andes/models/exciter/excbase.py +++ b/andes/models/exciter/excbase.py @@ -106,12 +106,12 @@ def __init__(self, system, config): tex_name=r'\theta', info='Bus voltage phase angle', ) - self.v = ExtAlgeb(model='Bus', - src='v', - indexer=self.bus, - tex_name=r'V', - info='Bus voltage magnitude', - ) + self.vbus = ExtAlgeb(model='Bus', + src='v', + indexer=self.bus, + tex_name='V', + info='Bus voltage magnitude', + ) self.vcomp = ExtAlgeb(model='VoltComp', src='vcomp', @@ -120,6 +120,16 @@ def __init__(self, system, config): info='Voltage comp. output', ) + # `self.v` is actually `ETERM` in other software + # TODO: + # Preferably, its name needs to be changed to `eterm`. + # That requires updates in equations of all exciters. + self.v = Algeb(info='Eterm, sum of vbus and vcomp', + tex_name='E_{term}', + v_str='vbus', + e_str='vbus - v' + ) + # output excitation voltage self.vout = Algeb(info='Exciter final output voltage', tex_name='v_{out}', From 2c19819ff77126f3058dce84fd8cb58a419f434c Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 16:39:51 -0500 Subject: [PATCH 29/58] Fixed warning from hline and vline. --- tests/test_case.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_case.py b/tests/test_case.py index 930411824..cf2a383bf 100644 --- a/tests/test_case.py +++ b/tests/test_case.py @@ -211,7 +211,7 @@ def test_kundur_plot(self): title='Bus Voltage Plot', left=0.2, right=1.5, ymin=0.95, ymax=1.05, legend=True, grid=True, greyscale=True, - hline1=1.01, hline2=1.02, vline1=0.5, vline2=0.8, + hline=[1.01, 1.02], vline=[0.5, 0.8], dpi=80, line_width=1.2, font_size=11, show=False, ) From 2e6577d0dd2a165c2fdaac5383f1a27709909450 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 22:19:40 -0500 Subject: [PATCH 30/58] Added `v_str_add` to allow the value of `v_str` to be added to existing initial values, possibly set by other models through `ExtVar`. --- andes/core/var.py | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/andes/core/var.py b/andes/core/var.py index a230dc11f..ec2e8c78c 100644 --- a/andes/core/var.py +++ b/andes/core/var.py @@ -50,6 +50,14 @@ class BaseVar: local-storage of the corresponding equation value e_str : str the string/symbolic representation of the equation + v_str : str + explicit initialization equation + v_str_add : bool + True if the value of `v_str` will be added to the variable. + Useful when other models access this variable and set part + of the initial value + v_iter : str + implicit iterative equation in the form of 0 = v_iter """ def __init__(self, @@ -63,6 +71,7 @@ def __init__(self, discrete: Optional[Discrete] = None, v_setter: Optional[bool] = False, e_setter: Optional[bool] = False, + v_str_add: Optional[bool] = False, addressable: Optional[bool] = True, export: Optional[bool] = True, diag_eps: Optional[float] = 0.0, @@ -84,6 +93,7 @@ def __init__(self, self.discrete = discrete self.v_setter = v_setter # True if this variable sets the variable value self.e_setter = e_setter # True if this var sets the equation value + self.v_str_add = v_str_add self.addressable = addressable # True if this var needs to be assigned an address FIXME: not in use self.export = export # True if this var's value needs to exported @@ -411,10 +421,16 @@ def set_arrays(self, dae, inplace=True, alloc=True): when ``e_str`` exists.. """ - if self.e_str is None: + if self.e_str is None or (self.n == 0): return - slice_idx = slice(self.r[0], self.r[-1] + 1) + try: + slice_idx = slice(self.r[0], self.r[-1] + 1) + except IndexError as e: + print(self.owner.class_name) + print(self.name) + raise e + if isinstance(self, ExtState): self.e = dae.h[slice_idx] elif isinstance(self, ExtAlgeb): From 1fc4fa864fd4be1589d3f5d35a6af9c4f37b5885 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 22:20:02 -0500 Subject: [PATCH 31/58] Textedit. --- andes/system.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/andes/system.py b/andes/system.py index 98ab8ad99..8a9510440 100644 --- a/andes/system.py +++ b/andes/system.py @@ -670,7 +670,7 @@ def init(self, models: OrderedDict, routine: str): logger.warning("Numba not found. JIT compilation is skipped.") for mdl in models.values(): - # link externals first + # link externals services first for instance in mdl.services_ext.values(): ext_name = instance.model try: From 3e292cfa81a181b7b7f7c9a29e073243bdcd5f28 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 22:20:27 -0500 Subject: [PATCH 32/58] Store jacobian triplets even if the number of elements of a variable is zero. --- andes/core/common.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/andes/core/common.py b/andes/core/common.py index 935a55536..c4c94ad11 100644 --- a/andes/core/common.py +++ b/andes/core/common.py @@ -148,8 +148,7 @@ def append_ijv(self, j_full_name, ii, jj, vv): vv : array-like Value indices """ - if len(ii) == 0 and len(jj) == 0: - return + self.ijac[j_full_name].append(ii) self.jjac[j_full_name].append(jj) self.vjac[j_full_name].append(vv) From be98b1fd6bef31070fcbfddc362535a151de3524 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 22:22:11 -0500 Subject: [PATCH 33/58] Handle other jacobian errors. --- andes/core/model.py | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/andes/core/model.py b/andes/core/model.py index d997f54da..638385f23 100644 --- a/andes/core/model.py +++ b/andes/core/model.py @@ -1274,16 +1274,10 @@ def j_update(self): for idx, fun in enumerate(self.calls.vjac[jname]): try: self.triplets.vjac[jname][idx][:] = ret[idx] - except ValueError as e: + except (ValueError, IndexError, FloatingPointError) as e: row_name, col_name = self._jac_eq_var_name(jname, idx) - logger.error('%s shape error: j_idx=%s, d%s / d%s', - jname, idx, row_name, col_name) - - raise e - except FloatingPointError as e: - row_name, col_name = self._jac_eq_var_name(jname, idx) - logger.error('%s eval error: j_idx=%s, d%s / d%s', - jname, idx, row_name, col_name) + logger.error('%s: error calculating or storing Jacobian <%s>: j_idx=%s, d%s / d%s', + self.class_name, jname, idx, row_name, col_name) raise e @@ -1684,12 +1678,20 @@ def init(self, routine): kwargs = self.get_inputs(refresh=True) for idx, name in enumerate(self.calls.init_seq): - # single variable + # single variable - do assignment if isinstance(name, str): instance = self.__dict__[name] _eval_discrete(instance) if instance.v_str is not None: - instance.v[:] = self.calls.ia[name](*self.ia_args[name]) + if not instance.v_str_add: + # assignment is for most variable initialization + instance.v[:] = self.calls.ia[name](*self.ia_args[name]) + else: + # in-place add initial values. + # Voltage compensators can set part of the `v` of exciters. + # Exciters will then set the bus voltage part. + instance.v[:] += self.calls.ia[name](*self.ia_args[name]) + # single variable iterative solution if name in self.calls.ii: self.solve_iter(name, kwargs) From 49e7f701e9eec9544e63e37ffacda20953efd2a2 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 22:22:52 -0500 Subject: [PATCH 34/58] Converted `ExcBase.v` to an `Algeb`. `v` cannot appear in `ConstService`. --- andes/models/exciter/esdc2a.py | 12 ++++++------ andes/models/exciter/esst4b.py | 12 ++++++------ andes/models/exciter/exac4.py | 13 +++++++------ andes/models/exciter/excbase.py | 28 +++++++++++++++++----------- andes/models/exciter/exdc2.py | 13 ++++++------- andes/models/exciter/ieeet1.py | 13 +++++++------ andes/models/exciter/ieeet3.py | 14 +++++++++----- andes/models/exciter/sexs.py | 15 ++++++++------- andes/models/vcomp/ieeevc.py | 31 +++++++++++++++++-------------- 9 files changed, 83 insertions(+), 68 deletions(-) diff --git a/andes/models/exciter/esdc2a.py b/andes/models/exciter/esdc2a.py index d2d9c3960..5c437b751 100644 --- a/andes/models/exciter/esdc2a.py +++ b/andes/models/exciter/esdc2a.py @@ -1,7 +1,7 @@ from andes.core.param import NumParam from andes.core.var import Algeb -from andes.core.service import ConstService, VarService, FlagValue +from andes.core.service import ConstService, VarService, FlagValue, PostInitService from andes.core.block import LagAntiWindup, LeadLag, Washout, Lag, HVGate from andes.core.block import LessThan @@ -124,17 +124,17 @@ def __init__(self, system, config): self.vfe0 = ConstService(v_str='vf0*KE + Se0', tex_name='V_{FE0}', ) - self.vref0 = ConstService(info='Initial reference voltage input', - tex_name='V_{ref0}', - v_str='v + vfe0 / KA', - ) self.vref = Algeb(info='Reference voltage input', tex_name='V_{ref}', unit='p.u.', - v_str='vref0', + v_str='v + vfe0 / KA', e_str='vref0 - vref' ) + self.vref0 = PostInitService(info='Const reference voltage', + tex_name='V_{ref0}', + v_str='vref', + ) self.vi = Algeb(info='Total input voltages', tex_name='V_i', diff --git a/andes/models/exciter/esst4b.py b/andes/models/exciter/esst4b.py index 90954e339..0f6a896ef 100644 --- a/andes/models/exciter/esst4b.py +++ b/andes/models/exciter/esst4b.py @@ -5,7 +5,7 @@ from andes.core.param import NumParam from andes.core.var import Algeb, ExtAlgeb from andes.core.block import Lag, PITrackAW, LVGate, Piecewise, GainLimiter # NOQA -from andes.core.service import ConstService, VarService +from andes.core.service import ConstService, VarService, PostInitService class ESST4BData(ExcBaseData): @@ -214,16 +214,16 @@ def __init__(self, system, config): info='Feedback gain with HL', ) - self.vref0 = ConstService(info='Initial reference voltage input', - tex_name='V_{ref0}', - v_str='v', - ) self.vref = Algeb(info='Reference voltage input', tex_name='V_{ref}', unit='p.u.', - v_str='vref0', + v_str='v', e_str='vref0 - vref' ) + self.vref0 = PostInitService(info='Const reference voltage', + tex_name='V_{ref0}', + v_str='vref', + ) self.vi = Algeb(info='Total input voltages', tex_name='V_i', diff --git a/andes/models/exciter/exac4.py b/andes/models/exciter/exac4.py index d1c8d3695..45b6a7e6c 100644 --- a/andes/models/exciter/exac4.py +++ b/andes/models/exciter/exac4.py @@ -3,7 +3,7 @@ from andes.core.param import NumParam from andes.core.var import Algeb from andes.core.block import LeadLag, Lag -from andes.core.service import ConstService +from andes.core.service import ConstService, PostInitService from andes.core.discrete import HardLimiter @@ -63,14 +63,10 @@ def __init__(self): class EXAC4Model(ExcBase): + # TODO: check why `vref` is not used def __init__(self, system, config): ExcBase.__init__(self, system, config) - self.vref0 = ConstService(info='Initial reference voltage input', - tex_name='V_{ref0}', - v_str='v + vf0 / KA', - ) - self.LG = Lag(u=self.v, T=self.TR, K=1, info='Sensing delay', ) @@ -81,6 +77,11 @@ def __init__(self, system, config): self.vi.v_str = 'vf0 / KA' self.vi.e_str = '(vref0 - LG_y) - vi' + self.vref0 = PostInitService(info='Const reference voltage', + tex_name='V_{ref0}', + v_str='v + vf0 / KA', + ) + self.HLI = HardLimiter(u=self.vi, lower=self.VIMIN, upper=self.VIMAX, info='Hard limiter on input', ) diff --git a/andes/models/exciter/excbase.py b/andes/models/exciter/excbase.py index 9983246a7..d8f599ddb 100644 --- a/andes/models/exciter/excbase.py +++ b/andes/models/exciter/excbase.py @@ -8,7 +8,7 @@ from andes.core.param import IdxParam, ExtParam from andes.core.var import Algeb, ExtState, ExtAlgeb -from andes.core.service import ExtService, ConstService, BackRef +from andes.core.service import ExtService, ConstService, BackRef, IdxRepeat from andes.core.block import Integrator from andes.core.discrete import LessThan from andes.models.exciter.saturation import ExcQuadSat @@ -28,6 +28,18 @@ def __init__(self): class ExcBase(Model): + """ + Base model for exciters. + + Notes + ----- + As of v1.4.5, the input voltage Eterm (variable ``self.v``) + is converted to type ``Algeb``. + Since variables are evaluated after services, + ``ConstService`` of exciters can no longer depend on ``v``. + + TODO: programmatically disallow ``ConstService`` use uninitialized variables. + """ def __init__(self, system, config): Model.__init__(self, system, config) self.group = 'Exciter' @@ -113,21 +125,15 @@ def __init__(self, system, config): info='Bus voltage magnitude', ) - self.vcomp = ExtAlgeb(model='VoltComp', - src='vcomp', - indexer=self.VoltComp, - tex_name=r'V_{comp}', - info='Voltage comp. output', - ) - # `self.v` is actually `ETERM` in other software # TODO: # Preferably, its name needs to be changed to `eterm`. # That requires updates in equations of all exciters. - self.v = Algeb(info='Eterm, sum of vbus and vcomp', + self.v = Algeb(info='Input to exciter (bus v or Eterm)', tex_name='E_{term}', v_str='vbus', - e_str='vbus - v' + e_str='vbus - v', + v_str_add=True, ) # output excitation voltage @@ -170,8 +176,8 @@ def __init__(self): self.vref = Algeb(info='Reference voltage input', tex_name='V_{ref}', unit='p.u.', - v_str='vref0', e_str='vref0 - vref' + # TODO: subclass to provide `vi.v_str` ) diff --git a/andes/models/exciter/exdc2.py b/andes/models/exciter/exdc2.py index d12d1318d..fa4e9606f 100644 --- a/andes/models/exciter/exdc2.py +++ b/andes/models/exciter/exdc2.py @@ -7,7 +7,7 @@ from andes.core.param import NumParam from andes.core.var import Algeb, State -from andes.core.service import ConstService +from andes.core.service import ConstService, PostInitService from andes.core.block import LeadLag, Washout, Lag, LessThan, LagAntiWindup @@ -114,17 +114,16 @@ def __init__(self, system, config): tex_name='V_{b0}', v_str='vr0 / KA') - self.vref0 = ConstService(info='Initial reference voltage input', - tex_name='V_{ref0}', - v_str='vb0 + v', - ) # derived classes to-do: provide `v_str` - self.vref = Algeb(info='Reference voltage input', tex_name='V_{ref}', unit='p.u.', - v_str='vref0', + v_str='v + vb0', e_str='vref0 - vref' ) + self.vref0 = PostInitService(info='Constant v ref', + tex_name='V_{ref0}', + v_str='vref', + ) self.SL = LessThan(u=self.vout, bound=self.SAT_A, diff --git a/andes/models/exciter/ieeet1.py b/andes/models/exciter/ieeet1.py index 28a8ae992..732740718 100644 --- a/andes/models/exciter/ieeet1.py +++ b/andes/models/exciter/ieeet1.py @@ -1,7 +1,7 @@ from andes.core.param import NumParam from andes.core.var import Algeb -from andes.core.service import ConstService, FlagValue +from andes.core.service import ConstService, FlagValue, PostInitService from andes.core.block import LagAntiWindup, Washout, Lag from andes.core.block import LessThan @@ -115,10 +115,6 @@ def __init__(self, system, config): self.vb0 = ConstService(info='Initial vb', tex_name='V_{b0}', v_str='vr0 / KA') - self.vref0 = ConstService(info='Initial reference voltage input', - tex_name='V_{ref0}', - v_str='v + vb0', - ) self.vfe0 = ConstService(v_str='vf0 * KE + Se0', tex_name='V_{FE0}', ) @@ -126,10 +122,15 @@ def __init__(self, system, config): self.vref = Algeb(info='Reference voltage input', tex_name='V_{ref}', unit='p.u.', - v_str='vref0', + v_str='v + vb0', e_str='vref0 - vref' ) + self.vref0 = PostInitService(info='Const reference voltage', + tex_name='V_{ref0}', + v_str='vref', + ) + self.LG = Lag(u=self.v, T=self.TR, K=1, info='Sensing delay', ) diff --git a/andes/models/exciter/ieeet3.py b/andes/models/exciter/ieeet3.py index 5f6de4bc5..7da53cbbe 100644 --- a/andes/models/exciter/ieeet3.py +++ b/andes/models/exciter/ieeet3.py @@ -1,7 +1,7 @@ from andes.core.param import NumParam from andes.core.var import Algeb, ExtAlgeb -from andes.core.service import ConstService, FlagValue, VarService +from andes.core.service import ConstService, FlagValue, VarService, PostInitService from andes.core.block import LagAntiWindup, Washout, Lag from andes.core.block import LessThan @@ -124,10 +124,6 @@ def __init__(self, system, config): tex_name='V_{b0}', v_str='VR0 / KA') - self.vref0 = ConstService(info='Initial reference voltage input', - tex_name='V_{ref0}', - v_str='v + vb0') - # Set VRMAX to 999 when VRMAX = 0 self._zVRM = FlagValue(self.VRMAX, value=0, tex_name='z_{VRMAX}', @@ -141,6 +137,13 @@ def __init__(self, system, config): ExcVsum.__init__(self) + self.vref.v_str = 'v + vb0' + + self.vref0 = PostInitService(info='Constant vref', + tex_name='V_{ref0}', + v_str='vref') + + # NOTE: for offline exciters, `vi` equation ignores ext. voltage changes self.vi = Algeb(info='Total input voltages', tex_name='V_i', @@ -203,6 +206,7 @@ class IEEET3(IEEET3Data, IEEET3Model): https://www.neplan.ch/wp-content/uploads/2015/08/Nep_EXCITERS1.pdf """ + def __init__(self, system, config): IEEET3Data.__init__(self) IEEET3Model.__init__(self, system, config) diff --git a/andes/models/exciter/sexs.py b/andes/models/exciter/sexs.py index ade7d8455..edaeaeb55 100644 --- a/andes/models/exciter/sexs.py +++ b/andes/models/exciter/sexs.py @@ -1,7 +1,7 @@ from andes.core.param import NumParam from andes.core.var import Algeb -from andes.core.service import ConstService +from andes.core.service import ConstService, PostInitService from andes.core.block import LagAntiWindup, LeadLag @@ -52,17 +52,18 @@ def __init__(self, system, config): self.TA = ConstService(v_str='TATB * TB') - self.vref0 = ConstService(info='Initial reference voltage input', - tex_name='V_{ref0}', - v_str='vf0/K + v', - ) - self.vref = Algeb(info='Reference voltage input', tex_name='V_{ref}', unit='p.u.', - v_str='vref0', + v_str='v + vf0 / K', e_str='vref0 - vref' ) + + self.vref0 = PostInitService(info='Constant vref', + tex_name='V_{ref0}', + v_str='vref', + ) + # input excitation voltages; PSS outputs summed at vi self.vi = Algeb(info='Total input voltages', tex_name='V_i', diff --git a/andes/models/vcomp/ieeevc.py b/andes/models/vcomp/ieeevc.py index e7aae63f4..d248f79bc 100644 --- a/andes/models/vcomp/ieeevc.py +++ b/andes/models/vcomp/ieeevc.py @@ -76,26 +76,29 @@ def __init__(self, system, config): info='q-axis machine current', ) - # from Exciter - self.vi = ExtAlgeb(model='Exciter', src='vi', indexer=self.avr, tex_name='v_i', - info='Exciter input voltage', - e_str='u * vcomp', - ename='Vi', - tex_ename='V_i', - ) - self.vct = VarService(tex_name=r'V_{CT}', - v_str='Abs((vd + 1j*vq) + (rc + 1j * xc) * (Id + 1j*Iq))', + v_str='u * Abs((vd + 1j*vq) + (rc + 1j * xc) * (Id + 1j*Iq))', ) - self.vcomp0 = ConstService(v_str='Abs((vd + 1j*vq) + (rc + 1j * xc) * (Id + 1j*Iq))') - # output voltage + # self.vcomp0 = ConstService(v_str='u * Abs((vd + 1j*vq) + (rc + 1j * xc) * (Id + 1j*Iq))') + + # output voltage. + # `vcomp` is the additional voltage to be added to bus terminal voltage self.vcomp = Algeb(info='Compensator output voltage to exciter', tex_name=r'v_{comp}', - v_str='vcomp0 - v', - e_str='u * (vct - v - vcomp)', - diag_eps=True, + v_str='vct - u * v', + e_str='vct - u * v - vcomp', ) + # do not need to interface to exciters here. + # Let the exciters pick up `vcomp` through back referencing + + self.Eterm = ExtAlgeb(model='Exciter', + src='v', + indexer=self.avr, + v_str='vcomp', + e_str='vcomp', + ) + class IEEEVC(IEEEVCData, IEEEVCModel): """ From 7c69f6711640a18c4d86827b69b5dc7f0167abe3 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 22:23:36 -0500 Subject: [PATCH 35/58] Removed unused code. --- andes/models/vcomp/ieeevc.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/andes/models/vcomp/ieeevc.py b/andes/models/vcomp/ieeevc.py index d248f79bc..81b974605 100644 --- a/andes/models/vcomp/ieeevc.py +++ b/andes/models/vcomp/ieeevc.py @@ -3,7 +3,7 @@ from andes.core.param import NumParam, IdxParam, ExtParam from andes.core.var import Algeb, ExtAlgeb -from andes.core.service import ConstService, VarService, ExtService +from andes.core.service import VarService, ExtService class IEEEVCData(ModelData): @@ -79,7 +79,6 @@ def __init__(self, system, config): self.vct = VarService(tex_name=r'V_{CT}', v_str='u * Abs((vd + 1j*vq) + (rc + 1j * xc) * (Id + 1j*Iq))', ) - # self.vcomp0 = ConstService(v_str='u * Abs((vd + 1j*vq) + (rc + 1j * xc) * (Id + 1j*Iq))') # output voltage. # `vcomp` is the additional voltage to be added to bus terminal voltage From 04df4b3baa60307d6418f2a04386fbfa9cbb4903 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 22:24:47 -0500 Subject: [PATCH 36/58] Style fixes. --- andes/models/exciter/exac4.py | 2 +- andes/models/exciter/excbase.py | 2 +- andes/models/exciter/exst1.py | 2 +- andes/models/exciter/ieeet3.py | 1 - andes/models/exciter/sexs.py | 6 +++--- 5 files changed, 6 insertions(+), 7 deletions(-) diff --git a/andes/models/exciter/exac4.py b/andes/models/exciter/exac4.py index 45b6a7e6c..ed4501383 100644 --- a/andes/models/exciter/exac4.py +++ b/andes/models/exciter/exac4.py @@ -3,7 +3,7 @@ from andes.core.param import NumParam from andes.core.var import Algeb from andes.core.block import LeadLag, Lag -from andes.core.service import ConstService, PostInitService +from andes.core.service import PostInitService from andes.core.discrete import HardLimiter diff --git a/andes/models/exciter/excbase.py b/andes/models/exciter/excbase.py index d8f599ddb..d09fe533a 100644 --- a/andes/models/exciter/excbase.py +++ b/andes/models/exciter/excbase.py @@ -8,7 +8,7 @@ from andes.core.param import IdxParam, ExtParam from andes.core.var import Algeb, ExtState, ExtAlgeb -from andes.core.service import ExtService, ConstService, BackRef, IdxRepeat +from andes.core.service import ExtService, ConstService, BackRef from andes.core.block import Integrator from andes.core.discrete import LessThan from andes.models.exciter.saturation import ExcQuadSat diff --git a/andes/models/exciter/exst1.py b/andes/models/exciter/exst1.py index 425b5e245..0f5702245 100644 --- a/andes/models/exciter/exst1.py +++ b/andes/models/exciter/exst1.py @@ -1,6 +1,6 @@ from andes.core.param import NumParam from andes.core.var import Algeb -from andes.core.service import ConstService, PostInitService +from andes.core.service import PostInitService from andes.core.block import LeadLag, Washout, Lag from andes.core.discrete import HardLimiter diff --git a/andes/models/exciter/ieeet3.py b/andes/models/exciter/ieeet3.py index 7da53cbbe..3cc26496d 100644 --- a/andes/models/exciter/ieeet3.py +++ b/andes/models/exciter/ieeet3.py @@ -143,7 +143,6 @@ def __init__(self, system, config): tex_name='V_{ref0}', v_str='vref') - # NOTE: for offline exciters, `vi` equation ignores ext. voltage changes self.vi = Algeb(info='Total input voltages', tex_name='V_i', diff --git a/andes/models/exciter/sexs.py b/andes/models/exciter/sexs.py index edaeaeb55..166c6edaa 100644 --- a/andes/models/exciter/sexs.py +++ b/andes/models/exciter/sexs.py @@ -60,9 +60,9 @@ def __init__(self, system, config): ) self.vref0 = PostInitService(info='Constant vref', - tex_name='V_{ref0}', - v_str='vref', - ) + tex_name='V_{ref0}', + v_str='vref', + ) # input excitation voltages; PSS outputs summed at vi self.vi = Algeb(info='Total input voltages', From 6aeb7e07e737154f788e66bf38322e671d8e7693 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 22:25:32 -0500 Subject: [PATCH 37/58] Initialization passes. --- examples/demonstration/test_IEEEVC.ipynb | 61 +++++++++--------------- 1 file changed, 23 insertions(+), 38 deletions(-) diff --git a/examples/demonstration/test_IEEEVC.ipynb b/examples/demonstration/test_IEEEVC.ipynb index 6f68c61bf..ac00a8a74 100644 --- a/examples/demonstration/test_IEEEVC.ipynb +++ b/examples/demonstration/test_IEEEVC.ipynb @@ -21,12 +21,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "Working directory: \"/Users/jinningwang/Documents/work/andes/examples/demonstration\"\n", - "Loaded config from file \"/Users/jinningwang/.andes/andes.rc\"\n", - "Loaded generated Python code in \"/Users/jinningwang/.andes/pycode\".\n", - "Parsing input file \"/Users/jinningwang/Documents/work/andes/andes/cases/ieee14/ieee14_ieeevc.xlsx\"...\n", - "Input file parsed in 0.4172 seconds.\n", - "System internal structure set up in 0.0211 seconds.\n" + "Working directory: \"/home/hcui7/repos/andes/examples/demonstration\"\n", + "Loaded config from file \"/home/hcui7/.andes/andes.rc\"\n", + "Loaded generated Python code in \"/home/hcui7/.andes/pycode\".\n", + "Parsing input file \"/home/hcui7/repos/andes/andes/cases/ieee14/ieee14_ieeevc.xlsx\"...\n", + "Input file parsed in 0.3254 seconds.\n", + "System internal structure set up in 0.0195 seconds.\n" ] }, { @@ -73,31 +73,16 @@ "1: |F(x)| = 0.006202200332\n", "2: |F(x)| = 5.819382825e-06\n", "3: |F(x)| = 6.967745825e-12\n", - "Converged in 4 iterations in 0.0080 seconds.\n", - "Suspect initialization issue! Simulation may crash!\n", - "\n", - " Name | Var. Value | Eqn. Mismatch\n", - "-------------+------------+--------------\n", - " vi IEEET1 1 | 0.294 | 0.025 \n", - "\n", - "\n", - "Initialization for dynamics completed in 0.0254 seconds.\n", - "Initialization failed!!\n" + "Converged in 4 iterations in 0.0051 seconds.\n", + "Initialization for dynamics completed in 0.0169 seconds.\n", + "Initialization was successful.\n" ] - }, - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ - "ss.PFlow.run()" + "ss.PFlow.run()\n", + "\n", + "xy = ss.TDS.init()" ] }, { @@ -109,8 +94,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Algeb: IEEEVC.vcomp, a=[214], v=[0.02460921], e=[0.]\n", - "Algeb: IEEET1.vi, a=[210], v=[0.29427554], e=[0.02460921]\n" + "Algeb: IEEEVC.vcomp, a=[158], v=[0.02460921], e=[0.]\n", + "Algeb: IEEET1.vi, a=[216], v=[0.29427554], e=[0.]\n" ] } ], @@ -128,8 +113,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Algeb: IEEEVC.vcomp, a=[214], v=[0.02460921], e=[0.]\n", - "Algeb: IEEEVC.vcomp, a=[214], v=[0.02460921], e=[0.]\n" + "Algeb: IEEEVC.vcomp, a=[158], v=[0.02460921], e=[0.]\n", + "Algeb: IEEEVC.vcomp, a=[158], v=[0.02460921], e=[0.]\n" ] } ], @@ -160,14 +145,14 @@ "text": [ ": Line.Line_1 status changed to 0 at t=1.0 sec.\n", ": Line.Line_1 status changed to 1 at t=1.1 sec.\n", - "100%|███████████████████████████████| 100/100 [00:00<00:00, 202.04%/s]" + "100%|███████████████████████████████| 100/100 [00:00<00:00, 261.85%/s]" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Simulation completed in 0.4953 seconds.\n" + "Simulation completed in 0.3826 seconds.\n" ] }, { @@ -210,8 +195,8 @@ "output_type": "stream", "text": [ "\n", - " _ _ | Version 1.4.4.post25+g39bd4f61\n", - " /_\\ _ _ __| |___ ___ | Python 3.7.10 on Darwin, 10/08/2021 06:31:01 PM\n", + " _ _ | Version 1.4.4.post38.dev0+g04df4b3b\n", + " /_\\ _ _ __| |___ ___ | Python 3.9.6 on Linux, 10/09/2021 10:25:15 PM\n", " / _ \\| ' \\/ _` / -_|_-< | \n", " /_/ \\_\\_||_\\__,_\\___/__/ | This program comes with ABSOLUTELY NO WARRANTY.\n", "\n", @@ -226,10 +211,10 @@ ], "metadata": { "interpreter": { - "hash": "b8c542af61804583455bb3cc02c5acff1b7eab71b36b048085e6e502c5a0f30d" + "hash": "491bc57f30212ab10e081de3c9da13bbea8cb936a32794256be1d301e32fe2dd" }, "kernelspec": { - "display_name": "Python 3.7.10 64-bit ('andes': conda)", + "display_name": "Python 3.9.6 64-bit ('a': conda)", "name": "python3" }, "language_info": { @@ -242,7 +227,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.9.6" } }, "nbformat": 4, From 698068ab11f123c643c1b80e44d92ac51509bd12 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 22:33:42 -0500 Subject: [PATCH 38/58] Fix docstring. --- andes/models/group.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/andes/models/group.py b/andes/models/group.py index a6edac04b..373d59e6c 100644 --- a/andes/models/group.py +++ b/andes/models/group.py @@ -338,7 +338,7 @@ def get_field(self, src: str, idx, field: str): def set_backref(self, name, from_idx, to_idx): """ - Set idxes to ``BackRef`, and set them to models. + Set idxes to ``BackRef``, and set them to models. """ uid = self.idx2uid(to_idx) From 10fad9b314afd46a157a07dcf3004fd6dc38db78 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sat, 9 Oct 2021 22:43:21 -0500 Subject: [PATCH 39/58] Added release notes. --- docs/source/release-notes.rst | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/docs/source/release-notes.rst b/docs/source/release-notes.rst index f758744ec..2a7b3be5b 100644 --- a/docs/source/release-notes.rst +++ b/docs/source/release-notes.rst @@ -9,6 +9,24 @@ The APIs before v3.0.0 are in beta and may change without prior notice. v1.4 Notes ---------- +v1.4.5 (2021-10-xx) +``````````````````` +- Allow ``BackRef`` to populate to models through ``Group``. + +When model `A` stores an ``IdxParam`` pointing to a group, if ``BackRef`` +with the name `A` are declared in both the group and the model, +both ``BackRef`` will retrieve the backward references from model `A`. + +- Allow ``BaseVar`` to accept partial initializations. + +If ``BaseVar.v_str_add = True``, the value of `v_str` will be added in place +to variable value. +An example is that voltage compensator sets part of the input voltage, and +exciter reads the bus voltage. Exciter has `v.v_str_add = True` so that +when compensators exist, the input voltage will be bus voltage (vbus) plus +(Eterm - vbus). +If no compensator exists, exciter will use bus voltages and function as expected. + v1.4.4 (2021-10-05) ```````````````````` - Bug fixes for refreshing generated code. From ccde557ee978255d2e482198f122487d0dfefa42 Mon Sep 17 00:00:00 2001 From: Jinning Wang Date: Sun, 10 Oct 2021 00:29:04 -0400 Subject: [PATCH 40/58] Added demo for IEEEVC. --- andes/cases/ieee14/ieee14_ieeevc.xlsx | Bin 27470 -> 26565 bytes examples/demonstration/2.5 demo_IEEEVC.ipynb | 383 +++++++++++++++++++ examples/demonstration/test_IEEEVC.ipynb | 235 ------------ 3 files changed, 383 insertions(+), 235 deletions(-) create mode 100644 examples/demonstration/2.5 demo_IEEEVC.ipynb delete mode 100644 examples/demonstration/test_IEEEVC.ipynb diff --git a/andes/cases/ieee14/ieee14_ieeevc.xlsx b/andes/cases/ieee14/ieee14_ieeevc.xlsx index f1740e4a121fa80ea6d48de8ada82c6e861c8d5c..5389654724d8499b9257a1e165ced164b7128f59 100644 GIT binary patch delta 6925 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 delta 7510 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 diff --git a/examples/demonstration/2.5 demo_IEEEVC.ipynb b/examples/demonstration/2.5 demo_IEEEVC.ipynb new file mode 100644 index 000000000..bb4adcb9b --- /dev/null +++ b/examples/demonstration/2.5 demo_IEEEVC.ipynb @@ -0,0 +1,383 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ANDES Demonstration of IEEEVC on IEEE 14-Bus System\n", + "\n", + "Prepared by Jinning Wang. Last revised on October 10, 2021." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2021-09-26T22:41:50.949182Z", + "iopub.status.busy": "2021-09-26T22:41:50.948875Z", + "iopub.status.idle": "2021-09-26T22:41:51.715473Z", + "shell.execute_reply": "2021-09-26T22:41:51.715029Z" + } + }, + "outputs": [], + "source": [ + "import andes\n", + "from andes.utils.paths import get_case\n", + "\n", + "andes.config_logger(stream_level=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2021-09-26T22:41:51.718124Z", + "iopub.status.busy": "2021-09-26T22:41:51.717830Z", + "iopub.status.idle": "2021-09-26T22:41:52.415346Z", + "shell.execute_reply": "2021-09-26T22:41:52.415616Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Working directory: \"/Users/jinningwang/Documents/work/andes/examples/demonstration\"\n", + "Loaded config from file \"/Users/jinningwang/.andes/andes.rc\"\n", + "Loaded generated Python code in \"/Users/jinningwang/.andes/pycode\".\n", + "Parsing input file \"/Users/jinningwang/Documents/work/andes/andes/cases/ieee14/ieee14_ieeevc.xlsx\"...\n", + "Input file parsed in 0.3611 seconds.\n", + "System internal structure set up in 0.0212 seconds.\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss = andes.load(get_case('ieee14/ieee14_ieeevc.xlsx'),\n", + " setup=False,\n", + " no_output=True)\n", + "ss.setup()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Simulation\n", + "\n", + "Voltage compensator ``IEEEVC_1`` and ``IEEEVC_2`` are connected to exciter ``IEEET1_1`` and ``ESST3A_3``, respectively, and the controlled generators are ``GENROU_5`` and ``GENROU_3``." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2021-09-26T22:41:52.417917Z", + "iopub.status.busy": "2021-09-26T22:41:52.417501Z", + "iopub.status.idle": "2021-09-26T22:41:52.439169Z", + "shell.execute_reply": "2021-09-26T22:41:52.439419Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "-> System connectivity check results:\n", + " No islanded bus detected.\n", + " A total of 1 island(s) detected.\n", + " Each island has a slack bus correctly defined and enabled.\n", + "\n", + "-> Power flow calculation\n", + " Sparse solver: KLU\n", + " Solution method: NR method\n", + " Sparse addition: Fast in-place (kvxopt)\n", + "Power flow initialized.\n", + "0: |F(x)| = 0.5605182134\n", + "1: |F(x)| = 0.006202200332\n", + "2: |F(x)| = 5.819382825e-06\n", + "3: |F(x)| = 6.967745825e-12\n", + "Converged in 4 iterations in 0.0054 seconds.\n", + "Initialization for dynamics completed in 0.0195 seconds.\n", + "Initialization was successful.\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss.PFlow.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2021-09-26T22:41:52.442840Z", + "iopub.status.busy": "2021-09-26T22:41:52.442389Z", + "iopub.status.idle": "2021-09-26T22:41:56.170885Z", + "shell.execute_reply": "2021-09-26T22:41:56.171492Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "-> Time Domain Simulation Summary:\n", + "Sparse Solver: KLU\n", + "Simulation time: 0.0-20 s.\n", + "Fixed step size: h=33.33 ms. Shrink if not converged.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": Line.Line_1 status changed to 0 at t=1.0 sec. \n", + ": Line.Line_1 status changed to 1 at t=1.1 sec. \n", + "100%|████████████████████████████████| 100/100 [00:01<00:00, 76.41%/s]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Simulation completed in 1.3090 seconds.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss.TDS.config.tf = 20\n", + "ss.TDS.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "execution": { + "iopub.execute_input": "2021-09-26T22:41:56.174327Z", + "iopub.status.busy": "2021-09-26T22:41:56.173526Z", + "iopub.status.idle": "2021-09-26T22:41:56.179960Z", + "shell.execute_reply": "2021-09-26T22:41:56.179271Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss.exit_code" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2021-09-26T22:41:56.186528Z", + "iopub.status.busy": "2021-09-26T22:41:56.186073Z", + "iopub.status.idle": "2021-09-26T22:41:56.995950Z", + "shell.execute_reply": "2021-09-26T22:41:56.996561Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(
, )" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ss.TDS.plt.plot(ss.IEEEVC.vcomp)\n", + "ss.TDS.plt.plot(ss.GENROU.vf,\n", + " a=(2,4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cleanup" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2021-09-26T22:41:57.710348Z", + "iopub.status.busy": "2021-09-26T22:41:57.709278Z", + "iopub.status.idle": "2021-09-26T22:41:58.781477Z", + "shell.execute_reply": "2021-09-26T22:41:58.781216Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r\n", + " _ _ | Version 1.4.4.post41.dev0+g10fad9b3\r\n", + " /_\\ _ _ __| |___ ___ | Python 3.7.10 on Darwin, 10/10/2021 12:26:03 AM\r\n", + " / _ \\| ' \\/ _` / -_|_-< | \r\n", + " /_/ \\_\\_||_\\__,_\\___/__/ | This program comes with ABSOLUTELY NO WARRANTY.\r\n", + "\r\n", + "No output file found in the working directory.\r\n" + ] + } + ], + "source": [ + "!andes misc -C" + ] + } + ], + "metadata": { + "hide_input": false, + "interpreter": { + "hash": "b8c542af61804583455bb3cc02c5acff1b7eab71b36b048085e6e502c5a0f30d" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.10" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/demonstration/test_IEEEVC.ipynb b/examples/demonstration/test_IEEEVC.ipynb deleted file mode 100644 index ac00a8a74..000000000 --- a/examples/demonstration/test_IEEEVC.ipynb +++ /dev/null @@ -1,235 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import andes\n", - "from andes.utils.paths import get_case\n", - "\n", - "andes.config_logger(stream_level=20)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Working directory: \"/home/hcui7/repos/andes/examples/demonstration\"\n", - "Loaded config from file \"/home/hcui7/.andes/andes.rc\"\n", - "Loaded generated Python code in \"/home/hcui7/.andes/pycode\".\n", - "Parsing input file \"/home/hcui7/repos/andes/andes/cases/ieee14/ieee14_ieeevc.xlsx\"...\n", - "Input file parsed in 0.3254 seconds.\n", - "System internal structure set up in 0.0195 seconds.\n" - ] - }, - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ss = andes.load(get_case('ieee14/ieee14_ieeevc.xlsx'),\n", - " setup=False,\n", - " no_output=True)\n", - "\n", - "ss.setup()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "-> System connectivity check results:\n", - " No islanded bus detected.\n", - " A total of 1 island(s) detected.\n", - " Each island has a slack bus correctly defined and enabled.\n", - "\n", - "-> Power flow calculation\n", - " Sparse solver: KLU\n", - " Solution method: NR method\n", - " Sparse addition: Fast in-place (kvxopt)\n", - "Power flow initialized.\n", - "0: |F(x)| = 0.5605182134\n", - "1: |F(x)| = 0.006202200332\n", - "2: |F(x)| = 5.819382825e-06\n", - "3: |F(x)| = 6.967745825e-12\n", - "Converged in 4 iterations in 0.0051 seconds.\n", - "Initialization for dynamics completed in 0.0169 seconds.\n", - "Initialization was successful.\n" - ] - } - ], - "source": [ - "ss.PFlow.run()\n", - "\n", - "xy = ss.TDS.init()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Algeb: IEEEVC.vcomp, a=[158], v=[0.02460921], e=[0.]\n", - "Algeb: IEEET1.vi, a=[216], v=[0.29427554], e=[0.]\n" - ] - } - ], - "source": [ - "print(ss.IEEEVC.vcomp)\n", - "print(ss.IEEET1.vi)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Algeb: IEEEVC.vcomp, a=[158], v=[0.02460921], e=[0.]\n", - "Algeb: IEEEVC.vcomp, a=[158], v=[0.02460921], e=[0.]\n" - ] - } - ], - "source": [ - "print(ss.IEEEVC.vcomp)\n", - "print(ss.IEEEVC.vcomp)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "-> Time Domain Simulation Summary:\n", - "Sparse Solver: KLU\n", - "Simulation time: 0.0-5 s.\n", - "Fixed step size: h=33.33 ms. Shrink if not converged.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - ": Line.Line_1 status changed to 0 at t=1.0 sec.\n", - ": Line.Line_1 status changed to 1 at t=1.1 sec.\n", - "100%|███████████████████████████████| 100/100 [00:00<00:00, 261.85%/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Simulation completed in 0.3826 seconds.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ss.TDS.config.tf = 5\n", - "ss.TDS.run()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Cleanup" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " _ _ | Version 1.4.4.post38.dev0+g04df4b3b\n", - " /_\\ _ _ __| |___ ___ | Python 3.9.6 on Linux, 10/09/2021 10:25:15 PM\n", - " / _ \\| ' \\/ _` / -_|_-< | \n", - " /_/ \\_\\_||_\\__,_\\___/__/ | This program comes with ABSOLUTELY NO WARRANTY.\n", - "\n", - "No output file found in the working directory.\n" - ] - } - ], - "source": [ - "!andes misc -C" - ] - } - ], - "metadata": { - "interpreter": { - "hash": "491bc57f30212ab10e081de3c9da13bbea8cb936a32794256be1d301e32fe2dd" - }, - "kernelspec": { - "display_name": "Python 3.9.6 64-bit ('a': conda)", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.6" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 9340834d38726cf69c5d6c277c44d98ee7cf3ea2 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Sun, 10 Oct 2021 11:28:23 -0500 Subject: [PATCH 41/58] Added notes. --- docs/source/release-notes.rst | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/docs/source/release-notes.rst b/docs/source/release-notes.rst index 2a7b3be5b..9f0660c5e 100644 --- a/docs/source/release-notes.rst +++ b/docs/source/release-notes.rst @@ -27,6 +27,12 @@ when compensators exist, the input voltage will be bus voltage (vbus) plus (Eterm - vbus). If no compensator exists, exciter will use bus voltages and function as expected. +- Added reserved variable names ``__ones`` and ``__zeros`` for ones and + zeros with length equal to the device number. + +``__ones`` and ``__zeros`` are useful for vectorizing ``choicelist`` +in ``Piecewise`` functions. + v1.4.4 (2021-10-05) ```````````````````` - Bug fixes for refreshing generated code. From cc6f0a3585ff22ba6a8c02f5a3bf61bac31a9e12 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Mon, 11 Oct 2021 11:48:52 -0500 Subject: [PATCH 42/58] Added notes. --- andes/core/symprocessor.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/andes/core/symprocessor.py b/andes/core/symprocessor.py index 008bb1f5f..80a28a9fc 100644 --- a/andes/core/symprocessor.py +++ b/andes/core/symprocessor.py @@ -225,7 +225,9 @@ def generate_services(self): s_args[name] = [str(i) for i in expr.free_symbols] s_calls[name] = lambdify(s_args[name], s_syms[name], modules=self.lambdify_func) + # TODO: below triggers DeprecationWarning with SymPy 1.9 self.s_matrix = Matrix(list(s_syms.values())) + self.calls.s = s_calls self.calls.s_args = s_args From 84cf0a925e6af241e15e4f43ee782b1084e4e96d Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Mon, 11 Oct 2021 13:45:55 -0500 Subject: [PATCH 43/58] Added `TGOV1NDB` model. --- andes/models/__init__.py | 3 ++- andes/models/governor/__init__.py | 1 + andes/models/governor/tgov1.py | 31 +++++++++++++++++++++++++++++++ 3 files changed, 34 insertions(+), 1 deletion(-) diff --git a/andes/models/__init__.py b/andes/models/__init__.py index bcd7311b1..ead309892 100644 --- a/andes/models/__init__.py +++ b/andes/models/__init__.py @@ -23,7 +23,8 @@ ('area', ['Area', 'ACE', 'ACEc']), ('dynload', ['ZIP', 'FLoad']), ('synchronous', ['GENCLS', 'GENROU']), - ('governor', ['TG2', 'TGOV1', 'TGOV1N', 'TGOV1DB', 'IEEEG1', 'IEESGO']), + ('governor', ['TG2', 'TGOV1', 'TGOV1DB', 'TGOV1N', 'TGOV1NDB', + 'IEEEG1', 'IEESGO']), ('vcomp', ['IEEEVC']), ('exciter', ['EXDC2', 'IEEEX1', 'ESDC2A', 'EXST1', 'ESST3A', 'SEXS', 'IEEET1', 'EXAC1', 'EXAC4', 'ESST4B', 'AC8B', 'IEEET3', diff --git a/andes/models/governor/__init__.py b/andes/models/governor/__init__.py index 1755d7443..1a3dbc965 100644 --- a/andes/models/governor/__init__.py +++ b/andes/models/governor/__init__.py @@ -1,4 +1,5 @@ from andes.models.governor.tg2 import TG2 # NOQA from andes.models.governor.tgov1 import TGOV1, TGOV1N, TGOV1DB # NOQA +from andes.models.governor.tgov1 import TGOV1NDB # NOQA from andes.models.governor.ieesgo import IEESGO # NOQA from andes.models.governor.ieeeg1 import IEEEG1 # NOQA diff --git a/andes/models/governor/tgov1.py b/andes/models/governor/tgov1.py index 29ab72470..fb7146bee 100644 --- a/andes/models/governor/tgov1.py +++ b/andes/models/governor/tgov1.py @@ -57,6 +57,10 @@ def __init__(self): class TGOV1Model(TGBase): + """ + Implement TGOV1 model. + """ + def __init__(self, system, config): TGBase.__init__(self, system, config) @@ -109,6 +113,10 @@ def __init__(self, system, config): class TGOV1DBModel(TGOV1Model): + """ + Model TGOV1 with deadband. + """ + def __init__(self, system, config): TGOV1Model.__init__(self, system, config) self.DB = DeadBand1(u=self.wd, center=0.0, lower=self.dbL, @@ -119,6 +127,19 @@ def __init__(self, system, config): self.pout.e_str = '(LL_y + Dt * DB_y) - pout' +class TGOV1NDBModel(TGOV1DBModel): + """ + Implementation of TGOV1NDB + """ + + def __init__(self, system, config): + TGOV1DBModel.__init__(self, system, config) + self.pref.v_str = 'tm0' + self.pref.e_str = 'pref0 - pref' + + self.pd.e_str = 'ue*(DB_y * gain + pref + paux) - pd' + + class TGOV1ModelAlt(TGBase): """ An alternative implementation of TGOV1 from equations @@ -211,3 +232,13 @@ class TGOV1DB(TGOV1DBData, TGOV1DBModel): def __init__(self, system, config): TGOV1DBData.__init__(self) TGOV1DBModel.__init__(self, system, config) + + +class TGOV1NDB(TGOV1DBData, TGOV1NDBModel): + """ + TGOV1N turbine governor model with speed input deadband. + """ + + def __init__(self, system, config): + TGOV1DBData.__init__(self) + TGOV1NDBModel.__init__(self, system, config) From 99123d3f5ceefaecbf7a204998b94164dcec7115 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Tue, 12 Oct 2021 21:28:57 -0500 Subject: [PATCH 44/58] Added latex prints for ones and zeros. --- andes/core/model.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/andes/core/model.py b/andes/core/model.py index 5e1a35128..2f1a97e5b 100644 --- a/andes/core/model.py +++ b/andes/core/model.py @@ -622,7 +622,9 @@ def __init__(self, system=None, config=None): self.tex_names = OrderedDict((('dae_t', 't_{dae}'), ('sys_f', 'f_{sys}'), - ('sys_mva', 'S_{b,sys}') + ('sys_mva', 'S_{b,sys}'), + ('__ones', 'O_{nes}'), + ('__zeros', 'Z_{eros}'), )) # Model behavior flags From d4c895151349b16cee96ac2fadcbc08998042afd Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 13 Oct 2021 16:01:48 -0500 Subject: [PATCH 45/58] Added a fix for `Piecewise` code generation so that both original equation and its derivative can compile with numba. --- andes/core/symprocessor.py | 10 ++++++++- andes/utils/__init__.py | 3 ++- andes/utils/sympy.py | 42 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 53 insertions(+), 2 deletions(-) create mode 100644 andes/utils/sympy.py diff --git a/andes/core/symprocessor.py b/andes/core/symprocessor.py index 80a28a9fc..8b97b12a4 100644 --- a/andes/core/symprocessor.py +++ b/andes/core/symprocessor.py @@ -5,8 +5,9 @@ import os import logging import pprint - +import sympy import numpy as np + from collections import OrderedDict, defaultdict from sympy import Symbol, Matrix @@ -16,6 +17,10 @@ from andes.core.npfunc import safe_div from andes.shared import dilled_vars from andes.utils.paths import get_pycode_path +from andes.utils.sympy import fixPiecewise + + +sympy.Piecewise = fixPiecewise logger = logging.getLogger(__name__) @@ -391,6 +396,9 @@ def generate_pycode(self, pycode_path, yapf_pycode): header = \ """from collections import OrderedDict # NOQA +import numpy + + from numpy import nan, pi, sin, cos, tan, sqrt, exp, select # NOQA from numpy import greater_equal, less_equal, greater, less, equal # NOQA from numpy import logical_and, logical_or, logical_not # NOQA diff --git a/andes/utils/__init__.py b/andes/utils/__init__.py index 8c5624983..cebc1e494 100644 --- a/andes/utils/__init__.py +++ b/andes/utils/__init__.py @@ -1,2 +1,3 @@ -from andes.utils import paths # NOQA +from andes.utils import paths # NOQA +from andes.utils import sympy # NOQA from andes.utils.paths import get_case # NOQA \ No newline at end of file diff --git a/andes/utils/sympy.py b/andes/utils/sympy.py new file mode 100644 index 000000000..d38f1b162 --- /dev/null +++ b/andes/utils/sympy.py @@ -0,0 +1,42 @@ +import sympy as sym + + +class fixPiecewise(sym.Piecewise): + """ + A derived Piecewise that fixes the printing of ``select`` to allow compilation with numba. + + See: https://github.com/sympy/sympy/issues/15014 + """ + + def _numpycode(expr, printer): + """ + Updated numpy code printer. + """ + + # find any symbol: + s = list(expr.atoms(sym.Symbol))[0] + + def broadcastarg(arg): + if arg.has(sym.Symbol): + return printer._print(arg) + elif arg == 0: + return printer._print(sym.Symbol(printer._module+'.zeros_like({0})'.format(s))) + else: + return printer._print(arg*sym.Symbol(printer._module+'.ones_like({0})'.format(s))) + + def broadcastcond(cond): + if cond.has(sym.Symbol): + return printer._print(cond) + else: + return printer._module+'.full({0}.shape,{1})'.format(printer._print(s), printer._print(cond)) + + "Piecewise function printer" + exprs = '[{}]'.format(','.join(broadcastarg(arg.expr) for arg in expr.args)) + conds = '[{}]'.format(','.join(broadcastcond(arg.cond) for arg in expr.args)) + # If [default_value, True] is a (expr, cond) sequence in a Piecewise object + # it will behave the same as passing the 'default' kwarg to select() + # *as long as* it is the last element in expr.args. + # If this is not the case, it may be triggered prematurely. + return '{}({}, {}, default={})'.format( + printer._module_format(printer._module + '.select'), conds, exprs, + printer._print(sym.S.NaN)) From 617dc0eedbaf1b1be9d9e3442870c6b98004958c Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 13 Oct 2021 16:20:55 -0500 Subject: [PATCH 46/58] Updated release notes. --- docs/source/release-notes.rst | 24 +++++++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/docs/source/release-notes.rst b/docs/source/release-notes.rst index 9f0660c5e..3c5401f90 100644 --- a/docs/source/release-notes.rst +++ b/docs/source/release-notes.rst @@ -9,8 +9,30 @@ The APIs before v3.0.0 are in beta and may change without prior notice. v1.4 Notes ---------- -v1.4.5 (2021-10-xx) +v1.5.0 (2021-10-13) ``````````````````` +- Support numba just-in-time compilation of all equation and Jacobian calls. + +This option accelerates simulations by up to 30%. +The acceleration is visible in medium-scale systems with multiple models. +Such systems involve heavy function calls but rather moderate load +for linear equation solvers. +The speed up is less significant in large-scale systems where +solving equations is the major time consumer. + +Numba is required an can be installed with ``pip install numba`` or +``conda install numba``. + +To turn on numba for ANDES, in the ANDES configuration under ``[System]``, +set ``numba = 1`` and ``numba_cache = 1``. + +Just-in-time compilation will compile the code upon the first execution +based on the input types. +When compilation is triggered, ANDES may appear frozen due to the compilation +lag. +The option ``numba_cache = 1`` will cache compiled machine code, so that +the compilation lag only occurs once until the next ``andes prep``. + - Allow ``BackRef`` to populate to models through ``Group``. When model `A` stores an ``IdxParam`` pointing to a group, if ``BackRef`` From 88702f655b0e55be166c8a925f32940c65581f9c Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 13 Oct 2021 17:21:28 -0500 Subject: [PATCH 47/58] Removed `troubleshooting.rst` and consolidated contents into `faq.rst`. --- docs/source/faq.rst | 15 +++++++++ docs/source/index.rst | 7 ++-- docs/source/troubleshooting.rst | 59 --------------------------------- 3 files changed, 18 insertions(+), 63 deletions(-) delete mode 100644 docs/source/troubleshooting.rst diff --git a/docs/source/faq.rst b/docs/source/faq.rst index 4f1ca8dcb..31f99a4c4 100644 --- a/docs/source/faq.rst +++ b/docs/source/faq.rst @@ -4,6 +4,21 @@ Frequently Asked Questions ************************** +Program Startup +=============== + +Q: Why do I get an "ImportError: DLL load failed" when running ANDES? + +Platform: Windows, error message: + + ImportError: DLL load failed: The specified module could not be found. + +This usually happens when andes is not installed in a Conda environment +but instead in a system-wide Python whose library path was not correctly +set in environment variables. + +The easiest fix is to install andes in a Conda environment. + General ======= diff --git a/docs/source/index.rst b/docs/source/index.rst index 94487128f..a48657fe6 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -74,12 +74,11 @@ See the GitHub repository for a full list of contributors. tutorial.rst modeling.rst cases.rst - modelref.rst - configref.rst + release-notes.rst faq.rst - troubleshooting.rst misc.rst - release-notes.rst + modelref.rst + configref.rst copyright.rst diff --git a/docs/source/troubleshooting.rst b/docs/source/troubleshooting.rst deleted file mode 100644 index 28670b6cb..000000000 --- a/docs/source/troubleshooting.rst +++ /dev/null @@ -1,59 +0,0 @@ -.. _troubleshooting: - -************************** -Troubleshooting -************************** - -Import Errors -============= - -ImportError: DLL load failed ----------------------------- - -Platform: Windows, error message: - - ImportError: DLL load failed: The specified module could not be found. - -This usually happens when andes is not installed in a Conda environment -but instead in a system-wide Python whose library path was not correctly -set in environment variables. - -The easiest fix is to install andes in a Conda environment. - - -Runtime Errors -============== - -EOFError: Ran out of input --------------------------- - -The error message looks like :: - - Traceback (most recent call last): - File "/home/user/miniconda3/envs/andes/bin/andes", line 11, in - load_entry_point('andes', 'console_scripts', 'andes')() - File "/home/user/repos/andes/andes/cli.py", line 179, in main - return func(cli=True, **vars(args)) - File "/home/user/repos/andes/andes/main.py", line 514, in run - system = run_case(cases[0], codegen=codegen, **kwargs) - File "/home/user/repos/andes/andes/main.py", line 304, in run_case - system = load(case, codegen=codegen, **kwargs) - File "/home/user/repos/andes/andes/main.py", line 284, in load - system.undill() - File "/home/user/repos/andes/andes/system.py", line 980, in undill - loaded_calls = self._load_pkl() - File "/home/user/repos/andes/andes/system.py", line 963, in _load_pkl - loaded_calls = dill.load(f) - File "/home/user/miniconda3/envs/andes/lib/python3.7/site-packages/dill/_dill.py", line 270, in load - return Unpickler(file, ignore=ignore, **kwds).load() - File "/home/user/miniconda3/envs/andes/lib/python3.7/site-packages/dill/_dill.py", line 473, in load - obj = StockUnpickler.load(self) - EOFError: Ran out of input - -Resolution: - -The error indicates the file for generated code is corrupt or inaccessible. -It can be fixed by running ``andes prepare`` from the command line. - -If the issue persists, try removing ``~/.andes/calls.pkl`` and running -``andes prepare`` agian. \ No newline at end of file From 28eef752aa779bce4682d68ad71209521602eafb Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 13 Oct 2021 17:21:34 -0500 Subject: [PATCH 48/58] Added notes for `numba`. --- docs/source/install.rst | 33 ++++++++++++++++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git a/docs/source/install.rst b/docs/source/install.rst index 02d2b4d7b..0d5f74cb7 100644 --- a/docs/source/install.rst +++ b/docs/source/install.rst @@ -188,8 +188,39 @@ KVXOPT contains inplace add and set functions for sparse matrix contributed by CURENT. These inplace functions significantly speed up large-scale system simulations. -To install ``KVXOPT`` run +To install ``KVXOPT``, run the following command in the terminal or Anaconda Prompt .. code:: bash python -m pip install kvxopt + +numba +----- + +.. note:: + + Numba is supported starting from ANDES 1.5.0. + +Numba is allows numerical functions calls to be compiled into machine code. +It can accelerates simulations by as high as 30%. +The speed up is visible in medium-scale systems with multiple models. +Such systems involve heavy function calls but rather moderate load +for linear equation solvers. +It is is less significant in large-scale systems where +solving equations is the major time consumer. + +To install ``numba``, run the following command in the terminal or Anaconda Prompt + +.. code:: bash + + python -m pip install numba + +Numba needs to be turned on manually. See the tutorial for editing ANDES configuration. +To turn on numba for ANDES, in the ANDES configuration under ``[System]``, +set ``numba = 1`` and ``numba_cache = 1``. + +Just-in-time compilation will compile the code upon the first execution +based on the input types. +When compilation is triggered, ANDES may appear frozen due to the compilation lag. +The option ``numba_cache = 1`` will cache compiled machine code, so that +the compilation lag only occurs once until the next code generation. From 887aecf5b24e8ebd0493660f7f790e4545d2c2df Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 13 Oct 2021 17:22:10 -0500 Subject: [PATCH 49/58] Improved the print of zeros. --- andes/utils/sympy.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/andes/utils/sympy.py b/andes/utils/sympy.py index d38f1b162..89172e25d 100644 --- a/andes/utils/sympy.py +++ b/andes/utils/sympy.py @@ -20,7 +20,7 @@ def broadcastarg(arg): if arg.has(sym.Symbol): return printer._print(arg) elif arg == 0: - return printer._print(sym.Symbol(printer._module+'.zeros_like({0})'.format(s))) + return printer._module+'.zeros_like({0})'.format(s) else: return printer._print(arg*sym.Symbol(printer._module+'.ones_like({0})'.format(s))) From fe636fc1902337e4ab9e8d68efaae330f0da9c6e Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 13 Oct 2021 17:39:41 -0500 Subject: [PATCH 50/58] Fixes the initialization of `vref`. --- andes/models/exciter/ac8b.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/andes/models/exciter/ac8b.py b/andes/models/exciter/ac8b.py index 2b85379c9..20574e8b2 100644 --- a/andes/models/exciter/ac8b.py +++ b/andes/models/exciter/ac8b.py @@ -167,6 +167,8 @@ def __init__(self, system, config): ExcVsum.__init__(self) + self.vref.v_str = 'v' + self.vi = Algeb(info='Total input voltages', tex_name='V_i', unit='p.u.', From e68a4f6c3b7cb0fdd728044d7d5d7823ba0e4a83 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 13 Oct 2021 17:45:25 -0500 Subject: [PATCH 51/58] Fixes initialization. --- andes/models/exciter/esdc2a.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/andes/models/exciter/esdc2a.py b/andes/models/exciter/esdc2a.py index 5c437b751..2384e455f 100644 --- a/andes/models/exciter/esdc2a.py +++ b/andes/models/exciter/esdc2a.py @@ -139,7 +139,7 @@ def __init__(self, system, config): self.vi = Algeb(info='Total input voltages', tex_name='V_i', unit='p.u.', - v_str='vref0 - v', + v_str='vfe0 / KA', e_str='(vref - v - WF_y) - vi', ) From 70d330cd29c088beed7b03bb41ea08f0e13d40ab Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 13 Oct 2021 17:55:44 -0500 Subject: [PATCH 52/58] Renamed first argument. --- andes/utils/sympy.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/andes/utils/sympy.py b/andes/utils/sympy.py index 89172e25d..5ac5534e9 100644 --- a/andes/utils/sympy.py +++ b/andes/utils/sympy.py @@ -8,13 +8,13 @@ class fixPiecewise(sym.Piecewise): See: https://github.com/sympy/sympy/issues/15014 """ - def _numpycode(expr, printer): + def _numpycode(self, printer): """ Updated numpy code printer. """ # find any symbol: - s = list(expr.atoms(sym.Symbol))[0] + s = list(self.atoms(sym.Symbol))[0] def broadcastarg(arg): if arg.has(sym.Symbol): @@ -31,11 +31,11 @@ def broadcastcond(cond): return printer._module+'.full({0}.shape,{1})'.format(printer._print(s), printer._print(cond)) "Piecewise function printer" - exprs = '[{}]'.format(','.join(broadcastarg(arg.expr) for arg in expr.args)) - conds = '[{}]'.format(','.join(broadcastcond(arg.cond) for arg in expr.args)) + exprs = '[{}]'.format(','.join(broadcastarg(arg.expr) for arg in self.args)) + conds = '[{}]'.format(','.join(broadcastcond(arg.cond) for arg in self.args)) # If [default_value, True] is a (expr, cond) sequence in a Piecewise object # it will behave the same as passing the 'default' kwarg to select() - # *as long as* it is the last element in expr.args. + # *as long as* it is the last element in self.args. # If this is not the case, it may be triggered prematurely. return '{}({}, {}, default={})'.format( printer._module_format(printer._module + '.select'), conds, exprs, From 12c729d9e9874c551db42fe7378a323541535896 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 13 Oct 2021 17:56:52 -0500 Subject: [PATCH 53/58] Refactor. --- andes/utils/sympy.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/andes/utils/sympy.py b/andes/utils/sympy.py index 5ac5534e9..32eb032fc 100644 --- a/andes/utils/sympy.py +++ b/andes/utils/sympy.py @@ -19,18 +19,19 @@ def _numpycode(self, printer): def broadcastarg(arg): if arg.has(sym.Symbol): return printer._print(arg) - elif arg == 0: + if arg == 0: return printer._module+'.zeros_like({0})'.format(s) - else: - return printer._print(arg*sym.Symbol(printer._module+'.ones_like({0})'.format(s))) + + return printer._print(arg*sym.Symbol(printer._module+'.ones_like({0})'.format(s))) def broadcastcond(cond): if cond.has(sym.Symbol): return printer._print(cond) - else: - return printer._module+'.full({0}.shape,{1})'.format(printer._print(s), printer._print(cond)) - "Piecewise function printer" + return printer._module+'.full({0}.shape,{1})'.format(printer._print(s), printer._print(cond)) + + # Piecewise function printer + exprs = '[{}]'.format(','.join(broadcastarg(arg.expr) for arg in self.args)) conds = '[{}]'.format(','.join(broadcastcond(arg.cond) for arg in self.args)) # If [default_value, True] is a (expr, cond) sequence in a Piecewise object From e84b24ee2f391d36bdcd0cd7c767e123940cf76d Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 13 Oct 2021 17:56:58 -0500 Subject: [PATCH 54/58] Removed unused code. --- andes/models/exciter/esst1a.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/andes/models/exciter/esst1a.py b/andes/models/exciter/esst1a.py index f5fd298e3..fa9548703 100644 --- a/andes/models/exciter/esst1a.py +++ b/andes/models/exciter/esst1a.py @@ -6,7 +6,7 @@ from andes.core.block import LagAntiWindup, Lag, HVGate, LVGate, GainLimiter from andes.core.block import LeadLag, Washout -from andes.models.exciter.excbase import ExcBase, ExcBaseData, ExcVsum, ExcACSat +from andes.models.exciter.excbase import ExcBase, ExcBaseData, ExcVsum class ESST1AData(ExcBaseData): @@ -107,7 +107,7 @@ def __init__(self): ) -class ESST1AModel(ExcBase, ExcVsum, ExcACSat): +class ESST1AModel(ExcBase, ExcVsum): """ Implementation of the ESST1A model. """ From 3081b0db7d6195e49817634f9aafd680e99b88b2 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 13 Oct 2021 19:43:21 -0500 Subject: [PATCH 55/58] Renamed `ll` and `ul` to `llim` and `ulim` to avoid name clash. --- andes/models/exciter/esst1a.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/andes/models/exciter/esst1a.py b/andes/models/exciter/esst1a.py index fa9548703..0cc0ce2c8 100644 --- a/andes/models/exciter/esst1a.py +++ b/andes/models/exciter/esst1a.py @@ -120,8 +120,8 @@ def __init__(self, system, config): self.UEL0.v_str = '-999' self.OEL0.v_str = '999' - self.ul = ConstService('9999') - self.ll = ConstService('-9999') + self.ulim = ConstService('9999') + self.llim = ConstService('-9999') self.SWUEL = Switcher(u=self.UELc, options=[0, 1, 2, 3], tex_name='SW_{UEL}', cache=True) self.SWVOS = Switcher(u=self.VOSc, options=[0, 1, 2], tex_name='SW_{VOS}', cache=True) @@ -139,7 +139,7 @@ def __init__(self, system, config): self.zero = ConstService('0') self.LR = GainLimiter(u='XadIfd - ILR', K=self.KLR, R=1, - upper=self.ul, lower=self.zero, + upper=self.ulim, lower=self.zero, no_upper=True, info='Exciter output current gain limiter', ) @@ -173,8 +173,8 @@ def __init__(self, system, config): self.UEL2 = Algeb(tex_name='UEL_2', info='UEL_2 as HVG1 u1', - v_str='ue * (SWUEL_s2 * UEL + (1 - SWUEL_s2) * ll)', - e_str='ue * (SWUEL_s2 * UEL + (1 - SWUEL_s2) * ll - UEL2)', + v_str='ue * (SWUEL_s2 * UEL + (1 - SWUEL_s2) * llim)', + e_str='ue * (SWUEL_s2 * UEL + (1 - SWUEL_s2) * llim - UEL2)', ) self.HVG1 = HVGate(u1=self.UEL2, u2=self.vil_y, @@ -212,8 +212,8 @@ def __init__(self, system, config): self.UEL3 = Algeb(tex_name='UEL_3', info='UEL_3 as HVG u1', - v_str='ue * (SWUEL_s3 * UEL + (1 - SWUEL_s3) * ll)', - e_str='ue * (SWUEL_s3 * UEL + (1 - SWUEL_s3) * ll - UEL3)', + v_str='ue * (SWUEL_s3 * UEL + (1 - SWUEL_s3) * llim)', + e_str='ue * (SWUEL_s3 * UEL + (1 - SWUEL_s3) * llim - UEL3)', ) self.HVG = HVGate(u1=self.UEL3, u2=self.vas, From bf312c987ad74780a93793150b0dc4ec05895477 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 13 Oct 2021 19:44:06 -0500 Subject: [PATCH 56/58] Renamed to `FixPiecewise`. --- andes/core/symprocessor.py | 4 ++-- andes/utils/sympy.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/andes/core/symprocessor.py b/andes/core/symprocessor.py index 8b97b12a4..6e92f3da2 100644 --- a/andes/core/symprocessor.py +++ b/andes/core/symprocessor.py @@ -17,10 +17,10 @@ from andes.core.npfunc import safe_div from andes.shared import dilled_vars from andes.utils.paths import get_pycode_path -from andes.utils.sympy import fixPiecewise +from andes.utils.sympy import FixPiecewise -sympy.Piecewise = fixPiecewise +sympy.Piecewise = FixPiecewise logger = logging.getLogger(__name__) diff --git a/andes/utils/sympy.py b/andes/utils/sympy.py index 32eb032fc..89d36ed0b 100644 --- a/andes/utils/sympy.py +++ b/andes/utils/sympy.py @@ -1,7 +1,7 @@ import sympy as sym -class fixPiecewise(sym.Piecewise): +class FixPiecewise(sym.Piecewise): """ A derived Piecewise that fixes the printing of ``select`` to allow compilation with numba. From dbca61d269e62707b4f14dc2e97da642430da704 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 13 Oct 2021 19:59:36 -0500 Subject: [PATCH 57/58] Style fix. --- andes/models/exciter/esst1a.py | 4 ++++ andes/models/vcomp/__init__.py | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/andes/models/exciter/esst1a.py b/andes/models/exciter/esst1a.py index 0cc0ce2c8..b0f2c2c34 100644 --- a/andes/models/exciter/esst1a.py +++ b/andes/models/exciter/esst1a.py @@ -1,3 +1,7 @@ +""" +ESST3A model. +""" + from andes.core.param import NumParam from andes.core.var import Algeb, ExtAlgeb diff --git a/andes/models/vcomp/__init__.py b/andes/models/vcomp/__init__.py index 45e9b0c70..d87c975e8 100644 --- a/andes/models/vcomp/__init__.py +++ b/andes/models/vcomp/__init__.py @@ -1 +1,5 @@ +""" +Voltage compensators. +""" + from andes.models.vcomp.ieeevc import IEEEVC # NOQA From 701628efd4ad3f11cd2ff720ca4381a577a91990 Mon Sep 17 00:00:00 2001 From: Hantao Cui Date: Wed, 13 Oct 2021 20:14:19 -0500 Subject: [PATCH 58/58] Added notes. --- andes/models/renewable/regcvsg2.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/andes/models/renewable/regcvsg2.py b/andes/models/renewable/regcvsg2.py index 50d1bdd74..15a8febad 100644 --- a/andes/models/renewable/regcvsg2.py +++ b/andes/models/renewable/regcvsg2.py @@ -28,7 +28,7 @@ class REGCVSG2(REGCVSGData, VSGOuterPIData, VSGInnerLagData, """ Voltage-controlled VSC with VSG control. - PI controllers are replaced with lag transfer functions. + The inner-loop current PI controllers are replaced with lag transfer functions. """ def __init__(self, system, config):