Datasets:

Denis641

/

CodeGenDataset

like 0

[ "def", "_var_bounds", "(", "self", ")", ":", "x0", "=", "array", "(", "[", "]", ")", "xmin", "=", "array", "(", "[", "]", ")", "xmax", "=", "array", "(", "[", "]", ")", "for", "var", "in", "self", ".", "om", ".", "vars", ":", "x0", "=", "r_", "[", "x0", ",", "var", ".", "v0", "]", "xmin", "=", "r_", "[", "xmin", ",", "var", ".", "vl", "]", "xmax", "=", "r_", "[", "xmax", ",", "var", ".", "vu", "]", "return", "x0", ",", "xmin", ",", "xmax" ]

[ "Returns", "bounds", "on", "the", "optimisation", "variables", "." ]

[ "def", "_initial_interior_point", "(", "self", ",", "buses", ",", "generators", ",", "xmin", ",", "xmax", ",", "ny", ")", ":", "Va", "=", "self", ".", "om", ".", "get_var", "(", "\"Va\"", ")", "va_refs", "=", "[", "b", ".", "v_angle", "*", "pi", "/", "180.0", "for", "b", "in", "buses", "if", "b", ".", "type", "==", "REFERENCE", "]", "x0", "=", "(", "xmin", "+", "xmax", ")", "/", "2.0", "x0", "[", "Va", ".", "i1", ":", "Va", ".", "iN", "+", "1", "]", "=", "va_refs", "[", "0", "]", "# Angles set to first reference angle.", "if", "ny", ">", "0", ":", "yvar", "=", "self", ".", "om", ".", "get_var", "(", "\"y\"", ")", "# Largest y-value in CCV data", "c", "=", "[", "]", "for", "g", "in", "generators", ":", "if", "g", ".", "pcost_model", "==", "PW_LINEAR", ":", "for", "_", ",", "y", "in", "g", ".", "p_cost", ":", "c", ".", "append", "(", "y", ")", "x0", "[", "yvar", ".", "i1", ":", "yvar", ".", "iN", "+", "1", "]", "=", "max", "(", "c", ")", "*", "1.1", "return", "x0" ]

[ "Selects", "an", "interior", "initial", "point", "for", "interior", "point", "solver", "." ]

[ "def", "solve", "(", "self", ")", ":", "base_mva", "=", "self", ".", "om", ".", "case", ".", "base_mva", "Bf", "=", "self", ".", "om", ".", "_Bf", "Pfinj", "=", "self", ".", "om", ".", "_Pfinj", "# Unpack the OPF model.", "bs", ",", "ln", ",", "gn", ",", "cp", "=", "self", ".", "_unpack_model", "(", "self", ".", "om", ")", "# Compute problem dimensions.", "ipol", ",", "ipwl", ",", "nb", ",", "nl", ",", "nw", ",", "ny", ",", "nxyz", "=", "self", ".", "_dimension_data", "(", "bs", ",", "ln", ",", "gn", ")", "# Split the constraints in equality and inequality.", "AA", ",", "ll", ",", "uu", "=", "self", ".", "_linear_constraints", "(", "self", ".", "om", ")", "# Piece-wise linear components of the objective function.", "Npwl", ",", "Hpwl", ",", "Cpwl", ",", "fparm_pwl", ",", "any_pwl", "=", "self", ".", "_pwl_costs", "(", "ny", ",", "nxyz", ",", "ipwl", ")", "# Quadratic components of the objective function.", "Npol", ",", "Hpol", ",", "Cpol", ",", "fparm_pol", ",", "polycf", ",", "npol", "=", "self", ".", "_quadratic_costs", "(", "gn", ",", "ipol", ",", "nxyz", ",", "base_mva", ")", "# Combine pwl, poly and user costs.", "NN", ",", "HHw", ",", "CCw", ",", "ffparm", "=", "self", ".", "_combine_costs", "(", "Npwl", ",", "Hpwl", ",", "Cpwl", ",", "fparm_pwl", ",", "any_pwl", ",", "Npol", ",", "Hpol", ",", "Cpol", ",", "fparm_pol", ",", "npol", ",", "nw", ")", "# Transform quadratic coefficients for w into coefficients for X.", "HH", ",", "CC", ",", "C0", "=", "self", ".", "_transform_coefficients", "(", "NN", ",", "HHw", ",", "CCw", ",", "ffparm", ",", "polycf", ",", "any_pwl", ",", "npol", ",", "nw", ")", "# Bounds on the optimisation variables.", "_", ",", "xmin", ",", "xmax", "=", "self", ".", "_var_bounds", "(", ")", "# Select an interior initial point for interior point solver.", "x0", "=", "self", ".", "_initial_interior_point", "(", "bs", ",", "gn", ",", "xmin", ",", "xmax", ",", "ny", ")", "# Call the quadratic/linear solver.", "s", "=", "self", ".", "_run_opf", "(", "HH", ",", "CC", ",", "AA", ",", "ll", ",", "uu", ",", "xmin", ",", "xmax", ",", "x0", ",", "self", ".", "opt", ")", "# Compute the objective function value.", "Va", ",", "Pg", "=", "self", ".", "_update_solution_data", "(", "s", ",", "HH", ",", "CC", ",", "C0", ")", "# Set case result attributes.", "self", ".", "_update_case", "(", "bs", ",", "ln", ",", "gn", ",", "base_mva", ",", "Bf", ",", "Pfinj", ",", "Va", ",", "Pg", ",", "s", "[", "\"lmbda\"", "]", ")", "return", "s" ]

[ "Solves", "DC", "optimal", "power", "flow", "and", "returns", "a", "results", "dict", "." ]

[ "def", "_pwl_costs", "(", "self", ",", "ny", ",", "nxyz", ",", "ipwl", ")", ":", "any_pwl", "=", "int", "(", "ny", ">", "0", ")", "if", "any_pwl", ":", "y", "=", "self", ".", "om", ".", "get_var", "(", "\"y\"", ")", "# Sum of y vars.", "Npwl", "=", "csr_matrix", "(", "(", "ones", "(", "ny", ")", ",", "(", "zeros", "(", "ny", ")", ",", "array", "(", "ipwl", ")", "+", "y", ".", "i1", ")", ")", ")", "Hpwl", "=", "csr_matrix", "(", "(", "1", ",", "1", ")", ")", "Cpwl", "=", "array", "(", "[", "1", "]", ")", "fparm_pwl", "=", "array", "(", "[", "[", "1.", ",", "0.", ",", "0.", ",", "1.", "]", "]", ")", "else", ":", "Npwl", "=", "None", "#zeros((0, nxyz))", "Hpwl", "=", "None", "#array([])", "Cpwl", "=", "array", "(", "[", "]", ")", "fparm_pwl", "=", "zeros", "(", "(", "0", ",", "4", ")", ")", "return", "Npwl", ",", "Hpwl", ",", "Cpwl", ",", "fparm_pwl", ",", "any_pwl" ]

[ "Returns", "the", "piece", "-", "wise", "linear", "components", "of", "the", "objective", "function", "." ]

[ "def", "_quadratic_costs", "(", "self", ",", "generators", ",", "ipol", ",", "nxyz", ",", "base_mva", ")", ":", "npol", "=", "len", "(", "ipol", ")", "rnpol", "=", "range", "(", "npol", ")", "gpol", "=", "[", "g", "for", "g", "in", "generators", "if", "g", ".", "pcost_model", "==", "POLYNOMIAL", "]", "if", "[", "g", "for", "g", "in", "gpol", "if", "len", "(", "g", ".", "p_cost", ")", ">", "3", "]", ":", "logger", ".", "error", "(", "\"Order of polynomial cost greater than quadratic.\"", ")", "iqdr", "=", "[", "i", "for", "i", ",", "g", "in", "enumerate", "(", "generators", ")", "if", "g", ".", "pcost_model", "==", "POLYNOMIAL", "and", "len", "(", "g", ".", "p_cost", ")", "==", "3", "]", "ilin", "=", "[", "i", "for", "i", ",", "g", "in", "enumerate", "(", "generators", ")", "if", "g", ".", "pcost_model", "==", "POLYNOMIAL", "and", "len", "(", "g", ".", "p_cost", ")", "==", "2", "]", "polycf", "=", "zeros", "(", "(", "npol", ",", "3", ")", ")", "if", "npol", ">", "0", ":", "if", "len", "(", "iqdr", ")", ">", "0", ":", "polycf", "[", "iqdr", ",", ":", "]", "=", "array", "(", "[", "list", "(", "g", ".", "p_cost", ")", "for", "g", "in", "generators", "]", ")", "#[iqdr, :].T", "if", "len", "(", "ilin", ")", ">", "0", ":", "polycf", "[", "ilin", ",", "1", ":", "]", "=", "array", "(", "[", "list", "(", "g", ".", "p_cost", "[", ":", "2", "]", ")", "for", "g", "in", "generators", "]", ")", "#[ilin, :].T", "# Convert to per-unit.", "polycf", "=", "polycf", "*", "array", "(", "[", "base_mva", "**", "2", ",", "base_mva", ",", "1", "]", ")", "Pg", "=", "self", ".", "om", ".", "get_var", "(", "\"Pg\"", ")", "Npol", "=", "csr_matrix", "(", "(", "ones", "(", "npol", ")", ",", "(", "rnpol", ",", "Pg", ".", "i1", "+", "array", "(", "ipol", ")", ")", ")", ",", "(", "npol", ",", "nxyz", ")", ")", "Hpol", "=", "csr_matrix", "(", "(", "2", "*", "polycf", "[", ":", ",", "0", "]", ",", "(", "rnpol", ",", "rnpol", ")", ")", ",", "(", "npol", ",", "npol", ")", ")", "Cpol", "=", "polycf", "[", ":", ",", "1", "]", "fparm_pol", "=", "(", "ones", "(", "npol", ")", "*", "array", "(", "[", "[", "1", "]", ",", "[", "0", "]", ",", "[", "0", "]", ",", "[", "1", "]", "]", ")", ")", ".", "T", "else", ":", "Npol", "=", "Hpol", "=", "None", "Cpol", "=", "array", "(", "[", "]", ")", "fparm_pol", "=", "zeros", "(", "(", "0", ",", "4", ")", ")", "return", "Npol", ",", "Hpol", ",", "Cpol", ",", "fparm_pol", ",", "polycf", ",", "npol" ]

[ "Returns", "the", "quadratic", "cost", "components", "of", "the", "objective", "function", "." ]

[ "def", "_combine_costs", "(", "self", ",", "Npwl", ",", "Hpwl", ",", "Cpwl", ",", "fparm_pwl", ",", "any_pwl", ",", "Npol", ",", "Hpol", ",", "Cpol", ",", "fparm_pol", ",", "npol", ",", "nw", ")", ":", "NN", "=", "vstack", "(", "[", "n", "for", "n", "in", "[", "Npwl", ",", "Npol", "]", "if", "n", "is", "not", "None", "]", ",", "\"csr\"", ")", "if", "(", "Hpwl", "is", "not", "None", ")", "and", "(", "Hpol", "is", "not", "None", ")", ":", "Hpwl", "=", "hstack", "(", "[", "Hpwl", ",", "csr_matrix", "(", "(", "any_pwl", ",", "npol", ")", ")", "]", ")", "Hpol", "=", "hstack", "(", "[", "csr_matrix", "(", "(", "npol", ",", "any_pwl", ")", ")", ",", "Hpol", "]", ")", "# if H is not None:", "# H = hstack([csr_matrix((nw, any_pwl+npol)), H])", "HHw", "=", "vstack", "(", "[", "h", "for", "h", "in", "[", "Hpwl", ",", "Hpol", "]", "if", "h", "is", "not", "None", "]", ",", "\"csr\"", ")", "CCw", "=", "r_", "[", "Cpwl", ",", "Cpol", "]", "ffparm", "=", "r_", "[", "fparm_pwl", ",", "fparm_pol", "]", "return", "NN", ",", "HHw", ",", "CCw", ",", "ffparm" ]

[ "Combines", "pwl", "polynomial", "and", "user", "-", "defined", "costs", "." ]

[ "def", "_transform_coefficients", "(", "self", ",", "NN", ",", "HHw", ",", "CCw", ",", "ffparm", ",", "polycf", ",", "any_pwl", ",", "npol", ",", "nw", ")", ":", "nnw", "=", "any_pwl", "+", "npol", "+", "nw", "M", "=", "csr_matrix", "(", "(", "ffparm", "[", ":", ",", "3", "]", ",", "(", "range", "(", "nnw", ")", ",", "range", "(", "nnw", ")", ")", ")", ")", "MR", "=", "M", "*", "ffparm", "[", ":", ",", "2", "]", "# FIXME: Possibly column 1.", "HMR", "=", "HHw", "*", "MR", "MN", "=", "M", "*", "NN", "HH", "=", "MN", ".", "T", "*", "HHw", "*", "MN", "CC", "=", "MN", ".", "T", "*", "(", "CCw", "-", "HMR", ")", "# Constant term of cost.", "C0", "=", "1.", "/", "2.", "*", "MR", ".", "T", "*", "HMR", "+", "sum", "(", "polycf", "[", ":", ",", "2", "]", ")", "return", "HH", ",", "CC", ",", "C0", "[", "0", "]" ]

[ "Transforms", "quadratic", "coefficients", "for", "w", "into", "coefficients", "for", "x", "." ]

[ "def", "_ref_bus_angle_constraint", "(", "self", ",", "buses", ",", "Va", ",", "xmin", ",", "xmax", ")", ":", "refs", "=", "[", "bus", ".", "_i", "for", "bus", "in", "buses", "if", "bus", ".", "type", "==", "REFERENCE", "]", "Varefs", "=", "array", "(", "[", "b", ".", "v_angle", "for", "b", "in", "buses", "if", "b", ".", "type", "==", "REFERENCE", "]", ")", "xmin", "[", "Va", ".", "i1", "-", "1", "+", "refs", "]", "=", "Varefs", "xmax", "[", "Va", ".", "iN", "-", "1", "+", "refs", "]", "=", "Varefs", "return", "xmin", ",", "xmax" ]

[ "Adds", "a", "constraint", "on", "the", "reference", "bus", "angles", "." ]

