Repository: CURENT/andes (language: python)

Issue:
Fix pandapower add_gencost
Change ``add_gencost`` to work on all generators rather than controllable ones, which will be easier to use if there are uncontrollable generators that will participate in scheduling later


Discussion / hints:

Fix patch:
diff --git a/.flake8 b/.flake8
index 5b1e3952e..80ea75bf9 100644
--- a/.flake8
+++ b/.flake8
@@ -1,3 +1,3 @@
 [flake8]
-exclude = .git,__pycache__,build,dist,demos,cases,cards,versioneer.py,texttable.py,andes/_version.py,docs/source/conf.py,benchmarks,andes/pycode,scripts,.history
+exclude = .git,__pycache__,build,dist,demos,cases,cards,versioneer.py,andes/_version.py,docs/source/conf.py,benchmarks,andes/pycode,scripts,.history
 max-line-length=115
diff --git a/LICENSE b/LICENSE
index f5a90c11c..74ae8d9ea 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 ANDES: Python Software for Symbolic Power System Modeling and Numerical Analysis
 
-Copyright (c) 2015-2021 Hantao Cui
+Copyright (c) 2015-2022 Hantao Cui
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -670,7 +670,7 @@ Also add information on how to contact you by electronic and paper mail.
   If the program does terminal interaction, make it output a short
 notice like this when it starts in an interactive mode:
 
