Repository: CURENT/andes (language: python)

Issue:
Model IEEEVC
Developed voltage compensator model ``IEEEVC``.


Discussion / hints:

Fix patch:
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
 
diff --git a/andes/cases/ieee14/ieee14_esst1a.xlsx b/andes/cases/ieee14/ieee14_esst1a.xlsx
index e7cadb7be..09bd3dffe 100644
Binary files a/andes/cases/ieee14/ieee14_esst1a.xlsx and b/andes/cases/ieee14/ieee14_esst1a.xlsx differ
diff --git a/andes/cases/ieee14/ieee14_ieeevc.xlsx b/andes/cases/ieee14/ieee14_ieeevc.xlsx
new file mode 100644
index 000000000..538965472
Binary files /dev/null and b/andes/cases/ieee14/ieee14_ieeevc.xlsx differ
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/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)
diff --git a/andes/core/model.py b/andes/core/model.py
index 3bd1b36b1..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
@@ -792,6 +794,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.
@@ -955,6 +968,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.
@@ -1263,16 +1282,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
 
@@ -1673,12 +1686,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)
diff --git a/andes/core/symprocessor.py b/andes/core/symprocessor.py
index 8a0c7ad78..6e92f3da2 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__)
 
@@ -129,10 +134,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
@@ -221,7 +230,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
 
@@ -371,6 +382,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)
@@ -379,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/core/var.py b/andes/core/var.py
index 8267436b7..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):
@@ -451,6 +467,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/__init__.py b/andes/models/__init__.py
index f2d5a8ad3..ead309892 100644
--- a/andes/models/__init__.py
+++ b/andes/models/__init__.py
@@ -23,10 +23,12 @@
     ('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',
-                 '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..898585a3e 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 andes.models.exciter.saturation import ExcQuadSat, ExcExpSat  # NOQA
diff --git a/andes/models/exciter/ac8b.py b/andes/models/exciter/ac8b.py
index ae7d7fc4c..20574e8b2 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.',
                             )
@@ -169,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.',
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/esdc2a.py b/andes/models/exciter/esdc2a.py
index d2d9c3960..2384e455f 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,22 +124,22 @@ 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',
                         unit='p.u.',
-                        v_str='vref0 - v',
+                        v_str='vfe0 / KA',
                         e_str='(vref - v - WF_y) - vi',
                         )
 
diff --git a/andes/models/exciter/esst1a.py b/andes/models/exciter/esst1a.py
new file mode 100644
index 000000000..b0f2c2c34
--- /dev/null
+++ b/andes/models/exciter/esst1a.py
@@ -0,0 +1,288 @@
+"""
+ESST3A model.
+"""
+
+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
+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
+
+
+class ESST1AData(ExcBaseData):
+    """
+    ESST1A data.
+    """
+
+    def __init__(self):
+        ExcBaseData.__init__(self)
+        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=r'V_{IMAX}',
+                              )
+        self.VIMIN = NumParam(default=-0.1,
+                              info='Min. input voltage',
+                              tex_name=r'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.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.VAMAX = NumParam(info='V_A upper limit',
+                              tex_name=r'V_{AMAX}',
+                              default=999,
+                              unit='p.u.')
+        self.VAMIN = NumParam(info='V_A lower limit',
+                              tex_name=r'V_{AMIN}',
+                              default=-999,
+                              unit='p.u.')
+
+        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.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}',
+                            )
+
+        self.VRMAX = NumParam(info='Maximum voltage regulator output limit',
+                              tex_name=r'V_{RMAX}',
+                              default=7.3,
+                              unit='p.u.',)
+        self.VRMIN = NumParam(info='Minimum voltage regulator output limit',
+                              tex_name=r'V_{RMIN}',
+                              default=-7.3,
+                              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_{F}',
+                           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_c',
+                             default=1,
+                             )
+        self.VOSc = NumParam(info='Alternate Stabilizer inputs, input code 1-2',
+                             tex_name='VOS_c',
+                             default=1,
+                             )
+
+
+class ESST1AModel(ExcBase, ExcVsum):
+    """
+    Implementation of the ESST1A model.
+    """
+
+    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.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)
+
+        # control block begin
+        self.LG = Lag(self.v, T=self.TR, K=1,
+                      info='Voltage transducer',
+                      )
+        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.zero = ConstService('0')
+        self.LR = GainLimiter(u='XadIfd - ILR',
+                              K=self.KLR, R=1,
+                              upper=self.ulim, 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.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_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 = 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',
+                          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,
+                           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.vas = Algeb(tex_name=r'V_{As}',
+                         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',
+                          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,
+                          info='HVGate for under excitation',
+                          )
+
+        self.LVG = LVGate(u1=self.HVG_y,
+                          u2=self.OEL,
+                          info='HVGate for over 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',
+                           )
+
+        self.efdu = VarService(info='Output exciter voltage upper bound',
+                               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=r'efd_{l}',
+                               v_str='Abs(vd + 1j*vq) * VRMIN'
+                               )
+
+        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,
+                          K=self.KF,
+                          info='V_F, Stablizing circuit feedback',
+                          )
+
+        self.vout.e_str = 'ue * (vol_y  - 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)
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/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..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
+from andes.core.service import 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 ed09ccd02..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
+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
@@ -28,11 +28,26 @@ 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'
         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',
@@ -103,12 +118,23 @@ 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.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='Input to exciter (bus v or Eterm)',
+                       tex_name='E_{term}',
+                       v_str='vbus',
+                       e_str='vbus - v',
+                       v_str_add=True,
+                       )
 
         # output excitation voltage
         self.vout = Algeb(info='Exciter final output voltage',
@@ -150,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/exst1.py b/andes/models/exciter/exst1.py
index d1605af96..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
+from andes.core.service import 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',
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 f09aa3c15..3cc26496d 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
@@ -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',
@@ -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,12 @@ 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 +205,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..166c6edaa 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/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)
diff --git a/andes/models/group.py b/andes/models/group.py
index 6e6cede2b..373d59e6c 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,9 +658,21 @@ def __init__(self):
         self.common_params.extend(('syn',))
         self.common_vars.extend(('vout', 'vi',))
 
+        self.VoltComp = BackRef()
         self.PSS = BackRef()
 
 
+class VoltComp(GroupBase):
+    """
+    Voltage compensator group for synchronous generators.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.common_params.extend(('rc', 'xc',))
+        self.common_vars.extend(('vcomp',))
+
+
 class PSS(GroupBase):
     """Power system stabilizer group."""
 
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}',
                               )
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):
diff --git a/andes/models/vcomp/__init__.py b/andes/models/vcomp/__init__.py
new file mode 100644
index 000000000..d87c975e8
--- /dev/null
+++ b/andes/models/vcomp/__init__.py
@@ -0,0 +1,5 @@
+"""
+Voltage compensators.
+"""
+
+from andes.models.vcomp.ieeevc import IEEEVC  # NOQA
diff --git a/andes/models/vcomp/ieeevc.py b/andes/models/vcomp/ieeevc.py
new file mode 100644
index 000000000..81b974605
--- /dev/null
+++ b/andes/models/vcomp/ieeevc.py
@@ -0,0 +1,120 @@
+from andes.core.model import ModelData, Model
+
+from andes.core.param import NumParam, IdxParam, ExtParam
+from andes.core.var import Algeb, ExtAlgeb
+
+from andes.core.service import VarService, ExtService
+
+
+class IEEEVCData(ModelData):
+    """
+    IEEEVC data.
+    """
+
+    def __init__(self):
+        ModelData.__init__(self)
+        self.avr = IdxParam(info='Exciter idx', mandatory=True, model='Exciter')
+
+        self.rc = NumParam(default=0.0,
+                           info="Active compensation degree.",
+                           z=True,
+                           tex_name='r_c'
+                           )
+        self.xc = NumParam(default=0.0,
+                           info="Reactive compensation degree.",
+                           z=True,
+                           tex_name='x_c'
+                           )
+
+
+class IEEEVCModel(Model):
+    """
+    Implementation of the IEEEVC model.
+    """
+
+    def __init__(self, system, config):
+        Model.__init__(self, system, config)
+        self.group = 'VoltComp'
+        self.flags.tds = True
+
+        # retrieve indices of connected generator, bus, and bus freq
+        self.syn = ExtParam(model='Exciter', src='syn', indexer=self.avr, export=False,
+                            info='Retrieved generator idx', vtype=str)
+
+        self.vf0 = ExtService(src='vf',
+                              model='SynGen',
+                              indexer=self.syn,
+                              tex_name=r'v_{f0}',
+                              info='Steady state excitation voltage')
+        # from Bus
+        self.v = ExtAlgeb(model='SynGen', src='v', indexer=self.syn, tex_name=r'V',
+                          info='Retrieved bus terminal voltage',
+                          )
+        # 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',
+                           )
+        self.Id = ExtAlgeb(src='Id',
+                           model='SynGen',
+                           indexer=self.syn,
+                           tex_name=r'I_d',
+                           info='d-axis machine current',
+                           )
+        self.Iq = ExtAlgeb(src='Iq',
+                           model='SynGen',
+                           indexer=self.syn,
+                           tex_name=r'I_q',
+                           info='q-axis machine current',
+                           )
+
+        self.vct = VarService(tex_name=r'V_{CT}',
+                              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='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):
+    """
+    Voltage compensator IEEEVC model.
+
+    Reference:
+
+    [1] PowerWorld, Voltage Compensator, IEEEVC, [Online],
+
+    [2] NEPLAN, Exciters Models, [Online],
+
+    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):
+        IEEEVCData.__init__(self)
+        IEEEVCModel.__init__(self, system, config)
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()
 
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)
 
diff --git a/andes/system.py b/andes/system.py
index e13f6eb36..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:
@@ -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):
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..89d36ed0b
--- /dev/null
+++ b/andes/utils/sympy.py
@@ -0,0 +1,43 @@
+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(self, printer):
+        """
+        Updated numpy code printer.
+        """
+
+        # find any symbol:
+        s = list(self.atoms(sym.Symbol))[0]
+
+        def broadcastarg(arg):
+            if arg.has(sym.Symbol):
+                return printer._print(arg)
+            if arg == 0:
+                return printer._module+'.zeros_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)
+
+            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
+        #     it will behave the same as passing the 'default' kwarg to select()
+        #     *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,
+            printer._print(sym.S.NaN))
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/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.
diff --git a/docs/source/release-notes.rst b/docs/source/release-notes.rst
index 293b3ae89..3c5401f90 100644
--- a/docs/source/release-notes.rst
+++ b/docs/source/release-notes.rst
@@ -9,6 +9,56 @@ The APIs before v3.0.0 are in beta and may change without prior notice.
 v1.4 Notes
 ----------
 