[ "def", "_f", "(", "self", ",", "x", ",", "user_data", "=", "None", ")", ":", "p_gen", "=", "x", "[", "self", ".", "_Pg", ".", "i1", ":", "self", ".", "_Pg", ".", "iN", "+", "1", "]", "# Active generation in p.u.", "q_gen", "=", "x", "[", "self", ".", "_Qg", ".", "i1", ":", "self", ".", "_Qg", ".", "iN", "+", "1", "]", "# Reactive generation in p.u.", "# Polynomial cost of P and Q.", "xx", "=", "r_", "[", "p_gen", ",", "q_gen", "]", "*", "self", ".", "_base_mva", "if", "len", "(", "self", ".", "_ipol", ")", ">", "0", ":", "f", "=", "sum", "(", "[", "g", ".", "total_cost", "(", "xx", "[", "i", "]", ")", "for", "i", ",", "g", "in", "enumerate", "(", "self", ".", "_gn", ")", "]", ")", "else", ":", "f", "=", "0", "# Piecewise linear cost of P and Q.", "if", "self", ".", "_ny", ":", "y", "=", "self", ".", "om", ".", "get_var", "(", "\"y\"", ")", "self", ".", "_ccost", "=", "csr_matrix", "(", "(", "ones", "(", "self", ".", "_ny", ")", ",", "(", "range", "(", "y", ".", "i1", ",", "y", ".", "iN", "+", "1", ")", ",", "zeros", "(", "self", ".", "_ny", ")", ")", ")", ",", "shape", "=", "(", "self", ".", "_nxyz", ",", "1", ")", ")", ".", "T", "f", "=", "f", "+", "self", ".", "_ccost", "*", "x", "else", ":", "self", ".", "_ccost", "=", "zeros", "(", "(", "1", ",", "self", ".", "_nxyz", ")", ")", "# TODO: Generalised cost term.", "return", "f" ]

[ "Evaluates", "the", "objective", "function", "." ]

[ "def", "_df", "(", "self", ",", "x", ",", "user_data", "=", "None", ")", ":", "p_gen", "=", "x", "[", "self", ".", "_Pg", ".", "i1", ":", "self", ".", "_Pg", ".", "iN", "+", "1", "]", "# Active generation in p.u.", "q_gen", "=", "x", "[", "self", ".", "_Qg", ".", "i1", ":", "self", ".", "_Qg", ".", "iN", "+", "1", "]", "# Reactive generation in p.u.", "# Polynomial cost of P and Q.", "xx", "=", "r_", "[", "p_gen", ",", "q_gen", "]", "*", "self", ".", "_base_mva", "iPg", "=", "range", "(", "self", ".", "_Pg", ".", "i1", ",", "self", ".", "_Pg", ".", "iN", "+", "1", ")", "iQg", "=", "range", "(", "self", ".", "_Qg", ".", "i1", ",", "self", ".", "_Qg", ".", "iN", "+", "1", ")", "# Polynomial cost of P and Q.", "df_dPgQg", "=", "zeros", "(", "(", "2", "*", "self", ".", "_ng", ",", "1", ")", ")", "# w.r.t p.u. Pg and Qg", "# df_dPgQg[ipol] = matrix([g.poly_cost(xx[i], 1) for g in gpol])", "# for i, g in enumerate(gn):", "# der = polyder(list(g.p_cost))", "# df_dPgQg[i] = polyval(der, xx[i]) * base_mva", "for", "i", "in", "self", ".", "_ipol", ":", "p_cost", "=", "list", "(", "self", ".", "_gn", "[", "i", "]", ".", "p_cost", ")", "df_dPgQg", "[", "i", "]", "=", "self", ".", "_base_mva", "*", "polyval", "(", "polyder", "(", "p_cost", ")", ",", "xx", "[", "i", "]", ")", "df", "=", "zeros", "(", "(", "self", ".", "_nxyz", ",", "1", ")", ")", "df", "[", "iPg", "]", "=", "df_dPgQg", "[", ":", "self", ".", "_ng", "]", "df", "[", "iQg", "]", "=", "df_dPgQg", "[", "self", ".", "_ng", ":", "self", ".", "_ng", "+", "self", ".", "_ng", "]", "# Piecewise linear cost of P and Q.", "df", "=", "df", "+", "self", ".", "_ccost", ".", "T", "# TODO: Generalised cost term.", "return", "asarray", "(", "df", ")", ".", "flatten", "(", ")" ]

[ "Evaluates", "the", "cost", "gradient", "." ]

[ "def", "_d2f", "(", "self", ",", "x", ")", ":", "d2f_dPg2", "=", "lil_matrix", "(", "(", "self", ".", "_ng", ",", "1", ")", ")", "# w.r.t p.u. Pg", "d2f_dQg2", "=", "lil_matrix", "(", "(", "self", ".", "_ng", ",", "1", ")", ")", "# w.r.t p.u. Qg]", "for", "i", "in", "self", ".", "_ipol", ":", "p_cost", "=", "list", "(", "self", ".", "_gn", "[", "i", "]", ".", "p_cost", ")", "d2f_dPg2", "[", "i", ",", "0", "]", "=", "polyval", "(", "polyder", "(", "p_cost", ",", "2", ")", ",", "self", ".", "_Pg", ".", "v0", "[", "i", "]", "*", "self", ".", "_base_mva", ")", "*", "self", ".", "_base_mva", "**", "2", "# for i in ipol:", "# d2f_dQg2[i] = polyval(polyder(list(gn[i].p_cost), 2),", "# Qg.v0[i] * base_mva) * base_mva**2", "i", "=", "r_", "[", "range", "(", "self", ".", "_Pg", ".", "i1", ",", "self", ".", "_Pg", ".", "iN", "+", "1", ")", ",", "range", "(", "self", ".", "_Qg", ".", "i1", ",", "self", ".", "_Qg", ".", "iN", "+", "1", ")", "]", "d2f", "=", "csr_matrix", "(", "(", "vstack", "(", "[", "d2f_dPg2", ",", "d2f_dQg2", "]", ")", ".", "toarray", "(", ")", ".", "flatten", "(", ")", ",", "(", "i", ",", "i", ")", ")", ",", "shape", "=", "(", "self", ".", "_nxyz", ",", "self", ".", "_nxyz", ")", ")", "return", "d2f" ]

[ "Evaluates", "the", "cost", "Hessian", "." ]

[ "def", "_gh", "(", "self", ",", "x", ")", ":", "Pgen", "=", "x", "[", "self", ".", "_Pg", ".", "i1", ":", "self", ".", "_Pg", ".", "iN", "+", "1", "]", "# Active generation in p.u.", "Qgen", "=", "x", "[", "self", ".", "_Qg", ".", "i1", ":", "self", ".", "_Qg", ".", "iN", "+", "1", "]", "# Reactive generation in p.u.", "for", "i", ",", "gen", "in", "enumerate", "(", "self", ".", "_gn", ")", ":", "gen", ".", "p", "=", "Pgen", "[", "i", "]", "*", "self", ".", "_base_mva", "# active generation in MW", "gen", ".", "q", "=", "Qgen", "[", "i", "]", "*", "self", ".", "_base_mva", "# reactive generation in MVAr", "# Rebuild the net complex bus power injection vector in p.u.", "Sbus", "=", "self", ".", "om", ".", "case", ".", "getSbus", "(", "self", ".", "_bs", ")", "Vang", "=", "x", "[", "self", ".", "_Va", ".", "i1", ":", "self", ".", "_Va", ".", "iN", "+", "1", "]", "Vmag", "=", "x", "[", "self", ".", "_Vm", ".", "i1", ":", "self", ".", "_Vm", ".", "iN", "+", "1", "]", "V", "=", "Vmag", "*", "exp", "(", "1j", "*", "Vang", ")", "# Evaluate the power flow equations.", "mis", "=", "V", "*", "conj", "(", "self", ".", "_Ybus", "*", "V", ")", "-", "Sbus", "# Equality constraints (power flow).", "g", "=", "r_", "[", "mis", ".", "real", ",", "# active power mismatch for all buses", "mis", ".", "imag", "]", "# reactive power mismatch for all buses", "# Inequality constraints (branch flow limits).", "# (line constraint is actually on square of limit)", "flow_max", "=", "array", "(", "[", "(", "l", ".", "rate_a", "/", "self", ".", "_base_mva", ")", "**", "2", "for", "l", "in", "self", ".", "_ln", "]", ")", "# FIXME: There must be a more elegant method for this.", "for", "i", ",", "v", "in", "enumerate", "(", "flow_max", ")", ":", "if", "v", "==", "0.0", ":", "flow_max", "[", "i", "]", "=", "Inf", "if", "self", ".", "flow_lim", "==", "IFLOW", ":", "If", "=", "self", ".", "_Yf", "*", "V", "It", "=", "self", ".", "_Yt", "*", "V", "# Branch current limits.", "h", "=", "r_", "[", "(", "If", "*", "conj", "(", "If", ")", ")", "-", "flow_max", ",", "(", "It", "*", "conj", "(", "It", ")", ")", "-", "flow_max", "]", "else", ":", "i_fbus", "=", "[", "e", ".", "from_bus", ".", "_i", "for", "e", "in", "self", ".", "_ln", "]", "i_tbus", "=", "[", "e", ".", "to_bus", ".", "_i", "for", "e", "in", "self", ".", "_ln", "]", "# Complex power injected at \"from\" bus (p.u.).", "Sf", "=", "V", "[", "i_fbus", "]", "*", "conj", "(", "self", ".", "_Yf", "*", "V", ")", "# Complex power injected at \"to\" bus (p.u.).", "St", "=", "V", "[", "i_tbus", "]", "*", "conj", "(", "self", ".", "_Yt", "*", "V", ")", "if", "self", ".", "flow_lim", "==", "PFLOW", ":", "# active power limit, P (Pan Wei)", "# Branch real power limits.", "h", "=", "r_", "[", "Sf", ".", "real", "(", ")", "**", "2", "-", "flow_max", ",", "St", ".", "real", "(", ")", "**", "2", "-", "flow_max", "]", "elif", "self", ".", "flow_lim", "==", "SFLOW", ":", "# apparent power limit, |S|", "# Branch apparent power limits.", "h", "=", "r_", "[", "(", "Sf", "*", "conj", "(", "Sf", ")", ")", "-", "flow_max", ",", "(", "St", "*", "conj", "(", "St", ")", ")", "-", "flow_max", "]", ".", "real", "else", ":", "raise", "ValueError", "return", "h", ",", "g" ]

[ "Evaluates", "the", "constraint", "function", "values", "." ]

[ "def", "_costfcn", "(", "self", ",", "x", ")", ":", "f", "=", "self", ".", "_f", "(", "x", ")", "df", "=", "self", ".", "_df", "(", "x", ")", "d2f", "=", "self", ".", "_d2f", "(", "x", ")", "return", "f", ",", "df", ",", "d2f" ]

[ "Evaluates", "the", "objective", "function", "gradient", "and", "Hessian", "for", "OPF", "." ]

[ "def", "_consfcn", "(", "self", ",", "x", ")", ":", "h", ",", "g", "=", "self", ".", "_gh", "(", "x", ")", "dh", ",", "dg", "=", "self", ".", "_dgh", "(", "x", ")", "return", "h", ",", "g", ",", "dh", ",", "dg" ]

[ "Evaluates", "nonlinear", "constraints", "and", "their", "Jacobian", "for", "OPF", "." ]

[ "def", "read", "(", "self", ",", "file_or_filename", ")", ":", "if", "isinstance", "(", "file_or_filename", ",", "basestring", ")", ":", "fname", "=", "os", ".", "path", ".", "basename", "(", "file_or_filename", ")", "logger", ".", "info", "(", "\"Unpickling case file [%s].\"", "%", "fname", ")", "file", "=", "None", "try", ":", "file", "=", "open", "(", "file_or_filename", ",", "\"rb\"", ")", "except", ":", "logger", ".", "error", "(", "\"Error opening %s.\"", "%", "fname", ")", "return", "None", "finally", ":", "if", "file", "is", "not", "None", ":", "case", "=", "pickle", ".", "load", "(", "file", ")", "file", ".", "close", "(", ")", "else", ":", "file", "=", "file_or_filename", "case", "=", "pickle", ".", "load", "(", "file", ")", "return", "case" ]

[ "Loads", "a", "pickled", "case", "." ]

[ "def", "write", "(", "self", ",", "file_or_filename", ")", ":", "if", "isinstance", "(", "file_or_filename", ",", "basestring", ")", ":", "fname", "=", "os", ".", "path", ".", "basename", "(", "file_or_filename", ")", "logger", ".", "info", "(", "\"Pickling case [%s].\"", "%", "fname", ")", "file", "=", "None", "try", ":", "file", "=", "open", "(", "file_or_filename", ",", "\"wb\"", ")", "except", ":", "logger", ".", "error", "(", "\"Error opening '%s'.\"", "%", "(", "fname", ")", ")", "return", "False", "finally", ":", "if", "file", "is", "not", "None", ":", "pickle", ".", "dump", "(", "self", ".", "case", ",", "file", ")", "file", ".", "close", "(", ")", "else", ":", "file", "=", "file_or_filename", "pickle", ".", "dump", "(", "file", ",", "self", ".", "case", ")", "return", "True" ]

[ "Writes", "the", "case", "to", "file", "using", "pickle", "." ]

[ "def", "process_token", "(", "self", ",", "tok", ")", ":", "if", "(", "tok", "[", "0", "]", ".", "__str__", "(", ")", "in", "(", "'Token.Comment.Multiline'", ",", "'Token.Comment'", ",", "'Token.Literal.String.Doc'", ")", ")", ":", "self", ".", "comments", "+=", "tok", "[", "1", "]", ".", "count", "(", "'\\n'", ")", "+", "1", "elif", "(", "tok", "[", "0", "]", ".", "__str__", "(", ")", "in", "(", "'Token.Comment.Single'", ")", ")", ":", "self", ".", "comments", "+=", "1", "elif", "(", "self", ".", "contains_code", "and", "tok", "[", "0", "]", ".", "__str__", "(", ")", ".", "startswith", "(", "'Token.Text'", ")", "and", "tok", "[", "1", "]", ".", "count", "(", "u'\\n'", ")", ")", ":", "# start new line", "self", ".", "contains_code", "=", "False", "self", ".", "sloc", "+=", "1", "# for c style includes", "elif", "(", "tok", "[", "0", "]", ".", "__str__", "(", ")", "==", "'Token.Comment.Preproc'", "and", "tok", "[", "1", "]", ".", "count", "(", "u'\\n'", ")", ")", ":", "# start new line", "self", ".", "contains_code", "=", "False", "self", ".", "sloc", "+=", "1", "elif", "(", "tok", "[", "0", "]", "[", "0", "]", "in", "token_types", ")", ":", "self", ".", "contains_code", "=", "True" ]

