Revision history  [back]

Running a short circuit analysis and getting the results back can be difficult with the PSSE API. The documentation doesn't have any examples, and the API is a bit confusing. Here is how to do it:

ASCC_CURRENTS

ascc_currents in the pssarrays module will run the short circuit analysis and return the results in a custom made Python type that PSSE refers to as rlst.

# this script assumes you have already initalised PSSE and loaded a saved case.
import pssarrays

# create a subsystem of buses you will apply the fault to.
DOWNTOWN_SID = 1
psspy.bsys(sid=DOWNTOWN_SID, numbus=2, buses=[2001, 2002])

results = pssarrays.ascc_currents(sid=DOWNTOWN_SID,
                                  all=0,
                                  fltlg=1, # report on line to ground faults.
                                  flat=0) # use prefault voltage from working case

This code will run a line to ground fault on two buses 2001 and 2002 and store the result in the scfilename file. We don't use flat start conditions, so the pre-fault voltage is the same as the one in the solved case.

Lets unpack the results variable to see what is inside:

# get the phase A current for this line to ground fault
phase_a = [i.ia for i in results.fltlg]
# and match the phase currents up against the faulted buses
fault_currents = zip(results.fltbus, phase_a)
print fault_currents

That final print statement should show something like this:

[(2001, (30.4 + 12.j) ),
 (2002, (30.1 + 11j) ]

And now to answer your question

You asked about how to find the _maximum_. There are a number of things that contribute to a maximum fault level:
  1. Prefault voltage (higher voltages have higher fault currents)
  2. All generation connected (each generator contributes to fault current)
  3. Buses at terminal stations are tied (will increase the fault current if the fault is downstream of the bus tie)

There are a few other things to watch for that will increase your fault currents unrealistically. If you model your SVC units as a synchronous condensor (like we do) then you need to replace it with an equivalent capacitor bank. SVC units behave like a capacitor during short circuits, not like a spinning machine.

Warning

I don't have a copy of PSSE here with me (and I wont for a few months). You should check that the code to get `phase_a` works. Let me know if it doesn't so I can update the answer with working code!

Running a short circuit analysis and getting the results back can be is difficult with the PSSE API. The documentation doesn't have any examples, and the API It is a bit confusing. one of the most difficult things to do. Here is how to do it:

ASCC_CURRENTS

ascc_currents in the pssarrays module will run the short circuit analysis and return the results in a custom made Python type that PSSE refers to as rlst.

import pssarrays

# this script assumescreate a subsystem of buses you have already initalised PSSE and loaded a savedwill apply the fault case.
import pssarrays

# create a subsystem of buses you will apply the fault to.
DOWNTOWN_SID = 1
psspy.bsys(sid=DOWNTOWN_SID, numbus=2, buses=[=[2001, 2002])])

results = pssarrays.ascc_currents(sid=DOWNTOWN_SID,
                                  all=0,
                                  fltlg=1, # report on line to ground faults.
                                  flat=0) # use prefault voltage from working case

This code will run a line to ground fault on two buses 2001 and 2002 and store the result in the scfilename file. We don't use flat start conditions, so the pre-fault voltage is the same as the one in the solved case.

Lets unpack the results variable to see what is inside:

# get the phase A current for this line to ground fault
phase_a = [i.ia for i in results.fltlg]
# and match the phase currents up against the faulted buses
fault_currents = zip(results.fltbus, phase_a)
print fault_currents

That final print statement should show something like this:

[(2001, (30.4 + 12.j) ),
 (2002, (30.1 + 11j) ]

And now to answer your question

You asked about how to find the _maximum_. There are a number of things that contribute to a maximum fault level:
  1. Prefault voltage (higher voltages have higher fault currents)
  2. All generation connected (each generator contributes to fault current)
  3. Buses at terminal stations are tied (will increase the fault current if the fault is downstream of the bus tie)

There are a few other things to watch for that will increase your fault currents unrealistically. If you model your SVC units as a synchronous condensor (like we do) then you need to replace it with an equivalent capacitor bank. SVC units behave like a capacitor during short circuits, not like a spinning machine.

Warning

I don't have a copy of PSSE here with me (and I wont for a few months). You should check that the code to get `phase_a` works. Let me know if it doesn't so I can update the answer with working code!

Running a short circuit analysis is difficult with the PSSE API. It is one of the most difficult things to do. Here is how to do it:

ASCC_CURRENTS

ascc_currents in the pssarrays module will

  1. Use the ascc_2 API to run the short circuit analysis and return store the results in to a custom made results (.sc) file
  2. Read the result into Python type that PSSE refers to as rlst.from the .sc file with the pssarrays.ascc_currents

ASCC_2

import pssarrays

# create a subsystem of buses you will apply the fault to.
DOWNTOWN_SID = 1
scfilename = "kolkata-fault.sc"
psspy.bsys(sid=DOWNTOWN_SID, numbus=2, buses=[=[2001, 2002])

results = pssarrays])
ierr = psspy.ascc_currentsascc_2(sid=DOWNTOWN_SID,
                                  all=0,
                                  fltlg # only process buses inside DOWNTOWN_SID
                    status1=1, # report onsingle line to ground faultsfault.
                                  flat=0scfile=scfilename) # use prefault voltage from working case

This code will run a line to ground fault on two buses 2001 and 2002 and store the result in the scfilename file. We don't use flat start conditions, so the pre-fault voltage is the same as the one in the solved case.

Lets unpack the ASCC_CURRENTS

ascc_currents in the pssarrays module will return the short circuit results variable to see what is inside:as Python data that we can use.

# get the phase A current for this line to ground fault
phase_a = [i.ia for i in results.fltlg]
# and match the phase currents up against the faulted buses
fault_currents = zip(results.fltbus, phase_a)
print fault_currentsimport pssarrays
results = pssarrays.ascc_currents(sid=DOWNTOWN_SID, 

That final print statement should show something like this:

[(2001, (30.4 + 12.j) ),
 (2002, (30.1 + 11j) ]

And now to answer your question

You asked about how to find the _maximum_. There are a number of things that contribute to a maximum fault level:
  1. Prefault voltage (higher voltages have higher fault currents)
  2. All generation connected (each generator contributes to fault current)
  3. Buses at terminal stations are tied (will increase the fault current if the fault is downstream of the bus tie)

There are a few other things to watch for that will increase your fault currents unrealistically. If you model your SVC units as a synchronous condensor (like we do) then you need to replace it with an equivalent capacitor bank. SVC units behave like a capacitor during short circuits, not like a spinning machine.

Warning

I don't have a copy of PSSE here with me (and I wont for a few months). You should check that the code to get `phase_a` works. Let me know if it doesn't so I can update the answer with working code!