-    ANDES  Copyright (C) 2015-2021 Hantao Cui
+    ANDES  Copyright (C) 2015-2022 Hantao Cui
     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
     This is free software, and you are welcome to redistribute it
     under certain conditions; type `show c' for details.
diff --git a/andes/cases/ieee14/ieee14_full.xlsx b/andes/cases/ieee14/ieee14_full.xlsx
new file mode 100644
index 000000000..01781a769
Binary files /dev/null and b/andes/cases/ieee14/ieee14_full.xlsx differ
diff --git a/andes/cases/ieee14/ieee14_regcp1.xlsx b/andes/cases/ieee14/ieee14_regcp1.xlsx
new file mode 100644
index 000000000..615954d75
Binary files /dev/null and b/andes/cases/ieee14/ieee14_regcp1.xlsx differ
diff --git a/andes/core/__init__.py b/andes/core/__init__.py
index 80120b1af..e4155d027 100644
--- a/andes/core/__init__.py
+++ b/andes/core/__init__.py
@@ -16,3 +16,4 @@
                                 OperationService, RandomService,)
 from andes.core.var import (Algeb, BaseVar, ExtAlgeb, ExtState, ExtVar,  # NOQA
                             State,)
+from andes.core.symprocessor import SymProcessor  # NOQA
diff --git a/andes/core/block.py b/andes/core/block.py
index 4a19c1eb1..f90973e85 100644
--- a/andes/core/block.py
+++ b/andes/core/block.py
@@ -1,4 +1,4 @@
-#  [ANDES] (C)2015-2021 Hantao Cui
+#  [ANDES] (C)2015-2022 Hantao Cui
 #
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
diff --git a/andes/core/discrete.py b/andes/core/discrete.py
index c2582d02d..35e1d73e3 100644
--- a/andes/core/discrete.py
+++ b/andes/core/discrete.py
@@ -1,4 +1,4 @@
-#  [ANDES] (C)2015-2021 Hantao Cui
+#  [ANDES] (C)2015-2022 Hantao Cui
 #
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -446,6 +446,7 @@ def check_var(self,
                   allow_adjust=True,  # allow flag from model
                   adjust_lower=False,
                   adjust_upper=False,
+                  is_init: bool = False,
                   *args, **kwargs):
         """
         Check the input variable and set flags.
@@ -458,7 +459,7 @@ def check_var(self,
             upper_v = -self.upper.v if self.sign_upper.v == -1 else self.upper.v
 
             # FIXME: adjust will not be successful when sign is -1
-            if self.allow_adjust and allow_adjust and adjust_upper:
+            if self.allow_adjust and is_init:
                 self.do_adjust_upper(self.u.v, upper_v, allow_adjust, adjust_upper)
 
             if self.equal:
@@ -470,7 +471,7 @@ def check_var(self,
             lower_v = -self.lower.v if self.sign_lower.v == -1 else self.lower.v
 
             # FIXME: adjust will not be successful when sign is -1
-            if self.allow_adjust and allow_adjust and adjust_lower:
+            if self.allow_adjust and is_init:
                 self.do_adjust_lower(self.u.v, lower_v, allow_adjust, adjust_lower)
 
             if self.equal:
@@ -507,9 +508,14 @@ def _show_adjust(self, val, old_limit, mask, limit_name, adjusted=True):
         """
         Helper function to show a table of the adjusted limits.
         """
+
         idxes = np.array(self.owner.idx.v)[mask]
+        if isinstance(val, (int, float)):
+            val = np.array([val])
+        if isinstance(old_limit, (int, float)):
+            old_limit = np.array([old_limit])
 
-        adjust_or_not = 'adjusted' if adjusted else 'unadjusted'
+        adjust_or_not = 'adjusted' if adjusted else '*not adjusted*'
 
         tab = Tab(title=f"{self.owner.class_name}.{self.name}: {adjust_or_not} limit <{limit_name}>",
                   header=['Idx', 'Input', 'Old Limit'],
diff --git a/andes/core/model/__init__.py b/andes/core/model/__init__.py
new file mode 100644
index 000000000..0dbfbd489
--- /dev/null
+++ b/andes/core/model/__init__.py
@@ -0,0 +1,8 @@
+"""
+Package for classes for modeling
+"""
+
+from .model import Model  # NOQA
+from .modeldata import ModelData  # NOQA
+from .modelcall import ModelCall  # NOQA
+from .modelcache import ModelCache  # NOQA
diff --git a/andes/core/model.py b/andes/core/model/model.py
similarity index 78%
rename from andes/core/model.py
rename to andes/core/model/model.py
index 2c0156598..56beb3d84 100644
--- a/andes/core/model.py
+++ b/andes/core/model/model.py
@@ -1,474 +1,43 @@
-"""
-Base class for building ANDES models.
-"""
-#  [ANDES] (C)2015-2021 Hantao Cui
+#  [ANDES] (C)2015-2022 Hantao Cui
 #
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
 #  the Free Software Foundation; either version 3 of the License, or
 #  (at your option) any later version.
 #
-#  File name: model.py
+
+"""
+Module for ANDES models.
+"""
 
 import logging
 import pprint
 from collections import OrderedDict
-from typing import Iterable, Sized, Union, Callable
+from typing import Callable, Iterable, Union
 
+import numpy as np
 import scipy as sp
-
 from andes.core.block import Block
 from andes.core.common import Config, JacTriplet, ModelFlags
 from andes.core.discrete import Discrete
 from andes.core.documenter import Documenter
-from andes.core.param import (BaseParam, DataParam, ExtParam, IdxParam,
-                              NumParam, TimerParam, )
+from andes.core.model.modelcache import ModelCache
+from andes.core.model.modelcall import ModelCall
+from andes.core.param import ExtParam
 from andes.core.service import (ApplyFunc, BackRef, BaseService, ConstService,
                                 DeviceFinder, ExtService, FlagValue,
                                 InitChecker, NumReduce, NumRepeat, NumSelect,
                                 ParamCalc, PostInitService, RandomService,
-                                Replace, SwBlock, VarService, )
+                                Replace, SubsService, SwBlock, VarService)
 from andes.core.symprocessor import SymProcessor
 from andes.core.var import Algeb, BaseVar, ExtAlgeb, ExtState, State
-from andes.shared import jac_full_names, jac_names, jac_types, np, pd, numba
+from andes.shared import jac_full_names, numba
 from andes.utils.func import list_flatten
 from andes.utils.tab import Tab
 
 logger = logging.getLogger(__name__)
 
 
-class ModelCache:
-    """
-    Class for caching the return value of callback functions.
-
-    Check ``ModelCache.__dict__.keys()`` for fields.
-    """
-
-    def __init__(self):
-        self._callbacks = {}
-
-    def __getattr__(self, item):
-        if item == "_callbacks":
-            return self.__getattribute__(item)
-
-        if item not in self.__dict__:
-            if item in self._callbacks:
-                self.__dict__[item] = self._call(item)
-
-        return self.__getattribute__(item)
-
-    def __getstate__(self):
-        return self.__dict__
-
-    def add_callback(self, name: str, callback):
-        """
-        Add a cache attribute and a callback function for updating the attribute.
-
-        Parameters
-        ----------
-        name : str
-            name of the cached function return value
-        callback : callable
-            callback function for updating the cached attribute
-        """
-        self._callbacks[name] = callback
-
-    def refresh(self, name=None):
-        """
-        Refresh the cached values
-
-        Parameters
-        ----------
-        name : str, list, optional
-            name or list of cached to refresh, by default None for refreshing all
-
-        """
-        if name is None:
-            for name in self._callbacks.keys():
-                self.__dict__[name] = self._call(name)
-        elif isinstance(name, str):
-            self.__dict__[name] = self._call(name)
-        elif isinstance(name, list):
-            for n in name:
-                self.__dict__[n] = self._call(n)
-
-    def _call(self, name):
-        """
-        Helper function for calling callback functions.
-
-        Parameters
-        ----------
-        name : str
-            attribute name to be updated
-
-        Returns
-        -------
-        callback result
-        """
-        if name not in self._callbacks:
-            return None
-        else:
-            if callable(self._callbacks[name]):
-                return self._callbacks[name]()
-            else:
-                return self._callbacks[name]
-
-
-class ModelData:
-    r"""
-    Class for holding parameter data for a model.
-
-    This class is designed to hold the parameter data separately from model equations.
-    Models should inherit this class to define the parameters from input files.
-
-    Inherit this class to create the specific class for holding input parameters for a new model.
-    The recommended name for the derived class is the model name with ``Data``. For example, data for `GENROU`
-    should be named `GENROUData`.
-
-    Parameters should be defined in the ``__init__`` function of the derived class.
-
-    Refer to :py:mod:`andes.core.param` for available parameter types.
-
-    Attributes
-    ----------
-    cache
-        A cache instance for different views of the internal data.
-
-    flags : dict
-        Flags to control the routine and functions that get called. If the model is using user-defined
-        numerical calls, set `f_num`, `g_num` and `j_num` properly.
-
-    Notes
-    -----
-    Three default parameters are pre-defined in ``ModelData``
-    and will be inherited by all models. They are
-
-    - ``idx``, unique device idx of type :py:class:`andes.core.param.DataParam`
-    - ``u``, connection status of type :py:class:`andes.core.param.NumParam`
-    - ``name``, (device name of type :py:class:`andes.core.param.DataParam`
-
-    In rare cases one does not want to define these three parameters,
-    one can pass `three_params=True` to the constructor of ``ModelData``.
-
-    Examples
-    --------
-    If we want to build a class ``PQData`` (for static PQ load) with three parameters, `Vn`, `p0`
-    and `q0`, we can use the following ::
-
-        from andes.core.model import ModelData, Model
-        from andes.core.param import IdxParam, NumParam
-
-        class PQData(ModelData):
-            super().__init__()
-            self.Vn = NumParam(default=110,
-                               info="AC voltage rating",
-                               unit='kV', non_zero=True,
-                               tex_name=r'V_n')
-            self.p0 = NumParam(default=0,
-                               info='active power load in system base',
-                               tex_name=r'p_0', unit='p.u.')
-            self.q0 = NumParam(default=0,
-                               info='reactive power load in system base',
-                               tex_name=r'q_0', unit='p.u.')
-
-    In this example, all the three parameters are defined as
-    :py:class:`andes.core.param.NumParam`.
-    In the full `PQData` class, other types of parameters also exist.
-    For example, to store the idx of `owner`, `PQData` uses ::
-
-        self.owner = IdxParam(model='Owner', info="owner idx")
-
-    """
-
-    def __init__(self, *args, three_params=True, **kwargs):
-        self.params = OrderedDict()
-        self.num_params = OrderedDict()
-        self.idx_params = OrderedDict()
-        self.timer_params = OrderedDict()
-        self.n = 0
-        self.uid = {}
-
-        if not hasattr(self, 'cache'):
-            self.cache = ModelCache()
-        self.cache.add_callback('dict', self.as_dict)
-        self.cache.add_callback('df', lambda: self.as_df())
-        self.cache.add_callback('dict_in', lambda: self.as_dict(True))
-        self.cache.add_callback('df_in', lambda: self.as_df(vin=True))
-
-        if three_params is True:
-            self.idx = DataParam(info='unique device idx')
-            self.u = NumParam(default=1, info='connection status', unit='bool', tex_name='u')
-            self.name = DataParam(info='device name')
-
-    def __len__(self):
-        return self.n
-
-    def __setattr__(self, key, value):
-        if isinstance(value, BaseParam):
-            value.owner = self
-            if not value.name:
-                value.name = key
-
-            if key in self.__dict__:
-                logger.warning("%s: redefining <%s>. This is likely a modeling error.",
-                               self.class_name, key)
-
-            self.params[key] = value
-
-        if isinstance(value, NumParam):
-            self.num_params[key] = value
-        elif isinstance(value, IdxParam):
-            self.idx_params[key] = value
-
-        # `TimerParam` is a subclass of `NumParam` and thus tested separately
-        if isinstance(value, TimerParam):
-            self.timer_params[key] = value
-
-        super(ModelData, self).__setattr__(key, value)
-
-    def add(self, **kwargs):
-        """
-        Add a device (an instance) to this model.
-
-        Warnings
-        --------
-        This function is not intended to be used directly.
-        Use the ``add`` method from System so that the index
-        can be registered correctly.
-
-        Parameters
-        ----------
-        kwargs
-            model parameters are collected into the kwargs dictionary
-        """
-        idx = kwargs['idx']
-        self.uid[idx] = self.n
-        self.n += 1
-        if "name" in self.params:
-            name = kwargs.get("name")
-            if (name is None) or (not isinstance(name, str) and np.isnan(name)):
-                kwargs["name"] = idx
-
-        if "idx" not in self.params:
-            kwargs.pop("idx")
-
-        for name, instance in self.params.items():
-            value = kwargs.pop(name, None)
-            instance.add(value)
-        if len(kwargs) > 0:
-            logger.warning("%s: unused data %s", self.class_name, str(kwargs))
-
-    def as_dict(self, vin=False):
-        """
-        Export all parameters as a dict.
-
-        Returns
-        -------
-        dict
-            a dict with the keys being the `ModelData` parameter names
-            and the values being an array-like of data in the order of adding.
-            An additional `uid` key is added with the value default to range(n).
-        """
-        out = dict()
-        out['uid'] = np.arange(self.n)
-
-        for name, instance in self.params.items():
-            # skip non-exported parameters
-            if instance.export is False:
-                continue
-
-            out[name] = instance.v
-
-            # use the original input if `vin` is True
-            if (vin is True) and hasattr(instance, 'vin') and (instance.vin is not None):
-                out[name] = instance.vin
-
-            conv = instance.oconvert
-            if conv is not None:
-                out[name] = np.array([conv(item) for item in out[name]])
-
-        return out
-
-    def as_df(self, vin=False):
-        """
-        Export all parameters as a `pandas.DataFrame` object.
-        This function utilizes `as_dict` for preparing data.
-
-        Returns
-        -------
-        DataFrame
-            A dataframe containing all model data. An `uid` column is added.
-        vin : bool
-            If True, export all parameters from original input (``vin``).
-        """
-        if vin is False:
-            out = pd.DataFrame(self.as_dict()).set_index('uid')
-        else:
-            out = pd.DataFrame(self.as_dict(vin=True)).set_index('uid')
-
-        return out
-
-    def update_from_df(self, df, vin=False):
-        """
-        Update parameter values from a DataFrame.
-
-        Adding devices are not allowed.
-        """
-        if vin is False:
-            for name, instance in self.params.items():
-                if instance.export is False:
-                    continue
-                instance.set_all('v', df[name])
-        else:
-            for name, instance in self.params.items():
-                if instance.export is False:
-                    continue
-                try:
-                    instance.set_all('vin', df[name])
-                    instance.v[:] = instance.vin * instance.pu_coeff
-                except KeyError:
-                    # fall back to `v`
-                    instance.set_all('v', df[name])
-
-        return True
-
-    def find_param(self, prop):
-        """
-        Find params with the given property and return in an OrderedDict.
-
-        Parameters
-        ----------
-        prop : str
-            Property name
-
-        Returns
-        -------
-        OrderedDict
-        """
-        out = OrderedDict()
-        for name, instance in self.params.items():
-            if instance.get_property(prop) is True:
-                out[name] = instance
-
-        return out
-
-    def find_idx(self, keys, values, allow_none=False, default=False):
-        """
-        Find `idx` of devices whose values match the given pattern.
-
-        Parameters
-        ----------
-        keys : str, array-like, Sized
-            A string or an array-like of strings containing the names of parameters for the search criteria
-        values : array, array of arrays, Sized
-            Values for the corresponding key to search for. If keys is a str, values should be an array of
-            elements. If keys is a list, values should be an array of arrays, each corresponds to the key.
-        allow_none : bool, Sized
-            Allow key, value to be not found. Used by groups.
-        default : bool
-            Default idx to return if not found (missing)
-
-        Returns
-        -------
-        list
-            indices of devices
-        """
-        if isinstance(keys, str):
-            keys = (keys,)
-            if not isinstance(values, (int, float, str, np.floating)) and not isinstance(values, Iterable):
-                raise ValueError(f"value must be a string, scalar or an iterable, got {values}")
-
-            if len(values) > 0 and not isinstance(values[0], (list, tuple, np.ndarray)):
-                values = (values,)
-
-        elif isinstance(keys, Sized):
-            if not isinstance(values, Iterable):
-                raise ValueError(f"value must be an iterable, got {values}")
-
-            if len(values) > 0 and not isinstance(values[0], Iterable):
-                raise ValueError(f"if keys is an iterable, values must be an iterable of iterables. got {values}")
-
-            if len(keys) != len(values):
-                raise ValueError("keys and values must have the same length")
-
-        v_attrs = [self.__dict__[key].v for key in keys]
-
-        idxes = []
-        for v_search in zip(*values):
-            v_idx = None
-            for pos, v_attr in enumerate(zip(*v_attrs)):
-                if all([i == j for i, j in zip(v_search, v_attr)]):
-                    v_idx = self.idx.v[pos]
-                    break
-            if v_idx is None:
-                if allow_none is False:
-                    raise IndexError(f'{list(keys)}={v_search} not found in {self.class_name}')
-                else:
-                    v_idx = default
-
-            idxes.append(v_idx)
-
-        return idxes
-
-
-class ModelCall:
-    """
-    Class for storing generated function calls, Jacobian calls, and arguments.
-    """
-
-    def __init__(self):
-        self.md5 = ''
-
-        # `f` and `g` are callables generated by lambdify that take positional args
-        self.f = None
-        self.g = None
-        self.j = dict()
-        self.s = OrderedDict()
-
-        # `f_args` and `g_args` are the arg names
-        self.f_args = list()
-        self.g_args = list()
-        self.j_args = dict()
-        self.ia = OrderedDict()
-        self.ii = OrderedDict()
-        self.ij = OrderedDict()
-        self.s_args = OrderedDict()
-        self.ia_args = OrderedDict()  # assignment initialization
-        self.ii_args = OrderedDict()  # iterative initialization
-        self.ij_args = OrderedDict()
-
-        self.ijac = OrderedDict()
-        self.jjac = OrderedDict()
-        self.vjac = OrderedDict()
-
-    def clear_ijv(self):
-        for jname in jac_names:
-            for jtype in jac_types:
-                self.ijac[jname + jtype] = list()
-                self.jjac[jname + jtype] = list()
-                self.vjac[jname + jtype] = list()
-
-    def append_ijv(self, j_full_name, ii, jj, vv):
-        if not isinstance(ii, int):
-            raise ValueError("i index must be an integer")
-        if not isinstance(jj, int):
-            raise ValueError("j index must be an integer")
-        if not isinstance(vv, (int, float)) and (not callable(vv)):
-            raise ValueError("v must be a number or a callable")
-
-        self.ijac[j_full_name].append(ii)
-        self.jjac[j_full_name].append(jj)
-        self.vjac[j_full_name].append(vv)
-
-    def zip_ijv(self, j_full_name):
-        """
-        Return a zipped iterator for the rows, cols and vals for the specified matrix name.
-        """
-        return zip(self.ijac[j_full_name],
-                   self.jjac[j_full_name],
-                   self.vjac[j_full_name])
-
-
 class Model:
     r"""
     Base class for power system DAE models.
@@ -624,7 +193,10 @@ def __init__(self, system=None, config=None):
 
         self.services = OrderedDict()  # service/temporary variables
         self.services_var = OrderedDict()  # variable services updated each step/iter
+        self.services_var_seq = OrderedDict()
+        self.services_var_nonseq = OrderedDict()
         self.services_post = OrderedDict()  # post-initialization storage services
+        self.services_subs = OrderedDict()  # to-be-substituted services
         self.services_icheck = OrderedDict()  # post-initialization check services
         self.services_ref = OrderedDict()  # BackRef
         self.services_fnd = OrderedDict()  # services to find/add devices
@@ -634,10 +206,6 @@ def __init__(self, system=None, config=None):
         self.tex_names = OrderedDict((('dae_t', 't_{dae}'),
                                       ('sys_f', 'f_{sys}'),
                                       ('sys_mva', 'S_{b,sys}'),
-                                      ('__zeros', '0'),
-                                      ('__ones', '1'),
-                                      ('__falses', '0'),
-                                      ('__trues', '1'),
                                       ))
 
         # Model behavior flags
@@ -676,6 +244,9 @@ def __init__(self, system=None, config=None):
         # cached class attributes
         self.cache.add_callback('all_vars', self._all_vars)
         self.cache.add_callback('iter_vars', self._iter_vars)
+        self.cache.add_callback('input_vars', self._input_vars)
+        self.cache.add_callback('output_vars', self._output_vars)
+
         self.cache.add_callback('all_vars_names', self._all_vars_names)
         self.cache.add_callback('all_params', self._all_params)
         self.cache.add_callback('all_params_names', self._all_params_names)
@@ -731,8 +302,14 @@ def _register_attribute(self, key, value):
             # store VarService in an additional dict
             if isinstance(value, VarService):
                 self.services_var[key] = value
+                if value.sequential:
+                    self.services_var_seq[key] = value
+                else:
+                    self.services_var_nonseq[key] = value
             elif isinstance(value, PostInitService):
                 self.services_post[key] = value
+        elif isinstance(value, SubsService):
+            self.services_subs[key] = value
         elif isinstance(value, DeviceFinder):
             self.services_fnd[key] = value
         elif isinstance(value, BackRef):
@@ -1062,6 +639,9 @@ def refresh_inputs_arg(self):
 
         self.f_args = [self._input[arg] for arg in self.calls.f_args]
         self.g_args = [self._input[arg] for arg in self.calls.g_args]
+        self.sns_args = [self._input[arg] for arg in self.calls.sns_args]
+
+        # each value below is a dict
         mapping = {
             'j_args': self.j_args,
             's_args': self.s_args,
@@ -1116,17 +696,18 @@ def s_update(self):
         """
         Update service equation values.
 
-        This function is only evaluated at initialization.
-        Service values are updated sequentially.
-        The ``v`` attribute of services will be assigned at a new memory address.
+        This function is only evaluated at initialization. Service values are
+        updated sequentially. The ``v`` attribute of services will be assigned
+        at a new memory address.
         """
         for name, instance in self.services.items():
             if name in self.calls.s:
                 func = self.calls.s[name]
                 if callable(func):
                     self.get_inputs(refresh=True)
-                    # NOTE: use new assignment due to possible size change
-                    #   Always make a copy and make the RHS a 1-d array
+                    # NOTE:
+                    # Use new assignment due to possible size change.
+                    # Always make a copy and make the RHS a 1-d array
                     instance.v = np.ravel(np.array(func(*self.s_args[name]), dtype=instance.vtype))
                 else:
                     instance.v = np.ravel(np.array(func, dtype=instance.vtype))
@@ -1154,20 +735,30 @@ def s_update(self):
 
     def s_update_var(self):
         """
-        Update VarService.
+        Update values of :py:class:`andes.core.service.VarService`.
         """
+
         if len(self.services_var):
             kwargs = self.get_inputs()
-            for name, instance in self.services_var.items():
+            # evaluate `v_str` functions for sequential VarService
+            for name, instance in self.services_var_seq.items():
                 if instance.v_str is not None:
                     func = self.calls.s[name]
                     if callable(func):
                         instance.v[:] = func(*self.s_args[name])
 
-                # Apply individual `v_numeric`
-                func = instance.v_numeric
-                if func is not None and callable(func):
-                    instance.v[:] = func(**kwargs)
+            # apply non-sequential services from ``v_str``:w
+            if callable(self.calls.sns):
+                ret = self.calls.sns(*self.sns_args)
+                for idx, instance in enumerate(self.services_var_nonseq.values()):
+                    instance.v[:] = ret[idx]
+
+            # Apply individual `v_numeric`
+            for instance in self.services_var.values():
+                if instance.v_numeric is None:
+                    continue
+                if callable(instance.v_numeric):
+                    instance.v[:] = instance.v_numeric(**kwargs)
 
         if self.flags.sv_num is True:
             kwargs = self.get_inputs()
@@ -1448,6 +1039,7 @@ def _all_params(self):
                            list(self.services.items()) +
                            list(self.services_ext.items()) +
                            list(self.services_ops.items()) +
+                           list(self.services_subs.items()) +
                            list(self.discrete.items())
                            )
 
@@ -1537,6 +1129,20 @@ def _e_setters(self):
             out[name] = var
         return out
 
+    def _input_vars(self):
+        out = list()
+        for name, var in self.cache.all_vars.items():
+            if var.is_input:
+                out.append(name)
+        return out
+
+    def _output_vars(self):
+        out = list()
+        for name, var in self.cache.all_vars.items():
+            if var.is_output:
+                out.append(name)
+        return out
+
     def set_in_use(self):
         """
         Set the `in_use` attribute. Called at the end of ``System.collect_ref``.
@@ -1642,6 +1248,7 @@ def prepare(self, quick=False, pycode_path=None, yapf_pycode=False):
         self.calls.md5 = self.get_md5()
 
         self.syms.generate_symbols()
+        self.syms.generate_subs_expr()
         self.syms.generate_equations()
         self.syms.generate_services()
         self.syms.generate_jacobians()
@@ -1684,6 +1291,8 @@ def get_md5(self):
             if item.v_str is not None:
                 md5.update(str(item.v_str).encode())
 
+            md5.update(str(int(item.sequential)).encode())
+
         for name, item in self.discrete.items():
             md5.update(str(name).encode())
             md5.update(str(','.join(item.export_flags)).encode())
@@ -1726,11 +1335,12 @@ def numba_jitify(self, parallel=False, cache=True, nopython=False):
 
         self.calls.f = to_jit(self.calls.f, **kwargs)
         self.calls.g = to_jit(self.calls.g, **kwargs)
+        self.calls.sns = to_jit(self.calls.sns, **kwargs)
 
         for jname in self.calls.j:
             self.calls.j[jname] = to_jit(self.calls.j[jname], **kwargs)
 
-        for name, instance in self.services_var.items():
+        for name, instance in self.services_var_seq.items():
             if instance.v_str is not None:
                 self.calls.s[name] = to_jit(self.calls.s[name], **kwargs)
 
@@ -1755,10 +1365,13 @@ def precompile(self):
         if callable(self.calls.g):
             self.calls.g(*self.g_args)
 
+        if callable(self.calls.sns):
+            self.calls.sns(*self.sns_args)
+
         for jname, jfunc in self.calls.j.items():
             jfunc(*self.j_args[jname])
 
-        for name, instance in self.services_var.items():
+        for name, instance in self.services_var_seq.items():
             if instance.v_str is not None:
                 self.calls.s[name](*self.s_args[name])
 
@@ -1775,7 +1388,7 @@ def _log_init_debug(self, *args):
         if self.system.options.get("init") is True:
             logger.debug(*args)
 
-    def init(self, routine, debug=False):
+    def init(self, routine):
         """
         Numerical initialization of a model.
 
@@ -1787,6 +1400,7 @@ def init(self, routine, debug=False):
 
         # evaluate `ConstService` and `VarService`
         self.s_update()
+        self.s_update_var()
 
         # find out if variables need to be initialized for `routine`
         flag_name = routine + '_init'
@@ -2018,7 +1632,9 @@ def _eval_discrete(instance, allow_adjust=True,
     for d in dlist:
         d.check_var(allow_adjust=allow_adjust,
                     adjust_lower=adjust_lower,
-                    adjust_upper=adjust_upper)
+                    adjust_upper=adjust_upper,
+                    is_init=True,
+                    )
 
 
 def to_jit(func: Union[Callable, None],
diff --git a/andes/core/model/modelcache.py b/andes/core/model/modelcache.py
new file mode 100644
index 000000000..dbfefc9a3
--- /dev/null
+++ b/andes/core/model/modelcache.py
@@ -0,0 +1,80 @@
+"""
+Module for ModelCache.
+"""
+
+
+class ModelCache:
+    """
+    Class for caching the return value of callback functions.
+
+    Check ``ModelCache.__dict__.keys()`` for fields.
+    """
+
+    def __init__(self):
+        self._callbacks = {}
+
+    def __getattr__(self, item):
+        if item == "_callbacks":
+            return self.__getattribute__(item)
+
+        if item not in self.__dict__:
+            if item in self._callbacks:
+                self.__dict__[item] = self._call(item)
+
+        return self.__getattribute__(item)
+
+    def __getstate__(self):
+        return self.__dict__
+
+    def add_callback(self, name: str, callback):
+        """
+        Add a cache attribute and a callback function for updating the attribute.
+
+        Parameters
+        ----------
+        name : str
+            name of the cached function return value
+        callback : callable
+            callback function for updating the cached attribute
+        """
+        self._callbacks[name] = callback
+
+    def refresh(self, name=None):
+        """
+        Refresh the cached values
+
+        Parameters
+        ----------
+        name : str, list, optional
+            name or list of cached to refresh, by default None for refreshing all
+
+        """
+        if name is None:
+            for name in self._callbacks.keys():
+                self.__dict__[name] = self._call(name)
+        elif isinstance(name, str):
+            self.__dict__[name] = self._call(name)
+        elif isinstance(name, list):
+            for n in name:
+                self.__dict__[n] = self._call(n)
+
+    def _call(self, name):
+        """
+        Helper function for calling callback functions.
+
+        Parameters
+        ----------
+        name : str
+            attribute name to be updated
+
+        Returns
+        -------
+        callback result
+        """
+        if name not in self._callbacks:
+            return None
+        else:
+            if callable(self._callbacks[name]):
+                return self._callbacks[name]()
+            else:
+                return self._callbacks[name]
diff --git a/andes/core/model/modelcall.py b/andes/core/model/modelcall.py
new file mode 100644
index 000000000..8dd2b9f38
--- /dev/null
+++ b/andes/core/model/modelcall.py
@@ -0,0 +1,67 @@
+"""
+Module for ModelCall.
+"""
+
+from collections import OrderedDict
+
+from andes.shared import jac_names, jac_types
+
+
+class ModelCall:
+    """
+    Class for storing generated function calls, Jacobian calls, and arguments.
+    """
+
+    def __init__(self):
+        self.md5 = ''
+
+        # `f` and `g` are callables generated by lambdify that take positional args
+        self.f = None
+        self.g = None
+        self.j = dict()
+        self.s = OrderedDict()
+        self.sns = None
+
+        # `f_args` and `g_args` are the arg names
+        self.f_args = list()
+        self.g_args = list()
+        self.j_args = dict()
+        self.ia = OrderedDict()
+        self.ii = OrderedDict()
+        self.ij = OrderedDict()
+        self.s_args = OrderedDict()
+        self.sns_args = list()
+        self.ia_args = OrderedDict()  # assignment initialization
+        self.ii_args = OrderedDict()  # iterative initialization
+        self.ij_args = OrderedDict()
+
+        self.ijac = OrderedDict()
+        self.jjac = OrderedDict()
+        self.vjac = OrderedDict()
+
+    def clear_ijv(self):
+        for jname in jac_names:
+            for jtype in jac_types:
+                self.ijac[jname + jtype] = list()
+                self.jjac[jname + jtype] = list()
+                self.vjac[jname + jtype] = list()
+
+    def append_ijv(self, j_full_name, ii, jj, vv):
+        if not isinstance(ii, int):
+            raise ValueError("i index must be an integer")
+        if not isinstance(jj, int):
+            raise ValueError("j index must be an integer")
+        if not isinstance(vv, (int, float)) and (not callable(vv)):
+            raise ValueError("v must be a number or a callable")
+
+        self.ijac[j_full_name].append(ii)
+        self.jjac[j_full_name].append(jj)
+        self.vjac[j_full_name].append(vv)
+
+    def zip_ijv(self, j_full_name):
+        """
+        Return a zipped iterator for the rows, cols and vals for the specified matrix name.
+        """
+        return zip(self.ijac[j_full_name],
+                   self.jjac[j_full_name],
+                   self.vjac[j_full_name])
diff --git a/andes/core/model/modeldata.py b/andes/core/model/modeldata.py
new file mode 100644
index 000000000..6c9720052
--- /dev/null
+++ b/andes/core/model/modeldata.py
@@ -0,0 +1,329 @@
+"""
+Module for ModelData.
+"""
+
+import logging
+from collections import OrderedDict
+from typing import Iterable, Sized
+
+import numpy as np
+from andes.core.model.modelcache import ModelCache
+from andes.core.param import (BaseParam, DataParam, IdxParam, NumParam,
+                              TimerParam)
+from andes.shared import pd
+
+logger = logging.getLogger(__name__)
+
+
+class ModelData:
+    r"""
+    Class for holding parameter data for a model.
+
+    This class is designed to hold the parameter data separately from model equations.
+    Models should inherit this class to define the parameters from input files.
+
+    Inherit this class to create the specific class for holding input parameters for a new model.
+    The recommended name for the derived class is the model name with ``Data``. For example, data for `GENROU`
+    should be named `GENROUData`.
+
+    Parameters should be defined in the ``__init__`` function of the derived class.
+
+    Refer to :py:mod:`andes.core.param` for available parameter types.
+
+    Attributes
+    ----------
+    cache
+        A cache instance for different views of the internal data.
+
+    flags : dict
+        Flags to control the routine and functions that get called. If the model is using user-defined
+        numerical calls, set `f_num`, `g_num` and `j_num` properly.
+
+    Notes
+    -----
+    Three default parameters are pre-defined in ``ModelData``
+    and will be inherited by all models. They are
+
+    - ``idx``, unique device idx of type :py:class:`andes.core.param.DataParam`
+    - ``u``, connection status of type :py:class:`andes.core.param.NumParam`
+    - ``name``, (device name of type :py:class:`andes.core.param.DataParam`
+
+    In rare cases one does not want to define these three parameters,
+    one can pass `three_params=True` to the constructor of ``ModelData``.
+
+    Examples
+    --------
+    If we want to build a class ``PQData`` (for static PQ load) with three parameters, `Vn`, `p0`
+    and `q0`, we can use the following ::
+
+        from andes.core.model import ModelData, Model
+        from andes.core.param import IdxParam, NumParam
+
+        class PQData(ModelData):
+            super().__init__()
+            self.Vn = NumParam(default=110,
+                               info="AC voltage rating",
+                               unit='kV', non_zero=True,
+                               tex_name=r'V_n')
+            self.p0 = NumParam(default=0,
+                               info='active power load in system base',
+                               tex_name=r'p_0', unit='p.u.')
+            self.q0 = NumParam(default=0,
+                               info='reactive power load in system base',
+                               tex_name=r'q_0', unit='p.u.')
+
+    In this example, all the three parameters are defined as
+    :py:class:`andes.core.param.NumParam`.
+    In the full `PQData` class, other types of parameters also exist.
+    For example, to store the idx of `owner`, `PQData` uses ::
+
+        self.owner = IdxParam(model='Owner', info="owner idx")
+
+    """
+
+    def __init__(self, *args, three_params=True, **kwargs):
+        self.params = OrderedDict()
+        self.num_params = OrderedDict()
+        self.idx_params = OrderedDict()
+        self.timer_params = OrderedDict()
+        self.n = 0
+        self.uid = {}
+
+        if not hasattr(self, 'cache'):
+            self.cache = ModelCache()
+        self.cache.add_callback('dict', self.as_dict)
+        self.cache.add_callback('df', lambda: self.as_df())
+        self.cache.add_callback('dict_in', lambda: self.as_dict(True))
+        self.cache.add_callback('df_in', lambda: self.as_df(vin=True))
+
+        if three_params is True:
+            self.idx = DataParam(info='unique device idx')
+            self.u = NumParam(default=1, info='connection status', unit='bool', tex_name='u')
+            self.name = DataParam(info='device name')
+
+    def __len__(self):
+        return self.n
+
+    def __setattr__(self, key, value):
+        if isinstance(value, BaseParam):
+            value.owner = self
+            if not value.name:
+                value.name = key
+
+            if key in self.__dict__:
+                logger.warning("%s: redefining <%s>. This is likely a modeling error.",
+                               self.class_name, key)
+
+            self.params[key] = value
+
+        if isinstance(value, NumParam):
+            self.num_params[key] = value
+        elif isinstance(value, IdxParam):
+            self.idx_params[key] = value
+
+        # `TimerParam` is a subclass of `NumParam` and thus tested separately
+        if isinstance(value, TimerParam):
+            self.timer_params[key] = value
+
+        super(ModelData, self).__setattr__(key, value)
+
+    def add(self, **kwargs):
+        """
+        Add a device (an instance) to this model.
+
+        Warnings
+        --------
+        This function is not intended to be used directly.
+        Use the ``add`` method from System so that the index
+        can be registered correctly.
+
+        Parameters
+        ----------
+        kwargs
+            model parameters are collected into the kwargs dictionary
+        """
+        idx = kwargs['idx']
+        self.uid[idx] = self.n
+        self.n += 1
+        if "name" in self.params:
+            name = kwargs.get("name")
+            if (name is None) or (not isinstance(name, str) and np.isnan(name)):
+                kwargs["name"] = idx
+
+        if "idx" not in self.params:
+            kwargs.pop("idx")
+
+        for name, instance in self.params.items():
+            value = kwargs.pop(name, None)
+            instance.add(value)
+        if len(kwargs) > 0:
+            logger.warning("%s: unused data %s", self.class_name, str(kwargs))
+
+    def as_dict(self, vin=False):
+        """
+        Export all parameters as a dict.
+
+        Returns
+        -------
+        dict
+            a dict with the keys being the `ModelData` parameter names
+            and the values being an array-like of data in the order of adding.
+            An additional `uid` key is added with the value default to range(n).
+        """
+        out = dict()
+        out['uid'] = np.arange(self.n)
+
+        for name, instance in self.params.items():
+            # skip non-exported parameters
+            if instance.export is False:
+                continue
+
+            out[name] = instance.v
+
+            # use the original input if `vin` is True
+            if (vin is True) and hasattr(instance, 'vin') and (instance.vin is not None):
+                out[name] = instance.vin
+
+            conv = instance.oconvert
+            if conv is not None:
+                out[name] = np.array([conv(item) for item in out[name]])
+
+        return out
+
+    def as_df(self, vin=False):
+        """
+        Export all parameters as a `pandas.DataFrame` object.
+        This function utilizes `as_dict` for preparing data.
+
+        Returns
+        -------
+        DataFrame
+            A dataframe containing all model data. An `uid` column is added.
+        vin : bool
+            If True, export all parameters from original input (``vin``).
+        """
+        if vin is False:
+            out = pd.DataFrame(self.as_dict()).set_index('uid')
+        else:
+            out = pd.DataFrame(self.as_dict(vin=True)).set_index('uid')
+
+        return out
+
+    def as_df_local(self):
+        """
+        Export local variable values and services to a DataFrame.
+        """
+
+        out = dict()
+        out['uid'] = np.arange(self.n)
+        out['idx'] = self.idx.v
+
+        for name, instance in self.cache.all_vars.items():
+            out[name] = instance.v
+
+        for name, instance in self.services.items():
+            out[name] = instance.v
+
+        return pd.DataFrame(out).set_index('uid')
+
+    def update_from_df(self, df, vin=False):
+        """
+        Update parameter values from a DataFrame.
+
+        Adding devices are not allowed.
+        """
+        if vin is False:
+            for name, instance in self.params.items():
+                if instance.export is False:
+                    continue
+                instance.set_all('v', df[name])
+        else:
+            for name, instance in self.params.items():
+                if instance.export is False:
+                    continue
+                try:
+                    instance.set_all('vin', df[name])
+                    instance.v[:] = instance.vin * instance.pu_coeff
+                except KeyError:
+                    # fall back to `v`
+                    instance.set_all('v', df[name])
+
+        return True
+
+    def find_param(self, prop):
+        """
+        Find params with the given property and return in an OrderedDict.
+
+        Parameters
+        ----------
+        prop : str
+            Property name
+
+        Returns
+        -------
+        OrderedDict
+        """
+        out = OrderedDict()
+        for name, instance in self.params.items():
+            if instance.get_property(prop) is True:
+                out[name] = instance
+
+        return out
+
+    def find_idx(self, keys, values, allow_none=False, default=False):
+        """
+        Find `idx` of devices whose values match the given pattern.
+
+        Parameters
+        ----------
+        keys : str, array-like, Sized
+            A string or an array-like of strings containing the names of parameters for the search criteria
+        values : array, array of arrays, Sized
+            Values for the corresponding key to search for. If keys is a str, values should be an array of
+            elements. If keys is a list, values should be an array of arrays, each corresponds to the key.
+        allow_none : bool, Sized
+            Allow key, value to be not found. Used by groups.
+        default : bool
+            Default idx to return if not found (missing)
+
+        Returns
+        -------
+        list
+            indices of devices
+        """
+        if isinstance(keys, str):
+            keys = (keys,)
+            if not isinstance(values, (int, float, str, np.floating)) and not isinstance(values, Iterable):
+                raise ValueError(f"value must be a string, scalar or an iterable, got {values}")
+
+            if len(values) > 0 and not isinstance(values[0], (list, tuple, np.ndarray)):
+                values = (values,)
+
+        elif isinstance(keys, Sized):
+            if not isinstance(values, Iterable):
+                raise ValueError(f"value must be an iterable, got {values}")
+
+            if len(values) > 0 and not isinstance(values[0], Iterable):
+                raise ValueError(f"if keys is an iterable, values must be an iterable of iterables. got {values}")
+
+            if len(keys) != len(values):
+                raise ValueError("keys and values must have the same length")
+
+        v_attrs = [self.__dict__[key].v for key in keys]
+
+        idxes = []
+        for v_search in zip(*values):
+            v_idx = None
+            for pos, v_attr in enumerate(zip(*v_attrs)):
+                if all([i == j for i, j in zip(v_search, v_attr)]):
+                    v_idx = self.idx.v[pos]
+                    break
+            if v_idx is None:
+                if allow_none is False:
+                    raise IndexError(f'{list(keys)}={v_search} not found in {self.class_name}')
+                else:
+                    v_idx = default
+
+            idxes.append(v_idx)
+
+        return idxes
diff --git a/andes/core/param.py b/andes/core/param.py
index b753073a9..6311c11a9 100644
--- a/andes/core/param.py
+++ b/andes/core/param.py
@@ -2,7 +2,7 @@
 Module for parameters used for describing models.
 """
 
-#  [ANDES] (C)2015-2021 Hantao Cui
+#  [ANDES] (C)2015-2022 Hantao Cui
 #
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
diff --git a/andes/core/service.py b/andes/core/service.py
index a1ee2522d..609775276 100644
--- a/andes/core/service.py
+++ b/andes/core/service.py
@@ -1,4 +1,4 @@
-#  [ANDES] (C)2015-2021 Hantao Cui
+#  [ANDES] (C)2015-2022 Hantao Cui
 #
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -41,10 +41,12 @@ class BaseService:
         The hosting/owner model instance
     """
 
-    def __init__(self, name: str = None, tex_name: str = None, info: str = None, vtype: Type = None):
+    def __init__(self, name: str = None, tex_name: str = None, unit: str = None,
+                 info: str = None, vtype: Type = None):
         self.name = name
         self.tex_name = tex_name if tex_name else name
         self.info = info
+        self.unit = unit
         self.vtype = vtype if vtype is not None else float  # type for `v`
         self.owner = None
 
@@ -83,7 +85,8 @@ def n(self):
         """
         Return the count of values in ``self.v``.
 
-        Needs to be overloaded if ``v`` of subclasses is not a 1-dimensional array.
+        Needs to be overloaded if ``v`` of subclasses is not a 1-dimensional
+        array.
 
         Returns
         -------
@@ -108,9 +111,12 @@ class ConstService(BaseService):
     """
     A type of Service that stays constant once initialized.
 
-    ConstService are usually constants calculated from parameters. They are only evaluated once in the
-    initialization phase before variables are initialized. Therefore, uninitialized variables must not be
-    used in `v_str``.
+    ConstService are usually constants calculated from parameters. They are only
+    evaluated once in the initialization phase before variables are initialized.
+    Therefore, uninitialized variables must not be used in `v_str``.
+
+    ConstService are evaluated *in sequence* after getting external variables
+    and parameters and before initializing internal variables.
 
     Parameters
     ----------
@@ -120,6 +126,8 @@ class ConstService(BaseService):
         An equation string to calculate the variable value.
     v_numeric : Callable, optional
         A callable which returns the value of the ConstService
+    v_type: type, optional, default to float
+        Type of element in the value array in float or complex
 
     Attributes
     ----------
@@ -131,21 +139,69 @@ def __init__(self,
                  v_str: Optional[str] = None,
                  v_numeric: Optional[Callable] = None,
                  vtype: Optional[type] = None,
-                 name: Optional[str] = None, tex_name=None, info=None):
-        super().__init__(name=name, vtype=vtype, tex_name=tex_name, info=info)
-        self.v_str = v_str
-        self.v_numeric = v_numeric
-        self.v: Union[float, int, np.ndarray] = np.array([0.])
+                 name: Optional[str] = None,
+                 tex_name: Optional[str] = None,
+                 info: Optional[str] = None,
+                 unit: Optional[str] = None,
+                 ):
+        super().__init__(name=name, vtype=vtype, tex_name=tex_name, info=info,
+                         unit=unit)
+        self.v_str: str = v_str
+        self.v_numeric: Callable = v_numeric
+        self.v: Union[float, int, np.ndarray] = 0.0
+        self.sequential = True
+
+
+class SubsService(BaseService):
+    """
+    A service to be substituted by its ``v_str`` in equations where it appears.
+
+    ``SubsService`` is useful for eliminating explicit algebraic variables from
+    equations.
+
+    Examples
+    --------
+
+    If one defines the following inside ``__init__()``:
+
+    .. code:: python
+
+        self.vd = SubsService(v_str='v * cos(delta - a)') self.p =
+        Algeb(e_str='vd * Id + vq * Iq')
+
+    At code-generation time, in ``p`` 's equation, the ``vd`` variable will be
+    replaced by its full expression, namely, ``v * cos(delta - a)``.
+    """
+
+    def __init__(self,
+                 v_str: Optional[str] = None,
+                 name: Optional[str] = None,
+                 tex_name: Optional[str] = None,
+                 info: Optional[str] = None,
+                 unit: Optional[str] = None,
+                 ):
+        super().__init__(name=name, tex_name=tex_name, info=info, unit=unit)
+        self.v_str: str = v_str
 
 
 class VarService(ConstService):
     """
-    Variable service that gets updated in each step/loop as variables change.
+    Variable service that gets updated in each step/iteration before computing
+    the residual equations. As a results, variable values from the k-th step are
+    used to compute a ``VarService`` that will be used to compute the residual
+    for the (k+1)-th step.
 
     This class is useful when one has non-differentiable algebraic equations,
-    which make use of `abs()`, `re` and `im`.
-    Instead of creating `Algeb`, one can put the equation in `VarService`,
-    which will be updated before solving algebraic equations.
+    which make use of `abs()`, `re` and `im`. Instead of creating `Algeb`, one
+    can put the equation in `VarService`, which will be updated before solving
+    algebraic equations.
+
+    Parameters
+    ----------
+    sequential : bool, optional, default to True
+        True if this VarService depends on previously defined VarService and
+        should be evaluated in sequence. False if this VarService only uses known
+        variables.
 
     Examples
     --------
@@ -159,10 +215,8 @@ class VarService(ConstService):
     One can use `VarService` to implement this equation ::
 
         self.VE = VarService(
-            tex_name='V_E',
-            info='VE',
-            v_str='Abs(KPC*(vd + 1j*vq) + 1j*(KI + KPC*XL)*(Id + 1j*Iq))',
-            )
+            tex_name='V_E', info='VE', v_str='Abs(KPC*(vd + 1j*vq) + 1j*(KI +
+            KPC*XL)*(Id + 1j*Iq))', )
 
     Warnings
     --------
@@ -171,20 +225,37 @@ class VarService(ConstService):
     Use an algebraic variable whenever possible.
     """
 
-    pass
+    def __init__(self,
+                 v_str: Optional[str] = None,
+                 v_numeric: Optional[Callable] = None,
+                 vtype: Optional[type] = None,
+                 name: Optional[str] = None,
+                 tex_name: Optional[str] = None,
+                 info: Optional[str] = None,
+                 unit: Optional[str] = None,
+                 sequential: Optional[bool] = True,
+                 ):
+
+        super().__init__(name=name,
+                         vtype=vtype,
+                         tex_name=tex_name,
+                         info=info,
+                         unit=unit,
+                         v_str=v_str,
+                         v_numeric=v_numeric)
+        self.sequential = sequential
 
 
 class EventFlag(VarService):
     """
-    Service to flag events when the input value changes.
-    The typical input is a `v-provider` with binary values.
+    Service to flag events when the input value changes. The typical input is a
+    `v-provider` with binary values.
 
     Implemented by providing `self.check(**kwargs)` as `v_numeric`.
-    `EventFlag.v` stores the values of the input variable
-    in the most recent iteration/step.
+    `EventFlag.v` stores the values of the input variable in the most recent
+    iteration/step.
 
-    After the evaluation of `self.check()`, `self.v` will be
-    updated.
+    After the evaluation of `self.check()`, `self.v` will be updated.
     """
 
     def __init__(self, u,
@@ -214,9 +285,8 @@ class VarHold(VarService):
     Parameters
     ----------
     hold : v-provider, binary
-        Hold signal array with length equal to the input.
-        For elements that are 1, the corresponding inputs
-        are held until the hold signal returns to 0.
+        Hold signal array with length equal to the input. For elements that are
+        1, the corresponding inputs are held until the hold signal returns to 0.
     """
 
     def __init__(self, u, hold, vtype=None, name=None, tex_name=None, info=None):
@@ -251,12 +321,12 @@ class ExtendedEvent(VarService):
 
     The triggering of an event, whether the rise or fall edge, is specified
     through `trig`. For example, if `trig = rise`, the change of the input from
-    0 to 1 will be considered as an input, whereas the subsequent change back
-    to 0 will be considered as the event end.
+    0 to 1 will be considered as an input, whereas the subsequent change back to
+    0 will be considered as the event end.
 
     `ExtendedEvent.v` stores the flags whether the extended time has completed.
-    Outputs will become 1 once the event starts and return to 0 when
-    the extended time ends.
+    Outputs will become 1 once the event starts and return to 0 when the
+    extended time ends.
 
     Warnings
     --------
@@ -356,7 +426,8 @@ def check(self, **kwargs):
                 self.n_ext += len(ending)
 
                 # TODO: insert extended event end times to a model-level list
-                logger.debug(f"Extended Event ending time set at t={final_times} sec.")
+                logger.debug("Extended Event ending time set at t=%.4f sec.",
+                             final_times)
 
         # final time of the extended event
         if self.n_ext and np.any(self.t_final <= dae_t):
@@ -373,24 +444,22 @@ class PostInitService(ConstService):
     """
     Constant service that gets stored once after init.
 
-    This service is useful when one need to store initialization
-    values stored in variables.
+    This service is useful when one need to store initialization values stored
+    in variables.
 
     Examples
     --------
     In ESST3A model, the `vf` variable is initialized followed by other
-    variables. One can store the initial `vf` into `vf0` so that equation
-    ``vf - vf0 = 0`` will hold. ::
+    variables. One can store the initial `vf` into `vf0` so that equation ``vf -
+    vf0 = 0`` will hold. ::
 
         self.vref0 = PostInitService(info='Initial reference voltage input',
-                                     tex_name='V_{ref0}',
-                                     v_str='vref',
-                                     )
-
-    Since all `ConstService` are evaluated before equation evaluation,
-    without using PostInitService, one will need to create lots
-    of `ConstService` to store values in the initialization path
-    towards `vf0`, in order to correctly initialize `vf`.
+                                     tex_name='V_{ref0}', v_str='vref', )
+
+    Since all `ConstService` are evaluated before equation evaluation, without
+    using PostInitService, one will need to create lots of `ConstService` to
+    store values in the initialization path towards `vf0`, in order to correctly
+    initialize `vf`.
     """
 
     pass
@@ -400,17 +469,18 @@ class BackRef(BaseService):
     """
     A special type of reference collector.
 
-    `BackRef` is used for collecting device indices of other models referencing the parent model of the
-    `BackRef`. The `v``field will be a list of lists, each containing the `idx` of other models
-    referencing each device of the parent model.
+    `BackRef` is used for collecting device indices of other models referencing
+    the parent model of the `BackRef`. The `v``field will be a list of lists,
+    each containing the `idx` of other models referencing each device of the
+    parent model.
 
-    BackRef can be passed as indexer for params and vars, or shape for `NumReduce` and
-    `NumRepeat`. See examples for illustration.
+    BackRef can be passed as indexer for params and vars, or shape for
+    `NumReduce` and `NumRepeat`. See examples for illustration.
 
     Examples
     --------
-    A Bus device has an `IdxParam` of `area`, storing the `idx` of area to which the bus device belongs.
-    In ``Bus.__init__()``, one has ::
+    A Bus device has an `IdxParam` of `area`, storing the `idx` of area to which
+    the bus device belongs. In ``Bus.__init__()``, one has ::
 
         self.area = IdxParam(model='Area')
 
@@ -425,36 +495,36 @@ class BackRef(BaseService):
         4      1     500
         ====   ====  ====
 
-    The Area model wants to collect the indices of Bus devices which points to the corresponding Area device.
-    In ``Area.__init__``, one defines ::
+    The Area model wants to collect the indices of Bus devices which points to
+    the corresponding Area device. In ``Area.__init__``, one defines ::
 
         self.Bus = BackRef()
 
-    where the member attribute name `Bus` needs to match exactly model name that `Area` wants to collect
-    `idx` for.
-    Similarly, one can define ``self.ACTopology = BackRef()`` to collect devices in the `ACTopology` group
+    where the member attribute name `Bus` needs to match exactly model name that
+    `Area` wants to collect `idx` for. Similarly, one can define
+    ``self.ACTopology = BackRef()`` to collect devices in the `ACTopology` group
     that references Area.
 
-    The collection of `idx` happens in :py:func:`andes.system.System._collect_ref_param`.
-    It has to be noted that the specific `Area` entry must exist to collect model idx-dx referencing it.
+    The collection of `idx` happens in
+    :py:func:`andes.system.System._collect_ref_param`. It has to be noted that
+    the specific `Area` entry must exist to collect model idx-dx referencing it.
     For example, if `Area` has the following data ::
 
-        idx
-        1
+        idx 1
 
-    Then, only Bus 1, 3, and 4 will be collected into `self.Bus.v`, namely, ``self.Bus.v == [ [1, 3, 4] ]``.
+    Then, only Bus 1, 3, and 4 will be collected into `self.Bus.v`, namely,
+    ``self.Bus.v == [ [1, 3, 4] ]``.
 
     If `Area` has data ::
 
-        idx
-        1
-        2
+        idx 1 2
 
     Then, `self.Bus.v` will end up with ``[ [1, 3, 4], [2] ]``.
 
     See Also
     --------
-    andes.core.service.NumReduce : A more complete example using BackRef to build the COI model
+    andes.core.service.NumReduce : A more complete example using BackRef to
+        build the COI model
 
     """
 
@@ -475,14 +545,17 @@ class ExtService(BaseService):
     model : str
         A model name or a group name
     indexer : IdxParam or BaseParam
-        An "Indexer" instance whose ``v`` field contains the ``idx`` of devices in the model or group.
+        An "Indexer" instance whose ``v`` field contains the ``idx`` of devices
+        in the model or group.
 
     Examples
     --------
-    A synchronous generator needs to retrieve the ``p`` and ``q`` values from static generators
-    for initialization. ``ExtService`` is used for this purpose.
+    A synchronous generator needs to retrieve the ``p`` and ``q`` values from
+    static generators for initialization. ``ExtService`` is used for this
+    purpose.
 
-    In a synchronous generator, one can define the following to retrieve ``StaticGen.p`` as ``p0``::
+    In a synchronous generator, one can define the following to retrieve
+    ``StaticGen.p`` as ``p0``::
 
         class GENCLSModel(Model):
             def __init__(...):
@@ -517,7 +590,8 @@ def __init__(self,
 
     def link_external(self, ext_model):
         """
-        Method to be called by ``System`` for getting values from the external model or group.
+        Method to be called by ``System`` for getting values from the external
+        model or group.
 
         Parameters
         ----------
@@ -540,19 +614,26 @@ class DataSelect(BaseService):
     """
     Class for selecting values for optional DataParam or NumParam.
 
-    This service is a v-provider that uses optional DataParam if available with a fallback.
+    This service is a v-provider that uses optional DataParam when available.
+    Otherwise, use the fallback value.
 
-    DataParam will be tested for `None`, and NumParam will be tested with `np.isnan()`.
+    DataParam will be tested for `None`, and NumParam will be tested with
+    ``np.isnan()``.
 
     Notes
     -----
-    An use case of DataSelect is remote bus. One can do ::
+    An use case of DataSelect is remote bus. One can do
+
+    .. code:: python
 
         self.buss = DataSelect(option=self.busr, fallback=self.bus)
 
-    Then, pass ``self.buss`` instead of ``self.bus`` as indexer to retrieve voltages.
+    Then, pass ``self.buss`` instead of ``self.bus`` as indexer to retrieve
+    voltages.
 
-    Another use case is to allow an optional turbine rating. One can do ::
+    Another use case is to allow an optional turbine rating. One can do
+
+    .. code:: python
 
         self.Tn = NumParam(default=None)
         self.Sg = ExtParam(...)
@@ -586,31 +667,40 @@ class DeviceFinder(BaseService):
     """
     Service for finding indices of optionally linked devices.
 
-    If not provided, `DeviceFinder` will add devices at the beginning of `System.setup`.
+    If not provided, `DeviceFinder` will add devices at the beginning of
+    `System.setup`.
 
     Examples
     --------
-    IEEEST stabilizer takes an optional `busf` (IdxParam) for specifying the connected BusFreq,
-    which is needed for mode 6. To avoid reimplementing `BusFreq` within IEEEST, one can do
+    IEEEST stabilizer takes an optional `busf` (IdxParam) for specifying the
+    connected BusFreq, which is needed for mode 6. To avoid reimplementing
+    `BusFreq` within IEEEST, one can do
 
     .. code-block :: python
 
-        self.busfreq = DeviceFinder(self.busf, link=self.buss, idx_name='bus')
+        self.busfreq = DeviceFinder(self.busf,
+                                    link=self.buss, idx_name='bus',
+                                    default_model='BusFreq')
 
-    where `self.busf` is the optional input, `self.buss` is the bus indices that `busf` should measure,
-    and `idx_name` is the name of a BusFreq parameter through which the measured bus indices are specified.
-    For each `None` values in `self.busf`, a `BusFreq` is created to measure the corresponding bus in `self.buss`.
+    where ``self.busf`` is the optional input, ``self.buss`` is the bus indices
+    that ``busf`` should measure, and ``idx_name`` is the name of a BusFreq
+    parameter through which the measured bus indices are specified. For each
+    ``None`` values in ``self.busf``, a ``BusFreq`` device will be created to
+    measure the corresponding bus in ``self.buss``.
 
-    That is, ``BusFreq.[idx_name].v = [link]``. `DeviceFinder` will find / create `BusFreq` devices so that
-    the returned list of `BusFreq` indices are connected to `self.buss`, respectively.
+    That is, ``BusFreq.[idx_name].v = [link]``. ``DeviceFinder`` will find or
+    create ``BusFreq`` devices so that the returned list of ``BusFreq`` indices
+    are connected to `self.buss`, respectively.
     """
 
-    def __init__(self, u, link, idx_name, name=None, tex_name=None, info=None):
+    def __init__(self, u, link, idx_name, default_model,
+                 name=None, tex_name=None, info=None):
         super().__init__(name=name, tex_name=tex_name, info=info)
 
         self.u = u
         self.model = u.model
         self.idx_name = idx_name
+        self.default_model = default_model
 
         if self.model is None:
             raise ValueError(f'{u.owner.class_name}.{u.name} must contain "model".')
@@ -626,24 +716,35 @@ def find_or_add(self, system):
         Find devices one by one.
         Devices previously added in this function can be used later without duplication.
         """
-        mdl = system.models[self.model]
+
+        if self.model in system.models:
+            is_model = True
+        elif self.model in system.groups:
+            is_model = False
+        else:
+            raise ValueError('<%s> is not a valid model or group name.' % self.model)
+
+        add_to_model = self.model if is_model else self.default_model
+
+        mdl = system.__dict__[self.model]
         added = False
 
         for ii, link_to in enumerate(self.link.v):
             idx = mdl.find_idx(self.idx_name, (link_to, ), allow_none=True, default=None)[0]
 
             if idx is None:
-                added = True
-                new_idx = system.add(self.model, {self.idx_name: link_to})
+                new_idx = system.add(add_to_model, {self.idx_name: link_to})
                 self.u.v[ii] = new_idx
 
                 logger.info(f"{self.owner.class_name} <{self.owner.idx.v[ii]}> "
-                            f"added {self.model} <{new_idx}> "
+                            f"added {add_to_model} <{new_idx}> "
                             f"linked to {self.idx_name} <{link_to}>")
+                added = True
             else:
                 self.u.v[ii] = idx
 
         if added:
+            mdl = system.models[add_to_model]
             mdl.list2array()
             mdl.refresh_inputs()
             system.link_ext_param({mdl.name: mdl})
@@ -656,8 +757,8 @@ def v(self):
 class OperationService(BaseService):
     """
     Base class for a type of Service which performs specific operations.
-    OperationService may not use the `assign_memory` from `BaseService`,
-    because it can have a different size.
+    OperationService may not use the `assign_memory` from `BaseService`, because
+    it can have a different size.
 
     This class cannot be used by itself.
 
@@ -665,9 +766,11 @@ class OperationService(BaseService):
     --------
     NumReduce : Service for Reducing linearly stored 2-D services into 1-D
 
-    NumRepeat : Service for repeating 1-D NumParam/ v-array following a sub-pattern
+    NumRepeat : Service for repeating 1-D NumParam/ v-array following a
+    sub-pattern
 
-    IdxRepeat : Service for repeating 1-D IdxParam/ v-list following a sub-pattern
+    IdxRepeat : Service for repeating 1-D IdxParam/ v-list following a
+    sub-pattern
     """
 
     def __init__(self,
@@ -693,11 +796,13 @@ def v(self, value):
 
 class NumReduce(OperationService):
     """
-    A helper Service type which reduces a linearly stored 2-D ExtParam into 1-D Service.
+    A helper Service type which reduces a linearly stored 2-D ExtParam into 1-D
+    Service.
 
-    NumReduce works with ExtParam whose `v` field is a list of lists. A reduce function
-    which takes an array-like and returns a scalar need to be supplied. NumReduce calls the reduce
-    function on each of the lists and return all the scalars in an array.
+    NumReduce works with ExtParam whose `v` field is a list of lists. A reduce
+    function which takes an array-like and returns a scalar need to be supplied.
+    NumReduce calls the reduce function on each of the lists and return all the
+    scalars in an array.
 
     Parameters
     ----------
@@ -710,7 +815,8 @@ class NumReduce(OperationService):
 
     Examples
     --------
-    Suppose one wants to calculate the mean value of the ``Vn`` in one Area. In the ``Area`` class, one defines ::
+    Suppose one wants to calculate the mean value of the ``Vn`` in one Area. In
+    the ``Area`` class, one defines ::
 
         class AreaModel(...):
             def __init__(...):
@@ -720,12 +826,12 @@ def __init__(...):
 
                 # collect the Vn in an 1-D array
                 self.Vn = ExtParam(model='Bus',
-                    src='Vn',
-                    indexer=self.Bus)
+                                   src='Vn',
+                                   indexer=self.Bus)
 
                 self.Vn_mean = NumReduce(u=self.Vn,
-                    fun=np.mean,
-                    ref=self.Bus)
+                                         fun=np.mean,
+                                         ref=self.Bus)
 
     Suppose we define two areas, 1 and 2, the Bus data looks like
 
@@ -739,10 +845,10 @@ def __init__(...):
         ===   =====  ====
 
     Then, `self.Bus.v` is a list of two lists ``[ [1, 3, 4], [2] ]``.
-    `self.Vn.v` will be retrieved and linearly stored as ``[110, 345, 500, 220]``.
-    Based on the shape from `self.Bus`, :py:func:`numpy.mean`
-    will be called on ``[110, 345, 500]`` and ``[220]`` respectively.
-    Thus, `self.Vn_mean.v` will become ``[318.33, 220]``.
+    `self.Vn.v` will be retrieved and linearly stored as ``[110, 345, 500,
+    220]``. Based on the shape from `self.Bus`, :py:func:`numpy.mean` will be
+    called on ``[110, 345, 500]`` and ``[220]`` respectively. Thus,
+    `self.Vn_mean.v` will become ``[318.33, 220]``.
 
     """
 
@@ -785,19 +891,21 @@ def v(self):
 
 class NumRepeat(OperationService):
     r"""
-    A helper Service type which repeats a v-provider's value based on the shape from a BackRef
+    A helper Service type which repeats a v-provider's value based on the shape
+    from a BackRef
 
     Examples
     --------
-    NumRepeat was originally designed for computing the inertia-weighted average rotor speed (center of
-    inertia speed). COI speed is computed with
+    NumRepeat was originally designed for computing the inertia-weighted average
+    rotor speed (center of inertia speed). COI speed is computed with
 
     .. math ::
         \omega_{COI} = \frac{ \sum{M_i * \omega_i} } {\sum{M_i}}
 
-    The numerator can be calculated with a mix of BackRef, ExtParam and ExtState. The denominator needs to be
-    calculated with NumReduce and Service Repeat. That is, use NumReduce to calculate the sum,
-    and use NumRepeat to repeat the summed value for each device.
+    The numerator can be calculated with a mix of BackRef, ExtParam and
+    ExtState. The denominator needs to be calculated with NumReduce and Service
+    Repeat. That is, use NumReduce to calculate the sum, and use NumRepeat to
+    repeat the summed value for each device.
 
     In the COI class, one would have
 
@@ -838,8 +946,9 @@ def __init__(...):
                                  indexer=self.pidx,
                                  )
 
-    It is very worth noting that the implementation uses a trick to separate the average weighted sum into `n`
-    sub-equations, each calculating the :math:`(M_i * \omega_i) / (\sum{M_i})`. Since all the variables are
+    It is very worth noting that the implementation uses a trick to separate the
+    average weighted sum into `n` sub-equations, each calculating the
+    :math:`(M_i * \omega_i) / (\sum{M_i})`. Since all the variables are
     preserved in the sub-equation, the derivatives can be calculated correctly.
 
     """
@@ -877,8 +986,9 @@ class IdxRepeat(OperationService):
     """
     Helper class to repeat IdxParam.
 
-    This class has the same functionality as :py:class:`andes.core.service.NumRepeat`
-    but only operates on IdxParam, DataParam or NumParam.
+    This class has the same functionality as
+    :py:class:`andes.core.service.NumRepeat` but only operates on IdxParam,
+    DataParam or NumParam.
     """
 
     def __init__(self,
@@ -905,7 +1015,8 @@ def v(self):
 
 class RefFlatten(OperationService):
     """
-    A service type for flattening :py:class:`andes.core.service.BackRef` into a 1-D list.
+    A service type for flattening :py:class:`andes.core.service.BackRef` into a
+    1-D list.
 
     Examples
     --------
@@ -918,12 +1029,12 @@ class RefFlatten(OperationService):
 
         self.SynGen = BackRef(info='SynGen idx lists', export=False)
 
-    After collecting BackRefs, `self.SynGen.v` will become a two-level list of indices,
-    where the first level correspond to each COI and the second level correspond to generators
-    of the COI.
+    After collecting BackRefs, `self.SynGen.v` will become a two-level list of
+    indices, where the first level correspond to each COI and the second level
+    correspond to generators of the COI.
 
-    Convert `self.SynGen` into 1-d as `self.SynGenIdx`, which can be passed as indexer for
-    retrieving other parameters and variables
+    Convert `self.SynGen` into 1-d as `self.SynGenIdx`, which can be passed as
+    indexer for retrieving other parameters and variables
 
     .. code-block :: python
 
@@ -949,9 +1060,11 @@ class NumSelect(OperationService):
 
     NumSelect works with internal and external parameters.
 
-    Notes
-    -----
-    One use case is to allow an optional turbine rating. One can do ::
+    Examples
+    --------
+    One use case is to allow an optional turbine rating. One can do
+
+    .. code:: python
 
         self.Tn = NumParam(default=None)
         self.Sg = ExtParam(...)
@@ -988,8 +1101,8 @@ class InitChecker(OperationService):
     Class for checking init values against known typical values.
 
     Instances will be stored in `Model.services_post` and
-    `Model.services_icheck`, which will be checked in
-    `Model.post_init_check()` after initialization.
+    `Model.services_icheck`, which will be checked in `Model.post_init_check()`
+    after initialization.
 
     Parameters
     ----------
@@ -1008,9 +1121,8 @@ class InitChecker(OperationService):
 
     Examples
     --------
-    Let's say generator excitation voltages are known to be in
-    the range of 1.6 - 3.0 per unit. One can add the following
-    instance to `GENBase` ::
+    Let's say generator excitation voltages are known to be in the range of 1.6
+    - 3.0 per unit. One can add the following instance to `GENBase` ::
 
         self._vfc = InitChecker(u=self.vf,
                                 info='vf range',
@@ -1018,11 +1130,10 @@ class InitChecker(OperationService):
                                 upper=3.0,
                                 )
 
-    `lower` and `upper` can also take v-providers instead of
-    float values.
+    `lower` and `upper` can also take v-providers instead of float values.
 
-    One can also pass float values from Config to make it
-    adjustable as in our implementation of ``GENBase._vfc``.
+    One can also pass float values from Config to make it adjustable as in our
+    implementation of ``GENBase._vfc``.
     """
 
     def __init__(self, u, lower=None, upper=None, equal=None, not_equal=None,
@@ -1104,8 +1215,8 @@ class FlagValue(BaseService):
 
     Warnings
     --------
-    `FlagNotNone` can only be applied to `BaseParam` with `cache=True`.
-    Applying to `Service` will fail unless `cache` is False (at a performance cost).
+    `FlagNotNone` can only be applied to `BaseParam` with `cache=True`. Applying
+    to `Service` will fail unless `cache` is False (at a performance cost).
     """
 
     def __init__(self, u, value, flag=0, name=None, tex_name=None, info=None, cache=True):
@@ -1177,9 +1288,8 @@ class FlagCondition(BaseService):
     """
     Class for flagging values based on a condition function.
 
-    By default, values whose condition function output equal
-    that equal to True/1 will be flagged as `1`.
-    `0` otherwise.
+    By default, values whose condition function output equal that equal to
+    True/1 will be flagged as `1`. `0` otherwise.
 
     Parameters
     ----------
@@ -1188,15 +1298,15 @@ class FlagCondition(BaseService):
     func
         A condition function that returns True or False.
     flag : 1 by default, only 0 or 1 is accepted.
-        The flag for the inputs whose condition output
-        is True.
+        The flag for the inputs whose condition output is True.
 
     Warnings
     --------
     This class is not ready.
 
     `FlagCondition` can only be applied to `BaseParam` with `cache=True`.
-    Applying to `Service` will fail unless `cache` is False (at a performance cost).
+    Applying to `Service` will fail unless `cache` is False (at a performance
+    cost).
     """
 
     def __init__(self, u, func, flag=1, name=None, tex_name=None, info=None, cache=True):
@@ -1232,8 +1342,8 @@ class FlagLessThan(FlagCondition):
     """
     Service for flagging parameters < or <= the given value element-wise.
 
-    Parameters that satisfy the comparison (u < or <= value) will flagged
-    as `flag` (1 by default).
+    Parameters that satisfy the comparison (u < or <= value) will flagged as
+    `flag` (1 by default).
     """
 
     def __init__(self, u, value=0.0, flag=1, equal=False,
@@ -1257,8 +1367,8 @@ class FlagGreaterThan(FlagCondition):
     """
     Service for flagging parameters > or >= the given value element-wise.
 
-    Parameters that satisfy the comparison (u > or >= value) will flagged
-    as `flag` (1 by default).
+    Parameters that satisfy the comparison (u > or >= value) will flagged as
+    `flag` (1 by default).
     """
 
     def __init__(self, u, value=0.0, flag=1, equal=False,
@@ -1280,16 +1390,16 @@ def __init__(self, u, value=0.0, flag=1, equal=False,
 
 class CurrentSign(ConstService):
     """
-    Service for computing the sign of the current flowing through a series device.
+    Service for computing the sign of the current flowing through a series
+    device.
 
     With a given line connecting `bus1` and `bus2`, one can compute the current
-    flow using ``(v1*exp(1j*a1) - v2*exp(1j*a2)) / (r + jx)`` whose value is
-    the outflow on `bus1`.
+    flow using ``(v1*exp(1j*a1) - v2*exp(1j*a2)) / (r + jx)`` whose value is the
+    outflow on `bus1`.
 
     `CurrentSign` can be used to compute the sign to be multiplied depending on
-    the observing bus.
-    For each value in `bus`, the sign will be ``+1`` if it appears in `bus1` or
-    ``-1`` otherwise.
+    the observing bus. For each value in `bus`, the sign will be ``+1`` if it
+    appears in `bus1` or ``-1`` otherwise.
 
     ::
 
@@ -1391,8 +1501,8 @@ class RandomService(BaseService):
 
     Warnings
     --------
-    The value will be randomized every time it is accessed. Do not use it if the value needs to be stable for
-    each simulation step.
+    The value will be randomized every time it is accessed. Do not use it if the
+    value needs to be stable for each simulation step.
     """
 
     def __init__(self, func=np.random.rand, **kwargs):
diff --git a/andes/core/symprocessor.py b/andes/core/symprocessor.py
index aeff5148a..58a74c5eb 100644
--- a/andes/core/symprocessor.py
+++ b/andes/core/symprocessor.py
@@ -10,10 +10,9 @@
 
 import numpy as np
 import sympy as sp
-
-from andes.thirdparty.sympymod import FixPiecewise
-from andes.core.npfunc import safe_div
 from andes.shared import dilled_vars
+from andes.thirdparty.npfunc import safe_div
+from andes.thirdparty.sympymod import FixPiecewise
 from andes.utils.paths import get_pycode_path
 
 logger = logging.getLogger(__name__)
@@ -67,6 +66,7 @@ def __init__(self, parent):
         self.vars_dict = OrderedDict()
         self.vars_int_dict = OrderedDict()   # internal variables only
         self.vars_list = list()
+        self.substitution_map = {}    # mapping of ``SubsService`` to its expression
 
         self.f_list, self.g_list = list(), list()  # symbolic equations in lists
         self.f_matrix, self.g_matrix, self.s_matrix = list(), list(), list()  # equations in matrices
@@ -141,10 +141,6 @@ def generate_symbols(self):
         self.inputs_dict['dae_t'] = sp.Symbol('dae_t')
         self.inputs_dict['sys_f'] = sp.Symbol('sys_f')
         self.inputs_dict['sys_mva'] = sp.Symbol('sys_mva')
-        self.inputs_dict['__zeros'] = sp.Symbol('__zeros')
-        self.inputs_dict['__ones'] = sp.Symbol('__ones')
-        self.inputs_dict['__falses'] = sp.Symbol('__falses')
-        self.inputs_dict['__trues'] = sp.Symbol('__trues')
 
         # custom functions
         self.lambdify_func[0]['Indicator'] = lambda x: x
@@ -166,6 +162,21 @@ def _check_expr_symbols(self, expr):
         fs = sorted(fs, key=lambda s: s.name)
         return fs
 
+    def generate_subs_expr(self):
+        """
+        Generate expressions for substituting ``SubsService``.
+        """
+        for name, instance in self.parent.services_subs.items():
+            if instance.v_str is not None:
+                expr = sp.sympify(instance.v_str, locals=self.inputs_dict)
+                self.substitution_map[self.inputs_dict[name]] = expr
+
+    def _do_substitute(self, input_expr):
+        """
+        Helper function to substitute ``SubsService`` with its expression.
+        """
+        return input_expr.subs(self.substitution_map)
+
     def generate_equations(self):
         """
         Generate equations.
@@ -198,6 +209,7 @@ def generate_equations(self):
                 else:
                     try:
                         expr = sp.sympify(instance.e_str, locals=self.inputs_dict)
+                        expr = self._do_substitute(expr)
                     except (sp.SympifyError, TypeError) as e:
                         logger.error('Error parsing equation "%s "for %s.%s',
                                      instance.e_str, instance.owner.class_name, name)
@@ -231,39 +243,60 @@ def generate_equations(self):
     def generate_services(self):
         """
         Generate calls for services, including ``ConstService`` and
-        ``VarService`` among others.
-        Sequence is preserved due to possible dependency.
+        ``VarService`` among others. Sequence is preserved due to possible
+        dependency.
 
-        Since SymPy 1.9, ``Matrix`` no longer supports non-Expr
-        objects. Due to the use of logical conditions in services,
-        service expressions will not be converted to SymPy Matrix.
-        The dictionary to look up service name and expression
-        is in ``self.s_syms``.
+        All ``VarService`` with ``sequential = False`` are generated into one
+        function, ``calls.sns``.
+
+        Starting from SymPy 1.9, ``Matrix`` no longer supports non-Expr objects.
+        Due to the use of logical conditions in services, service expressions
+        will not be converted to SymPy Matrix. The dictionary to look up service
+        name and expression is in ``self.s_syms``.
         """
 
-        s_args = OrderedDict()
         s_syms = OrderedDict()
+        s_args = OrderedDict()
         s_calls = OrderedDict()
+        sns_args = list()   # ``sns`` means services that are non-sequential
+        sns_calls = None
+
+        s_calls_nonseq = list()
+        s_calls_nonseq_args = list()
 
         for name, instance in self.parent.services.items():
             v_str = '0' if instance.v_str is None else instance.v_str
             try:
                 expr = sp.sympify(v_str, locals=self.inputs_dict)
+                expr = self._do_substitute(expr)
             except (sp.SympifyError, TypeError) as e:
                 logger.error(f'Error parsing equation for {instance.owner.class_name}.{name}')
                 raise e
 
             fs = self._check_expr_symbols(expr)
             s_syms[name] = expr
-            s_args[name] = [str(i) for i in fs]
-            s_calls[name] = sp.lambdify(s_args[name], s_syms[name], modules=self.lambdify_func)
+            args_expr = [str(i) for i in fs]
 
-            if 'select' in inspect.getsource(s_calls[name]):
-                s_args[name].extend(select_args_add)
+            if instance.sequential is True:
+                s_args[name] = args_expr
+                s_calls[name] = sp.lambdify(s_args[name], s_syms[name], modules=self.lambdify_func)
+                if 'select' in inspect.getsource(s_calls[name]):
+                    s_args[name].extend(select_args_add)
+            else:
+                s_calls_nonseq.append(expr)
+                s_calls_nonseq_args.extend(args_expr)
+
+        if len(s_calls_nonseq) > 0:
+            sns_args = sorted(list(set(s_calls_nonseq_args)))
+            sns_calls = sp.lambdify(sns_args, tuple(s_calls_nonseq), modules=self.lambdify_func)
+            if 'select' in inspect.getsource(sns_calls):
+                sns_args.extend(select_args_add)
 
         self.s_syms = s_syms
         self.calls.s = s_calls
         self.calls.s_args = s_args
+        self.calls.sns = sns_calls
+        self.calls.sns_args = sns_args
 
     def generate_jacobians(self, diag_eps=1e-8):
         """
@@ -444,7 +477,7 @@ def generate_pycode(self, pycode_path, yapf_pycode):
 from numpy import arcsin, arccos, arctan, arctan2                   # NOQA
 from numpy import log                                               # NOQA
 
-from andes.core.npfunc import *                                     # NOQA
+from andes.thirdparty.npfunc import *                               # NOQA
 
 """
         # header goes first
@@ -473,6 +506,9 @@ def generate_pycode(self, pycode_path, yapf_pycode):
         for name in self.calls.s:
             out.append(self._rename_func(self.calls.s[name], f'{name}_svc', yf))
 
+        # non-sequential services
+        out.append(self._rename_func(self.calls.sns, 'sns_update', yf))
+
         # variables
         for name in dilled_vars:
             out.append(f'{name} = ' + pprint.pformat(self.calls.__dict__[name]))
@@ -500,8 +536,15 @@ def _rename_func(self, func, func_name, yapf_pycode=False):
         """
         Rename the function name and return source code.
 
-        This function does not check for name conflicts.
-        Install `yapf` for optional code reformatting (takes extra processing time).
+        This function performs these tasks:
+
+        1. rename ``_lambdifygenerated`` to the given ``func_name``.
+        2. append four arguments if ``select`` is used to pass numba
+           compilation.
+        3. remove ``Indicator`` for wrappers of logic expressions.
+
+        This function does not check for name conflicts. Install `yapf` for
+        optional code reformatting (takes extra processing time).
 
         It also patches function argument list for select.
         """
@@ -517,7 +560,8 @@ def _rename_func(self, func, func_name, yapf_pycode=False):
 
         # append additional arguments for select
         if 'select' in src:
-            src = src.replace("):", ", __zeros, __ones, __falses, __trues):")
+            right_parenthesis = ", " + ', '.join(select_args_add) + "):"
+            src = src.replace("):", right_parenthesis)
 
         if yapf_pycode:
             try:
@@ -541,6 +585,7 @@ def generate_dependency(self):
         for name, instance in self.cache.all_vars.items():
             if instance.v_str is not None:
                 sympified = sp.sympify(instance.v_str, locals=self.inputs_dict)
+                sympified = self._do_substitute(sympified)
                 self._check_expr_symbols(sympified)
                 self.v_str_syms[name] = sympified
             else:
@@ -550,6 +595,7 @@ def generate_dependency(self):
 
             if instance.v_iter is not None:
                 sympified = sp.sympify(instance.v_iter, locals=self.inputs_dict)
+                sympified = self._do_substitute(sympified)
                 self._check_expr_symbols(sympified)
                 self.v_iter_syms[name] = sympified
 
diff --git a/andes/core/var.py b/andes/core/var.py
index ea9370e44..e70226c16 100644
--- a/andes/core/var.py
+++ b/andes/core/var.py
@@ -1,4 +1,4 @@
-#  [ANDES] (C)2015-2021 Hantao Cui
+#  [ANDES] (C)2015-2022 Hantao Cui
 #
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -77,6 +77,7 @@ def __init__(self,
                  export: Optional[bool] = True,
                  diag_eps: Optional[float] = 0.0,
                  deps: Optional[List] = None,
+                 is_output: Optional[bool] = False,
                  ):
 
         self.name = name
@@ -100,6 +101,8 @@ def __init__(self,
         self.export = export            # True if this var's value needs to exported
         self.diag_eps = diag_eps        # small diagonal value to be added to `dae.gy`
         self.deps = deps          # a list of variable names this BaseVar depends on for initialization
+        self.is_output = is_output      # indicate if this variable is an output terminal
+        self.is_input = False     # internal variables are never inputs
 
         # --- attributes assigned by `set_address` begins ---
         self.n = 0
@@ -366,6 +369,7 @@ def __init__(self,
                  addressable: Optional[bool] = True,
                  export: Optional[bool] = True,
                  diag_eps: Optional[float] = 0.0,
+                 is_input: Optional[bool] = False,
                  ):
         super().__init__(name=name,
                          tex_name=tex_name,
@@ -387,6 +391,9 @@ def __init__(self,
         self.src = src
         self.indexer = indexer
         self.allow_none = allow_none
+        self.is_input = is_input  # if this ExtVar is an input terminal
+        self.is_output = False    # external variables are never outputs
+
         self.parent = None
         self._idx = None
         self._n = []
@@ -533,6 +540,7 @@ class ExtState(ExtVar):
     source ``State`` variable. In fact, one should not set ``e_str`` for ``ExtState``.
     """
     e_code = 'f'
+    r_code = 'h'
     v_code = 'x'
     t_const = None
 
@@ -542,6 +550,7 @@ class ExtAlgeb(ExtVar):
     External algebraic variable type.
     """
     e_code = 'g'
+    r_code = 'i'
     v_code = 'y'
 
 
@@ -550,12 +559,14 @@ class AliasAlgeb(ExtAlgeb):
     Alias algebraic variable. Essentially ``ExtAlgeb`` that links to a a model's
     own variable.
 
-    ``AliasAlgeb`` is useful when the final output of a model is from a block, but
-    the model must provide the final output in a pre-defined name.
-    Using ``AliasAlgeb``, A model can avoid adding an additional variable with a dummy equations.
+    ``AliasAlgeb`` is useful when the final output of a model is from a block,
+    but the model must provide the final output in a pre-defined name. Using
+    ``AliasAlgeb``, A model can avoid adding an additional variable with a dummy
+    equations.
 
-    Like ``ExtVar``, labels of ``AliasAlgeb`` will not be saved in the final output.
-    When plotting from file, one need to look up the original variable name.
+    Like ``ExtVar``, labels of ``AliasAlgeb`` will not be saved in the final
+    output. When plotting from file, one need to look up the original variable
+    name.
     """
 
     def __init__(self, var, **kwargs):
@@ -564,6 +575,7 @@ def __init__(self, var, **kwargs):
                           src=var.name,
                           indexer=var.owner.idx,
                           info=f'Alias of {var.name}',
+                          is_input=False,
                           **kwargs,
                           )
 
@@ -581,5 +593,6 @@ def __init__(self, var, **kwargs):
                           src=var.name,
                           indexer=var.owner.idx,
                           info=f'Alias of {var.name}',
+                          is_input=False,
                           **kwargs,
                           )
diff --git a/andes/interop/pandapower.py b/andes/interop/pandapower.py
index 47fa378e6..e568983b6 100644
--- a/andes/interop/pandapower.py
+++ b/andes/interop/pandapower.py
@@ -143,27 +143,25 @@ def runopp_map(ssp, link_table, **kwargs):
     -----
       - The pandapower net and the ANDES system must have same base MVA.
       - Multiple ``DG`` connected to the same ``StaticGen`` will be converted to one generator.
-        The power is dispatched to each ``DG`` by the power ratio
+        The power is dispatched to each ``DG`` by the power ratio ``gammap``
     """
 
     pp.runopp(ssp, **kwargs)
+
     # take dispatch results from pp
-    ssp_res = pd.concat([ssp.gen['name'], ssp.res_gen[['p_mw', 'q_mvar', 'vm_pu']]], axis=1)
+    ssp_gen = ssp.gen.rename(columns={'name': 'stg_idx'})
+    ssp_res = pd.concat([ssp_gen[['stg_idx']],
+                        ssp.res_gen[['p_mw', 'q_mvar', 'vm_pu']]], axis=1)
 
     ssp_res = pd.merge(left=ssp_res,
-                       right=ssp.gen[['name', 'bus', 'controllable']],
-                       how='left', on='name')
-    ssp_res = pd.merge(left=ssp_res,
-                       right=ssp.bus[['name']].reset_index().rename(
-                           columns={'index': 'bus', 'name': 'bus_name'}),
-                       how='left', on='bus')
-    ssp_res = pd.merge(left=ssp_res,
-                       right=link_table,
-                       how='left', on='bus_name')
+                       right=ssp_gen[['stg_idx', 'controllable']],
+                       how='left', on='stg_idx')
+    ssp_res = pd.merge(left=ssp_res, right=link_table,
+                       how='left', on='stg_idx')
     ssp_res['p'] = ssp_res['p_mw'] * ssp_res['gammap'] / ssp.sn_mva
     ssp_res['q'] = ssp_res['q_mvar'] * ssp_res['gammaq'] / ssp.sn_mva
-    col = ['name', 'p', 'q', 'vm_pu', 'bus_name', 'bus_idx',
-           'controllable', 'dg_idx', 'syg_idx', 'gov_idx', 'exc_idx', 'stg_idx']
+    col = ['stg_idx', 'p', 'q', 'vm_pu', 'bus_idx', 'controllable',
+           'dg_idx', 'syg_idx', 'gov_idx', 'exc_idx']
     return ssp_res[col]
 
 
@@ -186,10 +184,10 @@ def add_gencost(ssp, gen_cost):
     """
 
     # check dimension
-    if gen_cost.shape[0] != ssp.gen[ssp.gen['controllable']].shape[0]:
-        print('Input cost function size does not match controllable gen size.')
+    if gen_cost.shape[0] != ssp.gen.shape[0]:
+        print('Input cost function size does not match gen size.')
 
-    for num, uid in enumerate(ssp.gen[ssp.gen['controllable']].index):
+    for num, uid in enumerate(ssp.gen.index):
         if gen_cost[num, 0] == 2:  # poly_cost
             pp.create_poly_cost(net=ssp,
                                 element=uid,
@@ -233,12 +231,14 @@ def _to_pp_line(ssa, ssp, ssa_bus):
     ssa_line['X'] = ssa_line["x"] * ssa_line['Zb']  # ohm
     ssa_line['C'] = ssa_line["b"] / ssa_line['Zb'] / omega * 1e9  # nF
     ssa_line['G'] = ssa_line["g"] * ssa_line['Yb'] * 1e6  # mS
+    # default rate_a is 2000 MVA
+    ssa_line['rate_a'] = ssa_line['rate_a'].replace(0, 2000)
+    ssa_line['max_i_ka'] = ssa_line["rate_a"] / ssa_line['Vb']  # kA
 
     # find index for transmission lines (i.e., non-transformers)
     ssl = ssa_line
     ssl['uidx'] = ssl.index
     index_line = ssl['uidx'][ssl['Vn1'] == ssl['Vn2']][ssl['trans'] == 0]
-    ll_ka = len(ssa_line) * [100]  # set large line limits
 
     ssa_line['name'] = _rename(ssa_line['name'])
     # --- 2a. transmission lines ---
@@ -259,7 +259,7 @@ def _to_pp_line(ssa, ssp, ssa_bus):
             x_ohm_per_km=ssa_line['X'].iloc[uid],
             c_nf_per_km=ssa_line['C'].iloc[uid],
             #    g_us_per_km = ssa_line['R'].iloc[uid],
-            max_i_ka=ll_ka[uid],
+            max_i_ka=ssa_line['max_i_ka'].iloc[uid],
             type='ol',
             max_loading_percent=100,
             index=num,
@@ -364,14 +364,14 @@ def _to_pp_shunt(ssa, ssp, ssa_bus):
 def _to_pp_gen_pre(ssa):
     """Create generator data in pandapower net"""
     # build StaticGen df
-    stg_cols = ['idx', 'u', 'name', 'bus', 'v0', 'vmax', 'vmin']
+    stg_cols = ['idx', 'u', 'bus', 'v0', 'vmax', 'vmin']
     stg_calc_cols = ['p0', 'q0', 'pmax', 'pmin', 'qmax', 'qmin']
     ssa_stg = build_group_table(ssa, 'StaticGen', stg_cols + stg_calc_cols)
+    ssa_stg['name'] = ssa_stg.idx
     ssa_stg.rename(inplace=True,
                    columns={"bus": "bus_idx",
                             "u": "stg_u",
-                            "idx": "stg_idx",
-                            "name": "stg_name"})
+                            "idx": "stg_idx"})
     # retrieve Bus idx in pp net
     ssa_busn = ssa.Bus.as_df().copy().reset_index()[["uid", "idx"]].rename(
         columns={"uid": "pp_bus", "idx": "bus_idx"})
@@ -379,39 +379,7 @@ def _to_pp_gen_pre(ssa):
     ssa_stg = pd.merge(ssa_stg, ssa_busn,
                        how="left", on="bus_idx")
 
-    # build SynGen df
-    syg_cols = ['idx', 'name', 'gen', 'gammap', 'gammaq']
-    ssa_syg = build_group_table(ssa, 'SynGen', syg_cols, ['GENROU', 'GENCLS'])
-    ssa_syg.rename(inplace=True,
-                   columns={"gen": "stg_idx",
-                            "idx": "syg_idx"})
-    # build DG df
-    dg_cols = ['idx', 'name', 'gen', 'gammap', 'gammaq']
-    ssa_dg = build_group_table(ssa, 'DG', dg_cols)
-    ssa_dg.rename(inplace=True,
-                  columns={"idx": "dg_idx",
-                           "gen": "stg_idx"})
-
-    if ssa_syg.shape[0] + ssa_dg.shape[0] == 0:
-        ssa_stg['name'] = ssa_stg['stg_name']
-        return ssa_stg
-    else:
-        # merge stg and syg as the syg
-        ssa_syg = pd.merge(ssa_stg, ssa_syg,
-                           how='right', on='stg_idx')
-
-        ssa_dgs = ssa_dg.groupby(['stg_idx']).sum().reset_index()
-        ssa_dgs_idx = ssa_dgs.index + 1
-        ssa_dgs['name'] = "DG_" + ssa_dgs_idx.astype(str)
-
-        # merge sg and DG as the dgs
-        ssa_dgs = pd.merge(ssa_stg, ssa_dgs,
-                           how='right', on='stg_idx')
-
-        # concat syg and dg as sg
-        ssa_sg = pd.concat([ssa_syg, ssa_dgs], axis=0).reset_index(drop=True)
-
-        return ssa_sg
+    return ssa_stg
 
 
 def _to_pp_gen(ssa, ssp, ctrl=[]):
@@ -434,18 +402,12 @@ def _to_pp_gen(ssa, ssp, ctrl=[]):
         ssa_sg['q0'] = ssa_sg['q0'] * ssa_sg['gammaq']
 
     # default controllable is determined by governor
-    if ctrl:
+    if len(ctrl) > 0:
         if len(ctrl) != len(ssa_sg):
             raise ValueError("ctrl length does not match StaticGen length")
-        ssa_sg["ctrl"] = [bool(x) for x in ctrl]
     else:
-        key = make_link_table(ssa)
-        if key.shape[0] == 0:
-            # if no dyn device, set all generators as controllable
-            ssa_sg["ctrl"] = [bool(x) for x in [1]*len(ssa_sg)]
-        else:
-            key = key[~key['stg_idx'].duplicated()]
-            ssa_sg["ctrl"] = [bool(x) for x in key['gov_idx'].fillna(False)]
+        ctrl = [1] * len(ssa_sg)
+    ssa_sg["ctrl"] = [bool(x) for x in ctrl]
 
     ssa_sg['name'] = _rename(ssa_sg['name'])
     # conversion
@@ -493,17 +455,13 @@ def to_pandapower(ssa, ctrl=[], verify=True, tol=1e-6):
     -----
     Handling of the following parameters:
 
-      - Line limts are set as 100.0 in the output network.
       - Generator cost is not included in the conversion. Use ``add_gencost()``
         to add cost data.
-      - By default, ``SynGen`` equipped with ``TurbineGov`` in the ANDES System is converted
-        to generators with ``controllable=True`` in pp's network
-      - By default, ``SynGen`` that has no ``TurbineGov`` and ``DG`` in the ANDES System
-        is converted to generators with ``controllable=False`` in pp's network
+      - By default, all generators in ``ssp`` are controllable unless user-defined controllability
+        is given
       - The online status of generators are determined by the online status of ``StaticGen``
         that connected to the ``SynGen`` or ``DG``
-      - Multiple ``DG`` connected to the same ``StaticGen`` will be converted to one generator.
-        The power is dispatched to each ``DG`` by the power ratio in ``runopp_map``
+      - ``ssp.gen.name`` is from ``ssa.StaticGen.idx``, which should be unique
     """
 
     # create a PP network
@@ -632,7 +590,7 @@ def _verifyGSF(ppn, gsf, tol=1e-4):
     rl_c = np.array(np.matrix(gsf) * np.matrix(rp.ngen).T)
     res_gap = rl.p_from_mw.values - rl_c.flatten()
     if np.abs(res_gap).max() <= tol:
-        logger.info("GSF is consisstent.")
+        logger.info("GSF is consistent.")
     else:
         logger.warning("Warning: GSF is inconsistent. Pleaes check!")
 
@@ -647,4 +605,6 @@ def _sumPF_ppn(ppn):
     rp = rp.merge(rd, on='bus', how='left')
     rp.fillna(0, inplace=True)
     rp['ngen'] = rp['gen'] - rp['demand']
+    rp = rp.groupby('bus').sum().reset_index(drop=True)
+    rp['bus'] = rp.index
     return rp
diff --git a/andes/io/matpower.py b/andes/io/matpower.py
index f03f5fa3d..4a8498b90 100644
--- a/andes/io/matpower.py
+++ b/andes/io/matpower.py
@@ -260,6 +260,10 @@ def mpc2system(mpc: dict, system) -> bool:
         r = data[2]
         x = data[3]
         b = data[4]
+        rate_a = data[5]
+        rate_b = data[6]
+        rate_c = data[7]
+
         status = int(data[10])
 
         if (data[8] == 0.0) or (data[8] == 1.0 and data[9] == 0.0):
@@ -278,7 +282,8 @@ def mpc2system(mpc: dict, system) -> bool:
                    Vn1=vf, Vn2=vt,
                    bus1=fbus, bus2=tbus,
                    r=r, x=x, b=b,
-                   trans=tf, tap=ratio, phi=angle)
+                   trans=tf, tap=ratio, phi=angle,
+                   rate_a=rate_a, rate_b=rate_b, rate_c=rate_c)
 
     if ('bus_name' in mpc) and (len(mpc['bus_name']) == len(system.Bus.name.v)):
         system.Bus.name.v[:] = mpc['bus_name']
@@ -392,7 +397,9 @@ def system2mpc(system) -> dict:
         branch[:, 2] = system.Line.r.v
         branch[:, 3] = system.Line.x.v
         branch[:, 4] = system.Line.b.v
-
+        branch[:, 5] = system.Line.rate_a.v
+        branch[:, 6] = system.Line.rate_b.v
+        branch[:, 7] = system.Line.rate_c.v
         branch[:, 8] = system.Line.tap.v
         branch[:, 9] = system.Line.phi.v * rad2deg
         branch[:, 10] = system.Line.u.v
diff --git a/andes/io/psse-dyr.yaml b/andes/io/psse-dyr.yaml
index 5f338da6c..9d5b2a818 100644
--- a/andes/io/psse-dyr.yaml
+++ b/andes/io/psse-dyr.yaml
@@ -810,6 +810,7 @@ HYGOV:
         - BUS
         - ID
         - R
+        - r
         - Tr
         - Tf
         - Tg
diff --git a/andes/io/psse.py b/andes/io/psse.py
index 4b1089eae..b5aa04b6c 100644
--- a/andes/io/psse.py
+++ b/andes/io/psse.py
@@ -450,6 +450,7 @@ def _parse_line_v33(raw, system):
         param = {
             'bus1': data[0], 'bus2': data[1],
             'r': data[3], 'x': data[4], 'b': data[5],
+            'rate_a': data[6], 'rate_b': data[7], 'rate_c': data[8],
             'Vn1': system.Bus.get(src='Vn', idx=data[0], attr='v'),
             'Vn2': system.Bus.get(src='Vn', idx=data[1], attr='v'),
         }
@@ -485,6 +486,9 @@ def _parse_transf_v33(raw, system, max_bus):
             transf = True
             tap = data[2][0]  # pu or in kV
             phi = data[2][2] * deg2rad  # `ANG1` is entered in degree; convert to rad
+            rate_a = data[2][3]
+            rate_b = data[2][4]
+            rate_c = data[2][5]
 
             # CW - Winding I/O code, 1-turn ratio on pu bus base kV, 2: winding V, 3: turn ratio pu on norn wind V
             if data[0][4] == 2:
@@ -516,6 +520,9 @@ def _parse_transf_v33(raw, system, max_bus):
                      'Sn': Sn,
                      'Vn1': Vn1,
                      'Vn2': Vn2,
+                     'rate_a': rate_a,
+                     'rate_b': rate_b,
+                     'rate_c': rate_c,
                      }
 
             out['Line'].append(param)
@@ -647,8 +654,8 @@ def sort_psse_models(dyr_yaml, system):
     list
         The sequence of model names for loading parameters.
     """
-
-    andes_models = list_flatten(list(file_classes.values()))
+    _, andes_models = map(list, zip(*file_classes))
+    andes_models = list_flatten(andes_models)
     graph = defaultdict(list)
 
     for psse_model in dyr_yaml:
diff --git a/andes/main.py b/andes/main.py
index a84f8d54b..6cfaf191b 100644
--- a/andes/main.py
+++ b/andes/main.py
@@ -4,7 +4,7 @@
 Main entry point for the ANDES CLI and scripting interfaces.
 """
 
-#  [ANDES] (C)2015-2021 Hantao Cui
+#  [ANDES] (C)2015-2022 Hantao Cui
 #
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -255,7 +255,7 @@ def print_license():
     print(f"""
     ANDES version {andes.__version__}
 
-    Copyright (c) 2015-2021 Hantao Cui
+    Copyright (c) 2015-2022 Hantao Cui
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
diff --git a/andes/models/__init__.py b/andes/models/__init__.py
index c6bbcfa68..a6b072635 100644
--- a/andes/models/__init__.py
+++ b/andes/models/__init__.py
@@ -2,17 +2,14 @@
 The package for DAE models in ANDES.
 """
 
-from collections import OrderedDict
-
 # Notes:
 # - `timer`s are moved to the beginning for initialization.
 #   Connectivity statuses should be restored before initializing the rest.
 
+# `file_classes` records the `.py` files under `andes/models` and the classes in
+# each file. Models will be initialized in the order given below.
 
-# `file_classes` records the `.py` files under `andes/models` and the classes in each file.
-# Models will be initialized in the order given below.
-
-file_classes = OrderedDict([
+file_classes = list([
     ('info', ['Summary']),
     ('timer', ['Toggler', 'Fault', 'Alter']),
     ('timeseries', ['TimeSeries']),
@@ -23,6 +20,7 @@
     ('area', ['Area', 'ACE', 'ACEc']),
     ('dynload', ['ZIP', 'FLoad']),
     ('synchronous', ['GENCLS', 'GENROU', 'PLBVFU1']),
+    ('experimental', ['GENROUOS']),
     ('governor', ['TG2', 'TGOV1', 'TGOV1DB', 'TGOV1N', 'TGOV1NDB',
                   'IEEEG1', 'IEESGO', 'GAST', 'HYGOV', 'HYGOVDB']),
     ('vcomp', ['IEEEVC']),
@@ -34,8 +32,10 @@
     ('measurement', ['BusFreq', 'BusROCOF', 'PMU', 'PLL1']),
     ('dc', ['Node', 'Ground', 'R', 'L', 'C', 'RCp', 'RCs', 'RLs', 'RLCs', 'RLCp']),
     ('acdc', ['VSCShunt']),
-    ('renewable', ['REGCA1', 'REECA1', 'REECA1E', 'REECA1G',
-                   'REPCA1', 'WTDTA1', 'WTDS', 'WTARA1', 'WTPTA1', 'WTTQA1', 'WTARV1',
+    ('renewable', ['REGCA1', 'REGCP1']),
+    ('renewable', ['REECA1', 'REECA1E', 'REECA1G']),
+    ('renewable', ['REPCA1']),
+    ('renewable', ['WTDTA1', 'WTDS', 'WTARA1', 'WTPTA1', 'WTTQA1', 'WTARV1',
                    'REGCV1', 'REGCV2']),
     ('distributed', ['PVD1', 'ESD1', 'EV1', 'EV2', 'DGPRCT1', 'DGPRCTExt']),
     ('coi', ['COI']),
diff --git a/andes/models/area.py b/andes/models/area.py
index fc10f70a9..4e2958e6f 100644
--- a/andes/models/area.py
+++ b/andes/models/area.py
@@ -90,7 +90,8 @@ def __init__(self, system, config):
         self.area = ExtParam(model='Bus', src='area', indexer=self.bus, export=False)
 
         self.busf.model = self.config.freq_model
-        self.busfreq = DeviceFinder(self.busf, link=self.bus, idx_name='bus')
+        self.busfreq = DeviceFinder(self.busf, link=self.bus, idx_name='bus',
+                                    default_model='BusFreq')
 
         self.imva = ConstService(v_str='1/sys_mva', info='reciprocal of system mva',
                                  tex_name='1/S_{b, sys}')
diff --git a/andes/models/bus.py b/andes/models/bus.py
index eb7b6e6be..f2419ee03 100644
--- a/andes/models/bus.py
+++ b/andes/models/bus.py
@@ -109,11 +109,13 @@ def __init__(self, system=None, config=None):
                        tex_name=r'\theta',
                        info='voltage angle',
                        unit='rad',
+                       is_output=True,
                        )
         self.v = Algeb(name='v',
                        tex_name='V',
                        info='voltage magnitude',
                        unit='p.u.',
+                       is_output=True,
                        )
 
         # initial values
diff --git a/andes/models/distributed/pvd1.py b/andes/models/distributed/pvd1.py
index a6c45d812..6ab7cbee4 100644
--- a/andes/models/distributed/pvd1.py
+++ b/andes/models/distributed/pvd1.py
@@ -233,7 +233,8 @@ def __init__(self, system, config):
                                info='selected bus (bus or igreg)',
                                )
 
-        self.busfreq = DeviceFinder(self.busf, link=self.buss, idx_name='bus')
+        self.busfreq = DeviceFinder(self.busf, link=self.buss, idx_name='bus',
+                                    default_model='BusFreq')
 
         # --- initial values from power flow ---
         # a : bus voltage angle
diff --git a/andes/models/dynload/fload.py b/andes/models/dynload/fload.py
index 66e14b633..64b634c23 100644
--- a/andes/models/dynload/fload.py
+++ b/andes/models/dynload/fload.py
@@ -70,6 +70,7 @@ def __init__(self, system, config):
 
         self.busfreq = DeviceFinder(u=self.busf, link=self.bus, idx_name='bus',
                                     info='found idx of BusFreq',
+                                    default_model='BusFreq',
                                     )
 
         self.f = ExtAlgeb(model='FreqMeasurement', src='f', indexer=self.busfreq,
diff --git a/andes/models/exciter/esst1a.py b/andes/models/exciter/esst1a.py
index e232054a2..06ead6485 100644
--- a/andes/models/exciter/esst1a.py
+++ b/andes/models/exciter/esst1a.py
@@ -243,10 +243,12 @@ def __init__(self, system, config):
         self.efdu = VarService(info='Output exciter voltage upper bound',
                                tex_name=r'efd_{u}',
                                v_str='Abs(vd + 1j*vq) * VRMAX - KC * XadIfd',
+                               sequential=False,
                                )
         self.efdl = VarService(info='Output exciter voltage lower bound',
                                tex_name=r'efd_{l}',
-                               v_str='Abs(vd + 1j*vq) * VRMIN'
+                               v_str='Abs(vd + 1j*vq) * VRMIN',
+                               sequential=False,
                                )
 
         self.vol = GainLimiter(u=self.LVG_y,
@@ -280,6 +282,7 @@ class ESST1A(ESST1AData, ESST1AModel):
 
     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/excbase.py b/andes/models/exciter/excbase.py
index 3c7fb962d..fc1c006fc 100644
--- a/andes/models/exciter/excbase.py
+++ b/andes/models/exciter/excbase.py
@@ -32,13 +32,14 @@ class ExcBase(Model):
 
     Notes
     -----
-    As of v1.4.5, the input voltage Eterm (variable ``self.v``)
-    is converted to type ``Algeb``.
-    Since variables are evaluated after services,
+    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.
+    TODO: programmatically disallow ``ConstService`` use uninitialized
+    variables.
     """
+
     def __init__(self, system, config):
         Model.__init__(self, system, config)
         self.group = 'Exciter'
@@ -94,6 +95,7 @@ def __init__(self, system, config):
                               indexer=self.syn,
                               tex_name=r'\omega',
                               info='Generator speed',
+                              is_input=True,
                               )
         self.vf = ExtAlgeb(src='vf',
                            model='SynGen',
@@ -103,12 +105,14 @@ def __init__(self, system, config):
                            info='Excitation field voltage to generator',
                            ename='vf',
                            tex_ename='v_f',
+                           is_input=False,
                            )
         self.XadIfd = ExtAlgeb(src='XadIfd',
                                model='SynGen',
                                indexer=self.syn,
                                tex_name=r'X_{ad}I_{fd}',
                                info='Armature excitation current',
+                               is_input=True,
                                )
         # from bus, get a and v
         self.a = ExtAlgeb(model='Bus',
@@ -116,12 +120,14 @@ def __init__(self, system, config):
                           indexer=self.bus,
                           tex_name=r'\theta',
                           info='Bus voltage phase angle',
+                          is_input=True,
                           )
         self.vbus = ExtAlgeb(model='Bus',
                              src='v',
                              indexer=self.bus,
                              tex_name='V',
                              info='Bus voltage magnitude',
+                             is_input=True
                              )
 
         # `self.v` is actually `ETERM` in other software
@@ -140,6 +146,7 @@ def __init__(self, system, config):
                           tex_name='v_{out}',
                           v_str='ue * vf0',
                           diag_eps=True,
+                          is_output=True,
                           )
 
         # Note:
diff --git a/andes/models/experimental.py b/andes/models/experimental.py
deleted file mode 100644
index 8ee16685e..000000000
--- a/andes/models/experimental.py
+++ /dev/null
@@ -1,201 +0,0 @@
-"""
-Experimental Models
-"""
-from andes.core.block import (DeadBand1, LagAWFreeze, LagFreeze, PIController,
-                              PIFreeze, PITrackAW, PITrackAWFreeze,)
-from andes.core.discrete import HardLimiter
-from andes.core.model import Model, ModelData
-from andes.core.param import IdxParam, NumParam
-from andes.core.service import ExtendedEvent, ExtService
-from andes.core.var import Algeb, ExtAlgeb, State
-
-
-class PI2Data(ModelData):
-    """Data for PI2 model with deadlock issue"""
-
-    def __init__(self):
-        ModelData.__init__(self)
-        self.Kp = NumParam()
-        self.Ki = NumParam()
-        self.Wmax = NumParam()
-        self.Wmin = NumParam()
-
-
-class PI2Model(Model):
-    def __init__(self, system, config):
-        Model.__init__(self, system, config)
-        self.group = 'Experimental'
-        self.flags.update({'tds': True})
-        self.uin = State(v_str=0,
-                         e_str='Piecewise((0, dae_t<= 0), (1, dae_t <= 2), (-1, dae_t <6), (1, True))',
-                         tex_name='u_{in}',
-                         )
-        self.x = State(e_str='uin * Ki * HL_zi',
-                       v_str=0.05,
-                       )
-        self.y = Algeb(e_str='uin * Kp + x - y',
-                       v_str=0.05)
-
-        self.HL = HardLimiter(u=self.y, lower=self.Wmin, upper=self.Wmax)
-        self.w = Algeb(e_str='HL_zi * y + HL_zl * Wmin + HL_zu * Wmax - w',
-                       v_str=0.05)
-
-
-class PI2(PI2Data, PI2Model):
-    def __init__(self, system, config):
-        PI2Data.__init__(self)
-        PI2Model.__init__(self, system, config)
-
-
-class TestFrame(ModelData, Model):
-    """
-    An empty model for testing modeling elements.
-    Needs to be inherited by specific test models.
-    """
-
-    def __init__(self, system, config):
-        ModelData.__init__(self)
-        Model.__init__(self, system, config)
-        self.group = 'Experimental'
-
-        self.flags.tds = True
-
-
-class TestDB1(TestFrame):
-    """
-    Test model for `DeadBand1`.
-    """
-
-    def __init__(self, system, config):
-        TestFrame.__init__(self, system, config)
-
-        self.uin = Algeb(v_str='-10',
-                         e_str='(dae_t - 10) - uin',
-                         tex_name='u_{in}'
-                         )
-        self.DB = DeadBand1(self.uin, center=0, lower=-5, upper=5)
-
-
-class TestPI(TestFrame):
-    def __init__(self, system, config):
-        TestFrame.__init__(self, system, config)
-
-        self.Text = NumParam(default=1.0, info='Extended event time', unit='s')
-
-        self.uin = Algeb(v_str=0,
-                         e_str='sin(dae_t) - uin',
-                         tex_name='u_{in}',
-                         )
-
-        self.zf = Algeb(v_str=0,
-                        e_str='Piecewise((0, dae_t <= 2), (1, dae_t <=6), (0, dae_t<=12), (1, dae_t<=15), '
-                              '(0, True)) - zf',
-                        tex_name='z_f',
-                        )
-
-        self.PI = PIController(u=self.uin, kp=1, ki=0.1)
-
-        self.PIF = PIFreeze(u=self.uin, kp=0.5, ki=0.5, x0=0,
-                            freeze=self.zf)
-
-        self.PIAW = PITrackAW(u=self.uin, kp=0.5, ki=0.5, ks=2,
-                              lower=-0.5, upper=0.5, x0=0.0,
-                              )
-
-        self.PIAWF = PITrackAWFreeze(u=self.uin, kp=0.5, ki=0.5, ks=2, x0=0,
-                                     freeze=self.zf, lower=-0.5, upper=0.5)
-
-        self.ExtEvent = ExtendedEvent(u=self.zf, t_ext=self.Text, trig='rise', extend_only=True)
-
-        self.ze = Algeb(v_str='ExtEvent', e_str='ExtEvent - ze')
-
-
-class TestLagAWFreeze(TestFrame):
-    def __init__(self, system, config):
-        TestFrame.__init__(self, system, config)
-
-        self.uin = Algeb(v_str=0,
-                         e_str='sin(dae_t) - uin',
-                         tex_name='u_{in}',
-                         )
-
-        self.zf = Algeb(v_str=0,
-                        e_str='Piecewise((0, dae_t <= 2), (1, dae_t <=6), (0, True)) - zf',
-                        tex_name='z_f',
-                        )
-
-        self.LGF = LagFreeze(u=self.uin, T=1.0, K=1.0,
-                             freeze=self.zf,
-                             )
-
-        self.LGAWF = LagAWFreeze(u=self.uin, T=1.0, K=1.0, lower=-0.5, upper=0.5,
-                                 freeze=self.zf,
-                                 )
-
-
-class FixedGenData(ModelData):
-    """
-    Data for fixed dynamic generator
-    """
-
-    def __init__(self):
-        ModelData.__init__(self)
-
-        self.bus = IdxParam(model='Bus',
-                            info="interface bus id",
-                            mandatory=True,
-                            )
-        self.gen = IdxParam(info="static generator index",
-                            mandatory=True,
-                            )
-
-
-class FixedGenModel(Model):
-    def __init__(self, system, config):
-        Model.__init__(self, system, config)
-
-        self.flags.tds = True
-        self.group = 'Experimental'
-
-        self.a = ExtAlgeb(model='Bus',
-                          src='a',
-                          indexer=self.bus,
-                          tex_name=r'\theta',
-                          info='Bus voltage angle',
-                          e_str='-p0',
-                          ename='P',
-                          tex_ename='P',
-                          )
-
-        self.v = ExtAlgeb(model='Bus',
-                          src='v',
-                          indexer=self.bus,
-                          tex_name=r'V',
-                          info='Bus voltage magnitude',
-                          e_str='-q0',
-                          ename='P',
-                          tex_ename='P',
-                          )
-
-        self.p0 = ExtService(model='StaticGen',
-                             src='p',
-                             indexer=self.gen,
-                             tex_name='P_0',
-                             )
-        self.q0 = ExtService(model='StaticGen',
-                             src='q',
-                             indexer=self.gen,
-                             tex_name='Q_0',
-                             )
-
-    def v_numeric(self, **kwargs):
-        """
-        Disable the corresponding `StaticGen`s.
-        """
-        self.system.groups['StaticGen'].set(src='u', idx=self.gen.v, attr='v', value=0)
-
-
-class FixedGen(FixedGenData, FixedGenModel):
-    def __init__(self, system, config):
-        FixedGenData.__init__(self)
-        FixedGenModel.__init__(self, system, config)
diff --git a/andes/models/experimental/__init__.py b/andes/models/experimental/__init__.py
new file mode 100644
index 000000000..279b3815e
--- /dev/null
+++ b/andes/models/experimental/__init__.py
@@ -0,0 +1,8 @@
+"""
+Experimental models.
+"""
+
+from andes.models.experimental.fixed import FixedGen  # NOQA
+from andes.models.experimental.picontroller import PI2  # NOQA
+from andes.models.experimental.testmodel import TestDB1, TestPI, TestLagAWFreeze  # NOQA
+from andes.models.experimental.genrouos import GENROUOS  # NOQA
diff --git a/andes/models/experimental/fixed.py b/andes/models/experimental/fixed.py
new file mode 100644
index 000000000..ddbeed92c
--- /dev/null
+++ b/andes/models/experimental/fixed.py
@@ -0,0 +1,69 @@
+from andes.core import ModelData, IdxParam, Model, ExtAlgeb, ExtService
+
+
+class FixedGenData(ModelData):
+    """
+    Data for fixed dynamic generator
+    """
+
+    def __init__(self):
+        ModelData.__init__(self)
+
+        self.bus = IdxParam(model='Bus',
+                            info="interface bus id",
+                            mandatory=True,
+                            )
+        self.gen = IdxParam(info="static generator index",
+                            mandatory=True,
+                            )
+
+
+class FixedGenModel(Model):
+    def __init__(self, system, config):
+        Model.__init__(self, system, config)
+
+        self.flags.tds = True
+        self.group = 'Experimental'
+
+        self.a = ExtAlgeb(model='Bus',
+                          src='a',
+                          indexer=self.bus,
+                          tex_name=r'\theta',
+                          info='Bus voltage angle',
+                          e_str='-p0',
+                          ename='P',
+                          tex_ename='P',
+                          )
+
+        self.v = ExtAlgeb(model='Bus',
+                          src='v',
+                          indexer=self.bus,
+                          tex_name=r'V',
+                          info='Bus voltage magnitude',
+                          e_str='-q0',
+                          ename='P',
+                          tex_ename='P',
+                          )
+
+        self.p0 = ExtService(model='StaticGen',
+                             src='p',
+                             indexer=self.gen,
+                             tex_name='P_0',
+                             )
+        self.q0 = ExtService(model='StaticGen',
+                             src='q',
+                             indexer=self.gen,
+                             tex_name='Q_0',
+                             )
+
+    def v_numeric(self, **kwargs):
+        """
+        Disable the corresponding `StaticGen`s.
+        """
+        self.system.groups['StaticGen'].set(src='u', idx=self.gen.v, attr='v', value=0)
+
+
+class FixedGen(FixedGenData, FixedGenModel):
+    def __init__(self, system, config):
+        FixedGenData.__init__(self)
+        FixedGenModel.__init__(self, system, config)
diff --git a/andes/models/experimental/genrouos.py b/andes/models/experimental/genrouos.py
new file mode 100644
index 000000000..f77f38bde
--- /dev/null
+++ b/andes/models/experimental/genrouos.py
@@ -0,0 +1,50 @@
+"""
+Round-rotor generator model.
+"""
+
+import logging
+
+from andes.core.service import VarService
+from andes.models.synchronous.genbase import GENBase, Flux0
+from andes.models.synchronous.genrou import GENROUData, GENROUModel
+
+logger = logging.getLogger(__name__)
+
+
+class GENROUOSModel(GENROUModel):
+    def __init__(self):
+        GENROUModel.__init__(self)
+        delattr(self, 'psi2q')
+        delattr(self, 'psi2d')
+        delattr(self, 'psi2')
+
+        self.algebs.pop('psi2q')
+        self.algebs.pop('psi2d')
+        self.algebs.pop('psi2')
+
+        self.psi2q = VarService(tex_name=r"\psi_{aq}", info='q-axis air gap flux',
+                                v_str='gq1*e1d + (1-gq1)*e2q',
+                                )
+
+        self.psi2d = VarService(tex_name=r"\psi_{ad}", info='d-axis air gap flux',
+                                v_str='gd1*e1q + gd2*(xd1-xl)*e2d',
+                                )
+
+        self.psi2 = VarService(tex_name=r"\psi_a", info='air gap flux magnitude',
+                               v_str='sqrt(psi2d **2 + psi2q ** 2)',
+                               )
+        # fix the reference to `psi2`
+        self.SL.u = self.psi2
+
+
+class GENROUOS(GENROUData, GENBase, GENROUOSModel, Flux0):
+    """
+    Round rotor generator with quadratic saturation. The model implements
+    operator splitting for the flux linkage equations.
+    """
+
+    def __init__(self, system, config):
+        GENROUData.__init__(self)
+        GENBase.__init__(self, system, config)
+        Flux0.__init__(self)
+        GENROUOSModel.__init__(self)
diff --git a/andes/models/experimental/picontroller.py b/andes/models/experimental/picontroller.py
new file mode 100644
index 000000000..bbb6ed76f
--- /dev/null
+++ b/andes/models/experimental/picontroller.py
@@ -0,0 +1,38 @@
+from andes.core import ModelData, NumParam, Model, State, Algeb, HardLimiter
+
+
+class PI2Data(ModelData):
+    """Data for PI2 model with deadlock issue"""
+
+    def __init__(self):
+        ModelData.__init__(self)
+        self.Kp = NumParam()
+        self.Ki = NumParam()
+        self.Wmax = NumParam()
+        self.Wmin = NumParam()
+
+
+class PI2Model(Model):
+    def __init__(self, system, config):
+        Model.__init__(self, system, config)
+        self.group = 'Experimental'
+        self.flags.update({'tds': True})
+        self.uin = State(v_str=0,
+                         e_str='Piecewise((0, dae_t<= 0), (1, dae_t <= 2), (-1, dae_t <6), (1, True))',
+                         tex_name='u_{in}',
+                         )
+        self.x = State(e_str='uin * Ki * HL_zi',
+                       v_str=0.05,
+                       )
+        self.y = Algeb(e_str='uin * Kp + x - y',
+                       v_str=0.05)
+
+        self.HL = HardLimiter(u=self.y, lower=self.Wmin, upper=self.Wmax)
+        self.w = Algeb(e_str='HL_zi * y + HL_zl * Wmin + HL_zu * Wmax - w',
+                       v_str=0.05)
+
+
+class PI2(PI2Data, PI2Model):
+    def __init__(self, system, config):
+        PI2Data.__init__(self)
+        PI2Model.__init__(self, system, config)
diff --git a/andes/models/group.py b/andes/models/group.py
index 1b6f3ef1f..9e9a8ce19 100644
--- a/andes/models/group.py
+++ b/andes/models/group.py
@@ -495,7 +495,7 @@ class StaticGen(GroupBase):
     def __init__(self):
         super().__init__()
         self.common_params.extend(('Sn', 'Vn', 'p0', 'q0', 'ra', 'xs', 'subidx'))
-        self.common_vars.extend(('p', 'q', 'a', 'v'))
+        self.common_vars.extend(('q', 'a', 'v'))
 
         self.SynGen = BackRef()
 
@@ -543,8 +543,7 @@ class SynGen(GroupBase):
     def __init__(self):
         super().__init__()
         self.common_params.extend(('Sn', 'Vn', 'fn', 'bus', 'M', 'D', 'subidx'))
-        self.common_vars.extend(('omega', 'delta', 'tm', 'te', 'vf', 'XadIfd', 'vd', 'vq', 'Id', 'Iq',
-                                 'a', 'v'))
+        self.common_vars.extend(('omega', 'delta', ))
 
         self.TurbineGov = BackRef()
         self.Exciter = BackRef()
@@ -720,6 +719,14 @@ def __init__(self):
         self.common_vars.extend(('am', 'vm'))
 
 
+class PLL(GroupBase):
+    """Phase-locked loop models."""
+
+    def __init__(self):
+        super().__init__()
+        self.common_vars.extend(('am',))
+
+
 class Motor(GroupBase):
     """Induction Motor group
     """
diff --git a/andes/models/line/line.py b/andes/models/line/line.py
index f839f51b1..d08e4a7c0 100644
--- a/andes/models/line/line.py
+++ b/andes/models/line/line.py
@@ -105,6 +105,24 @@ def __init__(self):
                             unit='radian',
                             )
 
+        self.rate_a = NumParam(default=0.0,
+                               info="long-term flow limit (placeholder)",
+                               tex_name='R_{ATEA}',
+                               unit='MVA',
+                               )
+
+        self.rate_b = NumParam(default=0.0,
+                               info="short-term flow limit (placeholder)",
+                               tex_name='R_{ATEB}',
+                               unit='MVA',
+                               )
+
+        self.rate_c = NumParam(default=0.0,
+                               info="emergency flow limit (placeholder)",
+                               tex_name='R_{ATEC}',
+                               unit='MVA',
+                               )
+
         self.owner = IdxParam(model='Owner', info="owner code")
 
         self.xcoord = DataParam(info="x coordinates")
@@ -115,8 +133,11 @@ class Line(LineData, Model):
     """
     AC transmission line model.
 
-    To reduce the number of variables, line injections are summed at bus equations
-    and are not stored. Current injections are not computed.
+    The model is also used for two-winding transformer. Transformers can set the
+    tap ratio in ``tap`` and/or phase shift angle ``phi``.
+
+    To reduce the number of variables, line injections are summed at bus
+    equations and are not stored. Current injections are not computed.
     """
 
     def __init__(self, system=None, config=None):
diff --git a/andes/models/measurement/pll.py b/andes/models/measurement/pll.py
index f2302a367..9ebaf157f 100644
--- a/andes/models/measurement/pll.py
+++ b/andes/models/measurement/pll.py
@@ -51,6 +51,8 @@ def __init__(self, system, config):
         super().__init__(system, config)
 
         self.flags.tds = True
+        self.group = 'PLL'
+
         self.a = ExtAlgeb(model='Bus',
                           src='a',
                           indexer=self.bus,
diff --git a/andes/models/pss/pssbase.py b/andes/models/pss/pssbase.py
index 5af154950..661a60b49 100644
--- a/andes/models/pss/pssbase.py
+++ b/andes/models/pss/pssbase.py
@@ -42,7 +42,8 @@ def __init__(self, system, config):
 
         self.buss = DataSelect(self.busr, self.bus, info='selected bus (bus or busr)')
 
-        self.busfreq = DeviceFinder(self.busf, link=self.buss, idx_name='bus')
+        self.busfreq = DeviceFinder(self.busf, link=self.buss, idx_name='bus',
+                                    default_model='BusFreq')
 
         # from SynGen
         self.Sn = ExtParam(model='SynGen', src='Sn', indexer=self.syn, tex_name='S_n',
@@ -50,6 +51,7 @@ def __init__(self, system, config):
 
         self.omega = ExtState(model='SynGen', src='omega', indexer=self.syn,
                               tex_name=r'\omega', info='Generator speed', unit='p.u.',
+                              is_input=True,
                               )
 
         self.tm0 = ExtService(model='SynGen', src='tm', indexer=self.syn,
@@ -57,13 +59,16 @@ def __init__(self, system, config):
                               )
         self.tm = ExtAlgeb(model='SynGen', src='tm', indexer=self.syn,
                            tex_name=r'\tau_m', info='Generator mechanical input',
+                           is_input=True,
                            )
         self.te = ExtAlgeb(model='SynGen', src='te', indexer=self.syn,
                            tex_name=r'\tau_e', info='Generator electrical output',
+                           is_input=True,
                            )
         # from Bus
         self.v = ExtAlgeb(model='Bus', src='v', indexer=self.buss, tex_name=r'V',
                           info='Bus (or busr, if given) terminal voltage',
+                          is_input=True,
                           )
         self.v0 = ExtService(model='Bus', src='v', indexer=self.buss, tex_name="V_0",
                              info='Initial bus voltage',
@@ -71,7 +76,9 @@ def __init__(self, system, config):
 
         # from BusFreq
         self.f = ExtAlgeb(model='FreqMeasurement', src='f', indexer=self.busfreq, export=False,
-                          info='Bus frequency')
+                          info='Bus frequency',
+                          is_input=True,
+                          )
 
         # from Exciter
         self.vi = ExtAlgeb(model='Exciter', src='vi', indexer=self.avr, tex_name='v_i',
@@ -79,8 +86,10 @@ def __init__(self, system, config):
                            e_str='u * vsout',
                            ename='Vi',
                            tex_ename='V_i',
+                           is_input=True,
                            )
 
         self.vsout = Algeb(info='PSS output voltage to exciter',
                            tex_name='v_{sout}',
+                           is_output=True,
                            )  # `self.vsout.e_str` to be provided by specific models
diff --git a/andes/models/pss/st2cut.py b/andes/models/pss/st2cut.py
index aae8e2146..bcc5f9806 100644
--- a/andes/models/pss/st2cut.py
+++ b/andes/models/pss/st2cut.py
@@ -96,7 +96,8 @@ def __init__(self, system, config):
         # retrieve indices of bus and bus freq
         self.buss2 = DataSelect(self.busr2, self.bus, info='selected bus (bus or busr)')
 
-        self.busfreq2 = DeviceFinder(self.busf2, link=self.buss2, idx_name='bus')
+        self.busfreq2 = DeviceFinder(self.busf2, link=self.buss2, idx_name='bus',
+                                     default_model='BusFreq', info='bus frequency idx')
 
         # from Bus
         self.v2 = ExtAlgeb(model='Bus', src='v', indexer=self.buss2, tex_name=r'V',
diff --git a/andes/models/renewable/__init__.py b/andes/models/renewable/__init__.py
index e9b7a93d2..7edc1b52b 100644
--- a/andes/models/renewable/__init__.py
+++ b/andes/models/renewable/__init__.py
@@ -5,6 +5,7 @@
 from andes.models.renewable.reeca1 import REECA1  # NOQA
 from andes.models.renewable.reeca1e import REECA1E, REECA1G  # NOQA
 from andes.models.renewable.regca1 import REGCA1  # NOQA
+from andes.models.renewable.regcp1 import REGCP1  # NOQA
 from andes.models.renewable.regcv1 import REGCV1  # NOQA
 from andes.models.renewable.regcv2 import REGCV2  # NOQA
 from andes.models.renewable.repca1 import REPCA1  # NOQA
diff --git a/andes/models/renewable/reeca1.py b/andes/models/renewable/reeca1.py
index 922d8269f..7537257a0 100644
--- a/andes/models/renewable/reeca1.py
+++ b/andes/models/renewable/reeca1.py
@@ -75,7 +75,7 @@ def __init__(self):
         self.Kqv = NumParam(default=1.0,
                             vrange=(0, 10),
                             tex_name='K_{qv}',
-                            info='Gain to compute Iqinj from V error',
+                            info='Gain to compute Iqinj from V error (caution!!)',
                             )
         self.Iqh1 = NumParam(default=999.0,
                              tex_name='I_{qh1}',
diff --git a/andes/models/renewable/reeca1e.py b/andes/models/renewable/reeca1e.py
index 4b44c0280..8cb82678c 100644
--- a/andes/models/renewable/reeca1e.py
+++ b/andes/models/renewable/reeca1e.py
@@ -41,6 +41,7 @@ def __init__(self, system, config):
         self.busrocof = DeviceFinder(self.busroc,
                                      link=self.bus,
                                      idx_name='bus',
+                                     default_model='BusROCOF',
                                      )
 
         self.df = ExtAlgeb(model='FreqMeasurement',
diff --git a/andes/models/renewable/regca1.py b/andes/models/renewable/regca1.py
index 9e7e7acbc..16a71107d 100644
--- a/andes/models/renewable/regca1.py
+++ b/andes/models/renewable/regca1.py
@@ -259,6 +259,7 @@ def __init__(self, system, config):
                                tex_name='H_{VG}'
                                )
         self.HVG.lim.no_warn = True
+        self.HVG.lim.allow_adjust = False
 
         self.Iqout = GainLimiter(u='S1_y - HVG_y',
                                  K=1, R=1,
diff --git a/andes/models/renewable/regcp1.py b/andes/models/renewable/regcp1.py
new file mode 100644
index 000000000..01bfd745e
--- /dev/null
+++ b/andes/models/renewable/regcp1.py
@@ -0,0 +1,69 @@
+"""
+Renewable energy generator (converter) model P with PLL support.
+
+This is a customized model in ANDES, modified from the standard REGCA1 model.
+"""
+
+from andes.core import Algeb, ExtState, IdxParam
+from andes.core.service import DeviceFinder
+from andes.models.renewable.regca1 import REGCA1Data, REGCA1Model
+
+
+class REGCP1Data(REGCA1Data):
+    """
+    REGCP1 model data.
+    """
+
+    def __init__(self):
+        REGCA1Data.__init__(self)
+
+        self.pll = IdxParam(info='Phase-lock loop device idx',
+                            model='PLL',
+                            default=None,
+                            )
+
+
+class REGCP1Model(REGCA1Model):
+    """
+    REGCP1 implementation.
+    """
+
+    def __init__(self, system, config):
+        REGCA1Model.__init__(self, system, config)
+        self.pllidx = DeviceFinder(self.pll,
+                                   link=self.bus,
+                                   idx_name='bus',
+                                   default_model='PLL1',
+                                   )
+
+        self.am = ExtState(model='PLL', src='am', indexer=self.pllidx)
+
+        self.vd = Algeb(v_str='v', info='d-axis voltage', tex_name='V_d',
+                        e_str='vd - v*cos(a - am)')
+
+        self.vq = Algeb(v_str='0', info='q-axis voltage', tex_name='V_q',
+                        e_str='-vq - v*sin(a - am)')
+
+        self.Pe.e_str = '(vd * Ipout + vq * Iqout_y) - Pe'
+
+        self.Qe.e_str = '(vd * Iqout_y - vq * Ipout) - Qe'
+
+    def v_numeric(self, **kwargs):
+        """
+        Disable the corresponding `StaticGen`s.
+        """
+        self.system.groups['StaticGen'].set(src='u', idx=self.gen.v, attr='v', value=0)
+
+
+class REGCP1(REGCP1Data, REGCP1Model):
+    """
+    Renewable energy generator model type A with PLL.
+
+    Volim is the voltage limit for high voltage reactive current management,
+    which should be large than static bus voltage (Volim > v),
+    or initialization error will occur.
+    """
+
+    def __init__(self, system, config):
+        REGCP1Data.__init__(self)
+        REGCP1Model.__init__(self, system, config)
diff --git a/andes/models/renewable/repca1.py b/andes/models/renewable/repca1.py
index df07d9474..83f55d391 100644
--- a/andes/models/renewable/repca1.py
+++ b/andes/models/renewable/repca1.py
@@ -246,7 +246,8 @@ def __init__(self, system, config):
 
         self.buss = DataSelect(self.busr, self.bus, info='selected bus (bus or busr)')
 
-        self.busfreq = DeviceFinder(self.busf, link=self.buss, idx_name='bus')
+        self.busfreq = DeviceFinder(self.busf, link=self.buss, idx_name='bus',
+                                    default_model='BusFreq')
 
         # from Bus
         self.v = ExtAlgeb(model='Bus', src='v', indexer=self.buss, tex_name='V',
diff --git a/andes/models/static/pq.py b/andes/models/static/pq.py
index 9a37cfbe3..b2bbe7077 100644
--- a/andes/models/static/pq.py
+++ b/andes/models/static/pq.py
@@ -136,6 +136,7 @@ def __init__(self, system=None, config=None):
                           tex_name=r'\theta',
                           ename='P',
                           tex_ename='P',
+                          is_input=True,
                           )
         self.v = ExtAlgeb(model='Bus',
                           src='v',
@@ -143,6 +144,7 @@ def __init__(self, system=None, config=None):
                           tex_name=r'V',
                           ename='Q',
                           tex_ename='Q',
+                          is_input=True,
                           )
 
         self.v0 = ExtService(src='v',
diff --git a/andes/models/static/pv.py b/andes/models/static/pv.py
index f84e9afe6..5e84999bf 100644
--- a/andes/models/static/pv.py
+++ b/andes/models/static/pv.py
@@ -6,6 +6,7 @@
 
 from andes.core import (ModelData, NumParam, ExtParam, DataParam, IdxParam, Model,
                         BackRef, ExtAlgeb, Algeb, SortedLimiter)
+from andes.core.service import ConstService
 
 
 class PVData(ModelData):
@@ -85,17 +86,18 @@ def __init__(self, system=None, config=None):
         self.a = ExtAlgeb(model='Bus', src='a', indexer=self.bus, tex_name=r'\theta',
                           ename='P',
                           tex_ename='P',
+                          is_input=True,
                           )
         self.v = ExtAlgeb(model='Bus', src='v', indexer=self.bus, v_setter=True, tex_name=r'V',
                           ename='dV',
                           tex_ename=r'\Delta V',
+                          is_input=True,
                           )
 
-        self.p = Algeb(info='actual active power generation',
-                       unit='p.u.',
-                       tex_name=r'p',
-                       diag_eps=True,
-                       )
+        self.p = ConstService(v_str='p0',
+                              info='copy of p0 used for power flow',
+                              tex_name='p',)
+
         self.q = Algeb(info='actual reactive power generation',
                        unit='p.u.',
                        tex_name='q',
@@ -112,7 +114,6 @@ def __init__(self, system=None, config=None):
 
         # variable initialization equations
         self.v.v_str = 'u * v0 + (1-u) * busv0'
-        self.p.v_str = 'u * p0'
         self.q.v_str = 'u * q0'
 
         # injections into buses have negative values
@@ -120,7 +121,6 @@ def __init__(self, system=None, config=None):
         self.v.e_str = "-u * q"
 
         # power injection equations g(y) = 0
-        self.p.e_str = "u * (p0 - p)"
         self.q.e_str = "u*(qlim_zi * (v0-v) + " \
                        "qlim_zl * (qmin-q) + " \
                        "qlim_zu * (qmax-q))"
diff --git a/andes/models/static/slack.py b/andes/models/static/slack.py
index a779626c3..a6f5b36a2 100644
--- a/andes/models/static/slack.py
+++ b/andes/models/static/slack.py
@@ -4,7 +4,7 @@
 
 from collections import OrderedDict
 
-from andes.core import NumParam, ExtParam, SortedLimiter
+from andes.core import NumParam, ExtParam, SortedLimiter, Algeb
 from andes.models.static.pv import PVData, PVModel
 
 
@@ -42,9 +42,18 @@ def __init__(self, system=None, config=None):
         self.a.v_setter = True
         self.a.v_str = 'u * a0 + (1-u) * busa0'
 
-        self.plim = SortedLimiter(u=self.p, lower=self.pmin, upper=self.pmax,
-                                  enable=self.config.av2pv)
+        delattr(self, 'p')
+        self.p = Algeb(info='actual active power generation',
+                       unit='p.u.',
+                       tex_name=r'p',
+                       diag_eps=True,
+                       v_str='u * p0',
+                       )
 
         self.p.e_str = "u*(plim_zi * (a0-a) + " \
                        "plim_zl * (pmin-p) + " \
                        "plim_zu * (pmax-p))"
+        self.a.e_str = '-u * p'
+
+        self.plim = SortedLimiter(u=self.p, lower=self.pmin, upper=self.pmax,
+                                  enable=self.config.av2pv)
diff --git a/andes/models/synchronous/genbase.py b/andes/models/synchronous/genbase.py
index 356edafb1..50539cf44 100644
--- a/andes/models/synchronous/genbase.py
+++ b/andes/models/synchronous/genbase.py
@@ -135,6 +135,7 @@ def __init__(self, system, config):
                           e_str='-u * (vd * Id + vq * Iq)',
                           ename='P',
                           tex_ename='P',
+                          is_input=True,
                           )
         self.v = ExtAlgeb(model='Bus',
                           src='v',
@@ -144,6 +145,7 @@ def __init__(self, system, config):
                           e_str='-u * (vq * Id - vd * Iq)',
                           ename='Q',
                           tex_ename='Q',
+                          is_input=True,
                           )
 
         # algebraic variables
diff --git a/andes/models/timer.py b/andes/models/timer.py
index 630790b94..b310c5d6f 100644
--- a/andes/models/timer.py
+++ b/andes/models/timer.py
@@ -121,11 +121,11 @@ def __init__(self, system, config):
                                      )))
         self.config.add_extra('_alt',
                               restore=(0, 1),
-                              mode=(1, 2),
+                              mode=(1, 2, 3),
                               )
         self.config.add_extra('_help',
                               restore='restore algebraic variables to pre-fault values',
-                              mode='1 - restore voltages on all buses, 2 - fault bus only',
+                              mode='1. restore all algeb variables, 2. fault bus only',
                               scale='scaling factor of restored algebraic values',
                               )
 
@@ -163,7 +163,8 @@ def __init__(self, system, config):
 
     def apply_fault(self, is_time: np.ndarray):
         """
-        Apply fault and store pre-fault algebraic variables (voltages and other algebs) to `self._vstore`.
+        Apply fault and store pre-fault algebraic variables (voltages and other
+        algebs) to `self._vstore`.
         """
         action = False
         for i in range(self.n):
@@ -172,6 +173,7 @@ def apply_fault(self, is_time: np.ndarray):
 
             self.uf.v[i] = 1
             self._vstore = np.array(self.system.dae.y[self.system.Bus.n:])
+            logger.debug("Pre-fault algebraic variables:\n" + str(self._vstore))
             tqdm.write(f'<Fault {self.idx.v[i]}>: '
                        f'Applying fault on Bus (idx={self.bus.v[i]}) at t={self.tf.v[i]} sec.')
 
@@ -180,24 +182,32 @@ def apply_fault(self, is_time: np.ndarray):
 
     def clear_fault(self, is_time: np.ndarray):
         """
-        Clear fault and restore pre-fault bus algebraic variables (voltages and others).
+        Clear fault and restore pre-fault bus algebraic variables (voltages and
+        others).
         """
         action = False
         for i in range(self.n):
             if is_time[i] and (self.u.v[i] == 1):
                 self.uf.v[i] = 0
-                v_addr = self.system.Bus.get(src='v', idx=self.bus.v[i], attr='a')
-                bus_uid = self.system.Bus.idx2uid(self.bus.v[i])
 
                 if self.config.restore:
                     if self.config.mode == 1:
                         self.system.dae.y[self.system.Bus.n:] = self._vstore * self.config.scale
-                        logger.debug("All voltage restored after clearance at t=%.6f",
+                        logger.debug("All algebraic variables restored after fault clearance at t=%.6f",
                                      self.system.dae.t)
+
+                    # TODO: neither mode 2 or 3 works. Pending further investigation.
                     elif self.config.mode == 2:
+                        v_addr = self.system.Bus.get(src='v', idx=self.bus.v[i], attr='a')
+                        bus_uid = self.system.Bus.idx2uid(self.bus.v[i])
                         self.system.dae.y[v_addr] = self._vstore[bus_uid] * self.config.scale
-                        logger.debug("Voltage on bus %s restored after clearance at t=%.6f",
+                        logger.debug("Voltage on bus %s restored after fault clearance at t=%.6f",
                                      self.bus.v[i], self.system.dae.t)
+                    elif self.config.mode == 3:
+                        nbus = self.system.Bus.n
+                        self.system.dae.y[nbus:2*nbus] = self._vstore[:nbus] * self.config.scale
+                        logger.debug("All bus voltages restored after fault clearance at t=%.6f",
+                                     self.system.dae.t)
                     else:
                         logger.error("Unsupport fault voltage restoration mode")
 
diff --git a/andes/plot.py b/andes/plot.py
index 8a86c7349..6fd3c8df3 100644
--- a/andes/plot.py
+++ b/andes/plot.py
@@ -10,10 +10,10 @@
 import numpy as np
 
 from andes.core.var import BaseVar
-from andes.shared import mpl, plt, set_latex
+from andes.shared import plt, set_font, set_latex
 
 logger = logging.getLogger(__name__)
-DPI = 100
+DPI = 80
 
 
 class TDSData:
@@ -262,6 +262,39 @@ def export_csv(self, path=None, idx=None, header=None, formatted=False,
 
         logger.info(f'CSV data saved to "{path}".')
 
+    def _process_yidx(self, yidx, a):
+        """
+        Helper function for processing ``yidx`` if it is a ``BaseVar`` or a list
+        of BaseVars.
+
+        Indexing by ``a`` is considered.
+        """
+        if isinstance(yidx, BaseVar):
+            yidx = [yidx]
+
+        if isinstance(yidx, list) and isinstance(yidx[0], BaseVar):
+            all_yidx = np.array([], dtype=int)
+            for item in yidx:
+                if item.n == 0:
+                    logger.warning("Variable <%s> contains no values, ignored.", item.name)
+                    continue
+                if item.v_code == 'y':
+                    offs = self.dae.n + 1
+                else:
+                    offs = 1
+
+                new_yidx = item.a + offs
+
+                if a is not None:
+                    new_yidx = np.take(new_yidx, a)
+                all_yidx = np.append(all_yidx, new_yidx)
+
+            yidx = all_yidx
+
+        # a list of integers will remain unchanged
+
+        return yidx
+
     def plot(self, yidx, xidx=(0,), *, a=None, ytimes=None, ycalc=None,
              left=None, right=None, ymin=None, ymax=None,
              xlabel=None, ylabel=None, xheader=None, yheader=None,
@@ -370,19 +403,17 @@ def plot(self, yidx, xidx=(0,), *, a=None, ytimes=None, ycalc=None,
             Figure object for bqplot backend.
 
         """
+
         if self._mode == 'memory':
-            if isinstance(yidx, BaseVar):
-                if yidx.n == 0:
-                    logger.error(f"Variable <{yidx.name}> contains no values.")
-                    return
-                offs = 1
-                if yidx.v_code == 'y':
-                    offs += self.dae.n
+            yidx = self._process_yidx(yidx, a)
 
-                yidx = yidx.a + offs
+        else:  # file mode
+            if a is not None:
+                yidx = np.take(yidx, a)
 
-        if a is not None:
-            yidx = np.take(yidx, a)
+        if len(yidx) == 0:
+            logger.error("No variables to plot.")
+            return
 
         xvalue = self.get_values(xidx)
         yvalue = self.get_values(yidx)
@@ -398,7 +429,7 @@ def plot(self, yidx, xidx=(0,), *, a=None, ytimes=None, ycalc=None,
         if ytimes is not None:
             ytimes = float(ytimes)
             if ytimes != 1.0:
-                yvalue = scale_func(ytimes)(yvalue)
+                yvalue = _scale_func(ytimes)(yvalue)
 
         # call `ycalc` on `yvalue`
         if ycalc is not None:
@@ -518,7 +549,7 @@ def plot_data(self, xdata, ydata, *, xheader=None, yheader=None, xlabel=None, yl
         >>>                      ylabel='Ipcmd [pu]')
 
         """
-        mpl.rc('font', family='serif', size=font_size)
+        set_font(family='serif', size=font_size)
 
         if not isinstance(ydata, np.ndarray):
             raise TypeError("ydata must be a numpy array. Retrieve with get_values().")
@@ -868,7 +899,7 @@ def parse_y(y, upper, lower=0):
             return []
 
         elif y[0].count(':') == 0:
-            if isint(y[0]):
+            if _isint(y[0]):
                 y[0] = int(y[0])
                 return y
         elif y[0].count(':') == 1:
@@ -997,15 +1028,11 @@ def tdsplot(filename, y, x=(0,),
         raise NotImplementedError("Plotting multiple data files are not supported yet")
 
 
-def isfloat(value):
-    try:
-        float(value)
-        return True
-    except ValueError:
-        return False
-
+def _isint(value):
+    """
+    Helper function to tell if ``value`` is convertable to an integer.
+    """
 
-def isint(value):
     try:
         int(value)
         return True
@@ -1013,7 +1040,7 @@ def isint(value):
         return False
 
 
-def scale_func(k):
+def _scale_func(k):
     """
     Return a lambda function that scales its input by k
 
@@ -1029,7 +1056,7 @@ def scale_func(k):
     return lambda y_values_input: k * y_values_input
 
 
-def label_latexify(label):
+def _label_latexify(label):
     """
     Convert a label to latex format by appending surrounding $ and escaping spaces
 
diff --git a/andes/routines/base.py b/andes/routines/base.py
index 47254bda1..d27f0d942 100644
--- a/andes/routines/base.py
+++ b/andes/routines/base.py
@@ -34,6 +34,7 @@ def __init__(self, system=None, config=None):
                               )
 
         self.solver = Solver(sparselib=self.config.sparselib)
+        self.exec_time = 0.0  # recorded time to execute the routine in seconds
 
     @property
     def class_name(self):
diff --git a/andes/routines/eig.py b/andes/routines/eig.py
index 602491054..b10ec7675 100644
--- a/andes/routines/eig.py
+++ b/andes/routines/eig.py
@@ -16,7 +16,7 @@
 
 from andes.plot import set_latex
 
-from andes.shared import matrix, spmatrix, sparse, plt, mpl
+from andes.shared import matrix, set_font, spmatrix, sparse, plt
 from andes.shared import div, spdiag
 
 
@@ -301,7 +301,8 @@ def run(self, **kwargs):
         self.calc_As()
         self.mu, self.pfactors, self.N, self.W = self.calc_pfactor()
         self._store_stats()
-        _, s = elapsed(t1)
+        t2, s = elapsed(t1)
+        self.exec_time = t2 - t1
 
         logger.info('  Positive  %6g', self.n_positive)
         logger.info('  Zeros     %6g', self.n_zeros)
@@ -370,7 +371,7 @@ def plot(self, mu=None, fig=None, ax=None,
 
         """
 
-        mpl.rc('font', family='Times New Roman', size=12)
+        set_font(family='Times New Roman', size=12)
 
         if mu is None:
             mu = self.mu
diff --git a/andes/routines/pflow.py b/andes/routines/pflow.py
index 2226845a8..10f953067 100644
--- a/andes/routines/pflow.py
+++ b/andes/routines/pflow.py
@@ -17,6 +17,7 @@ class PFlow(BaseRoutine):
     """
     Power flow calculation routine.
     """
+
     def __init__(self, system=None, config=None):
         super().__init__(system, config)
         self.config.add(OrderedDict((('tol', 1e-6),
@@ -74,6 +75,7 @@ def init(self):
         self.A = None
         self.niter = None
         self.mis = [1]
+        self.exec_time = 0.0
 
         self.x_sol = None
         self.y_sol = None
@@ -165,6 +167,7 @@ def summary(self):
         out = list()
         out.append('')
         out.append('-> Power flow calculation')
+        out.append(f'{"Numba":>16s}: {"On" if self.system.config.numba else "Off"}')
         out.append(f'{"Sparse solver":>16s}: {self.solver.sparselib.upper()}')
         out.append(f'{"Solution method":>16s}: {self.config.method} method')
         out_str = '\n'.join(out)
@@ -211,7 +214,8 @@ def run(self, **kwargs):
                 break
             self.niter += 1
 
-        _, s1 = elapsed(t0)
+        t1, s1 = elapsed(t0)
+        self.exec_time = t1 - t0
 
         if not self.converged:
             if abs(self.mis[-1] - self.mis[-2]) < self.config.tol:
diff --git a/andes/routines/tds.py b/andes/routines/tds.py
index 992d6e27f..c86c832a2 100644
--- a/andes/routines/tds.py
+++ b/andes/routines/tds.py
@@ -2,20 +2,18 @@
 ANDES module for time-domain simulation.
 """
 
-import sys
-import os
-import time
 import importlib
 import logging
+import os
+import sys
+import time
 from collections import OrderedDict
 
 from andes.routines.base import BaseRoutine
-from andes.routines.daeint import method_map, Trapezoid
-
-from andes.utils.misc import elapsed, is_notebook, is_interactive
+from andes.routines.daeint import Trapezoid, method_map
+from andes.shared import matrix, np, pd, spdiag, tqdm, tqdm_nb
+from andes.utils.misc import elapsed, is_interactive, is_notebook
 from andes.utils.tab import Tab
-from andes.shared import tqdm, tqdm_nb, np, pd
-from andes.shared import matrix, spdiag
 
 logger = logging.getLogger(__name__)
 
@@ -117,7 +115,7 @@ def __init__(self, system=None, config=None):
         self.deltatmin = 0
         self.deltatmax = 0
         self.h = 0
-        self.next_pc = 0
+        self.last_pc = 0.0
         self.Teye = None
         self.qg = np.array([])
         self.tol_zero = self.config.tol / 1e6
@@ -140,6 +138,7 @@ def __init__(self, system=None, config=None):
         self.test_ok = None
         self.qrt_start = None
         self.headroom = 0.0
+        self.call_stats = list()
 
         # internal storage for iterations
         self.x0 = None
@@ -331,8 +330,8 @@ def run(self, no_summary=False, **kwargs):
                              file=sys.stdout, disable=self.config.no_tqdm)
 
         if resume:
-            perc = round((dae.t - config.t0) / (config.tf - config.t0) * 100, 0)
-            self.next_pc = perc + 1
+            perc = round((dae.t - config.t0) / (config.tf - config.t0) * 100, 2)
+            self.last_pc = perc
             self.pbar.update(perc)
 
         self.qrt_start = time.time()
@@ -351,6 +350,10 @@ def run(self, no_summary=False, **kwargs):
             else:
                 step_status = self._csv_step()
 
+            # record number of iterations and success flag
+            if system.config.call_stats:
+                self.call_stats.append((system.dae.t.tolist(), self.niter, step_status))
+
             if step_status:
                 dae.store()
 
@@ -363,9 +366,12 @@ def run(self, no_summary=False, **kwargs):
 
                 # show progress in percentage
                 perc = max(min((dae.t - config.t0) / (config.tf - config.t0) * 100, 100), 0)
-                if perc >= self.next_pc:
-                    self.pbar.update(1)
-                    self.next_pc += 1
+                perc = round(perc, 2)
+
+                perc_diff = perc - self.last_pc
+                if perc_diff >= 1:
+                    self.pbar.update(perc_diff)
+                    self.last_pc = self.last_pc + perc_diff
 
                 # quasi-real-time check and wait (except for the last step)
                 if config.qrt and self.h > 0:
@@ -388,9 +394,6 @@ def run(self, no_summary=False, **kwargs):
                     self.busted = True
                     break
 
-        self.pbar.close()
-        self.pbar = None  # removed `pbar` so that System object can be serialized
-
         if self.busted:
             logger.error(self.err_msg)
             logger.error("Simulation terminated at t=%.4f s.", system.dae.t)
@@ -398,10 +401,15 @@ def run(self, no_summary=False, **kwargs):
         elif system.dae.t == self.config.tf:
             succeed = True   # success flag
             system.exit_code += 0
+            self.pbar.update(100 - self.last_pc)
         else:
             system.exit_code += 1
 
-        _, s1 = elapsed(t0)
+        self.pbar.close()
+        self.pbar = None  # removed `pbar` so that System object can be serialized
+
+        t1, s1 = elapsed(t0)
+        self.exec_time = t1 - t0
         logger.info('Simulation completed in %s.', s1)
 
         if config.qrt:
@@ -717,8 +725,8 @@ def fg_update(self, models, init=False):
         Perform one round of evaluation for one iteration step.
         The following operations are performed in order:
 
-        - discrete flags updating through ``l_update_var``
         - variable service updating through ``s_update_var``
+        - discrete flags updating through ``l_update_var``
         - evaluation of the right-hand-side of ``f``
         - equation-dependent discrete flags updating through ``l_update_eq``
         - evaluation of the right-hand-side of ``g``
@@ -729,13 +737,12 @@ def fg_update(self, models, init=False):
         system = self.system
         system.dae.clear_fg()
 
+        system.s_update_var(models=models)  # update VarService
         system.l_update_var(models=models,
                             niter=self.niter,
                             err=self.mis[-1],
                             )
 
-        system.s_update_var(models=models)  # update VarService
-
         # evalute the RHS of `f` and check the limiters (anti-windup)
         # 12/08/2020: Moved `l_update_eq` to before `g_update`
         #   because some algebraic variables depend on pegged states.
@@ -830,12 +837,16 @@ def _debug_g(self, y_idx):
             Index of the equation into the `g` array. Diff. eqns. are not counted in.
         """
         y_idx = y_idx.tolist()
-        logger.debug('Max. algebraic mismatch associated with <%s> [y_idx=%d]',
-                     self.system.dae.y_name[y_idx], y_idx)
+        logger.debug('--> Iteration Number: niter = %d', self.niter)
+        logger.debug('Max. algebraic equation mismatch:')
+        logger.debug('  <%s> [y_idx=%d]', self.system.dae.y_name[y_idx], y_idx)
+        logger.debug('  Variable value = %.4f', self.system.dae.y[y_idx])
+        logger.debug('  Mismatch value = %.4f', self.system.dae.g[y_idx])
+
         assoc_vars = self.system.dae.gy[y_idx, :]
         vars_idx = np.where(np.ravel(matrix(assoc_vars)))[0]
 
-        logger.debug('')
+        logger.debug('Related variable values:')
         logger.debug(f'{"y_index":<10} {"Variable":<20} {"Derivative":<20}')
         for v in vars_idx:
             v = v.tolist()
@@ -858,10 +869,13 @@ def _debug_ac(self, xy_idx):
         eqns_idx = np.where(np.ravel(matrix(assoc_eqns)))[0]
         vars_idx = np.where(np.ravel(matrix(assoc_vars)))[0]
 
-        logger.debug('Max. correction is for variable %s [%d]', self.system.dae.xy_name[xy_idx], xy_idx)
-        logger.debug('Associated equation rhs is %20g', self.system.dae.fg[xy_idx])
+        logger.debug('Max. correction=%.4f for variable %s [%d]', self.inc[xy_idx],
+                     self.system.dae.xy_name[xy_idx], xy_idx)
+        logger.debug('Associated equation RHS is %20g', self.system.dae.fg[xy_idx])
         logger.debug('')
 
+        logger.debug('Related Jacobian elements:')
+        logger.debug(f'{"y_index":<10} {"Variable":<20} {"Derivative":<20}')
         logger.debug(f'{"xy_index":<10} {"Equation (row)":<20} {"Derivative":<20} {"Eq. Mismatch":<20}')
         for eq in eqns_idx:
             eq = eq.tolist()
@@ -883,7 +897,7 @@ def reset(self):
         self.deltatmin = 0
         self.deltatmax = 0
         self.h = 0
-        self.next_pc = 0.1
+        self.last_pc = 0.0
         self.Teye = None
         self.qg = np.array([])
 
diff --git a/andes/shared.py b/andes/shared.py
index 6a0406e02..4d5a8d00a 100644
--- a/andes/shared.py
+++ b/andes/shared.py
@@ -28,7 +28,6 @@
 printing.options['width'] = -1
 
 from andes.utils.paths import get_dot_andes_path  # NOQA
-from andes.utils.texttable import Texttable  # NOQA
 
 # --- SYSTEM INFO ---
 NCPUS_PHYSICAL = psutil.cpu_count(logical=False)
@@ -44,7 +43,8 @@
 jac_names = ('fx', 'fy', 'gx', 'gy')
 jac_types = ('c', '')
 
-dilled_vars = ['f_args', 'g_args', 'j_args', 's_args',
+dilled_vars = ['f_args', 'g_args', 'j_args',
+               's_args', 'sns_args',
                'ia_args', 'ii_args', 'ij_args',
                'ijac', 'jjac', 'vjac', 'j_names',
                'init_seq']
@@ -111,3 +111,22 @@ def set_latex():
         return True
 
     return False
+
+
+def set_font(family='serif', size=12, style='normal', weight='normal'):
+    """
+    Sets the font for matplotlib.
+
+    Parameters
+    ----------
+    family : str
+        Font family.
+    size : int
+        Font size.
+    style : str
+        Font style.
+    weight : str
+        Font weight.
+    """
+
+    mpl.rc('font', family=family, size=size, style=style, weight=weight)
diff --git a/andes/system.py b/andes/system.py
index 0670094e8..97b5d7c3b 100644
--- a/andes/system.py
+++ b/andes/system.py
@@ -2,7 +2,7 @@
 System class for power system data and methods
 """
 
-#  [ANDES] (C)2015-2021 Hantao Cui
+#  [ANDES] (C)2015-2022 Hantao Cui
 #
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -18,7 +18,7 @@
 import os
 import sys
 import time
-from collections import OrderedDict
+from collections import OrderedDict, defaultdict
 from typing import Dict, Optional, Tuple, Union
 
 import dill
@@ -29,11 +29,11 @@
 from andes.models import file_classes
 from andes.models.group import GroupBase
 from andes.routines import all_routines
-from andes.shared import (NCPUS_PHYSICAL, Pool, Process, dilled_vars, jac_names, matrix, np,
-                          sparse, spmatrix,)
+from andes.shared import (NCPUS_PHYSICAL, Pool, Process, dilled_vars,
+                          jac_names, matrix, np, sparse, spmatrix)
 from andes.utils.misc import elapsed
 from andes.utils.paths import (andes_root, confirm_overwrite, get_config_path,
-                               get_pkl_path, get_pycode_path,)
+                               get_pkl_path, get_pycode_path)
 from andes.utils.tab import Tab
 from andes.variables import DAE, FileMan
 
@@ -144,6 +144,7 @@ def __init__(self,
                                      ('numba_parallel', 0),
                                      ('numba_nopython', 0),
                                      ('yapf_pycode', 0),
+                                     ('call_stats', 0),
                                      ('np_divide', 'warn'),
                                      ('np_invalid', 'warn'),
                                      ('pickle_path', get_pkl_path())
@@ -160,6 +161,7 @@ def __init__(self,
                               numba_parallel='enable parallel for numba.jit',
                               numba_nopython='nopython mode for numba',
                               yapf_pycode='format generated code with yapf',
+                              call_stats='store statistics of function calls',
                               np_divide='treatment for division by zero',
                               np_invalid='treatment for invalid floating-point ops.',
                               pickle_path='path models should be (un)dilled to/from',
@@ -175,6 +177,7 @@ def __init__(self,
                               numba_parallel=(0, 1),
                               numba_nopython=(0, 1),
                               yapf_pycode=(0, 1),
+                              call_stats=(0, 1),
                               np_divide={'ignore', 'warn', 'raise', 'call', 'print', 'log'},
                               np_invalid={'ignore', 'warn', 'raise', 'call', 'print', 'log'},
                               )
@@ -198,6 +201,7 @@ def __init__(self,
         self._setters = dict(f=list(), g=list(), x=list(), y=list())
         self.antiwindups = list()
         self.no_check_init = list()  # states for which initialization check is omitted
+        self.call_stats = defaultdict(dict)  # call statistics storage
 
         # internal flags
         self.is_setup = False        # if system has been setup
@@ -371,11 +375,11 @@ def _mp_prepare(self, models, quick, pycode_path, ncpu):
         model_names = list(models.keys())
         model_list = list()
 
-        for file, cls_list in file_classes.items():
+        for fname, cls_list in file_classes:
             for model_name in cls_list:
                 if model_name not in model_names:
                     continue
-                the_module = importlib.import_module('andes.models.' + file)
+                the_module = importlib.import_module('andes.models.' + fname)
                 the_class = getattr(the_module, model_name)
                 model_list.append(the_class(system=None, config=self._config_object))
 
@@ -558,6 +562,8 @@ def set_address(self, models):
         """
         Set addresses for differential and algebraic variables.
         """
+
+        # --- Phase 1: set internal variable addresses ---
         for mdl in models.values():
             if mdl.flags.address is True:
                 logger.debug('%s internal address exists', mdl.class_name)
@@ -565,33 +571,32 @@ def set_address(self, models):
             if mdl.n == 0:
                 continue
 
-            # set internal variable addresses
             logger.debug('Setting internal address for %s', mdl.class_name)
-            n = mdl.n
-            m0 = self.dae.m
-            n0 = self.dae.n
-            m_end = m0 + len(mdl.algebs) * n
-            n_end = n0 + len(mdl.states) * n
-            collate = mdl.flags.collate
-
-            if not collate:
-                for idx, item in enumerate(mdl.algebs.values()):
-                    item.set_address(np.arange(m0 + idx * n, m0 + (idx + 1) * n), contiguous=True)
-                for idx, item in enumerate(mdl.states.values()):
-                    item.set_address(np.arange(n0 + idx * n, n0 + (idx + 1) * n), contiguous=True)
-            else:
-                for idx, item in enumerate(mdl.algebs.values()):
-                    item.set_address(np.arange(m0 + idx, m_end, len(mdl.algebs)), contiguous=False)
-                for idx, item in enumerate(mdl.states.values()):
-                    item.set_address(np.arange(n0 + idx, n_end, len(mdl.states)), contiguous=False)
-
-            self.dae.m = m_end
-            self.dae.n = n_end
 
-        # set external variable addresses
+            collate = mdl.flags.collate
+            ndevice = mdl.n
+
+            # get and set internal variable addresses
+            xaddr = self.dae.request_address('x', ndevice=ndevice,
+                                             nvar=len(mdl.states),
+                                             collate=mdl.flags.collate,
+                                             )
+            yaddr = self.dae.request_address('y', ndevice=ndevice,
+                                             nvar=len(mdl.algebs),
+                                             collate=mdl.flags.collate,
+                                             )
+
+            for idx, item in enumerate(mdl.states.values()):
+                item.set_address(xaddr[idx], contiguous=not collate)
+            for idx, item in enumerate(mdl.algebs.values()):
+                item.set_address(yaddr[idx], contiguous=not collate)
+
+        # --- Phase 2: set external variable addresses ---
+        # NOTE: this step will retrieve the number of variables (item.n) for
+        # Phase 3.
         for mdl in models.values():
             # handle external groups
-            for name, instance in mdl.cache.vars_ext.items():
+            for instance in mdl.cache.vars_ext.values():
                 ext_name = instance.model
                 try:
                     ext_model = self.__dict__[ext_name]
@@ -605,7 +610,7 @@ def set_address(self, models):
                                  mdl.class_name, instance.name, instance.model,
                                  instance.indexer.name, repr(e))
 
-        # set external variable RHS addresses
+        #  --- Phase 3: set external variable RHS addresses ---
         for mdl in models.values():
             if mdl.flags.address is True:
                 logger.debug('%s RHS address exists', mdl.class_name)
@@ -1608,10 +1613,13 @@ def _expand_pycode(self, pycode_module):
 
             # services
             for instance in model.services.values():
-                if instance.v_str is not None:
+                if (instance.v_str is not None) and instance.sequential is True:
                     sv_name = f'{instance.name}_svc'
                     model.calls.s[instance.name] = pycode_model.__dict__[sv_name]
 
+            # services - non sequential
+            model.calls.sns = pycode_model.__dict__.get("sns_update")
+
             # load initialization; assignment
             for instance in model.cache.all_vars.values():
                 if instance.v_str is not None:
@@ -1693,6 +1701,12 @@ def call_models(self, method: str, models: OrderedDict, *args, **kwargs):
         for name, mdl in models.items():
             ret[name] = getattr(mdl, method)(*args, **kwargs)
 
+            if self.config.call_stats:
+                if method not in self.call_stats[name]:
+                    self.call_stats[name][method] = 1
+                else:
+                    self.call_stats[name][method] += 1
+
         return ret
 
     def _check_group_common(self):
@@ -1807,9 +1821,9 @@ def import_models(self):
 
         ``system.models['Bus']`` points the same instance as ``system.Bus``.
         """
-        for file, cls_list in file_classes.items():
+        for fname, cls_list in file_classes:
             for model_name in cls_list:
-                the_module = importlib.import_module('andes.models.' + file)
+                the_module = importlib.import_module('andes.models.' + fname)
                 the_class = getattr(the_module, model_name)
                 self.__dict__[model_name] = the_class(system=self, config=self._config_object)
                 self.models[model_name] = self.__dict__[model_name]
@@ -1949,8 +1963,8 @@ def _store_calls(self, models: OrderedDict):
 
     def _list2array(self):
         """
-        Helper function to call models' ``list2array`` method, which
-        usually performs memory preallocation.
+        Helper function to call models' ``list2array`` method, which usually
+        performs memory preallocation.
         """
         self.call_models('list2array', self.models)
 
@@ -1958,7 +1972,8 @@ def set_config(self, config=None):
         """
         Set configuration for the System object.
 
-        Config for models are routines are passed directly to their constructors.
+        Config for models are routines are passed directly to their
+        constructors.
         """
         if config is not None:
             # set config for system
@@ -1973,7 +1988,8 @@ def get_config(self):
         Returns
         -------
         dict
-            a dict containing the config from devices; class names are keys and configs in a dict are values.
+            a dict containing the config from devices; class names are keys and
+            configs in a dict are values.
         """
         config_dict = configparser.ConfigParser()
         config_dict[self.__class__.__name__] = self.config.as_dict()
@@ -1995,8 +2011,8 @@ def load_config(conf_path=None):
         Parameters
         ----------
         conf_path : None or str
-            Path to the config file. If is `None`, the function body
-            will not run.
+            Path to the config file. If is `None`, the function body will not
+            run.
 
         Returns
         -------
@@ -2012,20 +2028,22 @@ def load_config(conf_path=None):
 
     def save_config(self, file_path=None, overwrite=False):
         """
-        Save all system, model, and routine configurations to an rc-formatted file.
+        Save all system, model, and routine configurations to an rc-formatted
+        file.
 
         Parameters
         ----------
         file_path : str, optional
             path to the configuration file default to `~/andes/andes.rc`.
         overwrite : bool, optional
-            If file exists, True to overwrite without confirmation.
-            Otherwise prompt for confirmation.
+            If file exists, True to overwrite without confirmation. Otherwise
+            prompt for confirmation.
 
         Warnings
         --------
-        Saved config is loaded back and populated *at system instance creation time*.
-        Configs from the config file takes precedence over default config values.
+        Saved config is loaded back and populated *at system instance creation
+        time*. Configs from the config file takes precedence over default config
+        values.
         """
         if file_path is None:
             andes_path = os.path.join(os.path.expanduser('~'), '.andes')
@@ -2082,9 +2100,9 @@ def rst_ref(name, export):
 
     def as_dict(self, vin=False, skip_empty=True):
         """
-        Return system data as a dict where the keys are model names
-        and values are dicts. Each dict has parameter names as keys
-        and corresponding data in an array as values.
+        Return system data as a dict where the keys are model names and values
+        are dicts. Each dict has parameter names as keys and corresponding data
+        in an array as values.
 
         Returns
         -------
@@ -2104,8 +2122,8 @@ def fix_address(self):
         """
         Fixes addressing issues after loading a snapshot.
 
-        This function properly sets ``v`` and ``e`` of internal
-        variables as views of the corresponding DAE arrays.
+        This function properly sets ``v`` and ``e`` of internal variables as
+        views of the corresponding DAE arrays.
 
         Inputs will be refreshed for each model.
         """
diff --git a/andes/core/npfunc.py b/andes/thirdparty/npfunc.py
similarity index 100%
rename from andes/core/npfunc.py
rename to andes/thirdparty/npfunc.py
diff --git a/andes/utils/paths.py b/andes/utils/paths.py
index a2b6719b3..fdc9bbe98 100644
--- a/andes/utils/paths.py
+++ b/andes/utils/paths.py
@@ -231,10 +231,7 @@ def get_log_dir():
     str
         The path to the temporary logging directory
     """
-    tempdir = os.path.join(tempfile.gettempdir(), 'andes')
-    if not os.path.exists(tempdir):
-        os.mkdir(tempdir)
-
+    tempdir = tempfile.gettempdir()
     path = tempfile.mkdtemp(prefix='andes-', dir=tempdir)
     return path
 
diff --git a/andes/utils/snapshot.py b/andes/utils/snapshot.py
index c295997fe..8a0e8a17a 100644
--- a/andes/utils/snapshot.py
+++ b/andes/utils/snapshot.py
@@ -1,5 +1,34 @@
 """
 Utility functions for saving and loading snapshots.
+
+Code Examples:
+
+1. Setup base case and save the snapshot for once:
+
+.. code:: python
+
+    import andes
+
+    ss = andes.run(andes.get_case("ieee14/ieee14_linetrip.xlsx"))
+    ss.Toggler.u.v[:] = 0  # turn off line trips for the base case
+    xy = ss.TDS.init()
+
+    andes.utils.snapshot.save_ss("ieee14_snapshot.pkl", ss)
+
+2.  For every scenario afterwards, load the snapshot and apply
+disturbances:
+
+.. code:: python
+
+    import andes
+
+    ss = andes.utils.snapshot.load_ss("ieee14_snapshot.pkl")
+
+    # apply specific disturbances
+    ss.GENROU.omega.v[0] = 1.02
+
+    ss.TDS.run()
+
 """
 
 import dill
@@ -32,6 +61,16 @@ def save_ss(path, system):
 def load_ss(path):
     """
     Load an ANDES snapshot and return a System object.
+
+    Parameters
+    ----------
+    path : str
+        Path to the snapshot file.
+
+    Returns
+    -------
+    andes.system.System
+        The loaded system object
     """
 
     # the line below is needed to properly import `pycode`.
diff --git a/andes/utils/tab.py b/andes/utils/tab.py
index fd2a20ea3..07f915114 100644
--- a/andes/utils/tab.py
+++ b/andes/utils/tab.py
@@ -1,4 +1,8 @@
-from andes.shared import Texttable
+"""
+Module for drawing tables based on texttable.
+"""
+
+from texttable import Texttable
 
 
 class Tab(Texttable):
diff --git a/andes/utils/texttable.py b/andes/utils/texttable.py
deleted file mode 100644
index f3765c58e..000000000
--- a/andes/utils/texttable.py
+++ /dev/null
@@ -1,693 +0,0 @@
-# texttable - module for creating simple ASCII tables
-# Copyright (C) 2003-2020 Gerome Fournier <jef(at)foutaise.org>
-
-"""module for creating simple ASCII tables
-"""
-
-from __future__ import division
-
-__all__ = ["Texttable", "ArraySizeError"]
-
-__author__ = 'Gerome Fournier <jef(at)foutaise.org>'
-__license__ = 'MIT'
-__version__ = '1.6.3'
-__credits__ = """\
-Jeff Kowalczyk:
-    - textwrap improved import
-    - comment concerning header output
-
-Anonymous:
-    - add_rows method, for adding rows in one go
-
-Sergey Simonenko:
-    - redefined len() function to deal with non-ASCII characters
-
-Roger Lew:
-    - columns datatype specifications
-
-Brian Peterson:
-    - better handling of unicode errors
-
-Frank Sachsenheim:
-    - add Python 2/3-compatibility
-
-Maximilian Hils:
-    - fix minor bug for Python 3 compatibility
-
-frinkelpi:
-    - preserve empty lines
-"""
-
-import sys
-import unicodedata
-
-# define a text wrapping function to wrap some text
-# to a specific width:
-# - use cjkwrap if available (better CJK support)
-# - fallback to textwrap otherwise
-try:
-    import cjkwrap
-
-    def textwrapper(txt, width):
-        return cjkwrap.wrap(txt, width)
-except ImportError:
-    try:
-        import textwrap
-
-        def textwrapper(txt, width):
-            return textwrap.wrap(txt, width)
-    except ImportError:
-        sys.stderr.write("Can't import textwrap module!\n")
-        raise
-
-# define a function to calculate the rendering width of a unicode character
-# - use wcwidth if available
-# - fallback to unicodedata information otherwise
-try:
-    import wcwidth
-
-    def uchar_width(c):
-        """Return the rendering width of a unicode character
-        """
-        return max(0, wcwidth.wcwidth(c))
-except ImportError:
-    def uchar_width(c):
-        """Return the rendering width of a unicode character
-        """
-        if unicodedata.east_asian_width(c) in 'WF':
-            return 2
-        elif unicodedata.combining(c):
-            return 0
-        else:
-            return 1
-
-from functools import reduce
-
-if sys.version_info >= (3, 0):
-    unicode_type = str
-    bytes_type = bytes
-else:
-    unicode_type = unicode
-    bytes_type = str
-
-
-def obj2unicode(obj):
-    """Return a unicode representation of a python object
-    """
-    if isinstance(obj, unicode_type):
-        return obj
-    elif isinstance(obj, bytes_type):
-        try:
-            return unicode_type(obj, 'utf-8')
-        except UnicodeDecodeError as strerror:
-            sys.stderr.write("UnicodeDecodeError exception for string '%s': %s\n" % (obj, strerror))
-            return unicode_type(obj, 'utf-8', 'replace')
-    else:
-        return unicode_type(obj)
-
-
-def len(iterable):
-    """Redefining len here so it will be able to work with non-ASCII characters
-    """
-    if isinstance(iterable, bytes_type) or isinstance(iterable, unicode_type):
-        return sum([uchar_width(c) for c in obj2unicode(iterable)])
-    else:
-        return iterable.__len__()
-
-
-class ArraySizeError(Exception):
-    """Exception raised when specified rows don't fit the required size
-    """
-
-    def __init__(self, msg):
-        self.msg = msg
-        Exception.__init__(self, msg, '')
-
-    def __str__(self):
-        return self.msg
-
-
-class FallbackToText(Exception):
-    """Used for failed conversion to float"""
-    pass
-
-
-class Texttable:
-
-    BORDER = 1
-    HEADER = 1 << 1
-    HLINES = 1 << 2
-    VLINES = 1 << 3
-
-    def __init__(self, max_width=80):
-        """Constructor
-
-        - max_width is an integer, specifying the maximum width of the table
-        - if set to 0, size is unlimited, therefore cells won't be wrapped
-        """
-
-        self.set_max_width(max_width)
-        self._precision = 3
-
-        self._deco = Texttable.VLINES | Texttable.HLINES | Texttable.BORDER | \
-            Texttable.HEADER
-        self.set_chars(['-', '|', '+', '='])
-        self.reset()
-
-    def reset(self):
-        """Reset the instance
-
-        - reset rows and header
-        """
-
-        self._hline_string = None
-        self._row_size = None
-        self._header = []
-        self._rows = []
-        return self
-
-    def set_max_width(self, max_width):
-        """Set the maximum width of the table
-
-        - max_width is an integer, specifying the maximum width of the table
-        - if set to 0, size is unlimited, therefore cells won't be wrapped
-        """
-        self._max_width = max_width if max_width > 0 else False
-        return self
-
-    def set_chars(self, array):
-        """Set the characters used to draw lines between rows and columns
-
-        - the array should contain 4 fields:
-
-            [horizontal, vertical, corner, header]
-
-        - default is set to:
-
-            ['-', '|', '+', '=']
-        """
-
-        if len(array) != 4:
-            raise ArraySizeError("array should contain 4 characters")
-        array = [x[:1] for x in [str(s) for s in array]]
-        (self._char_horiz, self._char_vert,
-            self._char_corner, self._char_header) = array
-        return self
-
-    def set_deco(self, deco):
-        """Set the table decoration
-
-        - 'deco' can be a combinaison of:
-
-            Texttable.BORDER: Border around the table
-            Texttable.HEADER: Horizontal line below the header
-            Texttable.HLINES: Horizontal lines between rows
-            Texttable.VLINES: Vertical lines between columns
-
-           All of them are enabled by default
-
-        - example:
-
-            Texttable.BORDER | Texttable.HEADER
-        """
-
-        self._deco = deco
-        return self
-
-    def set_header_align(self, array):
-        """Set the desired header alignment
-
-        - the elements of the array should be either "l", "c" or "r":
-
-            * "l": column flushed left
-            * "c": column centered
-            * "r": column flushed right
-        """
-
-        self._check_row_size(array)
-        self._header_align = array
-        return self
-
-    def set_cols_align(self, array):
-        """Set the desired columns alignment
-
-        - the elements of the array should be either "l", "c" or "r":
-
-            * "l": column flushed left
-            * "c": column centered
-            * "r": column flushed right
-        """
-
-        self._check_row_size(array)
-        self._align = array
-        return self
-
-    def set_cols_valign(self, array):
-        """Set the desired columns vertical alignment
-
-        - the elements of the array should be either "t", "m" or "b":
-
-            * "t": column aligned on the top of the cell
-            * "m": column aligned on the middle of the cell
-            * "b": column aligned on the bottom of the cell
-        """
-
-        self._check_row_size(array)
-        self._valign = array
-        return self
-
-    def set_cols_dtype(self, array):
-        """Set the desired columns datatype for the cols.
-
-        - the elements of the array should be either a callable or any of
-          "a", "t", "f", "e" or "i":
-
-            * "a": automatic (try to use the most appropriate datatype)
-            * "t": treat as text
-            * "f": treat as float in decimal format
-            * "e": treat as float in exponential format
-            * "i": treat as int
-            * a callable: should return formatted string for any value given
-
-        - by default, automatic datatyping is used for each column
-        """
-
-        self._check_row_size(array)
-        self._dtype = array
-        return self
-
-    def set_cols_width(self, array):
-        """Set the desired columns width
-
-        - the elements of the array should be integers, specifying the
-          width of each column. For example:
-
-                [10, 20, 5]
-        """
-
-        self._check_row_size(array)
-        try:
-            array = list(map(int, array))
-            if reduce(min, array) <= 0:
-                raise ValueError
-        except ValueError:
-            sys.stderr.write("Wrong argument in column width specification\n")
-            raise
-        self._width = array
-        return self
-
-    def set_precision(self, width):
-        """Set the desired precision for float/exponential formats
-
-        - width must be an integer >= 0
-
-        - default value is set to 3
-        """
-
-        if not type(width) is int or width < 0:
-            raise ValueError('width must be an integer greater then 0')
-        self._precision = width
-        return self
-
-    def header(self, array):
-        """Specify the header of the table
-        """
-
-        self._check_row_size(array)
-        self._header = list(map(obj2unicode, array))
-        return self
-
-    def add_row(self, array):
-        """Add a row in the rows stack
-
-        - cells can contain newlines and tabs
-        """
-
-        self._check_row_size(array)
-
-        if not hasattr(self, "_dtype"):
-            self._dtype = ["a"] * self._row_size
-
-        cells = []
-        for i, x in enumerate(array):
-            cells.append(self._str(i, x))
-        self._rows.append(cells)
-        return self
-
-    def add_rows(self, rows, header=True):
-        """Add several rows in the rows stack
-
-        - The 'rows' argument can be either an iterator returning arrays,
-          or a by-dimensional array
-        - 'header' specifies if the first row should be used as the header
-          of the table
-        """
-
-        # nb: don't use 'iter' on by-dimensional arrays, to get a
-        #     usable code for python 2.1
-        if header:
-            if hasattr(rows, '__iter__') and hasattr(rows, 'next'):
-                self.header(rows.next())
-            else:
-                self.header(rows[0])
-                rows = rows[1:]
-        for row in rows:
-            self.add_row(row)
-        return self
-
-    def draw(self):
-        """Draw the table
-
-        - the table is returned as a whole string
-        """
-
-        if not self._header and not self._rows:
-            return
-        self._compute_cols_width()
-        self._check_align()
-        out = ""
-        if self._has_border():
-            out += self._hline()
-        if self._header:
-            out += self._draw_line(self._header, isheader=True)
-            if self._has_header():
-                out += self._hline_header()
-        length = 0
-        for row in self._rows:
-            length += 1
-            out += self._draw_line(row)
-            if self._has_hlines() and length < len(self._rows):
-                out += self._hline()
-        if self._has_border():
-            out += self._hline()
-        return out[:-1]
-
-    @classmethod
-    def _to_float(cls, x):
-        if x is None:
-            raise FallbackToText()
-        try:
-            return float(x)
-        except (TypeError, ValueError):
-            raise FallbackToText()
-
-    @classmethod
-    def _fmt_int(cls, x, **kw):
-        """Integer formatting class-method.
-        """
-        if type(x) == int:
-            return str(x)
-        else:
-            return str(int(round(cls._to_float(x))))
-
-    @classmethod
-    def _fmt_float(cls, x, **kw):
-        """Float formatting class-method.
-
-        - x parameter is ignored. Instead kw-argument f being x float-converted
-          will be used.
-
-        - precision will be taken from `n` kw-argument.
-        """
-        n = kw.get('n')
-        return '%.*f' % (n, cls._to_float(x))
-
-    @classmethod
-    def _fmt_exp(cls, x, **kw):
-        """Exponential formatting class-method.
-
-        - x parameter is ignored. Instead kw-argument f being x float-converted
-          will be used.
-
-        - precision will be taken from `n` kw-argument.
-        """
-        n = kw.get('n')
-        return '%.*e' % (n, cls._to_float(x))
-
-    @classmethod
-    def _fmt_text(cls, x, **kw):
-        """String formatting class-method."""
-        return obj2unicode(x)
-
-    @classmethod
-    def _fmt_auto(cls, x, **kw):
-        """auto formatting class-method."""
-        f = cls._to_float(x)
-        if abs(f) > 1e8:
-            fn = cls._fmt_exp
-        elif f != f:  # NaN
-            fn = cls._fmt_text
-        elif f - round(f) == 0:
-            fn = cls._fmt_int
-        else:
-            fn = cls._fmt_float
-        return fn(x, **kw)
-
-    def _str(self, i, x):
-        """Handles string formatting of cell data
-
-            i - index of the cell datatype in self._dtype
-            x - cell data to format
-        """
-        FMT = {
-            'a': self._fmt_auto,
-            'i': self._fmt_int,
-            'f': self._fmt_float,
-            'e': self._fmt_exp,
-            't': self._fmt_text,
-        }
-
-        n = self._precision
-        dtype = self._dtype[i]
-        try:
-            if callable(dtype):
-                return dtype(x)
-            else:
-                return FMT[dtype](x, n=n)
-        except FallbackToText:
-            return self._fmt_text(x)
-
-    def _check_row_size(self, array):
-        """Check that the specified array fits the previous rows size
-        """
-
-        if not self._row_size:
-            self._row_size = len(array)
-        elif self._row_size != len(array):
-            raise ArraySizeError("array should contain %d elements"
-                                 % self._row_size)
-
-    def _has_vlines(self):
-        """Return a boolean, if vlines are required or not
-        """
-
-        return self._deco & Texttable.VLINES > 0
-
-    def _has_hlines(self):
-        """Return a boolean, if hlines are required or not
-        """
-
-        return self._deco & Texttable.HLINES > 0
-
-    def _has_border(self):
-        """Return a boolean, if border is required or not
-        """
-
-        return self._deco & Texttable.BORDER > 0
-
-    def _has_header(self):
-        """Return a boolean, if header line is required or not
-        """
-
-        return self._deco & Texttable.HEADER > 0
-
-    def _hline_header(self):
-        """Print header's horizontal line
-        """
-
-        return self._build_hline(True)
-
-    def _hline(self):
-        """Print an horizontal line
-        """
-
-        if not self._hline_string:
-            self._hline_string = self._build_hline()
-        return self._hline_string
-
-    def _build_hline(self, is_header=False):
-        """Return a string used to separated rows or separate header from
-        rows
-        """
-        horiz = self._char_horiz
-        if (is_header):
-            horiz = self._char_header
-        # compute cell separator
-        s = "%s%s%s" % (horiz, [horiz, self._char_corner][self._has_vlines()],
-                        horiz)
-        # build the line
-        l = s.join([horiz * n for n in self._width])
-        # add border if needed
-        if self._has_border():
-            l = "%s%s%s%s%s\n" % (self._char_corner, horiz, l, horiz,
-                                  self._char_corner)
-        else:
-            l += "\n"
-        return l
-
-    def _len_cell(self, cell):
-        """Return the width of the cell
-
-        Special characters are taken into account to return the width of the
-        cell, such like newlines and tabs
-        """
-
-        cell_lines = cell.split('\n')
-        maxi = 0
-        for line in cell_lines:
-            length = 0
-            parts = line.split('\t')
-            for part, i in zip(parts, list(range(1, len(parts) + 1))):
-                length = length + len(part)
-                if i < len(parts):
-                    length = (length//8 + 1) * 8
-            maxi = max(maxi, length)
-        return maxi
-
-    def _compute_cols_width(self):
-        """Return an array with the width of each column
-
-        If a specific width has been specified, exit. If the total of the
-        columns width exceed the table desired width, another width will be
-        computed to fit, and cells will be wrapped.
-        """
-
-        if hasattr(self, "_width"):
-            return
-        maxi = []
-        if self._header:
-            maxi = [self._len_cell(x) for x in self._header]
-        for row in self._rows:
-            for cell, i in zip(row, list(range(len(row)))):
-                try:
-                    maxi[i] = max(maxi[i], self._len_cell(cell))
-                except (TypeError, IndexError):
-                    maxi.append(self._len_cell(cell))
-
-        ncols = len(maxi)
-        content_width = sum(maxi)
-        deco_width = 3*(ncols-1) + [0, 4][self._has_border()]
-        if self._max_width and (content_width + deco_width) > self._max_width:
-            """ content too wide to fit the expected max_width
-            let's recompute maximum cell width for each cell
-            """
-            if self._max_width < (ncols + deco_width):
-                raise ValueError('max_width too low to render data')
-            available_width = self._max_width - deco_width
-            newmaxi = [0] * ncols
-            i = 0
-            while available_width > 0:
-                if newmaxi[i] < maxi[i]:
-                    newmaxi[i] += 1
-                    available_width -= 1
-                i = (i + 1) % ncols
-            maxi = newmaxi
-        self._width = maxi
-
-    def _check_align(self):
-        """Check if alignment has been specified, set default one if not
-        """
-
-        if not hasattr(self, "_header_align"):
-            self._header_align = ["c"] * self._row_size
-        if not hasattr(self, "_align"):
-            self._align = ["l"] * self._row_size
-        if not hasattr(self, "_valign"):
-            self._valign = ["t"] * self._row_size
-
-    def _draw_line(self, line, isheader=False):
-        """Draw a line
-
-        Loop over a single cell length, over all the cells
-        """
-
-        line = self._splitit(line, isheader)
-        space = " "
-        out = ""
-        for i in range(len(line[0])):
-            if self._has_border():
-                out += "%s " % self._char_vert
-            length = 0
-            for cell, width, align in zip(line, self._width, self._align):
-                length += 1
-                cell_line = cell[i]
-                fill = width - len(cell_line)
-                if isheader:
-                    align = self._header_align[length - 1]
-                if align == "r":
-                    out += fill * space + cell_line
-                elif align == "c":
-                    out += (int(fill/2) * space + cell_line
-                            + int(fill/2 + fill % 2) * space)
-                else:
-                    out += cell_line + fill * space
-                if length < len(line):
-                    out += " %s " % [space, self._char_vert][self._has_vlines()]
-            out += "%s\n" % ['', space + self._char_vert][self._has_border()]
-        return out
-
-    def _splitit(self, line, isheader):
-        """Split each element of line to fit the column width
-
-        Each element is turned into a list, result of the wrapping of the
-        string to the desired width
-        """
-
-        line_wrapped = []
-        for cell, width in zip(line, self._width):
-            array = []
-            for c in cell.split('\n'):
-                if c.strip() == "":
-                    array.append("")
-                else:
-                    array.extend(textwrapper(c, width))
-            line_wrapped.append(array)
-        max_cell_lines = reduce(max, list(map(len, line_wrapped)))
-        for cell, valign in zip(line_wrapped, self._valign):
-            if isheader:
-                valign = "t"
-            if valign == "m":
-                missing = max_cell_lines - len(cell)
-                cell[:0] = [""] * int(missing / 2)
-                cell.extend([""] * int(missing / 2 + missing % 2))
-            elif valign == "b":
-                cell[:0] = [""] * (max_cell_lines - len(cell))
-            else:
-                cell.extend([""] * (max_cell_lines - len(cell)))
-        return line_wrapped
-
-
-if __name__ == '__main__':
-    table = Texttable()
-    table.set_cols_align(["l", "r", "c"])
-    table.set_cols_valign(["t", "m", "b"])
-    table.add_rows([["Name", "Age", "Nickname"],
-                    ["Mr\nXavier\nHuon", 32, "Xav'"],
-                    ["Mr\nBaptiste\nClement", 1, "Baby"],
-                    ["Mme\nLouise\nBourgeau", 28, "Lou\n \nLoue"]])
-    print(table.draw() + "\n")
-
-    table = Texttable()
-    table.set_deco(Texttable.HEADER)
-    table.set_cols_dtype(['t',  # text
-                          'f',  # float (decimal)
-                          'e',  # float (exponent)
-                          'i',  # integer
-                          'a'])  # automatic
-    table.set_cols_align(["l", "r", "r", "r", "l"])
-    table.add_rows([["text",    "float", "exp", "int", "auto"],
-                    ["abcd",    "67",    654,   89,    128.001],
-                    ["efghijk", 67.5434, .654,  89.6,  12800000000000000000000.00023],
-                    ["lmn",     5e-78,   5e-78, 89.4,  .000000000000128],
-                    ["opqrstu", .023,    5e+78, 92.,   12800000000000000000000]])
-    print(table.draw())
diff --git a/andes/variables/dae.py b/andes/variables/dae.py
index 967b61cc6..14757e2dd 100644
--- a/andes/variables/dae.py
+++ b/andes/variables/dae.py
@@ -5,7 +5,7 @@
 import numpy as np
 
 from andes.core import JacTriplet
-from andes.core.var import BaseVar
+from andes.core.var import BaseVar, ExtVar
 from andes.shared import jac_names, pd, spmatrix
 
 logger = logging.getLogger(__name__)
@@ -101,20 +101,23 @@ def unpack_df(self):
 
         return True
 
-    def get_data(self, base_vars: Union[BaseVar, List[BaseVar]], a=None):
+    def get_data(self, base_vars: Union[BaseVar, List[BaseVar]], *,
+                 a=None, rhs: bool = False,):
         """
-        Get time-series data for a variable instance.
+        Get time-series data, either for a variable or for the equation
+        associated with the variable.
 
-        Values for different variables will be stacked horizontally.
+        Each row correspond to a timestamp. Values for different variables will
+        be appended horizontally.
 
         Parameters
         ----------
         base_var : BaseVar or a sequence of BaseVar(s)
-            The variable types and internal addresses
-            are used for looking up the data.
+            The variable types and internal addresses are used for looking up
+            the data.
         a : an array/list of int or None
-            Sub-indices into the address of `base_var`.
-            Applied to each variable.
+            Sub-indices into the address of `base_var`. Applied to each
+            variable.
 
         """
         out = np.zeros((len(self.t), 0))
@@ -127,14 +130,47 @@ def get_data(self, base_vars: Union[BaseVar, List[BaseVar]], a=None):
                             base_var.owner.class_name, base_var.name)
                 continue
 
-            indices = base_var.a
-            if a is not None:
-                indices = indices[a]
+            if rhs is True and (base_var.e_code == 'g') and \
+                    not isinstance(base_var, ExtVar):
+                logger.warning("RHS of an internal algebraic variable <%s.%s> is always zero. Ignored",
+                               base_var.owner.class_name, base_var.name)
+                continue
 
-            out = np.hstack((out, self.__dict__[base_var.v_code][:, indices]))
+            if rhs is False:
+                indices = base_var.a
+                array_code = base_var.v_code
+            else:
+                if isinstance(base_var, ExtVar):
+                    # external algebraic variables
+                    indices = base_var.r
+                    array_code = base_var.r_code
+                else:
+                    # internal differential variables
+                    indices = base_var.a
+                    array_code = base_var.e_code
+
+            indices = indices[a] if a is not None else indices
+            out = np.hstack((out, self._access_array(array_code, indices)))
 
         return out
 
+    def _access_array(self, array_name, indices=None):
+        """
+        Helper function to access an existing array in TimeSeries.
+
+        The function checks for empty arrays and shows warnings.
+        """
+        if np.count_nonzero(self.__dict__[array_name]) == 0:
+            logger.error("TimeSeries matrix <%s> contains no element. Check if `[TDS] store_%s = 1`",
+                         array_name, array_name)
+
+            return None
+
+        if indices is None:
+            return self.__dict__[array_name][:, :]
+        else:
+            return self.__dict__[array_name][:, indices]
+
     @property
     def df(self):
         return self.df_xy
@@ -205,11 +241,20 @@ class DAE:
 
     def __init__(self, system):
         self.system = system
-        self.t = np.array(0, dtype=float)
+        self.t = np.array(0.0, dtype=float)
         self.ts = DAETimeSeries(self)
 
-        self.m, self.n, self.o = 0, 0, 0
-        self.p, self.q = 0, 0
+        self._array_and_counter = {
+            'f': 'n',  # differential equation RHS
+            'x': 'n',  # differential variables
+            'g': 'm',  # algebraic equation residual
+            'y': 'm',  # algebraic variables
+            'z': 'o',  # limiter flags
+            'h': 'p',  # RHS of external states
+            'i': 'q',  # RHS of external algebraic variables
+            }
+
+        self.m, self.n, self.o, self.p, self.q = 0, 0, 0, 0, 0
 
         self.x, self.y, self.z = np.array([]), np.array([]), np.array([])
         self.f, self.g = np.array([]), np.array([])  # RHS of equations
@@ -222,17 +267,40 @@ def __init__(self, system):
         self.gx, self.gy = None, None
         self.rx, self.tx = None, None
 
-        self.h_name, self.h_tex_name = [], []
-        self.i_name, self.i_tex_name = [], []
         self.x_name, self.x_tex_name = [], []
         self.y_name, self.y_tex_name = [], []
         self.z_name, self.z_tex_name = [], []
+        self.h_name, self.h_tex_name = [], []
+        self.i_name, self.i_tex_name = [], []
 
         self.triplets = JacTriplet()
 
         self.tpl = dict()  # sparsity templates with constants
 
+    def request_address(self, array_name: str, ndevice, nvar, collate=False):
+
+        out = []
+        counter_name = self._array_and_counter[array_name]
+
+        idx_begin = self.__dict__[counter_name]
+        idx_end = idx_begin + ndevice * nvar
+
+        if not collate:
+            for idx in range(nvar):
+                out.append(np.arange(idx_begin + idx * ndevice, idx_begin + (idx + 1) * ndevice))
+        else:
+            for idx in range(nvar):
+                out.append(np.arange(idx_begin + idx, idx_end, nvar))
+
+        self.__dict__[counter_name] = idx_end
+
+        return out
+
     def clear_ts(self):
+        """
+        Drop the TimeSeries data and create a new one.
+        """
+
         self.ts = DAETimeSeries(self)
 
     def clear_arrays(self):
@@ -303,7 +371,10 @@ def reset(self):
         self.clear_ts()
 
     def set_t(self, t):
-        """Helper function for setting time in-place"""
+        """
+        Helper function for setting time in-place.
+        """
+
         self.t.itemset(t)
 
     def get_size(self, name):
@@ -322,9 +393,9 @@ def get_size(self, name):
         """
         ret = []
         for char in name:
-            if char in ('f', 'x', 't'):
+            if char in ('f', 'x'):
                 ret.append(self.n)
-            elif char in ('g', 'y', 'r'):
+            elif char in ('g', 'y'):
                 ret.append(self.m)
             elif char == 'z':
                 ret.append(self.o)
diff --git a/andes/variables/report.py b/andes/variables/report.py
index 217a41385..d526240ee 100644
--- a/andes/variables/report.py
+++ b/andes/variables/report.py
@@ -14,7 +14,7 @@
 def report_info(system):
     info = list()
     info.append('ANDES' + ' ' + version + '\n')
-    info.append('Copyright (C) 2015-2021 Hantao Cui\n\n')
+    info.append('Copyright (C) 2015-2022 Hantao Cui\n\n')
     info.append('ANDES comes with ABSOLUTELY NO WARRANTY\n')
     info.append('Case file: ' + str(system.files.case) + '\n')
     info.append('Report time: ' + strftime("%m/%d/%Y %I:%M:%S %p") + '\n\n')
diff --git a/codecov.yml b/codecov.yml
index 12a78bc03..92842c6ce 100644
--- a/codecov.yml
+++ b/codecov.yml
@@ -3,5 +3,4 @@ codecov:
 
 ignore:
   - "andes/_version.py"
-  - "andes/utils/texttable.py"
   - "andes/utils/lazyimport.py"
diff --git a/docs/source/api.rst b/docs/source/api.rst
index bbee3d76f..3f6bae091 100644
--- a/docs/source/api.rst
+++ b/docs/source/api.rst
@@ -10,9 +10,10 @@ System
 
 .. autosummary::
    :maxdepth:4
-   :toctree: _generated
    :recursive:
+   :toctree: _generated
    :caption: System
+   :template: autosummary/module_toctree.rst
 
    andes.system
    andes.variables
diff --git a/docs/source/modeling/examples.rst b/docs/source/modeling/examples.rst
index b4eb78e47..1b6576c67 100644
--- a/docs/source/modeling/examples.rst
+++ b/docs/source/modeling/examples.rst
@@ -384,14 +384,13 @@ Assemble ``IEEESTData`` and ``IEEESTModel`` into ``IEEEST``:
             IEEESTData.__init__(self)
             IEEESTModel.__init__(self, system, config)
 
-Locate ``andes/models/__init__.py``, in ``file_classes``,
-find the key ``pss`` and add ``IEEEST`` to its value list.
-In ``file_classes``, keys are the ``.py`` file names under the folder ``models``,
-and values are class names to be imported from that file.
-If the file name does not exist as a key in ``file_classes``,
-add it after all prerequisite models.
-For example, PSS should be added after exciters (and generators,
-of course).
+Locate ``andes/models/__init__.py``, in ``file_classes``. In ``file_classes``,
+the first element of each sublist is the ``.py`` file names in ``models``
+folder, and the second element contains class names to be imported from that
+file. Find the line with ``pss`` and add ``IEEEST`` to the corresponding list of
+model names. If the file name does not exist in any element of ``file_classes``,
+add it after all prerequisite models. For example, PSS should be added after
+exciters (and generators, of course).
 
 Finally, locate ``andes/models/group.py``, check if the class
 with ``PSS`` exist.
diff --git a/docs/source/modeling/models.rst b/docs/source/modeling/models.rst
index 13acab368..a288b274f 100644
--- a/docs/source/modeling/models.rst
+++ b/docs/source/modeling/models.rst
@@ -115,7 +115,7 @@ Equation Generation
 equation generation is a multi-step process with symbol preparation, equation generation, Jacobian generation,
 initializer generation, and pretty print generation.
 
-.. autoclass:: andes.core.model.SymProcessor
+.. autoclass:: andes.core.SymProcessor
     :members: generate_symbols, generate_equations, generate_jacobians, generate_init
     :noindex:
 
diff --git a/docs/source/release-notes.rst b/docs/source/release-notes.rst
index 25e231943..d156bd87e 100644
--- a/docs/source/release-notes.rst
+++ b/docs/source/release-notes.rst
@@ -9,10 +9,48 @@ The APIs before v3.0.0 are in beta and may change without prior notice.
 v1.6 Notes
 ==========
 
+v1.6.4 (2022-04-17)
+-------------------
+Breaking change:
+
+- ``PV`` model no longer has ``p`` as a variable in the DAE. ``p`` copies the
+  value of ``p0``. This change affects the addresses of variables.
+- Changed ``models.file_classes`` to a list to improve the control over
+  the class initialization sequence in the same package.
+
+Operator splitting for internal algebraic variables:
+
+- ``VarService`` can be evaluated model-internal algebraic variables outside the
+  DAE system. This approach is known as operator splitting and is commonly used
+  in other simulation tools.
+- Operator splitting reduces the size of the DAE system but introduces a
+  one-iteration lag between the internal algebraic variables and others in the
+  DAE system.
+- ``VarService`` shall be avoided for singular functions (non-continuous) and
+  shall not be adopted to circumvent initializing algebraic equations.
+- ``VarService`` takes an argument ``sequential``, which is ``True`` by default.
+  Non-sequential ``VarService`` shall not depend on other ``VarService``
+  calculated at the same step as they will be evaluated simultaneously.
+- :py:func:`andes.interop.pandapower.to_pandapower` set all generators as
+  controllable by default. Generators in converted the pandapower case are named
+  using the ``idx`` of ``StaticGen``.
+- Bug fixes in ``interop.pandapower.make_link_table()``.
+
+Other changes:
+
+- Added a new service type :py:class:`andes.core.service.SubsService` for
+  temporary symbols that will be substituted at code generation time.
+- ``TDS.plt.plot()`` now accepts a list of variable objects. For example,
+  ``ss.TDS.plt.plot([ss.GENROU.omega, ss.GENROU.delta], a=[0, 1])`` will plot
+  the rotor speed and angles of the 0-th and the 1-st generator.
+- Added :ref:`REGCP1` model for generic converters with PLL support.
+- Fixed PSS/E parser for :ref:`HYGOV`.
+
 v1.6.3 (2022-04-06)
 -------------------
-- Adjustments in the Pandapower interface. Added make generation shift factor.
-- Reduced import overhead for command-line tool.
+- Adjustments in the Pandapower interface. Added ``make_GSF()`` for the
+  generation shift factor matrix.
+- Reduced import overhead for the command-line tool.
 
 v1.6.2 (2022-03-27)
 -------------------
diff --git a/examples/demonstration/REGCP1.ipynb b/examples/demonstration/REGCP1.ipynb
new file mode 100755
index 000000000..97ce994cb
--- /dev/null
+++ b/examples/demonstration/REGCP1.ipynb
@@ -0,0 +1,463 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d9629a00-bb32-47bc-9368-dde575c55b93",
+   "metadata": {},
+   "source": [
+    "# REGCP1: Renewable generator model with PLL support"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bc3b5410-dae2-44bd-8ab8-47d58a2264c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import andes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b03cbe7b-d8e3-4bed-8898-4e3aa2ec08ae",
+   "metadata": {},
+   "source": [
+    "## Comparing `REGCA1` with `REGCP1` with a low-latency PLL"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "30955e0f-c45c-4e34-ad78-e0798744887b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-> Single process finished in 0.4668 seconds.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "eba049dcc2b94c85af34ea4577ac2df8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100 [00:00<?, ?%/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "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"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ss_std = andes.run(andes.get_case(\"ieee14/ieee14_solar.xlsx\"), verbose=30)\n",
+    "\n",
+    "ss_std.TDS.config.tf = 5\n",
+    "ss_std.TDS.run()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "0942ae67-837d-491a-b6d1-235bf1b8e49d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-> Single process finished in 0.1744 seconds.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d88489ce5ace49e49c35216163e49752",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100 [00:00<?, ?%/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "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"
+     ]
+    }
+   ],
+   "source": [
+    "ss_pll = andes.run(andes.get_case(\"ieee14/ieee14_regcp1.xlsx\"), \n",
+    "               verbose=30,\n",
+    "               no_output=True,)\n",
+    "\n",
+    "ss_pll.TDS.config.tf = 5\n",
+    "xy = ss_pll.TDS.run()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53a0311a-73c7-43f2-ab16-8774f91b2fd8",
+   "metadata": {},
+   "source": [
+    "### PLL angle tracking performance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0c4b5ee4-4337-4f3b-9f62-a169d34ff933",
+   "metadata": {},
+   "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": {
+      "text/plain": [
+       "(<Figure size 600x400 with 1 Axes>, <AxesSubplot:xlabel='Time [s]'>)"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ss_pll.TDS.plt.plot([ss_pll.PLL1.a, ss_pll.PLL1.am])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e954cf9b-ed37-475a-a23e-975a03473bee",
+   "metadata": {},
+   "source": [
+    "### Comparing power outputs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "dfe38ffb-f21b-421f-b9be-16c4b13b39dd",
+   "metadata": {},
+   "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": {
+      "text/plain": [
+       "(<Figure size 600x400 with 1 Axes>, <AxesSubplot:xlabel='Time [s]'>)"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "fig, ax = ss_std.TDS.plt.plot([ss_std.REGCA1.Pe], right=5,\n",
+    "                              show=False, yheader=['$P_e$ without PLL'])\n",
+    "\n",
+    "ss_pll.TDS.plt.plot(ss_pll.REGCP1.Pe, yheader=['$P_e$ with PLL'],\n",
+    "                    right=5, fig=fig, ax=ax,\n",
+    "                    autoscale=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "150251dd-53d1-4cab-8130-45b85fe28891",
+   "metadata": {},
+   "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"
+    }
+   ],
+   "source": [
+    "fig, ax = ss_std.TDS.plt.plot([ss_std.REGCA1.Qe], right=5,\n",
+    "                              show=False, yheader=['$Q_e$ without PLL'])\n",
+    "\n",
+    "fig, ax = ss_pll.TDS.plt.plot(ss_pll.REGCP1.Qe, yheader=['$Q_e$ with PLL'],\n",
+    "                    right=5, fig=fig, ax=ax,\n",
+    "                    autoscale=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "a1e503bc-3eb0-4e19-b1ba-e9431fa68910",
+   "metadata": {},
+   "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"
+    }
+   ],
+   "source": [
+    "fig, ax = ss_std.TDS.plt.plot([ss_std.REGCA1.v], right=5,\n",
+    "                              show=False, yheader=['$V$ Bus 8 without PLL'])\n",
+    "\n",
+    "fig, ax = ss_pll.TDS.plt.plot(ss_pll.REGCP1.v, yheader=['$V$ Bus 8 with PLL'],\n",
+    "                    right=5, fig=fig, ax=ax,\n",
+    "                    autoscale=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0fa8b71a-3f90-4b45-a4f8-7a95d2696352",
+   "metadata": {},
+   "source": [
+    "## Comparing `REGCA1` with `REGCP1` with a high-latency PLL"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "39accc30-6700-471c-a318-714e33bbfae1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-> Single process finished in 0.1391 seconds.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "eb213c619d44404a884c00aa89a60766",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100 [00:00<?, ?%/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "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"
+     ]
+    }
+   ],
+   "source": [
+    "ss_pll = andes.run(andes.get_case(\"ieee14/ieee14_regcp1.xlsx\"), verbose=30)\n",
+    "\n",
+    "ss_pll.PLL1.alter(\"Tf\", \"PLL1_1\", 0.5)\n",
+    "ss_pll.PLL1.alter(\"Tp\", \"PLL1_1\", 0.5)\n",
+    "\n",
+    "ss_pll.TDS.config.tf = 5\n",
+    "xy = ss_pll.TDS.run()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "5ff92d5e-8974-4ce0-a250-736844010b12",
+   "metadata": {},
+   "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": {
+      "text/plain": [
+       "(<Figure size 600x400 with 1 Axes>, <AxesSubplot:xlabel='Time [s]'>)"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ss_pll.TDS.plt.plot([ss_pll.PLL1.a, ss_pll.PLL1.am])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "2c621bf9-355d-4c42-83a7-ae05d57ea427",
+   "metadata": {},
+   "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"
+    }
+   ],
+   "source": [
+    "fig, ax = ss_std.TDS.plt.plot([ss_std.REGCA1.Pe], right=5,\n",
+    "                              show=False, yheader=['$P_e$ without PLL'])\n",
+    "\n",
+    "fig, ax = ss_pll.TDS.plt.plot(ss_pll.REGCP1.Pe, yheader=['$P_e$ with PLL'],\n",
+    "                    right=5, fig=fig, ax=ax,\n",
+    "                    autoscale=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "a81f6059-ed6d-4264-9599-89c130c67c6d",
+   "metadata": {},
+   "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"
+    }
+   ],
+   "source": [
+    "fig, ax = ss_std.TDS.plt.plot([ss_std.REGCA1.Qe], right=5,\n",
+    "                              show=False, yheader=['$Q_e$ without PLL'])\n",
+    "\n",
+    "fig, ax = ss_pll.TDS.plt.plot(ss_pll.REGCP1.Qe, yheader=['$Q_e$ with PLL'],\n",
+    "                    right=5, fig=fig, ax=ax,\n",
+    "                    autoscale=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "47215ffd-73ff-4bb0-ae45-475e59c7b4d0",
+   "metadata": {},
+   "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"
+    }
+   ],
+   "source": [
+    "fig, ax = ss_std.TDS.plt.plot([ss_std.REGCA1.v], right=5,\n",
+    "                              show=False, yheader=['$V$ Bus 8 without PLL'])\n",
+    "\n",
+    "fig, ax = ss_pll.TDS.plt.plot(ss_pll.REGCP1.v, yheader=['$V$ Bus 8 with PLL'],\n",
+    "                    right=5, fig=fig, ax=ax,\n",
+    "                    autoscale=True)"
+   ]
+  }
+ ],
+ "metadata": {
+  "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.9.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/ex4.ipynb b/examples/ex4.ipynb
index 33e3592a2..a6bbf11bd 100644
--- a/examples/ex4.ipynb
+++ b/examples/ex4.ipynb
@@ -203,7 +203,7 @@
      "output_type": "stream",
      "text": [
       "ANDES 1.5.7.post27.dev0+g9e0e253e\n",
-      "Copyright (C) 2015-2021 Hantao Cui\n",
+      "Copyright (C) 2015-2022 Hantao Cui\n",
       "\n",
       "ANDES comes with ABSOLUTELY NO WARRANTY\n",
       "Case file: /home/hacui/repos/andes/andes/cases/kundur/kundur_full.xlsx\n",
diff --git a/requirements.txt b/requirements.txt
index b62439a79..5e018bdbd 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -14,3 +14,4 @@ coloredlogs
 chardet
 numba
 psutil
+texttable


Test patch:
diff --git a/andes/models/experimental/testmodel.py b/andes/models/experimental/testmodel.py
new file mode 100644
index 000000000..4310ca71b
--- /dev/null
+++ b/andes/models/experimental/testmodel.py
@@ -0,0 +1,90 @@
+from andes.core import ModelData, Model, Algeb, NumParam
+from andes.core.block import (DeadBand1, PIController, PIFreeze, PITrackAW,
+                              PITrackAWFreeze, LagFreeze, LagAWFreeze)
+from andes.core.service import ExtendedEvent
+
+
+class TestFrame(ModelData, Model):
+    """
+    An empty model for testing modeling elements.
+    Needs to be inherited by specific test models.
+    """
+
+    def __init__(self, system, config):
+        ModelData.__init__(self)
+        Model.__init__(self, system, config)
+        self.group = 'Experimental'
+
+        self.flags.tds = True
+
+
+class TestDB1(TestFrame):
+    """
+    Test model for `DeadBand1`.
+    """
+
+    def __init__(self, system, config):
+        TestFrame.__init__(self, system, config)
+
+        self.uin = Algeb(v_str='-10',
+                         e_str='(dae_t - 10) - uin',
+                         tex_name='u_{in}'
+                         )
+        self.DB = DeadBand1(self.uin, center=0, lower=-5, upper=5)
+
+
+class TestPI(TestFrame):
+    def __init__(self, system, config):
+        TestFrame.__init__(self, system, config)
+
+        self.Text = NumParam(default=1.0, info='Extended event time', unit='s')
+
+        self.uin = Algeb(v_str=0,
+                         e_str='sin(dae_t) - uin',
+                         tex_name='u_{in}',
+                         )
+
+        self.zf = Algeb(v_str=0,
+                        e_str='Piecewise((0, dae_t <= 2), (1, dae_t <=6), (0, dae_t<=12), (1, dae_t<=15), '
+                              '(0, True)) - zf',
+                        tex_name='z_f',
+                        )
+
+        self.PI = PIController(u=self.uin, kp=1, ki=0.1)
+
+        self.PIF = PIFreeze(u=self.uin, kp=0.5, ki=0.5, x0=0,
+                            freeze=self.zf)
+
+        self.PIAW = PITrackAW(u=self.uin, kp=0.5, ki=0.5, ks=2,
+                              lower=-0.5, upper=0.5, x0=0.0,
+                              )
+
+        self.PIAWF = PITrackAWFreeze(u=self.uin, kp=0.5, ki=0.5, ks=2, x0=0,
+                                     freeze=self.zf, lower=-0.5, upper=0.5)
+
+        self.ExtEvent = ExtendedEvent(u=self.zf, t_ext=self.Text, trig='rise', extend_only=True)
+
+        self.ze = Algeb(v_str='ExtEvent', e_str='ExtEvent - ze')
+
+
+class TestLagAWFreeze(TestFrame):
+    def __init__(self, system, config):
+        TestFrame.__init__(self, system, config)
+
+        self.uin = Algeb(v_str=0,
+                         e_str='sin(dae_t) - uin',
+                         tex_name='u_{in}',
+                         )
+
+        self.zf = Algeb(v_str=0,
+                        e_str='Piecewise((0, dae_t <= 2), (1, dae_t <=6), (0, True)) - zf',
+                        tex_name='z_f',
+                        )
+
+        self.LGF = LagFreeze(u=self.uin, T=1.0, K=1.0,
+                             freeze=self.zf,
+                             )
+
+        self.LGAWF = LagAWFreeze(u=self.uin, T=1.0, K=1.0, lower=-0.5, upper=0.5,
+                                 freeze=self.zf,
+                                 )
diff --git a/tests/test_addressing.py b/tests/test_addressing.py
new file mode 100644
index 000000000..5fcbe4763
--- /dev/null
+++ b/tests/test_addressing.py
@@ -0,0 +1,37 @@
+import unittest
+
+import andes
+import numpy as np
+
+
+class TestAddressing(unittest.TestCase):
+    """
+    Tests for DAE addressing.
+    """
+
+    def test_ieee14_address(self):
+        """
+        Test IEEE14 address.
+        """
+
+        ss = andes.system.example()
+
+        # bus variable indices (internal)
+        np.testing.assert_array_equal(ss.Bus.a.a,
+                                      np.arange(0, ss.Bus.n, 1))
+        np.testing.assert_array_equal(ss.Bus.v.a,
+                                      np.arange(ss.Bus.n, 2*ss.Bus.n, 1))
+        # external variable indices
+        np.testing.assert_array_equal(ss.PQ.a.a,
+                                      [1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13])
+        np.testing.assert_array_equal(ss.PQ.v.a,
+                                      ss.Bus.n + np.array([1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13]))
+
+        np.testing.assert_array_equal(ss.PV.q.a,
+                                      np.array([28, 29, 30, 31]))
+
+        np.testing.assert_array_equal(ss.Slack.q.a,
+                                      np.array([32]))
+
+        np.testing.assert_array_equal(ss.Slack.p.a,
+                                      np.array([33]))
diff --git a/tests/test_pandapower.py b/tests/test_pandapower.py
index ce4cd41f0..dfb543574 100644
--- a/tests/test_pandapower.py
+++ b/tests/test_pandapower.py
@@ -7,7 +7,7 @@
 
 import andes
 from andes.shared import deg2rad
-from andes.interop.pandapower import to_pandapower, make_link_table
+from andes.interop.pandapower import to_pandapower, make_link_table, make_GSF
 
 try:
     import pandapower as pp
@@ -61,6 +61,19 @@ def test_make_link_table(self):
         c = c_bus.values[0] and c_exc.values[0] and c_stg.values[0] and c_gov.values[0]
         return c
 
+    def test_make_GSF(self):
+        """
+        Test `andes.interop.pandapower.make_GSF with ieee39`
+        """
+
+        sa39 = andes.load(andes.get_case('ieee39/ieee39.xlsx'),
+                          setup=True,
+                          no_output=True,
+                          default_config=True)
+        sp39 = to_pandapower(sa39)
+        make_GSF(sp39)
+        return True
+
 
 def _test_to_pandapower_single(case, **kwargs):
     """
diff --git a/tests/test_psse_parser.py b/tests/test_psse_parser.py
new file mode 100644
index 000000000..d460c1ea3
--- /dev/null
+++ b/tests/test_psse_parser.py
@@ -0,0 +1,28 @@
+"""
+Tests for PSS/E parser.
+"""
+
+import os
+import unittest
+import yaml
+
+from andes.system import System
+from andes.io import psse
+
+
+class TestPSSEParser(unittest.TestCase):
+    """
+    Test PSSE parsers.
+    """
+
+    def test_sort_models(self):
+        """
+        Test sort_models.
+        """
+
+        system = System()
+
+        dirname = os.path.dirname(__file__)
+        with open(f'{dirname}/../andes/io/psse-dyr.yaml', 'r') as f:
+            dyr_yaml = yaml.full_load(f)
+        psse.sort_psse_models(dyr_yaml, system)