[ "count", "comments", "and", "non", "-", "empty", "lines", "that", "contain", "code" ]

[ "def", "get_metrics", "(", "self", ")", ":", "if", "(", "self", ".", "sloc", "==", "0", ")", ":", "if", "(", "self", ".", "comments", "==", "0", ")", ":", "ratio_comment_to_code", "=", "0.00", "else", ":", "ratio_comment_to_code", "=", "1.00", "else", ":", "ratio_comment_to_code", "=", "float", "(", "self", ".", "comments", ")", "/", "self", ".", "sloc", "metrics", "=", "OrderedDict", "(", "[", "(", "'sloc'", ",", "self", ".", "sloc", ")", ",", "(", "'comments'", ",", "self", ".", "comments", ")", ",", "(", "'ratio_comment_to_code'", ",", "round", "(", "ratio_comment_to_code", ",", "2", ")", ")", "]", ")", "return", "metrics" ]

[ "Calculate", "ratio_comment_to_code", "and", "return", "with", "the", "other", "values" ]

[ "def", "performAction", "(", "self", ",", "action", ")", ":", "gs", "=", "[", "g", "for", "g", "in", "self", ".", "case", ".", "online_generators", "if", "g", ".", "bus", ".", "type", "!=", "REFERENCE", "]", "assert", "len", "(", "action", ")", "==", "len", "(", "gs", ")", "logger", ".", "info", "(", "\"Action: %s\"", "%", "list", "(", "action", ")", ")", "# Set the output of each (non-reference) generator.", "for", "i", ",", "g", "in", "enumerate", "(", "gs", ")", ":", "g", ".", "p", "=", "action", "[", "i", "]", "# Compute power flows and slack generator set-point.", "NewtonPF", "(", "self", ".", "case", ",", "verbose", "=", "False", ")", ".", "solve", "(", ")", "#FastDecoupledPF(self.case, verbose=False).solve()", "# Store all generator set-points (only used for plotting).", "self", ".", "_Pg", "[", ":", ",", "self", ".", "_step", "]", "=", "[", "g", ".", "p", "for", "g", "in", "self", ".", "case", ".", "online_generators", "]", "# Apply the next load profile value to the original demand at each bus.", "if", "self", ".", "_step", "!=", "len", "(", "self", ".", "profile", ")", "-", "1", ":", "pq_buses", "=", "[", "b", "for", "b", "in", "self", ".", "case", ".", "buses", "if", "b", ".", "type", "==", "PQ", "]", "for", "i", ",", "b", "in", "enumerate", "(", "pq_buses", ")", ":", "b", ".", "p_demand", "=", "self", ".", "_Pd0", "[", "i", "]", "*", "self", ".", "profile", "[", "self", ".", "_step", "+", "1", "]", "self", ".", "_step", "+=", "1", "logger", ".", "info", "(", "\"Entering step %d.\"", "%", "self", ".", "_step", ")" ]

[ "Perform", "an", "action", "on", "the", "world", "that", "changes", "it", "s", "internal", "state", "." ]

[ "def", "reset", "(", "self", ")", ":", "logger", ".", "info", "(", "\"Reseting environment.\"", ")", "self", ".", "_step", "=", "0", "# Reset the set-point of each generator to its original value.", "gs", "=", "[", "g", "for", "g", "in", "self", ".", "case", ".", "online_generators", "if", "g", ".", "bus", ".", "type", "!=", "REFERENCE", "]", "for", "i", ",", "g", "in", "enumerate", "(", "gs", ")", ":", "g", ".", "p", "=", "self", ".", "_Pg0", "[", "i", "]", "# Apply load profile to the original demand at each bus.", "for", "i", ",", "b", "in", "enumerate", "(", "[", "b", "for", "b", "in", "self", ".", "case", ".", "buses", "if", "b", ".", "type", "==", "PQ", "]", ")", ":", "b", ".", "p_demand", "=", "self", ".", "_Pd0", "[", "i", "]", "*", "self", ".", "profile", "[", "self", ".", "_step", "]", "# Initialise the record of generator set-points.", "self", ".", "_Pg", "=", "zeros", "(", "(", "len", "(", "self", ".", "case", ".", "online_generators", ")", ",", "len", "(", "self", ".", "profile", ")", ")", ")", "# Apply the first load profile value.", "# self.step()", "self", ".", "case", ".", "reset", "(", ")" ]

[ "Re", "-", "initialises", "the", "environment", "." ]

[ "def", "isFinished", "(", "self", ")", ":", "finished", "=", "(", "self", ".", "env", ".", "_step", "==", "len", "(", "self", ".", "env", ".", "profile", ")", ")", "if", "finished", ":", "logger", ".", "info", "(", "\"Finished episode.\"", ")", "return", "finished" ]

[ "Is", "the", "current", "episode", "over?" ]

[ "def", "_oneInteraction", "(", "self", ")", ":", "if", "self", ".", "doOptimization", ":", "raise", "Exception", "(", "'When using a black-box learning algorithm, only full episodes can be done.'", ")", "else", ":", "self", ".", "stepid", "+=", "1", "self", ".", "agent", ".", "integrateObservation", "(", "self", ".", "task", ".", "getObservation", "(", ")", ")", "self", ".", "task", ".", "performAction", "(", "self", ".", "agent", ".", "getAction", "(", ")", ")", "# Save the cumulative sum of set-points for each period.", "for", "i", ",", "g", "in", "enumerate", "(", "self", ".", "task", ".", "env", ".", "case", ".", "online_generators", ")", ":", "self", ".", "Pg", "[", "i", ",", "self", ".", "stepid", "-", "1", "]", "=", "self", ".", "Pg", "[", "i", ",", "self", ".", "stepid", "-", "1", "]", "+", "g", ".", "p", "reward", "=", "self", ".", "task", ".", "getReward", "(", ")", "self", ".", "agent", ".", "giveReward", "(", "reward", ")", "return", "reward" ]

[ "Does", "one", "interaction", "between", "the", "task", "and", "the", "agent", "." ]

[ "def", "doEpisodes", "(", "self", ",", "number", "=", "1", ")", ":", "env", "=", "self", ".", "task", ".", "env", "self", ".", "Pg", "=", "zeros", "(", "(", "len", "(", "env", ".", "case", ".", "online_generators", ")", ",", "len", "(", "env", ".", "profile", ")", ")", ")", "rewards", "=", "super", "(", "OPFExperiment", ",", "self", ")", ".", "doEpisodes", "(", "number", ")", "# Average the set-points for each period.", "self", ".", "Pg", "=", "self", ".", "Pg", "/", "number", "return", "rewards" ]

[ "Does", "the", "the", "given", "number", "of", "episodes", "." ]

[ "def", "getMethodByName", "(", "obj", ",", "name", ")", ":", "try", ":", "#to get a method by asking the service", "obj", "=", "obj", ".", "_getMethodByName", "(", "name", ")", "except", ":", "#assumed a childObject is ment ", "#split the name from objName.childObjName... -> [objName, childObjName, ...]", "#and get all objects up to the last in list with name checking from the service object", "names", "=", "name", ".", "split", "(", "\".\"", ")", "for", "name", "in", "names", ":", "if", "nameAllowed", "(", "name", ")", ":", "obj", "=", "getattr", "(", "obj", ",", "name", ")", "else", ":", "raise", "MethodNameNotAllowed", "(", ")", "return", "obj" ]

[ "searches", "for", "an", "object", "with", "the", "name", "given", "inside", "the", "object", "given", ".", "obj", ".", "child", ".", "meth", "will", "return", "the", "meth", "obj", "." ]

[ "def", "waitForResponse", "(", "self", ",", "timeOut", "=", "None", ")", ":", "self", ".", "__evt", ".", "wait", "(", "timeOut", ")", "if", "self", ".", "waiting", "(", ")", ":", "raise", "Timeout", "(", ")", "else", ":", "if", "self", ".", "response", "[", "\"error\"", "]", ":", "raise", "Exception", "(", "self", ".", "response", "[", "\"error\"", "]", ")", "else", ":", "return", "self", ".", "response", "[", "\"result\"", "]" ]

[ "blocks", "until", "the", "response", "arrived", "or", "timeout", "is", "reached", "." ]

[ "def", "sendRequest", "(", "self", ",", "name", ",", "args", ")", ":", "(", "respEvt", ",", "id", ")", "=", "self", ".", "newResponseEvent", "(", ")", "self", ".", "sendMessage", "(", "{", "\"id\"", ":", "id", ",", "\"method\"", ":", "name", ",", "\"params\"", ":", "args", "}", ")", "return", "respEvt" ]

[ "sends", "a", "request", "to", "the", "peer" ]

[ "def", "sendResponse", "(", "self", ",", "id", ",", "result", ",", "error", ")", ":", "self", ".", "sendMessage", "(", "{", "\"result\"", ":", "result", ",", "\"error\"", ":", "error", ",", "\"id\"", ":", "id", "}", ")" ]

[ "sends", "a", "response", "to", "the", "peer" ]

[ "def", "newResponseEvent", "(", "self", ")", ":", "respEvt", "=", "ResponseEvent", "(", ")", "self", ".", "respLock", ".", "acquire", "(", ")", "eid", "=", "id", "(", "respEvt", ")", "self", ".", "respEvents", "[", "eid", "]", "=", "respEvt", "self", ".", "respLock", ".", "release", "(", ")", "return", "(", "respEvt", ",", "eid", ")" ]

[ "creates", "a", "response", "event", "and", "adds", "it", "to", "a", "waiting", "list", "When", "the", "reponse", "arrives", "it", "will", "be", "removed", "from", "the", "list", "." ]

[ "def", "handleResponse", "(", "self", ",", "resp", ")", ":", "id", "=", "resp", "[", "\"id\"", "]", "evt", "=", "self", ".", "respEvents", "[", "id", "]", "del", "(", "self", ".", "respEvents", "[", "id", "]", ")", "evt", ".", "handleResponse", "(", "resp", ")" ]

[ "handles", "a", "response", "by", "fireing", "the", "response", "event", "for", "the", "response", "coming", "in" ]

[ "def", "handleRequest", "(", "self", ",", "req", ")", ":", "name", "=", "req", "[", "\"method\"", "]", "params", "=", "req", "[", "\"params\"", "]", "id", "=", "req", "[", "\"id\"", "]", "obj", "=", "None", "try", ":", "#to get a callable obj ", "obj", "=", "getMethodByName", "(", "self", ".", "service", ",", "name", ")", "except", "MethodNameNotAllowed", ",", "e", ":", "self", ".", "sendResponse", "(", "id", ",", "None", ",", "e", ")", "except", ":", "self", ".", "sendResponse", "(", "id", ",", "None", ",", "MethodNotFound", "(", ")", ")", "if", "obj", ":", "try", ":", "#to call the object with parameters", "rslt", "=", "obj", "(", "*", "params", ")", "self", ".", "sendResponse", "(", "id", ",", "rslt", ",", "None", ")", "except", "TypeError", ":", "# wrong arguments", "#todo what if the TypeError was not thrown directly by the callable obj", "s", "=", "getTracebackStr", "(", ")", "self", ".", "sendResponse", "(", "id", ",", "None", ",", "InvalidMethodParameters", "(", ")", ")", "except", ":", "#error inside the callable object", "s", "=", "getTracebackStr", "(", ")", "self", ".", "sendResponse", "(", "id", ",", "None", ",", "s", ")" ]

[ "handles", "a", "request", "by", "calling", "the", "appropriete", "method", "the", "service", "exposes" ]

[ "def", "handleNotification", "(", "self", ",", "req", ")", ":", "name", "=", "req", "[", "\"method\"", "]", "params", "=", "req", "[", "\"params\"", "]", "try", ":", "#to get a callable obj ", "obj", "=", "getMethodByName", "(", "self", ".", "service", ",", "name", ")", "rslt", "=", "obj", "(", "*", "params", ")", "except", ":", "pass" ]

[ "handles", "a", "notification", "request", "by", "calling", "the", "appropriete", "method", "the", "service", "exposes" ]

[ "def", "read", "(", "self", ",", "file_or_filename", ")", ":", "self", ".", "file_or_filename", "=", "file_or_filename", "logger", ".", "info", "(", "\"Parsing PSAT case file [%s].\"", "%", "file_or_filename", ")", "t0", "=", "time", ".", "time", "(", ")", "self", ".", "case", "=", "Case", "(", ")", "# Name the case", "if", "isinstance", "(", "file_or_filename", ",", "basestring", ")", ":", "name", ",", "_", "=", "splitext", "(", "basename", "(", "file_or_filename", ")", ")", "else", ":", "name", ",", "_", "=", "splitext", "(", "file_or_filename", ".", "name", ")", "self", ".", "case", ".", "name", "=", "name", "bus_array", "=", "self", ".", "_get_bus_array_construct", "(", ")", "line_array", "=", "self", ".", "_get_line_array_construct", "(", ")", "# TODO: Lines.con - Alternative line data format", "slack_array", "=", "self", ".", "_get_slack_array_construct", "(", ")", "pv_array", "=", "self", ".", "_get_pv_array_construct", "(", ")", "pq_array", "=", "self", ".", "_get_pq_array_construct", "(", ")", "demand_array", "=", "self", ".", "_get_demand_array_construct", "(", ")", "supply_array", "=", "self", ".", "_get_supply_array_construct", "(", ")", "# TODO: Varname.bus (Bus names)", "# Pyparsing case:", "case", "=", "ZeroOrMore", "(", "matlab_comment", ")", "+", "bus_array", "+", "ZeroOrMore", "(", "matlab_comment", ")", "+", "line_array", "+", "ZeroOrMore", "(", "matlab_comment", ")", "+", "slack_array", "+", "ZeroOrMore", "(", "matlab_comment", ")", "+", "pv_array", "+", "ZeroOrMore", "(", "matlab_comment", ")", "+", "pq_array", "+", "ZeroOrMore", "(", "matlab_comment", ")", "+", "demand_array", "+", "ZeroOrMore", "(", "matlab_comment", ")", "+", "supply_array", "case", ".", "parseFile", "(", "file_or_filename", ")", "elapsed", "=", "time", ".", "time", "(", ")", "-", "t0", "logger", ".", "info", "(", "\"PSAT case file parsed in %.3fs.\"", "%", "elapsed", ")", "return", "self", ".", "case" ]

[ "Parses", "a", "PSAT", "data", "file", "and", "returns", "a", "case", "object" ]

