ltbams 0.9.9__py3-none-any.whl → 1.0.2a1__py3-none-any.whl

ams/core/symprocessor.py

@@ -0,0 +1,224 @@
+"""
+Symbolic processor class for AMS routines.
+
+This module is revised from ``andes.core.symprocessor``.
+"""
+
+import logging
+from collections import OrderedDict
+
+import sympy as sp
+
+from andes.utils.misc import elapsed
+from ams.core.matprocessor import MatProcessor
+
+logger = logging.getLogger(__name__)
+
+
+class SymProcessor:
+    """
+    Class for symbolic processing in AMS routine.
+
+    Parameters
+    ----------
+    parent : ams.routines.base.BaseRoutine
+        Routine instance to process.
+
+    Attributes
+    ----------
+    sub_map : dict
+        Substitution map for symbolic processing.
+    tex_map : dict
+        Tex substitution map for documentation.
+    val_map : dict
+        Value substitution map for post-solving value evaluation.
+    """
+
+    def __init__(self, parent):
+        self.parent = parent
+        self.inputs_dict = OrderedDict()
+        self.services_dict = OrderedDict()
+        self.config = parent.config
+        self.class_name = parent.class_name
+        self.tex_names = OrderedDict()
+        self.tex_map = OrderedDict()
+
+        lang = "cp"  # TODO: might need to be generalized to other solvers
+        # only used for CVXPY
+        self.sub_map = OrderedDict([
+            (r'\b(\w+)\s*\*\s*(\w+)\b', r'\1 @ \2'),
+            (r'\b(\w+)\s+dot\s+(\w+)\b', r'\1 * \2'),
+            (r' dot ', r' * '),
+            (r'\bsum\b', f'{lang}.sum'),
+            (r'\bvar\b', f'{lang}.Variable'),
+            (r'\bparam\b', f'{lang}.Parameter'),
+            (r'\bconst\b', f'{lang}.Constant'),
+            (r'\bproblem\b', f'{lang}.Problem'),
+            (r'\bmultiply\b', f'{lang}.multiply'),
+            (r'\bmul\b', f'{lang}.multiply'),  # alias for multiply
+            (r'\bvstack\b', f'{lang}.vstack'),
+            (r'\bnorm\b', f'{lang}.norm'),
+            (r'\bpos\b', f'{lang}.pos'),
+            (r'\bpower\b', f'{lang}.power'),
+            (r'\bsign\b', f'{lang}.sign'),
+            (r'\bsquare\b', f'{lang}.square'),
+            (r'\bquad_over_lin\b', f'{lang}.quad_over_lin'),
+            (r'\bdiag\b', f'{lang}.diag'),
+            (r'\bquad_form\b', f'{lang}.quad_form'),
+            (r'\bsum_squares\b', f'{lang}.sum_squares'),
+        ])
+
+        self.tex_map = OrderedDict([
+            (r'\*\*(\d+)', '^{\\1}'),
+            (r'\b(\w+)\s*\*\s*(\w+)\b', r'\1 \2'),
+            (r'\@', r' '),
+            (r'dot', r' '),
+            (r'sum_squares\((.*?)\)', r"SUM((\1))^2"),
+            (r'multiply\(([^,]+), ([^)]+)\)', r'\1 \2'),
+            (r'\bnp.linalg.pinv(\d+)', r'\1^{\-1}'),
+            (r'\bpos\b', 'F^{+}'),
+            (r'mul\((.*?),\s*(.*?)\)', r'\1 \2'),
+            (r'\bmul\b\((.*?),\s*(.*?)\)', r'\1 \2'),
+            (r'\bsum\b', 'SUM'),
+            (r'power\((.*?),\s*(\d+)\)', r'\1^\2'),
+            (r'(\w+).dual_variables\[0\]', r'\phi[\1]'),
+        ])
+
+        # mapping dict for evaluating expressions
+        self.val_map = OrderedDict([
+            (r'(== 0|<= 0)$', ''),  # remove the comparison operator
+            (r'cp\.(Minimize|Maximize)', r'float'),  # remove cp.Minimize/Maximize
+            (r'\bcp.\b', 'np.'),
+            (r'\bexp\b', 'np.exp'),
+            (r'\blog\b', 'np.log'),
+            (r'\bconj\b', 'np.conj'),
+        ])
+
+        self.status = {
+            'optimal': 0,
+            'infeasible': 1,
+            'unbounded': 2,
+            'infeasible_inaccurate': 3,
+            'unbounded_inaccurate': 4,
+            'optimal_inaccurate': 5,
+            'solver_error': 6,
+            'time_limit': 7,
+            'interrupted': 8,
+            'unknown': 9,
+            'infeasible_or_unbounded': 1.5,
+            'user_limit': 10,
+        }
+
+    def generate_symbols(self, force_generate=False):
+        """
+        Generate symbols for all variables.
+        """
+        logger.debug(f'Entering symbol generation for <{self.parent.class_name}>')
+
+        if (not force_generate) and self.parent._syms:
+            logger.debug(' - Symbols already generated')
+            return True
+        t, _ = elapsed()
+
+        # process tex_names defined in routines
+        # -----------------------------------------------------------
+        for key in self.parent.tex_names.keys():
+            self.tex_names[key] = sp.symbols(self.parent.tex_names[key])
+
+        # Vars
+        for vname, var in self.parent.vars.items():
+            self.inputs_dict[vname] = sp.symbols(f'{vname}')
+            self.sub_map[rf"\b{vname}\b"] = f"self.om.{vname}"
+            self.tex_map[rf"\b{vname}\b"] = rf'{var.tex_name}'
+            self.val_map[rf"\b{vname}\b"] = f"rtn.{vname}.v"
+
+        # RParams
+        for rpname, rparam in self.parent.rparams.items():
+            tmp = sp.symbols(f'{rparam.name}')
+            self.inputs_dict[rpname] = tmp
+            sub_name = ''
+            if isinstance(rparam.owner, MatProcessor):
+                # sparse matrices are accessed from MatProcessor
+                # otherwise, dense matrices are accessed from Routine
+                if rparam.sparse:
+                    sub_name = f'self.rtn.system.mats.{rpname}._v'
+                else:
+                    sub_name = f'self.rtn.{rpname}.v'
+            elif rparam.no_parse:
+                sub_name = f'self.rtn.{rpname}.v'
+            else:
+                sub_name = f'self.om.{rpname}'
+            self.sub_map[rf"\b{rpname}\b"] = sub_name
+            self.tex_map[rf"\b{rpname}\b"] = f'{rparam.tex_name}'
+            if not rparam.no_parse:
+                self.val_map[rf"\b{rpname}\b"] = f"rtn.{rpname}.v"
+
+        # Routine Services
+        for sname, service in self.parent.services.items():
+            tmp = sp.symbols(f'{service.name}')
+            self.services_dict[sname] = tmp
+            self.inputs_dict[sname] = tmp
+            sub_name = f'self.rtn.{sname}.v' if service.no_parse else f'self.om.{sname}'
+            self.sub_map[rf"\b{sname}\b"] = sub_name
+            self.tex_map[rf"\b{sname}\b"] = f'{service.tex_name}'
+            if not service.no_parse:
+                self.val_map[rf"\b{sname}\b"] = f"rtn.{sname}.v"
+
+        # Expressions
+        for ename, expr in self.parent.exprs.items():
+            self.inputs_dict[ename] = sp.symbols(f'{ename}')
+            self.sub_map[rf"\b{ename}\b"] = f"self.om.{ename}"
+            self.val_map[rf"\b{ename}\b"] = f"rtn.{ename}.v"
+            self.tex_map[rf"\b{ename}\b"] = f'{expr.tex_name}'
+
+        # Constraints
+        # NOTE: constraints are included in sub_map for ExpressionCalc
+        # thus, they don't have the suffix `.v`
+        for cname, constraint in self.parent.constrs.items():
+            self.sub_map[rf"\b{cname}\b"] = f'self.rtn.{cname}.optz'
+
+        # store tex names defined in `self.config`
+        for key in self.config.as_dict():
+            tmp = sp.symbols(key)
+            self.sub_map[rf"\b{key}\b"] = f'self.rtn.config.{key}'
+            if key not in self.config.tex_names.keys():
+                logger.debug(f'No tex name for config.{key}')
+                self.tex_map[rf"\b{key}\b"] = key
+            else:
+                self.tex_map[rf"\b{key}\b"] = self.config.tex_names[key]
+            self.inputs_dict[key] = tmp
+            if key in self.config.tex_names:
+                self.tex_names[tmp] = sp.Symbol(self.config.tex_names[key])
+
+        # store tex names for pretty printing replacement later
+        for var in self.inputs_dict:
+            if var in self.parent.__dict__ and self.parent.__dict__[var].tex_name is not None:
+                self.tex_names[sp.symbols(var)] = sp.symbols(self.parent.__dict__[var].tex_name)
+
+        # additional variables by conventions that are defined in ``BaseRoutine``
+        self.inputs_dict['sys_f'] = sp.symbols('sys_f')
+        self.inputs_dict['sys_mva'] = sp.symbols('sys_mva')
+
+        self.parent._syms = True
+        _, s = elapsed(t)
+
+        logger.debug(f' - Symbols generated in {s}')
+        return self.parent._syms
+
+    def _check_expr_symbols(self, expr):
+        """
+        Check if expression contains unknown symbols.
+        """
+        fs = expr.free_symbols
+        for item in fs:
+            if item not in self.inputs_dict.values():
+                raise ValueError(f'{self.class_name} expression "{expr}" contains unknown symbol "{item}"')
+
+        fs = sorted(fs, key=lambda s: s.name)
+        return fs
+
+    def generate_pretty_print(self):
+        """
+        Generate pretty print math formulation.
+        """
+        raise NotImplementedError

