def __init__(self, nbus, nbr, bus_names, branch_names, bus_types):
"""
TimeSeriesResults constructor
@param nbus: number of buses
@param nbr: number of branches
"""
ResultsTemplate.__init__(self,
name='Contingency Analysis Results',
available_results=[
ResultTypes.OTDF,
ResultTypes.BusActivePower,
ResultTypes.BranchActivePowerFrom,
ResultTypes.BranchLoading
],
data_variables=[
'bus_types', 'branch_names', 'bus_names',
'voltage', 'S', 'Sf', 'loading', 'otdf'
])
self.branch_names = branch_names
self.bus_names = bus_names
self.bus_types = bus_types
self.voltage = np.ones((nbr, nbus), dtype=complex)
self.S = np.zeros((nbr, nbus), dtype=complex)
self.Sf = np.zeros((nbr, nbr), dtype=complex)
self.loading = np.zeros((nbr, nbr), dtype=complex)
self.otdf = np.zeros((nbr, nbr))
def __init__(self, br_idx, n_bus, time_array, br_names, bus_names,
bus_types):
"""
:param br_idx:
:param n_bus:
:param time_array:
:param br_names:
:param bus_names:
:param bus_types:
"""
ResultsTemplate.__init__(
self,
name='ATC Time Series Results',
available_results=[
ResultTypes.AvailableTransferCapacity,
ResultTypes.NetTransferCapacity,
ResultTypes.AvailableTransferCapacityN,
ResultTypes.AvailableTransferCapacityAlpha,
ResultTypes.AvailableTransferCapacityReport
],
data_variables=[
'alpha', 'beta', 'atc', 'atc_n',
'atc_limiting_contingency_branch',
'atc_limiting_contingency_flow', 'base_flow', 'rates',
'contingency_rates', 'report', 'report_headers',
'report_indices', 'branch_names', 'bus_names', 'bus_types',
'branch_names', 'br_idx', 'time_array'
])
self.br_idx = br_idx
self.n_br = len(br_idx)
self.n_bus = n_bus
self.nt = len(time_array)
self.time_array = time_array
self.branch_names = br_names
self.bus_names = bus_names
self.bus_types = bus_types
# available transfer capacity matrix (branch, contingency branch)
self.rates = np.zeros((self.nt, self.n_br))
self.contingency_rates = np.zeros((self.nt, self.n_br))
self.base_exchange = np.zeros(self.nt)
self.alpha = np.zeros((self.nt, self.n_br))
self.atc = np.zeros((self.nt, self.n_br))
self.atc_n = np.zeros((self.nt, self.n_br))
self.atc_mc = np.zeros((self.nt, self.n_br))
self.ntc = np.zeros((self.nt, self.n_br))
self.beta = np.zeros((self.nt, self.n_br))
self.atc_limiting_contingency_branch = np.zeros((self.nt, self.n_br),
dtype=int)
self.atc_limiting_contingency_flow = np.zeros((self.nt, self.n_br))
self.base_flow = np.zeros((self.nt, self.n_br))
self.report = np.empty((self.n_br, 0), dtype=object)
self.report_headers = []
self.report_indices = self.time_array
def __init__(self, n_bus, br_names, bus_names, bus_types, bus_idx_from,
bus_idx_to, br_idx):
"""
:param n_bus:
:param br_names:
:param bus_names:
:param bus_types:
:param bus_idx_from:
:param bus_idx_to:
:param br_idx:
"""
ResultsTemplate.__init__(
self,
name='ATC Results',
available_results=[
ResultTypes.AvailableTransferCapacity,
ResultTypes.NetTransferCapacity,
ResultTypes.AvailableTransferCapacityN,
ResultTypes.AvailableTransferCapacityAlpha,
ResultTypes.AvailableTransferCapacityBeta,
ResultTypes.AvailableTransferCapacityReport
],
data_variables=[
'alpha', 'beta_mat', 'beta', 'atc', 'atc_n',
'atc_limiting_contingency_branch',
'atc_limiting_contingency_flow', 'base_flow', 'rates',
'contingency_rates', 'report', 'report_headers',
'report_indices', 'branch_names', 'bus_names', 'bus_types',
'bus_idx_from', 'bus_idx_to', 'br_idx'
])
self.n_br = len(br_idx)
self.n_bus = n_bus
self.branch_names = np.array(br_names, dtype=object)
self.bus_names = bus_names
self.bus_types = bus_types
self.bus_idx_from = bus_idx_from
self.bus_idx_to = bus_idx_to
self.br_idx = br_idx
# stores the worst transfer capacities (from to) and (to from)
self.rates = np.zeros(self.n_br)
self.contingency_rates = np.zeros(self.n_br)
self.base_exchange = 0
self.alpha = np.zeros(self.n_br)
self.atc = np.zeros(self.n_br)
self.atc_n = np.zeros(self.n_br)
self.atc_mc = np.zeros(self.n_br)
self.ntc = np.zeros(self.n_br)
self.beta_mat = np.zeros((self.n_br, self.n_br))
self.beta = np.zeros(self.n_br)
self.atc_limiting_contingency_branch = np.zeros(self.n_br, dtype=int)
self.atc_limiting_contingency_flow = np.zeros(self.n_br)
self.base_flow = np.zeros(self.n_br)
self.report = np.empty((self.n_br, 0), dtype=object)
self.report_headers = list()
self.report_indices = self.branch_names
def __init__(self, nval, nbus, nbr, bus_names, branch_names, bus_types):
"""
ContinuationPowerFlowResults instance
:param nbus: number of buses
:param nbr: number of branches
:param bus_names: names of the buses
"""
ResultsTemplate.__init__(
self,
name='Continuation Power Flow',
available_results=[
ResultTypes.BusVoltage, ResultTypes.BusActivePower,
ResultTypes.BusReactivePower,
ResultTypes.BranchActivePowerFrom,
ResultTypes.BranchReactivePowerFrom,
ResultTypes.BranchActivePowerTo,
ResultTypes.BranchReactivePowerTo,
ResultTypes.BranchActiveLosses,
ResultTypes.BranchReactiveLosses, ResultTypes.BranchLoading
],
data_variables=[
'bus_names', 'branch_names', 'voltages', 'lambdas', 'error',
'converged', 'Sf', 'St', 'loading', 'losses', 'Sbus',
'bus_types'
])
self.bus_names = bus_names
self.branch_names = branch_names
self.voltages = np.zeros((nval, nbus), dtype=complex)
self.lambdas = np.zeros(nval)
self.error = np.zeros(nval)
self.converged = np.zeros(nval, dtype=bool)
self.Sf = np.zeros((nval, nbr), dtype=complex)
self.St = np.zeros((nval, nbr), dtype=complex)
self.loading = np.zeros((nval, nbr))
self.losses = np.zeros((nval, nbr), dtype=complex)
self.Sbus = np.zeros((nval, nbus), dtype=complex)
self.bus_types = bus_types
def __init__(self, n, ne, nc, time_array, bus_names, branch_names,
bus_types):
"""
TimeSeriesResults constructor
@param n: number of buses
@param m: number of branches
"""
ResultsTemplate.__init__(self,
name='N-1 time series',
available_results=[
ResultTypes.ContingencyFrequency,
ResultTypes.ContingencyRelativeFrequency,
ResultTypes.MaxOverloads,
ResultTypes.WorstContingencyFlows,
ResultTypes.WorstContingencyLoading
],
data_variables=[
'branch_names', 'bus_names', 'bus_types',
'time_array', 'worst_flows',
'worst_loading', 'overload_count',
'relative_frequency', 'max_overload'
])
nt = len(time_array)
self.branch_names = branch_names
self.bus_names = bus_names
self.bus_types = bus_types
self.time_array = time_array
self.S = np.zeros((nt, n))
self.worst_flows = np.zeros((nt, ne))
self.worst_loading = np.zeros((nt, ne))
self.overload_count = np.zeros((ne, nc), dtype=int)
self.relative_frequency = np.zeros((ne, nc))
self.max_overload = np.zeros((ne, nc))
def __init__(self, n_br=0, n_bus=0, br_names=(), bus_names=(), bus_types=()):
"""
PTDF and LODF results class
:param n_br: number of branches
:param n_bus: number of buses
:param br_names: branch names
:param bus_names: bus names
:param bus_types: bus types array
"""
ResultsTemplate.__init__(self,
name='Linear Analysis',
available_results=[ResultTypes.PTDFBranchesSensitivity,
ResultTypes.OTDF,
ResultTypes.BranchActivePowerFrom,
ResultTypes.BranchLoading],
data_variables=['branch_names',
'bus_names',
'bus_types',
'PTDF',
'LODF',
'Sf',
'loading'])
# number of branches
self.n_br = n_br
self.n_bus = n_bus
# names of the branches
self.branch_names = br_names
self.bus_names = bus_names
self.bus_types = bus_types
self.logger = Logger()
self.PTDF = np.zeros((n_br, n_bus))
self.LODF = np.zeros((n_br, n_br))
self.Sf = np.zeros(self.n_br)
self.loading = np.zeros(self.n_br)
def __init__(self, n, m, time_array, bus_names, bus_types, branch_names):
"""
TimeSeriesResults constructor
@param n: number of buses
@param m: number of branches
@param nt: number of time steps
"""
ResultsTemplate.__init__(self,
name='Linear Analysis time series',
available_results=[
ResultTypes.BusActivePower,
ResultTypes.BranchActivePowerFrom,
ResultTypes.BranchLoading
],
data_variables=[
'bus_names', 'bus_types', 'time',
'branch_names', 'voltage', 'S', 'Sf',
'loading', 'losses'
])
self.nt = len(time_array)
self.m = m
self.n = n
self.time = time_array
self.bus_names = bus_names
self.bus_types = bus_types
self.branch_names = branch_names
self.voltage = np.ones((self.nt, n), dtype=float)
self.S = np.zeros((self.nt, n), dtype=float)
self.Sf = np.zeros((self.nt, m), dtype=float)
self.loading = np.zeros((self.nt, m), dtype=float)
self.losses = np.zeros((self.nt, m), dtype=float)
def __init__(self,
bus_names,
branch_names,
load_names,
generator_names,
battery_names,
hvdc_names,
Sbus=None,
voltage=None,
load_shedding=None,
generator_shedding=None,
battery_power=None,
controlled_generation_power=None,
Sf=None,
overloads=None,
loading=None,
losses=None,
converged=None,
bus_types=None,
hvdc_flow=None,
hvdc_slacks=None,
hvdc_loading=None,
node_slacks=None,
phase_shift=None,
generation_delta=None,
inter_area_branches=list(),
inter_area_hvdc=list()):
ResultsTemplate.__init__(
self,
name='OPF',
available_results=[
ResultTypes.BusVoltageModule, ResultTypes.BusVoltageAngle,
ResultTypes.BranchPower, ResultTypes.BranchLoading,
ResultTypes.BranchOverloads, ResultTypes.LoadShedding,
ResultTypes.ControlledGeneratorShedding,
ResultTypes.ControlledGeneratorPower, ResultTypes.BatteryPower,
ResultTypes.HvdcPowerFrom, ResultTypes.HvdcOverloads,
ResultTypes.BranchTapAngle, ResultTypes.GenerationDelta,
ResultTypes.InterAreaExchange
],
data_variables=[
'bus_names', 'branch_names', 'load_names', 'generator_names',
'battery_names', 'Sbus', 'voltage', 'load_shedding',
'generator_shedding', 'Sf', 'bus_types', 'overloads',
'loading', 'battery_power', 'generator_power', 'converged'
])
self.bus_names = bus_names
self.branch_names = branch_names
self.load_names = load_names
self.generator_names = generator_names
self.battery_names = battery_names
self.hvdc_names = hvdc_names
self.inter_area_branches = inter_area_branches
self.inter_area_hvdc = inter_area_hvdc
self.generation_delta = generation_delta
self.Sbus = Sbus
self.voltage = voltage
self.node_slacks = node_slacks
self.load_shedding = load_shedding
self.Sf = Sf
self.hvdc_Pf = hvdc_flow
self.hvdc_loading = hvdc_loading
self.hvdc_slacks = hvdc_slacks
self.phase_shift = phase_shift
self.bus_types = bus_types
self.overloads = overloads
self.loading = loading
self.losses = losses
self.battery_power = battery_power
self.generator_shedding = generator_shedding
self.generator_power = controlled_generation_power
self.converged = converged
self.plot_bars_limit = 100
def __init__(self, n, m, p, bus_names, branch_names, bus_types, name='Monte Carlo'):
"""
Constructor
@param n: number of nodes
@param m: number of branches
@param p: number of points (rows)
"""
ResultsTemplate.__init__(self,
name='Stochastic Power Flow',
available_results=[ResultTypes.BusVoltageAverage,
ResultTypes.BusVoltageStd,
ResultTypes.BusVoltageCDF,
ResultTypes.BusPowerCDF,
ResultTypes.BranchPowerAverage,
ResultTypes.BranchPowerStd,
ResultTypes.BranchPowerCDF,
ResultTypes.BranchLoadingAverage,
ResultTypes.BranchLoadingStd,
ResultTypes.BranchLoadingCDF,
ResultTypes.BranchLossesAverage,
ResultTypes.BranchLossesStd,
ResultTypes.BranchLossesCDF],
data_variables=[])
self.n = n
self.m = m
self.points_number = p
self.bus_names = bus_names
self.branch_names = branch_names
self.bus_types = bus_types
self.S_points = np.zeros((p, n), dtype=complex)
self.V_points = np.zeros((p, n), dtype=complex)
self.Sbr_points = np.zeros((p, m), dtype=complex)
self.loading_points = np.zeros((p, m), dtype=complex)
self.losses_points = np.zeros((p, m), dtype=complex)
self.error_series = list()
self.bus_types = np.zeros(n, dtype=int)
self.voltage = np.zeros(n)
self.loading = np.zeros(m)
self.sbranch = np.zeros(m)
self.losses = np.zeros(m)
# magnitudes standard deviation convergence
self.v_std_conv = None
self.s_std_conv = None
self.l_std_conv = None
self.loss_std_conv = None
# magnitudes average convergence
self.v_avg_conv = None
self.s_avg_conv = None
self.l_avg_conv = None
self.loss_avg_conv = None
self.available_results = [ResultTypes.BusVoltageAverage,
ResultTypes.BusVoltageStd,
ResultTypes.BusVoltageCDF,
ResultTypes.BusPowerCDF,
ResultTypes.BranchPowerAverage,
ResultTypes.BranchPowerStd,
ResultTypes.BranchPowerCDF,
ResultTypes.BranchLoadingAverage,
ResultTypes.BranchLoadingStd,
ResultTypes.BranchLoadingCDF,
ResultTypes.BranchLossesAverage,
ResultTypes.BranchLossesStd,
ResultTypes.BranchLossesCDF]
def __init__(self, n, m, n_tr, n_hvdc, bus_names, branch_names,
transformer_names, hvdc_names, bus_types):
"""
A **PowerFlowResults** object is create as an attribute of the
:ref:`PowerFlowMP<pf_mp>` (as PowerFlowMP.results) when the power flow is run. It
provides access to the simulation results through its class attributes.
:param n:
:param m:
:param n_tr:
:param n_hvdc:
:param bus_names:
:param branch_names:
:param transformer_names:
:param hvdc_names:
:param bus_types:
"""
ResultsTemplate.__init__(
self,
name='Power flow',
available_results=[
ResultTypes.BusVoltageModule, ResultTypes.BusVoltageAngle,
ResultTypes.BusActivePower, ResultTypes.BusReactivePower,
ResultTypes.BranchActivePowerFrom,
ResultTypes.BranchReactivePowerFrom,
ResultTypes.BranchActivePowerTo,
ResultTypes.BranchReactivePowerTo,
ResultTypes.BranchActiveCurrentFrom,
ResultTypes.BranchReactiveCurrentFrom,
ResultTypes.BranchActiveCurrentTo,
ResultTypes.BranchReactiveCurrentTo,
ResultTypes.BranchTapModule, ResultTypes.BranchTapAngle,
ResultTypes.BranchBeq, ResultTypes.BranchLoading,
ResultTypes.Transformer2WTapModule,
ResultTypes.BranchActiveLosses,
ResultTypes.BranchReactiveLosses, ResultTypes.BranchVoltage,
ResultTypes.BranchAngles, ResultTypes.HvdcLosses,
ResultTypes.HvdcPowerFrom, ResultTypes.HvdcPowerTo
],
data_variables=[
'bus_types', 'bus_names', 'branch_names', 'transformer_names',
'hvdc_names', 'Sbus', 'voltage', 'Sf', 'St', 'If', 'It', 'ma',
'theta', 'Beq', 'Vbranch', 'loading', 'transformer_tap_module',
'losses', 'hvdc_losses', 'hvdc_Pf', 'hvdc_Pt', 'hvdc_loading'
])
self.n = n
self.m = m
self.n_tr = n_tr
self.n_hvdc = n_hvdc
self.bus_types = bus_types
self.bus_names = bus_names
self.branch_names = branch_names
self.transformer_names = transformer_names
self.hvdc_names = hvdc_names
self.Sbus = np.zeros(n, dtype=complex)
self.voltage = np.zeros(n, dtype=complex)
self.Sf = np.zeros(m, dtype=complex)
self.St = np.zeros(m, dtype=complex)
self.If = np.zeros(m, dtype=complex)
self.It = np.zeros(m, dtype=complex)
self.ma = np.zeros(m, dtype=float)
self.theta = np.zeros(m, dtype=float)
self.Beq = np.zeros(m, dtype=float)
self.Vbranch = np.zeros(m, dtype=complex)
self.loading = np.zeros(m, dtype=complex)
self.transformer_tap_module = np.zeros(n_tr, dtype=float)
self.losses = np.zeros(m, dtype=complex)
self.hvdc_losses = np.zeros(self.n_hvdc)
self.hvdc_Pf = np.zeros(self.n_hvdc)
self.hvdc_Pt = np.zeros(self.n_hvdc)
self.hvdc_loading = np.zeros(self.n_hvdc)
self.plot_bars_limit = 100
self.convergence_reports = list()
def __init__(self,
bus_names,
branch_names,
load_names,
generator_names,
battery_names,
n,
m,
nt,
ngen=0,
nbat=0,
nload=0,
time=None,
bus_types=()):
"""
OPF Time Series results constructor
:param n: number of buses
:param m: number of branches
:param nt: number of time steps
:param ngen:
:param nbat:
:param nload:
:param time: Time array (optional)
"""
ResultsTemplate.__init__(
self,
name='OPF time series',
available_results=[
ResultTypes.BusVoltageModule, ResultTypes.BusVoltageAngle,
ResultTypes.ShadowPrices, ResultTypes.BranchPower,
ResultTypes.BranchLoading, ResultTypes.BranchOverloads,
ResultTypes.LoadShedding,
ResultTypes.ControlledGeneratorShedding,
ResultTypes.ControlledGeneratorPower, ResultTypes.BatteryPower,
ResultTypes.BatteryEnergy
],
data_variables=[
'bus_names', 'branch_names', 'load_names', 'generator_names',
'battery_names', 'bus_types', 'time', 'Sbus', 'voltage',
'load_shedding', 'Sf', 'overloads', 'loading', 'losses',
'battery_power', 'battery_energy', 'generator_shedding',
'generator_power', 'shadow_prices', 'converged'
])
self.bus_names = bus_names
self.branch_names = branch_names
self.load_names = load_names
self.generator_names = generator_names
self.battery_names = battery_names
self.bus_types = bus_types
self.n = n
self.m = m
self.nt = nt
self.time = time
self.voltage = np.zeros((nt, n), dtype=complex)
self.load_shedding = np.zeros((nt, nload), dtype=float)
self.loading = np.zeros((nt, m), dtype=float)
self.losses = np.zeros((nt, m), dtype=float)
self.overloads = np.zeros((nt, m), dtype=float)
self.Sbus = np.zeros((nt, n), dtype=complex)
self.shadow_prices = np.zeros((nt, n), dtype=float)
self.Sf = np.zeros((nt, m), dtype=complex)
self.generator_power = np.zeros((nt, ngen), dtype=float)
self.generator_shedding = np.zeros((nt, ngen), dtype=float)
self.battery_power = np.zeros((nt, nbat), dtype=float)
self.battery_energy = np.zeros((nt, nbat), dtype=float)
self.converged = np.empty(nt, dtype=bool)
def __init__(self, bus_names, branch_names, load_names, generator_names, battery_names,
Sbus=None, voltage=None, load_shedding=None, generator_shedding=None,
battery_power=None, controlled_generation_power=None,
Sf=None, overloads=None, loading=None, losses=None, converged=None, bus_types=None):
ResultsTemplate.__init__(self,
name='OPF',
available_results=[ResultTypes.BusVoltageModule,
ResultTypes.BusVoltageAngle,
ResultTypes.BranchPower,
ResultTypes.BranchLoading,
ResultTypes.BranchOverloads,
ResultTypes.LoadShedding,
ResultTypes.ControlledGeneratorShedding,
ResultTypes.ControlledGeneratorPower,
ResultTypes.BatteryPower],
data_variables=['bus_names',
'branch_names',
'load_names',
'generator_names',
'battery_names',
'Sbus',
'voltage',
'load_shedding',
'generator_shedding',
'Sf',
'bus_types',
'overloads',
'loading',
'battery_power',
'generator_power',
'converged'])
self.bus_names = bus_names
self.branch_names = branch_names
self.load_names = load_names
self.generator_names = generator_names
self.battery_names = battery_names
self.Sbus = Sbus
self.voltage = voltage
self.load_shedding = load_shedding
self.Sf = Sf
self.bus_types = bus_types
self.overloads = overloads
self.loading = loading
self.losses = losses
self.battery_power = battery_power
self.generator_shedding = generator_shedding
self.generator_power = controlled_generation_power
self.converged = converged
self.plot_bars_limit = 100