[ "def", "_get_bus_array_construct", "(", "self", ")", ":", "bus_no", "=", "integer", ".", "setResultsName", "(", "\"bus_no\"", ")", "v_base", "=", "real", ".", "setResultsName", "(", "\"v_base\"", ")", "# kV", "v_magnitude", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"v_magnitude\"", ")", "v_angle", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"v_angle\"", ")", "# radians", "area", "=", "Optional", "(", "integer", ")", ".", "setResultsName", "(", "\"area\"", ")", "# not used yet", "region", "=", "Optional", "(", "integer", ")", ".", "setResultsName", "(", "\"region\"", ")", "# not used yet", "bus_data", "=", "bus_no", "+", "v_base", "+", "v_magnitude", "+", "v_angle", "+", "area", "+", "region", "+", "scolon", "bus_data", ".", "setParseAction", "(", "self", ".", "push_bus", ")", "bus_array", "=", "Literal", "(", "\"Bus.con\"", ")", "+", "\"=\"", "+", "\"[\"", "+", "\"...\"", "+", "ZeroOrMore", "(", "bus_data", "+", "Optional", "(", "\"]\"", "+", "scolon", ")", ")", "# Sort buses according to their name (bus_no)", "bus_array", ".", "setParseAction", "(", "self", ".", "sort_buses", ")", "return", "bus_array" ]

[ "Returns", "a", "construct", "for", "an", "array", "of", "bus", "data", "." ]

[ "def", "_get_line_array_construct", "(", "self", ")", ":", "from_bus", "=", "integer", ".", "setResultsName", "(", "\"fbus\"", ")", "to_bus", "=", "integer", ".", "setResultsName", "(", "\"tbus\"", ")", "s_rating", "=", "real", ".", "setResultsName", "(", "\"s_rating\"", ")", "# MVA", "v_rating", "=", "real", ".", "setResultsName", "(", "\"v_rating\"", ")", "# kV", "f_rating", "=", "real", ".", "setResultsName", "(", "\"f_rating\"", ")", "# Hz", "length", "=", "real", ".", "setResultsName", "(", "\"length\"", ")", "# km (Line only)", "v_ratio", "=", "real", ".", "setResultsName", "(", "\"v_ratio\"", ")", "# kV/kV (Transformer only)", "r", "=", "real", ".", "setResultsName", "(", "\"r\"", ")", "# p.u. or Ohms/km", "x", "=", "real", ".", "setResultsName", "(", "\"x\"", ")", "# p.u. or Henrys/km", "b", "=", "real", ".", "setResultsName", "(", "\"b\"", ")", "# p.u. or Farads/km (Line only)", "tap_ratio", "=", "real", ".", "setResultsName", "(", "\"tap\"", ")", "# p.u./p.u. (Transformer only)", "phase_shift", "=", "real", ".", "setResultsName", "(", "\"shift\"", ")", "# degrees (Transformer only)", "i_limit", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"i_limit\"", ")", "# p.u.", "p_limit", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"p_limit\"", ")", "# p.u.", "s_limit", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"s_limit\"", ")", "# p.u.", "status", "=", "Optional", "(", "boolean", ")", ".", "setResultsName", "(", "\"status\"", ")", "line_data", "=", "from_bus", "+", "to_bus", "+", "s_rating", "+", "v_rating", "+", "f_rating", "+", "length", "+", "v_ratio", "+", "r", "+", "x", "+", "b", "+", "tap_ratio", "+", "phase_shift", "+", "i_limit", "+", "p_limit", "+", "s_limit", "+", "status", "+", "scolon", "line_data", ".", "setParseAction", "(", "self", ".", "push_line", ")", "line_array", "=", "Literal", "(", "\"Line.con\"", ")", "+", "\"=\"", "+", "\"[\"", "+", "\"...\"", "+", "ZeroOrMore", "(", "line_data", "+", "Optional", "(", "\"]\"", "+", "scolon", ")", ")", "return", "line_array" ]

[ "Returns", "a", "construct", "for", "an", "array", "of", "line", "data", "." ]

[ "def", "_get_slack_array_construct", "(", "self", ")", ":", "bus_no", "=", "integer", ".", "setResultsName", "(", "\"bus_no\"", ")", "s_rating", "=", "real", ".", "setResultsName", "(", "\"s_rating\"", ")", "# MVA", "v_rating", "=", "real", ".", "setResultsName", "(", "\"v_rating\"", ")", "# kV", "v_magnitude", "=", "real", ".", "setResultsName", "(", "\"v_magnitude\"", ")", "# p.u.", "ref_angle", "=", "real", ".", "setResultsName", "(", "\"ref_angle\"", ")", "# p.u.", "q_max", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"q_max\"", ")", "# p.u.", "q_min", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"q_min\"", ")", "# p.u.", "v_max", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"v_max\"", ")", "# p.u.", "v_min", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"v_min\"", ")", "# p.u.", "p_guess", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"p_guess\"", ")", "# p.u.", "# Loss participation coefficient", "lp_coeff", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"lp_coeff\"", ")", "ref_bus", "=", "Optional", "(", "boolean", ")", ".", "setResultsName", "(", "\"ref_bus\"", ")", "status", "=", "Optional", "(", "boolean", ")", ".", "setResultsName", "(", "\"status\"", ")", "slack_data", "=", "bus_no", "+", "s_rating", "+", "v_rating", "+", "v_magnitude", "+", "ref_angle", "+", "q_max", "+", "q_min", "+", "v_max", "+", "v_min", "+", "p_guess", "+", "lp_coeff", "+", "ref_bus", "+", "status", "+", "scolon", "slack_data", ".", "setParseAction", "(", "self", ".", "push_slack", ")", "slack_array", "=", "Literal", "(", "\"SW.con\"", ")", "+", "\"=\"", "+", "\"[\"", "+", "\"...\"", "+", "ZeroOrMore", "(", "slack_data", "+", "Optional", "(", "\"]\"", "+", "scolon", ")", ")", "return", "slack_array" ]

[ "Returns", "a", "construct", "for", "an", "array", "of", "slack", "bus", "data", "." ]

[ "def", "_get_pv_array_construct", "(", "self", ")", ":", "bus_no", "=", "integer", ".", "setResultsName", "(", "\"bus_no\"", ")", "s_rating", "=", "real", ".", "setResultsName", "(", "\"s_rating\"", ")", "# MVA", "v_rating", "=", "real", ".", "setResultsName", "(", "\"v_rating\"", ")", "# kV", "p", "=", "real", ".", "setResultsName", "(", "\"p\"", ")", "# p.u.", "v", "=", "real", ".", "setResultsName", "(", "\"v\"", ")", "# p.u.", "q_max", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"q_max\"", ")", "# p.u.", "q_min", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"q_min\"", ")", "# p.u.", "v_max", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"v_max\"", ")", "# p.u.", "v_min", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"v_min\"", ")", "# p.u.", "# Loss participation coefficient", "lp_coeff", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"lp_coeff\"", ")", "status", "=", "Optional", "(", "boolean", ")", ".", "setResultsName", "(", "\"status\"", ")", "pv_data", "=", "bus_no", "+", "s_rating", "+", "v_rating", "+", "p", "+", "v", "+", "q_max", "+", "q_min", "+", "v_max", "+", "v_min", "+", "lp_coeff", "+", "status", "+", "scolon", "pv_data", ".", "setParseAction", "(", "self", ".", "push_pv", ")", "pv_array", "=", "Literal", "(", "\"PV.con\"", ")", "+", "\"=\"", "+", "\"[\"", "+", "\"...\"", "+", "ZeroOrMore", "(", "pv_data", "+", "Optional", "(", "\"]\"", "+", "scolon", ")", ")", "return", "pv_array" ]

[ "Returns", "a", "construct", "for", "an", "array", "of", "PV", "generator", "data", "." ]

[ "def", "_get_pq_array_construct", "(", "self", ")", ":", "bus_no", "=", "integer", ".", "setResultsName", "(", "\"bus_no\"", ")", "s_rating", "=", "real", ".", "setResultsName", "(", "\"s_rating\"", ")", "# MVA", "v_rating", "=", "real", ".", "setResultsName", "(", "\"v_rating\"", ")", "# kV", "p", "=", "real", ".", "setResultsName", "(", "\"p\"", ")", "# p.u.", "q", "=", "real", ".", "setResultsName", "(", "\"q\"", ")", "# p.u.", "v_max", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"v_max\"", ")", "# p.u.", "v_min", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"v_min\"", ")", "# p.u.", "# Allow conversion to impedance", "z_conv", "=", "Optional", "(", "boolean", ")", ".", "setResultsName", "(", "\"z_conv\"", ")", "status", "=", "Optional", "(", "boolean", ")", ".", "setResultsName", "(", "\"status\"", ")", "pq_data", "=", "bus_no", "+", "s_rating", "+", "v_rating", "+", "p", "+", "q", "+", "v_max", "+", "v_min", "+", "z_conv", "+", "status", "+", "scolon", "pq_data", ".", "setParseAction", "(", "self", ".", "push_pq", ")", "pq_array", "=", "Literal", "(", "\"PQ.con\"", ")", "+", "\"=\"", "+", "\"[\"", "+", "\"...\"", "+", "ZeroOrMore", "(", "pq_data", "+", "Optional", "(", "\"]\"", "+", "scolon", ")", ")", "return", "pq_array" ]

[ "Returns", "a", "construct", "for", "an", "array", "of", "PQ", "load", "data", "." ]

[ "def", "_get_demand_array_construct", "(", "self", ")", ":", "bus_no", "=", "integer", ".", "setResultsName", "(", "\"bus_no\"", ")", "s_rating", "=", "real", ".", "setResultsName", "(", "\"s_rating\"", ")", "# MVA", "p_direction", "=", "real", ".", "setResultsName", "(", "\"p_direction\"", ")", "# p.u.", "q_direction", "=", "real", ".", "setResultsName", "(", "\"q_direction\"", ")", "# p.u.", "p_bid_max", "=", "real", ".", "setResultsName", "(", "\"p_bid_max\"", ")", "# p.u.", "p_bid_min", "=", "real", ".", "setResultsName", "(", "\"p_bid_min\"", ")", "# p.u.", "p_optimal_bid", "=", "Optional", "(", "real", ")", ".", "setResultsName", "(", "\"p_optimal_bid\"", ")", "p_fixed", "=", "real", ".", "setResultsName", "(", "\"p_fixed\"", ")", "# $/hr", "p_proportional", "=", "real", ".", "setResultsName", "(", "\"p_proportional\"", ")", "# $/MWh", "p_quadratic", "=", "real", ".", "setResultsName", "(", "\"p_quadratic\"", ")", "# $/MW^2h", "q_fixed", "=", "real", ".", "setResultsName", "(", "\"q_fixed\"", ")", "# $/hr", "q_proportional", "=", "real", ".", "setResultsName", "(", "\"q_proportional\"", ")", "# $/MVArh", "q_quadratic", "=", "real", ".", "setResultsName", "(", "\"q_quadratic\"", ")", "# $/MVAr^2h", "commitment", "=", "boolean", ".", "setResultsName", "(", "\"commitment\"", ")", "cost_tie_break", "=", "real", ".", "setResultsName", "(", "\"cost_tie_break\"", ")", "# $/MWh", "cost_cong_up", "=", "real", ".", "setResultsName", "(", "\"cost_cong_up\"", ")", "# $/h", "cost_cong_down", "=", "real", ".", "setResultsName", "(", "\"cost_cong_down\"", ")", "# $/h", "status", "=", "Optional", "(", "boolean", ")", ".", "setResultsName", "(", "\"status\"", ")", "demand_data", "=", "bus_no", "+", "s_rating", "+", "p_direction", "+", "q_direction", "+", "p_bid_max", "+", "p_bid_min", "+", "p_optimal_bid", "+", "p_fixed", "+", "p_proportional", "+", "p_quadratic", "+", "q_fixed", "+", "q_proportional", "+", "q_quadratic", "+", "commitment", "+", "cost_tie_break", "+", "cost_cong_up", "+", "cost_cong_down", "+", "status", "+", "scolon", "demand_data", ".", "setParseAction", "(", "self", ".", "push_demand", ")", "demand_array", "=", "Literal", "(", "\"Demand.con\"", ")", "+", "\"=\"", "+", "\"[\"", "+", "\"...\"", "+", "ZeroOrMore", "(", "demand_data", "+", "Optional", "(", "\"]\"", "+", "scolon", ")", ")", "return", "demand_array" ]

[ "Returns", "a", "construct", "for", "an", "array", "of", "power", "demand", "data", "." ]

[ "def", "_get_supply_array_construct", "(", "self", ")", ":", "bus_no", "=", "integer", ".", "setResultsName", "(", "\"bus_no\"", ")", "s_rating", "=", "real", ".", "setResultsName", "(", "\"s_rating\"", ")", "# MVA", "p_direction", "=", "real", ".", "setResultsName", "(", "\"p_direction\"", ")", "# CPF", "p_bid_max", "=", "real", ".", "setResultsName", "(", "\"p_bid_max\"", ")", "# p.u.", "p_bid_min", "=", "real", ".", "setResultsName", "(", "\"p_bid_min\"", ")", "# p.u.", "p_bid_actual", "=", "real", ".", "setResultsName", "(", "\"p_bid_actual\"", ")", "# p.u.", "p_fixed", "=", "real", ".", "setResultsName", "(", "\"p_fixed\"", ")", "# $/hr", "p_proportional", "=", "real", ".", "setResultsName", "(", "\"p_proportional\"", ")", "# $/MWh", "p_quadratic", "=", "real", ".", "setResultsName", "(", "\"p_quadratic\"", ")", "# $/MW^2h", "q_fixed", "=", "real", ".", "setResultsName", "(", "\"q_fixed\"", ")", "# $/hr", "q_proportional", "=", "real", ".", "setResultsName", "(", "\"q_proportional\"", ")", "# $/MVArh", "q_quadratic", "=", "real", ".", "setResultsName", "(", "\"q_quadratic\"", ")", "# $/MVAr^2h", "commitment", "=", "boolean", ".", "setResultsName", "(", "\"commitment\"", ")", "cost_tie_break", "=", "real", ".", "setResultsName", "(", "\"cost_tie_break\"", ")", "# $/MWh", "lp_factor", "=", "real", ".", "setResultsName", "(", "\"lp_factor\"", ")", "# Loss participation factor", "q_max", "=", "real", ".", "setResultsName", "(", "\"q_max\"", ")", "# p.u.", "q_min", "=", "real", ".", "setResultsName", "(", "\"q_min\"", ")", "# p.u.", "cost_cong_up", "=", "real", ".", "setResultsName", "(", "\"cost_cong_up\"", ")", "# $/h", "cost_cong_down", "=", "real", ".", "setResultsName", "(", "\"cost_cong_down\"", ")", "# $/h", "status", "=", "Optional", "(", "boolean", ")", ".", "setResultsName", "(", "\"status\"", ")", "supply_data", "=", "bus_no", "+", "s_rating", "+", "p_direction", "+", "p_bid_max", "+", "p_bid_min", "+", "p_bid_actual", "+", "p_fixed", "+", "p_proportional", "+", "p_quadratic", "+", "q_fixed", "+", "q_proportional", "+", "q_quadratic", "+", "commitment", "+", "cost_tie_break", "+", "lp_factor", "+", "q_max", "+", "q_min", "+", "cost_cong_up", "+", "cost_cong_down", "+", "status", "+", "scolon", "supply_data", ".", "setParseAction", "(", "self", ".", "push_supply", ")", "supply_array", "=", "Literal", "(", "\"Supply.con\"", ")", "+", "\"=\"", "+", "\"[\"", "+", "\"...\"", "+", "ZeroOrMore", "(", "supply_data", "+", "Optional", "(", "\"]\"", "+", "scolon", ")", ")", "return", "supply_array" ]

