def get_results(_name):
results1 = read_voltages(ONSS_HV)
results2 = read_voltages(ONSS_LV)
results3 = read_voltages(ONSRE_HDD_6)
results4 = read_voltages(ONSRE_HDD_5)
results5 = read_voltages(ONSRE_HDD_4)
results6 = read_voltages(ONSRE_HDD_3)
results7 = read_voltages(ONSRE_HDD_2)
results8 = read_voltages(ONSRE_HDD_1)
results9 = read_voltages(CNCRT_DB)
results10 = read_voltages(LNDFAL_HDD)
results11 = read_voltages(SEABED)
results12 = read_voltages(OFSS_HV)
results13 = read_voltages(OFSS_LV)
res_66kV = read_voltages(ToBus)
res_WT = read_voltages(WT_bus)
Pstat, Qstat = read_mach_output(ONSS1_HV, r"1")
q_wt = read_mach_Q(WT_bus)
Converged = psspy.solved()
results = [_name]
results.append(max_voltages(results1))
results.append(min(results1))
results.append(max_voltages(results2))
results.append(min(results2))
results.append(max_voltages(results3))
results.append(min(results3))
results.append(max_voltages(results4))
results.append(min(results4))
results.append(max_voltages(results5))
results.append(min(results5))
results.append(max_voltages(results6))
results.append(min(results6))
results.append(max_voltages(results7))
results.append(min(results7))
results.append(max_voltages(results8))
results.append(min(results8))
results.append(max_voltages(results9))
results.append(min(results9))
results.append(max_voltages(results10))
results.append(min(results10))
results.append(max_voltages(results11))
results.append(min(results11))
results.append(max_voltages(results12))
results.append(min(results12))
results.append(max_voltages(results13))
results.append(min(results13))
results.append(max_voltages(res_66kV))
results.append(min(res_66kV))
results.append(max_voltages(res_WT))
results.append(min(res_WT))
results.append(max_q(q_wt))
results.append(min(q_wt))
results.append(Qstat)
results.append(Converged)
result_dict[k] = results
def get_mvar(i):
"""
Changes the voltage set point at the synchronous machine
solves the case
returns the the new reactive power output of the sync machine.
"""
psspy.plant_data(busno, realar1=i)
ierr = psspy.fnsl()
val = psspy.solved()
if val == 0:
ierr, mvar = psspy.macdat(busno, str(genid), 'Q')
return mvar
else:
return None
def reduceModel(zonebuses):
# Reduce the model
psspy.bsys(sid=1, numbus=len(zonebuses), buses=zonebuses)
psspy.gnet(sid=1, all=0)
psspy.island()
psspy.fdns(options=[1, 0, 1, 1, 1, 0, 0, 0])
psspy.eeqv(sid=1, all=0, status=[0, 0, 0, 0, 1, 0], dval1=0)
psspy.island()
ierr = psspy.fdns(options=[1, 0, 1, 1, 1, 0, 0, 0])
ival = psspy.solved()
reducedModelName = "reduced"
print "ival equal to "
print ival
if ival == 0:
psspy.save(reducedModelName)
else:
return None
return reducedModelName
change_load(load_bus_region[1], load_change_region2)
change_load(load_bus_region[2], load_change_region3)
change_gen(gen_bus_region[0], loadIncrement_region1)
change_gen(gen_bus_region[1], loadIncrement_region2)
change_gen(gen_bus_region[2], loadIncrement_region3)
savecase = 'ieee118bus_divided_temp.sav'
psspy.save(savecase)
# secure or not
psspy.case(savecase)
psspy.fnsl()
# check convergency
N = psspy.solved()
[bus_voltage, bus_angle] = powerlib.getMeasurements(response_buses)
# check voltage violation
if N == 0:
# get bus measurements number
[bus_voltage,
bus_angle] = powerlib.getMeasurements(response_buses)
voltage_violation = 0
for vol_index in range(0, len(bus_voltage)):
if bus_voltage[vol_index] <= 0.844:
voltage_violation = 1
violation_index = vol_index
if voltage_violation == 1:
secure.append(2)
ReactivePowerDifference = abs(fromflow[0].imag - fromflow[1].imag)
RealPowerDifference = abs(fromflow[0].real - fromflow[1].real)
# Scale up the load at certain percentage
change_load(ScaleLoadAtBuses,percentage)
load = aloadreal(0,1,'TOTALACT')
load = load[0]
## #switch off the capbank
## for shunt_bus_num in shunt_bus:
## switchOffCap(shunt_bus_num)
# run load flow
psspy.fdns()
N = psspy.solved()
if N == 0:
# measure the voltage at each bus
psspy.bsys(sid = 1,numbus = len(bus_num), buses = bus_num)
ierr,bus_voltage = psspy.abusreal(1,1,['PU'])
bus_voltage = bus_voltage[0]
psspy.save(savecase)
else:
print '### system collapses ###'
#endregion
# Import PSS/E default
_i = psspy.getdefaultint()
_f = psspy.getdefaultreal()
_s = psspy.getdefaultchar()
redirect.psse2py()
# -------------------------------------------------- #
# initiate
psspy.psseinit(2000) # 2000 bus at most, this number can be changed
# Load and solve the powerflow case
psspy.case(sav_case)
# configure the solver
psspy.fnsl(options1=0, options5=0)
# sikve the power flow case
iVal = psspy.solved()
if iVal == 0:
print "Met convergence tolerance"
elif iVal == 1:
print "The iteration limit exceeded"
elif iVal > 1:
print "Blown up or others"
# ------------------------------------------------- #
# Dynamic Simulation
# Convert gen & load
# convert generators
ierr = psspy.cong(0)
# convert load
for i in [1, 2, 3]:
#Outage column to report
outage_column = ["Outage"] + [outage[0]] * (len(columns[0]) - 1)
columns.extend([outage_column])
#Contingency column to report
contingency_column = ["N-1"] + [contingency[0]] * (len(columns[0]) - 1)
columns.extend([contingency_column])
#Debug, get solution state
solution_state = psspy.solved()
#print solution_state, contingency #Debug, prints solution state
solution_state_column = [
"Solved"
] + [solution_states[solution_state]] * (len(columns[0]) - 1)
columns.extend([solution_state_column])
#Line flows when areas are scaled
for area in areas:
gen_scale(1, area[1]) #Change generation in Area by +1MW
for j in range(len(toBusList)):
if i == j:
continue
fromBus2 = fromBusList[j]
toBus2 = toBusList[j]
cktID2 = cktIDList[j].strip("'").strip()
branch1ID = str(fromBus1) + ',' + str(toBus1) + ',' + cktID1
branch2ID = str(fromBus2) + ',' + str(toBus2) + ',' + cktID2
# read the original raw file and try to solve power flow
ierr = psspy.read(0, settings['filename'])
ierr = psspy.branch_chng(
fromBus1, toBus1, cktID1, [0, _i, _i, _i, _i, _i],
[_f, _f, _f, _f, _f, _f, _f, _f, _f, _f, _f, _f, _f, _f, _f
]) # disconnect branch 1
ierr = psspy.branch_chng(
fromBus2, toBus2, cktID2, [0, _i, _i, _i, _i, _i],
[_f, _f, _f, _f, _f, _f, _f, _f, _f, _f, _f, _f, _f, _f, _f
]) # disconnect branch 2
ierr = psspy.fnsl(settings['pf_options'])
converge = psspy.solved()
if converge != 9:
string = branch1ID + ';' + branch2ID
nonIslandEvents.append(string)
with open('OKDoubleBranchOutages.txt', 'w') as f:
for line in nonIslandEvents:
f.write(line)
f.write('\n')
'1',
realar1=sheet.cell(row=i, column=4).value,
realar2=0.01 * sheet.cell(row=i, column=4).value)
psspy.load_chng_4(5,
'1',
realar1=sheet.cell(row=i, column=5).value,
realar2=0.01 * sheet.cell(row=i, column=5).value)
print('Changes completed...')
psspy.rawd_2(
0, 1, [0, 0, 1, 0, 0, 0, 0], 0,
"Snap_before_PF.raw") #save the raw file to convert to CIM
b = 'h' + str(i - 2) + '_before_PF.raw'
os.rename("Snap_before_PF.raw", b)
psspy.fnsl([1, 0, 0, 0, 0, 0, 0, 0]) #solve the power flow
ival = psspy.solved() #flag to check power flow convergence
if ival == 0:
print('Convergence')
sheet.cell(row=i, column=7).value = 'Convergence'
psspy.save('temp.sav') #save temporarily the solved case
psspy.case('temp.sav') #set the saved case as current case
psspy.rawd_2(
0, 1, [0, 0, 1, 0, 0, 0, 0], 0,
"Snap_after_PF.raw") #save the raw file to convert to CIM
b = 'h' + str((i - 2)) + '_after_PF.raw'
os.rename("Snap_after_PF.raw", b)
else:
print('No convergence')
sheet.cell(row=i, column=7).value = 'Non-convergence'
psspy.close_powerflow()
def update_raw_files(self, to_excel=True, out_dir=None):
"""Function for updating the psse case file.
Args:
to_excel(default=True): If a summary should be written to excel
out_dir: The directory where the results are stored
"""
if not out_dir:
out_dir = os.getcwd()
redirect.psse2py()
psspy.throwPsseExceptions = True
nbuses = 50000 # max no of buses
ierr = psspy.psseinit(nbuses)
psspy.case(self.basecase)
if to_excel:
self.create_excel_sheet()
self.to_excel = True
else:
self.sheet = None
for i, col in zip(range(0, 24), range(2, 2 + 24 * 3, 3)):
# Represent HVDC links as load and some other exchanges as well
print('Changing additional loads...')
row = 15
for load in self.ex_as_load:
self.load_change(load, i, to_excel, row, col)
row = row + 1
print('Changing interarea exchanges...')
row = 3
for area, info in self.area_info.items():
country = area[0:2]
# Changing interarea exchanges
exchange = self.calculate_exchange(info, area, i)
self.area_data(info.number, info.bus, exchange, area, row,
col + 2)
# Changing areas production and consumption
self.change_prod_con(info.number,
self.data[country]["PS"][area][i],
self.data[country]["FB"][area][i],
info.pf,
tol=4,
row=row,
column=col)
row = row + 1
print('Changes completed...')
# Save the raw file to convert to CIM
psspy.rawd_2(0, 1, [0, 0, 1, 0, 0, 0, 0], 0, "Snap_before_PF.raw")
b = os.path.join(out_dir, 'h' + str(
(col - 1) / 3) + '_before_PF.raw')
os.rename("Snap_before_PF.raw", b)
# Solve the power flow
psspy.fnsl([1, 2, 0, 0, 1, 0, 0, 0])
ival = psspy.solved() # flag to check power flow convergence
if ival == 0:
print('Convergence')
if self.to_excel:
self.sheet.cell(row=42, column=col).value = 'Convergence'
temp_fname = os.path.join(out_dir, "temp.sav")
print(temp_fname)
psspy.save(temp_fname) # save temporarily the solved case
psspy.case(temp_fname) # set the saved case as current case
# save the raw file to convert to CIM
raw_fname = os.path.join(out_dir, "Snap_after_PF.raw")
psspy.rawd_2(0, 1, [0, 0, 1, 0, 0, 0, 0], 0, raw_fname)
b = os.path.join(out_dir, 'h' + str(i) + '_after_PF.raw')
os.rename(raw_fname, b)
if self.to_excel:
# Merge cells
self.sheet.merge_cells(start_row=1,
start_column=col,
end_row=1,
end_column=col + 2)
self.sheet.cell(
row=2,
column=col).alignment = (Alignment(wrapText=True))
self.sheet.cell(row=2, column=col +
1).alignment = (Alignment(wrapText=True))
self.sheet.cell(row=2, column=col +
2).alignment = (Alignment(wrapText=True))
self.sheet.cell(
row=14,
column=col).alignment = (Alignment(wrapText=True))
self.sheet.cell(row=14, column=col +
1).alignment = (Alignment(wrapText=True))
self.sheet.cell(
row=30,
column=col).alignment = (Alignment(wrapText=True))
self.sheet.cell(row=30, column=col +
1).alignment = (Alignment(wrapText=True))
# Headers for data from nordpool
self.sheet.cell(row=1,
column=col).value = ('hour ' + str(i))
self.sheet.cell(
row=2,
column=col).value = ('Scheduled\nProduction\n[MWh]')
self.sheet.cell(
row=2, column=col +
1).value = ('Scheduled\nConsumption\n[MWh]')
self.sheet.cell(row=2, column=col +
2).value = ('Scheduled\nExchange\n[MWh]')
# Headers for exchanges represented as loads
self.sheet.cell(row=14,
column=col).value = ('Active Power\n[MW]')
self.sheet.cell(row=14, column=col +
1).value = ('Reactive Power\n[MW]')
# Headers for results after PSS/E
self.sheet.cell(
row=30, column=col).value = ('PSSE\nProduction\n[MWh]')
self.sheet.cell(row=30, column=col +
1).value = ('PSSE\nConsumption\n[MWh]')
self.sheet.cell(row=30, column=col +
2).value = ('PSSE\nExchange\n[MWh]')
row = 31
for _, info in self.area_info.items():
# to get the area production complex power
ierr = psspy.ardat(info.number, 'GEN')
self.sheet.cell(row=row, column=col).value = (round(
ierr[1].real, 0))
# to get the area consumption complex power
ierr = psspy.ardat(info.number, 'LOAD')
self.sheet.cell(row=row,
column=col + 1).value = (round(
ierr[1].real, 0))
row += 1
# to get the value of the areas active power interchange
ierr, intch = psspy.aareareal(-1, 1, 'PINT')
for r in range(0, len(intch[0])):
self.sheet.cell(row=31 + r,
column=col + 2).value = round(
intch[0][r].real, 0)
# limits check
ierr, busvoltages = psspy.abusreal(sid=-1, string="PU")
if any(x < 0.95 or x > 1.05 for x in busvoltages[0]):
self.sheet.cell(
row=43, column=col).value = ('Bus voltage problem')
ierr, machPGen = psspy.amachreal(sid=-1, string="PGEN")
ierr, machPMax = psspy.amachreal(sid=-1, string="PMAX")
ierr, machPMin = psspy.amachreal(sid=-1, string="PMIN")
ierr, machQGen = psspy.amachreal(sid=-1, string="QGEN")
ierr, machQMax = psspy.amachreal(sid=-1, string="QMAX")
ierr, machQMin = psspy.amachreal(sid=-1, string="QMIN")
ierr, machS = psspy.amachreal(sid=-1, string="MVA")
ierr, machMbase = psspy.amachreal(sid=-1, string="MBASE")
for l in range(0, len(machPGen[0])):
if (machPGen[0][l] <= machPMin[0][l]
or machPGen[0][l] >= machPMax[0][l]):
self.sheet.cell(row=45, column=col).value = (
'Generator active power output problem')
for m in range(0, len(machQGen[0])):
if (machQGen[0][m] <= machQMin[0][m]
or machQGen[0][m] >= machQMax[0][m]):
self.sheet.cell(row=46, column=col).value = (
'Generator reactive power output problem')
break
for n in range(0, len(machS[0])):
if machS[0][n] >= machMbase[0][n]:
self.sheet.cell(row=47, column=col).value = (
'Generator overloading problem')
break
ierr, brflowA = psspy.aflowreal(sid=-1, string="PCTCORPRATEA")
if any(x >= 100 for x in brflowA[0]):
self.sheet.cell(row=48, column=col).value = (
'Branch overloading problem (Rate A)')
ierr, brflowB = psspy.aflowreal(sid=-1, string="PCTCORPRATEB")
if any(x >= 100 for x in brflowB[0]):
self.sheet.cell(row=48, column=col).value = (
'Branch overloading problem (Rate B)')
ierr, brflowC = psspy.aflowreal(sid=-1, string="PCTCORPRATEC")
if any(x >= 100 for x in brflowC[0]):
self.sheet.cell(row=48, column=col).value = (
'Branch overloading problem (Rate C)')
else:
print('No convergence')
self.sheet.cell(row=43, column=col).value = 'No convergence'
psspy.close_powerflow()
# save the Excel file with all data
self.wb.save(os.path.join(out_dir, 'PSSE_in_out.xlsx'))
os.remove(temp_fname)
def changeLoad(raw, start, end, step, newdir):
"""
New raw files are created for each percentage step in [start,end].
The current step defines the percentage scaling up (or down) factor for load and generation
"""
# convert the raw file to another one where all the load is constant power
raw_conp = raw.replace('.raw', '') + '_conp.raw'
redirect.psse2py()
psspy.psseinit(buses=80000)
# ignore the output
psspy.report_output(6, '', [0, 0])
psspy.progress_output(6, '', [0, 0])
psspy.alert_output(6, '', [0, 0])
psspy.prompt_output(6, '', [0, 0])
# read the raw file and convert all the loads to constant power
ierr = psspy.read(0, raw)
# multi-line command to convert the loads to 100% constant power
psspy.conl(0, 1, 1, [1, 0], [0.0, 0.0, 0.0, 0.0])
psspy.conl(0, 1, 2, [1, 0], [0.0, 0.0, 0.0, 0.0])
psspy.conl(0, 1, 3, [1, 0], [0.0, 0.0, 0.0, 0.0])
ierr = psspy.rawd_2(0, 1, [1, 1, 1, 0, 0, 0, 0], 0, raw_conp)
# run change Load on the constant power load raw file
rawBusDataDict = getBusData(raw_conp)
# create a new directory to put the files in
currentdir = os.getcwd()
if not os.path.exists(newdir):
os.mkdir(newdir)
output_dir = currentdir + '/' + newdir
#genDiscount = 0.90 # ratio of the actual increase in generation
genDiscount = 1.0
lossRatio = 0.0 # gen scale-up factor: (scalePercent + (scalePercent-100)*lossRatio)/100
############################################
# create new raw files with scaled up loads and generation
for scalePercent in range(start, end + step, step):
scalePercent = float(
scalePercent) # float is needed, otherwise 101/100 returns 1
scalePercentInt = int(
scalePercent) # integer value needed to append to filename
scalePercentStr = str(scalePercentInt)
# variables to store load data
loadBusList = [] # list of load buses (string)
loadPList = [] # list of Pload values (string)
loadQList = [] # list of Qload values (string)
loadPListInt = [] # list of Pload values (float)
loadQListInt = [] # list of Qload values (float)
#loadBusListInt = [] # list of load buses (int)
# variables to store gen data
genBusList = []
#genBusListInt = []
genPList = []
genMVAList = []
genMVAListInt = []
genPListInt = []
raw_name = raw_conp.replace('.raw', '')
out_file = raw_name + scalePercentStr + '.raw' # output file
out_path = output_dir + '/' + out_file
impLoadBuses = [
] # enter specified load buses to scale, if empty all loads are scaled
incLoss = (
scalePercent - 100
) * lossRatio # Additional percentage increase in Pgen (to account for losses)
#############################################
#Read raw file
with open(raw_conp, 'r') as f:
filecontent = f.read()
filelines = filecontent.split('\n')
## Get start and end indices of load and gen info
#########################################
loadStartIndex = filelines.index(
'0 / END OF BUS DATA, BEGIN LOAD DATA') + 1
loadEndIndex = filelines.index(
'0 / END OF LOAD DATA, BEGIN FIXED SHUNT DATA')
genStartIndex = filelines.index(
'0 / END OF FIXED SHUNT DATA, BEGIN GENERATOR DATA') + 1
genEndIndex = filelines.index(
'0 / END OF GENERATOR DATA, BEGIN BRANCH DATA')
##############################################################################
totalPincr = 0.0
totalQincr = 0.0
percentIncr = (scalePercent -
100.0) / 100 # increment in percentage
newPConList = []
newQConList = []
newIPList = []
newIQList = []
newZPList = []
newZQList = []
# Extract load info
for i in range(loadStartIndex, loadEndIndex):
words = filelines[i].split(',')
loadBus = words[0].strip()
#loadBusList.append(words[0].strip())
loadPCon = float(words[5].strip())
loadQCon = float(words[6].strip())
loadIP = float(words[7].strip())
loadIQ = float(words[8].strip())
loadZP = float(words[9].strip())
loadZQ = float(words[10].strip())
# calculate the total MW (MVAr) increase in load
loadBusVolt = float(rawBusDataDict[loadBus].voltpu)
Pincr = percentIncr * (
loadPCon + loadIP * loadBusVolt + loadZP * loadBusVolt**2
) # this equation is provided in PAGV1 page 293
Qincr = percentIncr * (loadQCon + loadIQ * loadBusVolt +
loadZQ * loadBusVolt**2)
totalPincr += Pincr
totalQincr += Qincr
###
# new load values
newPConList.append(loadPCon * scalePercent / 100)
newQConList.append(loadQCon * scalePercent / 100)
newIPList.append(loadIP * scalePercent / 100)
newIQList.append(loadIQ * scalePercent / 100)
newZPList.append(loadZP * scalePercent / 100)
newZQList.append(loadZQ * scalePercent / 100)
"""
loadPList.append(words[5].strip()) # adding P value (constant power)
loadQList.append(words[6].strip()) # adding Q value (constant power)
loadIPList.append(words[7].strip()) # constant current P
loadIQList.append(words[7].strip()) # constant current Q
loadZPList.append(words[9].strip()) # adding P value (constant admittance)
loadZQList.append(words[10].strip()) # adding Q value (constant admittance)
"""
# get total MW gen
totalGenMW = 0.0 # total generation excluding the swing bus
for i in range(genStartIndex, genEndIndex):
words = filelines[i].split(',')
GenBus = words[0].strip()
if rawBusDataDict[GenBus].type == '3':
continue
PGen = float(words[2].strip())
totalGenMW += PGen
# get new MW Gen
GenMWDict = {} # dictionary to hold new PGen values
for i in range(genStartIndex, genEndIndex):
words = filelines[i].split(',')
Bus = words[0].strip()
if rawBusDataDict[Bus].type == '3':
continue
macID = words[1].strip()
key = Bus + macID
PGen = float(words[2].strip())
genIncr = PGen / totalGenMW * totalPincr
newPGen = (PGen + genIncr) * genDiscount
GenMVA = float(words[8].strip())
if newPGen < GenMVA:
GenMWDict[key] = newPGen
else:
GenMWDict[key] = GenMVA
# generate the new raw file
with open(out_path, 'w') as f:
# copy everything before load data
for i in range(loadStartIndex):
f.write(filelines[i])
f.write('\n')
# modify the load data
j = 0
for i in range(loadStartIndex, loadEndIndex):
words = filelines[i].split(',')
# change the constant MVA values
words[5] = '%.3f' % newPConList[j]
words[6] = '%.3f' % newQConList[j]
words[5] = words[5].rjust(10)
words[6] = words[6].rjust(10)
# change the constant current values
words[7] = '%.3f' % newIPList[j]
words[8] = '%.3f' % newIQList[j]
words[7] = words[7].rjust(10)
words[8] = words[8].rjust(10)
# change the constant impedance values
words[9] = '%.3f' % newZPList[j]
words[10] = '%.3f' % newZQList[j]
words[9] = words[9].rjust(10)
words[10] = words[10].rjust(10)
# construct a whole string by inserting commas between the words list
filelines[i] = reconstructLine2(words)
f.write(filelines[i])
f.write('\n')
# increment the load list index
j += 1
# copy the shunt data, which is in between the load and gen data
for i in range(loadEndIndex, genStartIndex):
f.write(filelines[i])
f.write('\n')
# update and write the gen data
for i in range(genStartIndex, genEndIndex):
words = filelines[i].split(',')
Bus = words[0].strip()
if rawBusDataDict[Bus].type == '3':
f.write(filelines[i])
f.write('\n')
continue
macID = words[1].strip()
key = Bus + macID
newPGen = GenMWDict[key]
words[2] = '%.3f' % newPGen
words[2] = words[2].rjust(10)
# construct a whole string by inserting commas between the words list
filelines[i] = reconstructLine2(words)
f.write(filelines[i])
f.write('\n')
# copy the rest of the raw data
for i in range(genEndIndex, len(filelines)):
f.write(filelines[i])
f.write('\n')
# solves each of the newly generated raw files and saves them
output_dir = currentdir + '/' + newdir
NewRawFiles = os.listdir(output_dir)
PathList = [(output_dir + '/' + f) for f in NewRawFiles]
redirect.psse2py()
psspy.psseinit(buses=80000)
_i = psspy.getdefaultint()
_f = psspy.getdefaultreal()
_s = psspy.getdefaultchar()
for i in range(len(PathList)):
#Settings. CONFIGURE THIS
settings = {
# use the same raw data in PSS/E and TS3ph #####################################
'filename':
PathList[i], #use the same raw data in PSS/E and TS3ph
################################################################################
'dyr_file':
'',
'out_file':
'output2.out',
'pf_options': [
0, #disable taps
0, #disable area exchange
0, #disable phase-shift
0, #disable dc-tap
0, #disable switched shunts
0, #do not flat start
0, #apply var limits immediately
0, #disable non-div solution
]
}
psse_log = output_dir + '/' + 'log' + NewRawFiles[i].replace(
'.raw', '.txt')
psspy.report_output(2, psse_log, [0, 0])
psspy.progress_output(2, psse_log, [0, 0])
psspy.alert_output(2, psse_log, [0, 0])
psspy.prompt_output(2, psse_log, [0, 0])
print "\n Reading raw file:", settings['filename']
ierr = psspy.read(0, settings['filename'])
ierr = psspy.fnsl(settings['pf_options'])
converge = psspy.solved()
if converge == 0:
ierr = psspy.rawd_2(0, 1, [1, 1, 1, 0, 0, 0, 0], 0, PathList[i])
else: # file does not converge, remove raw file, keep log file
os.remove(PathList[i])
"""
psspy.fdns([1,0,0,1,1,0,0,0])
psspy.fdns([1,0,0,1,1,0,0,0])
#########################################################################################
Converged = 1
count = 1
while (Converged == 1):
psspy.fdns([1,0,0,1,1,0,0,0])
psspy.fdns([1,0,0,1,1,0,0,0])
psspy.fnsl([1,0,0,1,1,0,0,0])
psspy.fnsl([1,0,0,1,1,0,0,0])
psspy.fnsl([1,0,0,1,1,0,0,0])
psspy.fnsl([1,0,0,1,1,0,0,0])
psspy.fnsl([1,0,0,1,1,0,0,0])
Converged = psspy.solved()
count = count + 1
if count > 5:
print ( "Case is non-convergent.")
time.sleep(10)
sys.exit()
Column_Lables = ['Vset_STAT (pu)','V_OnHV (pu)','V_OnLV (pu)','Tr_ONS_1','Tr_ONS_2','Tr_OFS_1','Tr_OFS_2','I_land (%)','I_cncr_duct_1 (%)','I_onsh_1 (%)','I_cncr_duct_2 (%)','I_onsh_2 (%)','I_cncr_duct_3 (%)','I_onsh_3 (%)','I_cncr_duct_4 (%)','I_lnd_HDD (%)','I_Sea (%)','I_Jtube','ONS_XFO (%)','OFS_XFO (%)','P_POI (MW)','Q_POI (MVar)','PF','Cnvg.','Reactors (nos.)','Q_stat1_final (MVar)','Q_stat2_final (MVar)','V_ofs_cab_min (PU)','V_ofs_cab_max (PU)','V_66kV_min (PU)','V_66kV_max (PU)','V_0.72_kV_min (PU)','V_0.72_kV_max (PU)','Qs_WTs_min (MVAr)','Qs_WTs_max (MVAr)'] # UPDATE_Q_WT # UPDATE_XFO_LOADING
myxls.set_range(1,1,[Column_Lables],
transpose=False,fontStyle='bold', fontName=None, fontSize=None, fontColor=None, wrapText=False,
numberFormat=None, sheet="RPS")
