Skip to content

Latest commit

 

History

History
186 lines (137 loc) · 8.33 KB

TODO.md

File metadata and controls

186 lines (137 loc) · 8.33 KB
Raw

v1.5

Milestones

  • Separate array-enabled parameters from NumParam into BaseConvParam, which implements iconvert and oconvert, and then ListParam
  • Improve the robustness of accessing the fields of pycode by properly handling KeyErrors.
  • Numba code generation for all models. Add a function for triggering all the JIT compilation before simulation.
  • Unit Model Test framework.

Later Versions

  • Allow selection of output variables
  • PQTS model for PQ with time-series.
  • Generalize two-terminal and multi-terminal devices
  • Allow for semi-analytical derivation of equations
  • Define general hooks - when should the connectivity check happen
  • Vectorize the enable option for most discrete blocks.
  • allow to remind developer of missing equations (such as vout of Exciters).

Help Wanted

  • Restore compatibility with dome format
  • Draw block diagram from symbolic models using BDP (or SchemDraw)
  • Eigenvalue analysis report sort options: by damping, frequency, or eigenvalue
  • Root loci plots

Previous

v1.4

  • Disallow linking ExtAlgeb to State and ExtState to Algeb (check in prepare).

v1.3

Milestones

  • Implement switched shunt model (ShuntSw)
  • Allow arrays as device parameter
  • An Summary model for storing system summary
  • Allow export of equation values. Using equation values are not recommended due to convergence considerations (partial derivatives not used).
  • Robust iterative initialization for variables

Version 1.1.0 (completed)

Milestones

  • Limiter check and warning after initialization
  • Renewable generator models (REGC_A, REEC_A, REPC_A)

To-do list

  • Improve the speed of DAETimeSeries.unpack.
  • Allow simulating to a time, pause, and continue to a new ending time.
  • Store TDS data as NumPy compressed format npz; allow to reload both npy and npz.
  • Power flow model variables erroneously point to the old dae.y array (fixed)
  • Allow loading default config for selftest (andes.run(default_config=True))

Version 0.9.0 (completed)

Milestones

  • Help system and consistency check system for Config
  • Handling of zero time constants (through State.t_const)
  • Refactor Model to separate symbolic processing part as ModelSymbolic -> Model.syms.
  • Separate the solver class into an interface class + different solver classes

To-do bullets

  • A working GENROU model with saturation function
  • Fix the model connectivity status u in interface equations
  • A refreshed raw file reader to build data into ModelData (partially refreshed)
  • A refreshed dyr file reader
  • Add Model.int for internal indexer (implemented by replacing Model.idx as DataParam)
  • Allow adding routine without modifying code (as long as routines are added to Routines.all_routines)
  • Add a help system for Config
  • Add consistency checks for Config
  • Return an error state to system if a simulation routine fails
  • Example COI model

Version 0.8.0 (Completed)

Milestones

  • A working PQNew class with an option to convert to Z; Allow config in models
  • A defined data loading, model initialization, variable/equation relaying sequence
  • A working power flow routine fully generated from symbolic expressions
  • A working System class providing parameter retrieval by group and model
  • Time domain simulation using scipy.integrate (odeint and solve_ivp)

Features

  • Symbolic DAE modeling and automated code generation for numerical simulation
  • Numerical DAE modeling for scenarios when symbolic implementations are difficult
  • Rapid modeling with block library with common transfer functions.
  • Discrete component library such as hard limiter, dead band, and anti-windup limiter.
  • Pretty printing of DAE and automatically derived Jacobians
  • Newton-Raphson and Newton-Krylov power flow (with automatic handling of separated systems).
  • Trapezoidal method for semi-explicit time domain simulation.

Usability

  • Set up command line interface

To-do bullets

  • Clearly define interface variables VarExt
  • Define associated equation with each variable (internal of interface)
  • Use SymPy/SynEngine to generate function calls - define the interfaces
  • Use SymEngine to get the derivative for each model; the derivatives may store in a smaller matrix locally to the model
  • Pickle/dill the auto-generated function calls on the first run
  • Function for providing the jacobian triplet
  • Implement a PV model with the old code - Partially done with the Hybrid j_numeric
  • Define the call sequence for data flow between models and dae/models
  • Initial values, pass initialized values between models, and solve initializer equations
  • Improve the access to dae attributes. Get rid of self.dae.__dict__[f''] usages.
  • Configs in models that can participate in the computation, saved to files, and loaded
  • Dummy service variables for storing initial values (such as pm0, vref0) (Solved with Service itself)
  • Improve running functions based on routine. Get rid of passing around is_tds. Possibly implementing a

pflow_models and a tds_models list in system

  • Implement a group for PV and Slack. Possibly implementing all groups in group.py
  • Implement index handling in group.py, update link_external to work with groups (Let group implement

similar api to models.idx2uid, or implement a get_by_idx for both)

  • Let Synchronous generator subsitute PV; more generally, let any non-pflow model substitute a pflow one

(Currently done with v_numeric )

  • Prototype Connectivity checking, previously implemented as gyisland. Need to be implemented under

System (It turns out that gy_island and gisland does not need to be implemented. If there is a large mismatch, just let the power flow fail and let the user correct the data.)

  • Prototype a Bus voltage average for area (COI-type of one-to-multiple aggregation model

(RefParam, SericeReduce and RepeaterService)

  • Divide limiter to update_var and update_eq (such as anti-windup limiter which depends on equations)
  • Allow time definition in models reserve keyword dae_t (see Area)
  • Clean up System._get_models; Clean up the use of model-dependent calls
  • Clearly define reset and clear (clear clears the values but retains the size; reset resets

attributes to a state before setup)

  • Fix the case when Area is not a TDS model but has an equation time = dae_t which does not get updated

during TDS. (a non- tds model is not allowed to use dae.t )

  • Implement a trapezoidal rule for numerical integration
  • Refactorize jacobian after critical time (works for implicit method)
  • Use an iterator into System.times rather than deleting times[0]
  • Implement a time-based switching model and export all switching time to System.switch_times
  • Sequential initialization
  • Limiter in PI controller
  • Clean up the use of vars_to_dae and vars_to_model
  • low pass filter in PI Controller - How the equations should be written
  • Refactor Config to make load and save part of the config
  • Per-unit conversion (get ExtParam Sn, Vn before per unit conversion - Yes)
  • LaTeX names in blocks and limiters
  • Input switch. If input equals 1, 2, 3, or 4; Discrete
  • Quadratic and exponential saturation for generators
  • Piecewise nonlinear functions (block. Piecewise)
  • Decide whether to keep Calc as Var or move it to service. (eliminated from VarBase subclasses; Likely a

service subclass)

  • Use SymPy to solve e1d, e1q, e2d and e2q equations for GENROU
  • Test initialization and report suspect issues
  • Test anti-windup limiter
  • Added expression symbol checking. Undefined symbols will throw ValueError during preparation
  • [X]System.reset() not working after TDS.run
  • Export power flow iteration steps for debugging; export limiter status (get_inputs) alongside equations (implemented in _input_z)
  • Batch simulation with in-place parameter modification (implemented with Model.alter())
  • Control feedback, possibly with perturbation files (control implemented in this approach has a "delay" of a step size)
  • TimeSeries output to DataFrame (system.dae.ts.df)

Examples

  • implement a standalone PI controller with numerical jacobians