[ "Returns", "a", "construct", "for", "an", "array", "of", "power", "supply", "data", "." ]

[ "def", "_get_generator_ramping_construct", "(", "self", ")", ":", "supply_no", "=", "integer", ".", "setResultsName", "(", "\"supply_no\"", ")", "s_rating", "=", "real", ".", "setResultsName", "(", "\"s_rating\"", ")", "# MVA", "up_rate", "=", "real", ".", "setResultsName", "(", "\"up_rate\"", ")", "# p.u./h", "down_rate", "=", "real", ".", "setResultsName", "(", "\"down_rate\"", ")", "# p.u./h", "min_period_up", "=", "real", ".", "setResultsName", "(", "\"min_period_up\"", ")", "# h", "min_period_down", "=", "real", ".", "setResultsName", "(", "\"min_period_down\"", ")", "# h", "initial_period_up", "=", "integer", ".", "setResultsName", "(", "\"initial_period_up\"", ")", "initial_period_down", "=", "integer", ".", "setResultsName", "(", "\"initial_period_down\"", ")", "c_startup", "=", "real", ".", "setResultsName", "(", "\"c_startup\"", ")", "# $", "status", "=", "boolean", ".", "setResultsName", "(", "\"status\"", ")", "g_ramp_data", "=", "supply_no", "+", "s_rating", "+", "up_rate", "+", "down_rate", "+", "min_period_up", "+", "min_period_down", "+", "initial_period_up", "+", "initial_period_down", "+", "c_startup", "+", "status", "+", "scolon", "g_ramp_array", "=", "Literal", "(", "\"Rmpg.con\"", ")", "+", "\"=\"", "+", "\"[\"", "+", "ZeroOrMore", "(", "g_ramp_data", "+", "Optional", "(", "\"]\"", "+", "scolon", ")", ")", "return", "g_ramp_array" ]

[ "Returns", "a", "construct", "for", "an", "array", "of", "generator", "ramping", "data", "." ]

[ "def", "_get_load_ramping_construct", "(", "self", ")", ":", "bus_no", "=", "integer", ".", "setResultsName", "(", "\"bus_no\"", ")", "s_rating", "=", "real", ".", "setResultsName", "(", "\"s_rating\"", ")", "# MVA", "up_rate", "=", "real", ".", "setResultsName", "(", "\"up_rate\"", ")", "# p.u./h", "down_rate", "=", "real", ".", "setResultsName", "(", "\"down_rate\"", ")", "# p.u./h", "min_up_time", "=", "real", ".", "setResultsName", "(", "\"min_up_time\"", ")", "# min", "min_down_time", "=", "real", ".", "setResultsName", "(", "\"min_down_time\"", ")", "# min", "n_period_up", "=", "integer", ".", "setResultsName", "(", "\"n_period_up\"", ")", "n_period_down", "=", "integer", ".", "setResultsName", "(", "\"n_period_down\"", ")", "status", "=", "boolean", ".", "setResultsName", "(", "\"status\"", ")", "l_ramp_data", "=", "bus_no", "+", "s_rating", "+", "up_rate", "+", "down_rate", "+", "min_up_time", "+", "min_down_time", "+", "n_period_up", "+", "n_period_down", "+", "status", "+", "scolon", "l_ramp_array", "=", "Literal", "(", "\"Rmpl.con\"", ")", "+", "\"=\"", "+", "\"[\"", "+", "ZeroOrMore", "(", "l_ramp_data", "+", "Optional", "(", "\"]\"", "+", "scolon", ")", ")", "return", "l_ramp_array" ]

[ "Returns", "a", "construct", "for", "an", "array", "of", "load", "ramping", "data", "." ]

[ "def", "push_bus", "(", "self", ",", "tokens", ")", ":", "logger", ".", "debug", "(", "\"Pushing bus data: %s\"", "%", "tokens", ")", "bus", "=", "Bus", "(", ")", "bus", ".", "name", "=", "tokens", "[", "\"bus_no\"", "]", "bus", ".", "v_magnitude", "=", "tokens", "[", "\"v_magnitude\"", "]", "bus", ".", "v_angle", "=", "tokens", "[", "\"v_angle\"", "]", "bus", ".", "v_magnitude", "=", "tokens", "[", "\"v_magnitude\"", "]", "bus", ".", "v_angle", "=", "tokens", "[", "\"v_angle\"", "]", "self", ".", "case", ".", "buses", ".", "append", "(", "bus", ")" ]

[ "Adds", "a", "Bus", "object", "to", "the", "case", "." ]

[ "def", "push_line", "(", "self", ",", "tokens", ")", ":", "logger", ".", "debug", "(", "\"Pushing line data: %s\"", "%", "tokens", ")", "from_bus", "=", "self", ".", "case", ".", "buses", "[", "tokens", "[", "\"fbus\"", "]", "-", "1", "]", "to_bus", "=", "self", ".", "case", ".", "buses", "[", "tokens", "[", "\"tbus\"", "]", "-", "1", "]", "e", "=", "Branch", "(", "from_bus", "=", "from_bus", ",", "to_bus", "=", "to_bus", ")", "e", ".", "r", "=", "tokens", "[", "\"r\"", "]", "e", ".", "x", "=", "tokens", "[", "\"x\"", "]", "e", ".", "b", "=", "tokens", "[", "\"b\"", "]", "e", ".", "rate_a", "=", "tokens", "[", "\"s_limit\"", "]", "e", ".", "rate_b", "=", "tokens", "[", "\"p_limit\"", "]", "e", ".", "rate_c", "=", "tokens", "[", "\"i_limit\"", "]", "# Optional parameter", "if", "tokens", "[", "\"tap\"", "]", "==", "0", ":", "#Transmission line", "e", ".", "ratio", "=", "1.0", "else", ":", "# Transformer", "e", ".", "ratio", "=", "tokens", "[", "\"tap\"", "]", "e", ".", "phase_shift", "=", "tokens", "[", "\"shift\"", "]", "# Optional parameter", "# if \"status\" in tokens.keys:", "# e.online = tokens[\"status\"]", "self", ".", "case", ".", "branches", ".", "append", "(", "e", ")" ]

[ "Adds", "a", "Branch", "object", "to", "the", "case", "." ]

[ "def", "push_slack", "(", "self", ",", "tokens", ")", ":", "logger", ".", "debug", "(", "\"Pushing slack data: %s\"", "%", "tokens", ")", "bus", "=", "self", ".", "case", ".", "buses", "[", "tokens", "[", "\"bus_no\"", "]", "-", "1", "]", "g", "=", "Generator", "(", "bus", ")", "g", ".", "q_max", "=", "tokens", "[", "\"q_max\"", "]", "g", ".", "q_min", "=", "tokens", "[", "\"q_min\"", "]", "# Optional parameter", "# if tokens.has_key(\"status\"):", "# g.online = tokens[\"status\"]", "self", ".", "case", ".", "generators", ".", "append", "(", "g", ")", "bus", ".", "type", "=", "\"ref\"" ]

[ "Finds", "the", "slack", "bus", "adds", "a", "Generator", "with", "the", "appropriate", "data", "and", "sets", "the", "bus", "type", "to", "slack", "." ]

[ "def", "push_pv", "(", "self", ",", "tokens", ")", ":", "logger", ".", "debug", "(", "\"Pushing PV data: %s\"", "%", "tokens", ")", "bus", "=", "self", ".", "case", ".", "buses", "[", "tokens", "[", "\"bus_no\"", "]", "-", "1", "]", "g", "=", "Generator", "(", "bus", ")", "g", ".", "p", "=", "tokens", "[", "\"p\"", "]", "g", ".", "q_max", "=", "tokens", "[", "\"q_max\"", "]", "g", ".", "q_min", "=", "tokens", "[", "\"q_min\"", "]", "# Optional parameter", "# if tokens.has_key(\"status\"):", "# g.online = tokens[\"status\"]", "self", ".", "case", ".", "generators", ".", "append", "(", "g", ")" ]

[ "Creates", "and", "Generator", "object", "populates", "it", "with", "data", "finds", "its", "Bus", "and", "adds", "it", "." ]

[ "def", "push_pq", "(", "self", ",", "tokens", ")", ":", "logger", ".", "debug", "(", "\"Pushing PQ data: %s\"", "%", "tokens", ")", "bus", "=", "self", ".", "case", ".", "buses", "[", "tokens", "[", "\"bus_no\"", "]", "-", "1", "]", "bus", ".", "p_demand", "=", "tokens", "[", "\"p\"", "]", "bus", ".", "q_demand", "=", "tokens", "[", "\"q\"", "]" ]

[ "Creates", "and", "Load", "object", "populates", "it", "with", "data", "finds", "its", "Bus", "and", "adds", "it", "." ]

[ "def", "push_supply", "(", "self", ",", "tokens", ")", ":", "logger", ".", "debug", "(", "\"Pushing supply data: %s\"", "%", "tokens", ")", "bus", "=", "self", ".", "case", ".", "buses", "[", "tokens", "[", "\"bus_no\"", "]", "-", "1", "]", "n_generators", "=", "len", "(", "[", "g", "for", "g", "in", "self", ".", "case", ".", "generators", "if", "g", ".", "bus", "==", "bus", "]", ")", "if", "n_generators", "==", "0", ":", "logger", ".", "error", "(", "\"No generator at bus [%s] for matching supply\"", "%", "bus", ")", "return", "elif", "n_generators", ">", "1", ":", "g", "=", "[", "g", "for", "g", "in", "self", ".", "case", ".", "generators", "if", "g", ".", "bus", "==", "bus", "]", "[", "0", "]", "logger", ".", "warning", "(", "\"More than one generator at bus [%s] for demand. Using the \"", "\"first one [%s].\"", "%", "(", "bus", ",", "g", ")", ")", "else", ":", "g", "=", "[", "g", "for", "g", "in", "self", ".", "case", ".", "generators", "if", "g", ".", "bus", "==", "bus", "]", "[", "0", "]", "g", ".", "pcost_model", "=", "\"poly\"", "g", ".", "poly_coeffs", "=", "(", "tokens", "[", "\"p_fixed\"", "]", ",", "tokens", "[", "\"p_proportional\"", "]", ",", "tokens", "[", "\"p_quadratic\"", "]", ")" ]

[ "Adds", "OPF", "and", "CPF", "data", "to", "a", "Generator", "." ]

[ "def", "_parse_file", "(", "self", ",", "file", ")", ":", "case", "=", "Case", "(", ")", "file", ".", "seek", "(", "0", ")", "line", "=", "file", ".", "readline", "(", ")", ".", "split", "(", ")", "if", "line", "[", "0", "]", "!=", "\"function\"", ":", "logger", ".", "error", "(", "\"Invalid data file header.\"", ")", "return", "case", "if", "line", "[", "1", "]", "!=", "\"mpc\"", ":", "self", ".", "_is_struct", "=", "False", "base", "=", "\"\"", "else", ":", "base", "=", "\"mpc.\"", "case", ".", "name", "=", "line", "[", "-", "1", "]", "for", "line", "in", "file", ":", "if", "line", ".", "startswith", "(", "\"%sbaseMVA\"", "%", "base", ")", ":", "case_data", "=", "line", ".", "rstrip", "(", "\";\\n\"", ")", ".", "split", "(", ")", "case", ".", "base_mva", "=", "float", "(", "case_data", "[", "-", "1", "]", ")", "elif", "line", ".", "startswith", "(", "\"%sbus\"", "%", "base", ")", ":", "self", ".", "_parse_buses", "(", "case", ",", "file", ")", "elif", "line", ".", "startswith", "(", "\"%sgencost\"", "%", "base", ")", ":", "self", ".", "_parse_gencost", "(", "case", ",", "file", ")", "elif", "line", ".", "startswith", "(", "\"%sgen\"", "%", "base", ")", ":", "self", ".", "_parse_generators", "(", "case", ",", "file", ")", "elif", "line", ".", "startswith", "(", "\"%sbranch\"", "%", "base", ")", ":", "self", ".", "_parse_branches", "(", "case", ",", "file", ")", "return", "case" ]

[ "Parses", "the", "given", "file", "-", "like", "object", "." ]

[ "def", "write", "(", "self", ",", "file_or_filename", ")", ":", "if", "isinstance", "(", "file_or_filename", ",", "basestring", ")", ":", "self", ".", "_fcn_name", ",", "_", "=", "splitext", "(", "basename", "(", "file_or_filename", ")", ")", "else", ":", "self", ".", "_fcn_name", "=", "self", ".", "case", ".", "name", "self", ".", "_fcn_name", "=", "self", ".", "_fcn_name", ".", "replace", "(", "\",\"", ",", "\"\"", ")", ".", "replace", "(", "\" \"", ",", "\"_\"", ")", "super", "(", "MATPOWERWriter", ",", "self", ")", ".", "write", "(", "file_or_filename", ")" ]

[ "Writes", "case", "data", "to", "file", "in", "MATPOWER", "format", "." ]

[ "def", "write_case_data", "(", "self", ",", "file", ")", ":", "file", ".", "write", "(", "\"function mpc = %s\\n\"", "%", "self", ".", "_fcn_name", ")", "file", ".", "write", "(", "'\\n%%%% MATPOWER Case Format : Version %d\\n'", "%", "2", ")", "file", ".", "write", "(", "\"mpc.version = '%d';\\n\"", "%", "2", ")", "file", ".", "write", "(", "\"\\n%%%%----- Power Flow Data -----%%%%\\n\"", ")", "file", ".", "write", "(", "\"%%%% system MVA base\\n\"", ")", "file", ".", "write", "(", "\"%sbaseMVA = %g;\\n\"", "%", "(", "self", ".", "_prefix", ",", "self", ".", "case", ".", "base_mva", ")", ")" ]

