1

LITS.jl—An Open-Source Julia basedSimulation Toolbox for Low-Inertia Power Systems

Rodrigo Henriquez-Auba?, Jose D. Lara†, Ciaran Roberts?, Nathan Pallo? and Duncan S. Callaway?,†

Abstract—The integration of converter-interfaced generation(CIG) from renewable energy sources poses challenges to thestability and transient behavior of electric power systems. Un-derstanding the dynamic behavior of low-inertia power systems iscritical to addressing these stability questions. However, there is alimited availability of open source tools explicitly geared towardslow-inertia systems modeling. In this paper, we develop an opensource simulation toolbox to study transient responses underhigh penetration scenarios. LITS.jl is implemented in theJulia computing language and features multi-machine modelingcapability, a rich library of synchronous generators components(AVR, PSS, Governor, etc.) and inverter configurations. Severalcase studies are conducted and benchmarked and validatedagainst existing toolboxes. Case studies are selected to showcasethe integration of different device models’ behavior in powersystems.

Index Terms—Low–Inertia Power Systems, Converter–Interfaced Generation, Synchronous Machines, Transient Sim-ulations, Software Implementation

I. INTRODUCTION

The increasing penetration of Converter-Interfaced Genera-tion (CIG) presents new challenges to the operation of powersystems. The integration of more CIG and subsequent substi-tution of traditional synchronous machines decreases systems’inertia. This may result in higher frequency rate of change,and lower nadir when a disturbance occurs. Theoretical resultsabout the reduction of available inertia in systems have beenstudied in detail, and raise concerns about the transient stabil-ity behavior as well as the potential control actions to mitigaterisks after a contingency. An additional complexity introducedby CIG are new control structures that have faster dynamicswhich can interact and generate unexpected time couplingwith existing system components - for example, synchronousgenerators’ controls or transmission lines [1], [2].

The study of stability and analysis of transient response inlarge-scale low-inertia power systems requires understandingthe dynamic behavior of system components under myriadassumptions. These include model fidelity, converter configu-rations, line dynamics, and load models. Traditional modelingassumptions, such as omitting network dynamics due to time

This research is supported by the National Science Foundation undergrants CPS-16446612 and CyberSEES-1539585. This work was supportedby the Laboratory Directed Research and Development (LDRD) at theNational Renewable Energy Laboratory (NREL). Corresponding authors:rhenriquez@berkeley.edu and jdlara@berkeley.edu

?Department of Electrical Engineering and Computer Sciences, Universityof California, Berkeley, United States

†Energy and Resources Group, University of California, Berkeley, UnitedStates

scale separation, likely break down with fast acting CIG [3]–[5]. To comprehend the effects of increased CIG sources onpower systems, it is critical to model diverse power sys-tems component combinations. However, research concerningthe level of modeling detail required to produce relevantconclusions is still ongoing, rendering the development andperformance of computational studies cumbersome.

Practitioners are already beginning to experience the limi-tations of existing modeling packages for systems that havesizeable CIG penetration. For instance, Electric ReliabilityCouncil of Texas (ERCOT) issued a report [6] pointing tonon-convergence and numerical instabilities under low systemstrength conditions. The report also notes the inability tomodel the specific component behavior during transients. Thiscan have a significant impact on the response of CIG, since itdoes not characterize converter misoperation from erroneousmeasurements following a disturbance [7].

This paper is rooted in the principle that large scale low iner-tia power systems require a simulation tool whose flexibilityenables researchers to quickly explore emerging challenges.It needs to be open-source so that research scholars fromall communities can access it and so that it can undergorapid research-driven evolution with the introduction of newtechnologies and as our understanding of the dynamics ofthese systems improves. Although there are several non-commercial tools available for electro-mechanical modeling inpower systems, they do not fully address the needs for opensource computing to study large-scale low inertia systems.For instance, PSAT and Matdyn are based on the commercialsoftware Matlab. The former has a version based on GNUOctave [8], [9]. However, the level of customizability inthese tools is limited: they do not feature component-levelflexibility such as the specification of composite devices likeinverters. Meanwhile, PYPOWER-Dynamics and InterPSS arenon-commercial alternatives to perform transient simulationsbased on open source programming languages [10], [11].However, they offer only basic converter models and featurestrictly algebraic network models. Finally, DOME is a Unix-supported power system simulation project written in Python,C, and Fortran which has both AC and DC devices and canmix phasor and Electromagnetic Transient (EMT) models [12].Although DOME is developed using open-source languagesand operating systems, it is not an open-source project. Thesource code is only provided to researchers upon request [13].