ams/core/var.py

@@ -0,0 +1,59 @@
+"""
+Base class for variables.
+"""
+
+from typing import Optional
+import logging
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class Algeb:
+    """
+    Algebraic variable class.
+
+    This class is simplified from ``andes.core.var.Algeb``.
+    """
+
+    def __init__(self,
+                 name: Optional[str] = None,
+                 tex_name: Optional[str] = None,
+                 info: Optional[str] = None,
+                 unit: Optional[str] = None,
+                 ):
+        self.name = name
+        self.info = info
+        self.unit = unit
+
+        self.tex_name = tex_name if tex_name else name
+        self.owner = None  # instance of the owner Model
+        self.id = None     # variable internal index inside a model (assigned in run time)
+
+        # TODO: set a
+        # address into the variable and equation arrays (dae.f/dae.g and dae.x/dae.y)
+        self.a: np.ndarray = np.array([], dtype=int)
+
+        self.v: np.ndarray = np.array([], dtype=float)  # variable value array
+
+    def __repr__(self):
+        if self.owner.n == 0:
+            span = []
+
+        elif 1 <= self.owner.n <= 20:
+            span = f'a={self.a}, v={self.v}'
+
+        else:
+            span = []
+            span.append(self.a[0])
+            span.append(self.a[-1])
+            span.append(self.a[1] - self.a[0])
+            span = ':'.join([str(i) for i in span])
+            span = 'a=[' + span + ']'
+
+        return f'{self.__class__.__name__}: {self.owner.__class__.__name__}.{self.name}, {span}'
+
+    @property
+    def class_name(self):
+        return self.__class__.__name__

