repo
stringlengths 7
55
| path
stringlengths 4
127
| func_name
stringlengths 1
88
| original_string
stringlengths 75
19.8k
| language
stringclasses 1
value | code
stringlengths 75
19.8k
| code_tokens
sequence | docstring
stringlengths 3
17.3k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 87
242
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
rwl/pylon | pylon/solver.py | _Solver._var_bounds | def _var_bounds(self):
""" Returns bounds on the optimisation variables.
"""
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 | python | def _var_bounds(self):
""" Returns bounds on the optimisation variables.
"""
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 | [
"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. | [
"Returns",
"bounds",
"on",
"the",
"optimisation",
"variables",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/solver.py#L152-L164 | train |
rwl/pylon | pylon/solver.py | _Solver._initial_interior_point | def _initial_interior_point(self, buses, generators, xmin, xmax, ny):
""" Selects an interior initial point for interior point solver.
"""
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 | python | def _initial_interior_point(self, buses, generators, xmin, xmax, ny):
""" Selects an interior initial point for interior point solver.
"""
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 | [
"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",
"]",
"if",
"ny",
">",
"0",
":",
"yvar",
"=",
"self",
".",
"om",
".",
"get_var",
"(",
"\"y\"",
")",
"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. | [
"Selects",
"an",
"interior",
"initial",
"point",
"for",
"interior",
"point",
"solver",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/solver.py#L167-L190 | train |
rwl/pylon | pylon/solver.py | DCOPFSolver.solve | def solve(self):
""" Solves DC optimal power flow and returns a results dict.
"""
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 | python | def solve(self):
""" Solves DC optimal power flow and returns a results dict.
"""
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 | [
"def",
"solve",
"(",
"self",
")",
":",
"base_mva",
"=",
"self",
".",
"om",
".",
"case",
".",
"base_mva",
"Bf",
"=",
"self",
".",
"om",
".",
"_Bf",
"Pfinj",
"=",
"self",
".",
"om",
".",
"_Pfinj",
"bs",
",",
"ln",
",",
"gn",
",",
"cp",
"=",
"self",
".",
"_unpack_model",
"(",
"self",
".",
"om",
")",
"ipol",
",",
"ipwl",
",",
"nb",
",",
"nl",
",",
"nw",
",",
"ny",
",",
"nxyz",
"=",
"self",
".",
"_dimension_data",
"(",
"bs",
",",
"ln",
",",
"gn",
")",
"AA",
",",
"ll",
",",
"uu",
"=",
"self",
".",
"_linear_constraints",
"(",
"self",
".",
"om",
")",
"Npwl",
",",
"Hpwl",
",",
"Cpwl",
",",
"fparm_pwl",
",",
"any_pwl",
"=",
"self",
".",
"_pwl_costs",
"(",
"ny",
",",
"nxyz",
",",
"ipwl",
")",
"Npol",
",",
"Hpol",
",",
"Cpol",
",",
"fparm_pol",
",",
"polycf",
",",
"npol",
"=",
"self",
".",
"_quadratic_costs",
"(",
"gn",
",",
"ipol",
",",
"nxyz",
",",
"base_mva",
")",
"NN",
",",
"HHw",
",",
"CCw",
",",
"ffparm",
"=",
"self",
".",
"_combine_costs",
"(",
"Npwl",
",",
"Hpwl",
",",
"Cpwl",
",",
"fparm_pwl",
",",
"any_pwl",
",",
"Npol",
",",
"Hpol",
",",
"Cpol",
",",
"fparm_pol",
",",
"npol",
",",
"nw",
")",
"HH",
",",
"CC",
",",
"C0",
"=",
"self",
".",
"_transform_coefficients",
"(",
"NN",
",",
"HHw",
",",
"CCw",
",",
"ffparm",
",",
"polycf",
",",
"any_pwl",
",",
"npol",
",",
"nw",
")",
"_",
",",
"xmin",
",",
"xmax",
"=",
"self",
".",
"_var_bounds",
"(",
")",
"x0",
"=",
"self",
".",
"_initial_interior_point",
"(",
"bs",
",",
"gn",
",",
"xmin",
",",
"xmax",
",",
"ny",
")",
"s",
"=",
"self",
".",
"_run_opf",
"(",
"HH",
",",
"CC",
",",
"AA",
",",
"ll",
",",
"uu",
",",
"xmin",
",",
"xmax",
",",
"x0",
",",
"self",
".",
"opt",
")",
"Va",
",",
"Pg",
"=",
"self",
".",
"_update_solution_data",
"(",
"s",
",",
"HH",
",",
"CC",
",",
"C0",
")",
"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. | [
"Solves",
"DC",
"optimal",
"power",
"flow",
"and",
"returns",
"a",
"results",
"dict",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/solver.py#L218-L257 | train |
rwl/pylon | pylon/solver.py | DCOPFSolver._pwl_costs | def _pwl_costs(self, ny, nxyz, ipwl):
""" Returns the piece-wise linear components of the objective function.
"""
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 | python | def _pwl_costs(self, ny, nxyz, ipwl):
""" Returns the piece-wise linear components of the objective function.
"""
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 | [
"def",
"_pwl_costs",
"(",
"self",
",",
"ny",
",",
"nxyz",
",",
"ipwl",
")",
":",
"any_pwl",
"=",
"int",
"(",
"ny",
">",
"0",
")",
"if",
"any_pwl",
":",
"y",
"=",
"self",
".",
"om",
".",
"get_var",
"(",
"\"y\"",
")",
"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",
"Hpwl",
"=",
"None",
"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. | [
"Returns",
"the",
"piece",
"-",
"wise",
"linear",
"components",
"of",
"the",
"objective",
"function",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/solver.py#L260-L277 | train |
rwl/pylon | pylon/solver.py | DCOPFSolver._quadratic_costs | def _quadratic_costs(self, generators, ipol, nxyz, base_mva):
""" Returns the quadratic cost components of the objective function.
"""
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 | python | def _quadratic_costs(self, generators, ipol, nxyz, base_mva):
""" Returns the quadratic cost components of the objective function.
"""
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 | [
"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",
"]",
")",
"if",
"len",
"(",
"ilin",
")",
">",
"0",
":",
"polycf",
"[",
"ilin",
",",
"1",
":",
"]",
"=",
"array",
"(",
"[",
"list",
"(",
"g",
".",
"p_cost",
"[",
":",
"2",
"]",
")",
"for",
"g",
"in",
"generators",
"]",
")",
"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. | [
"Returns",
"the",
"quadratic",
"cost",
"components",
"of",
"the",
"objective",
"function",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/solver.py#L280-L316 | train |
rwl/pylon | pylon/solver.py | DCOPFSolver._combine_costs | def _combine_costs(self, Npwl, Hpwl, Cpwl, fparm_pwl, any_pwl,
Npol, Hpol, Cpol, fparm_pol, npol, nw):
""" Combines pwl, polynomial and user-defined costs.
"""
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 | python | def _combine_costs(self, Npwl, Hpwl, Cpwl, fparm_pwl, any_pwl,
Npol, Hpol, Cpol, fparm_pol, npol, nw):
""" Combines pwl, polynomial and user-defined costs.
"""
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 | [
"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",
"]",
")",
"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. | [
"Combines",
"pwl",
"polynomial",
"and",
"user",
"-",
"defined",
"costs",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/solver.py#L319-L337 | train |
rwl/pylon | pylon/solver.py | DCOPFSolver._transform_coefficients | def _transform_coefficients(self, NN, HHw, CCw, ffparm, polycf,
any_pwl, npol, nw):
""" Transforms quadratic coefficients for w into coefficients for x.
"""
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] | python | def _transform_coefficients(self, NN, HHw, CCw, ffparm, polycf,
any_pwl, npol, nw):
""" Transforms quadratic coefficients for w into coefficients for x.
"""
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] | [
"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",
"]",
"HMR",
"=",
"HHw",
"*",
"MR",
"MN",
"=",
"M",
"*",
"NN",
"HH",
"=",
"MN",
".",
"T",
"*",
"HHw",
"*",
"MN",
"CC",
"=",
"MN",
".",
"T",
"*",
"(",
"CCw",
"-",
"HMR",
")",
"C0",
"=",
"1.",
"/",
"2.",
"*",
"MR",
".",
"T",
"*",
"HMR",
"+",
"sum",
"(",
"polycf",
"[",
":",
",",
"2",
"]",
")",
"return",
"HH",
",",
"CC",
",",
"C0",
"[",
"0",
"]"
] | Transforms quadratic coefficients for w into coefficients for x. | [
"Transforms",
"quadratic",
"coefficients",
"for",
"w",
"into",
"coefficients",
"for",
"x",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/solver.py#L340-L354 | train |
rwl/pylon | pylon/solver.py | PIPSSolver._ref_bus_angle_constraint | def _ref_bus_angle_constraint(self, buses, Va, xmin, xmax):
""" Adds a constraint on the reference bus angles.
"""
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 | python | def _ref_bus_angle_constraint(self, buses, Va, xmin, xmax):
""" Adds a constraint on the reference bus angles.
"""
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 | [
"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. | [
"Adds",
"a",
"constraint",
"on",
"the",
"reference",
"bus",
"angles",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/solver.py#L444-L453 | train |
rwl/pylon | pylon/solver.py | PIPSSolver._f | def _f(self, x, user_data=None):
""" Evaluates the objective function.
"""
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 | python | def _f(self, x, user_data=None):
""" Evaluates the objective function.
"""
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 | [
"def",
"_f",
"(",
"self",
",",
"x",
",",
"user_data",
"=",
"None",
")",
":",
"p_gen",
"=",
"x",
"[",
"self",
".",
"_Pg",
".",
"i1",
":",
"self",
".",
"_Pg",
".",
"iN",
"+",
"1",
"]",
"q_gen",
"=",
"x",
"[",
"self",
".",
"_Qg",
".",
"i1",
":",
"self",
".",
"_Qg",
".",
"iN",
"+",
"1",
"]",
"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",
"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",
")",
")",
"return",
"f"
] | Evaluates the objective function. | [
"Evaluates",
"the",
"objective",
"function",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/solver.py#L515-L539 | train |
rwl/pylon | pylon/solver.py | PIPSSolver._df | def _df(self, x, user_data=None):
""" Evaluates the cost gradient.
"""
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() | python | def _df(self, x, user_data=None):
""" Evaluates the cost gradient.
"""
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() | [
"def",
"_df",
"(",
"self",
",",
"x",
",",
"user_data",
"=",
"None",
")",
":",
"p_gen",
"=",
"x",
"[",
"self",
".",
"_Pg",
".",
"i1",
":",
"self",
".",
"_Pg",
".",
"iN",
"+",
"1",
"]",
"q_gen",
"=",
"x",
"[",
"self",
".",
"_Qg",
".",
"i1",
":",
"self",
".",
"_Qg",
".",
"iN",
"+",
"1",
"]",
"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",
")",
"df_dPgQg",
"=",
"zeros",
"(",
"(",
"2",
"*",
"self",
".",
"_ng",
",",
"1",
")",
")",
"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",
"]",
"df",
"=",
"df",
"+",
"self",
".",
"_ccost",
".",
"T",
"return",
"asarray",
"(",
"df",
")",
".",
"flatten",
"(",
")"
] | Evaluates the cost gradient. | [
"Evaluates",
"the",
"cost",
"gradient",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/solver.py#L542-L573 | train |
rwl/pylon | pylon/solver.py | PIPSSolver._d2f | def _d2f(self, x):
""" Evaluates the cost Hessian.
"""
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 | python | def _d2f(self, x):
""" Evaluates the cost Hessian.
"""
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 | [
"def",
"_d2f",
"(",
"self",
",",
"x",
")",
":",
"d2f_dPg2",
"=",
"lil_matrix",
"(",
"(",
"self",
".",
"_ng",
",",
"1",
")",
")",
"d2f_dQg2",
"=",
"lil_matrix",
"(",
"(",
"self",
".",
"_ng",
",",
"1",
")",
")",
"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",
"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. | [
"Evaluates",
"the",
"cost",
"Hessian",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/solver.py#L576-L595 | train |
rwl/pylon | pylon/solver.py | PIPSSolver._gh | def _gh(self, x):
""" Evaluates the constraint function values.
"""
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 | python | def _gh(self, x):
""" Evaluates the constraint function values.
"""
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 | [
"def",
"_gh",
"(",
"self",
",",
"x",
")",
":",
"Pgen",
"=",
"x",
"[",
"self",
".",
"_Pg",
".",
"i1",
":",
"self",
".",
"_Pg",
".",
"iN",
"+",
"1",
"]",
"Qgen",
"=",
"x",
"[",
"self",
".",
"_Qg",
".",
"i1",
":",
"self",
".",
"_Qg",
".",
"iN",
"+",
"1",
"]",
"for",
"i",
",",
"gen",
"in",
"enumerate",
"(",
"self",
".",
"_gn",
")",
":",
"gen",
".",
"p",
"=",
"Pgen",
"[",
"i",
"]",
"*",
"self",
".",
"_base_mva",
"gen",
".",
"q",
"=",
"Qgen",
"[",
"i",
"]",
"*",
"self",
".",
"_base_mva",
"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",
")",
"mis",
"=",
"V",
"*",
"conj",
"(",
"self",
".",
"_Ybus",
"*",
"V",
")",
"-",
"Sbus",
"g",
"=",
"r_",
"[",
"mis",
".",
"real",
",",
"mis",
".",
"imag",
"]",
"flow_max",
"=",
"array",
"(",
"[",
"(",
"l",
".",
"rate_a",
"/",
"self",
".",
"_base_mva",
")",
"**",
"2",
"for",
"l",
"in",
"self",
".",
"_ln",
"]",
")",
"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",
"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",
"]",
"Sf",
"=",
"V",
"[",
"i_fbus",
"]",
"*",
"conj",
"(",
"self",
".",
"_Yf",
"*",
"V",
")",
"St",
"=",
"V",
"[",
"i_tbus",
"]",
"*",
"conj",
"(",
"self",
".",
"_Yt",
"*",
"V",
")",
"if",
"self",
".",
"flow_lim",
"==",
"PFLOW",
":",
"h",
"=",
"r_",
"[",
"Sf",
".",
"real",
"(",
")",
"**",
"2",
"-",
"flow_max",
",",
"St",
".",
"real",
"(",
")",
"**",
"2",
"-",
"flow_max",
"]",
"elif",
"self",
".",
"flow_lim",
"==",
"SFLOW",
":",
"h",
"=",
"r_",
"[",
"(",
"Sf",
"*",
"conj",
"(",
"Sf",
")",
")",
"-",
"flow_max",
",",
"(",
"St",
"*",
"conj",
"(",
"St",
")",
")",
"-",
"flow_max",
"]",
".",
"real",
"else",
":",
"raise",
"ValueError",
"return",
"h",
",",
"g"
] | Evaluates the constraint function values. | [
"Evaluates",
"the",
"constraint",
"function",
"values",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/solver.py#L598-L654 | train |
rwl/pylon | pylon/solver.py | PIPSSolver._costfcn | def _costfcn(self, x):
""" Evaluates the objective function, gradient and Hessian for OPF.
"""
f = self._f(x)
df = self._df(x)
d2f = self._d2f(x)
return f, df, d2f | python | def _costfcn(self, x):
""" Evaluates the objective function, gradient and Hessian for OPF.
"""
f = self._f(x)
df = self._df(x)
d2f = self._d2f(x)
return f, df, d2f | [
"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. | [
"Evaluates",
"the",
"objective",
"function",
"gradient",
"and",
"Hessian",
"for",
"OPF",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/solver.py#L716-L723 | train |
rwl/pylon | pylon/solver.py | PIPSSolver._consfcn | def _consfcn(self, x):
""" Evaluates nonlinear constraints and their Jacobian for OPF.
"""
h, g = self._gh(x)
dh, dg = self._dgh(x)
return h, g, dh, dg | python | def _consfcn(self, x):
""" Evaluates nonlinear constraints and their Jacobian for OPF.
"""
h, g = self._gh(x)
dh, dg = self._dgh(x)
return h, g, dh, dg | [
"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. | [
"Evaluates",
"nonlinear",
"constraints",
"and",
"their",
"Jacobian",
"for",
"OPF",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/solver.py#L726-L732 | train |
rwl/pylon | pylon/io/pickle.py | PickleReader.read | def read(self, file_or_filename):
""" Loads a pickled case.
"""
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 | python | def read(self, file_or_filename):
""" Loads a pickled case.
"""
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 | [
"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. | [
"Loads",
"a",
"pickled",
"case",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/pickle.py#L45-L66 | train |
rwl/pylon | pylon/io/pickle.py | PickleWriter.write | def write(self, file_or_filename):
""" Writes the case to file using pickle.
"""
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 | python | def write(self, file_or_filename):
""" Writes the case to file using pickle.
"""
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 | [
"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. | [
"Writes",
"the",
"case",
"to",
"file",
"using",
"pickle",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/pickle.py#L76-L97 | train |
finklabs/metrics | metrics/sloc.py | SLOCMetric.process_token | def process_token(self, tok):
"""count comments and non-empty lines that contain code"""
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 | python | def process_token(self, tok):
"""count comments and non-empty lines that contain code"""
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 | [
"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'",
")",
")",
":",
"self",
".",
"contains_code",
"=",
"False",
"self",
".",
"sloc",
"+=",
"1",
"elif",
"(",
"tok",
"[",
"0",
"]",
".",
"__str__",
"(",
")",
"==",
"'Token.Comment.Preproc'",
"and",
"tok",
"[",
"1",
"]",
".",
"count",
"(",
"u'\\n'",
")",
")",
":",
"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 | [
"count",
"comments",
"and",
"non",
"-",
"empty",
"lines",
"that",
"contain",
"code"
] | fd9974af498831664b9ae8e8f3834e1ec2e8a699 | https://github.com/finklabs/metrics/blob/fd9974af498831664b9ae8e8f3834e1ec2e8a699/metrics/sloc.py#L34-L53 | train |
finklabs/metrics | metrics/sloc.py | SLOCMetric.get_metrics | def get_metrics(self):
"""Calculate ratio_comment_to_code and return with the other values"""
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 | python | def get_metrics(self):
"""Calculate ratio_comment_to_code and return with the other values"""
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 | [
"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 | [
"Calculate",
"ratio_comment_to_code",
"and",
"return",
"with",
"the",
"other",
"values"
] | fd9974af498831664b9ae8e8f3834e1ec2e8a699 | https://github.com/finklabs/metrics/blob/fd9974af498831664b9ae8e8f3834e1ec2e8a699/metrics/sloc.py#L68-L79 | train |
rwl/pylon | pyreto/rlopf.py | CaseEnvironment.performAction | def performAction(self, action):
""" Perform an action on the world that changes it's internal state.
"""
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) | python | def performAction(self, action):
""" Perform an action on the world that changes it's internal state.
"""
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) | [
"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",
")",
")",
"for",
"i",
",",
"g",
"in",
"enumerate",
"(",
"gs",
")",
":",
"g",
".",
"p",
"=",
"action",
"[",
"i",
"]",
"NewtonPF",
"(",
"self",
".",
"case",
",",
"verbose",
"=",
"False",
")",
".",
"solve",
"(",
")",
"self",
".",
"_Pg",
"[",
":",
",",
"self",
".",
"_step",
"]",
"=",
"[",
"g",
".",
"p",
"for",
"g",
"in",
"self",
".",
"case",
".",
"online_generators",
"]",
"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. | [
"Perform",
"an",
"action",
"on",
"the",
"world",
"that",
"changes",
"it",
"s",
"internal",
"state",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/rlopf.py#L109-L137 | train |
rwl/pylon | pyreto/rlopf.py | CaseEnvironment.reset | def reset(self):
""" Re-initialises the environment.
"""
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() | python | def reset(self):
""" Re-initialises the environment.
"""
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() | [
"def",
"reset",
"(",
"self",
")",
":",
"logger",
".",
"info",
"(",
"\"Reseting environment.\"",
")",
"self",
".",
"_step",
"=",
"0",
"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",
"]",
"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",
"]",
"self",
".",
"_Pg",
"=",
"zeros",
"(",
"(",
"len",
"(",
"self",
".",
"case",
".",
"online_generators",
")",
",",
"len",
"(",
"self",
".",
"profile",
")",
")",
")",
"self",
".",
"case",
".",
"reset",
"(",
")"
] | Re-initialises the environment. | [
"Re",
"-",
"initialises",
"the",
"environment",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/rlopf.py#L140-L162 | train |
rwl/pylon | pyreto/rlopf.py | MinimiseCostTask.isFinished | def isFinished(self):
""" Is the current episode over?
"""
finished = (self.env._step == len(self.env.profile))
if finished:
logger.info("Finished episode.")
return finished | python | def isFinished(self):
""" Is the current episode over?
"""
finished = (self.env._step == len(self.env.profile))
if finished:
logger.info("Finished episode.")
return finished | [
"def",
"isFinished",
"(",
"self",
")",
":",
"finished",
"=",
"(",
"self",
".",
"env",
".",
"_step",
"==",
"len",
"(",
"self",
".",
"env",
".",
"profile",
")",
")",
"if",
"finished",
":",
"logger",
".",
"info",
"(",
"\"Finished episode.\"",
")",
"return",
"finished"
] | Is the current episode over? | [
"Is",
"the",
"current",
"episode",
"over?"
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/rlopf.py#L216-L222 | train |
rwl/pylon | pyreto/rlopf.py | OPFExperiment._oneInteraction | def _oneInteraction(self):
""" Does one interaction between the task and the agent.
"""
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 | python | def _oneInteraction(self):
""" Does one interaction between the task and the agent.
"""
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 | [
"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",
"(",
")",
")",
"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. | [
"Does",
"one",
"interaction",
"between",
"the",
"task",
"and",
"the",
"agent",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/rlopf.py#L272-L288 | train |
rwl/pylon | pyreto/rlopf.py | OPFExperiment.doEpisodes | def doEpisodes(self, number=1):
""" Does the the given number of episodes.
"""
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 | python | def doEpisodes(self, number=1):
""" Does the the given number of episodes.
"""
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 | [
"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",
")",
"self",
".",
"Pg",
"=",
"self",
".",
"Pg",
"/",
"number",
"return",
"rewards"
] | Does the the given number of episodes. | [
"Does",
"the",
"the",
"given",
"number",
"of",
"episodes",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/rlopf.py#L291-L302 | train |
rwl/pylon | contrib/public/services/jsonrpc/__init__.py | getMethodByName | def getMethodByName(obj, name):
"""searches for an object with the name given inside the object given.
"obj.child.meth" will return the meth obj.
"""
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 | python | def getMethodByName(obj, name):
"""searches for an object with the name given inside the object given.
"obj.child.meth" will return the meth obj.
"""
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 | [
"def",
"getMethodByName",
"(",
"obj",
",",
"name",
")",
":",
"try",
":",
"obj",
"=",
"obj",
".",
"_getMethodByName",
"(",
"name",
")",
"except",
":",
"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. | [
"searches",
"for",
"an",
"object",
"with",
"the",
"name",
"given",
"inside",
"the",
"object",
"given",
".",
"obj",
".",
"child",
".",
"meth",
"will",
"return",
"the",
"meth",
"obj",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/public/services/jsonrpc/__init__.py#L168-L186 | train |
rwl/pylon | contrib/public/services/jsonrpc/__init__.py | ResponseEvent.waitForResponse | def waitForResponse(self, timeOut=None):
"""blocks until the response arrived or timeout is reached."""
self.__evt.wait(timeOut)
if self.waiting():
raise Timeout()
else:
if self.response["error"]:
raise Exception(self.response["error"])
else:
return self.response["result"] | python | def waitForResponse(self, timeOut=None):
"""blocks until the response arrived or timeout is reached."""
self.__evt.wait(timeOut)
if self.waiting():
raise Timeout()
else:
if self.response["error"]:
raise Exception(self.response["error"])
else:
return self.response["result"] | [
"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. | [
"blocks",
"until",
"the",
"response",
"arrived",
"or",
"timeout",
"is",
"reached",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/public/services/jsonrpc/__init__.py#L51-L60 | train |
rwl/pylon | contrib/public/services/jsonrpc/__init__.py | SimpleMessageHandler.sendRequest | def sendRequest(self, name, args):
"""sends a request to the peer"""
(respEvt, id) = self.newResponseEvent()
self.sendMessage({"id":id, "method":name, "params": args})
return respEvt | python | def sendRequest(self, name, args):
"""sends a request to the peer"""
(respEvt, id) = self.newResponseEvent()
self.sendMessage({"id":id, "method":name, "params": args})
return respEvt | [
"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 | [
"sends",
"a",
"request",
"to",
"the",
"peer"
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/public/services/jsonrpc/__init__.py#L108-L112 | train |
rwl/pylon | contrib/public/services/jsonrpc/__init__.py | SimpleMessageHandler.sendResponse | def sendResponse(self, id, result, error):
"""sends a response to the peer"""
self.sendMessage({"result":result, "error": error, "id":id}) | python | def sendResponse(self, id, result, error):
"""sends a response to the peer"""
self.sendMessage({"result":result, "error": error, "id":id}) | [
"def",
"sendResponse",
"(",
"self",
",",
"id",
",",
"result",
",",
"error",
")",
":",
"self",
".",
"sendMessage",
"(",
"{",
"\"result\"",
":",
"result",
",",
"\"error\"",
":",
"error",
",",
"\"id\"",
":",
"id",
"}",
")"
] | sends a response to the peer | [
"sends",
"a",
"response",
"to",
"the",
"peer"
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/public/services/jsonrpc/__init__.py#L114-L116 | train |
rwl/pylon | contrib/public/services/jsonrpc/__init__.py | SimpleMessageHandler.newResponseEvent | def newResponseEvent(self):
"""creates a response event and adds it to a waiting list
When the reponse arrives it will be removed from the list.
"""
respEvt = ResponseEvent()
self.respLock.acquire()
eid = id(respEvt)
self.respEvents[eid] = respEvt
self.respLock.release()
return (respEvt,eid) | python | def newResponseEvent(self):
"""creates a response event and adds it to a waiting list
When the reponse arrives it will be removed from the list.
"""
respEvt = ResponseEvent()
self.respLock.acquire()
eid = id(respEvt)
self.respEvents[eid] = respEvt
self.respLock.release()
return (respEvt,eid) | [
"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. | [
"creates",
"a",
"response",
"event",
"and",
"adds",
"it",
"to",
"a",
"waiting",
"list",
"When",
"the",
"reponse",
"arrives",
"it",
"will",
"be",
"removed",
"from",
"the",
"list",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/public/services/jsonrpc/__init__.py#L118-L127 | train |
rwl/pylon | contrib/public/services/jsonrpc/__init__.py | SimpleMessageHandler.handleResponse | def handleResponse(self, resp):
"""handles a response by fireing the response event for the response coming in"""
id=resp["id"]
evt = self.respEvents[id]
del(self.respEvents[id])
evt.handleResponse(resp) | python | def handleResponse(self, resp):
"""handles a response by fireing the response event for the response coming in"""
id=resp["id"]
evt = self.respEvents[id]
del(self.respEvents[id])
evt.handleResponse(resp) | [
"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 | [
"handles",
"a",
"response",
"by",
"fireing",
"the",
"response",
"event",
"for",
"the",
"response",
"coming",
"in"
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/public/services/jsonrpc/__init__.py#L145-L150 | train |
rwl/pylon | contrib/public/services/jsonrpc/__init__.py | SimpleServiceHandler.handleRequest | def handleRequest(self, req):
"""handles a request by calling the appropriete method the service exposes"""
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) | python | def handleRequest(self, req):
"""handles a request by calling the appropriete method the service exposes"""
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) | [
"def",
"handleRequest",
"(",
"self",
",",
"req",
")",
":",
"name",
"=",
"req",
"[",
"\"method\"",
"]",
"params",
"=",
"req",
"[",
"\"params\"",
"]",
"id",
"=",
"req",
"[",
"\"id\"",
"]",
"obj",
"=",
"None",
"try",
":",
"obj",
"=",
"getMethodByName",
"(",
"self",
".",
"service",
",",
"name",
")",
"except",
"MethodNameNotAllowed",
",",
"e",
":",
"self",
".",
"sendResponse",
"(",
"id",
",",
"None",
",",
"e",
")",
"except",
":",
"self",
".",
"sendResponse",
"(",
"id",
",",
"None",
",",
"MethodNotFound",
"(",
")",
")",
"if",
"obj",
":",
"try",
":",
"rslt",
"=",
"obj",
"(",
"*",
"params",
")",
"self",
".",
"sendResponse",
"(",
"id",
",",
"rslt",
",",
"None",
")",
"except",
"TypeError",
":",
"s",
"=",
"getTracebackStr",
"(",
")",
"self",
".",
"sendResponse",
"(",
"id",
",",
"None",
",",
"InvalidMethodParameters",
"(",
")",
")",
"except",
":",
"s",
"=",
"getTracebackStr",
"(",
")",
"self",
".",
"sendResponse",
"(",
"id",
",",
"None",
",",
"s",
")"
] | handles a request by calling the appropriete method the service exposes | [
"handles",
"a",
"request",
"by",
"calling",
"the",
"appropriete",
"method",
"the",
"service",
"exposes"
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/public/services/jsonrpc/__init__.py#L205-L227 | train |
rwl/pylon | contrib/public/services/jsonrpc/__init__.py | SimpleServiceHandler.handleNotification | def handleNotification(self, req):
"""handles a notification request by calling the appropriete method the service exposes"""
name = req["method"]
params = req["params"]
try: #to get a callable obj
obj = getMethodByName(self.service, name)
rslt = obj(*params)
except:
pass | python | def handleNotification(self, req):
"""handles a notification request by calling the appropriete method the service exposes"""
name = req["method"]
params = req["params"]
try: #to get a callable obj
obj = getMethodByName(self.service, name)
rslt = obj(*params)
except:
pass | [
"def",
"handleNotification",
"(",
"self",
",",
"req",
")",
":",
"name",
"=",
"req",
"[",
"\"method\"",
"]",
"params",
"=",
"req",
"[",
"\"params\"",
"]",
"try",
":",
"obj",
"=",
"getMethodByName",
"(",
"self",
".",
"service",
",",
"name",
")",
"rslt",
"=",
"obj",
"(",
"*",
"params",
")",
"except",
":",
"pass"
] | handles a notification request by calling the appropriete method the service exposes | [
"handles",
"a",
"notification",
"request",
"by",
"calling",
"the",
"appropriete",
"method",
"the",
"service",
"exposes"
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/public/services/jsonrpc/__init__.py#L229-L237 | train |
rwl/pylon | pylon/io/psat.py | PSATReader.read | def read(self, file_or_filename):
""" Parses a PSAT data file and returns a case object
file_or_filename: File object or path to PSAT data file
return: Case object
"""
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 | python | def read(self, file_or_filename):
""" Parses a PSAT data file and returns a case object
file_or_filename: File object or path to PSAT data file
return: Case object
"""
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 | [
"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",
"(",
")",
"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",
"(",
")",
"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",
"(",
")",
"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
file_or_filename: File object or path to PSAT data file
return: Case object | [
"Parses",
"a",
"PSAT",
"data",
"file",
"and",
"returns",
"a",
"case",
"object"
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L54-L101 | train |
rwl/pylon | pylon/io/psat.py | PSATReader._get_bus_array_construct | def _get_bus_array_construct(self):
""" Returns a construct for an array of bus data.
"""
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 | python | def _get_bus_array_construct(self):
""" Returns a construct for an array of bus data.
"""
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 | [
"def",
"_get_bus_array_construct",
"(",
"self",
")",
":",
"bus_no",
"=",
"integer",
".",
"setResultsName",
"(",
"\"bus_no\"",
")",
"v_base",
"=",
"real",
".",
"setResultsName",
"(",
"\"v_base\"",
")",
"v_magnitude",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"v_magnitude\"",
")",
"v_angle",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"v_angle\"",
")",
"area",
"=",
"Optional",
"(",
"integer",
")",
".",
"setResultsName",
"(",
"\"area\"",
")",
"region",
"=",
"Optional",
"(",
"integer",
")",
".",
"setResultsName",
"(",
"\"region\"",
")",
"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",
")",
")",
"bus_array",
".",
"setParseAction",
"(",
"self",
".",
"sort_buses",
")",
"return",
"bus_array"
] | Returns a construct for an array of bus data. | [
"Returns",
"a",
"construct",
"for",
"an",
"array",
"of",
"bus",
"data",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L107-L128 | train |
rwl/pylon | pylon/io/psat.py | PSATReader._get_line_array_construct | def _get_line_array_construct(self):
""" Returns a construct for an array of line data.
"""
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 | python | def _get_line_array_construct(self):
""" Returns a construct for an array of line data.
"""
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 | [
"def",
"_get_line_array_construct",
"(",
"self",
")",
":",
"from_bus",
"=",
"integer",
".",
"setResultsName",
"(",
"\"fbus\"",
")",
"to_bus",
"=",
"integer",
".",
"setResultsName",
"(",
"\"tbus\"",
")",
"s_rating",
"=",
"real",
".",
"setResultsName",
"(",
"\"s_rating\"",
")",
"v_rating",
"=",
"real",
".",
"setResultsName",
"(",
"\"v_rating\"",
")",
"f_rating",
"=",
"real",
".",
"setResultsName",
"(",
"\"f_rating\"",
")",
"length",
"=",
"real",
".",
"setResultsName",
"(",
"\"length\"",
")",
"v_ratio",
"=",
"real",
".",
"setResultsName",
"(",
"\"v_ratio\"",
")",
"r",
"=",
"real",
".",
"setResultsName",
"(",
"\"r\"",
")",
"x",
"=",
"real",
".",
"setResultsName",
"(",
"\"x\"",
")",
"b",
"=",
"real",
".",
"setResultsName",
"(",
"\"b\"",
")",
"tap_ratio",
"=",
"real",
".",
"setResultsName",
"(",
"\"tap\"",
")",
"phase_shift",
"=",
"real",
".",
"setResultsName",
"(",
"\"shift\"",
")",
"i_limit",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"i_limit\"",
")",
"p_limit",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"p_limit\"",
")",
"s_limit",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"s_limit\"",
")",
"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. | [
"Returns",
"a",
"construct",
"for",
"an",
"array",
"of",
"line",
"data",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L131-L160 | train |
rwl/pylon | pylon/io/psat.py | PSATReader._get_slack_array_construct | def _get_slack_array_construct(self):
""" Returns a construct for an array of slack bus data.
"""
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 | python | def _get_slack_array_construct(self):
""" Returns a construct for an array of slack bus data.
"""
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 | [
"def",
"_get_slack_array_construct",
"(",
"self",
")",
":",
"bus_no",
"=",
"integer",
".",
"setResultsName",
"(",
"\"bus_no\"",
")",
"s_rating",
"=",
"real",
".",
"setResultsName",
"(",
"\"s_rating\"",
")",
"v_rating",
"=",
"real",
".",
"setResultsName",
"(",
"\"v_rating\"",
")",
"v_magnitude",
"=",
"real",
".",
"setResultsName",
"(",
"\"v_magnitude\"",
")",
"ref_angle",
"=",
"real",
".",
"setResultsName",
"(",
"\"ref_angle\"",
")",
"q_max",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"q_max\"",
")",
"q_min",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"q_min\"",
")",
"v_max",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"v_max\"",
")",
"v_min",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"v_min\"",
")",
"p_guess",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"p_guess\"",
")",
"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. | [
"Returns",
"a",
"construct",
"for",
"an",
"array",
"of",
"slack",
"bus",
"data",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L163-L190 | train |
rwl/pylon | pylon/io/psat.py | PSATReader._get_pv_array_construct | def _get_pv_array_construct(self):
""" Returns a construct for an array of PV generator data.
"""
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 | python | def _get_pv_array_construct(self):
""" Returns a construct for an array of PV generator data.
"""
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 | [
"def",
"_get_pv_array_construct",
"(",
"self",
")",
":",
"bus_no",
"=",
"integer",
".",
"setResultsName",
"(",
"\"bus_no\"",
")",
"s_rating",
"=",
"real",
".",
"setResultsName",
"(",
"\"s_rating\"",
")",
"v_rating",
"=",
"real",
".",
"setResultsName",
"(",
"\"v_rating\"",
")",
"p",
"=",
"real",
".",
"setResultsName",
"(",
"\"p\"",
")",
"v",
"=",
"real",
".",
"setResultsName",
"(",
"\"v\"",
")",
"q_max",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"q_max\"",
")",
"q_min",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"q_min\"",
")",
"v_max",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"v_max\"",
")",
"v_min",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"v_min\"",
")",
"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. | [
"Returns",
"a",
"construct",
"for",
"an",
"array",
"of",
"PV",
"generator",
"data",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L193-L217 | train |
rwl/pylon | pylon/io/psat.py | PSATReader._get_pq_array_construct | def _get_pq_array_construct(self):
""" Returns a construct for an array of PQ load data.
"""
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 | python | def _get_pq_array_construct(self):
""" Returns a construct for an array of PQ load data.
"""
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 | [
"def",
"_get_pq_array_construct",
"(",
"self",
")",
":",
"bus_no",
"=",
"integer",
".",
"setResultsName",
"(",
"\"bus_no\"",
")",
"s_rating",
"=",
"real",
".",
"setResultsName",
"(",
"\"s_rating\"",
")",
"v_rating",
"=",
"real",
".",
"setResultsName",
"(",
"\"v_rating\"",
")",
"p",
"=",
"real",
".",
"setResultsName",
"(",
"\"p\"",
")",
"q",
"=",
"real",
".",
"setResultsName",
"(",
"\"q\"",
")",
"v_max",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"v_max\"",
")",
"v_min",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"v_min\"",
")",
"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. | [
"Returns",
"a",
"construct",
"for",
"an",
"array",
"of",
"PQ",
"load",
"data",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L220-L242 | train |
rwl/pylon | pylon/io/psat.py | PSATReader._get_demand_array_construct | def _get_demand_array_construct(self):
""" Returns a construct for an array of power demand data.
"""
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 | python | def _get_demand_array_construct(self):
""" Returns a construct for an array of power demand data.
"""
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 | [
"def",
"_get_demand_array_construct",
"(",
"self",
")",
":",
"bus_no",
"=",
"integer",
".",
"setResultsName",
"(",
"\"bus_no\"",
")",
"s_rating",
"=",
"real",
".",
"setResultsName",
"(",
"\"s_rating\"",
")",
"p_direction",
"=",
"real",
".",
"setResultsName",
"(",
"\"p_direction\"",
")",
"q_direction",
"=",
"real",
".",
"setResultsName",
"(",
"\"q_direction\"",
")",
"p_bid_max",
"=",
"real",
".",
"setResultsName",
"(",
"\"p_bid_max\"",
")",
"p_bid_min",
"=",
"real",
".",
"setResultsName",
"(",
"\"p_bid_min\"",
")",
"p_optimal_bid",
"=",
"Optional",
"(",
"real",
")",
".",
"setResultsName",
"(",
"\"p_optimal_bid\"",
")",
"p_fixed",
"=",
"real",
".",
"setResultsName",
"(",
"\"p_fixed\"",
")",
"p_proportional",
"=",
"real",
".",
"setResultsName",
"(",
"\"p_proportional\"",
")",
"p_quadratic",
"=",
"real",
".",
"setResultsName",
"(",
"\"p_quadratic\"",
")",
"q_fixed",
"=",
"real",
".",
"setResultsName",
"(",
"\"q_fixed\"",
")",
"q_proportional",
"=",
"real",
".",
"setResultsName",
"(",
"\"q_proportional\"",
")",
"q_quadratic",
"=",
"real",
".",
"setResultsName",
"(",
"\"q_quadratic\"",
")",
"commitment",
"=",
"boolean",
".",
"setResultsName",
"(",
"\"commitment\"",
")",
"cost_tie_break",
"=",
"real",
".",
"setResultsName",
"(",
"\"cost_tie_break\"",
")",
"cost_cong_up",
"=",
"real",
".",
"setResultsName",
"(",
"\"cost_cong_up\"",
")",
"cost_cong_down",
"=",
"real",
".",
"setResultsName",
"(",
"\"cost_cong_down\"",
")",
"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. | [
"Returns",
"a",
"construct",
"for",
"an",
"array",
"of",
"power",
"demand",
"data",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L245-L278 | train |
rwl/pylon | pylon/io/psat.py | PSATReader._get_supply_array_construct | def _get_supply_array_construct(self):
""" Returns a construct for an array of power supply data.
"""
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 | python | def _get_supply_array_construct(self):
""" Returns a construct for an array of power supply data.
"""
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 | [
"def",
"_get_supply_array_construct",
"(",
"self",
")",
":",
"bus_no",
"=",
"integer",
".",
"setResultsName",
"(",
"\"bus_no\"",
")",
"s_rating",
"=",
"real",
".",
"setResultsName",
"(",
"\"s_rating\"",
")",
"p_direction",
"=",
"real",
".",
"setResultsName",
"(",
"\"p_direction\"",
")",
"p_bid_max",
"=",
"real",
".",
"setResultsName",
"(",
"\"p_bid_max\"",
")",
"p_bid_min",
"=",
"real",
".",
"setResultsName",
"(",
"\"p_bid_min\"",
")",
"p_bid_actual",
"=",
"real",
".",
"setResultsName",
"(",
"\"p_bid_actual\"",
")",
"p_fixed",
"=",
"real",
".",
"setResultsName",
"(",
"\"p_fixed\"",
")",
"p_proportional",
"=",
"real",
".",
"setResultsName",
"(",
"\"p_proportional\"",
")",
"p_quadratic",
"=",
"real",
".",
"setResultsName",
"(",
"\"p_quadratic\"",
")",
"q_fixed",
"=",
"real",
".",
"setResultsName",
"(",
"\"q_fixed\"",
")",
"q_proportional",
"=",
"real",
".",
"setResultsName",
"(",
"\"q_proportional\"",
")",
"q_quadratic",
"=",
"real",
".",
"setResultsName",
"(",
"\"q_quadratic\"",
")",
"commitment",
"=",
"boolean",
".",
"setResultsName",
"(",
"\"commitment\"",
")",
"cost_tie_break",
"=",
"real",
".",
"setResultsName",
"(",
"\"cost_tie_break\"",
")",
"lp_factor",
"=",
"real",
".",
"setResultsName",
"(",
"\"lp_factor\"",
")",
"q_max",
"=",
"real",
".",
"setResultsName",
"(",
"\"q_max\"",
")",
"q_min",
"=",
"real",
".",
"setResultsName",
"(",
"\"q_min\"",
")",
"cost_cong_up",
"=",
"real",
".",
"setResultsName",
"(",
"\"cost_cong_up\"",
")",
"cost_cong_down",
"=",
"real",
".",
"setResultsName",
"(",
"\"cost_cong_down\"",
")",
"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. | [
"Returns",
"a",
"construct",
"for",
"an",
"array",
"of",
"power",
"supply",
"data",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L281-L316 | train |
rwl/pylon | pylon/io/psat.py | PSATReader._get_generator_ramping_construct | def _get_generator_ramping_construct(self):
""" Returns a construct for an array of generator ramping data.
"""
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 | python | def _get_generator_ramping_construct(self):
""" Returns a construct for an array of generator ramping data.
"""
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 | [
"def",
"_get_generator_ramping_construct",
"(",
"self",
")",
":",
"supply_no",
"=",
"integer",
".",
"setResultsName",
"(",
"\"supply_no\"",
")",
"s_rating",
"=",
"real",
".",
"setResultsName",
"(",
"\"s_rating\"",
")",
"up_rate",
"=",
"real",
".",
"setResultsName",
"(",
"\"up_rate\"",
")",
"down_rate",
"=",
"real",
".",
"setResultsName",
"(",
"\"down_rate\"",
")",
"min_period_up",
"=",
"real",
".",
"setResultsName",
"(",
"\"min_period_up\"",
")",
"min_period_down",
"=",
"real",
".",
"setResultsName",
"(",
"\"min_period_down\"",
")",
"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. | [
"Returns",
"a",
"construct",
"for",
"an",
"array",
"of",
"generator",
"ramping",
"data",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L319-L340 | train |
rwl/pylon | pylon/io/psat.py | PSATReader._get_load_ramping_construct | def _get_load_ramping_construct(self):
""" Returns a construct for an array of load ramping data.
"""
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 | python | def _get_load_ramping_construct(self):
""" Returns a construct for an array of load ramping data.
"""
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 | [
"def",
"_get_load_ramping_construct",
"(",
"self",
")",
":",
"bus_no",
"=",
"integer",
".",
"setResultsName",
"(",
"\"bus_no\"",
")",
"s_rating",
"=",
"real",
".",
"setResultsName",
"(",
"\"s_rating\"",
")",
"up_rate",
"=",
"real",
".",
"setResultsName",
"(",
"\"up_rate\"",
")",
"down_rate",
"=",
"real",
".",
"setResultsName",
"(",
"\"down_rate\"",
")",
"min_up_time",
"=",
"real",
".",
"setResultsName",
"(",
"\"min_up_time\"",
")",
"min_down_time",
"=",
"real",
".",
"setResultsName",
"(",
"\"min_down_time\"",
")",
"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. | [
"Returns",
"a",
"construct",
"for",
"an",
"array",
"of",
"load",
"ramping",
"data",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L343-L363 | train |
rwl/pylon | pylon/io/psat.py | PSATReader.push_bus | def push_bus(self, tokens):
""" Adds a Bus object to the case.
"""
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) | python | def push_bus(self, tokens):
""" Adds a Bus object to the case.
"""
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) | [
"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. | [
"Adds",
"a",
"Bus",
"object",
"to",
"the",
"case",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L369-L381 | train |
rwl/pylon | pylon/io/psat.py | PSATReader.push_line | def push_line(self, tokens):
""" Adds a Branch object to the case.
"""
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) | python | def push_line(self, tokens):
""" Adds a Branch object to the case.
"""
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) | [
"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\"",
"]",
"if",
"tokens",
"[",
"\"tap\"",
"]",
"==",
"0",
":",
"e",
".",
"ratio",
"=",
"1.0",
"else",
":",
"e",
".",
"ratio",
"=",
"tokens",
"[",
"\"tap\"",
"]",
"e",
".",
"phase_shift",
"=",
"tokens",
"[",
"\"shift\"",
"]",
"self",
".",
"case",
".",
"branches",
".",
"append",
"(",
"e",
")"
] | Adds a Branch object to the case. | [
"Adds",
"a",
"Branch",
"object",
"to",
"the",
"case",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L390-L415 | train |
rwl/pylon | pylon/io/psat.py | PSATReader.push_slack | def push_slack(self, tokens):
""" Finds the slack bus, adds a Generator with the appropriate data
and sets the bus type to slack.
"""
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" | python | def push_slack(self, tokens):
""" Finds the slack bus, adds a Generator with the appropriate data
and sets the bus type to slack.
"""
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" | [
"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\"",
"]",
"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. | [
"Finds",
"the",
"slack",
"bus",
"adds",
"a",
"Generator",
"with",
"the",
"appropriate",
"data",
"and",
"sets",
"the",
"bus",
"type",
"to",
"slack",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L418-L435 | train |
rwl/pylon | pylon/io/psat.py | PSATReader.push_pv | def push_pv(self, tokens):
""" Creates and Generator object, populates it with data, finds its Bus
and adds it.
"""
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) | python | def push_pv(self, tokens):
""" Creates and Generator object, populates it with data, finds its Bus
and adds it.
"""
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) | [
"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\"",
"]",
"self",
".",
"case",
".",
"generators",
".",
"append",
"(",
"g",
")"
] | Creates and Generator object, populates it with data, finds its Bus
and adds it. | [
"Creates",
"and",
"Generator",
"object",
"populates",
"it",
"with",
"data",
"finds",
"its",
"Bus",
"and",
"adds",
"it",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L438-L454 | train |
rwl/pylon | pylon/io/psat.py | PSATReader.push_pq | def push_pq(self, tokens):
""" Creates and Load object, populates it with data, finds its Bus and
adds it.
"""
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"] | python | def push_pq(self, tokens):
""" Creates and Load object, populates it with data, finds its Bus and
adds it.
"""
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"] | [
"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. | [
"Creates",
"and",
"Load",
"object",
"populates",
"it",
"with",
"data",
"finds",
"its",
"Bus",
"and",
"adds",
"it",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L457-L465 | train |
rwl/pylon | pylon/io/psat.py | PSATReader.push_supply | def push_supply(self, tokens):
""" Adds OPF and CPF data to a Generator.
"""
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"]
) | python | def push_supply(self, tokens):
""" Adds OPF and CPF data to a Generator.
"""
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"]
) | [
"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. | [
"Adds",
"OPF",
"and",
"CPF",
"data",
"to",
"a",
"Generator",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psat.py#L493-L518 | train |
rwl/pylon | pylon/io/matpower.py | MATPOWERReader._parse_file | def _parse_file(self, file):
""" Parses the given file-like object.
"""
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 | python | def _parse_file(self, file):
""" Parses the given file-like object.
"""
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 | [
"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. | [
"Parses",
"the",
"given",
"file",
"-",
"like",
"object",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/matpower.py#L95-L125 | train |
rwl/pylon | pylon/io/matpower.py | MATPOWERWriter.write | def write(self, file_or_filename):
""" Writes case data to file in MATPOWER format.
"""
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) | python | def write(self, file_or_filename):
""" Writes case data to file in MATPOWER format.
"""
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) | [
"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. | [
"Writes",
"case",
"data",
"to",
"file",
"in",
"MATPOWER",
"format",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/matpower.py#L748-L758 | train |
rwl/pylon | pylon/io/matpower.py | MATPOWERWriter.write_case_data | def write_case_data(self, file):
""" Writes the case data in MATPOWER format.
"""
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)) | python | def write_case_data(self, file):
""" Writes the case data in MATPOWER format.
"""
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)) | [
"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. | [
"Writes",
"the",
"case",
"data",
"in",
"MATPOWER",
"format",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/matpower.py#L767-L776 | train |
rwl/pylon | pylon/io/matpower.py | MATPOWERWriter.write_generator_cost_data | def write_generator_cost_data(self, file):
""" Writes generator cost data to 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") | python | def write_generator_cost_data(self, file):
""" Writes generator cost data to 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") | [
"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",
"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. | [
"Writes",
"generator",
"cost",
"data",
"to",
"file",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/matpower.py#L858-L888 | train |
rwl/pylon | pylon/io/matpower.py | MATPOWERWriter.write_area_data | def write_area_data(self, file):
""" Writes area data to 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") | python | def write_area_data(self, file):
""" Writes area data to 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") | [
"def",
"write_area_data",
"(",
"self",
",",
"file",
")",
":",
"file",
".",
"write",
"(",
"\"%% area data\"",
"+",
"\"\\n\"",
")",
"file",
".",
"write",
"(",
"\"%\\tno.\\tprice_ref_bus\"",
"+",
"\"\\n\"",
")",
"file",
".",
"write",
"(",
"\"areas = [\"",
"+",
"\"\\n\"",
")",
"file",
".",
"write",
"(",
"\"\\t1\\t1;\"",
"+",
"\"\\n\"",
")",
"file",
".",
"write",
"(",
"\"];\"",
"+",
"\"\\n\"",
")"
] | Writes area data to file. | [
"Writes",
"area",
"data",
"to",
"file",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/matpower.py#L906-L915 | train |
finklabs/metrics | metrics/metricbase.py | MetricBase.process_file | def process_file(self, language, key, token_list):
"""
Initiate processing for each token.
Override this if you want tt control the processing of the tokens yourself.
"""
self.language = language
for tok in token_list:
self.process_token(tok) | python | def process_file(self, language, key, token_list):
"""
Initiate processing for each token.
Override this if you want tt control the processing of the tokens yourself.
"""
self.language = language
for tok in token_list:
self.process_token(tok) | [
"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.
Override this if you want tt control the processing of the tokens yourself. | [
"Initiate",
"processing",
"for",
"each",
"token",
"."
] | fd9974af498831664b9ae8e8f3834e1ec2e8a699 | https://github.com/finklabs/metrics/blob/fd9974af498831664b9ae8e8f3834e1ec2e8a699/metrics/metricbase.py#L26-L34 | train |
rwl/pylon | pyreto/renderer.py | ParticipantRenderer.draw_plot | def draw_plot(self):
""" Initialises plots of the environment.
"""
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() | python | def draw_plot(self):
""" Initialises plots of the environment.
"""
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() | [
"def",
"draw_plot",
"(",
"self",
")",
":",
"pylab",
".",
"ion",
"(",
")",
"fig",
"=",
"pylab",
".",
"figure",
"(",
"1",
")",
"reward_axis",
"=",
"fig",
".",
"add_subplot",
"(",
"3",
",",
"1",
",",
"3",
")",
"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. | [
"Initialises",
"plots",
"of",
"the",
"environment",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/renderer.py#L177-L211 | train |
rwl/pylon | pylon/io/psse.py | PSSEWriter.write_case_data | def write_case_data(self, file):
""" Writes case data to 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))) | python | def write_case_data(self, file):
""" Writes case data to 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))) | [
"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. | [
"Writes",
"case",
"data",
"to",
"file",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/psse.py#L387-L397 | train |
rwl/pylon | pyreto/util.py | plotGenCost | def plotGenCost(generators):
""" Plots the costs of the given 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() | python | def plotGenCost(generators):
""" Plots the costs of the given 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() | [
"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. | [
"Plots",
"the",
"costs",
"of",
"the",
"given",
"generators",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/util.py#L129-L147 | train |
rwl/pylon | pyreto/util.py | ReSTExperimentWriter.write | def write(self, file):
""" Writes market experiment data to file in ReStructuredText format.
"""
# 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") | python | def write(self, file):
""" Writes market experiment data to file in ReStructuredText format.
"""
# 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") | [
"def",
"write",
"(",
"self",
",",
"file",
")",
":",
"file",
".",
"write",
"(",
"\"State\\n\"",
")",
"file",
".",
"write",
"(",
"(",
"\"-\"",
"*",
"5",
")",
"+",
"\"\\n\"",
")",
"self",
".",
"writeDataTable",
"(",
"file",
",",
"type",
"=",
"\"state\"",
")",
"file",
".",
"write",
"(",
"\"Action\\n\"",
")",
"file",
".",
"write",
"(",
"(",
"\"-\"",
"*",
"6",
")",
"+",
"\"\\n\"",
")",
"self",
".",
"writeDataTable",
"(",
"file",
",",
"type",
"=",
"\"action\"",
")",
"file",
".",
"write",
"(",
"\"Reward\\n\"",
")",
"file",
".",
"write",
"(",
"(",
"\"-\"",
"*",
"6",
")",
"+",
"\"\\n\"",
")",
"self",
".",
"writeDataTable",
"(",
"file",
",",
"type",
"=",
"\"reward\"",
")"
] | Writes market experiment data to file in ReStructuredText format. | [
"Writes",
"market",
"experiment",
"data",
"to",
"file",
"in",
"ReStructuredText",
"format",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/util.py#L210-L226 | train |
rwl/pylon | pyreto/util.py | ReSTExperimentWriter.writeDataTable | def writeDataTable(self, file, type):
""" Writes agent data to an ReST table. The 'type' argument may
be 'state', 'action' or 'reward'.
"""
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) | python | def writeDataTable(self, file, type):
""" Writes agent data to an ReST table. The 'type' argument may
be 'state', 'action' or 'reward'.
"""
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) | [
"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",
")",
"file",
".",
"write",
"(",
"\"..\"",
".",
"rjust",
"(",
"idxColWidth",
")",
"+",
"\" \"",
")",
"for",
"agent",
"in",
"agents",
":",
"file",
".",
"write",
"(",
"agent",
".",
"name",
"[",
"-",
"colWidth",
":",
"]",
".",
"center",
"(",
"colWidth",
")",
"+",
"\" \"",
")",
"file",
".",
"write",
"(",
"\"\\n\"",
")",
"file",
".",
"write",
"(",
"sep",
")",
"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",
")",
"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'. | [
"Writes",
"agent",
"data",
"to",
"an",
"ReST",
"table",
".",
"The",
"type",
"argument",
"may",
"be",
"state",
"action",
"or",
"reward",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/util.py#L229-L269 | train |
rwl/pylon | pyreto/continuous/task.py | ProfitTask.performAction | def performAction(self, action):
""" Execute one action.
"""
# print "ACTION:", action
self.t += 1
Task.performAction(self, action)
# self.addReward()
self.samples += 1 | python | def performAction(self, action):
""" Execute one action.
"""
# print "ACTION:", action
self.t += 1
Task.performAction(self, action)
# self.addReward()
self.samples += 1 | [
"def",
"performAction",
"(",
"self",
",",
"action",
")",
":",
"self",
".",
"t",
"+=",
"1",
"Task",
".",
"performAction",
"(",
"self",
",",
"action",
")",
"self",
".",
"samples",
"+=",
"1"
] | Execute one action. | [
"Execute",
"one",
"action",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/continuous/task.py#L74-L81 | train |
pymoca/pymoca | src/pymoca/backends/xml/model.py | split_dae_alg | def split_dae_alg(eqs: SYM, dx: SYM) -> Dict[str, SYM]:
"""Split equations into differential algebraic and algebraic only"""
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)
} | python | def split_dae_alg(eqs: SYM, dx: SYM) -> Dict[str, SYM]:
"""Split equations into differential algebraic and algebraic only"""
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)
} | [
"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 | [
"Split",
"equations",
"into",
"differential",
"algebraic",
"and",
"algebraic",
"only"
] | 14b5eb7425e96689de6cc5c10f400895d586a978 | https://github.com/pymoca/pymoca/blob/14b5eb7425e96689de6cc5c10f400895d586a978/src/pymoca/backends/xml/model.py#L174-L186 | train |
pymoca/pymoca | src/pymoca/backends/xml/model.py | permute | def permute(x: SYM, perm: List[int]) -> SYM:
"""Perumute a vector"""
x_s = []
for i in perm:
x_s.append(x[i])
return ca.vertcat(*x_s) | python | def permute(x: SYM, perm: List[int]) -> SYM:
"""Perumute a vector"""
x_s = []
for i in perm:
x_s.append(x[i])
return ca.vertcat(*x_s) | [
"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 | [
"Perumute",
"a",
"vector"
] | 14b5eb7425e96689de6cc5c10f400895d586a978 | https://github.com/pymoca/pymoca/blob/14b5eb7425e96689de6cc5c10f400895d586a978/src/pymoca/backends/xml/model.py#L189-L194 | train |
pymoca/pymoca | src/pymoca/backends/xml/model.py | blt | def blt(f: List[SYM], x: List[SYM]) -> Dict[str, Any]:
"""
Sort equations by dependence
"""
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
} | python | def blt(f: List[SYM], x: List[SYM]) -> Dict[str, Any]:
"""
Sort equations by dependence
"""
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
} | [
"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 | [
"Sort",
"equations",
"by",
"dependence"
] | 14b5eb7425e96689de6cc5c10f400895d586a978 | https://github.com/pymoca/pymoca/blob/14b5eb7425e96689de6cc5c10f400895d586a978/src/pymoca/backends/xml/model.py#L198-L213 | train |
pymoca/pymoca | src/pymoca/backends/xml/model.py | HybridOde.create_function_f_m | def create_function_f_m(self):
"""Discrete state dynamics"""
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) | python | def create_function_f_m(self):
"""Discrete state dynamics"""
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) | [
"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 | [
"Discrete",
"state",
"dynamics"
] | 14b5eb7425e96689de6cc5c10f400895d586a978 | https://github.com/pymoca/pymoca/blob/14b5eb7425e96689de6cc5c10f400895d586a978/src/pymoca/backends/xml/model.py#L94-L100 | train |
pymoca/pymoca | src/pymoca/backends/xml/model.py | HybridOde.create_function_f_J | def create_function_f_J(self):
"""Jacobian for state integration"""
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) | python | def create_function_f_J(self):
"""Jacobian for state integration"""
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) | [
"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 | [
"Jacobian",
"for",
"state",
"integration"
] | 14b5eb7425e96689de6cc5c10f400895d586a978 | https://github.com/pymoca/pymoca/blob/14b5eb7425e96689de6cc5c10f400895d586a978/src/pymoca/backends/xml/model.py#L102-L108 | train |
pymoca/pymoca | src/pymoca/backends/xml/model.py | HybridDae.to_ode | def to_ode(self) -> HybridOde:
"""Convert to a 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,
) | python | def to_ode(self) -> HybridOde:
"""Convert to a 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,
) | [
"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 | [
"Convert",
"to",
"a",
"HybridOde"
] | 14b5eb7425e96689de6cc5c10f400895d586a978 | https://github.com/pymoca/pymoca/blob/14b5eb7425e96689de6cc5c10f400895d586a978/src/pymoca/backends/xml/model.py#L143-L171 | train |
rwl/pylon | pylon/util.py | format_from_extension | def format_from_extension(fname):
""" Tries to infer a protocol from the file extension."""
_base, ext = os.path.splitext(fname)
if not ext:
return None
try:
format = known_extensions[ext.replace('.', '')]
except KeyError:
format = None
return format | python | def format_from_extension(fname):
""" Tries to infer a protocol from the file extension."""
_base, ext = os.path.splitext(fname)
if not ext:
return None
try:
format = known_extensions[ext.replace('.', '')]
except KeyError:
format = None
return format | [
"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. | [
"Tries",
"to",
"infer",
"a",
"protocol",
"from",
"the",
"file",
"extension",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/util.py#L159-L168 | train |
rwl/pylon | pylon/util.py | pickle_matpower_cases | def pickle_matpower_cases(case_paths, case_format=2):
""" Parses the MATPOWER case files at the given paths and pickles the
resulting Case objects to the same directory.
"""
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) | python | def pickle_matpower_cases(case_paths, case_format=2):
""" Parses the MATPOWER case files at the given paths and pickles the
resulting Case objects to the same directory.
"""
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) | [
"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",
":",
"case",
"=",
"pylon",
".",
"io",
".",
"MATPOWERReader",
"(",
"case_format",
")",
".",
"read",
"(",
"case_path",
")",
"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'",
")",
"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. | [
"Parses",
"the",
"MATPOWER",
"case",
"files",
"at",
"the",
"given",
"paths",
"and",
"pickles",
"the",
"resulting",
"Case",
"objects",
"to",
"the",
"same",
"directory",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/util.py#L174-L194 | train |
rwl/pylon | pylon/util.py | fair_max | def fair_max(x):
""" 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.
"""
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 | python | def fair_max(x):
""" 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.
"""
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 | [
"def",
"fair_max",
"(",
"x",
")",
":",
"value",
"=",
"max",
"(",
"x",
")",
"i",
"=",
"[",
"x",
".",
"index",
"(",
"v",
")",
"for",
"v",
"in",
"x",
"if",
"v",
"==",
"value",
"]",
"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. | [
"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",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/util.py#L243-L256 | train |
rwl/pylon | pylon/util.py | factorial | def factorial(n):
""" Returns the factorial of n.
"""
f = 1
while (n > 0):
f = f * n
n = n - 1
return f | python | def factorial(n):
""" Returns the factorial of n.
"""
f = 1
while (n > 0):
f = f * n
n = n - 1
return f | [
"def",
"factorial",
"(",
"n",
")",
":",
"f",
"=",
"1",
"while",
"(",
"n",
">",
"0",
")",
":",
"f",
"=",
"f",
"*",
"n",
"n",
"=",
"n",
"-",
"1",
"return",
"f"
] | Returns the factorial of n. | [
"Returns",
"the",
"factorial",
"of",
"n",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/util.py#L262-L269 | train |
rwl/pylon | pylon/util.py | _Named._get_name | def _get_name(self):
""" Returns the name, which is generated if it has not been already.
"""
if self._name is None:
self._name = self._generate_name()
return self._name | python | def _get_name(self):
""" Returns the name, which is generated if it has not been already.
"""
if self._name is None:
self._name = self._generate_name()
return self._name | [
"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. | [
"Returns",
"the",
"name",
"which",
"is",
"generated",
"if",
"it",
"has",
"not",
"been",
"already",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/util.py#L61-L66 | train |
rwl/pylon | pylon/util.py | _Serializable.save_to_file_object | def save_to_file_object(self, fd, format=None, **kwargs):
""" Save the object to a given file like object in the given format.
"""
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) | python | def save_to_file_object(self, fd, format=None, **kwargs):
""" Save the object to a given file like object in the given format.
"""
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) | [
"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. | [
"Save",
"the",
"object",
"to",
"a",
"given",
"file",
"like",
"object",
"in",
"the",
"given",
"format",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/util.py#L98-L105 | train |
rwl/pylon | pylon/util.py | _Serializable.load_from_file_object | def load_from_file_object(cls, fd, format=None):
""" Load the object from a given file like object in the given format.
"""
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) | python | def load_from_file_object(cls, fd, format=None):
""" Load the object from a given file like object in the given format.
"""
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) | [
"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. | [
"Load",
"the",
"object",
"from",
"a",
"given",
"file",
"like",
"object",
"in",
"the",
"given",
"format",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/util.py#L109-L116 | train |
rwl/pylon | pylon/util.py | _Serializable.save | def save(self, filename, format=None, **kwargs):
""" Save the object to file given by filename.
"""
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) | python | def save(self, filename, format=None, **kwargs):
""" Save the object to file given by filename.
"""
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) | [
"def",
"save",
"(",
"self",
",",
"filename",
",",
"format",
"=",
"None",
",",
"**",
"kwargs",
")",
":",
"if",
"format",
"is",
"None",
":",
"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. | [
"Save",
"the",
"object",
"to",
"file",
"given",
"by",
"filename",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/util.py#L119-L126 | train |
rwl/pylon | pylon/util.py | _Serializable.load | def load(cls, filename, format=None):
""" Return an instance of the class that is saved in the file with the
given filename in the specified format.
"""
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 | python | def load(cls, filename, format=None):
""" Return an instance of the class that is saved in the file with the
given filename in the specified format.
"""
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 | [
"def",
"load",
"(",
"cls",
",",
"filename",
",",
"format",
"=",
"None",
")",
":",
"if",
"format",
"is",
"None",
":",
"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. | [
"Return",
"an",
"instance",
"of",
"the",
"class",
"that",
"is",
"saved",
"in",
"the",
"file",
"with",
"the",
"given",
"filename",
"in",
"the",
"specified",
"format",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/util.py#L130-L140 | train |
rwl/pylon | pylon/dc_pf.py | DCPF.solve | def solve(self):
""" Solves a DC power flow.
"""
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 | python | def solve(self):
""" Solves a DC power flow.
"""
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 | [
"def",
"solve",
"(",
"self",
")",
":",
"case",
"=",
"self",
".",
"case",
"logger",
".",
"info",
"(",
"\"Starting DC power flow [%s].\"",
"%",
"case",
".",
"name",
")",
"t0",
"=",
"time",
".",
"time",
"(",
")",
"self",
".",
"case",
".",
"index_buses",
"(",
")",
"ref_idx",
"=",
"self",
".",
"_get_reference_index",
"(",
"case",
")",
"if",
"ref_idx",
"<",
"0",
":",
"return",
"False",
"B",
",",
"Bsrc",
",",
"p_businj",
",",
"p_srcinj",
"=",
"case",
".",
"Bdc",
"v_angle_guess",
"=",
"self",
".",
"_get_v_angle_guess",
"(",
"case",
")",
"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",
"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. | [
"Solves",
"a",
"DC",
"power",
"flow",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/dc_pf.py#L66-L95 | train |
rwl/pylon | pylon/dc_pf.py | DCPF._get_reference_index | def _get_reference_index(self, case):
""" Returns the index of the reference bus.
"""
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 | python | def _get_reference_index(self, case):
""" Returns the index of the reference bus.
"""
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 | [
"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. | [
"Returns",
"the",
"index",
"of",
"the",
"reference",
"bus",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/dc_pf.py#L101-L109 | train |
rwl/pylon | pylon/dc_pf.py | DCPF._get_v_angle_guess | def _get_v_angle_guess(self, case):
""" Make the vector of voltage phase guesses.
"""
v_angle = array([bus.v_angle * (pi / 180.0)
for bus in case.connected_buses])
return v_angle | python | def _get_v_angle_guess(self, case):
""" Make the vector of voltage phase guesses.
"""
v_angle = array([bus.v_angle * (pi / 180.0)
for bus in case.connected_buses])
return v_angle | [
"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. | [
"Make",
"the",
"vector",
"of",
"voltage",
"phase",
"guesses",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/dc_pf.py#L115-L120 | train |
rwl/pylon | pylon/dc_pf.py | DCPF._get_v_angle | def _get_v_angle(self, case, B, v_angle_guess, p_businj, iref):
""" Calculates the voltage phase angles.
"""
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] | python | def _get_v_angle(self, case, B, v_angle_guess, p_businj, iref):
""" Calculates the voltage phase angles.
"""
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] | [
"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",
"]",
"Bpvpq",
"=",
"B",
"[",
"pvpq_rows",
",",
"pvpq_idxs",
"]",
"Bref",
"=",
"B",
"[",
"pvpq_rows",
",",
"[",
"iref",
"]",
"]",
"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",
"=",
"spsolve",
"(",
"A",
",",
"b",
")",
"v_angle",
"=",
"r_",
"[",
"x",
"[",
":",
"iref",
"]",
",",
"v_angle_guess",
"[",
"iref",
"]",
",",
"x",
"[",
"iref",
":",
"]",
"]",
"return",
"v_angle",
",",
"Pbus",
"[",
"iref",
"]"
] | Calculates the voltage phase angles. | [
"Calculates",
"the",
"voltage",
"phase",
"angles",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/dc_pf.py#L126-L159 | train |
rwl/pylon | pylon/dc_pf.py | DCPF._update_model | def _update_model(self, case, B, Bsrc, v_angle, p_srcinj, p_ref, ref_idx):
""" Updates the case with values computed from the voltage phase
angle solution.
"""
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] | python | def _update_model(self, case, B, Bsrc, v_angle, p_srcinj, p_ref, ref_idx):
""" Updates the case with values computed from the voltage phase
angle solution.
"""
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] | [
"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",
"g_ref",
"=",
"[",
"g",
"for",
"g",
"in",
"case",
".",
"generators",
"if",
"g",
".",
"bus",
"==",
"buses",
"[",
"iref",
"]",
"]",
"[",
"0",
"]",
"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. | [
"Updates",
"the",
"case",
"with",
"values",
"computed",
"from",
"the",
"voltage",
"phase",
"angle",
"solution",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/dc_pf.py#L165-L192 | train |
rwl/pylon | pylon/case.py | Case.getSbus | def getSbus(self, buses=None):
""" Returns the net complex bus power injection vector in p.u.
"""
bs = self.buses if buses is None else buses
s = array([self.s_surplus(v) / self.base_mva for v in bs])
return s | python | def getSbus(self, buses=None):
""" Returns the net complex bus power injection vector in p.u.
"""
bs = self.buses if buses is None else buses
s = array([self.s_surplus(v) / self.base_mva for v in bs])
return s | [
"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. | [
"Returns",
"the",
"net",
"complex",
"bus",
"power",
"injection",
"vector",
"in",
"p",
".",
"u",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/case.py#L270-L275 | train |
rwl/pylon | pylon/case.py | Case.sort_generators | def sort_generators(self):
""" Reorders the list of generators according to bus index.
"""
self.generators.sort(key=lambda gn: gn.bus._i) | python | def sort_generators(self):
""" Reorders the list of generators according to bus index.
"""
self.generators.sort(key=lambda gn: gn.bus._i) | [
"def",
"sort_generators",
"(",
"self",
")",
":",
"self",
".",
"generators",
".",
"sort",
"(",
"key",
"=",
"lambda",
"gn",
":",
"gn",
".",
"bus",
".",
"_i",
")"
] | Reorders the list of generators according to bus index. | [
"Reorders",
"the",
"list",
"of",
"generators",
"according",
"to",
"bus",
"index",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/case.py#L280-L283 | train |
rwl/pylon | pylon/case.py | Case.index_buses | def index_buses(self, buses=None, start=0):
""" Updates the indices of all buses.
@param start: Starting index, typically 0 or 1.
@type start: int
"""
bs = self.connected_buses if buses is None else buses
for i, b in enumerate(bs):
b._i = start + i | python | def index_buses(self, buses=None, start=0):
""" Updates the indices of all buses.
@param start: Starting index, typically 0 or 1.
@type start: int
"""
bs = self.connected_buses if buses is None else buses
for i, b in enumerate(bs):
b._i = start + i | [
"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.
@param start: Starting index, typically 0 or 1.
@type start: int | [
"Updates",
"the",
"indices",
"of",
"all",
"buses",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/case.py#L289-L297 | train |
rwl/pylon | pylon/case.py | Case.index_branches | def index_branches(self, branches=None, start=0):
""" Updates the indices of all branches.
@param start: Starting index, typically 0 or 1.
@type start: int
"""
ln = self.online_branches if branches is None else branches
for i, l in enumerate(ln):
l._i = start + i | python | def index_branches(self, branches=None, start=0):
""" Updates the indices of all branches.
@param start: Starting index, typically 0 or 1.
@type start: int
"""
ln = self.online_branches if branches is None else branches
for i, l in enumerate(ln):
l._i = start + i | [
"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.
@param start: Starting index, typically 0 or 1.
@type start: int | [
"Updates",
"the",
"indices",
"of",
"all",
"branches",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/case.py#L300-L308 | train |
rwl/pylon | pylon/case.py | Case.s_supply | def s_supply(self, bus):
""" Returns the total complex power generation capacity.
"""
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 | python | def s_supply(self, bus):
""" Returns the total complex power generation capacity.
"""
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 | [
"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. | [
"Returns",
"the",
"total",
"complex",
"power",
"generation",
"capacity",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/case.py#L314-L323 | train |
rwl/pylon | pylon/case.py | Case.s_demand | def s_demand(self, bus):
""" Returns the total complex power demand.
"""
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 | python | def s_demand(self, bus):
""" Returns the total complex power demand.
"""
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 | [
"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. | [
"Returns",
"the",
"total",
"complex",
"power",
"demand",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/case.py#L326-L334 | train |
rwl/pylon | pylon/case.py | Case.reset | def reset(self):
""" Resets the readonly variables for all of the case components.
"""
for bus in self.buses:
bus.reset()
for branch in self.branches:
branch.reset()
for generator in self.generators:
generator.reset() | python | def reset(self):
""" Resets the readonly variables for all of the case components.
"""
for bus in self.buses:
bus.reset()
for branch in self.branches:
branch.reset()
for generator in self.generators:
generator.reset() | [
"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. | [
"Resets",
"the",
"readonly",
"variables",
"for",
"all",
"of",
"the",
"case",
"components",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/case.py#L911-L919 | train |
rwl/pylon | pylon/case.py | Case.save_matpower | def save_matpower(self, fd):
""" Serialize the case as a MATPOWER data file.
"""
from pylon.io import MATPOWERWriter
MATPOWERWriter(self).write(fd) | python | def save_matpower(self, fd):
""" Serialize the case as a MATPOWER data file.
"""
from pylon.io import MATPOWERWriter
MATPOWERWriter(self).write(fd) | [
"def",
"save_matpower",
"(",
"self",
",",
"fd",
")",
":",
"from",
"pylon",
".",
"io",
"import",
"MATPOWERWriter",
"MATPOWERWriter",
"(",
"self",
")",
".",
"write",
"(",
"fd",
")"
] | Serialize the case as a MATPOWER data file. | [
"Serialize",
"the",
"case",
"as",
"a",
"MATPOWER",
"data",
"file",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/case.py#L925-L929 | train |
rwl/pylon | pylon/case.py | Case.load_psat | def load_psat(cls, fd):
""" Returns a case object from the given PSAT data file.
"""
from pylon.io.psat import PSATReader
return PSATReader().read(fd) | python | def load_psat(cls, fd):
""" Returns a case object from the given PSAT data file.
"""
from pylon.io.psat import PSATReader
return PSATReader().read(fd) | [
"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. | [
"Returns",
"a",
"case",
"object",
"from",
"the",
"given",
"PSAT",
"data",
"file",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/case.py#L960-L964 | train |
rwl/pylon | pylon/case.py | Case.save_rst | def save_rst(self, fd):
""" Save a reStructuredText representation of the case.
"""
from pylon.io import ReSTWriter
ReSTWriter(self).write(fd) | python | def save_rst(self, fd):
""" Save a reStructuredText representation of the case.
"""
from pylon.io import ReSTWriter
ReSTWriter(self).write(fd) | [
"def",
"save_rst",
"(",
"self",
",",
"fd",
")",
":",
"from",
"pylon",
".",
"io",
"import",
"ReSTWriter",
"ReSTWriter",
"(",
"self",
")",
".",
"write",
"(",
"fd",
")"
] | Save a reStructuredText representation of the case. | [
"Save",
"a",
"reStructuredText",
"representation",
"of",
"the",
"case",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/case.py#L967-L971 | train |
rwl/pylon | pylon/case.py | Case.save_csv | def save_csv(self, fd):
""" Saves the case as a series of Comma-Separated Values.
"""
from pylon.io.excel import CSVWriter
CSVWriter(self).write(fd) | python | def save_csv(self, fd):
""" Saves the case as a series of Comma-Separated Values.
"""
from pylon.io.excel import CSVWriter
CSVWriter(self).write(fd) | [
"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. | [
"Saves",
"the",
"case",
"as",
"a",
"series",
"of",
"Comma",
"-",
"Separated",
"Values",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/case.py#L974-L978 | train |
rwl/pylon | pylon/case.py | Case.save_excel | def save_excel(self, fd):
""" Saves the case as an Excel spreadsheet.
"""
from pylon.io.excel import ExcelWriter
ExcelWriter(self).write(fd) | python | def save_excel(self, fd):
""" Saves the case as an Excel spreadsheet.
"""
from pylon.io.excel import ExcelWriter
ExcelWriter(self).write(fd) | [
"def",
"save_excel",
"(",
"self",
",",
"fd",
")",
":",
"from",
"pylon",
".",
"io",
".",
"excel",
"import",
"ExcelWriter",
"ExcelWriter",
"(",
"self",
")",
".",
"write",
"(",
"fd",
")"
] | Saves the case as an Excel spreadsheet. | [
"Saves",
"the",
"case",
"as",
"an",
"Excel",
"spreadsheet",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/case.py#L981-L985 | train |
rwl/pylon | pylon/case.py | Case.save_dot | def save_dot(self, fd):
""" Saves a representation of the case in the Graphviz DOT language.
"""
from pylon.io import DotWriter
DotWriter(self).write(fd) | python | def save_dot(self, fd):
""" Saves a representation of the case in the Graphviz DOT language.
"""
from pylon.io import DotWriter
DotWriter(self).write(fd) | [
"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. | [
"Saves",
"a",
"representation",
"of",
"the",
"case",
"in",
"the",
"Graphviz",
"DOT",
"language",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/case.py#L988-L992 | train |
rwl/pylon | pylon/ac_pf.py | _ACPF.solve | def solve(self):
""" Runs a power flow
@rtype: dict
@return: Solution dictionary with the following keys:
- C{V} - final complex voltages
- C{converged} - boolean value indicating if the solver
converged or not
- C{iterations} - the number of iterations performed
"""
# 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} | python | def solve(self):
""" Runs a power flow
@rtype: dict
@return: Solution dictionary with the following keys:
- C{V} - final complex voltages
- C{converged} - boolean value indicating if the solver
converged or not
- C{iterations} - the number of iterations performed
"""
# 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} | [
"def",
"solve",
"(",
"self",
")",
":",
"self",
".",
"case",
".",
"reset",
"(",
")",
"b",
",",
"l",
",",
"g",
",",
"_",
",",
"_",
",",
"_",
",",
"_",
"=",
"self",
".",
"_unpack_case",
"(",
"self",
".",
"case",
")",
"self",
".",
"case",
".",
"index_buses",
"(",
"b",
")",
"refs",
",",
"pq",
",",
"pv",
",",
"pvpq",
"=",
"self",
".",
"_index_buses",
"(",
"b",
")",
"if",
"len",
"(",
"refs",
")",
"!=",
"1",
":",
"logger",
".",
"error",
"(",
"\"Swing bus required for DCPF.\"",
")",
"return",
"{",
"\"converged\"",
":",
"False",
"}",
"t0",
"=",
"time",
"(",
")",
"V0",
"=",
"self",
".",
"_initial_voltage",
"(",
"b",
",",
"g",
")",
"repeat",
"=",
"True",
"while",
"repeat",
":",
"Ybus",
",",
"Yf",
",",
"Yt",
"=",
"self",
".",
"case",
".",
"getYbus",
"(",
"b",
",",
"l",
")",
"Sbus",
"=",
"self",
".",
"case",
".",
"getSbus",
"(",
"b",
")",
"V",
",",
"converged",
",",
"i",
"=",
"self",
".",
"_run_power_flow",
"(",
"Ybus",
",",
"Sbus",
",",
"V0",
",",
"pv",
",",
"pq",
",",
"pvpq",
")",
"self",
".",
"case",
".",
"pf_solution",
"(",
"Ybus",
",",
"Yf",
",",
"Yt",
",",
"V",
")",
"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
@rtype: dict
@return: Solution dictionary with the following keys:
- C{V} - final complex voltages
- C{converged} - boolean value indicating if the solver
converged or not
- C{iterations} - the number of iterations performed | [
"Runs",
"a",
"power",
"flow"
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/ac_pf.py#L94-L166 | train |
rwl/pylon | pylon/ac_pf.py | _ACPF._unpack_case | def _unpack_case(self, case):
""" Returns the contents of the case to be used in the OPF.
"""
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 | python | def _unpack_case(self, case):
""" Returns the contents of the case to be used in the OPF.
"""
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 | [
"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. | [
"Returns",
"the",
"contents",
"of",
"the",
"case",
"to",
"be",
"used",
"in",
"the",
"OPF",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/ac_pf.py#L169-L180 | train |
rwl/pylon | pylon/ac_pf.py | _ACPF._index_buses | def _index_buses(self, buses):
""" Set up indexing for updating v.
"""
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 | python | def _index_buses(self, buses):
""" Set up indexing for updating v.
"""
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 | [
"def",
"_index_buses",
"(",
"self",
",",
"buses",
")",
":",
"refs",
"=",
"[",
"bus",
".",
"_i",
"for",
"bus",
"in",
"buses",
"if",
"bus",
".",
"type",
"==",
"REFERENCE",
"]",
"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. | [
"Set",
"up",
"indexing",
"for",
"updating",
"v",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/ac_pf.py#L183-L193 | train |
rwl/pylon | pylon/ac_pf.py | _ACPF._initial_voltage | def _initial_voltage(self, buses, generators):
""" Returns the initial vector of complex bus voltages.
The bus voltage vector contains the set point for generator
(including ref bus) buses, and the reference angle of the swing
bus, as well as an initial guess for remaining magnitudes and
angles.
"""
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 | python | def _initial_voltage(self, buses, generators):
""" Returns the initial vector of complex bus voltages.
The bus voltage vector contains the set point for generator
(including ref bus) buses, and the reference angle of the swing
bus, as well as an initial guess for remaining magnitudes and
angles.
"""
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 | [
"def",
"_initial_voltage",
"(",
"self",
",",
"buses",
",",
"generators",
")",
":",
"Vm",
"=",
"array",
"(",
"[",
"bus",
".",
"v_magnitude",
"for",
"bus",
"in",
"buses",
"]",
")",
"Va",
"=",
"array",
"(",
"[",
"bus",
".",
"v_angle",
"*",
"(",
"pi",
"/",
"180.0",
")",
"for",
"bus",
"in",
"buses",
"]",
")",
"V",
"=",
"Vm",
"*",
"exp",
"(",
"1j",
"*",
"Va",
")",
"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.
The bus voltage vector contains the set point for generator
(including ref bus) buses, and the reference angle of the swing
bus, as well as an initial guess for remaining magnitudes and
angles. | [
"Returns",
"the",
"initial",
"vector",
"of",
"complex",
"bus",
"voltages",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/ac_pf.py#L196-L216 | train |
rwl/pylon | pylon/ac_pf.py | NewtonPF._one_iteration | def _one_iteration(self, F, Ybus, V, Vm, Va, pv, pq, pvpq):
""" Performs one Newton iteration.
"""
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 | python | def _one_iteration(self, F, Ybus, V, Vm, Va, pv, pq, pvpq):
""" Performs one Newton iteration.
"""
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 | [
"def",
"_one_iteration",
"(",
"self",
",",
"F",
",",
"Ybus",
",",
"V",
",",
"Vm",
",",
"Va",
",",
"pv",
",",
"pq",
",",
"pvpq",
")",
":",
"J",
"=",
"self",
".",
"_build_jacobian",
"(",
"Ybus",
",",
"V",
",",
"pv",
",",
"pq",
",",
"pvpq",
")",
"dx",
"=",
"-",
"1",
"*",
"spsolve",
"(",
"J",
",",
"F",
")",
"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",
")",
"Va",
"=",
"angle",
"(",
"V",
")",
"return",
"V",
",",
"Vm",
",",
"Va"
] | Performs one Newton iteration. | [
"Performs",
"one",
"Newton",
"iteration",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/ac_pf.py#L265-L287 | train |
rwl/pylon | pylon/ac_pf.py | NewtonPF._build_jacobian | def _build_jacobian(self, Ybus, V, pv, pq, pvpq):
""" Returns the Jacobian matrix.
"""
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 | python | def _build_jacobian(self, Ybus, V, pv, pq, pvpq):
""" Returns the Jacobian matrix.
"""
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 | [
"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. | [
"Returns",
"the",
"Jacobian",
"matrix",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/ac_pf.py#L325-L344 | train |
rwl/pylon | pylon/ac_pf.py | FastDecoupledPF._evaluate_mismatch | def _evaluate_mismatch(self, Ybus, V, Sbus, pq, pvpq):
""" Evaluates the mismatch.
"""
mis = (multiply(V, conj(Ybus * V)) - Sbus) / abs(V)
P = mis[pvpq].real
Q = mis[pq].imag
return P, Q | python | def _evaluate_mismatch(self, Ybus, V, Sbus, pq, pvpq):
""" Evaluates the mismatch.
"""
mis = (multiply(V, conj(Ybus * V)) - Sbus) / abs(V)
P = mis[pvpq].real
Q = mis[pq].imag
return P, Q | [
"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. | [
"Evaluates",
"the",
"mismatch",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/ac_pf.py#L444-L452 | train |
rwl/pylon | pylon/ac_pf.py | FastDecoupledPF._p_iteration | def _p_iteration(self, P, Bp_solver, Vm, Va, pvpq):
""" Performs a P iteration, updates Va.
"""
dVa = -Bp_solver.solve(P)
# Update voltage.
Va[pvpq] = Va[pvpq] + dVa
V = Vm * exp(1j * Va)
return V, Vm, Va | python | def _p_iteration(self, P, Bp_solver, Vm, Va, pvpq):
""" Performs a P iteration, updates Va.
"""
dVa = -Bp_solver.solve(P)
# Update voltage.
Va[pvpq] = Va[pvpq] + dVa
V = Vm * exp(1j * Va)
return V, Vm, Va | [
"def",
"_p_iteration",
"(",
"self",
",",
"P",
",",
"Bp_solver",
",",
"Vm",
",",
"Va",
",",
"pvpq",
")",
":",
"dVa",
"=",
"-",
"Bp_solver",
".",
"solve",
"(",
"P",
")",
"Va",
"[",
"pvpq",
"]",
"=",
"Va",
"[",
"pvpq",
"]",
"+",
"dVa",
"V",
"=",
"Vm",
"*",
"exp",
"(",
"1j",
"*",
"Va",
")",
"return",
"V",
",",
"Vm",
",",
"Va"
] | Performs a P iteration, updates Va. | [
"Performs",
"a",
"P",
"iteration",
"updates",
"Va",
"."
] | 916514255db1ae1661406f0283df756baf960d14 | https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/ac_pf.py#L479-L488 | train |