This paper presents the Low Inertia Transient Simulationtoolbox LITS.jl, with four key contributions:

• LITS.jl is designed to enable researchers to easilyassess the trade-off between model complexity and com-

arX

iv:2

003.

0295

7v1

[ee

ss.S

Y]

5 M

ar 2

020

2

putational requirements. This enables low-effort compar-isons of system response for different device modelsunder the same disturbance, which is not straightforwardwith existing tools.

• LITS.jl is developed in the Julia computing languageon top of the existing package DifferentialEquations.jl[14], [15]. These state of the art open-source computingtools are freely accessible to the research community, andhave multiple features to facilitate the development ofcomputational experiments.

• LITS.jl separates modeling from simulation, and canquickly scale to analyze large-scale systems by exploitingJulia’s large library of solution methods. Leveraging theselibraries enables many benefits, including substantialspeed-up on computing time.

• The modular design enables code and model reuse; thisreduces development requirements and enables fast andsimple prototyping of controls and models.

Our choice of Julia as the software development environ-ment is central to enabling many of the features of LITS.jl.Julia is a scripting language like Python and Matlab, butoffers the performance one would associate with low-levelcompiled languages. It was developed with mathematical andscientific computing in mind and has a number of powerfulfeatures that are well-suited to exploring large-scale computingexperiments. Julia’s support of multiple dispatch and compo-sition allows us to design a software and model library that iscomputationally efficient yet easy for a developer to use andextend [16]. Multiple dispatch – which we define precisely inthe following section – allows us to create generic methods formodeling power system devices; this results in a fast, feature-rich, and highly extensible modeling package. The detailedcode implementation is discussed in Section II.

The paper is structured as follows: Section II describes themodeling strategy and software architecture, as well as the im-plementation of LITS.jl. Section III showcases the differentmodels available and specifies the dynamic system. Section IVcontains simulations to highlight the features available in thesoftware. Finally, Section V outlines conclusions and futurework.

II. SOFTWARE IMPLEMENTATION

LITS.jl uses Julia data structures to define power systemdynamic devices and their corresponding components. Thecomponents are built exploiting PowerSystems.jl typehierarchy [17]. The key feature of LITS.jl design is thecapability to mix and match different component models witha small number of script modifications. The flexibility ofmodel specification enables precise control when specifyingthe complexity of each power system device.

Multiple dispatch lies at the core of Julia’s power as ascientific scripting and computing language. It enables thecompiler to determine which method to call based solely on thetypes of the argument passed into a generic function. This isa way to enable code reuse and the implementation of genericinterfaces for custom models without requiring modificationsto the main source code. For example, LITS.jl will deploy

Electrical Machine Stator Electro-Magnetic

Dynamics

N-Mass Shaft Rotor Electro-Mechanical

Dynamics

Excitation Circuit Electromotive Dynamics and

associated controls (AVR and PSS)

Prime Mover Thermo-Mechanical Dynamics and

associated Controls (Governor)

Electric Power Grid

Reference Frame Conversion

τe

τm

Pref

ωref

Vref

|Vdq|

Vri Iri

Vdq Idq

δ

Vf

ω

Fig. 1. Generator meta-model.

different order generator models by changing by detecting thesignature of arguments passed into the model function. Multi-ple dispatch is particularly useful for mathematical modelingsince methods can be defined based on abstract data structuresto enable code re-use and easy interfacing with custom models[14]. Internally, the choice of the mathematical description fora device is implemented as a function method and called basedon arguments given and their types. This approach is differentfrom traditional scripting languages, where dispatch is basedon a special argument syntax and is sometimes implied ratherthan explicitly written.

The flexibility in LITS.jl originates from the use of poly-morphism and encapsulation in the device model definition,which enables treating objects of different types similarly ifthey provide common interfaces. Generators and inverters aredefined as a composition of components; the functionalities ofthe component instances determine the device model providinga flat interface to the complex object. This design enablesthe interoperability of components within a generic devicedefinition. As a result, it is possible to implement customcomponent models and interface them with other existingmodels with minimal effort. For instance, it is possible toformulate any of the classical machine models in terms ofits components and also formulate custom machine models,as shown in the forthcoming section.

A. Data Structures