[ "Writes", "the", "case", "data", "in", "MATPOWER", "format", "." ]

[ "def", "write_generator_cost_data", "(", "self", ",", "file", ")", ":", "file", ".", "write", "(", "\"\\n%%%% generator cost data\\n\"", ")", "file", ".", "write", "(", "\"%%\\t1\\tstartup\\tshutdown\\tn\\tx1\\ty1\\t...\\txn\\tyn\\n\"", ")", "file", ".", "write", "(", "\"%%\\t2\\tstartup\\tshutdown\\tn\\tc(n-1)\\t...\\tc0\\n\"", ")", "file", ".", "write", "(", "\"%sgencost = [\\n\"", "%", "self", ".", "_prefix", ")", "for", "generator", "in", "self", ".", "case", ".", "generators", ":", "n", "=", "len", "(", "generator", ".", "p_cost", ")", "template", "=", "'\\t%d\\t%g\\t%g\\t%d'", "for", "_", "in", "range", "(", "n", ")", ":", "template", "=", "'%s\\t%%g'", "%", "template", "template", "=", "'%s;\\n'", "%", "template", "if", "generator", ".", "pcost_model", "==", "PW_LINEAR", ":", "t", "=", "2", "# cp = [p for p, q in generator.p_cost]", "# cq = [q for p, q in generator.p_cost]", "# c = zip(cp, cq)", "c", "=", "[", "v", "for", "pc", "in", "generator", ".", "p_cost", "for", "v", "in", "pc", "]", "elif", "generator", ".", "pcost_model", "==", "POLYNOMIAL", ":", "t", "=", "1", "c", "=", "list", "(", "generator", ".", "p_cost", ")", "else", ":", "raise", "vals", "=", "[", "t", ",", "generator", ".", "c_startup", ",", "generator", ".", "c_shutdown", ",", "n", "]", "+", "c", "file", ".", "write", "(", "template", "%", "tuple", "(", "vals", ")", ")", "file", ".", "write", "(", "\"];\\n\"", ")" ]

[ "Writes", "generator", "cost", "data", "to", "file", "." ]

[ "def", "write_area_data", "(", "self", ",", "file", ")", ":", "file", ".", "write", "(", "\"%% area data\"", "+", "\"\\n\"", ")", "file", ".", "write", "(", "\"%\\tno.\\tprice_ref_bus\"", "+", "\"\\n\"", ")", "file", ".", "write", "(", "\"areas = [\"", "+", "\"\\n\"", ")", "# TODO: Implement areas", "file", ".", "write", "(", "\"\\t1\\t1;\"", "+", "\"\\n\"", ")", "file", ".", "write", "(", "\"];\"", "+", "\"\\n\"", ")" ]

[ "Writes", "area", "data", "to", "file", "." ]

[ "def", "process_file", "(", "self", ",", "language", ",", "key", ",", "token_list", ")", ":", "self", ".", "language", "=", "language", "for", "tok", "in", "token_list", ":", "self", ".", "process_token", "(", "tok", ")" ]

[ "Initiate", "processing", "for", "each", "token", "." ]

[ "def", "draw_plot", "(", "self", ")", ":", "pylab", ".", "ion", "(", ")", "fig", "=", "pylab", ".", "figure", "(", "1", ")", "# State plot.", "# state_axis = fig.add_subplot(3, 1, 1) # numrows, numcols, fignum", "# state_axis.title = 'State'", "# state_axis.xlabel = 'Time (hours)'", "# state_axis.grid = True", "# for i in range(self.state_data.shape[0]):", "# lines = state_axis.plot(self.state_data[i, 0], \"g+-\")", "# self.state_lines.append(lines[0])", "# Action plot.", "# action_axis = fig.add_subplot(3, 1, 2)", "# action_axis.title = 'Action'", "# action_axis.xlabel = 'Time (hours)'", "# action_axis.ylabel = 'Price ($/MWh)'", "# action_axis.grid = True", "# for i in range(self.action_data.shape[0]):", "# lines = action_axis.plot(self.action_data[i, 0], \"ro-\")", "# self.action_lines.append(lines[0])", "# Reward plot.", "reward_axis", "=", "fig", ".", "add_subplot", "(", "3", ",", "1", ",", "3", ")", "# reward_axis.title = 'Reward'", "# reward_axis.xlabel = 'Time (hours)'", "# reward_axis.ylabel = 'Earnings ($)'", "# reward_axis.grid(True)", "reward_lines", "=", "reward_axis", ".", "plot", "(", "self", ".", "reward_data", "[", "0", ",", "0", "]", ",", "[", "0", "]", ",", "\"mx-\"", ")", "self", ".", "reward_line", "=", "reward_lines", "[", "0", "]", "pylab", ".", "draw", "(", ")" ]

[ "Initialises", "plots", "of", "the", "environment", "." ]

[ "def", "write_case_data", "(", "self", ",", "file", ")", ":", "change_code", "=", "0", "s_base", "=", "self", ".", "case", ".", "base_mva", "timestr", "=", "time", ".", "strftime", "(", "\"%Y%m%d%H%M\"", ",", "time", ".", "gmtime", "(", ")", ")", "file", ".", "write", "(", "\"%d, %8.2f, 30 / PSS(tm)E-30 RAW created by Pylon (%s).\\n\"", "%", "(", "change_code", ",", "s_base", ",", "timestr", ")", ")", "file", ".", "write", "(", "\"Modified by Hantao Cui, CURENT, UTK\\n \"", ")", "file", ".", "write", "(", "\"%s, %d BUSES, %d BRANCHES\\n\"", "%", "(", "self", ".", "case", ".", "name", ",", "len", "(", "self", ".", "case", ".", "buses", ")", ",", "len", "(", "self", ".", "case", ".", "branches", ")", ")", ")" ]

[ "Writes", "case", "data", "to", "file", "." ]

[ "def", "plotGenCost", "(", "generators", ")", ":", "figure", "(", ")", "plots", "=", "[", "]", "for", "generator", "in", "generators", ":", "if", "generator", ".", "pcost_model", "==", "PW_LINEAR", ":", "x", "=", "[", "x", "for", "x", ",", "_", "in", "generator", ".", "p_cost", "]", "y", "=", "[", "y", "for", "_", ",", "y", "in", "generator", ".", "p_cost", "]", "elif", "generator", ".", "pcost_model", "==", "POLYNOMIAL", ":", "x", "=", "scipy", ".", "arange", "(", "generator", ".", "p_min", ",", "generator", ".", "p_max", ",", "5", ")", "y", "=", "scipy", ".", "polyval", "(", "scipy", ".", "array", "(", "generator", ".", "p_cost", ")", ",", "x", ")", "else", ":", "raise", "plots", ".", "append", "(", "plot", "(", "x", ",", "y", ")", ")", "xlabel", "(", "\"P (MW)\"", ")", "ylabel", "(", "\"Cost ($)\"", ")", "legend", "(", "plots", ",", "[", "g", ".", "name", "for", "g", "in", "generators", "]", ")", "show", "(", ")" ]

[ "Plots", "the", "costs", "of", "the", "given", "generators", "." ]

[ "def", "write", "(", "self", ",", "file", ")", ":", "# Write environment state data.", "file", ".", "write", "(", "\"State\\n\"", ")", "file", ".", "write", "(", "(", "\"-\"", "*", "5", ")", "+", "\"\\n\"", ")", "self", ".", "writeDataTable", "(", "file", ",", "type", "=", "\"state\"", ")", "# Write action data.", "file", ".", "write", "(", "\"Action\\n\"", ")", "file", ".", "write", "(", "(", "\"-\"", "*", "6", ")", "+", "\"\\n\"", ")", "self", ".", "writeDataTable", "(", "file", ",", "type", "=", "\"action\"", ")", "# Write reward data.", "file", ".", "write", "(", "\"Reward\\n\"", ")", "file", ".", "write", "(", "(", "\"-\"", "*", "6", ")", "+", "\"\\n\"", ")", "self", ".", "writeDataTable", "(", "file", ",", "type", "=", "\"reward\"", ")" ]

[ "Writes", "market", "experiment", "data", "to", "file", "in", "ReStructuredText", "format", "." ]

[ "def", "writeDataTable", "(", "self", ",", "file", ",", "type", ")", ":", "agents", "=", "self", ".", "experiment", ".", "agents", "numAgents", "=", "len", "(", "self", ".", "experiment", ".", "agents", ")", "colWidth", "=", "8", "idxColWidth", "=", "3", "sep", "=", "(", "\"=\"", "*", "idxColWidth", ")", "+", "\" \"", "+", "(", "\"=\"", "*", "colWidth", "+", "\" \"", ")", "*", "numAgents", "+", "\"\\n\"", "file", ".", "write", "(", "sep", ")", "# Table column headers.", "file", ".", "write", "(", "\"..\"", ".", "rjust", "(", "idxColWidth", ")", "+", "\" \"", ")", "for", "agent", "in", "agents", ":", "# The end of the name is typically the unique part.", "file", ".", "write", "(", "agent", ".", "name", "[", "-", "colWidth", ":", "]", ".", "center", "(", "colWidth", ")", "+", "\" \"", ")", "file", ".", "write", "(", "\"\\n\"", ")", "file", ".", "write", "(", "sep", ")", "# Table values.", "if", "agents", ":", "rows", ",", "_", "=", "agents", "[", "0", "]", ".", "history", ".", "getField", "(", "type", ")", ".", "shape", "else", ":", "rows", ",", "_", "=", "(", "0", ",", "0", ")", "for", "sequence", "in", "range", "(", "min", "(", "rows", ",", "999", ")", ")", ":", "file", ".", "write", "(", "str", "(", "sequence", "+", "1", ")", ".", "rjust", "(", "idxColWidth", ")", "+", "\" \"", ")", "for", "agent", "in", "agents", ":", "field", "=", "agent", ".", "history", ".", "getField", "(", "type", ")", "# FIXME: Handle multiple state values.", "file", ".", "write", "(", "\"%8.3f \"", "%", "field", "[", "sequence", ",", "0", "]", ")", "file", ".", "write", "(", "\"\\n\"", ")", "file", ".", "write", "(", "sep", ")" ]

[ "Writes", "agent", "data", "to", "an", "ReST", "table", ".", "The", "type", "argument", "may", "be", "state", "action", "or", "reward", "." ]

[ "def", "performAction", "(", "self", ",", "action", ")", ":", "# print \"ACTION:\", action", "self", ".", "t", "+=", "1", "Task", ".", "performAction", "(", "self", ",", "action", ")", "# self.addReward()", "self", ".", "samples", "+=", "1" ]

[ "Execute", "one", "action", "." ]

[ "def", "split_dae_alg", "(", "eqs", ":", "SYM", ",", "dx", ":", "SYM", ")", "->", "Dict", "[", "str", ",", "SYM", "]", ":", "dae", "=", "[", "]", "alg", "=", "[", "]", "for", "eq", "in", "ca", ".", "vertsplit", "(", "eqs", ")", ":", "if", "ca", ".", "depends_on", "(", "eq", ",", "dx", ")", ":", "dae", ".", "append", "(", "eq", ")", "else", ":", "alg", ".", "append", "(", "eq", ")", "return", "{", "'dae'", ":", "ca", ".", "vertcat", "(", "*", "dae", ")", ",", "'alg'", ":", "ca", ".", "vertcat", "(", "*", "alg", ")", "}" ]

[ "Split", "equations", "into", "differential", "algebraic", "and", "algebraic", "only" ]

[ "def", "permute", "(", "x", ":", "SYM", ",", "perm", ":", "List", "[", "int", "]", ")", "->", "SYM", ":", "x_s", "=", "[", "]", "for", "i", "in", "perm", ":", "x_s", ".", "append", "(", "x", "[", "i", "]", ")", "return", "ca", ".", "vertcat", "(", "*", "x_s", ")" ]

[ "Perumute", "a", "vector" ]

[ "def", "blt", "(", "f", ":", "List", "[", "SYM", "]", ",", "x", ":", "List", "[", "SYM", "]", ")", "->", "Dict", "[", "str", ",", "Any", "]", ":", "J", "=", "ca", ".", "jacobian", "(", "f", ",", "x", ")", "nblock", ",", "rowperm", ",", "colperm", ",", "rowblock", ",", "colblock", ",", "coarserow", ",", "coarsecol", "=", "J", ".", "sparsity", "(", ")", ".", "btf", "(", ")", "return", "{", "'J'", ":", "J", ",", "'nblock'", ":", "nblock", ",", "'rowperm'", ":", "rowperm", ",", "'colperm'", ":", "colperm", ",", "'rowblock'", ":", "rowblock", ",", "'colblock'", ":", "colblock", ",", "'coarserow'", ":", "coarserow", ",", "'coarsecol'", ":", "coarsecol", "}" ]

[ "Sort", "equations", "by", "dependence" ]

[ "def", "create_function_f_m", "(", "self", ")", ":", "return", "ca", ".", "Function", "(", "'f_m'", ",", "[", "self", ".", "t", ",", "self", ".", "x", ",", "self", ".", "y", ",", "self", ".", "m", ",", "self", ".", "p", ",", "self", ".", "c", ",", "self", ".", "pre_c", ",", "self", ".", "ng", ",", "self", ".", "nu", "]", ",", "[", "self", ".", "f_m", "]", ",", "[", "'t'", ",", "'x'", ",", "'y'", ",", "'m'", ",", "'p'", ",", "'c'", ",", "'pre_c'", ",", "'ng'", ",", "'nu'", "]", ",", "[", "'m'", "]", ",", "self", ".", "func_opt", ")" ]

[ "Discrete", "state", "dynamics" ]

[ "def", "create_function_f_J", "(", "self", ")", ":", "return", "ca", ".", "Function", "(", "'J'", ",", "[", "self", ".", "t", ",", "self", ".", "x", ",", "self", ".", "y", ",", "self", ".", "m", ",", "self", ".", "p", ",", "self", ".", "c", ",", "self", ".", "ng", ",", "self", ".", "nu", "]", ",", "[", "ca", ".", "jacobian", "(", "self", ".", "f_x_rhs", ",", "self", ".", "x", ")", "]", ",", "[", "'t'", ",", "'x'", ",", "'y'", ",", "'m'", ",", "'p'", ",", "'c'", ",", "'ng'", ",", "'nu'", "]", ",", "[", "'J'", "]", ",", "self", ".", "func_opt", ")" ]

