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