def testVa(self):
""" Test voltage angle solution vector from DC power flow.
"""
solver = DCPF(self.case)
solver.solve()
mpVa = mmread(join(DATA_DIR, self.case_name, "Va.mtx")).flatten()
self.assertTrue(abs(max(solver.v_angle - mpVa)) < 1e-14, self.case_name)
def main():
""" Parses the command line and call Pylon with the correct data.
"""
parser = optparse.OptionParser(usage="usage: pylon [options] input_file",
version="%prog 0.4.4")
parser.add_option("-o", "--output", dest="output", metavar="FILE",
help="Write the solution report to FILE.")
# parser.add_option("-q", "--quiet", action="store_true", dest="quiet",
# default=False, help="Print less information.")
parser.add_option("-v", "--verbose", action="store_true", dest="verbose",
default=False, help="Print more information.")
# parser.add_option("-g", "--gui", action="store_true", dest="gui",
# default=False, help="Use the portable graphical interface to Pylon.")
# parser.add_option("-n", "--no-report", action="store_true",
# dest="no_report", default=False, help="Suppress report output.")
parser.add_option("-d", "--debug", action="store_true", dest="debug",
default=False, help="Print debug information.")
parser.add_option("-t", "--input-type", dest="type", metavar="TYPE",
default="any", help="The argument following the -t is used to "
"indicate the format type of the input data file. The types which are "
"currently supported include: matpower, psse [default: %default]"
" If not specified Pylon will try to determine the type according to "
"the file name extension and the file header.")
parser.add_option("-s", "--solver", dest="solver", metavar="SOLVER",
default="acpf", help="The argument following the -s is used to"
"indicate the type of routine to use in solving. The types which are "
"currently supported are: 'dcpf', 'acpf', 'dcopf', 'acopf', 'udopf' "
"and 'none' [default: %default].")
parser.add_option("-a", "--algorithm", action="store_true",
metavar="ALGORITHM", dest="algorithm", default="newton",
help="Indicates the algorithm type to be used for AC power flow. The "
"types which are currently supported are: 'newton' and 'fdpf' "
"[default: %default].")
parser.add_option("-T", "--output-type", dest="output_type",
metavar="OUTPUT_TYPE", default="rst", help="Indicates the output "
"format type. The type swhich are currently supported include: rst, "
"matpower, csv, excel and none [default: %default].")
(options, args) = parser.parse_args()
if options.verbose:
logger.setLevel(logging.INFO)
elif options.debug:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.ERROR)
# Output.
outext = {'psse': '.raw', 'matpower': '.m'}
if options.output:
if options.output == "-":
outfile = sys.stdout
logger.setLevel(logging.CRITICAL) # must stay quiet
# options.output_type = "none"
else:
outfile = open(options.output, "wb")
elif options.output_type is not None:
if options.output_type in outext.keys():
inname, ext = os.path.splitext(args[0])
outfile = inname + outext[options.output_type]
else:
outfile = sys.stdout
else:
outfile = sys.stdout
# if not options.no_report:
# logger.setLevel(logging.CRITICAL) # must stay quiet
# Input.
if len(args) > 1:
parser.print_help()
sys.exit(1)
elif (len(args) == 0) or (args[0] == "-"):
filename = ""
if sys.stdin.isatty():
# True if the file is connected to a tty device, and False
# otherwise (pipeline or file redirection).
parser.print_help()
sys.exit(1)
else:
# Handle piped input ($ cat ehv3.raw | pylon | rst2pdf -o ans.pdf).
infile = sys.stdin
else:
filename = args[0]
infile = open(filename, "rb")
if options.type == "any":
type = detect_data_file(infile, filename)
else:
type = options.type
# Get the case from the input file-like object.
case = read_case(infile, type)
if case is not None:
# Routine (and algorithm) selection.
if options.solver == "dcpf":
solver = DCPF(case)
elif options.solver == "acpf":
if options.algorithm == "newton":
solver = NewtonPF(case)
elif options.algorithm == "fdpf":
solver = FastDecoupledPF(case)
else:
logger.critical("Invalid algorithm [%s]." % options.algorithm)
sys.exit(1)
elif options.solver == "dcopf":
solver = OPF(case, True)
elif options.solver == "acopf":
solver = OPF(case, False)
elif options.solver == "udopf":
solver = UDOPF(case)
elif options.solver == "none":
solver = None
else:
logger.critical("Invalid solver [%s]." % options.solver)
# sys.exit(1)
solver = None
# Output writer selection.
if options.output_type == "matpower":
writer = MATPOWERWriter(case)
elif options.output_type == "psse":
writer = PSSEWriter(case)
elif options.output_type == "rst":
writer = ReSTWriter(case)
elif options.output_type == "csv":
from pylon.io.excel import CSVWriter
writer = CSVWriter(case)
elif options.output_type == "excel":
from pylon.io.excel import ExcelWriter
writer = ExcelWriter(case)
elif options.output_type == "pickle":
writer = PickleWriter(case)
else:
logger.critical("Invalid output type [%s]." % options.output_type)
sys.exit(1)
if solver is not None:
solver.solve()
if options.output_type != "none":
writer.write(outfile)
print('Output file {0} written'.format(outfile))
else:
logger.critical("Unable to read case data.")
# Don't close stdin or stdout.
if len(args) == 1:
infile.close()
if options.output and not (options.output == "-"):
outfile.close()