We define a meta-model to implement the generic compo-sition scheme for devices that inject current into the system.Figures 1 and 2 showcase the generator and inverter meta-model; each block corresponds to a possible component in-stance. This implementation enables the developer to focus onthe interfaces to device components that encapsulate the modelimplementation of each block independently.

3

Filter AC Voltage and Current

Dynamics

Converter

PWM DynamicsDC Source

DC-side Dynamics

Inner Loop Control Voltage Control, Current Controland Virtual Impedance Dynamics

Electric Power Grid

Reference Frame Conversion

Pref

Frequency Estimator

PLL Dynamics

Vdq Idq

IriVri

Vdq

Outer Loop Control Active and Reactive Power

Control Dynamics

δolc

Vdc

ωolc Vref

Qref

ωpll

δolc

Vdq, Idq

V refdq

δpll

V refolc Irefolc

Vdq, Idq

V cvdq , I

cvdq

Fig. 2. Inverter meta-model.

B. Generator ModelsFigure 1 depicts the proposed meta-model used in

LITS.jl to describe synchronous generators. Each generatoris defined by a machine model, an excitation circuit andassociated controls (Automatic Voltage Regulators (AVR) andPower System Stabilizers (PSS)), a shaft model, and a primemover. The generator structure is designed to share networkvoltage and current output in the device’s dq SynchronousReference Frames (SRFs) Vdq , Idq mechanical and electricaltorque τm τe, frequency ω, field voltage Vf and angle δ.

C. Inverter ModelsFigure 2 depicts the proposed meta-model. Each inverter

is defined by a filter, converter model, inner loop control(including both voltage and current controller), outer loopcontrol (including both active and reactive power controller),a frequency estimator (typically Phase-Locked-Loop (PLL)),and a DC source model.

The meta-model chosen allows a high level of complexityby including the option of modeling both grid-forming andgrid-feeding devices.

D. BranchesLITS.jl can model AC-branch in two ways: static and

dynamic. The static branch model is used to define thesystem’s admittance matrix Y and no bus voltage differentialstates are included in the dynamic model. This can be usedto model both lines and transformers. Dynamic branch modelsuse the same parameters as static branch models. However, busvoltage differential equations are included in model to accountfor the dynamic behavior of shunt capacitance currents whichare also added to the total line current balance.

Di erentialEquationsSolver

DifferentialEquations.jl

Common Interface

PowerSystems.jlData Structures

LITS.jlModels and Methods

ForwardDiff.jlSmall Signal Analysis

x

f(x)

f(x), J(x)

Fig. 3. Information flow in LITS.jl.

E. Software Architecture

Figure 3 shows the interactions between LITS.jl, Dif-ferentialEquations.jl and the integrators. The architecture ofLITS.jl is such that the power system models are allself-contained and return the model function evaluations.The Jacobian is calculated through DifferentialEquations.jl’scommon-interface enabling the use of any solver available inJulia. Considering that the resulting models are Differential-Algebraic Equations (DAE), the implementation focuses onthe use of implicit solvers, in particular SUNDIALS [18] sinceit has exceptional features applicable to large models forinstance, interfacing with distributed linear-solvers and GPUarrays.

The data model is critical to enable fast model solution timesgiven that most of the allocating computations happen beforethe simulation run-time. All the model functions in LITS.jlare implemented as in-place updating and avoid allocationsat each iteration of the integrator to reduce memory usage.In the system construction process, we generate an internalindex with the location of the states relevant to each device andachieve efficient use of memory. The information necessary forthe pre-indexing exists already in the data model. The indexis stored in a 2-level nested dictionary. The device name is thefirst level key, and the state is the second level key. As a result,whenever the function iterates over the vector containing theentire state space, only the relevant portions are accessed.

Pre-indexing and internal variable sharing enable fast andmemory-efficient evaluations of the model function and itsJacobian. In conjunction with the fact that Julia code is a Just-In-Time compiling language, LITS.jl achieves exceptionalcomputational performance with reduced software develop-ment overhead when compared to low-level languages.

At the device modeling layer, component instances sharelocal information internal to each device through port vari-ables. The port variables enable efficient information passingbetween component modeling functions.

F. Perturbations

The DifferentialEquations.jl common interface simplifiesthe implementation of perturbations such as line faults orstep changes. Through the use of callbacks into the solvers,it is possible to control the solution flow and intermediateinitializations without requiring simulation re-starts and otherheuristics typically used in power systems dynamic modeling.

4