[ "Jacobian", "for", "state", "integration" ]

[ "def", "to_ode", "(", "self", ")", "->", "HybridOde", ":", "res_split", "=", "split_dae_alg", "(", "self", ".", "f_x", ",", "self", ".", "dx", ")", "alg", "=", "res_split", "[", "'alg'", "]", "dae", "=", "res_split", "[", "'dae'", "]", "x_rhs", "=", "tangent_approx", "(", "dae", ",", "self", ".", "dx", ",", "assert_linear", "=", "True", ")", "y_rhs", "=", "tangent_approx", "(", "alg", ",", "self", ".", "y", ",", "assert_linear", "=", "True", ")", "return", "HybridOde", "(", "c", "=", "self", ".", "c", ",", "dx", "=", "self", ".", "dx", ",", "f_c", "=", "self", ".", "f_c", ",", "f_i", "=", "self", ".", "f_i", ",", "f_m", "=", "self", ".", "f_m", ",", "f_x_rhs", "=", "x_rhs", ",", "y_rhs", "=", "y_rhs", ",", "m", "=", "self", ".", "m", ",", "ng", "=", "self", ".", "ng", ",", "nu", "=", "self", ".", "nu", ",", "p", "=", "self", ".", "p", ",", "pre_m", "=", "self", ".", "pre_m", ",", "pre_c", "=", "self", ".", "pre_c", ",", "prop", "=", "self", ".", "prop", ",", "sym", "=", "self", ".", "sym", ",", "t", "=", "self", ".", "t", ",", "x", "=", "self", ".", "x", ",", "y", "=", "self", ".", "y", ",", ")" ]

[ "Convert", "to", "a", "HybridOde" ]

[ "def", "format_from_extension", "(", "fname", ")", ":", "_base", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "fname", ")", "if", "not", "ext", ":", "return", "None", "try", ":", "format", "=", "known_extensions", "[", "ext", ".", "replace", "(", "'.'", ",", "''", ")", "]", "except", "KeyError", ":", "format", "=", "None", "return", "format" ]

[ "Tries", "to", "infer", "a", "protocol", "from", "the", "file", "extension", "." ]

[ "def", "pickle_matpower_cases", "(", "case_paths", ",", "case_format", "=", "2", ")", ":", "import", "pylon", ".", "io", "if", "isinstance", "(", "case_paths", ",", "basestring", ")", ":", "case_paths", "=", "[", "case_paths", "]", "for", "case_path", "in", "case_paths", ":", "# Read the MATPOWER case file.", "case", "=", "pylon", ".", "io", ".", "MATPOWERReader", "(", "case_format", ")", ".", "read", "(", "case_path", ")", "# Give the new file the same name, but with a different extension.", "dir_path", "=", "os", ".", "path", ".", "dirname", "(", "case_path", ")", "case_basename", "=", "os", ".", "path", ".", "basename", "(", "case_path", ")", "root", ",", "_", "=", "os", ".", "path", ".", "splitext", "(", "case_basename", ")", "pickled_case_path", "=", "os", ".", "path", ".", "join", "(", "dir_path", ",", "root", "+", "'.pkl'", ")", "# Pickle the resulting Pylon Case object.", "pylon", ".", "io", ".", "PickleWriter", "(", "case", ")", ".", "write", "(", "pickled_case_path", ")" ]

[ "Parses", "the", "MATPOWER", "case", "files", "at", "the", "given", "paths", "and", "pickles", "the", "resulting", "Case", "objects", "to", "the", "same", "directory", "." ]

[ "def", "fair_max", "(", "x", ")", ":", "value", "=", "max", "(", "x", ")", "# List indexes of max value.", "i", "=", "[", "x", ".", "index", "(", "v", ")", "for", "v", "in", "x", "if", "v", "==", "value", "]", "# Select index randomly among occurances.", "idx", "=", "random", ".", "choice", "(", "i", ")", "return", "idx", ",", "value" ]

[ "Takes", "a", "single", "iterable", "as", "an", "argument", "and", "returns", "the", "same", "output", "as", "the", "built", "-", "in", "function", "max", "with", "two", "output", "parameters", "except", "that", "where", "the", "maximum", "value", "occurs", "at", "more", "than", "one", "position", "in", "the", "vector", "the", "index", "is", "chosen", "randomly", "from", "these", "positions", "as", "opposed", "to", "just", "choosing", "the", "first", "occurance", "." ]

[ "def", "factorial", "(", "n", ")", ":", "f", "=", "1", "while", "(", "n", ">", "0", ")", ":", "f", "=", "f", "*", "n", "n", "=", "n", "-", "1", "return", "f" ]

[ "Returns", "the", "factorial", "of", "n", "." ]

[ "def", "_get_name", "(", "self", ")", ":", "if", "self", ".", "_name", "is", "None", ":", "self", ".", "_name", "=", "self", ".", "_generate_name", "(", ")", "return", "self", ".", "_name" ]

[ "Returns", "the", "name", "which", "is", "generated", "if", "it", "has", "not", "been", "already", "." ]

[ "def", "save_to_file_object", "(", "self", ",", "fd", ",", "format", "=", "None", ",", "*", "*", "kwargs", ")", ":", "format", "=", "'pickle'", "if", "format", "is", "None", "else", "format", "save", "=", "getattr", "(", "self", ",", "\"save_%s\"", "%", "format", ",", "None", ")", "if", "save", "is", "None", ":", "raise", "ValueError", "(", "\"Unknown format '%s'.\"", "%", "format", ")", "save", "(", "fd", ",", "*", "*", "kwargs", ")" ]

[ "Save", "the", "object", "to", "a", "given", "file", "like", "object", "in", "the", "given", "format", "." ]

[ "def", "load_from_file_object", "(", "cls", ",", "fd", ",", "format", "=", "None", ")", ":", "format", "=", "'pickle'", "if", "format", "is", "None", "else", "format", "load", "=", "getattr", "(", "cls", ",", "\"load_%s\"", "%", "format", ",", "None", ")", "if", "load", "is", "None", ":", "raise", "ValueError", "(", "\"Unknown format '%s'.\"", "%", "format", ")", "return", "load", "(", "fd", ")" ]

[ "Load", "the", "object", "from", "a", "given", "file", "like", "object", "in", "the", "given", "format", "." ]

[ "def", "save", "(", "self", ",", "filename", ",", "format", "=", "None", ",", "*", "*", "kwargs", ")", ":", "if", "format", "is", "None", ":", "# try to derive protocol from file extension", "format", "=", "format_from_extension", "(", "filename", ")", "with", "file", "(", "filename", ",", "'wb'", ")", "as", "fp", ":", "self", ".", "save_to_file_object", "(", "fp", ",", "format", ",", "*", "*", "kwargs", ")" ]

[ "Save", "the", "object", "to", "file", "given", "by", "filename", "." ]

[ "def", "load", "(", "cls", ",", "filename", ",", "format", "=", "None", ")", ":", "if", "format", "is", "None", ":", "# try to derive protocol from file extension", "format", "=", "format_from_extension", "(", "filename", ")", "with", "file", "(", "filename", ",", "'rbU'", ")", "as", "fp", ":", "obj", "=", "cls", ".", "load_from_file_object", "(", "fp", ",", "format", ")", "obj", ".", "filename", "=", "filename", "return", "obj" ]

[ "Return", "an", "instance", "of", "the", "class", "that", "is", "saved", "in", "the", "file", "with", "the", "given", "filename", "in", "the", "specified", "format", "." ]

[ "def", "solve", "(", "self", ")", ":", "case", "=", "self", ".", "case", "logger", ".", "info", "(", "\"Starting DC power flow [%s].\"", "%", "case", ".", "name", ")", "t0", "=", "time", ".", "time", "(", ")", "# Update bus indexes.", "self", ".", "case", ".", "index_buses", "(", ")", "# Find the index of the refence bus.", "ref_idx", "=", "self", ".", "_get_reference_index", "(", "case", ")", "if", "ref_idx", "<", "0", ":", "return", "False", "# Build the susceptance matrices.", "B", ",", "Bsrc", ",", "p_businj", ",", "p_srcinj", "=", "case", ".", "Bdc", "# Get the vector of initial voltage angles.", "v_angle_guess", "=", "self", ".", "_get_v_angle_guess", "(", "case", ")", "# Calculate the new voltage phase angles.", "v_angle", ",", "p_ref", "=", "self", ".", "_get_v_angle", "(", "case", ",", "B", ",", "v_angle_guess", ",", "p_businj", ",", "ref_idx", ")", "logger", ".", "debug", "(", "\"Bus voltage phase angles: \\n%s\"", "%", "v_angle", ")", "self", ".", "v_angle", "=", "v_angle", "# Push the results to the case.", "self", ".", "_update_model", "(", "case", ",", "B", ",", "Bsrc", ",", "v_angle", ",", "p_srcinj", ",", "p_ref", ",", "ref_idx", ")", "logger", ".", "info", "(", "\"DC power flow completed in %.3fs.\"", "%", "(", "time", ".", "time", "(", ")", "-", "t0", ")", ")", "return", "True" ]

[ "Solves", "a", "DC", "power", "flow", "." ]

[ "def", "_get_reference_index", "(", "self", ",", "case", ")", ":", "refs", "=", "[", "bus", ".", "_i", "for", "bus", "in", "case", ".", "connected_buses", "if", "bus", ".", "type", "==", "REFERENCE", "]", "if", "len", "(", "refs", ")", "==", "1", ":", "return", "refs", "[", "0", "]", "else", ":", "logger", ".", "error", "(", "\"Single swing bus required for DCPF.\"", ")", "return", "-", "1" ]

[ "Returns", "the", "index", "of", "the", "reference", "bus", "." ]

[ "def", "_get_v_angle_guess", "(", "self", ",", "case", ")", ":", "v_angle", "=", "array", "(", "[", "bus", ".", "v_angle", "*", "(", "pi", "/", "180.0", ")", "for", "bus", "in", "case", ".", "connected_buses", "]", ")", "return", "v_angle" ]

[ "Make", "the", "vector", "of", "voltage", "phase", "guesses", "." ]

[ "def", "_get_v_angle", "(", "self", ",", "case", ",", "B", ",", "v_angle_guess", ",", "p_businj", ",", "iref", ")", ":", "buses", "=", "case", ".", "connected_buses", "pv_idxs", "=", "[", "bus", ".", "_i", "for", "bus", "in", "buses", "if", "bus", ".", "type", "==", "PV", "]", "pq_idxs", "=", "[", "bus", ".", "_i", "for", "bus", "in", "buses", "if", "bus", ".", "type", "==", "PQ", "]", "pvpq_idxs", "=", "pv_idxs", "+", "pq_idxs", "pvpq_rows", "=", "[", "[", "i", "]", "for", "i", "in", "pvpq_idxs", "]", "# Get the susceptance matrix with the column and row corresponding to", "# the reference bus removed.", "Bpvpq", "=", "B", "[", "pvpq_rows", ",", "pvpq_idxs", "]", "Bref", "=", "B", "[", "pvpq_rows", ",", "[", "iref", "]", "]", "# Bus active power injections (generation - load) adjusted for phase", "# shifters and real shunts.", "p_surplus", "=", "array", "(", "[", "case", ".", "s_surplus", "(", "v", ")", ".", "real", "for", "v", "in", "buses", "]", ")", "g_shunt", "=", "array", "(", "[", "bus", ".", "g_shunt", "for", "bus", "in", "buses", "]", ")", "Pbus", "=", "(", "p_surplus", "-", "p_businj", "-", "g_shunt", ")", "/", "case", ".", "base_mva", "Pbus", ".", "shape", "=", "len", "(", "Pbus", ")", ",", "1", "A", "=", "Bpvpq", "b", "=", "Pbus", "[", "pvpq_idxs", "]", "-", "Bref", "*", "v_angle_guess", "[", "iref", "]", "# x, res, rank, s = linalg.lstsq(A.todense(), b)", "x", "=", "spsolve", "(", "A", ",", "b", ")", "# Insert the reference voltage angle of the slack bus.", "v_angle", "=", "r_", "[", "x", "[", ":", "iref", "]", ",", "v_angle_guess", "[", "iref", "]", ",", "x", "[", "iref", ":", "]", "]", "return", "v_angle", ",", "Pbus", "[", "iref", "]" ]

[ "Calculates", "the", "voltage", "phase", "angles", "." ]

[ "def", "_update_model", "(", "self", ",", "case", ",", "B", ",", "Bsrc", ",", "v_angle", ",", "p_srcinj", ",", "p_ref", ",", "ref_idx", ")", ":", "iref", "=", "ref_idx", "base_mva", "=", "case", ".", "base_mva", "buses", "=", "case", ".", "connected_buses", "branches", "=", "case", ".", "online_branches", "p_from", "=", "(", "Bsrc", "*", "v_angle", "+", "p_srcinj", ")", "*", "base_mva", "p_to", "=", "-", "p_from", "for", "i", ",", "branch", "in", "enumerate", "(", "branches", ")", ":", "branch", ".", "p_from", "=", "p_from", "[", "i", "]", "branch", ".", "p_to", "=", "p_to", "[", "i", "]", "branch", ".", "q_from", "=", "0.0", "branch", ".", "q_to", "=", "0.0", "for", "j", ",", "bus", "in", "enumerate", "(", "buses", ")", ":", "bus", ".", "v_angle", "=", "v_angle", "[", "j", "]", "*", "(", "180", "/", "pi", ")", "bus", ".", "v_magnitude", "=", "1.0", "# Update Pg for swing generator.", "g_ref", "=", "[", "g", "for", "g", "in", "case", ".", "generators", "if", "g", ".", "bus", "==", "buses", "[", "iref", "]", "]", "[", "0", "]", "# Pg = Pinj + Pload + Gs", "# newPg = oldPg + newPinj - oldPinj", "p_inj", "=", "(", "B", "[", "iref", ",", ":", "]", "*", "v_angle", "-", "p_ref", ")", "*", "base_mva", "g_ref", ".", "p", "+=", "p_inj", "[", "0", "]" ]

[ "Updates", "the", "case", "with", "values", "computed", "from", "the", "voltage", "phase", "angle", "solution", "." ]