ams/extension/__init__.py

@@ -0,0 +1,5 @@
+"""
+Extension module.
+"""
+
+from ams.extension import eva  # NOQA

ams/extension/eva.py

@@ -0,0 +1,401 @@
+"""
+EV Aggregator module.
+
+EVD is the generated datasets, and EVA is the aggregator model.
+
+Reference:
+[1] J. Wang et al., "Electric Vehicles Charging Time Constrained Deliverable Provision of Secondary
+Frequency Regulation," in IEEE Transactions on Smart Grid, doi: 10.1109/TSG.2024.3356948.
+[2] M. Wang, Y. Mu, Q. Shi, H. Jia and F. Li, "Electric Vehicle Aggregator Modeling and Control for
+Frequency Regulation Considering Progressive State Recovery," in IEEE Transactions on Smart Grid,
+vol. 11, no. 5, pp. 4176-4189, Sept. 2020, doi: 10.1109/TSG.2020.2981843.
+"""
+
+import logging
+import itertools
+from collections import OrderedDict
+
+import scipy.stats as stats
+
+from andes.core import Config
+from andes.core.param import NumParam
+from andes.core.model import ModelData
+from andes.shared import np, pd
+from andes.utils.misc import elapsed
+
+from ams.core.model import Model
+from ams.utils.paths import ams_root
+
+logger = logging.getLogger(__name__)
+
+
+# NOTE: following definition comes from ref[2], except `tt` that is assumed by ref[1]
+# normal distribution parameters
+ndist = {'soci': {'mu': 0.3, 'var': 0.05, 'lb': 0.2, 'ub': 0.4},
+         'socd': {'mu': 0.8, 'var': 0.03, 'lb': 0.7, 'ub': 0.9},
+         'ts1': {'mu': -6.5, 'var': 3.4, 'lb': 0.0, 'ub': 5.5},
+         'ts2': {'mu': 17.5, 'var': 3.4, 'lb': 5.5, 'ub': 24.0},
+         'tf1': {'mu': 8.9, 'var': 3.4, 'lb': 0.0, 'ub': 20.9},
+         'tf2': {'mu': 32.9, 'var': 3.4, 'lb': 20.9, 'ub': 24.0},
+         'tt': {'mu': 0.5, 'var': 0.02, 'lb': 0, 'ub': 1}}
+# uniform distribution parameters
+udist = {'Pc': {'lb': 5.0, 'ub': 7.0},
+         'Pd': {'lb': 5.0, 'ub': 7.0},
+         'nc': {'lb': 0.88, 'ub': 0.95},
+         'nd': {'lb': 0.88, 'ub': 0.95},
+         'Q': {'lb': 20.0, 'ub': 30.0}}
+
+
+class EVD(ModelData, Model):
+    """
+    In the EVD, each single EV is recorded as a device with its own parameters.
+    The parameters are generated from given statistical distributions.
+    """
+
+    def __init__(self, N=10000, Ns=20, Tagc=4, SOCf=0.2, r=0.5,
+                 t=18, seed=None, name='EVA', A_csv=None):
+        """
+        Initialize the EV aggregation model.
+
+        Parameters
+        ----------
+        N : int, optional
+            Number of related EVs, default is 10000.
+        Ns : int, optional
+            Number of SOC intervals, default is 20.
+        Tagc : int, optional
+            AGC time intervals in seconds, default is 4.
+        SOCf : float, optional
+            Force charge SOC level between 0 and 1, default is 0.2.
+        r : float, optional
+            Ratio of time range 1 to time range 2 between 0 and 1, default is 0.5.
+        seed : int or None, optional
+            Seed for random number generator, default is None.
+        t : int, optional
+            Current time in 24 hours, default is 18.
+        name : str, optional
+            Name of the EVA, default is 'EVA'.
+        A_csv : str, optional
+            Path to the CSV file containing the state space matrix A, default is None.
+        """
+        # inherit attributes and methods from ANDES `ModelData` and AMS `Model`
+        ModelData.__init__(self)
+        Model.__init__(self, system=None, config=None)
+
+        self.evdname = name
+
+        # internal flags
+        self.is_setup = False        # if EVA has been setup
+
+        self.t = np.array(t, dtype=float)  # time in 24 hours
+        self.eva = None  # EV Aggregator
+        self.A_csv = A_csv  # path to the A matrix
+
+        # manually set config as EVA is not processed by the system
+        self.config = Config(self.__class__.__name__)
+        self.config.add(OrderedDict((('n', int(N)),
+                                     ('ns', Ns),
+                                     ('tagc', Tagc),
+                                     ('socf', SOCf),
+                                     ('r', r),
+                                     ('socl', 0),
+                                     ('socu', 1),
+                                     ('tf', self.t),
+                                     ('prumax', 0),
+                                     ('prdmax', 0),
+                                     ('seed', seed),
+                                     )))
+        self.config.add_extra("_help",
+                              n="Number of related EVs",
+                              ns="SOC intervals",
+                              tagc="AGC time intervals in seconds",
+                              socf="Force charge SOC level",
+                              r="ratio of time range 1 to time range 2",
+                              socl="lowest SOC limit",
+                              socu="highest SOC limit",
+                              tf="EVA running end time in 24 hours",
+                              prumax="maximum power of regulation up, in MW",
+                              prdmax="maximum power of regulation down, in MW",
+                              seed='seed (or None) for random number generator',
+                              )
+        self.config.add_extra("_tex",
+                              n='N_{ev}',
+                              ns='N_s',
+                              tagc='T_{agc}',
+                              socf='SOC_f',
+                              r='r',
+                              socl='SOC_{l}',
+                              socu='SOC_{u}',
+                              tf='T_f',
+                              prumax='P_{ru,max}',
+                              prdmax='P_{rd,max}',
+                              seed='seed',
+                              )
+        self.config.add_extra("_alt",
+                              n='int',
+                              ns="int",
+                              tagc="float",
+                              socf="float",
+                              r="float",
+                              socl="float",
+                              socu="float",
+                              tf="float",
+                              prumax="float",
+                              prdmax="float",
+                              seed='int or None',
+                              )
+
+        unit = self.config.socu / self.config.ns
+        self.soc_intv = OrderedDict({
+            i: (np.around(i * unit, 2), np.around((i + 1) * unit, 2))
+            for i in range(self.config.ns)
+        })
+
+        # NOTE: the parameters and variables are declared here and populated in `setup()`
+        # param `idx`, `name`, and `u` are already included in `ModelData`
+        # variables here are actually declared as parameters for memory saving
+        # because ams.core.var.Var has more overhead
+
+        # --- parameters ---
+        self.namax = NumParam(default=0,
+                              info='maximum number of action')
+        self.ts = NumParam(default=0, vrange=(0, 24),
+                           info='arrive time, in 24 hours')
+        self.tf = NumParam(default=0, vrange=(0, 24),
+                           info='departure time, in 24 hours')
+        self.tt = NumParam(default=0,
+                           info='Tolerance of increased charging time, in hours')
+        self.soci = NumParam(default=0,
+                             info='initial SOC')
+        self.socd = NumParam(default=0,
+                             info='demand SOC')
+        self.Pc = NumParam(default=0,
+                           info='rated charging power, in kW')
+        self.Pd = NumParam(default=0,
+                           info='rated discharging power, in kW')
+        self.nc = NumParam(default=0,
+                           info='charging efficiency',
+                           vrange=(0, 1))
+        self.nd = NumParam(default=0,
+                           info='discharging efficiency',
+                           vrange=(0, 1))
+        self.Q = NumParam(default=0,
+                          info='rated capacity, in kWh')
+
+        # --- variables ---
+        self.soc0 = NumParam(default=0,
+                             info='previous SOC')
+        self.u0 = NumParam(default=0,
+                           info='previous online status')
+        self.na0 = NumParam(default=0,
+                            info='previous action number')
+        self.soc = NumParam(default=0,
+                            info='SOC')
+        self.na = NumParam(default=0,
+                           info='action number')
+
+    def setup(self, ndist=ndist, udist=udist):
+        """
+        Setup the EV aggregation model.
+
+        Parameters
+        ----------
+        ndist : dict, optional
+            Normal distribution parameters, default by built-in `ndist`.
+        udist : dict, optional
+            Uniform distribution parameters, default by built-in `udist`.
+
+        Returns
+        -------
+        is_setup : bool
+            If the setup is successful.
+        """
+        if self.is_setup:
+            logger.warning(f'{self.evdname} aggregator has been setup, setup twice is not allowed.')
+            return False
+
+        t0, _ = elapsed()
+
+        # manually set attributes as EVA is not processed by the system
+        self.n = self.config.n
+        self.idx.v = ['SEV_' + str(i+1) for i in range(self.config.n)]
+        self.name.v = ['SEV ' + str(i+1) for i in range(self.config.n)]
+        self.u.v = np.array(self.u.v, dtype=int)
+        self.uid = {self.idx.v[i]: i for i in range(self.config.n)}
+
+        # --- populate parameters' value ---
+        # set `soci`, `socd`, `tt`
+        self.soci.v = build_truncnorm(ndist['soci']['mu'], ndist['soci']['var'],
+                                      ndist['soci']['lb'], ndist['soci']['ub'],
+                                      self.config.n, self.config.seed)
+        self.socd.v = build_truncnorm(ndist['socd']['mu'], ndist['socd']['var'],
+                                      ndist['socd']['lb'], ndist['socd']['ub'],
+                                      self.config.n, self.config.seed)
+        self.tt.v = build_truncnorm(ndist['tt']['mu'], ndist['tt']['var'],
+                                    ndist['tt']['lb'], ndist['tt']['ub'],
+                                    self.config.n, self.config.seed)
+        # set `ts`, `tf`
+        tdf = pd.DataFrame({
+            col: build_truncnorm(ndist[col]['mu'], ndist[col]['var'],
+                                 ndist[col]['lb'], ndist[col]['ub'],
+                                 self.config.n, self.config.seed)
+            for col in ['ts1', 'ts2', 'tf1', 'tf2']
+        })
+
+        nev_t1 = int(self.config.n * self.config.r)  # number of EVs in time range 1
+        tp1 = tdf[['ts1', 'tf1']].sample(n=nev_t1, random_state=self.config.seed)
+        tp2 = tdf[['ts2', 'tf2']].sample(n=self.config.n-nev_t1, random_state=self.config.seed)
+        tp = pd.concat([tp1, tp2], axis=0).reset_index(drop=True).fillna(0)
+        tp['ts'] = tp['ts1'] + tp['ts2']
+        tp['tf'] = tp['tf1'] + tp['tf2']
+        # Swap ts and tf if ts > tf
+        check = tp['ts'] > tp['tf']
+        tp.loc[check, ['ts', 'tf']] = tp.loc[check, ['tf', 'ts']].values
+
+        self.ts.v = tp['ts'].values
+        self.tf.v = tp['tf'].values
+
+        # set `Pc`, `Pd`, `nc`, `nd`, `Q`
+        # NOTE: here it assumes (1) Pc == Pd, (2) nc == nd given by ref[2]
+        if self.config.seed is not None:
+            np.random.seed(self.config.seed)
+        self.Pc.v = np.random.uniform(udist['Pc']['lb'], udist['Pc']['ub'], self.config.n)
+        self.Pd.v = self.Pc.v
+        self.nc.v = np.random.uniform(udist['nc']['lb'], udist['nc']['ub'], self.config.n)
+        self.nd.v = self.nc.v
+        self.Q.v = np.random.uniform(udist['Q']['lb'], udist['Q']['ub'], self.config.n)
+
+        # --- adjust variables given current time ---
+        self.g_u()  # update online status
+        # adjust SOC considering random behavior
+        # NOTE: here we ignore the AGC participation before the current time `self.t`
+
+        # stayed time for the EVs arrived before t, reset negative time to 0
+        tc = np.maximum(self.t - self.ts.v, 0)
+        self.soc.v = self.soci.v + tc * self.Pc.v * self.nc.v / self.Q.v  # charge them
+
+        tr = (self.socd.v - self.soci.v) * self.Q.v / self.Pc.v / self.nc.v  # time needed to charge to socd
+
+        # ratio of stay/required time, stay less than required time reset to 1
+        kt = np.maximum(tc / tr, 1)
+        socp = self.socd.v + np.log(kt) * (1 - self.socd.v)  # log scale higher than socd
+        mask = kt > 1
+        self.soc.v[mask] = socp[mask]  # Update soc
+
+        # clip soc to min/max
+        self.soc.v = np.clip(self.soc.v, self.config.socl, self.config.socu)
+
+        self.soc0.v = self.soc.v.copy()
+        self.u0.v = self.u.v.copy()
+
+        self.evd = EVA(evd=self, A_csv=self.A_csv)
+
+        self.is_setup = True
+
+        _, s = elapsed(t0)
+        msg = f'{self.evdname} aggregator setup in {s}, and the current time is {self.t} H.\n'
+        msg += f'It has {self.config.n} EVs in total and {self.u.v.sum()} EVs online.'
+        logger.info(msg)
+
+        return self.is_setup
+
+    def g_u(self):
+        """
+        Update online status of EVs based on current time.
+        """
+        self.u.v = ((self.ts.v <= self.t) & (self.t <= self.tf.v)).astype(int)
+
+        return True
+
+
+class EVA:
+    """
+    State space modeling based EV aggregation model.
+    """
+
+    def __init__(self, evd, A_csv=None):
+        """
+        Parameters
+        ----------
+        EVD : ams.extension.eva.EVD
+            EV Aggregator model.
+        A_csv : str, optional
+            Path to the CSV file containing the state space matrix A, default is None.
+        """
+        self.parent = evd
+
+        # states of EV, intersection of charging status and SOC intervals
+        # C: charging, I: idle, D: discharging
+        states = list(itertools.product(['C', 'I', 'D'], self.parent.soc_intv.keys()))
+        self.state = OrderedDict(((''.join(str(i) for i in s), 0.0) for s in states))
+
+        # NOTE: 3*ns comes from the intersection of charging status and SOC intervals
+        ns = self.parent.config.ns
+        # NOTE: x, A will be updated in `setup()`
+        self.x = np.zeros(3*ns)
+
+        # A matrix
+        default_A_csv = ams_root() + '/extension/Aest.csv'
+        if A_csv:
+            try:
+                self.A = pd.read_csv(A_csv).values
+                logger.debug(f'Loaded A matrix from {A_csv}.')
+            except FileNotFoundError:
+                self.A = pd.read_csv(default_A_csv).values
+                logger.debug(f'File {A_csv} not found, using default A matrix.')
+        else:
+            self.A = pd.read_csv(default_A_csv).values
+            logger.debug('No A matrix provided, using default A matrix.')
+
+        mate = np.eye(ns)
+        mat0 = np.zeros((ns, ns))
+        self.B = np.vstack((-mate, mate, mat0))
+        self.C = np.vstack((mat0, -mate, mate))
+
+        # SSM variables
+        kde = stats.gaussian_kde(self.parent.Pc.v)
+        step = 0.01
+        Pl_values = np.arange(self.parent.Pc.v.min(), self.parent.Pc.v.max(), step)
+        self.Pave = 1e-3 * np.sum([Pl * kde.integrate_box(Pl, Pl + step) for Pl in Pl_values])  # kw to MW
+
+        # NOTE: D, Da, Db, Dc, Dd will be scaled by Pave later in `setup()`
+        vec1 = np.ones((1, ns))
+        vec0 = np.zeros((1, ns))
+        self.D = self.Pave * np.hstack((-vec1, vec0, vec0))
+        self.Da = self.Pave * np.hstack((vec0, vec0, vec1))
+        self.Db = self.Pave * np.hstack((vec1, vec1, vec1))
+        self.Db[0, ns] = 0  # low charged EVs don't DC
+        self.Dc = self.Pave * np.hstack((-vec1, vec0, vec0))
+        self.Dd = self.Pave * np.hstack((-vec1, -vec1, -vec1))
+        self.Dd[0, 2*ns-1] = 0  # overcharged EVs don't C
+
+
+def build_truncnorm(mu, var, lb, ub, n, seed):
+    """
+    Helper function to generate truncated normal distribution
+    using scipy.stats.
+
+    Parameters
+    ----------
+    mu : float
+        Mean of the normal distribution.
+    var : float
+        Variance of the normal distribution.
+    lb : float
+        Lower bound of the truncated distribution.
+    ub : float
+        Upper bound of the truncated distribution.
+    n : int
+        Number of samples to generate.
+    seed : int
+        Random seed to use.
+
+    Returns
+    -------
+    samples : ndarray
+        Generated samples.
+    """
+    a = (lb - mu) / var
+    b = (ub - mu) / var
+    distribution = stats.truncnorm(a, b, loc=mu, scale=var)
+    return distribution.rvs(n, random_state=seed)