The built-in features and the design of perturbation objects inLITS.jl to internally define callbacks in the solver allowsfurther flexibility in the type of perturbations that can beanalyzed.

G. Small Signal Analysis

In order to estimate the eigenvalues and perform Small Sig-nal Stability Analysis, the complete dynamic model containingall states from dynamic components x and algebraic variablesy is used to define g(y, x) as the vector of algebraic equationsand f(y, x, p) as the vector of differential equations of theentire system. With that, the non-linear differential algebraicsystem of equations can be written as:[

0x

]=

[g(y, x, p)f(y, x, p)

](1)

For Small Signal Stability Analysis, we are interested in thestability around an equilibrium point yeq, xeq that satisfiesx = 0 or equivalently f(yeq, xeq) = 0, while satisfyingg(yeq, xeq) = 0. To do that we use a first order approximation:[

0∆x

]=

[g(yeq, xeq)f(yeq, xeq)

]︸ ︷︷ ︸

=0

+J [yeq, xeq]

[∆y∆x

](2)

For small signal analyses, we are interested in the stabilityof the differential states, while still considering that those needto evolve in the manifold defined by the linearized algebraicequations. Note that the Jacobian matrix can be split in fourblocks depending on the specific variables we are taking thepartial derivatives:

J [yeq, xeq] =

[gy gxfy fx

](3)

Assuming that gy is not singular [19] we can eliminate thealgebraic variables to obtain the reduced Jacobian:

Jred = fx − fyg−1y gx (4)

that defines our reduced system for the differential variables

∆x = Jred∆x (5)

on which we can compute its eigenvalues to analyze localstability. To do so, LITS.jl computes the equilibrium pointyeq, xeq by solving the non-linear system of equations inequilibrium, and via automatic differentiation by using thepackage ForwardDiff.jl, it computes the Jacobian of thenon-linear algebraic system of equations at that equilibriumpoint. LITS.jl handles the resulting Jacobian and reportsthe reduced Jacobian and the corresponding eigenvalues andeigenvectors.

III. MODELS

LITS.jl is based on a standard current injection model asdefined in [19]. The numerical advantages of current injectionmodels outweigh the complexities of implementing constantpower loads for longer-term transient stability analysis. Thenetwork is defined in a SRF, named the RI (real-imaginary)

idiq

=ra −xq

xd ra

−1ed − vdeq − vq

Gen 1

Machine: Classic

Shaft: SingleMass

idiq

=ra −xd

xd ra

−1 −vdeq − vq

Pe = (vq + raiq)iq + (vd + raid)id

δ = Ωb(ω − ωs)

ω =1

2H(τm − τe −D(ω − ωs))

AVR: NoAVR

TurbineGovernor: FixedPm

PSS: NoPSS

Gen 2

Machine: One d- One q-

Shaft: SingleMass

Pe = (vq + raiq)iq + (vd + raid)id

δ = Ωb(ω − ωs)

ω =1

2H(τm − τe −D(ω − ωs))

AVR: FixedVf

TurbineGovernor: FixedPm

PSS: NoPSS

eq = (−eq − (xd − xd)id + vf )/Td0

ed = (−ed + (xq − xq)iq)/Tq0

Fig. 4. Mix and match different components for generators and theirrespective DAEs.

reference frame, rotating at the constant base frequency Ωb,while each device is modeled in its own dq SRF.LITS.jl also supports several static injection devices that

can inject or withdraw current from a bus instantaneously.This category includes loads and voltage and current sources.All other dynamic injections devices define local differentialequations for the state of each component.LITS.jl internally tracks the current-injection balances at

the nodal level from all the devices on the system. Based on thebuses and branches information, the system constructor com-putes the admittance matrix Y assuming nominal frequency,and this is used for static branch modeling. The algebraicequations for the static portions of the network are as follows:

A. Network Balance Model

LITS.jl internally tracks the current-injection balances atthe nodal level from all the devices on the system. Based on thebuses and branches information, the system constructor com-putes the admittance matrix Y assuming nominal frequencyand this is used for static branch modeling. The algebraicequations for the static portions of the network are as follows:

0 = i(x,v) − Y v (6)

where i is the vector of the sum of complex current injectionsfrom devices, x is the vector of states and v is the vectorof complex bus voltages. Equations (6) connect all the portvariables, i.e., currents, defined for each injection device.Components that contribute to (6) by modifying the currenti or the admittance matrix Y , are (i) static injection devices,(ii) dynamic injection devices, (iii) algebraic network branchesand (iv) dynamic network branches.