+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``
+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.
+
+- 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.
+
 v1.4.3 (2021-09-25)
 ```````````````````
 This release features parallel processing that cuts the time for
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 <module>
-        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
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": [
       "<Toggler Toggler_1>: Line.Line_1 status changed to 0 at t=1.0 sec.    \n",
       "<Toggler Toggler_2>: 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": [
-       "(<Figure size 600x400 with 1 Axes>, <AxesSubplot:xlabel='Time [s]'>)"
-      ]
-     },
-     "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": [
        "<Figure size 600x400 with 1 Axes>"
       ]
@@ -293,14 +265,15 @@
        "(<Figure size 600x400 with 1 Axes>, <AxesSubplot:xlabel='Time [s]'>)"
       ]
      },
-     "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": [
       "<Toggler Toggler_1>: Line.Line_1 status changed to 0 at t=1.0 sec.    \n",
       "<Toggler Toggler_2>: 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": [
-       "(<Figure size 600x400 with 1 Axes>, <AxesSubplot:xlabel='Time [s]'>)"
-      ]
-     },
-     "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": [
        "<Figure size 600x400 with 1 Axes>"
       ]
@@ -290,14 +262,15 @@
        "(<Figure size 600x400 with 1 Axes>, <AxesSubplot:xlabel='Time [s]'>)"
       ]
      },
-     "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": [
       "<Toggler Toggler_1>: Line.Line_1 status changed to 0 at t=1.0 sec.    \n",
       "<Toggler Toggler_2>: 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": [
-       "(<Figure size 600x400 with 1 Axes>, <AxesSubplot:xlabel='Time [s]'>)"
-      ]
-     },
-     "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": [
        "<Figure size 600x400 with 1 Axes>"
       ]
@@ -294,14 +266,15 @@
        "(<Figure size 600x400 with 1 Axes>, <AxesSubplot:xlabel='Time [s]'>)"
       ]
      },
-     "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.4 demo_ESST1A.ipynb b/examples/demonstration/2.4 demo_ESST1A.ipynb
new file mode 100644
index 000000000..9312a3722
--- /dev/null
+++ b/examples/demonstration/2.4 demo_ESST1A.ipynb
@@ -0,0 +1,381 @@
+{
+ "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"
+    },
+    "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 \"~/.andes/pycode\".\n",
+      "Parsing input file \"/Users/jinningwang/Documents/work/andes/andes/cases/ieee14/ieee14_esst1a.xlsx\"...\n",
+      "Input file parsed in 0.3120 seconds.\n",
+      "System internal structure set up in 0.0222 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.0056 seconds.\n",
+      "Initialization for dynamics completed in 0.0226 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": [
+      "<Toggler Toggler_1>: Line.Line_1 status changed to 0 at t=1.0 sec.    \n",
+      "<Toggler Toggler_2>: Line.Line_1 status changed to 1 at t=1.1 sec.    \n",
+      "100%|████████████████████████████████| 100/100 [00:01<00:00, 65.48%/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Simulation completed in 1.5276 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": [
+       "<Figure size 600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAFwCAYAAACFGhBLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAA9hAAAPYQGoP6dpAABAEklEQVR4nO3deXxjV2H3/8/R4nVsy541s2bkkD0k8cyErM1T4gHC1gQ8mZbSB2jLuFD6agP87M7T0lJ4ng42KS1QCnZKWBuSzJQlBVJqJxBIk0AyJmkWslmTZNZ4Zjzyvkk6vz905ZFk2ZYsy7I83/fr5Zete+69Olfytb4+59xzjbUWERERkXxw5bsCIiIicuZSEBEREZG8URARERGRvFEQERERkbxREBEREZG8URARERGRvFEQERERkbzx5LsCuWaMMcBaYCDfdRERESlAFcARm6OJx5Z8ECEaQg7luxIiIiIFbD1wOBc7PhOCyADAwYMHqayszHddRERECkZ/fz8bNmyAHPYqnAlBBIDKykoFERERkUVGg1VFREQkbxREREREJG8URERERCRvFEREREQkbxREREREJG/OmKtmREQkO9ZawuEwoVAo31WRLHm9Xtxud76rASiIiIjILKy1BINBjh8/Tjgcznd1ZJ74fD7WrFlDdALy/FEQERGRGR07doxgMDg5H5PH48n7h5fMnbWW4eFhenp6ADjrrLPyWh8FERERmVY4HKavr4+VK1eyYsWKfFdH5klpaSkAPT09rFq1Kq/dNBqsKiIi05qYmMBaS3l5eb6rIvOsrKwMiL7H+aQgssB+c7SfOx46QDiSk5sYiojkhLpilp7F8p6qa2aBfeL7T/P4K6d4rX+U3W+9IN/VERERySu1iCygw8ER9r96ilKvmx89dTTf1REREck7BZEF9KsDJ7EW/u9NF3Po1AivnhzOd5VERM5ora2tVFdXU1tbS2tr65Tyffv2YYxh+/btdHV1pdxHIBCgubkZY8zkflpbW2lubmbHjh0p9yunqWtmAXX3DLGmsoT6C1fjMvBo4CQbl5flu1oiImespqYmOjo68Pv9NDU1TSlvaGigqamJlpaWaffh9/tpaWmhq6uLurq6KfvZsmUL3d3dtLW1zXv9U2lubqa2thaAmpoaGhoaFuR550pBZAF1Hx+kdlU5VaVeNi0v57ljA/mukojIGc/v9xMIBFKWtba2zhhC0tHY2EhjY2POg0gwGOSGG27g/vvvx+fz0dXVxZYtW7B2cV8coa6ZBdR9fJDalcsAqF25jJeOD+a5RiIiUltbmzKIxFo4CkVzczM7d+7E5/MBUFdXR0dHR34rlQa1iCyQcMTy8olhfv8NmwA4Z9Uy/uPJI3mulYjI3I2Mh+leJP9Q1a5cRmnR3Cblmq5FpLOzM2V3TaZaWloS9tPV1UVzczOBQIDu7m4gGiLa29tpaWlh165dALS3t+P3+wkGgwQCAXw+32RZKu3t7XR3dxMIBAgEAtTX11NfX591/XNNQWSB9AyMMh6OsLEmOiakdmU5h4MjDI+HKCvS2yAihaf7+CBv/+JD+a4GAD/8s2u5eF3VnLb1+/1AtGsj1pqwb9++GT/0p9PV1cW+ffuA6CDWjo4OmpubE/ZVV1dHc3MzjY2Nk8tiY0xiYvuIBYlAIEBnZ+e0zxsLUl1dXfj9fvx+P42NjezYsWPRhxF9Ai6Qnv4xAFYuK4JImHNWRbtoAseH5nzyiIjkU+3KZfzwz67NdzUAJru95yIWRAKBAHV1dQSDQXp7eydDSSbq6uoSBofW19fT3NyM3+9PCAQ1NTVTtk1+vr1793LLLbfg8/nw+/1s3bp12ueNBRGfzzfZndTS0sLmzZs5depUxsexkBREFkjPQDSIrAv+Eu78EOde+THgbA6dGlEQEZGCVFrkXhJ/v2IBIBZE2tvb56VLBqLBpKWlZfLKmVjomU1DQwNtbW1UV1dTV1fHzp0706pTfFjx+XwEg0E6OzsXdatIRkHEGOMDbgF2WGu3p7lNExB0Hvqsta1xZbH9AdQCfuCD1tpg0vaxcqy1p9uyCsjxgTFcBiov2A4H3knZo/9AhffzHDqluURERPItNk4kFx/asRaKtra2Ga/ACQaDCY87Ojro6uqis7Nz8oqb6cLIdAHH5/NNe0XQYpH2VTPGmDqiocEHTG1TSr1NE4C1tt1a2w50GWPir19qATqd8magF9gbt32LtbbV+Wp0li3+IcAp9AyM4i8fxz3eB29oxAyf5OZlz3I4OJLvqomInPH8fj/d3d05vVJm+fLlM5b39vZO/tze3g4wOS/J/v37ufvuu6fdNjYuJDl0BIPBGbt0FoO0g4i1tssJE5lEq91Ae9w+OoH40T9+IH6mlW5gK0y2ltQ532PagHpjTHptW4vI8YEx3ufpgC/UwcrzoaaWa93PcuiUgoiISL75/X7uueeeOQ1QnU1zc/OUK16SQ0PsyphYq0gwGJwMI/HbzKSlpSUhrOzbt4/6+vpFfwlyzsaIOGHBF9/NEldWb63tTNG9sw2IHxa8lWhYiQ0ljr1rvhmetxgojltUkVnNc6NnYIx3mZdhzSVgDJxTT1kgqCAiIrII1NbWcvvtt89pgGogEKCtrY3Ozk4CgcBky8fJkycnw8b+/fsT9u3z+WhpaaG1tXUyYNTX19PW1obf70+4eif2HLfffvuM9WhoaKC3t3dySvmTJ0+e8fOITBfdgqQIEsaYBmf5DgAnwFQnrRbruJupVWY38Ldp13KB9AyMsTnUDWucBqC3tvLUz7o59LOX8lsxERHJanBqbIr3TGdgTX7O+ZiKPRctOrmWj5lVe4kbY2KM8RljdhENLntTtaDE2Q00zrLOHqAq7mt9thWeD6ODp6iZOBZtEXGsr4Dx0WGGxkJ5rJmIiEj+5COIJAx0tdYGncGqrQDGmFNJ40JwlrcAdzvjVKZlrR2z1vbHvoBFcUOX4pEewsYLNU5D0cQIb//hNt7hfoRj/aP5rZyIiEie5DKITNd94gMCTktIS1Lo6HTKE66dcrptuuMv/S0koXCE/xldzb4bH4d1zuhlbynhirWcY45wrE9BREREzkw5CyLW2gAQTHWFi3P1jB9oIrGFxOd8D8YWGGPqnW3ance+Qrtqpn802vVSVVYMrtMvuVl5HueYQxxVEBERkTPUXIJIyjlEjDH+uMnHYvYQ17rhtGy0Q/RyYKDVCSwxO4EuJ6jE5i6pIzr/iN8JILuIjjMpGH0jE/yp+/ts+9WfJyx3rzqf89xHeE1dMyIicoZK+6oZJwQ0EA0Ldc6YjcestfucVeqBRmCy+8Ra22qMaXICCMC2pJlR9ySFFx9wg/N8PuB+Z1nCUORC66IJDo9zgetVSkJJuW/FuazlOD2n+vNTMRERkTxLO4g4LRetxAWNpPJ24iYvi1sev/6+pLLgDPsLMvXy3YIUHJlgnTmB8W1JLLhkBx96wk9kIJKfiomIiORZPq6aOeP0DU+wypzCW510JXFRGcurfRzr16RmIiJyZlIQWQB9w+OspA9P5erEAmtpPNjE5af+Kz8VExERyTMFkQUQHB7nY57dmPNuTCwwhuXjh9k0/iLjIXXPiIjImUdBZAEER0M8V74NfBunlE1UbmKj6dGVMyIiedDa2kp1dTW1tbWT92iJt2/fPowxbN++na6urhR7iN4Hprm5GWPM5H5aW1tpbm5mx44dKfcrp+XyXjPi8AYP8Mfh+2DkUij1JZS5ajaz8fADvNY/yoaasvxUUETkDNXU1ERHRwd+vz/l/WYaGhpoamqa8T4ysXvNdHV1UVdXN2U/W7Zsobu7m7a2tnmvf7L29naCwSA+n4/u7m527949pxv5LSQFkQVQM/A8O4e+DfbTU8pKVvnZaO7i/qAGrIqI5IPf75+8S26y1tbWjG9ml6yxsZHGxsacB5HW1lZ27do1GTyCwSAf/OAH2bt3b06fN1vqmlkAxWMnCeGB0qlXIxdf9Hb+0v4pPf3DeaiZiIjU1tamDCKxFo5C0dHRkdD64fP5CAaDeatPutQisgBKxnsZ8lZTZcyUMrPiHJ6uup6V/RN5qJmISJYGjkW/4pX6oPpsmBiF489N3WbtZdHvJ16E8aHEMt9GKKuBoRPQdyixrLgCltdCJAzHnjq9vGJN9GuOpmsR6ezsTNldk6mWlpaE/XR1ddHc3EwgEKC7uxuA5uZm2tvbaWlpYdeuXUC0m8Xv9xMMBgkEAvh8vsmyVHw+H9u3b2fv3r34fD4CgQB+/+K/I4qCyAIon+hlpKiaqlSF1vIB14858tplwIULWzERkWw9/jV48DOJyy65Bd59O/Qfhvbrp27zyb7o9+9/CA49llh2cztcuhOe+R78+OOJZbVvhD/4XjS8xO/3+r+E394950OIfVjHxlZAdJDqTB/60+nq6mLfvujcnYFAgI6ODpqbmxP2VVdXR3NzM42Npycaj40xiYnto76+fnJfnZ2dMz737bffzpYtW6iurqapqYna2toFGZeSLQWRBfBkxM/KlbWkzOvGcNPgPfwoNAS8Z4FrJiKSpa0fgOSpCWKD8ivXwa4Hp9/2pi+nbhEBuOhmWL8tsay4Ivq9qDxxv1m0hsDpIBIIBKirqyMYDNLb2zunQZ51dXU0NDRMPq6vr6e5uRm/3z8ZKgBqaqbeti35+fbu3cstt9yCz+fD7/ezdevWGZ/b5/PR3NxMR0cHra2t1NfXT26/mCmILIBvj1/P+nPP56ppygdK11E5fHhB6yQiMi9m6hbxlpzuhkllxeumLytfEf1KxeWeeb8Zin1Qx4JIe3v7vHTJQDSYtLS0TF45k25XSUNDA21tbVRXV1NXV8fOnTtnrVNzc/Nk10wgEGDHjh2Tz7uYabBqjo2HIqwPH6TGDE67zljFRlaEjhKJ2AWsmYiIxMTGiXR2dia0XMyH2IDX2bpJkgeWdnR0sH//fnbu3ElbW9uM85EEAgGCweBk3f1+P/v378fn80128yxWCiI5NjQW4ltFe7jo4J3TrmN9m1hvejgxNLaANRMRkRi/3093d3dOr5RZvnz5jOW9vb2TP7e3R+8hG5uXZP/+/dx9993TbhsbzJosfhzKYqUgkmODYyF8DOEqm9ofGGM2XsmD4Ut5LajZVUVE8sHv93PPPffMaYDqbJqbm6dc8ZJ8pU7syphYq0gwGJwMI/HbTKe+vp6urq4prSr79+9PGLOyGGmMSI4NDA6wwYzhKZ8+iCy7+EZ2/8BLe/8olyxg3UREJKq2tpbbb799TgM7A4EAbW1tdHZ2EggEJls+Tp48ORk2Yt0kMT6fj5aWFlpbWycDRn19PW1tbfj9/oSrd2LPcfvtt89Yj71797Jnzx6WL18+OYdItpOxLQRj7dIel2CMqQT6+vr6qKysXPDn73r6Wer2XcXRt32Ds7bdlHKdSDjMm//m6/zxm+rYef3lC1tBEZEZjI6OcuDAATZv3kxJSUm+qyPzKJ33tr+/n6qqKoAqa21/LuqhrpkcGxsKMmKLKK6cvm/QheU+78epPvDjBayZiIhI/imI5FhP8SYuGPs6pWdPd/Eu4PZwwr0KT/+rC1cxERGRRUBBJMcGRkO4DJQUuWdc71TxOsqHD824joiIyFKjIJJjZx28jx8V/R/MLGNxRsrWUz1+dIFqJSIisjgoiOSYd/gYG80xcM38UoeqNuIOj7DUBw+LiIjEUxDJMTPez7Apm3W9ntd/iBvGbqN/NLQAtRIRyYz+SVp6Fst7qiCSY67xQUZM+azrrakqBeBYnyY1E5HFw+v1YoxhaGho9pWloAwPDwPR9zifNKFZjnkmBhh1z94ismaZm/uLPsbEEx+Ft8z/zH4iInPhdrupqqri+PHjjI2NUVlZicfjwRiT76rJHFlrGR4epqenB5/Ph9s988UUuaYgkmP3V96E9fbzV7Ost8pXQY+ZYLzn2QWpl4hIutasWUNpaSk9PT309+dkTivJA5/Px5o109w5eQEpiOTYC2YzRRWz94AVeVy84trAWcGXFqBWIiLpM8bg8/moqqoiHA4TCmksW6Hzer15bwmJURDJsSuDP8RWbgC2zrruieKNnDe4P/eVEhGZA2MMHo8Hj0cfHTJ/NFg1x946+F0uGXksrXX7yv1Ujx+B0FiOayUiIrI4KIjkWFlkiIh3WVrrHlnzRv582T+AS/9tiIjImUFBJMdK7TCR4oq01q1etY4H+tdizexvi7WWXwZO8vBLJwhHFse14CIiIpnSv965FAlTzii2uDKt1TevKGdX5G76HztF1RW/N+16Y6EwH/p2Fw881wPAZRt8fO3926guL5qXaouIiCwUtYjkUnicH0auZrRyc1qrb15RzlWuZwk98x8zrveZ+57joZdO8NXfPZd7/vBSXu0dpvFb+9UyIiIiBUdBJIdCrmI+Mv4RBlZvS2v9DTVlPBXZTHHPE9Ou88JrA3zj4Zf5+JvO5YbII1zxnddzn//f+Z+Xj/KNh1+en4qLiIgsEAWRHBoeGWK9Oc4yT3otFSVeN6+WXsCykcMwdCLlOv/282f5UNkDfODqs+GCd0L937L65R9w34ov8E8/eYZXTw7P4xGIiIjkloJIDoUO/pqHiv+c5WOH0t5mcOVl0R8OT51PpG9kgtc99Q/8hf023qGjUOqDa/4c3vtdzh5+mk96v8mnf6SZWUVEpHAoiOTQ2OApADzlVWlvs2r9ubS7fw+WnzOl7Of3/4j3mP9i9LrdULX+dMGmqzBv+we2bqzg/meP8vMXjmdddxERkYWgIJJDoZHoPRmKy31pb3Phuir+fugdnCrZkLA8MjHGxV2f4GDpuVRc/2dTN9zyPja871/ZtnkFf3fv00yEI9lUXUREZEEoiORQeKSPiDWUlKU3jwjAhWdVUsEwfZ23wamXJ5e/2HkHG8KHGHjT58CV+v4Axhj+4cIAn+z/BN98SPesERGRxU9BJIfCowMMUkppsTftbTavKMdbVMzqp74Cj355cvlnX9vKrRW3cdHl18y4/fpN53CN6xlGH/gsJwY1VbyIiCxuGU1oZozxAbcAO6y129PcpgkIOg991trWFPsDqAX8wAettcF0tl/sXqx9P29+5EIeL0r/Dodul+Fy/1n8+MTbePf+r8PqizhONfc/7+Lvb96OMWbmHWx8A2NXfZTGRz7HbXdeQ/MH3zf7NkRnao3Y6POLiIgslLSDiDGmjugtZH1ATZrbNAFYa9udx/XGmDZrbaOzSgvQYq0NOOVtwF5ge5rbL2rD42FCeCjNIIgAXPu6FfzNi2/mptpXcd/7Z0RK/Kwu/iS/c9natLYvrd9N74sP8ieH/w9f//5K3n/TW6eEkUjEsv/VU/zof47S+ZvXONY3SthalpcXcdHaKq7YXMNVtcu5dL1P4URERHLGWJvZbJzGmAZgt7V2SxrrngI2J7VwWGutcX7uADpirRxO8Nhtra1OZ/s061sJ9PX19VFZmd5U6/PlyW818eQLB/iDT92TVqtEzKsnh7n+tp+y56aLuOGscd54+wt84LfO5aPbz03/yUf7eOHrH+I9L7+dK19/Ph/+X+ewYlkRz782wAPP9fDjp47yWv8YmyoMn1xxP6uKJzAuNz3Wx6NDa7j72FmcGndTVerl2tet4Er/cs5bXUHtynIqSrx43QZrYWg8xPB4mKGxEGOhCOOhCOPhCBOhCEUeF8UeNyVeFyVeN8Xe6ONij4tijyuj10RERBZef38/VVVVAFXW2v5cPEfO7jVjjPET7UoJpiirt9Z2puje2QZ0prv9NM9bDBTHLaoA+NW3/pry0ujicXcZv173+wBcfvhOisJDCfv4zaq30l+yjg3BX7G2/8mEsuPl5xJYfj2lE6d4/dF91Lz+Rs7b+saUr0Fl3wtsdgUz/sDduLyMN1+4hi/+NMDeqhJKS0r4o2vSmyZ+UkkV5/7JnXziicN89T9+Sv9zH+aXkY14CfFWbw+/X1FG8D13Ube+EtcXm2G8CMITXDj4Gv8rNMrHb32GJ/vL6HnoGzx/dIA7nt7AgchKIHosbpfJekr5IieQuIzBmNieo4NuDRB92U6XRb8bZ53YsrjHTnns5TZx+8IkPp6yrrPc5Tq93EnLcetHv9xEcBkLuIi43HgIU2LHcJswLixuLMZAv7saYww1oeN4CeEmjMtEt+/1rGbcXYovdBJf5CRuG92niwhD7ip6ijdSFBmldvSZ6PMRwYXFheWZymswGGqHn6A83IcL69TNcqj8QoJFZ7Fy/CDrR36DsbG6Wwa9KzlQuRW3neDS3p9gYts55c+sfAthVym1wYepGjuKMRaXtRhjOVxxGccrzqd65BX8p/474TmHi5fzwuq3AXD5wW9ibAhj7eRr+8xZ72K0qJpNJ37OisEXJn+HAF6rej2Hq6+gYuwI5x77ccLvx4SnnKfXR++5dPHBqefpi2vexmDpWtb2/oo1fYnn6cmK8zi48npKxnu54NDehDJr3Dyx+Y8BOO/wv1M+njh54IFV9QSXncOq4JOs630koay/bBMHzroRT3iEi1/++uTvWcz/bP4jIq4iao/+kIrhxPmDDq+8lpO+S6juf56NPfcnlA0Xr+alDe8G4PUv/QvJntv4+4wXVbHxWCe+wRcSyo5Vb+W15VdQMfQq/qM/TCgb81Txm03Rv3UXH7gDd3g0ofzF9e9iuGQNa48/xMqk1/BE5cUcWvlblI4d57xD+6KvnVMWdhXx1OY/AuD8g3dRMn7q9IYWutfcSH/52aw+1cXa3l8m7De4zM+B1W/GExrg4le+PeVYn9j8QazLw+uO/IBlI0cSyl5ZcT0nKy9gef9v2HTiwYSygZK1vLj2nZhIiMtf/tcp+31q43sZdy/D/9p/4RsKJJQdqbmCY746qoZepva1/4w7UhgpqubZ9TsBuOzlO3BHxhNei9+sfTfDxSvZeOIXrBx4JmG/r1W+noPLr6Z89BjnH/1BQlnIXcKTG98HwMWHvkPxROJn/AurbqS/bCNrTz3O2r79Cc/ZW34OgZVvpHiij0sO3z3lWB/btAuAC45+n2VjPQllgRW/zcllr2NV/9Ns6n04oayvdD0vrH4rrsg4W179OgDHIr4p+59vubzpnX+a5UGi3TsJnJYWH7BjLtvH2Q38bfLCzYd+QEVxdGzuSVPNXYd/C4DtE//BStubsO4dR87mKVeEPwg/wnXhxD+OB1zXcJfHzwZ7hPePf41nTzwN0wQR98QAw66yGao6w0G89Xwav7Wfo8ERvvB7l1NVlv6A13i/c9k63uJ7HUP3b+Divm68RSUULd+I2XQNnO30sN361OkNIhE4+RKe6vVsqQb++1FuHPhP/qIIIp5ShkvXsv+Sv+HVysvZfPwBzjl8Lx5XBDcWt4kwetYV9F/xUYrHTrLiR3+MjYSJRMKEjZuw8fKrq9sZsW7OefZLLBvoZgIPEdyA5bk17+CIbwtrex/joqPfBRvB2AiGCCdLN/Pw2R/GFZngnc9+FLDRMhvBYLn33P/HkKeGa1/9Mmf3PYYh7JRbHl+9gydWvINNfY9x4yufxXB6v73F6/nGOV/AArc+00BxeCiu3PIV/5c4UvI63nnkc1zV+31ccX+gflazgx+s/gibhp/mL17504TXfcBdRbP/e1gLf3XkY6wMHU0o/9zqPTxduo1r++7ld/oS/xg/VHYDX6lpZlXoKB859vEp7+mONfdhLTT2folzJ55P3O+yj/FMyRu5ceTn3DL05YSy/Z7LubN8M6V2kE/0//2U/bb3nM8p4+PTo3dxdfhxLAYbfaX5F/f/Zq+nnOvDv+KW0JfjYgi8wNnc8eKFAPwk/A3cRCa3A2h55TxeNuv4aOR+3mB/kfCcj5le/tUs51L7PG+2dyaUnaCaf3npCgDusv/OCk4llH/hwFqeZJg/4mdcwU8Syp6x1/B51nI2R/gqiX+oJ/Dw/u7rAWjjXtZxMKH8qy9V8lPC7OAhtpl/Tyh72V5C65N+fAzwPVdiwAH4oxevZNCWcpvrPs4xv0ko+86Lhu9ZD28yv+SvkrZ9xm7m009GX8MHPVP3+xfPXcRhVvHXrg7Odf0qoezHkWG+ZivYxrPc5k7c9ggr+X/P1AFwr/t7VDGYUP6pFzbxDH7+1PyMi12J4ehR28M/2VWcy6u0JdV3mBJan78WgDtcP2QNib/f//zSch5mjPeYX1Bn7k0oe4HLuc2ezUp6ucvsm3Ksf9h9HRN4+Zz5Ma8j8eq/O7uLuQ83bzOPchWJdXqSc/mnZy/AywT3OWXxIfFjgTpOUM3f0MHFdCVs+5MDE3zHVHAVT3J90n5f5iy++EK0A+BevksZiWFuz8vn8iIb+TN+Rh2J4ehXBGkzq7nAdvOmpP32sYwvB67FGPh65F7OInH+p7ZXzuJxM8F77UNcaRMDZjdv4HbX2ay1r/F2O/X35U8ORv/H/8fwfWwiMXTdc7CCB4yHd0R+xfVJ23aZC7njxQsosyO8OxItOzaW4T/Bc5CzrhljTD3RbheTtLyb6LiQ2LgPH9EBqz4gGD8eJJ3tUzxvqhaRQ7nomvl1640YG+Gy5p+kLD/62St5bGwD7/zrqb8oBWW4Fw49BidehL6DcOnvwdrL4Onvwv/cA8blNCW4YP0VcPVHYOQU/Ofu6DJjIBKG8ATc3AZuD/zXX8PRJ6PLIqHoetfeCufdCC92wMNfdPbrjn5fdSFs/7vo+vv+0NlvXPlbPgNlNfDYV+HoE6fLjTu6z3NugJ7n4Il/O72NcUH5KnhD9L8HHv7i6boYZ51LGmDZKnjlYTj+fNxzumHlebCuLvr6HHjw9DYuN7iLos8J8OqjEBpLfN6V50FpNQwcg8GexOMproTKs6LHOnA08ViMgfKV0e+jfdHX1ThtNcaApxQ80dYtwuOnl8f24faCtWAjcWXqIhOR1BaiayYfQeQU0JwqSBhjdhEdwLqZ6MDYjLafph45GyMyWxA5sedifsY2GnZ/bV6fV0REZCEsRBDJ5TwigWmW+4CAMcZnjGlxWkRiOp3y+tm2n58q5ta9q/6EX5b/dr6rISIismjlbIyItTZgjAkaY/yxy3Pjyjqdy4GbgDbi5glxvgdn2z5X9c7EXcs/grWWy6Ypf6z4KgYJLWSVRERECspcWkRSziFijPHH5v2Is4do60ZsnQagHcBa2wW0JoWMnUBXXNCYdvvFoNe7mpOe1akLwyGuObGXTebYwlZKRESkgGQyoZkfaCAaFuqMMS3AY9ba2LDneqARmJz51FrbaoxpcgIEwLakycj2JIUXH3BDBtvn1W/3fd8Z9LdtauFoH+8Nfpk7ytObhExERORMlHYQcVouWokLGknl7aRorUiakn1fUllwuv2ls32+XTCyH2OnucvtWHRMjy1O/4Z3IiIiZxrd9C5Xxgai34sXdjZXERGRQqIgkitOi4gpVRARERGZjoJIrhSV8wsux5SldX9AERGRM5KCSBZ+XX4dXWXXpS5cezl/ONGEu3z5wlZKRESkgOTyXjNL3iMVbyISsfxhirKJkX5Kw4OUet0LXi8REZFCoRaRLKwdP8C68dSTvIYfaeNnxbdSVqSsJyIiMh19Smbhpt47nMt3d04pC430MWhLKStSi4iIiMh01CKSI+GRfgYoo1RBREREZFoKIjliR/sZpJRydc2IiIhMS0EkR+xoP/1WLSIiIiIzURDJwpC7kiFX6gnLnrr689w68WGNEREREZmB+g2y8I2V/x+RiOWaFGVDYQ+DlCmIiIiIzEAtIjly0aMf512un6trRkREZAZqEcnC+45/FqwF7plStqrnv1nrehNFbmU9ERGR6SiIZKE83O/MIzKVNzTImKccY8wC10pERKRw6N/1XJgYxW0nmHCX57smIiIii5qCSC6MDQAw4a3Ic0VEREQWNwWRXPCW8oP1H+dQ8Tn5romIiMiipjEiWfhBzQewEctlyQXFy3iw8h0MTQznoVYiIiKFQ0EkC4eL/IQjdmpB3yEuPfEj+r2pZhgRERGRGHXNZOGqgQ6uHvjJ1IIjT/C+nlaqvKGFr5SIiEgBUYtIFuqGfgGRFGHDGazqKk49/buIiIhEqUUkC8ZAio4ZGOtnHC9FJaULXSUREZGCoiCStRRRZKyfQaP7zIiIiMxGQSQLxjgzvCdbtppfcyGlRer5EhERmYmCSBZeKN/Ck8V1Uwvq/je32lvVIiIiIjIL/cuehYeXv5uDvcN8ILlgYpTRiQkFERERkVkoiGShOnSc4dDglOWRu9/LP7t66S/6Zh5qJSIiUjgURLLwzmNfwo6cAm5OWB4ZHWAADVYVERGZjcaIZMO4cBGZstiO9jFgSylVEBEREZmRgkgWIsaNy04NIow5LSJeBREREZGZKIhkw7gwKYKIa6yfQVtKmS7fFRERmZGCSBbCriLCmCnLn7ypkzvDN6hrRkREZBb6lz0LP9z0lzwSOknybe/63NUarCoiIpIGtYhkwWUM4eSpVYdOcsGDH+IC8wrl6poRERGZkT4ps3DNa9/muuEngOtPLxw+yZojnZRztbpmREREZqEgkoXKieOsiBxMXDjWD8CIq4wijxqcREREZqJPyixY45l6+a4TRCa8FXmokYiISGFREMmGy4WLcOKysQEAIt5leaiQiIhIYcmoa8YY4wNuAXZYa7enuU0TEHQe+qy1rSnKAWoBrLWNSeW7AJ+zj1pgj7U2yCJgjXvqzKorL+CB9R/GnlKLiIiIyGzSDiLGmDpgK9FQUJPmNk0A1tp253G9MaYtFjaMMS3W2ua49duMMR2xkONs3x4LHk4Quh3YkW69c+n5lW/h7tfW8bn4hSvP5f7l76FkOJinWomIiBSOtLtmrLVdTqAIZLD/3UB73D46gV0wGSrqnO8xbUC9McbvPN4e3/rh/By/fl6dWvY6HjJbEhcee5oNvY9qDhEREZE05GyMiBMmfKm6UYwx9c6PWwF/XFEs5Pic70FjTEcsrDj7nDEIGWOKjTGVsS8gZ30kZw08zc3hpOnMnvwOv3PsC5RqDhEREZFZ5XKwqn+a5UGcgGKtrbbWdsWVxQJKLGx80NnPKWNMC1CfPIYkhd1AX9zXoblUPh0b+x6jMXJX4sLRPoaNbngnIiKSjnxcNdPL9GNMdgONsVYU53sLsA9oAnYkdeWksgeoivtan3WNp2FdKQarjg0wRKm6ZkRERNKQjyCSMoQ4LR53xwa2xi0LWGt3EL1ipgbYP9POrbVj1tr+2BcwMH9VT660C3eKy3f7balmVRUREUlDLoPIdGM5fMllxpgGoDv+0t64MSadANbagLV2C9FxIw25qXKGjBt38oRmVes4wDq1iIiIiKQhZ0HEWhsgGhqmjBWJhQs4PXA17hJfn7ONn9Pzj8Rry0mF52CgfCO/4LLEhe/8Iv9sfpcyDVYVERGZ1VyCyHRdK/64ycli9nB6AGqs5SO+66UOqAO6nO39RC/v7XXCSvLlvQBbrLX75lDveXd41fX8eeTWxIXWMjweVouIiIhIGjKZ0MwPNAA7iQaEFuCxuFBQDzQCk90r1tpWY0xTXFfKtrjJzHzA/US7alrinyuui2YHsNsYcxLnahugmUXCExnHZ/sSF35mEw2hmygr+mh+KiUiIlJA0g4iTldLK3FBI6m8nbjWjrjl8evvi1seBKpnec4giyh4JDvn2I941PN3YHeCMRCJwFgfw7ZI84iIiIikQTe9y4bL6X6JOFfOjA8CMGRL1DUjIiKSBgWRbBgnbFgniDh33h1El++KiIikQ0EkC8ZpEYmEQ9EFTovIoC2hXF0zIiIis1IQyYaJvnyTQaR6My80PMDTdrO6ZkRERNKgIJKFI2u3c/HovxLxLosu8BRxquxsRilW14yIiEgaFESy4PIUM0jZ6bvNHNrPxl98jFJG1SIiIiKSBgWRLNScepJvevcQGT4VXXDyRc468D0iuCjzaoyIiIjIbBREslA8EeS33E9hJ0aiC8YGiBgPY3jVNSMiIpIGBZEsGFe01SMcPn357oS7DI/LRZFHL62IiMhs9GmZBeNyXr7I6ct3x91lGh8iIiKSJg1kyMLpeUScFpFN1/D4oQhlh/WyioiIpEMtIlkYqfDziYn3Eyp2bplzzg08vOIWtYiIiIikSUEkCxPL1vCt8JuIFFdGFxzuorLvOQ1UFRERSZOCSBaKxoPc7PoFdiQYXXD/p7ju6NfVIiIiIpImBZEslA0d5h+LvozpOxhdMD7IEKWU6j4zIiIiaVEQycLkYNXYVTNjg84N79QiIiIikg4FkSwYtxM4ws4k7+ODDNgSjRERERFJk4JIFqa0iCxbxWuRao0RERERSZOCSBast5yuyDmEPaXRBR98gH3ut1CmMSIiIiJpURDJQrhyPe8a/xRjyy+YXDY8HqLUqxYRERGRdCiIZMEYA1jCYQtDJ+EzG7lsbL+6ZkRERNKkIJKF4qEjvFzy+5QefBDG+mG0j+GQURARERFJk4JIFlzO3XdtJAzjgwD0R4o1RkRERCRNCiJZiN1910bCMBYNIoOUqkVEREQkTQoiWTApWkSGNI+IiIhI2hREsuByJjSzkRBsuIKD77qXE1Spa0ZERCRNCiLZKK7k+rHP0bf2Oiip4lTNpYTwqGtGREQkTQoiWTBuD6/YNYQ85dD9U5Y/8vcA6poRERFJk/oQsuC2If7R+yXKj7pg/ClWdH8XuJ5ydc2IiIikRS0iWXAZuNn933gHXoGxfiY8ZYBaRERERNKlf92z4HI7L18kAqFhJlzRIKIxIiIiIulRi0gWYlfNEAlDZIKQceN1G7xuvawiIiLpUItIFlwGQtaFtWHYfD0v9K2gtE+tISIiIunSv+5ZcBnD50Pvot93MVzSwC9X/67mEBEREcmAgkgWXMbwxfC76Ku5BE52U9rXrfEhIiIiGVAQyYLLwNWupykeeBXu/xT1r3yOsmIFERERkXSpHyELLmP4svefOHpwAiIhJqyLMq9eUhERkXSpRSQLLpchjAsTCUEkzIR1aQ4RERGRDCiIZMFlIIwbbARsmHHr0hgRERGRDGTUj2CM8QG3ADustdvT3KYJCDoPfdba1hTlALUA1trGFPtoAbqdh73W2n2Z1DtXXMYwgRsiE+AtY8BatYiIiIhkIO0gYoypA7YCPqAmzW2aAKy17c7jemNMWyxsGGNarLXNceu3GWM6YiHHCT73AzdYa4NOHfYDJt1655LbZXjVrmaZZxk0fIPPfv4XbFEQERERSVvaXTPW2i4nUAQy2P9uoD1uH53ALpgMGXXO95g2oN4Y43cetwB3W2uDsToAabXELARj4HfHP8GLte8DYGwiTKlXQURERCRdORsj4oQJXyxEJJXVOz9uBfxxRbGQ43O+7wL2GWP8sW2cMDPT8xYbYypjX0DF3I9iZi4TbZgJR4B73sf7R76uICIiIpKBXA5W9U+zPIgTUKy11U4rR0wsoATiWkXqiAaTgNN1U8/MdgN9cV+H5lL5dLiN4U7v/+XiZz4LfQepCPdRrCAiIiKStnxcNdPL9GNMdgONTitKLIgEnW6hANAM7J1l/3uAqriv9VnXeBrGQLkZxTsxAJEwYxEXJQoiIiIiactHEEkZQpwrY+6ODWyN83jsByeg+GZqFbHWjllr+2NfwMA81DklYwwh3BAJYSMhxiJGXTMiIiIZyOU0oNMNavUllxljGoDupBAy3fZBpu/2WXBh3LicIBLBRYlXU7OIiIikK2efmk5XSjBurEd82eSA07hBqLFLfH3GGL+zfYCpocNHXCtJvoXwYGyI4e238W/hG9QiIiIikoG5BJHpulb8cZOTxezh9ADUWMtHe9zjOqKDUbuc7f1Er5TpdVZpBnYmbd+ZNMA1rz4d+QD7/R9mcPU2XrLrNUZEREQkA5lMaOYHGogGgzpnTMdjcbOc1gONwOTMqdbaVmNMkxMgALbFTWbmIzpZmY/ofCHEb+d832eMqYkLOMvTndF1obziWk9f2SaKHvsKV7nGKfa+Id9VEhERKRhpBxGnq6SVuKCRVN5OXGtH3PL49ffFLQ8C1Wk875R9LiY3mQc57+ATVBz+Ble6rlTXjIiISAZ0z/osXWeeYFNPCMIhQlaX74qIiGRCl3hkKXbVDJEwYVxqEREREcmAgkiWwsaDy4bAhgjjVouIiIhIBhREshTGg4mEOLb2Tbxo12keERERkQxojEiWulyXsGrFeRy/9EM88NyTahERERHJgIJIln7qvY7qtes4N/gKFWaYYo9aRERERNKlT80sraaXmoEXeNuDb+dm7y8xxuS7SiIiIgVDLSJZenf4Pt72/EO4iOB2q1tGREQkE2oRyVLYePBExgFwub15ro2IiEhhURDJknV58ETGAHC51cAkIiKSCQWRLEWMB4+Ntoi4PQoiIiIimdAnZ5bGXSUMeqppOf/fefZIMN/VERERKSgKIln6z/J30r35PRgLxqXBqiIiIplQ10yWPC5D8XgfH+7+Ey4IPZvv6oiIiBQUtYhk6cqx/+YjL95GsR1lWclIvqsjIiJSUNQikqUyRim2owBYo64ZERGRTCiIZMsVN3eIxoiIiIhkREEkS9Z1unfLGvV0iYiIZEJBJEuxILJv+Yc4VrQhz7UREREpLPoXPkuvlFzE51Z+mpeWbWUkopdTREQkE2oRydJQ8XK6vedydf99VEb6810dERGRgqJ/4bO0MtzDO07+I1vGHuWl0kvyXR0REZGCohaRLC0P9bBl7FEAjC7fFRERyYiCSJZs3OW7VpfvioiIZERBJEvGrct3RURE5kpBJFtOEBky5YQ9pXmujIiISGHRv/BZGvdU8aD3Wr5b9T7c3uX5ro6IiEhBUYtIloZK1vCZ0o/Sa6ox+a6MiIhIgVEQyZLXFeHtYz/iW8cbqLCaR0RERCQTCiJZKg/38adjXwXAuHXVjIiISCYURLJk3EWTP+uqGRERkcwoiGQrLogYl4KIiIhIJhREsuSKCyIul15OERGRTOiTM1vOPCJfK34v1lU0y8oiIiIST30JWfK4XWzhTnzeMn7bpQt4RUREMqEWkSy5XYbX2+f41Mjf4yWc7+qIiIgUFLWIZMntMnzNfArC8IjL5rs6IiIiBUUtIlnyxHXHqGdGREQkMwoiWXLHXSnjNkoiIiIimcioa8YY4wNuAXZYa7enuU0TEHQe+qy1rSnKAWoBrLWNM+yrI93nXSgJLSJqEhEREclI2kHEGFMHbAV8QE2a2zQBWGvbncf1xpi2WNgwxrRYa5vj1m+bLmwYYxqA+nTru1ASwodLU7yLiIhkIu0gYq3tArqcQJCu3cDmuH10GmM6gEandaXOGOOz1gadVdqA/cYYv7U2ENvOWTet8LPQPC7DrvFb6feu5Dq3N9/VERERKSg5GyNijPET7YoJpiiLtWxsBfxxRbHw4Uva5BbgnjSft9gYUxn7AioyqXem3C7DM5GzWRXuwU0kl08lIiKy5ORysKp/muVBnIBira12WlpiYgElvjWkHujM4Hl3A31xX4cy2DZjHpdht/dOvuD5JzxG84iIiIhkIh9XzfQyfTfLbqAxqRXFF99Nk4Y9QFXc1/q5VDJdLpfh7e5fRn/WVTMiIiIZyceEZilDiDGmBbg7NrDVWbYr/nE6rLVjwFjcPuZaz7QkziOiICIiIpKJXAaR6VoxfMllzgDY7qQQUgc8nrPazRN3XBBx6/JdERGRjOQsiFhrA8aYYPIVME7Z5JiP2MDVuEt8fURbTWqIXlUTGzdS65Q3AQFr7b5c1T0Tbpdh1HopMRNqEREREcnQXILIdF0rfqAhacKyPUQHoMZCRkPsZ+dxHVAH7HO2B2gA2p3w0pm07q7kCdHyze0yfDF0MxVmmApPUb6rIyIiUlAymdDMTzQk7CTaUtECPBbXMlEPNAKTQcFa22qMaYqbe2Rb3GRmPuB+ol01LfHPlWL21djzxsaSdMS3quSTx+XiS+GbAPiMWkREREQyYqxd2neMdeYS6evr66OysnLe97//lVN8p30Pt3nb2PfWX9NwxXRXLYuIiBSW/v5+qqqqAKqstf25eA7d9C5LbpfhbzzfAkANIiIiIplREMmSx2UYd3q43Ho1RUREMqKPziy5XYYJJ4joqhkREZHMKIhkye0yTNjoXXcVRERERDKjIJIlt8twX+QKAFy6+66IiEhGFESy5HEZvhB6F3WjX8Hlcue7OiIiIgVFQSRLbpfhPHOQJs9duG0o39UREREpKAoiWfK6XfyBp4Pf9fwMt1nac7KIiIjMNwWRLHlchrNMLwAuvZoiIiIZ0UdnljwuF/eFo4NV3RojIiIikhEFkSx53IZvhN/EOaPfxLh10zsREZFMKIhkye0ygCGER10zIiIiGdJHZ5a8cfO6uzWhmYiISEYURLLkisseLpeCiIiISCYURLJk4lpBNMW7iIhIZhRE5pFbLSIiIiIZURCZRxojIiIikhkFkXmkHCIiIpIZBZF5pK4ZERGRzCiIzCMFERERkcwoiMwj5RAREZHMKIjMI12+KyIikhkFkXmkrhkREZHMKIjMI7WIiIiIZEZBZB5pincREZHMKIjMI01oJiIikhkFkXnk0qspIiKSEX10ziONEREREcmMgsg8UteMiIhIZhRE5pEGq4qIiGRGQWQeKYeIiIhkRkFkHmlCMxERkcwoiMwjDVYVERHJjILIPFIQERERyYyCyDxQl4yIiMjcKIjMA4+CiIiIyJwoiMwDr1svo4iIyFzoE3QeqGtGRERkbhRE5oHXrSAiIiIyF55MVjbG+IBbgB3W2u1pbtMEBJ2HPmtta4pygFoAa21jJuWLgVpERERE5ibtIGKMqQO2Aj6gJs1tmgCste3O43pjTFssTBhjWqy1zXHrtxljOmIhZ7byxcKj2+6KiIjMSdqfoNbaLidQBDLY/26gPW4fncAumGxdqXO+x7QB9cYY/2zlGdQh59Q1IyIiMjc5+1feCQs+a20wRVm98+NWID5UxEKOL83yVM9bbIypjH0BFRlXPkPqmhEREZmbjMaIZGi6VosgpwNKdVJZLKAEZiuf4Xl3A3+bdi3ngS7fFRERmZt8fIL2Mv0Yk91AY6pWlDTLAfYAVXFf6+dWzfSpRURERGRuctkiMp2UIcQY0wLcHRvYmml5jLV2DBiL2y6LqqbHoxYRERGROcllEJmu+8SXXGaMaQC6ZwghM5bnm6Z4FxERmZuc/StvrQ0AwVRXuDhXzwCnB67GXeLri99mtvLFIBZELDbPNRERESkscwki03Wt+OMmH4vZw+kBprGWjfa4x3VAHdDlbO8nenlvbzrli8WFayvzXQUREZGCZKxN7794JwQ0ADuJhoNW4DFr7T6nfBfQbK2tTdquidNdMdtiE5Q584McIMWluNZaM1t5WpWOPk8l0NfX10dlZW4Cw3goQuDEIOevUSAREZGlo7+/n6qqKoAqa21/Lp4j7SBSqBYiiIiIiCxFCxFEdLmHiIiI5I2CiIiIiOSNgoiIiIjkjYKIiIiI5I2CiIiIiOSNgoiIiIjkjYKIiIiI5I2CiIiIiOSNgoiIiIjkjYKIiIiI5I0n3xVYKP39OZmZVkREZMlaiM/OMyGI1ABs2LAh3/UQEREpVDVATlLJmRBEep3v64GBfFYkxyqAQ+g4lwod59JyphwnnDnHeqYdZ+9sK87VmRBEYgZydefAxcAYE/tRx7kE6DiXljPlOOHMOdYz8DhzRoNVRUREJG8URERERCRvzoQgMgb8nfN9KdNxLi06zqXlTDlOOHOOVcc5T4y1Nlf7FhEREZnRmdAiIiIiIouUgoiIiIjkjYKIiIiI5I2CiIiIiORNwU9oZoxpAoLOQ5+1tjUX2+SbU2eAWgBrbeMs69cDjUAHEAC2A49Za/flsp7Zmmu9C+09NcbsBe4meozB+DJrbWCabRb9e2qM8QG3ADustdtTlC+J8zXN44QCP19nOs6ldK7OcpxL6lyd7XczL+eotbZgv4AmoCnucT3QNt/b5PsLaEl63AZ0zLJNA3AKsEA3sCvfx5HmsWZc7wJ9T7udY0z+2luo7ylQB+xy3o/98/E+Lcb3No3jXBLnaxrHuSTO1TSOc8mcq7P9bubrHM37C5Pli3qKaPqKX2bne5s8H6OPaKr2xS2rc37B/TNs15B8nIXwNZd6F9p76tSvKcWyGf9YFcp76tQz1R/0JXW+pjrOpXi+zvB+LqlzdYbjXBLnajq/m/k6Rwt2jIgxxk/04IMpyurna5tFYivgj3scaw70LXxVFpcCfk8Tmmiduj6ep7rknM5X4Aw/Xwv4/VxK5+q0v5v5PEcLeYyIf5rlQaY/4eeyTV45b3B10uLYG5yyfzLOLcaYXqK3b6611jbPc/VyJZN6F9x7Col9y87J7LfWdqaxaaG+pzpfl+b5qnN1eovq/Uzjd3PrNJsGyfE5WshBZDqxNz7X2+TTbqAxVQqN0wWnTyJjzC5jzF5r7Y4FqF825qvehfSeNttZBjM6CvU9nYnO16hCfG91rk6vUN7Pyd/NGe6ym/NztGC7ZmYwl1/oQjkJMMa0AHdba9tnWs9aG7CJI7rvARqc0eGL1jzWuyDeU2NMXbrrFup7OgudrxTme6tzdXqF8H6m+7vJApyjhRxEpmvm9M1QNpdtFg1jTAPQbdO7nKoh/nHcf2PTNaUtCnOod0G/p0Qv8etOZ8VCfU8dOl9nX3dSIby3Olent9jfz2l+N/N2jhZsEHHSZtDps0suS9l/N5dtFovYwJ9YejXG+FIdR6wM2BtfHpfEF+0JP5d6F/J76qgnaW6CVAr1PY3R+bq0zledq9Nb7O/ndL+b+TxHCzaIOPZwerBNLOW1xz32x03ektY2i5HTJFgHdDnH5Cd63XuvU55wnE76bk1qGtwF7Julnzqv0qn3UnlP4/hJ8cepwN/T6Zpll9r5mvI4l+D5OuU4l+i5Olt3QsGfq7P9bpKnc9Q41/wWLOdFib3h2+JHJhtjdhEdXFSb7jaLjZOkD5BiBLK11jjrTDlOZ7tdcasvX8zHGTNbvZfCexrPGNNNdDbHrqTlBfeeOn/UGoCdRP/YtZI0m+RSOF9nOs6ldL7O9n4ulXM1nd9bZ72CPlfT+d101lvwc7Tgg4iIiIgUrkLvmhEREZECpiAiIiIieaMgIiIiInmjICIiIiJ5oyAiIiIieaMgIiIiInmjICIiIiJ5oyAiIiIieaMgIiIFyxjT5nz5Zlhnl7NOw3TriEj+ePJdARFZPJzprvcDnZyesrmB6M2+7gaW49xXwlq7JQ9VnOSEj+Bs00nH3dyrBdg307oisvAUREQkng/YE397cKcloTNpWUfczy2A31q7YyErKiJLg4KIiMSrYeqdM4Mp1tsb93MHKW6kJSKSDgUREYnnS/NW5QFjjM9aG7TWdua6UiKydCmIiMik5Fufz7BeJ4Axpg6Idc3UOsvqnWUAHwT8RFtatlhrG51bifcSve36nhS3VY/dUtwPBNKtk7PtLmdbn7N9MDZGREQWJwUREZkza22XMaaZuK4aa22ns6wNqIkFCWNMtzGmJTa41BgDcDswOejVGLMXuDtumw5jTCA5rKQSuyomLiT5cQbWisjipct3RSQXeom2ksR32wSS1uki2moBTAaHhqQWkL1AYwbPuyN2Ka+1NgA8nkmlRWThqUVERHIlOXgEge4Z1q8Hgk7XTkwtcWFlJtbafcaYRuCUMaaLaMtK62zbiUh+KYiIyGLhIzomJL4VJaOBsNba7c64lXqg0RiDwojI4qauGRFZLBK6amJmmjU1ab1dEB234oSPLUQHxIrIIqYgIiKz8TE/84TMuA+nJeTxFFOx35Lu/mNhJE5y95CILDLqmhGRlJzLaJcTbaWoj11WGz+Y1OkG2Q34jTFN1trWaZY1AVudbQJEB7PuJhoeWohexht0ulZajDE1zjpkcPlt0Nl/LMj4iV4+LCKLmLHW5rsOIiIZc7psds92r5m49VvSXVdEFo66ZkRERCRvFEREREQkbxRERKSQNRhj2ma6ssYYs8uZsVVEFiGNEREREZG8UYuIiIiI5I2CiIiIiOSNgoiIiIjkjYKIiIiI5I2CiIiIiOSNgoiIiIjkjYKIiIiI5I2CiIiIiOTN/w8k8CAHU63v0wAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(<Figure size 600x400 with 1 Axes>, <AxesSubplot:xlabel='Time [s]'>)"
+      ]
+     },
+     "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.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",
+      "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
+}
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": [
+      "<Toggler Toggler_1>: Line.Line_1 status changed to 0 at t=1.0 sec.    \n",
+      "<Toggler Toggler_2>: 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": "iVBORw0KGgoAAAANSUhEUgAAAhoAAAFrCAYAAACXLyDfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA0uklEQVR4nO3de3wcV33///eRLMuWbWktx7kQJyQyISQBAmsbKIFCk1Upl9JvqGTTC9CWSqK0QPn9ilT9eoFSeIhVS/voj7Z8taa/wrf0YksthS/w5VHJtFBKoLYUrimUaBOIE0IcSyvZ8V06vz/OzGp2tSvtyDvai1/Px2Mfu3vmzMyZ3Zmdz55z5oyx1goAACAKDZUuAAAAqF8EGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIbKl2AcjHGGElPk3Sq0mUBAKAGbZP0mC3zSJ51E2jIBRnHK10IAABq2C5Jj5ZzgaECDWNMh6QuSWlJHZJS1tpM2LzGmISXLSZpn6RD1tqpwLwJb560JFlrJ0oo3ilJeuSRR9Ta2hpmswAAuKLNz8/rhhtukCJoFQhbozFqrd0jZQOJg5K615B3VNI91toJY0y79363lzchqdta2+fNN+5PK0VrayuBBgAAVaLkQMM76WdZa9OBmomwebuDNRiSMoHXI5L2BObrLLWMAACguoS56iQhaSYvbcYYEw+bN68ppFsuuPADlHZrbcYYEzfGxKy16UKFMcY0G2Na/YdcJxYAAFBFwgQasSLp7WvJ6wUSSUnj1tqUlxyXC0j8vh293utCBiXNBR50BAUAoMqU46qT2FryWmunjDFpSUljTJe1dkwuEOmQNOHVaqQkzUoyBZY1JOlPAu+3iWADQB1YWFjQxYsXK10M1JmmpiY1Njau+3rDBBoZLa+9aFdu/4pQeb1gYlTSuDFmu1wtRsa/OsWbLmNMPK9Ph6y15yWd99+7YTQAoLadPn1ax48fV5mHMgBkjNGuXbu0devWdV1vmEBjQlJfgfRjYfJ6nUJHrbXbvTS/D0ZH4DUAXHEWFhZ0/PhxtbS0aOfOnfyBQtlYa3XixAkdP35ct9xyy7rWbJQcaHhXgGTfex03jwXGxojL1UakV8prjJmRC0R8/nxTXt5jXifQjDdfOr82AwDq0cWLF2Wt1c6dO7V58+ZKFwd1ZufOnXr44Yd18eLF6gw0PN1eB86jcgNtBcfQGPTSh1fK6/XNOGSM6fXydcq7nNWfT67fxqSXzuWtAK4o1GQgCpXar0y9tAN6l7jOzc3NMWAXgJp07tw5PfTQQ7r55pu1adOmShenpk1MTGh0dFSpVEr9/f3q7OxUe3u7RkZGsmm7d+9WJpPRyZMnlUqlNDo6WrY8mUxGQ0NDmpqaUjKZVH9/f7Zsw8PDGhoa0v79+zUyMpJT7lQqpenpae3evVvt7e2KxWJKp9NKJBLq6OjI38ysqakp9fT0aHJysmielfav+fl5tbW1SVKbtXZ+TR96MdbaunhIapVk5+bmbCTOzVv7yLFolg0A1tqzZ8/aBx54wJ49e7bSRakL09PTVpKdnZ1dMc1aaycnJ+3IyEhZ80xOThbMY621yWRyWVoikcjOG1yeJDs9PV10O0dHR7P5VrLS/jU3N2clWUmttsznZ24TX6rP9ksfuVu6eK7SJQEAlKC9ffkwT4XSJCkej5c9TzweV0dHh1KpVE6eiYkJdXXlDhE1POx6HfT29uakx+PxZWn5urq6ctZbbQg0SrV5u7Rhk9REdSYA1IupqSml0+6Cx/3795c9T19f37LmkampqWXNIENDQ+rrK3SxptTdXeyWYrWBQKNkVoo9vdKFAICqMzY2pr6+PmUyGUnuxDgxUcpNtysnlUppeHhYPT092bRYLFb2PL29vUqn09kgpNAy0um0MplM0T4Yq/XPqHblGBn0ynB+Xnryu9L470ud7610aQBcIc5eWND0idPrvt7dO7dq88bVL4EcGxtTV1eXRkZGlE6nFY/H1dnZmXNirUa9vb3LTvhR5InFYkokEhoZGVEymVQqlSpaK1KvCDRKde2dkj4ufff/EGgAWDfTJ07rNR/60rqv99Nve4mefX3bqvm6urqUyWSyQYYk7d27d9UTdLUI9pWYmJhQIrH8puSXm6evr089PT1KJpPKZDLLPhu/tiL4GQal0+nsFSi1iECjVC/slTZukT7569K5eWkTl9ACiN7unVv16be9pCLrLVX+iTWdTi/r7Fitgk0SxWphLjdPV1eXuru7lUqlijaB9Pf3a2RkpODnNjU1VTOfZyEEGqXKPCLt2C3JSj/8unTzSytdIgBXgM0bG0uqWaikdDqt3bt3S9Kyvgb+eBL79u2T5E666XRaY2Njisfj2TEixsbGFIvF1N7ernQ6nfMvP5FIZPOOjY3p5MmT2rdvn9LpdM74FPlmZmZKSvPL6Y9BUa48QV1dXRoYGNDs7GzB+ZLJpDo7O5VKpXKuMvH7vZSqUI1JpRFolOpv/od0y09KTVukH36NQAMAPL29vRoYGNDY2Jik3GaEe+65R0eOHJGk7GWefX19Gh8flyR1dnaqo6ND8XhcIyMjGh0dzQ62NTIyorGxMR07diwnKDl06JC6urqUSqWyfUTy+cuQ3BUdBw4ckKTsFSBDQ0PZ4Gh6elqpVEqDg4OampoqS558g4ODq3boHB8f1/DwsAYGBrIDduV/noVMTExkP08/qKumGhBGBi3VH90ivaBH2rVXat0l7Xxm+dcB4IpWbyODBgOGYNr4+LiSyaQkac+ePZqcnNTw8LDi8bgSiUTO64GBAR04cCDbdyE4ra+vT93d3QX7TGC5So0MyuWtpTp/SmreJu2+myADAErk/9uXlpoBduzYIck1i+zdu1eSdPTo0ezr8fHx7Gt/zAm/30Mwn1/DgepG00kpFi5Kl85Kza3Sfx6Urr5duumuSpcKAKpaIpHQ+Ph4dkyN9vb2nLRgE4S0NL5ELBbLvu7o6NDhw4ez/RbS6bQOHz6sTCazbCAsVCeaTkpxZkYavlk68HHpc4PSnT8n3f075V0HgCtevTWdlFsmk1FPT0+27wXCoemkmrW0S78/K936qkqXBACuWENDQ5UuAtaAppNSNRCTAUAl+R1IUVs4e5bixHeljySkJx+sdEkAAKgpBBqluPCUdPyodPGMG0vj6mdVukQAANQEmk7Ces2fVLoEAADUDGo0wpr/oXRurtKlAACgJhBohPVXndKX/7zSpQAAoCbQdFKK7TdJ945IbbsqXRIAQAn84c9TqZT6+/vV2dmp9vZ2jYyMZNN2796tTCajkydPKpVKaXR0tGx5/JvJTU1NKZlM5tz8bXh4WENDQ9q/f/+yQcdSqZSmp6ez9zqJxWLZEVCL3StlamoqOyja0aNHdfDgweq6sZq1ti4eklol2bm5ORupP7nD2iPvi3YdAK5IZ8+etQ888IA9e/ZspYtSF6anp60kOzs7u2KatdZOTk7akZGRsuaZnJwsmMdaa5PJ5LK0RCKRnTe4PEl2enq66HYGl5VMJm08Hi+Yb6X9a25uzkqyklptmc/PNJ2U4vQJN/T4UycrXRIAQIn8u5+uliYpe9O2cuaJx+Pq6OjI3rXWNzExsezuqsPDw5KUc4t4fxn5aUFTU1M5A5l1dXVpamoqe2+YakCgUYq5R6TP/pY0/2ilSwIAKKPgSXn//v1lz9PX17esecS/UVzQ0NCQ+vr6Ci67u7u7aPnj8bgOHjyYfe/fuK5YIFQJBBphvW1SetlApUsBAFVjbGxMfX192ZNcd3d3ts9AtUqlUhoeHlZPT082Lb9fQzny9Pb2Kp1O59Qw5C8jnU4rk8kU7YOxUv8MSTm1I4cOHVIikaiqPhp0Bg1rQ3OlSwDgSnPqcfcI2hxzHdUvnpNOfGf5PE97nnt+8ntu0MGg2I3uHk5PPSnNHc+d1rxN2rFbpRobG1NXV5dGRkaUTqcVj8fV2dlZVVX3hfT29q56Mi5HnlgspkQioZGRESWTSaVSqaK1Ipcrk8lobGxMk5OTkSx/rQg0whr9JWn33VL8jZUuCYArxbG/lr7wgdy05+yXfvaga9JNvWz5PO/xxvv5519zIxsH3ZuS7jwgffsTrlk4aPfd0hs+UXLRurq6lMlkskGGJO3du7eq/lGvJFgbMDExoUQiUfY8fX196unpUTKZVCaTWfbZ+LUVwc8wKJ1OZ69AWcnAwIDGx8er7rMn0ChFc6s7+Jq3SsePSTueUekSAbiS7P1l6dZX5qZtjrnn1uul3i8Un/d/fLhwjYYk3XGvtGtf7rTmbaGLl39iTafTyzo7Vqtgk0SxWpjLzdPV1aXu7m6lUqmiTSD9/f0aGRkp+LlNTU2t+nkODw9rYGBAHR0d2Sasagk4CDRKcdUzQkX4AFBW2651j0KaNi01kxRy1S3Fp225yj0uUzqd1u7drrklv6+BP57Evn0uoOnq6lI6ndbY2Jji8Xh2jIixsTHFYjG1t7crnU7n/MtPJBLZvGNjYzp58qT27dundDqdMz5FvpmZmZLS/HL6TQ7lyhPU1dWlgYEBzc7OFpwvmUyqs7NTqVQq5yoTP2hYif9Z+kHG4cOHV7xSZb0RaJRiccH9I9i4pdIlAYCq09vbq4GBAY2NjUnKbUa45557dOTIEUnKXubZ19en8fFxSVJnZ6c6OjoUj8c1MjKi0dHR7GBbIyMjGhsb07Fjx3KCkkOHDqmrq0upVCrbRySfvwzJXdFx4MABScpeATI0NJQNjqanp5VKpTQ4OKipqamy5Mk3ODi4YodOSRofH8/WTPgDduV/nvnS6fSyq1JisVhVBRoVH2irXA9FOWDX8Ulr391q7WNf9wbs+sPyrwPAFa/eBuwaHx+3vb29y9L6+/uz7/3BpZLJpB0fH1/2ur+/305OTmbzB6f19vZmX2N1DNhVKxLvkZ716kqXAgBqgv9vX1pqBtixY4ck92987969ktzQ2f7r8fHx7Gt/zAm/30Mwn1/DgepG00lYz6mNDk4AUGmJRELj4+PZMTXa29tz0oJNENJS58VYLJZ93dHRkdPnIJ1O6/Dhw8pkMssGwkJ1MtY1O9Q8Y0yrpLm5uTm1traWd+GPTkkHf0Lq+3fpyf+W2juk65dfggQAl+PcuXN66KGHdPPNN2vTpk2VLk7VyWQy6unpyfa9QDgr7V/z8/Nqa2uTpDZr7Xw510vTSVgT75G++9lKlwIArjjBe3qgdtB0UoprnyP91oNL160DANZdMpmsdBGwBgQapWhskrburHQpAACoOaGaTowxHcaYfmNMl/ccW0teY0zCe3QZY5LGmIIdHrxpRdexbk5OS3//c9LMQ5UuCYArQL30nUN1qdR+FbaPxqi1dthaOyZpTNLBNeYdlTTjTZv23ufwgo/iQ76tp3Nzrl/G+VPSrr1Lw/cCQBk1NjZKki5cuFDhkqAe+fuVv5+tl5KbTowxOUOaWWvTxpiCFzCXkLfbWjsVeJ8psJgOSdV3+7/uj1a6BADq1IYNG9TS0qITJ06oqalJDQ3010d5LC4u6sSJE2ppadGGDevbayLM2hKS8gd3nzHGxPOChlXzWmsnAundknIuhjbGdFlrx4wx1dfz59J5yTRKjXRvAVBexhhdd911euihh/T973+/0sVBnWloaNCNN94oY8y6rjfM2TJWJL19LXm9ppEDksattalAekyFazhyGGOaJTUHksLfcnAtPrRHuvP10t2/uy6rA3Bl2bhxo2655RaaT1B2GzdurEgtWTn+lsfWktdaO2WMSUtK+jUY3qT9wcBjBYOS3h1i3WvXer30k++Xtl23LqsDcGVraGhgwC7UjTChTUbLay/aVbj2oaS81tqMXEfQUWNMzOvHcbjE8gxJags8dpU4X3jbrpFe/Btc4goAQEhhAo2JIunHwuT1LmudDaT5HT79DqT7jTG9xpheL22w0OWv1trz1tp5/yHpVAnbsDZnZqRvf0I6m4lsFQAA1KOSm068K0ey770rS455tRJ+n4uMtTa9Ul5jzIxyAxF/vvwOpTLGjEgasdZW9uqT2Yel0V+S3vKlihYDAIBaE7aPRrd3JchRSfvkrhjxDXrpwyvl9fpmHPJqLCSpU9Ke4Eq8DqH+9AFjzEihQKQifnVCatpc6VIAAFATuHtrKfy7t77lS+6+JwAA1BHu3lpNPv1O6Ztjq+cDAADcVK0kTZtdTcaGTdL3xqWWHZUuEQAANYFAoxRX30ZHUAAA1oCmEwAAEBkCjVI8dr/0h1dLj3+r0iUBAKCm0HRSCmulhfOSrHTXO6Srb690iQAAqAkEGmG9oKfSJQAAoGbQdBLW9OelE/9d6VIAAFATCDTC+tTbpW+Wet83AACubDSdlOLq26S3fkXafnOlSwIAQE0h0ChF02YXbAAAgFBoOinF7PelT/6GNHe80iUBAKCmEGiU4sxJ6f6/kc7OSu0d0padlS4RAAA1gaaTsN70qUqXAACAmkGNBgAAiAyBRlh/8ULpC3+0cp6Fi9J//Jn05Q+55hYAAK5QBBql2HqNdNdvur4ZF57yhiNfQcMG6YFPSZ9/n5R6uTT36HqUEgCAqkOgUYq266XOP5C2Xbt63vOnJWOkN49Lv/5VaXFB+oefd7UcAABcYQg0SnH+lPTwl1wQsZIffVv609vdc0ODtP0m6cDfSD/6lvTgxLoUFQCAakKgUYonvyd99NXS7EMr57vvL6WNW6WrnrmU9rTnS79xTLr1ldGWEQCAKkSgEdbPH5b2vnl5+rl56Vtj0r43S41NudPab3a3mn/gk64ppVTWSqdPSCe+K53NXFaxAQCoBMbRCOua2wunf/ez0qVz0nP2F57++Dekw2+Ufiopvegtq6/n1OOuI+mpHy6ltd0o9f6btGVH2FIDQHksLkqy7rX1nhsaXd+0hUuSXVhK96c1Nrn5Fi4sX17TJvd88dzyaY0bXTP0wsXlf9JKXe6l87nlkdx8DY2uvIuXcqeZBmnDRjfPpQId/zc0u229dEGyi3ll2iA1bnBlze+XZ4ybd7VtjWq5q32Ghba1TOov0Eh2SJsCFTU//WfS835Omvpf0md+KzfvTS+R3vBP0oUzUvKm5ct6x9el1uvcpaqS+7KP/KG0a+/yppDHvynd+GNS7IbC5bruTmnfr0pH/kDqeLl09bOW51lclB4cl575Cnely55fdoHN5nYXcJz4jtTS7vJ+9DVS2w3SzS+Vrn2utO06afN2t0PNPizNPCSd/pGb79SPpGckpFsS0vFJ6d//2OXdcpW7kmb7TdJtP+2We3Ja2rjF3d/Ft3Gr2yEvnHFX3AQP2g2bpI0t3gFwwX1GDRvczo/oWOsexiz96C1edD9Q1rrnxib3XS5cdKPb2sXAw0rbn+6WNfuw+5FZXFiavv3p0qY2af6Hbuj94Lwt7e7ePxfPSt//j6X1+Y9nvtLthw99UXrqhJvuL/uGF0g7dksn/tubN1CebddKt7/W/fh/5S+Wl/eFb5E2tUrfHJOeeCB3+jM6pY6XSY9/S5r8qJfurXPrtdLdv+O29VNvly6eyZ23873uGDj6Eem//2UpXVZ61mtcLeWPHpA+838H5ltwn88bPuGW+7f7vc8p8Bm+9s+lp/+Y9OU/l776P73jxjt2bvtp6ZVJ99n/1SuW0v1j613fc89/8zrpsfv9L909vfpPpGe/Tpr8mDT+e9lkyUo3/7j0+r+Vzs1JH7xt+XLf+S133P/DL0jf+5fcMv3k+6QX/Zr07U9IY78SOM6t+/3q+6J7+76r3b4W9Navut+0T79Duv/judNe8k4p8R73fX/sNbnTWq+X/q8H3Ov/9/nSqcdyp7/p0+437l/fL33pT3OnPf8N0s/8ufTkd6W/fFHutMaN0u+dcK8/co/7fQ7q/qh0x73ue/mX38mdduurpJ/7e+mpJ6U/foaW+e1H3H749wek6c/nTnvVH0sv6JG+OSp9oi932q590q96ffXef83y5b79fjfy9Cd/ffkdwl/229JPDErpf5U+/rO507bfLL3ja+71n97ujvWgN4+7427896Wv/GXutH2/Kr36g+6P8Id+fHmZyqT+Ao17fl/aGjhJXh93z7v2Sa94f27e1qe558am5dMktzNJ0vN/UXrmT0lX3Sp945D7Yc8PNF7xfvfDu5LO90oP/4f0d/ulX/6s1LZradqjU9Jn3yU9eswd0NfdKb18oPByFi5JN75I+s5npK//3VL626bcj/jn3+d2dMn9GG69NnBTOO9H/8nvuQP/qSdd044faHz4xa5mJujX7nMBz+cGXMAWdNdvuityfnCf68fiMw1S6y7pnd4B/uG7XOCTDUQapJ/9iDsAvjoife1vXbq8AOXWn5J+/F3uPjP/1OMv1D01Nkm/9Gn3+lNvc8GRP80Y6WX97gf32/8sHfurpXmNcfvB3b/rfohHf3lpHj/P/o+5k/PEe9x3Irt0Un/RW9zn9L0J6QsfyD0JXn2bdO//dIv5yxfnnSQXpTf+sxS7UfrcoPRfn849mb3ordJdb5fSX5BGf2kp3VoXTL71y265H3yWdPqJpenS0o/IxHvcyTnI/xH50bel1Mtyp23cJv0/3r17/u6AC2KDXv/30rNe5favI+/NnXb7z0j7/5f7Qcv/0ZOk331CamiW/i0pff9LudNe+yG3j/7gPunT73T7QUOje376i12gYRekf/+gSws+nv+L7pj8wX3S98Zzp7XvdoHG2VnpB1/xAjBv2ReeWlr//GNu//anm4bAvzyzFCT70/yAe0Oz+/6y6zTu2PJdH3fHUXD6lqvctGufLT33wFK6JF3zbPfc3Crt/RVv9caVIRijP6dLuuku5ezf/rH8tOdJL/2twLxyZZTcH4C7fzdvucbt25IUf6P7w+MzRrrhhe71dXe6YCa43JZALepP/5nbB4PL9a/Ie/4bpZteuvR5Skt/qnbeKt2bUo7gH5pXJpf/hu681T3fca+0M+/Glu3e3bS3Xbd8uSbwZ/Pu31ve9Hz9Hvd8S+fyW0r454XmbcuXK7nPVpLueof03NfnLdc739zwwuXzBj/DQsv1y7Hvze6PYdA1d7jnq+9YPq//nUrueL+UV7vT3uGen9MtXfe83Gk7vEAqdqP0mj+TPvAry8tVBsbmVynVKGNMq6S5ubk5tba2RreiP322dOfrlw5iSToz42oISvkXn/mB9Nevdj+or3i/+1H8yoelB/5Zuvp2t6M8/cWll+dsxvXhOP0j90O7qc2dnO2iO/iDB3Ixly4sVRX+4D7X3+TimaXt2X23W+5j97vyS8r+wLTvdkHI6Sek9L+5akj/sWGT9Lyfd9n/86A7uS8ueNMvSvE3uR+L73xGevDI0r8ka13t0PN/wf2j/vz7lPPPrKFB+hnvpHrkDwNl8vK8oE+6YZ/7d/qNf8j913bd86SX/KYry6felvuvTZLuHXEH7hf/2J2ggyedO1/vPotHjkpTH1uaJuP+Eb/kN90y/s/AUrpf43DXO12T17c/4f51B0+ST3+x+9c285Cb7p+QTKP73ONvcMu9/+Ou5iE47zNfIW29Wnrsa9LJB3PLu/1m6brnum39wVcCy22QGprcOiU3b85yjftx2hxzfYSeOrEUDJgGV8O17RoX8J5+fHlA0LLDLePCU16tS0MgoGh03x+AqjI/P6+2tjZJarPWzpdz2QQaYRUKNP761a524nUjpS3jqSelphbX5PBvH5C+9U/Sj71Vet4vunY4AADWUZSBBme1yzX/mGuC+Jm/WD2vz69SlaQf75de/tvlLxcAAFWAQCOs+Bvd2Bi+b3/C9Rm47TXF51kJ1cgAgDpGoBHWy/pz33/rH6VbfjK3YxgAAJDEgF3hPXa/lHnEvT5/ynWUu+PeypYJAIAqRaAR1qE3uCsOJHf50zu+QaABAEARBBqX4/QJdxlfQ2OlSwIAQFUi0AirscmNgHn6CemDz5T+639XukQAAFQtAo2wNm5xt4v/zmckGenGEINrAQBwhSHQCGvb01ytxg/uc5e5coMzAACK4vLWsH7Bu9nNh1+yNK49AAAoiBqNtVhclOYfXbrRDQAAKIgajbCOvFd64r+kd00vv1UyAADIESrQMMZ0SOqSlJbUISllrc2EzWuM8e+BG5O0T9Iha+2UNy0uyZ++T1JPsXVUxIWnpNmH3dDhDc2VLg0AAFUtbI3GqLV2j5QNJA5K6l5D3lFJ91hrJ4wx7d773d60hLV22JuvX9IRSXtCljM6G7dITzwgpV4u9fxrabeGBwDgClVyHw0vWMiy1qa1VPMQNm+3X4PhyXjzxSUNBtLHJMXzl1dRG7e65/nHCDIAAFhFmM6gCUkzeWkzXnAQKq+1diKQ3i1pxEufktQTmBbz581fgTGm2RjT6j8kbSt1Qy6LH2i0XLVyPgAAECrQiBVJb19LXmNM3BiTlDRurU356dbasUD+A5ImivTRGJQ0F3gcL1bwsnrWq6QtO6WWQpsNAACCynF5a2wteb3aiyFJu40xXfkZjTExuc6kxfqADElqCzx2hSjH2rXtkq6+XdpCjQYAAKsJ0xk0o+W1F+1e+pryWmszxphRSePGmO15NRdJSZ3Frjix1p6XdN5/b9arv8Tsw+45/sb1WR8AADUsTI3GRJH0Y2HyGmMSxpjZQFrae852+PSuNklaa9PGmJhXu1EdTj0uPfQFNxQ5AABYUcmBhnflSJZ3JcixwNgY2atDVsk7o9xAJC4pExhHo0vSlB9kSNpfVeNobNzinh/5amXLAQBADQg7jka314HzqNxgWsH+E4Ne+vBKea21U8aYQ8aYXi9fp7xxMryAZNR77S83IynbWbTiFhfc82P3S3veVNmyAABQ5Yy1ttJlKAvvEte5ubk5tba2RreihYvSJ39DSrxbaqX5BABQ++bn59XW1iZJbdba+XIum3udhNXYJL1upNKlAACgJnD3VgAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEBkCDQAAEJkNYTIbYzokdUlKS+qQlLLWZsLmNcYkvGwxSfskHbLWToVdBwAAqG6hAg1Jo9baPVI2IDgoqXsNeUcl3WOtnTDGtHvvd69hHQAAoIqV3HTinfSzrLVpSYk15u32azA8mbDrAAAA1S9MH42EpJm8tBljTDxsXmvtRCC9W9LIGtYBAACqXJimk1iR9Pa15PWChwOSxq21qbDrMMY0S2oOJG0rMi8AAKiQclx1EltLXq/pZEjSbmNM1xrWMShpLvA4HqIcAABgHYQJNDJaXrPQ7qWvKa93NcmopFFjTCzkOoYktQUeu4oXHQAAVEKYQGOiSPqxMHmNMQljzGwgLe09d4RZh7X2vLV23n9IOlVkXgAAUCEl99Gw1qaNMdn33hUixwJjY8QlZay16ZXyGmNmlBtQ+PP542gUXQcAAKgtYcfR6DbGJCUdlRtoKzi+xaCXPrxSXmvtlDHmkDGm18vXKWlPiesAAAA1xFhrK12GsjDGtEqam5ubU2tra6WLAwBAzZifn1dbW5sktXndEcqGe50AAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIEGgAAIDIbAiT2RjTIalLUlpSh6SUtTYTNq8xJi4p4WXdJ6knMK3DmzbjzTdmrU2HKScAAKgOoQINSaPW2j1SNiA4KKl7DXkT1tphb1q/pCOS9njTuvxp3vQRSX0hywkAAKpAyU0nXrCQ5dUyJMLm9WozBgOTxyTFA/McKLVMAACguoXpo+E3ZwTNeIFDyXmttVOSegLpMX96IN+kMabDGJOQNB6ijAAAoIqECTRiRdLbw+a11o4F0g5Imgj09fCbV6YldeflzTLGNBtjWv2HpG3Fiw4AACohbB+NQmJrzWuMicl1GN0TSE5IGpDrCDpijJG1tlAfjUFJ7w5TUAAAsL7C1GhktLz2ot1LX2vepKTOvCtO9llrJ6y1KUm7Je3P7/PhGZLUFnjsKm0zAADAegkTaEwUST+2lrze1SZJa23aGBPzajfiko76ebxOpEMqUGtirT1vrZ33H5JOlbQVAABg3ZQcaOSPZeHVMhwLjo3h1zyUkLdL0pQfZEja702bkhtXI2iH14EUAADUGGOtLT2zCxj65God9kkaCgQPo5KOBsbHKJjXS5/OW3TGWrvdmy8hV7OR8aZNlDJgl9chdG5ubk6tra0lbxMAAFe6+fl5tbW1SVKb10pQNqECjWpGoAEAwNpEGWhwrxMAABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAg0AABAZAo0SnTp3Ue889DXd9nuf0ye/9miliwMAQE3YECazMaZDUpektKQOSSlrbSZsXmNMXFLCy7pPUk9wOcaYhDdPWpKstRNhyhmFf5w8rv/99cd0adFq+onTlS4OAAA1IVSgIWnUWrtHygYSByV1ryFvwlo77E3rl3REkp83IanbWtvnzTcuaXfIcpbdidPndU3rpkoXAwCAmlJy04l30s+y1qa1VCtRcl6vNmMwMHlMUjwwz4ikgcB8naWWMUqzZy5q+5amShcDAICaEqaPRkLSTF7ajBc4lJzXWjslqSeQHgtM75DUbq3NGGPixpiYF2xUXObMBW1v2VjpYgAAUFPCBBqxIuntYfNaa8cCaQckTXh9NOJyAYfft6PXe72MMabZGNPqPyRtW3ULLsPsUxcVI9AAACCUsH00ComtNa8xJibXYXSPl9Qu1wl0wqvVSEmalWQKLGtQ0rtDlnXNZs9c0DOu3rpeqwMAoC6EqdHIaHntRbuXvta8SUmdgStO0pIy/vu8q1TyDUlqCzx2rVL+y5I5c1HbW+ijAQBAGGECjWKXmB5bS17vapOktTZtjIl5tRsl98ew1p631s77D0mnSp13LWbPXKDpBACAkEoONPI7ZXodN48Fax38K0dKyNslacoPMiTtt9ZmvPmOeWn+fGmvA2nFnL2woPOXFrnqBACAkML20eg2xiQlHZUbaCs4hsaglz68Ul4veBj1XvvzZiSl/PkkJY0xk3J9Nyp+eevsmQuSRI0GAAAhhQo0vBqHAe/tWN607lLyeumFOnf60zOS+sKUK2qZMxclSbHN1GgAABAG9zopwaXFRUlS84bGCpcEAIDaQqABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ABAAAiQ6ARUlOj0blLi5UuBgAANYFAI6S2lo3KnLlQ6WIAAFATCDRC2t7SpMyZi5UuBgAANWFDpQtQbqkvTmvzlm1lXebjc+eyr2Obm/RY5twKuaUHnzit/+8/HtKXH3xSZy4saEvzBt3+tFbtuXG7XtjRrtuubVVDg1lxGQuLVidPn9cTp87r/KUFLSy6tOamBm1r3qBtm5q0ddMGtTQ1rrqsYqy1urRoZa1kjGQkGWO8Z/e6XljrttP6ryXvvUuX934xO20pjwL5Cs2vbHpuvsVFm11usfmVkx7Il1e2xSLlXzZ/qWWz/rTg+kosm5cv5zPLm3/5Z5b7XsFyBl4vBpabk7/o97rCtBXmXGm+ldgVZly5LCstc5V1rnE7VlzsWj+AyxHB70kUv1BR/OyZCEpa7nKee+p0eRcYUHeBxsfv+74aN20p+3JvbG/RNa3NirVs1AM/nC+Y5+yFBSU/9x197L6HtXNrs1793OsU27xRmbMX9K1H5/SBz31HFy4tqnWTCzx2bW/R5qZGbWg0mj97SU+ePq8nT5/XiVPuebGE3wJjpE0bGrV5Y6M2NzVqU1ODNjQ06NLioi4tWl1asLq4sKiFxcDzotWlhcWSl78sAJFLDL43Rmrw8ig4T4H5JSM/Nip8Ult+ElKBad5cbjtWPJmj0krdjxrMUp78/WjF5a+47pVnXu33euXZV1n2ZZV7tXmLZ7ic9UYhisMwimN7paBuzcuMpJzld+nsUxEs1am7QOOLA3ertbU1suXHWpo0W6DpZPL7M3rX6Df0aOasfudVt+kNP/Z0NW9ozMlz7uKCvvZIRv/50Iy++6NTevCJ07pwaVGXFhe1tXmDrtrarDtviGnn1mZd07pJV29r1s5tzWrZ6GotGo3RuUsLOn3ukk6du6RT5y/p9LlLOntxQee8x9kLC7q0aNXUaNTY0KANDUYbGo2aGhvU2GC0oWHptZ/HaOV/o8F/rMX+iWbnX+GfrAJ5Fu3Sj2F+DUoweMmZHkwzSz+z2ZOTd2JS3sls6SSXf3LzT2yFl11ofml58NTQsHy5hebXsuWt8LrgNgfmX21ZxeZfoWwN2WkFgoESll1w/jqqFQPq2fz8vNreH82y6y7QiNr2lo2aO3NR1lrNn72k+9In9amvP6rPfvNx3bmrTZ95+0v1jKu3Fpx3U1OjXtSxQy/q2LHOpQYAoDIINEKKtTTpwsKifvsfv6nDk4/IWummHS36o67n6nXxXWpcY38JAADqEYFGSLGWjZKkQ8ce0btecatee+fTdEN7S4VLBQBAdSLQCCm2uUmStKmpQb/+E8+ocGkAAKhujKMRUqzFBRqvuOPaCpcEAIDqR41GSDe2t+gPXnuHXhe/vtJFAQCg6hFohGSM0ZtefFOliwEAQE2g6QQAAEQmVI2GMaZDUpektKQOSSlrbSZsXmNMXFLCy7pPUk+h5RhjkpKGiq0DAABUt7BNJ6PW2j1SNpA4KKl7DXkT1tphb1q/pCOS9gRn9oKRfklDIcsIAACqRMlNJ16wkGWtTWupVqLkvF4AMRiYPCYpnj+PXC1IutTyAQCA6hOmj0ZC0kxe2owXOJSc11o7JaknkB7zp/sJxpgua+1YiLIBAIAqFKbpJFYkvT1s3rwg4oCkiUD/jZikzGqFMcY0S2oOJJX33vAAAOCyleOqk9ha83pBRZdy+3nst9ZOlLCsQUlzgcfxEOUAAADrIEygkdHy2ot2Fa59KDVvUlJnoDYjIelwieUZktQWeOwqcT4AALBOwgQaxWoZjq0lr3e1SdJamzbGxLzaDUnab4zpNcb0ynUIHSzUD8Rae95aO+8/JJ0qeUsAAMC6KLmPhhcQZN97V4kcyxsbI2OtTZeQt0vSlB9kyDWXpJQXoBhjRiSNeFetAACAGhN2HI1ubxCto3IDbQX7Vgx66cMr5fWCjlHvtT9vRlLKf+MFH73e2wFjzIh3tQoAAKghxlpb6TKUhTGmVdLcI488otbW1koXBwCAmjE/P68bbrhBktq87ghlU083VWuX5H9QAAAgvHZJBBpF+AN+7VJ9dwzdJncpL9tZP66UbWU76wvbWV/87cwfbPOy1VOg4TtV7mqfahLo18J21okrZVvZzvrCdtaX4AUc5cZt4gEAQGQINAAAQGTqKdA4L+kPvOd6xnbWnytlW9nO+sJ21pfItrNuLm8FAADVp55qNAAAQJUh0AAAAJGpqctbveHLuySl5W64lvLvn3I5eauRd++YhPd2n6SeFbY1LknW2ilvu2O1MmR7mLLX8nfq3d9nQpJWK3MtfZ9eWQ9aa/fkpdfdsbrCttbVsbrKdtbNsbrCdtbVsbrS/rlux6m1tmYekiYDrzskjZYjbzU+JPUHXwe3p0DeEUnWe4zL7ewV34YSt7PkstfydxrYxuCjv0jemvg+vR+duPsZWft3VQvf6yrbWjfH6irbWTfH6irbWVfH6kr753odpxX/EEJ8WB35B7Ck2cvNW40P7wCYDbzv8HbkjiL5eyXFqnEnL2FbSyp7LX+n3vZ15aUV/OGqxe8z/8e6no/VAttal8dqkRNw3R2rBb7PujpWV9o/1/M4raU+GgktHxp1xq+6uoy8Vce6qreeQFLMey46NKy1NmOrrGqyVCWWvda/0zH/tVc1O7ZC9pr+PsWxKnGs1vJ3WjfH6ir757odp7XURyNWJL39MvNWpeDOLumApIkVduaYd0BIrg1uxFqbjrJ8ZVRq2WNF5q/67zT4vRljYpLaV/l+avn7lDhWOVYLq/rvtB6P1WL7p7d9hZT9OK2lQKOYWER5q4K3M3RJ2rNCtmynHGNMWq6tcHfkhSuPyy17LIIyRSkpaWCVPLX8fa4kFlHeqsCxuqpYBGWKUl0dqyXun1IEx2ktNZ1ktDx6avfSLydvtUtK6lylaq4j8DotqcPrIVwLSi17RjX+nXoHeqKEatZa/j4ljtXMCnlq+bvlWF2ulr7P/P0zo3U6Tmsp0Jgokn7sMvNWLWNMv6SktTZtjIkVqury2siOFJi97Lf6LbeQZa+H73SvVjkwa/n7DOBY5VgtpJa+07o6Vovsn+t2nNZMoJHf7uVFjccC1VZxP5JcLW8t8Nr9pvwdQ9L+QtsqF0UHq/cSksZqZFtXLHu9fadyPcCX/QjVw/cZPLHW+7GaH0TU67Gat511e6wW6atQN8dqsf1zPY/TmrrXibdxfZKOynW8GQp8KKOSjlprh1fLW+28sk/nJWestdu96fnb6g/IkpG021q7Wrti1Vip7PX0nUrZfxW7rbV9eek1+X0aYxKSOuWuzR+W24Yxb1pdHavFtrXejtVVvtO6OVZX2k5vel0cqyXsn+tynNZUoAEAAGpLzTSdAACA2kOgAQAAIkOgAQAAIkOgAQAAIkOgAQAAIkOgAQAAIkOgAaBqeYMGJb1xDwpN7/Wmx9a5aABKRKABQJIbxMgYM22M6fdO4JPewz+ZT/u3hfbSu1ZbZhl0yN0Rs+AQyNbalNwAQlV/Z1DgSlUPd28FUB4xuZsupSXJGNMpacY7mcsYc0juxD8lN/RyLd27AkCFUKMBwNeef0+DIGvtlLyaA2vtRDUNKQ2gehFoAPAdLlMeAMii6QSAJKmUGgprbcbrp3FQru9EyuuomZQ0IndHyw65G1YNyDXHJJR3gypvnriXf18pN6Py7zzpzRMrdT4AlUWgASAUa+2U11/Dfz9hjJmQ69/RLUnGmG5JXd6dH6e8jqQxL1DpkJS01u7x8rYbY/r9u0SuoFfudtcT/nxRbB+A8iLQAFAOJ72HLyNX8xB83+4990maybtkdV8J6xiTNGmMSUs6JCm19uICWC8EGgCikllh2lTeJaulBA0z1trtXtPNAUmjck00AKoYnUEBrFVsjdMPyfXbyCo2IFeeQWNMh7V2yuubkSlhHgAVRo0GgBzeSb9DrrOmjDG9ko55l7cqUKMwY4wZkwsoDnjTJvLmnZILKjokDRhjBrw+HgPGmKTcYFuSVHBArjwnJSWMMTNyzTCHVskPoAoYa22lywAABXmjj06tNL5HKXkAVA5NJwAAIDIEGgAAIDIEGgCqWVpS30p3b5W7NHZmXUsFoGT00QAAAJGhRgMAAESGQAMAAESGQAMAAESGQAMAAESGQAMAAESGQAMAAESGQAMAAESGQAMAAESGQAMAAETm/wd3Wf6CsSiuLwAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(<Figure size 600x400 with 1 Axes>, <AxesSubplot:xlabel='Time [s]'>)"
+      ]
+     },
+     "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
+}


Test patch:
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,
                         )