[ "def", "getSbus", "(", "self", ",", "buses", "=", "None", ")", ":", "bs", "=", "self", ".", "buses", "if", "buses", "is", "None", "else", "buses", "s", "=", "array", "(", "[", "self", ".", "s_surplus", "(", "v", ")", "/", "self", ".", "base_mva", "for", "v", "in", "bs", "]", ")", "return", "s" ]

[ "Returns", "the", "net", "complex", "bus", "power", "injection", "vector", "in", "p", ".", "u", "." ]

[ "def", "sort_generators", "(", "self", ")", ":", "self", ".", "generators", ".", "sort", "(", "key", "=", "lambda", "gn", ":", "gn", ".", "bus", ".", "_i", ")" ]

[ "Reorders", "the", "list", "of", "generators", "according", "to", "bus", "index", "." ]

[ "def", "index_buses", "(", "self", ",", "buses", "=", "None", ",", "start", "=", "0", ")", ":", "bs", "=", "self", ".", "connected_buses", "if", "buses", "is", "None", "else", "buses", "for", "i", ",", "b", "in", "enumerate", "(", "bs", ")", ":", "b", ".", "_i", "=", "start", "+", "i" ]

[ "Updates", "the", "indices", "of", "all", "buses", "." ]

[ "def", "index_branches", "(", "self", ",", "branches", "=", "None", ",", "start", "=", "0", ")", ":", "ln", "=", "self", ".", "online_branches", "if", "branches", "is", "None", "else", "branches", "for", "i", ",", "l", "in", "enumerate", "(", "ln", ")", ":", "l", ".", "_i", "=", "start", "+", "i" ]

[ "Updates", "the", "indices", "of", "all", "branches", "." ]

[ "def", "s_supply", "(", "self", ",", "bus", ")", ":", "Sg", "=", "array", "(", "[", "complex", "(", "g", ".", "p", ",", "g", ".", "q", ")", "for", "g", "in", "self", ".", "generators", "if", "(", "g", ".", "bus", "==", "bus", ")", "and", "not", "g", ".", "is_load", "]", ",", "dtype", "=", "complex64", ")", "if", "len", "(", "Sg", ")", ":", "return", "sum", "(", "Sg", ")", "else", ":", "return", "0", "+", "0j" ]

[ "Returns", "the", "total", "complex", "power", "generation", "capacity", "." ]

[ "def", "s_demand", "(", "self", ",", "bus", ")", ":", "Svl", "=", "array", "(", "[", "complex", "(", "g", ".", "p", ",", "g", ".", "q", ")", "for", "g", "in", "self", ".", "generators", "if", "(", "g", ".", "bus", "==", "bus", ")", "and", "g", ".", "is_load", "]", ",", "dtype", "=", "complex64", ")", "Sd", "=", "complex", "(", "bus", ".", "p_demand", ",", "bus", ".", "q_demand", ")", "return", "-", "sum", "(", "Svl", ")", "+", "Sd" ]

[ "Returns", "the", "total", "complex", "power", "demand", "." ]

[ "def", "reset", "(", "self", ")", ":", "for", "bus", "in", "self", ".", "buses", ":", "bus", ".", "reset", "(", ")", "for", "branch", "in", "self", ".", "branches", ":", "branch", ".", "reset", "(", ")", "for", "generator", "in", "self", ".", "generators", ":", "generator", ".", "reset", "(", ")" ]

[ "Resets", "the", "readonly", "variables", "for", "all", "of", "the", "case", "components", "." ]

[ "def", "save_matpower", "(", "self", ",", "fd", ")", ":", "from", "pylon", ".", "io", "import", "MATPOWERWriter", "MATPOWERWriter", "(", "self", ")", ".", "write", "(", "fd", ")" ]

[ "Serialize", "the", "case", "as", "a", "MATPOWER", "data", "file", "." ]

[ "def", "load_psat", "(", "cls", ",", "fd", ")", ":", "from", "pylon", ".", "io", ".", "psat", "import", "PSATReader", "return", "PSATReader", "(", ")", ".", "read", "(", "fd", ")" ]

[ "Returns", "a", "case", "object", "from", "the", "given", "PSAT", "data", "file", "." ]

[ "def", "save_rst", "(", "self", ",", "fd", ")", ":", "from", "pylon", ".", "io", "import", "ReSTWriter", "ReSTWriter", "(", "self", ")", ".", "write", "(", "fd", ")" ]

[ "Save", "a", "reStructuredText", "representation", "of", "the", "case", "." ]

[ "def", "save_csv", "(", "self", ",", "fd", ")", ":", "from", "pylon", ".", "io", ".", "excel", "import", "CSVWriter", "CSVWriter", "(", "self", ")", ".", "write", "(", "fd", ")" ]

[ "Saves", "the", "case", "as", "a", "series", "of", "Comma", "-", "Separated", "Values", "." ]

[ "def", "save_excel", "(", "self", ",", "fd", ")", ":", "from", "pylon", ".", "io", ".", "excel", "import", "ExcelWriter", "ExcelWriter", "(", "self", ")", ".", "write", "(", "fd", ")" ]

[ "Saves", "the", "case", "as", "an", "Excel", "spreadsheet", "." ]

[ "def", "save_dot", "(", "self", ",", "fd", ")", ":", "from", "pylon", ".", "io", "import", "DotWriter", "DotWriter", "(", "self", ")", ".", "write", "(", "fd", ")" ]

[ "Saves", "a", "representation", "of", "the", "case", "in", "the", "Graphviz", "DOT", "language", "." ]

[ "def", "solve", "(", "self", ")", ":", "# Zero result attributes.", "self", ".", "case", ".", "reset", "(", ")", "# Retrieve the contents of the case.", "b", ",", "l", ",", "g", ",", "_", ",", "_", ",", "_", ",", "_", "=", "self", ".", "_unpack_case", "(", "self", ".", "case", ")", "# Update bus indexes.", "self", ".", "case", ".", "index_buses", "(", "b", ")", "# Index buses accoding to type.", "# try:", "# _, pq, pv, pvpq = self._index_buses(b)", "# except SlackBusError:", "# logger.error(\"Swing bus required for DCPF.\")", "# return {\"converged\": False}", "refs", ",", "pq", ",", "pv", ",", "pvpq", "=", "self", ".", "_index_buses", "(", "b", ")", "if", "len", "(", "refs", ")", "!=", "1", ":", "logger", ".", "error", "(", "\"Swing bus required for DCPF.\"", ")", "return", "{", "\"converged\"", ":", "False", "}", "# Start the clock.", "t0", "=", "time", "(", ")", "# Build the vector of initial complex bus voltages.", "V0", "=", "self", ".", "_initial_voltage", "(", "b", ",", "g", ")", "# Save index and angle of original reference bus.", "# if self.qlimit:", "# ref0 = ref", "# Varef0 = b[ref0].Va", "# # List of buses at Q limits.", "# limits = []", "# # Qg of generators at Q limits.", "# fixedQg = matrix(0.0, (g.size[0], 1))", "repeat", "=", "True", "while", "repeat", ":", "# Build admittance matrices.", "Ybus", ",", "Yf", ",", "Yt", "=", "self", ".", "case", ".", "getYbus", "(", "b", ",", "l", ")", "# Compute complex bus power injections (generation - load).", "Sbus", "=", "self", ".", "case", ".", "getSbus", "(", "b", ")", "# Run the power flow.", "V", ",", "converged", ",", "i", "=", "self", ".", "_run_power_flow", "(", "Ybus", ",", "Sbus", ",", "V0", ",", "pv", ",", "pq", ",", "pvpq", ")", "# Update case with solution.", "self", ".", "case", ".", "pf_solution", "(", "Ybus", ",", "Yf", ",", "Yt", ",", "V", ")", "# Enforce generator Q limits.", "if", "self", ".", "qlimit", ":", "raise", "NotImplementedError", "else", ":", "repeat", "=", "False", "elapsed", "=", "time", "(", ")", "-", "t0", "if", "converged", "and", "self", ".", "verbose", ":", "logger", ".", "info", "(", "\"AC power flow converged in %.3fs\"", "%", "elapsed", ")", "return", "{", "\"converged\"", ":", "converged", ",", "\"elapsed\"", ":", "elapsed", ",", "\"iterations\"", ":", "i", ",", "\"V\"", ":", "V", "}" ]

[ "Runs", "a", "power", "flow" ]

[ "def", "_unpack_case", "(", "self", ",", "case", ")", ":", "base_mva", "=", "case", ".", "base_mva", "b", "=", "case", ".", "connected_buses", "l", "=", "case", ".", "online_branches", "g", "=", "case", ".", "online_generators", "nb", "=", "len", "(", "b", ")", "nl", "=", "len", "(", "l", ")", "ng", "=", "len", "(", "g", ")", "return", "b", ",", "l", ",", "g", ",", "nb", ",", "nl", ",", "ng", ",", "base_mva" ]

[ "Returns", "the", "contents", "of", "the", "case", "to", "be", "used", "in", "the", "OPF", "." ]

[ "def", "_index_buses", "(", "self", ",", "buses", ")", ":", "refs", "=", "[", "bus", ".", "_i", "for", "bus", "in", "buses", "if", "bus", ".", "type", "==", "REFERENCE", "]", "# if len(refs) != 1:", "# raise SlackBusError", "pv", "=", "[", "bus", ".", "_i", "for", "bus", "in", "buses", "if", "bus", ".", "type", "==", "PV", "]", "pq", "=", "[", "bus", ".", "_i", "for", "bus", "in", "buses", "if", "bus", ".", "type", "==", "PQ", "]", "pvpq", "=", "pv", "+", "pq", "return", "refs", ",", "pq", ",", "pv", ",", "pvpq" ]

[ "Set", "up", "indexing", "for", "updating", "v", "." ]

[ "def", "_initial_voltage", "(", "self", ",", "buses", ",", "generators", ")", ":", "Vm", "=", "array", "(", "[", "bus", ".", "v_magnitude", "for", "bus", "in", "buses", "]", ")", "# Initial bus voltage angles in radians.", "Va", "=", "array", "(", "[", "bus", ".", "v_angle", "*", "(", "pi", "/", "180.0", ")", "for", "bus", "in", "buses", "]", ")", "V", "=", "Vm", "*", "exp", "(", "1j", "*", "Va", ")", "# Get generator set points.", "for", "g", "in", "generators", ":", "i", "=", "g", ".", "bus", ".", "_i", "V", "[", "i", "]", "=", "g", ".", "v_magnitude", "/", "abs", "(", "V", "[", "i", "]", ")", "*", "V", "[", "i", "]", "return", "V" ]

[ "Returns", "the", "initial", "vector", "of", "complex", "bus", "voltages", "." ]

[ "def", "_one_iteration", "(", "self", ",", "F", ",", "Ybus", ",", "V", ",", "Vm", ",", "Va", ",", "pv", ",", "pq", ",", "pvpq", ")", ":", "J", "=", "self", ".", "_build_jacobian", "(", "Ybus", ",", "V", ",", "pv", ",", "pq", ",", "pvpq", ")", "# Update step.", "dx", "=", "-", "1", "*", "spsolve", "(", "J", ",", "F", ")", "# dx = -1 * linalg.lstsq(J.todense(), F)[0]", "# Update voltage vector.", "npv", "=", "len", "(", "pv", ")", "npq", "=", "len", "(", "pq", ")", "if", "npv", ">", "0", ":", "Va", "[", "pv", "]", "=", "Va", "[", "pv", "]", "+", "dx", "[", "range", "(", "npv", ")", "]", "if", "npq", ">", "0", ":", "Va", "[", "pq", "]", "=", "Va", "[", "pq", "]", "+", "dx", "[", "range", "(", "npv", ",", "npv", "+", "npq", ")", "]", "Vm", "[", "pq", "]", "=", "Vm", "[", "pq", "]", "+", "dx", "[", "range", "(", "npv", "+", "npq", ",", "npv", "+", "npq", "+", "npq", ")", "]", "V", "=", "Vm", "*", "exp", "(", "1j", "*", "Va", ")", "Vm", "=", "abs", "(", "V", ")", "# Avoid wrapped round negative Vm.", "Va", "=", "angle", "(", "V", ")", "return", "V", ",", "Vm", ",", "Va" ]

[ "Performs", "one", "Newton", "iteration", "." ]

[ "def", "_build_jacobian", "(", "self", ",", "Ybus", ",", "V", ",", "pv", ",", "pq", ",", "pvpq", ")", ":", "pq_col", "=", "[", "[", "i", "]", "for", "i", "in", "pq", "]", "pvpq_col", "=", "[", "[", "i", "]", "for", "i", "in", "pvpq", "]", "dS_dVm", ",", "dS_dVa", "=", "self", ".", "case", ".", "dSbus_dV", "(", "Ybus", ",", "V", ")", "J11", "=", "dS_dVa", "[", "pvpq_col", ",", "pvpq", "]", ".", "real", "J12", "=", "dS_dVm", "[", "pvpq_col", ",", "pq", "]", ".", "real", "J21", "=", "dS_dVa", "[", "pq_col", ",", "pvpq", "]", ".", "imag", "J22", "=", "dS_dVm", "[", "pq_col", ",", "pq", "]", ".", "imag", "J", "=", "vstack", "(", "[", "hstack", "(", "[", "J11", ",", "J12", "]", ")", ",", "hstack", "(", "[", "J21", ",", "J22", "]", ")", "]", ",", "format", "=", "\"csr\"", ")", "return", "J" ]

[ "Returns", "the", "Jacobian", "matrix", "." ]

[ "def", "_evaluate_mismatch", "(", "self", ",", "Ybus", ",", "V", ",", "Sbus", ",", "pq", ",", "pvpq", ")", ":", "mis", "=", "(", "multiply", "(", "V", ",", "conj", "(", "Ybus", "*", "V", ")", ")", "-", "Sbus", ")", "/", "abs", "(", "V", ")", "P", "=", "mis", "[", "pvpq", "]", ".", "real", "Q", "=", "mis", "[", "pq", "]", ".", "imag", "return", "P", ",", "Q" ]

[ "Evaluates", "the", "mismatch", "." ]

[ "def", "_p_iteration", "(", "self", ",", "P", ",", "Bp_solver", ",", "Vm", ",", "Va", ",", "pvpq", ")", ":", "dVa", "=", "-", "Bp_solver", ".", "solve", "(", "P", ")", "# Update voltage.", "Va", "[", "pvpq", "]", "=", "Va", "[", "pvpq", "]", "+", "dVa", "V", "=", "Vm", "*", "exp", "(", "1j", "*", "Va", ")", "return", "V", ",", "Vm", ",", "Va" ]

[ "Performs", "a", "P", "iteration", "updates", "Va", "." ]