B. Available Generator Component Models

Currently, for synchronous generators, the software sup-ports:

• Electrical Machines: The classical model (II-ordermodel), one d- one q- axis model (IV-order model),

5

Anderson-Fouad model (VI and VIII-order model), Mar-conato model (VI and VIII-order model), and stator-rotorfluxes model are already implemented [19], [20].

• AVR: Simplified DC and AC AVR (namely Type I andType II) are already implemented [19]. In addition, fixedvoltage Vf and no-AVR, are also included.

• PSS: Models already implemented consider a simplified-PSS, namely a rotor velocity and electrical power droopfor Vf , used as an extra signal for the AVR. Type I andType II proposed in [19] are also implemented.

• Shafts: A standard 1-mass shaft (rotor mass) is im-plemented. A 5-mass shaft (modeled as a spring-masssystem) for rotor mass, high-pressure, mid-pressure, low-pressure turbines, and excitation mass, is also included[19].

• Prime movers: Type I and Type II turbine governors [19]are implemented. In addition, a fixed mechanical torqueτm is included.

Figure 4 provides an example of the modularity capabilitieswhen defining a generator model. As depicted, it is possibleto exchange generator components to study the effects ofdifferent complexity levels. In this particular case, it is possibleto exchange the generator’s machine model between the classicalgebraic representation in the two-state machine with the 2-state transient model of the 4-state machine. This flexibilityis key to studying under-explored and emerging challenges inlow-inertia systems. For example, including multi-mass shaftdynamics can be used to study torsional interaction betweengenerators and CIG power sources and their controllers, anissue that has been reported in systems with HVDC lines andFACTS [20]. In addition, it enables the analysis of controllerarchitecture upgrades to enhance the resilience of the systemas the adoption of CIG sources increases.

Details about the specific model equations and implemen-tation can be found in the documentation1.

C. Available Inverter Component Models

The modularity of the inverter meta-model, as depicted inFig. 2, allows users to easily substitute any component withcustom ones only requiring the implementation of the portvariables – for instance, a new PLL for frequency estimationor outer control loops. Component model reuse permits rapidtesting of different custom inverter configurations withoutrequiring the complete re-implementation of the rest of theinverter components. For example, the outer loop controlvirtual speed ωolc is a differential state if virtual inertia isconsidered, like in the Virtual Synchronous Machine (VSM)model. However, in an grid-feeding inverter without virtualinertia, ωolc is implemented as an algebraic state, equal to ωpllthat depends linearly on the PLL voltage states [21]. Addi-tionally, inverters can operate in either grid-feeding or grid-supporting mode individually, which enables a heterogeneousmix of devices in the system.

The current modeling capabilities include several complexconfigurations, such as VSM control using PLL-orientatedSRF as in [3], [22].

1https://energy-mac.github.io/LITS.jl/

Code Block 1 Running an OMIB case in LITS v0.3.0 in Julia 1.3# Load LITS.jl and datausing LITSusing PowerSystemsusing Sundialsusing Plotsinclude("data/network_data.jl")

### Generator Data# Machinemach = BaseMachine(0.0, #R

0.2995, #Xd_p0.7087, #eq_p100.0); #MVABase

# Shaftshaft = SingleMass(3.148, #H

2.0); #D# AVRno_avr = AVRFixed(0.0);# Turbine Governorno_tg = TGFixed(1.0); #efficiency# PSSno_pss = PSSFixed(0.0);gen = DynamicGenerator(1, #number

"OMIB_Gen", #GenNamebuses[2], # BusLocation1.0, # ω_ref1.0, # V_ref,0.5, # P_ref,0.0, # Q_ref, not used with AVRmach, # machineshaft, no_avr, no_tg, no_pss)

# Create system (MVABase = 100 MVA, nom frequency 60 Hz)sys = System(100.0, frequency = 60.0)# Add busesfor (bus in buses) add_components(sys, bus) end# Add branchesfor (br in branches) add_components(sys, br) end# Add loadsfor (load in loads) add_components(sys, load) end# Add infinite sourceadd_component!(sys, source)# Add generatoradd_component!(sys, gen)

# Run simulation. Compute faulted Ybus.Ybus_fault = Ybus(branches_faulted, buses)# Set a three phase fault (change in Ybus)Ybus_change = ThreePhaseFault(1.0, #change

Ybus_fault) #New YBustspan = (0.0, 30.0) #define time span# Run a dynamic simulation.sim = Simulation(sys, #system

tspan, #time spanYbus_change) #fault

#Obtain small signal results for initial conditionssmall_sig = small_signal_analysis(sim)# Run transient simulationrun_simulation!(sim, Sundials.IDA(), dtmax = 0.02);# Obtain resultsseries = get_state_series(sim, ("OMIB_Gen", :δ))plot(series)

• Filters: LC and LCL filters are implemented to connectthe converter with the electric grid.

• Converters: An average converter model is already im-plemented. Converter voltage output is given by vcnv =mvdc, where m is the modulation signal – an output ofthe inner loop control – and vdc is the DC voltage outputof the DC side.

• Inner-Loop Control: Output current and voltage refer-ences first pass through a virtual impedance block andthen through cascaded PI controllers, implemented in thesynchronous reference frame of the inverter. This controlimplementation ultimately provides the dq modulationcommands to the converter model.

6

0 2 4 6 8 10 12 14 16 18 200.6

0.61

0.62

0.63

0.64

0.65

0.66

PSAT 8th-order: δ2(t)

PSAT 6th-order: δ2(t)

PSAT 4th-order: δ2(t)

LITS.jl 4th-order: δ2(t)

LITS.jl 6th-order: δ2(t)

LITS.jl 8th-order: δ2(t)

Time [s]

Rot

or a

ngl

e [rad

]

Fig. 5. Rotor angle δ2(t) evolution for different machine models in Case 1.

• Outer-Loop Control: We implement a decoupled activepower controller and reactive power controller. The ac-tive power controller emulates a synchronous machinewith an inertia constant, damping term, and frequencydroop. The reactive power controller is implemented asa proportional voltage droop controller [22].

• Frequency Estimator: A PLL is implemented to estimatethe grid frequency based on the bus voltages using themodel presented in [22].

• DC source: Currently the model supports any DC voltagesource. However, the only available implementation is afixed DC source voltage.

D. Branch models

Each dynamic branch will add three differential equationsas follows:

L

Ωb

di`dt

= (vfrom − vto) − (R+ jL)i` (7)

Cfrom

Ωb

dvfrom

dt= ifrom

c − jCfromvfrom (8)

Cto

Ωb

dvto

dt= itoc − jCtovto (9)

where i` is the complex current going through the RL circuitand ic is the current injected due to the line shunt susceptanceincluded in the Π-line model.

IV. SIMULATIONS

Case studies and benchmarks are presented to showcase thecapabilities of LITS.jl and validation of the implementedmodels. The first case study focus on synchronous generatormodeling and compare the simulations to PSAT [8]. The sec-ond case compares the inverter model with published resultsin [22]. The third case showcase the effects of consideringmulti-mass shaft models. Finally, the fourth case analyzes theinteraction between a synchronous machine and an inverter in

0 0.5 1 1.5 2 2.5 3 3.5 40.9998

1

1.0002

1.0004

1.0006

1.0008

1.001

ωvsm(t)

Time [s]

Virtu

al r

otor

spee

d [pu]

Fig. 6. Virtual rotor speed ωvsm(t) evolution for VSM in Case 2.

a 3-bus system. The last case also highlight the capabilities ofthe proposed software to model dynamic branches selectively.

The simulations cases use the implicit solver IDA fromthe suite SUNDIALS [18], which is available in the Juliaenvironment.

A. Running a case

LITS.jl is a registered Julia package. To install, using theJulia REPL: ] add LITS. The source code can be found inthe repository2 where the master branch contains the latestdevelopment code. Code Block 1 describes a basic simulationrun using LITS.jl of a 2-state machine against infinite bus.This case is available in the Github repository of LITS.jlexamples.

B. Case 1: 3 buses – Two generators against infinite bus

The first case study analyzes a triangular 3-bus system. Atbus 1, a voltage source is connected as an infinite bus. Singleshaft machines are connected in buses 2 and 3. Each machinehas an AVR Type I (simplified IEEE DC AVR model). Thebus loads are 1.5 in buses 1 and 2 and 0.5 MW in bus 3.The simulation is developed to analyze the behavior of severalmachine electromagnetic models. In this particular case, weanalyze the following

1) One d- One q- (4th order machine).2) Simplified Marconato model (6th order machine).3) Full Marconato model (8th order machine) [23].The results show a line trip perturbation triggered at t = 1s.

Figure 5 shows the evolution of rotor angle of the synchronousgenerator connected at bus 2. Results show that the responsesbetween PSAT and LITS.jl are equivalent with acceptabledifferences in the range of numeric tolerances.

C. Case 2: VSM against infinite bus

The second case study is used to validate the transientbehavior of a 19-states VSM inverter connected against an

2https://github.com/Energy-MAC/LITS.jl

7

1 1.5 2 2.5 3 3.5 40.99998

1

1.00002

1.00004

1.00006

1.00008

1.0001

1.00012

Time [s]

Rot

or s

pee

d [pu]

Single Shaft: ω(t)Five-Mass Shaft: ω(t)

Fig. 7. Rotor speed ω(t) evolution for different shaft models in Case 3.

infinite bus with the same setting as in [22]. A step changein the power from 0.5 pu to 0.7 pu is introduced at t = 1.Figure 6 depicts the effect on the VSM angular speed due tothe step change. Results show a consistent transient behaviorthat is showcased in Figure 9 in [22].

D. Case 3: Multi-mass shaft modeling

Our third case uses the same system as in Case 1 with aOne d- one q- (4th order) machine in Bus 2 and replacingthe single-mass shaft model for a five-mass spring dynamicsmodel. This is directly implemented in LITS.jl by modify-ing the generator shaft of the generator structure. Similar toCase 1, at t = 1s, the line that connects buses 1 and 3 trips.Figure 7 depicts the effect on rotor speed ω(t) of includingspring dynamics at the shaft between mass elements. Due tothe presence of the infinite bus and power flow reconfiguration,rotor speed remains close to the nominal frequency, but fasteroscillations can be observed in the five-mass shaft due to theadditional second order dynamics.

E. Case 4: VSM against synchronous machine consideringdynamic lines

The fourth case is also based on the same system as Casewith One d- one q- (4th order) machine in Bus 2 and a VSMinverter connected in bus 3. The model also considers differentline models connecting bus 2 and 3, first an algebraic one,while on a second scenario we use a dynamic line model.All remaining lines are modeled as algebraic ones in bothscenarios. This is done in LITS.jl by simply selecting whichdata types of lines are static or dynamic.

At t = 1, two of the three circuits of the line that connectsbuses 1 and 3 trip. Figure 8 illustrates the evolution ofthe voltage magnitude at bus 2. As depicted, line dynamicsallow us to model a fast behavior that is not reflected in thestatic lines simulation case that have effects on the transientresponse of different devices. As mentioned before, a key

0 5 10 15 20 25 30

1.006

1.008

1.01

1.012

1.014

1.016

1.018

1.02

1.022

1.024

1.026

1.1 1.2 1.3 1.4 1.5

1.012

1.014

1.016

1.018

1.02

1.022

1.024

1.026

Vol

tage

mag

nitude

[pu]

1.0

Time [s]

Algebraic Lines: |V2(t)|Dynamic Lines: |V2(t)|

Fig. 8. Voltage magnitude |V2(t)| at bus 2, for Case 4.

motivation for building LITS.jl is to enable this trade-offbetween model complexity and computational requirements.More complex models, such as ones including line dynamics,showcase faster behavior, but lead to increasingly stiff systems,longer computational times, and susceptibility to numericalinstabilities under default solver parameters.

V. CONCLUSIONS

This paper introduced the open-source simulation toolboxLITS.jl, which focuses on transient simulation of low-inertia power systems. LITS.jl is built on Julia scripting lan-guage and incorporates a myriad of power system devices andcomponent models. LITS.jl enables the analysis of transientresponses of dynamical systems using different model com-plexity. The development of device meta-models for generatorsand inverters standardize ports and states interaction amongdevices and their internal components. The proposed softwaredesign enables researchers to define a new component’s modelwithin the proposed meta-model and quickly explore novelarchitectures and controls.

We presented several numerical experiments and bench-marks to highlight the capabilities of LITS.jl and thevalidity of the models included in the library. Case studiesshow that LITS.jl enables easier assessment of the trade-offbetween model complexity and computational requirements byexchanging device models and comparing simulation resultsunder different assumptions.

The ongoing development of LITS.jl focuses on ex-tending the available models and analytical capabilities. Thisincludes reduced-order inverter models, FACTS device mod-els, and HVDC and DC-side dynamics of inverters. Finally,incorporating numerical Jacobian calculations capabilities forsmall-signal analysis is a future task in this project.

8

REFERENCES

[1] F. Milano, F. Dorfler, G. Hug, D. J. Hill, and G. Verbic, “Foundations andchallenges of low-inertia systems,” in 2018 Power Systems ComputationConference (PSCC). IEEE, 2018, pp. 1–25.

[2] A. Ulbig, T. S. Borsche, and G. Andersson, “Impact of low rotationalinertia on power system stability and operation,” IFAC ProceedingsVolumes, vol. 47, no. 3, pp. 7290–7297, 2014.

[3] U. Markovic, J. Vorwerk, P. Aristidou, and G. Hug, “Stability analysisof converter control modes in low-inertia power systems,” in 2018 IEEEPES Innovative Smart Grid Technologies Conference Europe (ISGT-Europe). IEEE, 2018, pp. 1–6.

[4] D. Groß, M. Colombino, J.-S. Brouillon, and F. Dorfler, “The effect oftransmission-line dynamics on grid-forming dispatchable virtual oscilla-tor control,” IEEE Transactions on Control of Network Systems, 2019.

[5] “IEEE guide for synchronous generator modeling practices and applica-tions in power system stability analyses,” IEEE Std 1110-2002 (Revisionof IEEE Std 1110-1991), 2003.

[6] E. Rehman, M. Miller, J. Schmall, and S. H. F. Huang, “Dynamicstability assessment of high penetration of renewable generation in theercot grid,” ERCOT, Tech. Rep., 04 2018, version 1.0.

[7] NERC, “1,200 mw fault induced solar photovoltaic resource interruptiondisturbance report,” Tech. Rep., 06 2017, version 1.1.

[8] F. Milano, “An open source power system analysis toolbox,” IEEETransactions on Power systems, vol. 20, no. 3, pp. 1199–1206, 2005.

[9] S. Cole and R. Belmans, “Matdyn, a new matlab-based toolbox forpower system dynamic simulation,” IEEE Transactions on Power sys-tems, vol. 26, no. 3, pp. 1129–1136, 2010.

[10] J. Susanto, “GitHub repository for susantoj/PYPOWER-Dynamics,”GitHub, May, 2018.

[11] M. Zhou and Q. Huang, “Interpss: A new generation power systemsimulation engine,” arXiv preprint arXiv:1711.10875, 2017.

[12] F. Milano, “A python-based software tool for power system analysis,”in 2013 IEEE Power & Energy Society General Meeting. IEEE, 2013,pp. 1–5.

[13] “DOME,” http://faraday1.ucd.ie/dome.html, accessed: 2019-09-22.[14] J. Bezanson, A. Edelman, S. Karpinski, and V. B. Shah, “Julia: A fresh

approach to numerical computing,” SIAM review, vol. 59, no. 1, pp.65–98, 2017.

[15] C. Rackauckas and Q. Nie, “Differentialequations.jl – a performantand feature-rich ecosystem for solving differential equations in Julia,”Journal of Open Research Software, vol. 5, no. 1, 2017.

[16] “Methods: The Julia Language,” https://docs.julialang.org/en/v1/manual/-methods/, accessed: 2019-09-25.

[17] J. D. Lara, D. Krishnamurthy, and C. Barrows, “PowerSystems.jl andPowerSimulations.jl,” 2018. [Online]. Available: https://www.osti.gov//servlets/purl/1484014

[18] A. C. Hindmarsh, P. N. Brown, K. E. Grant, S. L. Lee, R. Serban, D. E.Shumaker, and C. S. Woodward, “SUNDIALS: Suite of nonlinear anddifferential algebraic equation solvers,” ACM Transactions on Mathe-matical Software (TOMS), vol. 31, no. 3, pp. 363–396, 2005.

[19] F. Milano, Power system modelling and scripting. Springer Science &Business Media, 2010.

[20] P. Kundur, N. J. Balu, and M. G. Lauby, Power system stability andcontrol. McGraw-hill New York, 1994, vol. 7.

[21] Y. Lin, B. Johnson, V. Gevorgian, V. Purba, and S. Dhople, “Stabilityassessment of a system comprising a single machine and inverter withscalable ratings,” in 2017 North American Power Symposium (NAPS).IEEE, 2017, pp. 1–6.

[22] S. D’Arco, J. A. Suul, and O. B. Fosso, “A virtual synchronousmachine implementation for distributed control of power converters insmartgrids,” Electric Power Systems Research, vol. 122, pp. 180 – 197,2015.

[23] R. Marconato, Electric power systems. CEI - Italian ElectotechnicalCommittee, 2002.