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
sequencelengths
20
707
docstring
stringlengths
3
17.3k
docstring_tokens
sequencelengths
3
222
sha
stringlengths
40
40
url
stringlengths
87
242
partition
stringclasses
1 value
idx
int64
0
252k
rwl/pylon
pylon/ac_pf.py
FastDecoupledPF._q_iteration
def _q_iteration(self, Q, Bpp_solver, Vm, Va, pq): """ Performs a Q iteration, updates Vm. """ dVm = -Bpp_solver.solve(Q) # Update voltage. Vm[pq] = Vm[pq] + dVm V = Vm * exp(1j * Va) return V, Vm, Va
python
def _q_iteration(self, Q, Bpp_solver, Vm, Va, pq): """ Performs a Q iteration, updates Vm. """ dVm = -Bpp_solver.solve(Q) # Update voltage. Vm[pq] = Vm[pq] + dVm V = Vm * exp(1j * Va) return V, Vm, Va
[ "def", "_q_iteration", "(", "self", ",", "Q", ",", "Bpp_solver", ",", "Vm", ",", "Va", ",", "pq", ")", ":", "dVm", "=", "-", "Bpp_solver", ".", "solve", "(", "Q", ")", "# Update voltage.", "Vm", "[", "pq", "]", "=", "Vm", "[", "pq", "]", "+", "dVm", "V", "=", "Vm", "*", "exp", "(", "1j", "*", "Va", ")", "return", "V", ",", "Vm", ",", "Va" ]
Performs a Q iteration, updates Vm.
[ "Performs", "a", "Q", "iteration", "updates", "Vm", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/ac_pf.py#L494-L503
train
800
melizalab/libtfr
examples/tfr_tm.py
fmsin
def fmsin(N, fnormin=0.05, fnormax=0.45, period=None, t0=None, fnorm0=0.25, pm1=1): """ Signal with sinusoidal frequency modulation. generates a frequency modulation with a sinusoidal frequency. This sinusoidal modulation is designed such that the instantaneous frequency at time T0 is equal to FNORM0, and the ambiguity between increasing or decreasing frequency is solved by PM1. N : number of points. FNORMIN : smallest normalized frequency (default: 0.05) FNORMAX : highest normalized frequency (default: 0.45) PERIOD : period of the sinusoidal fm (default: N ) T0 : time reference for the phase (default: N/2 ) FNORM0 : normalized frequency at time T0 (default: 0.25) PM1 : frequency direction at T0 (-1 or +1) (default: +1 ) Returns: Y : signal IFLAW : its instantaneous frequency law Example: z,i=fmsin(140,0.05,0.45,100,20,0.3,-1.0) Original MATLAB code F. Auger, July 1995. (note: Licensed under GPL; see main LICENSE file) """ if period==None: period = N if t0==None: t0 = N/2 pm1 = nx.sign(pm1) fnormid=0.5*(fnormax+fnormin); delta =0.5*(fnormax-fnormin); phi =-pm1*nx.arccos((fnorm0-fnormid)/delta); time =nx.arange(1,N)-t0; phase =2*nx.pi*fnormid*time+delta*period*(nx.sin(2*nx.pi*time/period+phi)-nx.sin(phi)); y =nx.exp(1j*phase) iflaw =fnormid+delta*nx.cos(2*nx.pi*time/period+phi); return y,iflaw
python
def fmsin(N, fnormin=0.05, fnormax=0.45, period=None, t0=None, fnorm0=0.25, pm1=1): """ Signal with sinusoidal frequency modulation. generates a frequency modulation with a sinusoidal frequency. This sinusoidal modulation is designed such that the instantaneous frequency at time T0 is equal to FNORM0, and the ambiguity between increasing or decreasing frequency is solved by PM1. N : number of points. FNORMIN : smallest normalized frequency (default: 0.05) FNORMAX : highest normalized frequency (default: 0.45) PERIOD : period of the sinusoidal fm (default: N ) T0 : time reference for the phase (default: N/2 ) FNORM0 : normalized frequency at time T0 (default: 0.25) PM1 : frequency direction at T0 (-1 or +1) (default: +1 ) Returns: Y : signal IFLAW : its instantaneous frequency law Example: z,i=fmsin(140,0.05,0.45,100,20,0.3,-1.0) Original MATLAB code F. Auger, July 1995. (note: Licensed under GPL; see main LICENSE file) """ if period==None: period = N if t0==None: t0 = N/2 pm1 = nx.sign(pm1) fnormid=0.5*(fnormax+fnormin); delta =0.5*(fnormax-fnormin); phi =-pm1*nx.arccos((fnorm0-fnormid)/delta); time =nx.arange(1,N)-t0; phase =2*nx.pi*fnormid*time+delta*period*(nx.sin(2*nx.pi*time/period+phi)-nx.sin(phi)); y =nx.exp(1j*phase) iflaw =fnormid+delta*nx.cos(2*nx.pi*time/period+phi); return y,iflaw
[ "def", "fmsin", "(", "N", ",", "fnormin", "=", "0.05", ",", "fnormax", "=", "0.45", ",", "period", "=", "None", ",", "t0", "=", "None", ",", "fnorm0", "=", "0.25", ",", "pm1", "=", "1", ")", ":", "if", "period", "==", "None", ":", "period", "=", "N", "if", "t0", "==", "None", ":", "t0", "=", "N", "/", "2", "pm1", "=", "nx", ".", "sign", "(", "pm1", ")", "fnormid", "=", "0.5", "*", "(", "fnormax", "+", "fnormin", ")", "delta", "=", "0.5", "*", "(", "fnormax", "-", "fnormin", ")", "phi", "=", "-", "pm1", "*", "nx", ".", "arccos", "(", "(", "fnorm0", "-", "fnormid", ")", "/", "delta", ")", "time", "=", "nx", ".", "arange", "(", "1", ",", "N", ")", "-", "t0", "phase", "=", "2", "*", "nx", ".", "pi", "*", "fnormid", "*", "time", "+", "delta", "*", "period", "*", "(", "nx", ".", "sin", "(", "2", "*", "nx", ".", "pi", "*", "time", "/", "period", "+", "phi", ")", "-", "nx", ".", "sin", "(", "phi", ")", ")", "y", "=", "nx", ".", "exp", "(", "1j", "*", "phase", ")", "iflaw", "=", "fnormid", "+", "delta", "*", "nx", ".", "cos", "(", "2", "*", "nx", ".", "pi", "*", "time", "/", "period", "+", "phi", ")", "return", "y", ",", "iflaw" ]
Signal with sinusoidal frequency modulation. generates a frequency modulation with a sinusoidal frequency. This sinusoidal modulation is designed such that the instantaneous frequency at time T0 is equal to FNORM0, and the ambiguity between increasing or decreasing frequency is solved by PM1. N : number of points. FNORMIN : smallest normalized frequency (default: 0.05) FNORMAX : highest normalized frequency (default: 0.45) PERIOD : period of the sinusoidal fm (default: N ) T0 : time reference for the phase (default: N/2 ) FNORM0 : normalized frequency at time T0 (default: 0.25) PM1 : frequency direction at T0 (-1 or +1) (default: +1 ) Returns: Y : signal IFLAW : its instantaneous frequency law Example: z,i=fmsin(140,0.05,0.45,100,20,0.3,-1.0) Original MATLAB code F. Auger, July 1995. (note: Licensed under GPL; see main LICENSE file)
[ "Signal", "with", "sinusoidal", "frequency", "modulation", "." ]
9f7e7705793d258a0b205f185b20e3bbcda473da
https://github.com/melizalab/libtfr/blob/9f7e7705793d258a0b205f185b20e3bbcda473da/examples/tfr_tm.py#L14-L56
train
801
rwl/pylon
pylon/io/rdf.py
RDFReader._parse_rdf
def _parse_rdf(self, file): """ Returns a case from the given file. """ store = Graph() store.parse(file) print len(store)
python
def _parse_rdf(self, file): """ Returns a case from the given file. """ store = Graph() store.parse(file) print len(store)
[ "def", "_parse_rdf", "(", "self", ",", "file", ")", ":", "store", "=", "Graph", "(", ")", "store", ".", "parse", "(", "file", ")", "print", "len", "(", "store", ")" ]
Returns a case from the given file.
[ "Returns", "a", "case", "from", "the", "given", "file", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/rdf.py#L72-L78
train
802
finklabs/metrics
metrics/plugins.py
load_plugins
def load_plugins(group='metrics.plugin.10'): """Load and installed metrics plugins. """ # on using entrypoints: # http://stackoverflow.com/questions/774824/explain-python-entry-points file_processors = [] build_processors = [] for ep in pkg_resources.iter_entry_points(group, name=None): log.debug('loading \'%s\'', ep) plugin = ep.load() # load the plugin if hasattr(plugin, 'get_file_processors'): file_processors.extend(plugin.get_file_processors()) if hasattr(plugin, 'get_build_processors'): build_processors.extend(plugin.get_build_processors()) return file_processors, build_processors
python
def load_plugins(group='metrics.plugin.10'): """Load and installed metrics plugins. """ # on using entrypoints: # http://stackoverflow.com/questions/774824/explain-python-entry-points file_processors = [] build_processors = [] for ep in pkg_resources.iter_entry_points(group, name=None): log.debug('loading \'%s\'', ep) plugin = ep.load() # load the plugin if hasattr(plugin, 'get_file_processors'): file_processors.extend(plugin.get_file_processors()) if hasattr(plugin, 'get_build_processors'): build_processors.extend(plugin.get_build_processors()) return file_processors, build_processors
[ "def", "load_plugins", "(", "group", "=", "'metrics.plugin.10'", ")", ":", "# on using entrypoints:", "# http://stackoverflow.com/questions/774824/explain-python-entry-points", "file_processors", "=", "[", "]", "build_processors", "=", "[", "]", "for", "ep", "in", "pkg_resources", ".", "iter_entry_points", "(", "group", ",", "name", "=", "None", ")", ":", "log", ".", "debug", "(", "'loading \\'%s\\''", ",", "ep", ")", "plugin", "=", "ep", ".", "load", "(", ")", "# load the plugin", "if", "hasattr", "(", "plugin", ",", "'get_file_processors'", ")", ":", "file_processors", ".", "extend", "(", "plugin", ".", "get_file_processors", "(", ")", ")", "if", "hasattr", "(", "plugin", ",", "'get_build_processors'", ")", ":", "build_processors", ".", "extend", "(", "plugin", ".", "get_build_processors", "(", ")", ")", "return", "file_processors", ",", "build_processors" ]
Load and installed metrics plugins.
[ "Load", "and", "installed", "metrics", "plugins", "." ]
fd9974af498831664b9ae8e8f3834e1ec2e8a699
https://github.com/finklabs/metrics/blob/fd9974af498831664b9ae8e8f3834e1ec2e8a699/metrics/plugins.py#L11-L25
train
803
rwl/pylon
pylon/main.py
read_case
def read_case(input, format=None): """ Returns a case object from the given input file object. The data format may be optionally specified. """ # Map of data file types to readers. format_map = {"matpower": MATPOWERReader, "psse": PSSEReader, "pickle": PickleReader} # Read case data. if format_map.has_key(format): reader_klass = format_map[format] reader = reader_klass() case = reader.read(input) else: # Try each of the readers at random. for reader_klass in format_map.values(): reader = reader_klass() try: case = reader.read(input) if case is not None: break except: pass else: case = None return case
python
def read_case(input, format=None): """ Returns a case object from the given input file object. The data format may be optionally specified. """ # Map of data file types to readers. format_map = {"matpower": MATPOWERReader, "psse": PSSEReader, "pickle": PickleReader} # Read case data. if format_map.has_key(format): reader_klass = format_map[format] reader = reader_klass() case = reader.read(input) else: # Try each of the readers at random. for reader_klass in format_map.values(): reader = reader_klass() try: case = reader.read(input) if case is not None: break except: pass else: case = None return case
[ "def", "read_case", "(", "input", ",", "format", "=", "None", ")", ":", "# Map of data file types to readers.", "format_map", "=", "{", "\"matpower\"", ":", "MATPOWERReader", ",", "\"psse\"", ":", "PSSEReader", ",", "\"pickle\"", ":", "PickleReader", "}", "# Read case data.", "if", "format_map", ".", "has_key", "(", "format", ")", ":", "reader_klass", "=", "format_map", "[", "format", "]", "reader", "=", "reader_klass", "(", ")", "case", "=", "reader", ".", "read", "(", "input", ")", "else", ":", "# Try each of the readers at random.", "for", "reader_klass", "in", "format_map", ".", "values", "(", ")", ":", "reader", "=", "reader_klass", "(", ")", "try", ":", "case", "=", "reader", ".", "read", "(", "input", ")", "if", "case", "is", "not", "None", ":", "break", "except", ":", "pass", "else", ":", "case", "=", "None", "return", "case" ]
Returns a case object from the given input file object. The data format may be optionally specified.
[ "Returns", "a", "case", "object", "from", "the", "given", "input", "file", "object", ".", "The", "data", "format", "may", "be", "optionally", "specified", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/main.py#L48-L74
train
804
rwl/pylon
pylon/main.py
detect_data_file
def detect_data_file(input, file_name=""): """ Detects the format of a network data file according to the file extension and the header. """ _, ext = os.path.splitext(file_name) if ext == ".m": line = input.readline() # first line if line.startswith("function"): type = "matpower" logger.info("Recognised MATPOWER data file.") elif line.startswith("Bus.con" or line.startswith("%")): type = "psat" logger.info("Recognised PSAT data file.") else: type = "unrecognised" input.seek(0) # reset buffer for parsing elif (ext == ".raw") or (ext == ".psse"): type = "psse" logger.info("Recognised PSS/E data file.") elif (ext == ".pkl") or (ext == ".pickle"): type = "pickle" logger.info("Recognised pickled case.") else: type = None return type
python
def detect_data_file(input, file_name=""): """ Detects the format of a network data file according to the file extension and the header. """ _, ext = os.path.splitext(file_name) if ext == ".m": line = input.readline() # first line if line.startswith("function"): type = "matpower" logger.info("Recognised MATPOWER data file.") elif line.startswith("Bus.con" or line.startswith("%")): type = "psat" logger.info("Recognised PSAT data file.") else: type = "unrecognised" input.seek(0) # reset buffer for parsing elif (ext == ".raw") or (ext == ".psse"): type = "psse" logger.info("Recognised PSS/E data file.") elif (ext == ".pkl") or (ext == ".pickle"): type = "pickle" logger.info("Recognised pickled case.") else: type = None return type
[ "def", "detect_data_file", "(", "input", ",", "file_name", "=", "\"\"", ")", ":", "_", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "file_name", ")", "if", "ext", "==", "\".m\"", ":", "line", "=", "input", ".", "readline", "(", ")", "# first line", "if", "line", ".", "startswith", "(", "\"function\"", ")", ":", "type", "=", "\"matpower\"", "logger", ".", "info", "(", "\"Recognised MATPOWER data file.\"", ")", "elif", "line", ".", "startswith", "(", "\"Bus.con\"", "or", "line", ".", "startswith", "(", "\"%\"", ")", ")", ":", "type", "=", "\"psat\"", "logger", ".", "info", "(", "\"Recognised PSAT data file.\"", ")", "else", ":", "type", "=", "\"unrecognised\"", "input", ".", "seek", "(", "0", ")", "# reset buffer for parsing", "elif", "(", "ext", "==", "\".raw\"", ")", "or", "(", "ext", "==", "\".psse\"", ")", ":", "type", "=", "\"psse\"", "logger", ".", "info", "(", "\"Recognised PSS/E data file.\"", ")", "elif", "(", "ext", "==", "\".pkl\"", ")", "or", "(", "ext", "==", "\".pickle\"", ")", ":", "type", "=", "\"pickle\"", "logger", ".", "info", "(", "\"Recognised pickled case.\"", ")", "else", ":", "type", "=", "None", "return", "type" ]
Detects the format of a network data file according to the file extension and the header.
[ "Detects", "the", "format", "of", "a", "network", "data", "file", "according", "to", "the", "file", "extension", "and", "the", "header", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/main.py#L80-L109
train
805
rwl/pylon
pylon/io/dot.py
DotWriter.write
def write(self, file_or_filename, prog=None, format='xdot'): """ Writes the case data in Graphviz DOT language. The format 'raw' is used to dump the Dot representation of the Case object, without further processing. The output can be processed by any of graphviz tools, defined in 'prog'. """ if prog is None: file = super(DotWriter, self).write(file_or_filename) else: buf = StringIO.StringIO() super(DotWriter, self).write(buf) buf.seek(0) data = self.create(buf.getvalue(), prog, format) if isinstance(file_or_filename, basestring): file = None try: file = open(file_or_filename, "wb") except: logger.error("Error opening %s." % file_or_filename) finally: if file is not None: file.write(data) file.close() else: file = file_or_filename file.write(data) return file
python
def write(self, file_or_filename, prog=None, format='xdot'): """ Writes the case data in Graphviz DOT language. The format 'raw' is used to dump the Dot representation of the Case object, without further processing. The output can be processed by any of graphviz tools, defined in 'prog'. """ if prog is None: file = super(DotWriter, self).write(file_or_filename) else: buf = StringIO.StringIO() super(DotWriter, self).write(buf) buf.seek(0) data = self.create(buf.getvalue(), prog, format) if isinstance(file_or_filename, basestring): file = None try: file = open(file_or_filename, "wb") except: logger.error("Error opening %s." % file_or_filename) finally: if file is not None: file.write(data) file.close() else: file = file_or_filename file.write(data) return file
[ "def", "write", "(", "self", ",", "file_or_filename", ",", "prog", "=", "None", ",", "format", "=", "'xdot'", ")", ":", "if", "prog", "is", "None", ":", "file", "=", "super", "(", "DotWriter", ",", "self", ")", ".", "write", "(", "file_or_filename", ")", "else", ":", "buf", "=", "StringIO", ".", "StringIO", "(", ")", "super", "(", "DotWriter", ",", "self", ")", ".", "write", "(", "buf", ")", "buf", ".", "seek", "(", "0", ")", "data", "=", "self", ".", "create", "(", "buf", ".", "getvalue", "(", ")", ",", "prog", ",", "format", ")", "if", "isinstance", "(", "file_or_filename", ",", "basestring", ")", ":", "file", "=", "None", "try", ":", "file", "=", "open", "(", "file_or_filename", ",", "\"wb\"", ")", "except", ":", "logger", ".", "error", "(", "\"Error opening %s.\"", "%", "file_or_filename", ")", "finally", ":", "if", "file", "is", "not", "None", ":", "file", ".", "write", "(", "data", ")", "file", ".", "close", "(", ")", "else", ":", "file", "=", "file_or_filename", "file", ".", "write", "(", "data", ")", "return", "file" ]
Writes the case data in Graphviz DOT language. The format 'raw' is used to dump the Dot representation of the Case object, without further processing. The output can be processed by any of graphviz tools, defined in 'prog'.
[ "Writes", "the", "case", "data", "in", "Graphviz", "DOT", "language", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/dot.py#L71-L100
train
806
rwl/pylon
pylon/io/dot.py
DotWriter.write_bus_data
def write_bus_data(self, file, padding=" "): """ Writes bus data to file. """ for bus in self.case.buses: attrs = ['%s="%s"' % (k, v) for k, v in self.bus_attr.iteritems()] # attrs.insert(0, 'label="%s"' % bus.name) attr_str = ", ".join(attrs) file.write("%s%s [%s];\n" % (padding, bus.name, attr_str))
python
def write_bus_data(self, file, padding=" "): """ Writes bus data to file. """ for bus in self.case.buses: attrs = ['%s="%s"' % (k, v) for k, v in self.bus_attr.iteritems()] # attrs.insert(0, 'label="%s"' % bus.name) attr_str = ", ".join(attrs) file.write("%s%s [%s];\n" % (padding, bus.name, attr_str))
[ "def", "write_bus_data", "(", "self", ",", "file", ",", "padding", "=", "\" \"", ")", ":", "for", "bus", "in", "self", ".", "case", ".", "buses", ":", "attrs", "=", "[", "'%s=\"%s\"'", "%", "(", "k", ",", "v", ")", "for", "k", ",", "v", "in", "self", ".", "bus_attr", ".", "iteritems", "(", ")", "]", "# attrs.insert(0, 'label=\"%s\"' % bus.name)", "attr_str", "=", "\", \"", ".", "join", "(", "attrs", ")", "file", ".", "write", "(", "\"%s%s [%s];\\n\"", "%", "(", "padding", ",", "bus", ".", "name", ",", "attr_str", ")", ")" ]
Writes bus data to file.
[ "Writes", "bus", "data", "to", "file", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/dot.py#L114-L122
train
807
rwl/pylon
pylon/io/dot.py
DotWriter.write_branch_data
def write_branch_data(self, file, padding=" "): """ Writes branch data in Graphviz DOT language. """ attrs = ['%s="%s"' % (k,v) for k,v in self.branch_attr.iteritems()] attr_str = ", ".join(attrs) for br in self.case.branches: file.write("%s%s -> %s [%s];\n" % \ (padding, br.from_bus.name, br.to_bus.name, attr_str))
python
def write_branch_data(self, file, padding=" "): """ Writes branch data in Graphviz DOT language. """ attrs = ['%s="%s"' % (k,v) for k,v in self.branch_attr.iteritems()] attr_str = ", ".join(attrs) for br in self.case.branches: file.write("%s%s -> %s [%s];\n" % \ (padding, br.from_bus.name, br.to_bus.name, attr_str))
[ "def", "write_branch_data", "(", "self", ",", "file", ",", "padding", "=", "\" \"", ")", ":", "attrs", "=", "[", "'%s=\"%s\"'", "%", "(", "k", ",", "v", ")", "for", "k", ",", "v", "in", "self", ".", "branch_attr", ".", "iteritems", "(", ")", "]", "attr_str", "=", "\", \"", ".", "join", "(", "attrs", ")", "for", "br", "in", "self", ".", "case", ".", "branches", ":", "file", ".", "write", "(", "\"%s%s -> %s [%s];\\n\"", "%", "(", "padding", ",", "br", ".", "from_bus", ".", "name", ",", "br", ".", "to_bus", ".", "name", ",", "attr_str", ")", ")" ]
Writes branch data in Graphviz DOT language.
[ "Writes", "branch", "data", "in", "Graphviz", "DOT", "language", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/dot.py#L125-L133
train
808
rwl/pylon
pylon/io/dot.py
DotWriter.write_generator_data
def write_generator_data(self, file, padding=" "): """ Write generator data in Graphviz DOT language. """ attrs = ['%s="%s"' % (k, v) for k, v in self.gen_attr.iteritems()] attr_str = ", ".join(attrs) edge_attrs = ['%s="%s"' % (k,v) for k,v in {}.iteritems()] edge_attr_str = ", ".join(edge_attrs) for g in self.case.generators: # Generator node. file.write("%s%s [%s];\n" % (padding, g.name, attr_str)) # Edge connecting generator and bus. file.write("%s%s -> %s [%s];\n" % \ (padding, g.name, g.bus.name, edge_attr_str))
python
def write_generator_data(self, file, padding=" "): """ Write generator data in Graphviz DOT language. """ attrs = ['%s="%s"' % (k, v) for k, v in self.gen_attr.iteritems()] attr_str = ", ".join(attrs) edge_attrs = ['%s="%s"' % (k,v) for k,v in {}.iteritems()] edge_attr_str = ", ".join(edge_attrs) for g in self.case.generators: # Generator node. file.write("%s%s [%s];\n" % (padding, g.name, attr_str)) # Edge connecting generator and bus. file.write("%s%s -> %s [%s];\n" % \ (padding, g.name, g.bus.name, edge_attr_str))
[ "def", "write_generator_data", "(", "self", ",", "file", ",", "padding", "=", "\" \"", ")", ":", "attrs", "=", "[", "'%s=\"%s\"'", "%", "(", "k", ",", "v", ")", "for", "k", ",", "v", "in", "self", ".", "gen_attr", ".", "iteritems", "(", ")", "]", "attr_str", "=", "\", \"", ".", "join", "(", "attrs", ")", "edge_attrs", "=", "[", "'%s=\"%s\"'", "%", "(", "k", ",", "v", ")", "for", "k", ",", "v", "in", "{", "}", ".", "iteritems", "(", ")", "]", "edge_attr_str", "=", "\", \"", ".", "join", "(", "edge_attrs", ")", "for", "g", "in", "self", ".", "case", ".", "generators", ":", "# Generator node.", "file", ".", "write", "(", "\"%s%s [%s];\\n\"", "%", "(", "padding", ",", "g", ".", "name", ",", "attr_str", ")", ")", "# Edge connecting generator and bus.", "file", ".", "write", "(", "\"%s%s -> %s [%s];\\n\"", "%", "(", "padding", ",", "g", ".", "name", ",", "g", ".", "bus", ".", "name", ",", "edge_attr_str", ")", ")" ]
Write generator data in Graphviz DOT language.
[ "Write", "generator", "data", "in", "Graphviz", "DOT", "language", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/dot.py#L136-L151
train
809
rwl/pylon
pylon/io/dot.py
DotWriter.create
def create(self, dotdata, prog="dot", format="xdot"): """ Creates and returns a representation of the graph using the Graphviz layout program given by 'prog', according to the given format. Writes the graph to a temporary dot file and processes it with the program given by 'prog' (which defaults to 'dot'), reading the output and returning it as a string if the operation is successful. On failure None is returned. Based on PyDot by Ero Carrera. """ import os, tempfile from dot2tex.dotparsing import find_graphviz # Map Graphviz executable names to their paths. progs = find_graphviz() if progs is None: logger.warning("GraphViz executables not found.") return None if not progs.has_key(prog): logger.warning('Invalid program [%s]. Available programs are: %s' % \ (prog, progs.keys())) return None # Make a temporary file ... tmp_fd, tmp_name = tempfile.mkstemp() os.close(tmp_fd) # ... and save the graph to it. dot_fd = file(tmp_name, "w+b") dot_fd.write(dotdata) # DOT language. dot_fd.close() # Get the temporary file directory name. tmp_dir = os.path.dirname(tmp_name) # Process the file using the layout program, specifying the format. p = subprocess.Popen((progs[prog], '-T'+format, tmp_name), cwd=tmp_dir, stderr=subprocess.PIPE, stdout=subprocess.PIPE) stderr = p.stderr stdout = p.stdout # Make sense of the standard output form the process. stdout_output = list() while True: data = stdout.read() if not data: break stdout_output.append(data) stdout.close() if stdout_output: stdout_output = ''.join(stdout_output) # Similarly so for any standard error. if not stderr.closed: stderr_output = list() while True: data = stderr.read() if not data: break stderr_output.append(data) stderr.close() if stderr_output: stderr_output = ''.join(stderr_output) status = p.wait() if status != 0 : logger.error("Program [%s] terminated with status: %d. stderr " \ "follows: %s" % ( prog, status, stderr_output ) ) elif stderr_output: logger.error( "%s", stderr_output ) # Remove the temporary file. os.unlink(tmp_name) return stdout_output
python
def create(self, dotdata, prog="dot", format="xdot"): """ Creates and returns a representation of the graph using the Graphviz layout program given by 'prog', according to the given format. Writes the graph to a temporary dot file and processes it with the program given by 'prog' (which defaults to 'dot'), reading the output and returning it as a string if the operation is successful. On failure None is returned. Based on PyDot by Ero Carrera. """ import os, tempfile from dot2tex.dotparsing import find_graphviz # Map Graphviz executable names to their paths. progs = find_graphviz() if progs is None: logger.warning("GraphViz executables not found.") return None if not progs.has_key(prog): logger.warning('Invalid program [%s]. Available programs are: %s' % \ (prog, progs.keys())) return None # Make a temporary file ... tmp_fd, tmp_name = tempfile.mkstemp() os.close(tmp_fd) # ... and save the graph to it. dot_fd = file(tmp_name, "w+b") dot_fd.write(dotdata) # DOT language. dot_fd.close() # Get the temporary file directory name. tmp_dir = os.path.dirname(tmp_name) # Process the file using the layout program, specifying the format. p = subprocess.Popen((progs[prog], '-T'+format, tmp_name), cwd=tmp_dir, stderr=subprocess.PIPE, stdout=subprocess.PIPE) stderr = p.stderr stdout = p.stdout # Make sense of the standard output form the process. stdout_output = list() while True: data = stdout.read() if not data: break stdout_output.append(data) stdout.close() if stdout_output: stdout_output = ''.join(stdout_output) # Similarly so for any standard error. if not stderr.closed: stderr_output = list() while True: data = stderr.read() if not data: break stderr_output.append(data) stderr.close() if stderr_output: stderr_output = ''.join(stderr_output) status = p.wait() if status != 0 : logger.error("Program [%s] terminated with status: %d. stderr " \ "follows: %s" % ( prog, status, stderr_output ) ) elif stderr_output: logger.error( "%s", stderr_output ) # Remove the temporary file. os.unlink(tmp_name) return stdout_output
[ "def", "create", "(", "self", ",", "dotdata", ",", "prog", "=", "\"dot\"", ",", "format", "=", "\"xdot\"", ")", ":", "import", "os", ",", "tempfile", "from", "dot2tex", ".", "dotparsing", "import", "find_graphviz", "# Map Graphviz executable names to their paths.", "progs", "=", "find_graphviz", "(", ")", "if", "progs", "is", "None", ":", "logger", ".", "warning", "(", "\"GraphViz executables not found.\"", ")", "return", "None", "if", "not", "progs", ".", "has_key", "(", "prog", ")", ":", "logger", ".", "warning", "(", "'Invalid program [%s]. Available programs are: %s'", "%", "(", "prog", ",", "progs", ".", "keys", "(", ")", ")", ")", "return", "None", "# Make a temporary file ...", "tmp_fd", ",", "tmp_name", "=", "tempfile", ".", "mkstemp", "(", ")", "os", ".", "close", "(", "tmp_fd", ")", "# ... and save the graph to it.", "dot_fd", "=", "file", "(", "tmp_name", ",", "\"w+b\"", ")", "dot_fd", ".", "write", "(", "dotdata", ")", "# DOT language.", "dot_fd", ".", "close", "(", ")", "# Get the temporary file directory name.", "tmp_dir", "=", "os", ".", "path", ".", "dirname", "(", "tmp_name", ")", "# Process the file using the layout program, specifying the format.", "p", "=", "subprocess", ".", "Popen", "(", "(", "progs", "[", "prog", "]", ",", "'-T'", "+", "format", ",", "tmp_name", ")", ",", "cwd", "=", "tmp_dir", ",", "stderr", "=", "subprocess", ".", "PIPE", ",", "stdout", "=", "subprocess", ".", "PIPE", ")", "stderr", "=", "p", ".", "stderr", "stdout", "=", "p", ".", "stdout", "# Make sense of the standard output form the process.", "stdout_output", "=", "list", "(", ")", "while", "True", ":", "data", "=", "stdout", ".", "read", "(", ")", "if", "not", "data", ":", "break", "stdout_output", ".", "append", "(", "data", ")", "stdout", ".", "close", "(", ")", "if", "stdout_output", ":", "stdout_output", "=", "''", ".", "join", "(", "stdout_output", ")", "# Similarly so for any standard error.", "if", "not", "stderr", ".", "closed", ":", "stderr_output", "=", "list", "(", ")", "while", "True", ":", "data", "=", "stderr", ".", "read", "(", ")", "if", "not", "data", ":", "break", "stderr_output", ".", "append", "(", "data", ")", "stderr", ".", "close", "(", ")", "if", "stderr_output", ":", "stderr_output", "=", "''", ".", "join", "(", "stderr_output", ")", "status", "=", "p", ".", "wait", "(", ")", "if", "status", "!=", "0", ":", "logger", ".", "error", "(", "\"Program [%s] terminated with status: %d. stderr \"", "\"follows: %s\"", "%", "(", "prog", ",", "status", ",", "stderr_output", ")", ")", "elif", "stderr_output", ":", "logger", ".", "error", "(", "\"%s\"", ",", "stderr_output", ")", "# Remove the temporary file.", "os", ".", "unlink", "(", "tmp_name", ")", "return", "stdout_output" ]
Creates and returns a representation of the graph using the Graphviz layout program given by 'prog', according to the given format. Writes the graph to a temporary dot file and processes it with the program given by 'prog' (which defaults to 'dot'), reading the output and returning it as a string if the operation is successful. On failure None is returned. Based on PyDot by Ero Carrera.
[ "Creates", "and", "returns", "a", "representation", "of", "the", "graph", "using", "the", "Graphviz", "layout", "program", "given", "by", "prog", "according", "to", "the", "given", "format", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/dot.py#L157-L235
train
810
finklabs/metrics
metrics/outputformat_xml.py
format
def format(file_metrics, build_metrics): """compute output in XML format.""" def indent(elem, level=0): i = "\n" + level*" " if len(elem): if not elem.text or not elem.text.strip(): elem.text = i + " " if not elem.tail or not elem.tail.strip(): elem.tail = i for elem in elem: indent(elem, level+1) if not elem.tail or not elem.tail.strip(): elem.tail = i else: if level and (not elem.tail or not elem.tail.strip()): elem.tail = i root = ET.Element('metrics') # file_metrics files = ET.Element('files') root.append(files) for key in file_metrics.keys(): tmp_file = ET.SubElement(files, "file", {'name': key, 'language': file_metrics[key]['language']}) for name in file_metrics[key].keys(): if name == 'language': continue tmp_metric = ET.SubElement(tmp_file, "metric", {'name': name, 'value': str(file_metrics[key][name])}) # build_metrics if build_metrics: build = ET.Element('build') root.append(build) # TODO indent(root) if PY3: body = ET.tostring(root, encoding='unicode') else: body = ET.tostring(root) return body
python
def format(file_metrics, build_metrics): """compute output in XML format.""" def indent(elem, level=0): i = "\n" + level*" " if len(elem): if not elem.text or not elem.text.strip(): elem.text = i + " " if not elem.tail or not elem.tail.strip(): elem.tail = i for elem in elem: indent(elem, level+1) if not elem.tail or not elem.tail.strip(): elem.tail = i else: if level and (not elem.tail or not elem.tail.strip()): elem.tail = i root = ET.Element('metrics') # file_metrics files = ET.Element('files') root.append(files) for key in file_metrics.keys(): tmp_file = ET.SubElement(files, "file", {'name': key, 'language': file_metrics[key]['language']}) for name in file_metrics[key].keys(): if name == 'language': continue tmp_metric = ET.SubElement(tmp_file, "metric", {'name': name, 'value': str(file_metrics[key][name])}) # build_metrics if build_metrics: build = ET.Element('build') root.append(build) # TODO indent(root) if PY3: body = ET.tostring(root, encoding='unicode') else: body = ET.tostring(root) return body
[ "def", "format", "(", "file_metrics", ",", "build_metrics", ")", ":", "def", "indent", "(", "elem", ",", "level", "=", "0", ")", ":", "i", "=", "\"\\n\"", "+", "level", "*", "\" \"", "if", "len", "(", "elem", ")", ":", "if", "not", "elem", ".", "text", "or", "not", "elem", ".", "text", ".", "strip", "(", ")", ":", "elem", ".", "text", "=", "i", "+", "\" \"", "if", "not", "elem", ".", "tail", "or", "not", "elem", ".", "tail", ".", "strip", "(", ")", ":", "elem", ".", "tail", "=", "i", "for", "elem", "in", "elem", ":", "indent", "(", "elem", ",", "level", "+", "1", ")", "if", "not", "elem", ".", "tail", "or", "not", "elem", ".", "tail", ".", "strip", "(", ")", ":", "elem", ".", "tail", "=", "i", "else", ":", "if", "level", "and", "(", "not", "elem", ".", "tail", "or", "not", "elem", ".", "tail", ".", "strip", "(", ")", ")", ":", "elem", ".", "tail", "=", "i", "root", "=", "ET", ".", "Element", "(", "'metrics'", ")", "# file_metrics", "files", "=", "ET", ".", "Element", "(", "'files'", ")", "root", ".", "append", "(", "files", ")", "for", "key", "in", "file_metrics", ".", "keys", "(", ")", ":", "tmp_file", "=", "ET", ".", "SubElement", "(", "files", ",", "\"file\"", ",", "{", "'name'", ":", "key", ",", "'language'", ":", "file_metrics", "[", "key", "]", "[", "'language'", "]", "}", ")", "for", "name", "in", "file_metrics", "[", "key", "]", ".", "keys", "(", ")", ":", "if", "name", "==", "'language'", ":", "continue", "tmp_metric", "=", "ET", ".", "SubElement", "(", "tmp_file", ",", "\"metric\"", ",", "{", "'name'", ":", "name", ",", "'value'", ":", "str", "(", "file_metrics", "[", "key", "]", "[", "name", "]", ")", "}", ")", "# build_metrics", "if", "build_metrics", ":", "build", "=", "ET", ".", "Element", "(", "'build'", ")", "root", ".", "append", "(", "build", ")", "# TODO", "indent", "(", "root", ")", "if", "PY3", ":", "body", "=", "ET", ".", "tostring", "(", "root", ",", "encoding", "=", "'unicode'", ")", "else", ":", "body", "=", "ET", ".", "tostring", "(", "root", ")", "return", "body" ]
compute output in XML format.
[ "compute", "output", "in", "XML", "format", "." ]
fd9974af498831664b9ae8e8f3834e1ec2e8a699
https://github.com/finklabs/metrics/blob/fd9974af498831664b9ae8e8f3834e1ec2e8a699/metrics/outputformat_xml.py#L16-L59
train
811
brunobord/tdaemon
tdaemon.py
ask
def ask(message='Are you sure? [y/N]'): """Asks the user his opinion.""" agree = False answer = raw_input(message).lower() if answer.startswith('y'): agree = True return agree
python
def ask(message='Are you sure? [y/N]'): """Asks the user his opinion.""" agree = False answer = raw_input(message).lower() if answer.startswith('y'): agree = True return agree
[ "def", "ask", "(", "message", "=", "'Are you sure? [y/N]'", ")", ":", "agree", "=", "False", "answer", "=", "raw_input", "(", "message", ")", ".", "lower", "(", ")", "if", "answer", ".", "startswith", "(", "'y'", ")", ":", "agree", "=", "True", "return", "agree" ]
Asks the user his opinion.
[ "Asks", "the", "user", "his", "opinion", "." ]
733b5bddb4b12bc3db326a192ce5606f28768307
https://github.com/brunobord/tdaemon/blob/733b5bddb4b12bc3db326a192ce5606f28768307/tdaemon.py#L45-L51
train
812
brunobord/tdaemon
tdaemon.py
main
def main(prog_args=None): """ What do you expect? """ if prog_args is None: prog_args = sys.argv parser = optparse.OptionParser() parser.usage = """Usage: %[prog] [options] [<path>]""" parser.add_option("-t", "--test-program", dest="test_program", default="nose", help="specifies the test-program to use. Valid values" " include `nose` (or `nosetests`), `django`, `py` (for `py.test`), " '`symfony`, `jelix` `phpunit` and `tox`') parser.add_option("-d", "--debug", dest="debug", action="store_true", default=False) parser.add_option('-s', '--size-max', dest='size_max', default=25, type="int", help="Sets the maximum size (in MB) of files.") parser.add_option('--custom-args', dest='custom_args', default='', type="str", help="Defines custom arguments to pass after the test program command") parser.add_option('--ignore-dirs', dest='ignore_dirs', default='', type="str", help="Defines directories to ignore. Use a comma-separated list.") parser.add_option('-y', '--quiet', dest='quiet', action="store_true", default=False, help="Don't ask for any input.") opt, args = parser.parse_args(prog_args) if args[1:]: path = args[1] else: path = '.' try: watcher = Watcher(path, opt.test_program, opt.debug, opt.custom_args, opt.ignore_dirs, opt.quiet) watcher_file_size = watcher.file_sizes() if watcher_file_size > opt.size_max: message = "It looks like the total file size (%dMb) is larger than the `max size` option (%dMb).\nThis may slow down the file comparison process, and thus the daemon performances.\nDo you wish to continue? [y/N] " % (watcher_file_size, opt.size_max) if not opt.quiet and not ask(message): raise CancelDueToUserRequest('Ok, thx, bye...') print "Ready to watch file changes..." watcher.loop() except (KeyboardInterrupt, SystemExit): # Ignore when you exit via Crtl-C pass except Exception, msg: print msg print "Bye"
python
def main(prog_args=None): """ What do you expect? """ if prog_args is None: prog_args = sys.argv parser = optparse.OptionParser() parser.usage = """Usage: %[prog] [options] [<path>]""" parser.add_option("-t", "--test-program", dest="test_program", default="nose", help="specifies the test-program to use. Valid values" " include `nose` (or `nosetests`), `django`, `py` (for `py.test`), " '`symfony`, `jelix` `phpunit` and `tox`') parser.add_option("-d", "--debug", dest="debug", action="store_true", default=False) parser.add_option('-s', '--size-max', dest='size_max', default=25, type="int", help="Sets the maximum size (in MB) of files.") parser.add_option('--custom-args', dest='custom_args', default='', type="str", help="Defines custom arguments to pass after the test program command") parser.add_option('--ignore-dirs', dest='ignore_dirs', default='', type="str", help="Defines directories to ignore. Use a comma-separated list.") parser.add_option('-y', '--quiet', dest='quiet', action="store_true", default=False, help="Don't ask for any input.") opt, args = parser.parse_args(prog_args) if args[1:]: path = args[1] else: path = '.' try: watcher = Watcher(path, opt.test_program, opt.debug, opt.custom_args, opt.ignore_dirs, opt.quiet) watcher_file_size = watcher.file_sizes() if watcher_file_size > opt.size_max: message = "It looks like the total file size (%dMb) is larger than the `max size` option (%dMb).\nThis may slow down the file comparison process, and thus the daemon performances.\nDo you wish to continue? [y/N] " % (watcher_file_size, opt.size_max) if not opt.quiet and not ask(message): raise CancelDueToUserRequest('Ok, thx, bye...') print "Ready to watch file changes..." watcher.loop() except (KeyboardInterrupt, SystemExit): # Ignore when you exit via Crtl-C pass except Exception, msg: print msg print "Bye"
[ "def", "main", "(", "prog_args", "=", "None", ")", ":", "if", "prog_args", "is", "None", ":", "prog_args", "=", "sys", ".", "argv", "parser", "=", "optparse", ".", "OptionParser", "(", ")", "parser", ".", "usage", "=", "\"\"\"Usage: %[prog] [options] [<path>]\"\"\"", "parser", ".", "add_option", "(", "\"-t\"", ",", "\"--test-program\"", ",", "dest", "=", "\"test_program\"", ",", "default", "=", "\"nose\"", ",", "help", "=", "\"specifies the test-program to use. Valid values\"", "\" include `nose` (or `nosetests`), `django`, `py` (for `py.test`), \"", "'`symfony`, `jelix` `phpunit` and `tox`'", ")", "parser", ".", "add_option", "(", "\"-d\"", ",", "\"--debug\"", ",", "dest", "=", "\"debug\"", ",", "action", "=", "\"store_true\"", ",", "default", "=", "False", ")", "parser", ".", "add_option", "(", "'-s'", ",", "'--size-max'", ",", "dest", "=", "'size_max'", ",", "default", "=", "25", ",", "type", "=", "\"int\"", ",", "help", "=", "\"Sets the maximum size (in MB) of files.\"", ")", "parser", ".", "add_option", "(", "'--custom-args'", ",", "dest", "=", "'custom_args'", ",", "default", "=", "''", ",", "type", "=", "\"str\"", ",", "help", "=", "\"Defines custom arguments to pass after the test program command\"", ")", "parser", ".", "add_option", "(", "'--ignore-dirs'", ",", "dest", "=", "'ignore_dirs'", ",", "default", "=", "''", ",", "type", "=", "\"str\"", ",", "help", "=", "\"Defines directories to ignore. Use a comma-separated list.\"", ")", "parser", ".", "add_option", "(", "'-y'", ",", "'--quiet'", ",", "dest", "=", "'quiet'", ",", "action", "=", "\"store_true\"", ",", "default", "=", "False", ",", "help", "=", "\"Don't ask for any input.\"", ")", "opt", ",", "args", "=", "parser", ".", "parse_args", "(", "prog_args", ")", "if", "args", "[", "1", ":", "]", ":", "path", "=", "args", "[", "1", "]", "else", ":", "path", "=", "'.'", "try", ":", "watcher", "=", "Watcher", "(", "path", ",", "opt", ".", "test_program", ",", "opt", ".", "debug", ",", "opt", ".", "custom_args", ",", "opt", ".", "ignore_dirs", ",", "opt", ".", "quiet", ")", "watcher_file_size", "=", "watcher", ".", "file_sizes", "(", ")", "if", "watcher_file_size", ">", "opt", ".", "size_max", ":", "message", "=", "\"It looks like the total file size (%dMb) is larger than the `max size` option (%dMb).\\nThis may slow down the file comparison process, and thus the daemon performances.\\nDo you wish to continue? [y/N] \"", "%", "(", "watcher_file_size", ",", "opt", ".", "size_max", ")", "if", "not", "opt", ".", "quiet", "and", "not", "ask", "(", "message", ")", ":", "raise", "CancelDueToUserRequest", "(", "'Ok, thx, bye...'", ")", "print", "\"Ready to watch file changes...\"", "watcher", ".", "loop", "(", ")", "except", "(", "KeyboardInterrupt", ",", "SystemExit", ")", ":", "# Ignore when you exit via Crtl-C", "pass", "except", "Exception", ",", "msg", ":", "print", "msg", "print", "\"Bye\"" ]
What do you expect?
[ "What", "do", "you", "expect?" ]
733b5bddb4b12bc3db326a192ce5606f28768307
https://github.com/brunobord/tdaemon/blob/733b5bddb4b12bc3db326a192ce5606f28768307/tdaemon.py#L235-L288
train
813
brunobord/tdaemon
tdaemon.py
Watcher.check_configuration
def check_configuration(self, file_path, test_program, custom_args): """Checks if configuration is ok.""" # checking filepath if not os.path.isdir(file_path): raise InvalidFilePath("INVALID CONFIGURATION: file path %s is not a directory" % os.path.abspath(file_path) ) if not test_program in IMPLEMENTED_TEST_PROGRAMS: raise InvalidTestProgram('The `%s` is unknown, or not yet implemented. Please chose another one.' % test_program) if custom_args: if not self.quiet and not ask("WARNING!!!\nYou are about to run the following command\n\n $ %s\n\nAre you sure you still want to proceed [y/N]? " % self.get_cmd()): raise CancelDueToUserRequest('Test cancelled...')
python
def check_configuration(self, file_path, test_program, custom_args): """Checks if configuration is ok.""" # checking filepath if not os.path.isdir(file_path): raise InvalidFilePath("INVALID CONFIGURATION: file path %s is not a directory" % os.path.abspath(file_path) ) if not test_program in IMPLEMENTED_TEST_PROGRAMS: raise InvalidTestProgram('The `%s` is unknown, or not yet implemented. Please chose another one.' % test_program) if custom_args: if not self.quiet and not ask("WARNING!!!\nYou are about to run the following command\n\n $ %s\n\nAre you sure you still want to proceed [y/N]? " % self.get_cmd()): raise CancelDueToUserRequest('Test cancelled...')
[ "def", "check_configuration", "(", "self", ",", "file_path", ",", "test_program", ",", "custom_args", ")", ":", "# checking filepath", "if", "not", "os", ".", "path", ".", "isdir", "(", "file_path", ")", ":", "raise", "InvalidFilePath", "(", "\"INVALID CONFIGURATION: file path %s is not a directory\"", "%", "os", ".", "path", ".", "abspath", "(", "file_path", ")", ")", "if", "not", "test_program", "in", "IMPLEMENTED_TEST_PROGRAMS", ":", "raise", "InvalidTestProgram", "(", "'The `%s` is unknown, or not yet implemented. Please chose another one.'", "%", "test_program", ")", "if", "custom_args", ":", "if", "not", "self", ".", "quiet", "and", "not", "ask", "(", "\"WARNING!!!\\nYou are about to run the following command\\n\\n $ %s\\n\\nAre you sure you still want to proceed [y/N]? \"", "%", "self", ".", "get_cmd", "(", ")", ")", ":", "raise", "CancelDueToUserRequest", "(", "'Test cancelled...'", ")" ]
Checks if configuration is ok.
[ "Checks", "if", "configuration", "is", "ok", "." ]
733b5bddb4b12bc3db326a192ce5606f28768307
https://github.com/brunobord/tdaemon/blob/733b5bddb4b12bc3db326a192ce5606f28768307/tdaemon.py#L88-L101
train
814
brunobord/tdaemon
tdaemon.py
Watcher.check_dependencies
def check_dependencies(self): "Checks if the test program is available in the python environnement" if self.test_program == 'nose': try: import nose except ImportError: sys.exit('Nosetests is not available on your system. Please install it and try to run it again') if self.test_program == 'py': try: import py except: sys.exit('py.test is not available on your system. Please install it and try to run it again') if self.test_program == 'django': try: import django except: sys.exit('django is not available on your system. Please install it and try to run it again') if self.test_program == 'phpunit': try: process = subprocess.check_call(['phpunit','--version']) except: sys.exit('phpunit is not available on your system. Please install it and try to run it again') if self.test_program == 'tox': try: import tox except ImportError: sys.exit('tox is not available on your system. Please install it and try to run it again')
python
def check_dependencies(self): "Checks if the test program is available in the python environnement" if self.test_program == 'nose': try: import nose except ImportError: sys.exit('Nosetests is not available on your system. Please install it and try to run it again') if self.test_program == 'py': try: import py except: sys.exit('py.test is not available on your system. Please install it and try to run it again') if self.test_program == 'django': try: import django except: sys.exit('django is not available on your system. Please install it and try to run it again') if self.test_program == 'phpunit': try: process = subprocess.check_call(['phpunit','--version']) except: sys.exit('phpunit is not available on your system. Please install it and try to run it again') if self.test_program == 'tox': try: import tox except ImportError: sys.exit('tox is not available on your system. Please install it and try to run it again')
[ "def", "check_dependencies", "(", "self", ")", ":", "if", "self", ".", "test_program", "==", "'nose'", ":", "try", ":", "import", "nose", "except", "ImportError", ":", "sys", ".", "exit", "(", "'Nosetests is not available on your system. Please install it and try to run it again'", ")", "if", "self", ".", "test_program", "==", "'py'", ":", "try", ":", "import", "py", "except", ":", "sys", ".", "exit", "(", "'py.test is not available on your system. Please install it and try to run it again'", ")", "if", "self", ".", "test_program", "==", "'django'", ":", "try", ":", "import", "django", "except", ":", "sys", ".", "exit", "(", "'django is not available on your system. Please install it and try to run it again'", ")", "if", "self", ".", "test_program", "==", "'phpunit'", ":", "try", ":", "process", "=", "subprocess", ".", "check_call", "(", "[", "'phpunit'", ",", "'--version'", "]", ")", "except", ":", "sys", ".", "exit", "(", "'phpunit is not available on your system. Please install it and try to run it again'", ")", "if", "self", ".", "test_program", "==", "'tox'", ":", "try", ":", "import", "tox", "except", "ImportError", ":", "sys", ".", "exit", "(", "'tox is not available on your system. Please install it and try to run it again'", ")" ]
Checks if the test program is available in the python environnement
[ "Checks", "if", "the", "test", "program", "is", "available", "in", "the", "python", "environnement" ]
733b5bddb4b12bc3db326a192ce5606f28768307
https://github.com/brunobord/tdaemon/blob/733b5bddb4b12bc3db326a192ce5606f28768307/tdaemon.py#L103-L129
train
815
brunobord/tdaemon
tdaemon.py
Watcher.get_cmd
def get_cmd(self): """Returns the full command to be executed at runtime""" cmd = None if self.test_program in ('nose', 'nosetests'): cmd = "nosetests %s" % self.file_path elif self.test_program == 'django': executable = "%s/manage.py" % self.file_path if os.path.exists(executable): cmd = "python %s/manage.py test" % self.file_path else: cmd = "django-admin.py test" elif self.test_program == 'py': cmd = 'py.test %s' % self.file_path elif self.test_program == 'symfony': cmd = 'symfony test-all' elif self.test_program == 'jelix': # as seen on http://jelix.org/articles/fr/manuel-1.1/tests_unitaires cmd = 'php tests.php' elif self.test_program == 'phpunit': cmd = 'phpunit' elif self.test_program == 'sphinx': cmd = 'make html' elif self.test_program == 'tox': cmd = 'tox' if not cmd: raise InvalidTestProgram("The test program %s is unknown. Valid options are: `nose`, `django` and `py`" % self.test_program) # adding custom args if self.custom_args: cmd = '%s %s' % (cmd, self.custom_args) return cmd
python
def get_cmd(self): """Returns the full command to be executed at runtime""" cmd = None if self.test_program in ('nose', 'nosetests'): cmd = "nosetests %s" % self.file_path elif self.test_program == 'django': executable = "%s/manage.py" % self.file_path if os.path.exists(executable): cmd = "python %s/manage.py test" % self.file_path else: cmd = "django-admin.py test" elif self.test_program == 'py': cmd = 'py.test %s' % self.file_path elif self.test_program == 'symfony': cmd = 'symfony test-all' elif self.test_program == 'jelix': # as seen on http://jelix.org/articles/fr/manuel-1.1/tests_unitaires cmd = 'php tests.php' elif self.test_program == 'phpunit': cmd = 'phpunit' elif self.test_program == 'sphinx': cmd = 'make html' elif self.test_program == 'tox': cmd = 'tox' if not cmd: raise InvalidTestProgram("The test program %s is unknown. Valid options are: `nose`, `django` and `py`" % self.test_program) # adding custom args if self.custom_args: cmd = '%s %s' % (cmd, self.custom_args) return cmd
[ "def", "get_cmd", "(", "self", ")", ":", "cmd", "=", "None", "if", "self", ".", "test_program", "in", "(", "'nose'", ",", "'nosetests'", ")", ":", "cmd", "=", "\"nosetests %s\"", "%", "self", ".", "file_path", "elif", "self", ".", "test_program", "==", "'django'", ":", "executable", "=", "\"%s/manage.py\"", "%", "self", ".", "file_path", "if", "os", ".", "path", ".", "exists", "(", "executable", ")", ":", "cmd", "=", "\"python %s/manage.py test\"", "%", "self", ".", "file_path", "else", ":", "cmd", "=", "\"django-admin.py test\"", "elif", "self", ".", "test_program", "==", "'py'", ":", "cmd", "=", "'py.test %s'", "%", "self", ".", "file_path", "elif", "self", ".", "test_program", "==", "'symfony'", ":", "cmd", "=", "'symfony test-all'", "elif", "self", ".", "test_program", "==", "'jelix'", ":", "# as seen on http://jelix.org/articles/fr/manuel-1.1/tests_unitaires", "cmd", "=", "'php tests.php'", "elif", "self", ".", "test_program", "==", "'phpunit'", ":", "cmd", "=", "'phpunit'", "elif", "self", ".", "test_program", "==", "'sphinx'", ":", "cmd", "=", "'make html'", "elif", "self", ".", "test_program", "==", "'tox'", ":", "cmd", "=", "'tox'", "if", "not", "cmd", ":", "raise", "InvalidTestProgram", "(", "\"The test program %s is unknown. Valid options are: `nose`, `django` and `py`\"", "%", "self", ".", "test_program", ")", "# adding custom args", "if", "self", ".", "custom_args", ":", "cmd", "=", "'%s %s'", "%", "(", "cmd", ",", "self", ".", "custom_args", ")", "return", "cmd" ]
Returns the full command to be executed at runtime
[ "Returns", "the", "full", "command", "to", "be", "executed", "at", "runtime" ]
733b5bddb4b12bc3db326a192ce5606f28768307
https://github.com/brunobord/tdaemon/blob/733b5bddb4b12bc3db326a192ce5606f28768307/tdaemon.py#L132-L164
train
816
brunobord/tdaemon
tdaemon.py
Watcher.include
def include(self, path): """Returns `True` if the file is not ignored""" for extension in IGNORE_EXTENSIONS: if path.endswith(extension): return False parts = path.split(os.path.sep) for part in parts: if part in self.ignore_dirs: return False return True
python
def include(self, path): """Returns `True` if the file is not ignored""" for extension in IGNORE_EXTENSIONS: if path.endswith(extension): return False parts = path.split(os.path.sep) for part in parts: if part in self.ignore_dirs: return False return True
[ "def", "include", "(", "self", ",", "path", ")", ":", "for", "extension", "in", "IGNORE_EXTENSIONS", ":", "if", "path", ".", "endswith", "(", "extension", ")", ":", "return", "False", "parts", "=", "path", ".", "split", "(", "os", ".", "path", ".", "sep", ")", "for", "part", "in", "parts", ":", "if", "part", "in", "self", ".", "ignore_dirs", ":", "return", "False", "return", "True" ]
Returns `True` if the file is not ignored
[ "Returns", "True", "if", "the", "file", "is", "not", "ignored" ]
733b5bddb4b12bc3db326a192ce5606f28768307
https://github.com/brunobord/tdaemon/blob/733b5bddb4b12bc3db326a192ce5606f28768307/tdaemon.py#L167-L176
train
817
brunobord/tdaemon
tdaemon.py
Watcher.diff_list
def diff_list(self, list1, list2): """Extracts differences between lists. For debug purposes""" for key in list1: if key in list2 and list2[key] != list1[key]: print key elif key not in list2: print key
python
def diff_list(self, list1, list2): """Extracts differences between lists. For debug purposes""" for key in list1: if key in list2 and list2[key] != list1[key]: print key elif key not in list2: print key
[ "def", "diff_list", "(", "self", ",", "list1", ",", "list2", ")", ":", "for", "key", "in", "list1", ":", "if", "key", "in", "list2", "and", "list2", "[", "key", "]", "!=", "list1", "[", "key", "]", ":", "print", "key", "elif", "key", "not", "in", "list2", ":", "print", "key" ]
Extracts differences between lists. For debug purposes
[ "Extracts", "differences", "between", "lists", ".", "For", "debug", "purposes" ]
733b5bddb4b12bc3db326a192ce5606f28768307
https://github.com/brunobord/tdaemon/blob/733b5bddb4b12bc3db326a192ce5606f28768307/tdaemon.py#L205-L211
train
818
brunobord/tdaemon
tdaemon.py
Watcher.run
def run(self, cmd): """Runs the appropriate command""" print datetime.datetime.now() output = subprocess.Popen(cmd, shell=True) output = output.communicate()[0] print output
python
def run(self, cmd): """Runs the appropriate command""" print datetime.datetime.now() output = subprocess.Popen(cmd, shell=True) output = output.communicate()[0] print output
[ "def", "run", "(", "self", ",", "cmd", ")", ":", "print", "datetime", ".", "datetime", ".", "now", "(", ")", "output", "=", "subprocess", ".", "Popen", "(", "cmd", ",", "shell", "=", "True", ")", "output", "=", "output", ".", "communicate", "(", ")", "[", "0", "]", "print", "output" ]
Runs the appropriate command
[ "Runs", "the", "appropriate", "command" ]
733b5bddb4b12bc3db326a192ce5606f28768307
https://github.com/brunobord/tdaemon/blob/733b5bddb4b12bc3db326a192ce5606f28768307/tdaemon.py#L213-L218
train
819
brunobord/tdaemon
tdaemon.py
Watcher.loop
def loop(self): """Main loop daemon.""" while True: sleep(1) new_file_list = self.walk(self.file_path, {}) if new_file_list != self.file_list: if self.debug: self.diff_list(new_file_list, self.file_list) self.run_tests() self.file_list = new_file_list
python
def loop(self): """Main loop daemon.""" while True: sleep(1) new_file_list = self.walk(self.file_path, {}) if new_file_list != self.file_list: if self.debug: self.diff_list(new_file_list, self.file_list) self.run_tests() self.file_list = new_file_list
[ "def", "loop", "(", "self", ")", ":", "while", "True", ":", "sleep", "(", "1", ")", "new_file_list", "=", "self", ".", "walk", "(", "self", ".", "file_path", ",", "{", "}", ")", "if", "new_file_list", "!=", "self", ".", "file_list", ":", "if", "self", ".", "debug", ":", "self", ".", "diff_list", "(", "new_file_list", ",", "self", ".", "file_list", ")", "self", ".", "run_tests", "(", ")", "self", ".", "file_list", "=", "new_file_list" ]
Main loop daemon.
[ "Main", "loop", "daemon", "." ]
733b5bddb4b12bc3db326a192ce5606f28768307
https://github.com/brunobord/tdaemon/blob/733b5bddb4b12bc3db326a192ce5606f28768307/tdaemon.py#L224-L233
train
820
finklabs/metrics
metrics/outputformat_json.py
format
def format(file_metrics, build_metrics): """compute output in JSON format.""" metrics = {'files': file_metrics} if build_metrics: metrics['build'] = build_metrics body = json.dumps(metrics, sort_keys=True, indent=4) + '\n' return body
python
def format(file_metrics, build_metrics): """compute output in JSON format.""" metrics = {'files': file_metrics} if build_metrics: metrics['build'] = build_metrics body = json.dumps(metrics, sort_keys=True, indent=4) + '\n' return body
[ "def", "format", "(", "file_metrics", ",", "build_metrics", ")", ":", "metrics", "=", "{", "'files'", ":", "file_metrics", "}", "if", "build_metrics", ":", "metrics", "[", "'build'", "]", "=", "build_metrics", "body", "=", "json", ".", "dumps", "(", "metrics", ",", "sort_keys", "=", "True", ",", "indent", "=", "4", ")", "+", "'\\n'", "return", "body" ]
compute output in JSON format.
[ "compute", "output", "in", "JSON", "format", "." ]
fd9974af498831664b9ae8e8f3834e1ec2e8a699
https://github.com/finklabs/metrics/blob/fd9974af498831664b9ae8e8f3834e1ec2e8a699/metrics/outputformat_json.py#L9-L15
train
821
rwl/pylon
contrib/cvxopf.py
split_linear_constraints
def split_linear_constraints(A, l, u): """ Returns the linear equality and inequality constraints. """ ieq = [] igt = [] ilt = [] ibx = [] for i in range(len(l)): if abs(u[i] - l[i]) <= EPS: ieq.append(i) elif (u[i] > 1e10) and (l[i] > -1e10): igt.append(i) elif (l[i] <= -1e10) and (u[i] < 1e10): ilt.append(i) elif (abs(u[i] - l[i]) > EPS) and (u[i] < 1e10) and (l[i] > -1e10): ibx.append(i) else: raise ValueError Ae = A[ieq, :] Ai = sparse([A[ilt, :], -A[igt, :], A[ibx, :], -A[ibx, :]]) be = u[ieq, :] bi = matrix([u[ilt], -l[igt], u[ibx], -l[ibx]]) return Ae, be, Ai, bi
python
def split_linear_constraints(A, l, u): """ Returns the linear equality and inequality constraints. """ ieq = [] igt = [] ilt = [] ibx = [] for i in range(len(l)): if abs(u[i] - l[i]) <= EPS: ieq.append(i) elif (u[i] > 1e10) and (l[i] > -1e10): igt.append(i) elif (l[i] <= -1e10) and (u[i] < 1e10): ilt.append(i) elif (abs(u[i] - l[i]) > EPS) and (u[i] < 1e10) and (l[i] > -1e10): ibx.append(i) else: raise ValueError Ae = A[ieq, :] Ai = sparse([A[ilt, :], -A[igt, :], A[ibx, :], -A[ibx, :]]) be = u[ieq, :] bi = matrix([u[ilt], -l[igt], u[ibx], -l[ibx]]) return Ae, be, Ai, bi
[ "def", "split_linear_constraints", "(", "A", ",", "l", ",", "u", ")", ":", "ieq", "=", "[", "]", "igt", "=", "[", "]", "ilt", "=", "[", "]", "ibx", "=", "[", "]", "for", "i", "in", "range", "(", "len", "(", "l", ")", ")", ":", "if", "abs", "(", "u", "[", "i", "]", "-", "l", "[", "i", "]", ")", "<=", "EPS", ":", "ieq", ".", "append", "(", "i", ")", "elif", "(", "u", "[", "i", "]", ">", "1e10", ")", "and", "(", "l", "[", "i", "]", ">", "-", "1e10", ")", ":", "igt", ".", "append", "(", "i", ")", "elif", "(", "l", "[", "i", "]", "<=", "-", "1e10", ")", "and", "(", "u", "[", "i", "]", "<", "1e10", ")", ":", "ilt", ".", "append", "(", "i", ")", "elif", "(", "abs", "(", "u", "[", "i", "]", "-", "l", "[", "i", "]", ")", ">", "EPS", ")", "and", "(", "u", "[", "i", "]", "<", "1e10", ")", "and", "(", "l", "[", "i", "]", ">", "-", "1e10", ")", ":", "ibx", ".", "append", "(", "i", ")", "else", ":", "raise", "ValueError", "Ae", "=", "A", "[", "ieq", ",", ":", "]", "Ai", "=", "sparse", "(", "[", "A", "[", "ilt", ",", ":", "]", ",", "-", "A", "[", "igt", ",", ":", "]", ",", "A", "[", "ibx", ",", ":", "]", ",", "-", "A", "[", "ibx", ",", ":", "]", "]", ")", "be", "=", "u", "[", "ieq", ",", ":", "]", "bi", "=", "matrix", "(", "[", "u", "[", "ilt", "]", ",", "-", "l", "[", "igt", "]", ",", "u", "[", "ibx", "]", ",", "-", "l", "[", "ibx", "]", "]", ")", "return", "Ae", ",", "be", ",", "Ai", ",", "bi" ]
Returns the linear equality and inequality constraints.
[ "Returns", "the", "linear", "equality", "and", "inequality", "constraints", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/cvxopf.py#L472-L496
train
822
rwl/pylon
contrib/cvxopf.py
dSbus_dV
def dSbus_dV(Y, V): """ Computes the partial derivative of power injection w.r.t. voltage. References: Ray Zimmerman, "dSbus_dV.m", MATPOWER, version 3.2, PSERC (Cornell), http://www.pserc.cornell.edu/matpower/ """ I = Y * V diagV = spdiag(V) diagIbus = spdiag(I) diagVnorm = spdiag(div(V, abs(V))) # Element-wise division. dS_dVm = diagV * conj(Y * diagVnorm) + conj(diagIbus) * diagVnorm dS_dVa = 1j * diagV * conj(diagIbus - Y * diagV) return dS_dVm, dS_dVa
python
def dSbus_dV(Y, V): """ Computes the partial derivative of power injection w.r.t. voltage. References: Ray Zimmerman, "dSbus_dV.m", MATPOWER, version 3.2, PSERC (Cornell), http://www.pserc.cornell.edu/matpower/ """ I = Y * V diagV = spdiag(V) diagIbus = spdiag(I) diagVnorm = spdiag(div(V, abs(V))) # Element-wise division. dS_dVm = diagV * conj(Y * diagVnorm) + conj(diagIbus) * diagVnorm dS_dVa = 1j * diagV * conj(diagIbus - Y * diagV) return dS_dVm, dS_dVa
[ "def", "dSbus_dV", "(", "Y", ",", "V", ")", ":", "I", "=", "Y", "*", "V", "diagV", "=", "spdiag", "(", "V", ")", "diagIbus", "=", "spdiag", "(", "I", ")", "diagVnorm", "=", "spdiag", "(", "div", "(", "V", ",", "abs", "(", "V", ")", ")", ")", "# Element-wise division.", "dS_dVm", "=", "diagV", "*", "conj", "(", "Y", "*", "diagVnorm", ")", "+", "conj", "(", "diagIbus", ")", "*", "diagVnorm", "dS_dVa", "=", "1j", "*", "diagV", "*", "conj", "(", "diagIbus", "-", "Y", "*", "diagV", ")", "return", "dS_dVm", ",", "dS_dVa" ]
Computes the partial derivative of power injection w.r.t. voltage. References: Ray Zimmerman, "dSbus_dV.m", MATPOWER, version 3.2, PSERC (Cornell), http://www.pserc.cornell.edu/matpower/
[ "Computes", "the", "partial", "derivative", "of", "power", "injection", "w", ".", "r", ".", "t", ".", "voltage", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/cvxopf.py#L502-L518
train
823
rwl/pylon
contrib/cvxopf.py
dIbr_dV
def dIbr_dV(Yf, Yt, V): """ Computes partial derivatives of branch currents w.r.t. voltage. Ray Zimmerman, "dIbr_dV.m", MATPOWER, version 4.0b1, PSERC (Cornell), http://www.pserc.cornell.edu/matpower/ """ # nb = len(V) Vnorm = div(V, abs(V)) diagV = spdiag(V) diagVnorm = spdiag(Vnorm) dIf_dVa = Yf * 1j * diagV dIf_dVm = Yf * diagVnorm dIt_dVa = Yt * 1j * diagV dIt_dVm = Yt * diagVnorm # Compute currents. If = Yf * V It = Yt * V return dIf_dVa, dIf_dVm, dIt_dVa, dIt_dVm, If, It
python
def dIbr_dV(Yf, Yt, V): """ Computes partial derivatives of branch currents w.r.t. voltage. Ray Zimmerman, "dIbr_dV.m", MATPOWER, version 4.0b1, PSERC (Cornell), http://www.pserc.cornell.edu/matpower/ """ # nb = len(V) Vnorm = div(V, abs(V)) diagV = spdiag(V) diagVnorm = spdiag(Vnorm) dIf_dVa = Yf * 1j * diagV dIf_dVm = Yf * diagVnorm dIt_dVa = Yt * 1j * diagV dIt_dVm = Yt * diagVnorm # Compute currents. If = Yf * V It = Yt * V return dIf_dVa, dIf_dVm, dIt_dVa, dIt_dVm, If, It
[ "def", "dIbr_dV", "(", "Yf", ",", "Yt", ",", "V", ")", ":", "# nb = len(V)", "Vnorm", "=", "div", "(", "V", ",", "abs", "(", "V", ")", ")", "diagV", "=", "spdiag", "(", "V", ")", "diagVnorm", "=", "spdiag", "(", "Vnorm", ")", "dIf_dVa", "=", "Yf", "*", "1j", "*", "diagV", "dIf_dVm", "=", "Yf", "*", "diagVnorm", "dIt_dVa", "=", "Yt", "*", "1j", "*", "diagV", "dIt_dVm", "=", "Yt", "*", "diagVnorm", "# Compute currents.", "If", "=", "Yf", "*", "V", "It", "=", "Yt", "*", "V", "return", "dIf_dVa", ",", "dIf_dVm", ",", "dIt_dVa", ",", "dIt_dVm", ",", "If", ",", "It" ]
Computes partial derivatives of branch currents w.r.t. voltage. Ray Zimmerman, "dIbr_dV.m", MATPOWER, version 4.0b1, PSERC (Cornell), http://www.pserc.cornell.edu/matpower/
[ "Computes", "partial", "derivatives", "of", "branch", "currents", "w", ".", "r", ".", "t", ".", "voltage", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/cvxopf.py#L524-L544
train
824
rwl/pylon
contrib/cvxopf.py
dSbr_dV
def dSbr_dV(Yf, Yt, V, buses, branches): """ Computes the branch power flow vector and the partial derivative of branch power flow w.r.t voltage. """ nl = len(branches) nb = len(V) f = matrix([l.from_bus._i for l in branches]) t = matrix([l.to_bus._i for l in branches]) # Compute currents. If = Yf * V It = Yt * V Vnorm = div(V, abs(V)) diagVf = spdiag(V[f]) diagIf = spdiag(If) diagVt = spdiag(V[t]) diagIt = spdiag(It) diagV = spdiag(V) diagVnorm = spdiag(Vnorm) ibr = range(nl) size = (nl, nb) # Partial derivative of S w.r.t voltage phase angle. dSf_dVa = 1j * (conj(diagIf) * spmatrix(V[f], ibr, f, size) - diagVf * conj(Yf * diagV)) dSt_dVa = 1j * (conj(diagIt) * spmatrix(V[t], ibr, t, size) - diagVt * conj(Yt * diagV)) # Partial derivative of S w.r.t. voltage amplitude. dSf_dVm = diagVf * conj(Yf * diagVnorm) + conj(diagIf) * \ spmatrix(Vnorm[f], ibr, f, size) dSt_dVm = diagVt * conj(Yt * diagVnorm) + conj(diagIt) * \ spmatrix(Vnorm[t], ibr, t, size) # Compute power flow vectors. Sf = mul(V[f], conj(If)) St = mul(V[t], conj(It)) return dSf_dVa, dSf_dVm, dSt_dVa, dSt_dVm, Sf, St
python
def dSbr_dV(Yf, Yt, V, buses, branches): """ Computes the branch power flow vector and the partial derivative of branch power flow w.r.t voltage. """ nl = len(branches) nb = len(V) f = matrix([l.from_bus._i for l in branches]) t = matrix([l.to_bus._i for l in branches]) # Compute currents. If = Yf * V It = Yt * V Vnorm = div(V, abs(V)) diagVf = spdiag(V[f]) diagIf = spdiag(If) diagVt = spdiag(V[t]) diagIt = spdiag(It) diagV = spdiag(V) diagVnorm = spdiag(Vnorm) ibr = range(nl) size = (nl, nb) # Partial derivative of S w.r.t voltage phase angle. dSf_dVa = 1j * (conj(diagIf) * spmatrix(V[f], ibr, f, size) - diagVf * conj(Yf * diagV)) dSt_dVa = 1j * (conj(diagIt) * spmatrix(V[t], ibr, t, size) - diagVt * conj(Yt * diagV)) # Partial derivative of S w.r.t. voltage amplitude. dSf_dVm = diagVf * conj(Yf * diagVnorm) + conj(diagIf) * \ spmatrix(Vnorm[f], ibr, f, size) dSt_dVm = diagVt * conj(Yt * diagVnorm) + conj(diagIt) * \ spmatrix(Vnorm[t], ibr, t, size) # Compute power flow vectors. Sf = mul(V[f], conj(If)) St = mul(V[t], conj(It)) return dSf_dVa, dSf_dVm, dSt_dVa, dSt_dVm, Sf, St
[ "def", "dSbr_dV", "(", "Yf", ",", "Yt", ",", "V", ",", "buses", ",", "branches", ")", ":", "nl", "=", "len", "(", "branches", ")", "nb", "=", "len", "(", "V", ")", "f", "=", "matrix", "(", "[", "l", ".", "from_bus", ".", "_i", "for", "l", "in", "branches", "]", ")", "t", "=", "matrix", "(", "[", "l", ".", "to_bus", ".", "_i", "for", "l", "in", "branches", "]", ")", "# Compute currents.", "If", "=", "Yf", "*", "V", "It", "=", "Yt", "*", "V", "Vnorm", "=", "div", "(", "V", ",", "abs", "(", "V", ")", ")", "diagVf", "=", "spdiag", "(", "V", "[", "f", "]", ")", "diagIf", "=", "spdiag", "(", "If", ")", "diagVt", "=", "spdiag", "(", "V", "[", "t", "]", ")", "diagIt", "=", "spdiag", "(", "It", ")", "diagV", "=", "spdiag", "(", "V", ")", "diagVnorm", "=", "spdiag", "(", "Vnorm", ")", "ibr", "=", "range", "(", "nl", ")", "size", "=", "(", "nl", ",", "nb", ")", "# Partial derivative of S w.r.t voltage phase angle.", "dSf_dVa", "=", "1j", "*", "(", "conj", "(", "diagIf", ")", "*", "spmatrix", "(", "V", "[", "f", "]", ",", "ibr", ",", "f", ",", "size", ")", "-", "diagVf", "*", "conj", "(", "Yf", "*", "diagV", ")", ")", "dSt_dVa", "=", "1j", "*", "(", "conj", "(", "diagIt", ")", "*", "spmatrix", "(", "V", "[", "t", "]", ",", "ibr", ",", "t", ",", "size", ")", "-", "diagVt", "*", "conj", "(", "Yt", "*", "diagV", ")", ")", "# Partial derivative of S w.r.t. voltage amplitude.", "dSf_dVm", "=", "diagVf", "*", "conj", "(", "Yf", "*", "diagVnorm", ")", "+", "conj", "(", "diagIf", ")", "*", "spmatrix", "(", "Vnorm", "[", "f", "]", ",", "ibr", ",", "f", ",", "size", ")", "dSt_dVm", "=", "diagVt", "*", "conj", "(", "Yt", "*", "diagVnorm", ")", "+", "conj", "(", "diagIt", ")", "*", "spmatrix", "(", "Vnorm", "[", "t", "]", ",", "ibr", ",", "t", ",", "size", ")", "# Compute power flow vectors.", "Sf", "=", "mul", "(", "V", "[", "f", "]", ",", "conj", "(", "If", ")", ")", "St", "=", "mul", "(", "V", "[", "t", "]", ",", "conj", "(", "It", ")", ")", "return", "dSf_dVa", ",", "dSf_dVm", ",", "dSt_dVa", ",", "dSt_dVm", ",", "Sf", ",", "St" ]
Computes the branch power flow vector and the partial derivative of branch power flow w.r.t voltage.
[ "Computes", "the", "branch", "power", "flow", "vector", "and", "the", "partial", "derivative", "of", "branch", "power", "flow", "w", ".", "r", ".", "t", "voltage", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/cvxopf.py#L550-L593
train
825
rwl/pylon
contrib/cvxopf.py
dAbr_dV
def dAbr_dV(dSf_dVa, dSf_dVm, dSt_dVa, dSt_dVm, Sf, St): """ Partial derivatives of squared flow magnitudes w.r.t voltage. Computes partial derivatives of apparent power w.r.t active and reactive power flows. Partial derivative must equal 1 for lines with zero flow to avoid division by zero errors (1 comes from L'Hopital). """ dAf_dPf = spdiag(2 * Sf.real()) dAf_dQf = spdiag(2 * Sf.imag()) dAt_dPt = spdiag(2 * St.real()) dAt_dQt = spdiag(2 * St.imag()) # Partial derivative of apparent power magnitude w.r.t voltage # phase angle. dAf_dVa = dAf_dPf * dSf_dVa.real() + dAf_dQf * dSf_dVa.imag() dAt_dVa = dAt_dPt * dSt_dVa.real() + dAt_dQt * dSt_dVa.imag() # Partial derivative of apparent power magnitude w.r.t. voltage # amplitude. dAf_dVm = dAf_dPf * dSf_dVm.real() + dAf_dQf * dSf_dVm.imag() dAt_dVm = dAt_dPt * dSt_dVm.real() + dAt_dQt * dSt_dVm.imag() return dAf_dVa, dAf_dVm, dAt_dVa, dAt_dVm
python
def dAbr_dV(dSf_dVa, dSf_dVm, dSt_dVa, dSt_dVm, Sf, St): """ Partial derivatives of squared flow magnitudes w.r.t voltage. Computes partial derivatives of apparent power w.r.t active and reactive power flows. Partial derivative must equal 1 for lines with zero flow to avoid division by zero errors (1 comes from L'Hopital). """ dAf_dPf = spdiag(2 * Sf.real()) dAf_dQf = spdiag(2 * Sf.imag()) dAt_dPt = spdiag(2 * St.real()) dAt_dQt = spdiag(2 * St.imag()) # Partial derivative of apparent power magnitude w.r.t voltage # phase angle. dAf_dVa = dAf_dPf * dSf_dVa.real() + dAf_dQf * dSf_dVa.imag() dAt_dVa = dAt_dPt * dSt_dVa.real() + dAt_dQt * dSt_dVa.imag() # Partial derivative of apparent power magnitude w.r.t. voltage # amplitude. dAf_dVm = dAf_dPf * dSf_dVm.real() + dAf_dQf * dSf_dVm.imag() dAt_dVm = dAt_dPt * dSt_dVm.real() + dAt_dQt * dSt_dVm.imag() return dAf_dVa, dAf_dVm, dAt_dVa, dAt_dVm
[ "def", "dAbr_dV", "(", "dSf_dVa", ",", "dSf_dVm", ",", "dSt_dVa", ",", "dSt_dVm", ",", "Sf", ",", "St", ")", ":", "dAf_dPf", "=", "spdiag", "(", "2", "*", "Sf", ".", "real", "(", ")", ")", "dAf_dQf", "=", "spdiag", "(", "2", "*", "Sf", ".", "imag", "(", ")", ")", "dAt_dPt", "=", "spdiag", "(", "2", "*", "St", ".", "real", "(", ")", ")", "dAt_dQt", "=", "spdiag", "(", "2", "*", "St", ".", "imag", "(", ")", ")", "# Partial derivative of apparent power magnitude w.r.t voltage", "# phase angle.", "dAf_dVa", "=", "dAf_dPf", "*", "dSf_dVa", ".", "real", "(", ")", "+", "dAf_dQf", "*", "dSf_dVa", ".", "imag", "(", ")", "dAt_dVa", "=", "dAt_dPt", "*", "dSt_dVa", ".", "real", "(", ")", "+", "dAt_dQt", "*", "dSt_dVa", ".", "imag", "(", ")", "# Partial derivative of apparent power magnitude w.r.t. voltage", "# amplitude.", "dAf_dVm", "=", "dAf_dPf", "*", "dSf_dVm", ".", "real", "(", ")", "+", "dAf_dQf", "*", "dSf_dVm", ".", "imag", "(", ")", "dAt_dVm", "=", "dAt_dPt", "*", "dSt_dVm", ".", "real", "(", ")", "+", "dAt_dQt", "*", "dSt_dVm", ".", "imag", "(", ")", "return", "dAf_dVa", ",", "dAf_dVm", ",", "dAt_dVa", ",", "dAt_dVm" ]
Partial derivatives of squared flow magnitudes w.r.t voltage. Computes partial derivatives of apparent power w.r.t active and reactive power flows. Partial derivative must equal 1 for lines with zero flow to avoid division by zero errors (1 comes from L'Hopital).
[ "Partial", "derivatives", "of", "squared", "flow", "magnitudes", "w", ".", "r", ".", "t", "voltage", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/cvxopf.py#L599-L621
train
826
rwl/pylon
contrib/cvxopf.py
d2Sbus_dV2
def d2Sbus_dV2(Ybus, V, lam): """ Computes 2nd derivatives of power injection w.r.t. voltage. """ n = len(V) Ibus = Ybus * V diaglam = spdiag(lam) diagV = spdiag(V) A = spmatrix(mul(lam, V), range(n), range(n)) B = Ybus * diagV C = A * conj(B) D = Ybus.H * diagV E = conj(diagV) * (D * diaglam - spmatrix(D*lam, range(n), range(n))) F = C - A * spmatrix(conj(Ibus), range(n), range(n)) G = spmatrix(div(matrix(1.0, (n, 1)), abs(V)), range(n), range(n)) Gaa = E + F Gva = 1j * G * (E - F) Gav = Gva.T Gvv = G * (C + C.T) * G return Gaa, Gav, Gva, Gvv
python
def d2Sbus_dV2(Ybus, V, lam): """ Computes 2nd derivatives of power injection w.r.t. voltage. """ n = len(V) Ibus = Ybus * V diaglam = spdiag(lam) diagV = spdiag(V) A = spmatrix(mul(lam, V), range(n), range(n)) B = Ybus * diagV C = A * conj(B) D = Ybus.H * diagV E = conj(diagV) * (D * diaglam - spmatrix(D*lam, range(n), range(n))) F = C - A * spmatrix(conj(Ibus), range(n), range(n)) G = spmatrix(div(matrix(1.0, (n, 1)), abs(V)), range(n), range(n)) Gaa = E + F Gva = 1j * G * (E - F) Gav = Gva.T Gvv = G * (C + C.T) * G return Gaa, Gav, Gva, Gvv
[ "def", "d2Sbus_dV2", "(", "Ybus", ",", "V", ",", "lam", ")", ":", "n", "=", "len", "(", "V", ")", "Ibus", "=", "Ybus", "*", "V", "diaglam", "=", "spdiag", "(", "lam", ")", "diagV", "=", "spdiag", "(", "V", ")", "A", "=", "spmatrix", "(", "mul", "(", "lam", ",", "V", ")", ",", "range", "(", "n", ")", ",", "range", "(", "n", ")", ")", "B", "=", "Ybus", "*", "diagV", "C", "=", "A", "*", "conj", "(", "B", ")", "D", "=", "Ybus", ".", "H", "*", "diagV", "E", "=", "conj", "(", "diagV", ")", "*", "(", "D", "*", "diaglam", "-", "spmatrix", "(", "D", "*", "lam", ",", "range", "(", "n", ")", ",", "range", "(", "n", ")", ")", ")", "F", "=", "C", "-", "A", "*", "spmatrix", "(", "conj", "(", "Ibus", ")", ",", "range", "(", "n", ")", ",", "range", "(", "n", ")", ")", "G", "=", "spmatrix", "(", "div", "(", "matrix", "(", "1.0", ",", "(", "n", ",", "1", ")", ")", ",", "abs", "(", "V", ")", ")", ",", "range", "(", "n", ")", ",", "range", "(", "n", ")", ")", "Gaa", "=", "E", "+", "F", "Gva", "=", "1j", "*", "G", "*", "(", "E", "-", "F", ")", "Gav", "=", "Gva", ".", "T", "Gvv", "=", "G", "*", "(", "C", "+", "C", ".", "T", ")", "*", "G", "return", "Gaa", ",", "Gav", ",", "Gva", ",", "Gvv" ]
Computes 2nd derivatives of power injection w.r.t. voltage.
[ "Computes", "2nd", "derivatives", "of", "power", "injection", "w", ".", "r", ".", "t", ".", "voltage", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/cvxopf.py#L627-L648
train
827
rwl/pylon
contrib/cvxopf.py
d2Ibr_dV2
def d2Ibr_dV2(Ybr, V, lam): """ Computes 2nd derivatives of complex branch current w.r.t. voltage. """ nb = len(V) diaginvVm = spdiag(div(matrix(1.0, (nb, 1)), abs(V))) Haa = spdiag(mul(-(Ybr.T * lam), V)) Hva = -1j * Haa * diaginvVm Hav = Hva Hvv = spmatrix([], [], [], (nb, nb)) return Haa, Hav, Hva, Hvv
python
def d2Ibr_dV2(Ybr, V, lam): """ Computes 2nd derivatives of complex branch current w.r.t. voltage. """ nb = len(V) diaginvVm = spdiag(div(matrix(1.0, (nb, 1)), abs(V))) Haa = spdiag(mul(-(Ybr.T * lam), V)) Hva = -1j * Haa * diaginvVm Hav = Hva Hvv = spmatrix([], [], [], (nb, nb)) return Haa, Hav, Hva, Hvv
[ "def", "d2Ibr_dV2", "(", "Ybr", ",", "V", ",", "lam", ")", ":", "nb", "=", "len", "(", "V", ")", "diaginvVm", "=", "spdiag", "(", "div", "(", "matrix", "(", "1.0", ",", "(", "nb", ",", "1", ")", ")", ",", "abs", "(", "V", ")", ")", ")", "Haa", "=", "spdiag", "(", "mul", "(", "-", "(", "Ybr", ".", "T", "*", "lam", ")", ",", "V", ")", ")", "Hva", "=", "-", "1j", "*", "Haa", "*", "diaginvVm", "Hav", "=", "Hva", "Hvv", "=", "spmatrix", "(", "[", "]", ",", "[", "]", ",", "[", "]", ",", "(", "nb", ",", "nb", ")", ")", "return", "Haa", ",", "Hav", ",", "Hva", ",", "Hvv" ]
Computes 2nd derivatives of complex branch current w.r.t. voltage.
[ "Computes", "2nd", "derivatives", "of", "complex", "branch", "current", "w", ".", "r", ".", "t", ".", "voltage", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/cvxopf.py#L654-L665
train
828
rwl/pylon
contrib/cvxopf.py
d2Sbr_dV2
def d2Sbr_dV2(Cbr, Ybr, V, lam): """ Computes 2nd derivatives of complex power flow w.r.t. voltage. """ nb = len(V) diaglam = spdiag(lam) diagV = spdiag(V) A = Ybr.H * diaglam * Cbr B = conj(diagV) * A * diagV D = spdiag(mul((A*V), conj(V))) E = spdiag(mul((A.T * conj(V)), V)) F = B + B.T G = spdiag(div(matrix(1.0, (nb, 1)), abs(V))) Haa = F - D - E Hva = 1j * G * (B - B.T - D + E) Hav = Hva.T Hvv = G * F * G return Haa, Hav, Hva, Hvv
python
def d2Sbr_dV2(Cbr, Ybr, V, lam): """ Computes 2nd derivatives of complex power flow w.r.t. voltage. """ nb = len(V) diaglam = spdiag(lam) diagV = spdiag(V) A = Ybr.H * diaglam * Cbr B = conj(diagV) * A * diagV D = spdiag(mul((A*V), conj(V))) E = spdiag(mul((A.T * conj(V)), V)) F = B + B.T G = spdiag(div(matrix(1.0, (nb, 1)), abs(V))) Haa = F - D - E Hva = 1j * G * (B - B.T - D + E) Hav = Hva.T Hvv = G * F * G return Haa, Hav, Hva, Hvv
[ "def", "d2Sbr_dV2", "(", "Cbr", ",", "Ybr", ",", "V", ",", "lam", ")", ":", "nb", "=", "len", "(", "V", ")", "diaglam", "=", "spdiag", "(", "lam", ")", "diagV", "=", "spdiag", "(", "V", ")", "A", "=", "Ybr", ".", "H", "*", "diaglam", "*", "Cbr", "B", "=", "conj", "(", "diagV", ")", "*", "A", "*", "diagV", "D", "=", "spdiag", "(", "mul", "(", "(", "A", "*", "V", ")", ",", "conj", "(", "V", ")", ")", ")", "E", "=", "spdiag", "(", "mul", "(", "(", "A", ".", "T", "*", "conj", "(", "V", ")", ")", ",", "V", ")", ")", "F", "=", "B", "+", "B", ".", "T", "G", "=", "spdiag", "(", "div", "(", "matrix", "(", "1.0", ",", "(", "nb", ",", "1", ")", ")", ",", "abs", "(", "V", ")", ")", ")", "Haa", "=", "F", "-", "D", "-", "E", "Hva", "=", "1j", "*", "G", "*", "(", "B", "-", "B", ".", "T", "-", "D", "+", "E", ")", "Hav", "=", "Hva", ".", "T", "Hvv", "=", "G", "*", "F", "*", "G", "return", "Haa", ",", "Hav", ",", "Hva", ",", "Hvv" ]
Computes 2nd derivatives of complex power flow w.r.t. voltage.
[ "Computes", "2nd", "derivatives", "of", "complex", "power", "flow", "w", ".", "r", ".", "t", ".", "voltage", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/cvxopf.py#L671-L691
train
829
rwl/pylon
contrib/cvxopf.py
tocvx
def tocvx(B): """ Converts a sparse SciPy matrix into a sparse CVXOPT matrix. """ Bcoo = B.tocoo() return spmatrix(Bcoo.data, Bcoo.row.tolist(), Bcoo.col.tolist())
python
def tocvx(B): """ Converts a sparse SciPy matrix into a sparse CVXOPT matrix. """ Bcoo = B.tocoo() return spmatrix(Bcoo.data, Bcoo.row.tolist(), Bcoo.col.tolist())
[ "def", "tocvx", "(", "B", ")", ":", "Bcoo", "=", "B", ".", "tocoo", "(", ")", "return", "spmatrix", "(", "Bcoo", ".", "data", ",", "Bcoo", ".", "row", ".", "tolist", "(", ")", ",", "Bcoo", ".", "col", ".", "tolist", "(", ")", ")" ]
Converts a sparse SciPy matrix into a sparse CVXOPT matrix.
[ "Converts", "a", "sparse", "SciPy", "matrix", "into", "a", "sparse", "CVXOPT", "matrix", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/cvxopf.py#L741-L745
train
830
rwl/pylon
pyreto/discrete/experiment.py
MarketExperiment.doInteractions
def doInteractions(self, number=1): """ Directly maps the agents and the tasks. """ t0 = time.time() for _ in range(number): self._oneInteraction() elapsed = time.time() - t0 logger.info("%d interactions executed in %.3fs." % (number, elapsed)) return self.stepid
python
def doInteractions(self, number=1): """ Directly maps the agents and the tasks. """ t0 = time.time() for _ in range(number): self._oneInteraction() elapsed = time.time() - t0 logger.info("%d interactions executed in %.3fs." % (number, elapsed)) return self.stepid
[ "def", "doInteractions", "(", "self", ",", "number", "=", "1", ")", ":", "t0", "=", "time", ".", "time", "(", ")", "for", "_", "in", "range", "(", "number", ")", ":", "self", ".", "_oneInteraction", "(", ")", "elapsed", "=", "time", ".", "time", "(", ")", "-", "t0", "logger", ".", "info", "(", "\"%d interactions executed in %.3fs.\"", "%", "(", "number", ",", "elapsed", ")", ")", "return", "self", ".", "stepid" ]
Directly maps the agents and the tasks.
[ "Directly", "maps", "the", "agents", "and", "the", "tasks", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/discrete/experiment.py#L72-L83
train
831
rwl/pylon
pylon/dyn.py
DynamicCase.exciter
def exciter(self, Xexc, Pexc, Vexc): """ Exciter model. Based on Exciter.m from MatDyn by Stijn Cole, developed at Katholieke Universiteit Leuven. See U{http://www.esat.kuleuven.be/electa/teaching/ matdyn/} for more information. """ exciters = self.exciters F = zeros(Xexc.shape) typ1 = [e.generator._i for e in exciters if e.model ==CONST_EXCITATION] typ2 = [e.generator._i for e in exciters if e.model == IEEE_DC1A] # Exciter type 1: constant excitation F[typ1, :] = 0.0 # Exciter type 2: IEEE DC1A Efd = Xexc[typ2, 0] Uf = Xexc[typ2, 1] Ur = Xexc[typ2, 2] Ka = Pexc[typ2, 0] Ta = Pexc[typ2, 1] Ke = Pexc[typ2, 2] Te = Pexc[typ2, 3] Kf = Pexc[typ2, 4] Tf = Pexc[typ2, 5] Aex = Pexc[typ2, 6] Bex = Pexc[typ2, 7] Ur_min = Pexc[typ2, 8] Ur_max = Pexc[typ2, 9] Uref = Pexc[typ2, 10] Uref2 = Pexc[typ2, 11] U = Vexc[typ2, 1] Ux = Aex * exp(Bex * Efd) dUr = 1 / Ta * (Ka * (Uref - U + Uref2 - Uf) - Ur) dUf = 1 / Tf * (Kf / Te * (Ur - Ux - Ke * Efd) - Uf) if sum(flatnonzero(Ur > Ur_max)) >= 1: Ur2 = Ur_max elif sum(flatnonzero(Ur < Ur_max)) >= 1: Ur2 = Ur_min else: Ur2 = Ur dEfd = 1 / Te * (Ur2 - Ux - Ke * Efd) F[typ2, :] = c_[dEfd, dUf, dUr] # Exciter type 3: # Exciter type 4: return F
python
def exciter(self, Xexc, Pexc, Vexc): """ Exciter model. Based on Exciter.m from MatDyn by Stijn Cole, developed at Katholieke Universiteit Leuven. See U{http://www.esat.kuleuven.be/electa/teaching/ matdyn/} for more information. """ exciters = self.exciters F = zeros(Xexc.shape) typ1 = [e.generator._i for e in exciters if e.model ==CONST_EXCITATION] typ2 = [e.generator._i for e in exciters if e.model == IEEE_DC1A] # Exciter type 1: constant excitation F[typ1, :] = 0.0 # Exciter type 2: IEEE DC1A Efd = Xexc[typ2, 0] Uf = Xexc[typ2, 1] Ur = Xexc[typ2, 2] Ka = Pexc[typ2, 0] Ta = Pexc[typ2, 1] Ke = Pexc[typ2, 2] Te = Pexc[typ2, 3] Kf = Pexc[typ2, 4] Tf = Pexc[typ2, 5] Aex = Pexc[typ2, 6] Bex = Pexc[typ2, 7] Ur_min = Pexc[typ2, 8] Ur_max = Pexc[typ2, 9] Uref = Pexc[typ2, 10] Uref2 = Pexc[typ2, 11] U = Vexc[typ2, 1] Ux = Aex * exp(Bex * Efd) dUr = 1 / Ta * (Ka * (Uref - U + Uref2 - Uf) - Ur) dUf = 1 / Tf * (Kf / Te * (Ur - Ux - Ke * Efd) - Uf) if sum(flatnonzero(Ur > Ur_max)) >= 1: Ur2 = Ur_max elif sum(flatnonzero(Ur < Ur_max)) >= 1: Ur2 = Ur_min else: Ur2 = Ur dEfd = 1 / Te * (Ur2 - Ux - Ke * Efd) F[typ2, :] = c_[dEfd, dUf, dUr] # Exciter type 3: # Exciter type 4: return F
[ "def", "exciter", "(", "self", ",", "Xexc", ",", "Pexc", ",", "Vexc", ")", ":", "exciters", "=", "self", ".", "exciters", "F", "=", "zeros", "(", "Xexc", ".", "shape", ")", "typ1", "=", "[", "e", ".", "generator", ".", "_i", "for", "e", "in", "exciters", "if", "e", ".", "model", "==", "CONST_EXCITATION", "]", "typ2", "=", "[", "e", ".", "generator", ".", "_i", "for", "e", "in", "exciters", "if", "e", ".", "model", "==", "IEEE_DC1A", "]", "# Exciter type 1: constant excitation", "F", "[", "typ1", ",", ":", "]", "=", "0.0", "# Exciter type 2: IEEE DC1A", "Efd", "=", "Xexc", "[", "typ2", ",", "0", "]", "Uf", "=", "Xexc", "[", "typ2", ",", "1", "]", "Ur", "=", "Xexc", "[", "typ2", ",", "2", "]", "Ka", "=", "Pexc", "[", "typ2", ",", "0", "]", "Ta", "=", "Pexc", "[", "typ2", ",", "1", "]", "Ke", "=", "Pexc", "[", "typ2", ",", "2", "]", "Te", "=", "Pexc", "[", "typ2", ",", "3", "]", "Kf", "=", "Pexc", "[", "typ2", ",", "4", "]", "Tf", "=", "Pexc", "[", "typ2", ",", "5", "]", "Aex", "=", "Pexc", "[", "typ2", ",", "6", "]", "Bex", "=", "Pexc", "[", "typ2", ",", "7", "]", "Ur_min", "=", "Pexc", "[", "typ2", ",", "8", "]", "Ur_max", "=", "Pexc", "[", "typ2", ",", "9", "]", "Uref", "=", "Pexc", "[", "typ2", ",", "10", "]", "Uref2", "=", "Pexc", "[", "typ2", ",", "11", "]", "U", "=", "Vexc", "[", "typ2", ",", "1", "]", "Ux", "=", "Aex", "*", "exp", "(", "Bex", "*", "Efd", ")", "dUr", "=", "1", "/", "Ta", "*", "(", "Ka", "*", "(", "Uref", "-", "U", "+", "Uref2", "-", "Uf", ")", "-", "Ur", ")", "dUf", "=", "1", "/", "Tf", "*", "(", "Kf", "/", "Te", "*", "(", "Ur", "-", "Ux", "-", "Ke", "*", "Efd", ")", "-", "Uf", ")", "if", "sum", "(", "flatnonzero", "(", "Ur", ">", "Ur_max", ")", ")", ">=", "1", ":", "Ur2", "=", "Ur_max", "elif", "sum", "(", "flatnonzero", "(", "Ur", "<", "Ur_max", ")", ")", ">=", "1", ":", "Ur2", "=", "Ur_min", "else", ":", "Ur2", "=", "Ur", "dEfd", "=", "1", "/", "Te", "*", "(", "Ur2", "-", "Ux", "-", "Ke", "*", "Efd", ")", "F", "[", "typ2", ",", ":", "]", "=", "c_", "[", "dEfd", ",", "dUf", ",", "dUr", "]", "# Exciter type 3:", "# Exciter type 4:", "return", "F" ]
Exciter model. Based on Exciter.m from MatDyn by Stijn Cole, developed at Katholieke Universiteit Leuven. See U{http://www.esat.kuleuven.be/electa/teaching/ matdyn/} for more information.
[ "Exciter", "model", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/dyn.py#L409-L464
train
832
rwl/pylon
pylon/dyn.py
DynamicCase.governor
def governor(self, Xgov, Pgov, Vgov): """ Governor model. Based on Governor.m from MatDyn by Stijn Cole, developed at Katholieke Universiteit Leuven. See U{http://www.esat.kuleuven.be/electa/teaching/ matdyn/} for more information. """ governors = self.governors omegas = 2 * pi * self.freq F = zeros(Xgov.shape) typ1 = [g.generator._i for g in governors if g.model == CONST_POWER] typ2 = [g.generator._i for g in governors if g.model == GENERAL_IEEE] # Governor type 1: constant power F[typ1, 0] = 0 # Governor type 2: IEEE general speed-governing system Pm = Xgov[typ2, 0] P = Xgov[typ2, 1] x = Xgov[typ2, 2] z = Xgov[typ2, 3] K = Pgov[typ2, 0] T1 = Pgov[typ2, 1] T2 = Pgov[typ2, 2] T3 = Pgov[typ2, 3] Pup = Pgov[typ2, 4] Pdown = Pgov[typ2, 5] Pmax = Pgov[typ2, 6] Pmin = Pgov[typ2, 7] P0 = Pgov[typ2, 8] omega = Vgov[typ2, 0] dx = K * (-1 / T1 * x + (1 - T2 / T1) * (omega - omegas)) dP = 1 / T1 * x + T2 / T1 * (omega - omegas) y = 1 / T3 * (P0 - P - Pm) y2 = y if sum(flatnonzero(y > Pup)) >= 1: y2 = (1 - flatnonzero(y > Pup)) * y2 + flatnonzero(y > Pup) * Pup if sum(flatnonzero(y < Pdown)) >= 1: y2 = (1 - flatnonzero(y<Pdown)) * y2 + flatnonzero(y<Pdown) * Pdown dz = y2 dPm = y2 if sum(flatnonzero(z > Pmax)) >= 1: dPm = (1 - flatnonzero(z > Pmax)) * dPm + flatnonzero(z > Pmax) * 0 if sum(flatnonzero(z < Pmin)) >= 1: dPm = (1 - flatnonzero(z < Pmin)) * dPm + flatnonzero(z < Pmin) * 0 F[typ2, :] = c_[dPm, dP, dx, dz] # Governor type 3: # Governor type 4: return F
python
def governor(self, Xgov, Pgov, Vgov): """ Governor model. Based on Governor.m from MatDyn by Stijn Cole, developed at Katholieke Universiteit Leuven. See U{http://www.esat.kuleuven.be/electa/teaching/ matdyn/} for more information. """ governors = self.governors omegas = 2 * pi * self.freq F = zeros(Xgov.shape) typ1 = [g.generator._i for g in governors if g.model == CONST_POWER] typ2 = [g.generator._i for g in governors if g.model == GENERAL_IEEE] # Governor type 1: constant power F[typ1, 0] = 0 # Governor type 2: IEEE general speed-governing system Pm = Xgov[typ2, 0] P = Xgov[typ2, 1] x = Xgov[typ2, 2] z = Xgov[typ2, 3] K = Pgov[typ2, 0] T1 = Pgov[typ2, 1] T2 = Pgov[typ2, 2] T3 = Pgov[typ2, 3] Pup = Pgov[typ2, 4] Pdown = Pgov[typ2, 5] Pmax = Pgov[typ2, 6] Pmin = Pgov[typ2, 7] P0 = Pgov[typ2, 8] omega = Vgov[typ2, 0] dx = K * (-1 / T1 * x + (1 - T2 / T1) * (omega - omegas)) dP = 1 / T1 * x + T2 / T1 * (omega - omegas) y = 1 / T3 * (P0 - P - Pm) y2 = y if sum(flatnonzero(y > Pup)) >= 1: y2 = (1 - flatnonzero(y > Pup)) * y2 + flatnonzero(y > Pup) * Pup if sum(flatnonzero(y < Pdown)) >= 1: y2 = (1 - flatnonzero(y<Pdown)) * y2 + flatnonzero(y<Pdown) * Pdown dz = y2 dPm = y2 if sum(flatnonzero(z > Pmax)) >= 1: dPm = (1 - flatnonzero(z > Pmax)) * dPm + flatnonzero(z > Pmax) * 0 if sum(flatnonzero(z < Pmin)) >= 1: dPm = (1 - flatnonzero(z < Pmin)) * dPm + flatnonzero(z < Pmin) * 0 F[typ2, :] = c_[dPm, dP, dx, dz] # Governor type 3: # Governor type 4: return F
[ "def", "governor", "(", "self", ",", "Xgov", ",", "Pgov", ",", "Vgov", ")", ":", "governors", "=", "self", ".", "governors", "omegas", "=", "2", "*", "pi", "*", "self", ".", "freq", "F", "=", "zeros", "(", "Xgov", ".", "shape", ")", "typ1", "=", "[", "g", ".", "generator", ".", "_i", "for", "g", "in", "governors", "if", "g", ".", "model", "==", "CONST_POWER", "]", "typ2", "=", "[", "g", ".", "generator", ".", "_i", "for", "g", "in", "governors", "if", "g", ".", "model", "==", "GENERAL_IEEE", "]", "# Governor type 1: constant power", "F", "[", "typ1", ",", "0", "]", "=", "0", "# Governor type 2: IEEE general speed-governing system", "Pm", "=", "Xgov", "[", "typ2", ",", "0", "]", "P", "=", "Xgov", "[", "typ2", ",", "1", "]", "x", "=", "Xgov", "[", "typ2", ",", "2", "]", "z", "=", "Xgov", "[", "typ2", ",", "3", "]", "K", "=", "Pgov", "[", "typ2", ",", "0", "]", "T1", "=", "Pgov", "[", "typ2", ",", "1", "]", "T2", "=", "Pgov", "[", "typ2", ",", "2", "]", "T3", "=", "Pgov", "[", "typ2", ",", "3", "]", "Pup", "=", "Pgov", "[", "typ2", ",", "4", "]", "Pdown", "=", "Pgov", "[", "typ2", ",", "5", "]", "Pmax", "=", "Pgov", "[", "typ2", ",", "6", "]", "Pmin", "=", "Pgov", "[", "typ2", ",", "7", "]", "P0", "=", "Pgov", "[", "typ2", ",", "8", "]", "omega", "=", "Vgov", "[", "typ2", ",", "0", "]", "dx", "=", "K", "*", "(", "-", "1", "/", "T1", "*", "x", "+", "(", "1", "-", "T2", "/", "T1", ")", "*", "(", "omega", "-", "omegas", ")", ")", "dP", "=", "1", "/", "T1", "*", "x", "+", "T2", "/", "T1", "*", "(", "omega", "-", "omegas", ")", "y", "=", "1", "/", "T3", "*", "(", "P0", "-", "P", "-", "Pm", ")", "y2", "=", "y", "if", "sum", "(", "flatnonzero", "(", "y", ">", "Pup", ")", ")", ">=", "1", ":", "y2", "=", "(", "1", "-", "flatnonzero", "(", "y", ">", "Pup", ")", ")", "*", "y2", "+", "flatnonzero", "(", "y", ">", "Pup", ")", "*", "Pup", "if", "sum", "(", "flatnonzero", "(", "y", "<", "Pdown", ")", ")", ">=", "1", ":", "y2", "=", "(", "1", "-", "flatnonzero", "(", "y", "<", "Pdown", ")", ")", "*", "y2", "+", "flatnonzero", "(", "y", "<", "Pdown", ")", "*", "Pdown", "dz", "=", "y2", "dPm", "=", "y2", "if", "sum", "(", "flatnonzero", "(", "z", ">", "Pmax", ")", ")", ">=", "1", ":", "dPm", "=", "(", "1", "-", "flatnonzero", "(", "z", ">", "Pmax", ")", ")", "*", "dPm", "+", "flatnonzero", "(", "z", ">", "Pmax", ")", "*", "0", "if", "sum", "(", "flatnonzero", "(", "z", "<", "Pmin", ")", ")", ">=", "1", ":", "dPm", "=", "(", "1", "-", "flatnonzero", "(", "z", "<", "Pmin", ")", ")", "*", "dPm", "+", "flatnonzero", "(", "z", "<", "Pmin", ")", "*", "0", "F", "[", "typ2", ",", ":", "]", "=", "c_", "[", "dPm", ",", "dP", ",", "dx", ",", "dz", "]", "# Governor type 3:", "# Governor type 4:", "return", "F" ]
Governor model. Based on Governor.m from MatDyn by Stijn Cole, developed at Katholieke Universiteit Leuven. See U{http://www.esat.kuleuven.be/electa/teaching/ matdyn/} for more information.
[ "Governor", "model", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/dyn.py#L467-L530
train
833
rwl/pylon
pylon/dyn.py
DynamicCase.generator
def generator(self, Xgen, Xexc, Xgov, Vgen): """ Generator model. Based on Generator.m from MatDyn by Stijn Cole, developed at Katholieke Universiteit Leuven. See U{http://www.esat.kuleuven.be/electa/teaching/ matdyn/} for more information. """ generators = self.dyn_generators omegas = 2 * pi * self.freq F = zeros(Xgen.shape) typ1 = [g._i for g in generators if g.model == CLASSICAL] typ2 = [g._i for g in generators if g.model == FOURTH_ORDER] # Generator type 1: classical model omega = Xgen[typ1, 1] Pm0 = Xgov[typ1, 0] H = array([g.h for g in generators])[typ1] D = array([g.d for g in generators])[typ1] Pe = Vgen[typ1, 2] ddelta = omega = omegas domega = pi * self.freq / H * (-D * (omega - omegas) + Pm0 - Pe) dEq = zeros(len(typ1)) F[typ1, :] = c_[ddelta, domega, dEq] # Generator type 2: 4th order model omega = Xgen[typ2, 1] Eq_tr = Xgen[typ2, 2] Ed_tr = Xgen[typ2, 3] H = array([g.h for g in generators]) D = array([g.d for g in generators]) xd = array([g.xd for g in generators]) xq = array([g.xq for g in generators]) xd_tr = array([g.xd_tr for g in generators]) xq_tr = array([g.xq_tr for g in generators]) Td0_tr = array([g.td for g in generators]) Tq0_tr = array([g.tq for g in generators]) Id = Vgen[typ2, 0] Iq = Vgen[typ2, 1] Pe = Vgen[typ2, 2] Efd = Xexc[typ2, 0] Pm = Xgov[typ2, 0] ddelta = omega - omegas domega = pi * self.freq / H * (-D * (omega - omegas) + Pm - Pe) dEq = 1 / Td0_tr * (Efd - Eq_tr + (xd - xd_tr) * Id) dEd = 1 / Tq0_tr * (-Ed_tr - (xq - xq_tr) * Iq) F[typ2, :] = c_[ddelta, domega, dEq, dEd] # Generator type 3: # Generator type 4: return F
python
def generator(self, Xgen, Xexc, Xgov, Vgen): """ Generator model. Based on Generator.m from MatDyn by Stijn Cole, developed at Katholieke Universiteit Leuven. See U{http://www.esat.kuleuven.be/electa/teaching/ matdyn/} for more information. """ generators = self.dyn_generators omegas = 2 * pi * self.freq F = zeros(Xgen.shape) typ1 = [g._i for g in generators if g.model == CLASSICAL] typ2 = [g._i for g in generators if g.model == FOURTH_ORDER] # Generator type 1: classical model omega = Xgen[typ1, 1] Pm0 = Xgov[typ1, 0] H = array([g.h for g in generators])[typ1] D = array([g.d for g in generators])[typ1] Pe = Vgen[typ1, 2] ddelta = omega = omegas domega = pi * self.freq / H * (-D * (omega - omegas) + Pm0 - Pe) dEq = zeros(len(typ1)) F[typ1, :] = c_[ddelta, domega, dEq] # Generator type 2: 4th order model omega = Xgen[typ2, 1] Eq_tr = Xgen[typ2, 2] Ed_tr = Xgen[typ2, 3] H = array([g.h for g in generators]) D = array([g.d for g in generators]) xd = array([g.xd for g in generators]) xq = array([g.xq for g in generators]) xd_tr = array([g.xd_tr for g in generators]) xq_tr = array([g.xq_tr for g in generators]) Td0_tr = array([g.td for g in generators]) Tq0_tr = array([g.tq for g in generators]) Id = Vgen[typ2, 0] Iq = Vgen[typ2, 1] Pe = Vgen[typ2, 2] Efd = Xexc[typ2, 0] Pm = Xgov[typ2, 0] ddelta = omega - omegas domega = pi * self.freq / H * (-D * (omega - omegas) + Pm - Pe) dEq = 1 / Td0_tr * (Efd - Eq_tr + (xd - xd_tr) * Id) dEd = 1 / Tq0_tr * (-Ed_tr - (xq - xq_tr) * Iq) F[typ2, :] = c_[ddelta, domega, dEq, dEd] # Generator type 3: # Generator type 4: return F
[ "def", "generator", "(", "self", ",", "Xgen", ",", "Xexc", ",", "Xgov", ",", "Vgen", ")", ":", "generators", "=", "self", ".", "dyn_generators", "omegas", "=", "2", "*", "pi", "*", "self", ".", "freq", "F", "=", "zeros", "(", "Xgen", ".", "shape", ")", "typ1", "=", "[", "g", ".", "_i", "for", "g", "in", "generators", "if", "g", ".", "model", "==", "CLASSICAL", "]", "typ2", "=", "[", "g", ".", "_i", "for", "g", "in", "generators", "if", "g", ".", "model", "==", "FOURTH_ORDER", "]", "# Generator type 1: classical model", "omega", "=", "Xgen", "[", "typ1", ",", "1", "]", "Pm0", "=", "Xgov", "[", "typ1", ",", "0", "]", "H", "=", "array", "(", "[", "g", ".", "h", "for", "g", "in", "generators", "]", ")", "[", "typ1", "]", "D", "=", "array", "(", "[", "g", ".", "d", "for", "g", "in", "generators", "]", ")", "[", "typ1", "]", "Pe", "=", "Vgen", "[", "typ1", ",", "2", "]", "ddelta", "=", "omega", "=", "omegas", "domega", "=", "pi", "*", "self", ".", "freq", "/", "H", "*", "(", "-", "D", "*", "(", "omega", "-", "omegas", ")", "+", "Pm0", "-", "Pe", ")", "dEq", "=", "zeros", "(", "len", "(", "typ1", ")", ")", "F", "[", "typ1", ",", ":", "]", "=", "c_", "[", "ddelta", ",", "domega", ",", "dEq", "]", "# Generator type 2: 4th order model", "omega", "=", "Xgen", "[", "typ2", ",", "1", "]", "Eq_tr", "=", "Xgen", "[", "typ2", ",", "2", "]", "Ed_tr", "=", "Xgen", "[", "typ2", ",", "3", "]", "H", "=", "array", "(", "[", "g", ".", "h", "for", "g", "in", "generators", "]", ")", "D", "=", "array", "(", "[", "g", ".", "d", "for", "g", "in", "generators", "]", ")", "xd", "=", "array", "(", "[", "g", ".", "xd", "for", "g", "in", "generators", "]", ")", "xq", "=", "array", "(", "[", "g", ".", "xq", "for", "g", "in", "generators", "]", ")", "xd_tr", "=", "array", "(", "[", "g", ".", "xd_tr", "for", "g", "in", "generators", "]", ")", "xq_tr", "=", "array", "(", "[", "g", ".", "xq_tr", "for", "g", "in", "generators", "]", ")", "Td0_tr", "=", "array", "(", "[", "g", ".", "td", "for", "g", "in", "generators", "]", ")", "Tq0_tr", "=", "array", "(", "[", "g", ".", "tq", "for", "g", "in", "generators", "]", ")", "Id", "=", "Vgen", "[", "typ2", ",", "0", "]", "Iq", "=", "Vgen", "[", "typ2", ",", "1", "]", "Pe", "=", "Vgen", "[", "typ2", ",", "2", "]", "Efd", "=", "Xexc", "[", "typ2", ",", "0", "]", "Pm", "=", "Xgov", "[", "typ2", ",", "0", "]", "ddelta", "=", "omega", "-", "omegas", "domega", "=", "pi", "*", "self", ".", "freq", "/", "H", "*", "(", "-", "D", "*", "(", "omega", "-", "omegas", ")", "+", "Pm", "-", "Pe", ")", "dEq", "=", "1", "/", "Td0_tr", "*", "(", "Efd", "-", "Eq_tr", "+", "(", "xd", "-", "xd_tr", ")", "*", "Id", ")", "dEd", "=", "1", "/", "Tq0_tr", "*", "(", "-", "Ed_tr", "-", "(", "xq", "-", "xq_tr", ")", "*", "Iq", ")", "F", "[", "typ2", ",", ":", "]", "=", "c_", "[", "ddelta", ",", "domega", ",", "dEq", ",", "dEd", "]", "# Generator type 3:", "# Generator type 4:", "return", "F" ]
Generator model. Based on Generator.m from MatDyn by Stijn Cole, developed at Katholieke Universiteit Leuven. See U{http://www.esat.kuleuven.be/electa/teaching/ matdyn/} for more information.
[ "Generator", "model", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/dyn.py#L533-L595
train
834
rwl/pylon
pylon/io/rst.py
ReSTWriter._write_data
def _write_data(self, file): """ Writes case data to file in ReStructuredText format. """ self.write_case_data(file) file.write("Bus Data\n") file.write("-" * 8 + "\n") self.write_bus_data(file) file.write("\n") file.write("Branch Data\n") file.write("-" * 11 + "\n") self.write_branch_data(file) file.write("\n") file.write("Generator Data\n") file.write("-" * 14 + "\n") self.write_generator_data(file) file.write("\n")
python
def _write_data(self, file): """ Writes case data to file in ReStructuredText format. """ self.write_case_data(file) file.write("Bus Data\n") file.write("-" * 8 + "\n") self.write_bus_data(file) file.write("\n") file.write("Branch Data\n") file.write("-" * 11 + "\n") self.write_branch_data(file) file.write("\n") file.write("Generator Data\n") file.write("-" * 14 + "\n") self.write_generator_data(file) file.write("\n")
[ "def", "_write_data", "(", "self", ",", "file", ")", ":", "self", ".", "write_case_data", "(", "file", ")", "file", ".", "write", "(", "\"Bus Data\\n\"", ")", "file", ".", "write", "(", "\"-\"", "*", "8", "+", "\"\\n\"", ")", "self", ".", "write_bus_data", "(", "file", ")", "file", ".", "write", "(", "\"\\n\"", ")", "file", ".", "write", "(", "\"Branch Data\\n\"", ")", "file", ".", "write", "(", "\"-\"", "*", "11", "+", "\"\\n\"", ")", "self", ".", "write_branch_data", "(", "file", ")", "file", ".", "write", "(", "\"\\n\"", ")", "file", ".", "write", "(", "\"Generator Data\\n\"", ")", "file", ".", "write", "(", "\"-\"", "*", "14", "+", "\"\\n\"", ")", "self", ".", "write_generator_data", "(", "file", ")", "file", ".", "write", "(", "\"\\n\"", ")" ]
Writes case data to file in ReStructuredText format.
[ "Writes", "case", "data", "to", "file", "in", "ReStructuredText", "format", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/rst.py#L40-L58
train
835
rwl/pylon
pylon/io/rst.py
ReSTWriter.write_bus_data
def write_bus_data(self, file): """ Writes bus data to a ReST table. """ report = CaseReport(self.case) buses = self.case.buses col_width = 8 col_width_2 = col_width * 2 + 1 col1_width = 6 sep = "=" * 6 + " " + ("=" * col_width + " ") * 6 + "\n" file.write(sep) # Line one of column headers file.write("Name".center(col1_width) + " ") file.write("Voltage (pu)".center(col_width_2) + " ") file.write("Generation".center(col_width_2) + " ") file.write("Load".center(col_width_2) + " ") file.write("\n") file.write("-" * col1_width +" "+ ("-" * col_width_2 + " ") * 3 + "\n") # Line two of column header file.write("..".ljust(col1_width) + " ") file.write("Amp".center(col_width) + " ") file.write("Phase".center(col_width) + " ") file.write("P (MW)".center(col_width) + " ") file.write("Q (MVAr)".center(col_width) + " ") file.write("P (MW)".center(col_width) + " ") file.write("Q (MVAr)".center(col_width) + " ") file.write("\n") file.write(sep) # Bus rows for bus in buses: file.write(bus.name[:col1_width].ljust(col1_width)) file.write(" %8.3f" % bus.v_magnitude) file.write(" %8.3f" % bus.v_angle) file.write(" %8.2f" % self.case.s_supply(bus).real) file.write(" %8.2f" % self.case.s_supply(bus).imag) file.write(" %8.2f" % self.case.s_demand(bus).real) file.write(" %8.2f" % self.case.s_demand(bus).imag) file.write("\n") # Totals # file.write("..".ljust(col1_width) + " ") # file.write(("..".ljust(col_width) + " ")*2) # file.write(("_"*col_width + " ")*4 + "\n") file.write("..".ljust(col1_width) + " " + "..".ljust(col_width) + " ") file.write("*Total:*".rjust(col_width) + " ") ptot = report.actual_pgen qtot = report.actual_qgen file.write("%8.2f " % ptot) file.write("%8.2f " % qtot) file.write("%8.2f " % report.p_demand) file.write("%8.2f " % report.q_demand) file.write("\n") file.write(sep) del report
python
def write_bus_data(self, file): """ Writes bus data to a ReST table. """ report = CaseReport(self.case) buses = self.case.buses col_width = 8 col_width_2 = col_width * 2 + 1 col1_width = 6 sep = "=" * 6 + " " + ("=" * col_width + " ") * 6 + "\n" file.write(sep) # Line one of column headers file.write("Name".center(col1_width) + " ") file.write("Voltage (pu)".center(col_width_2) + " ") file.write("Generation".center(col_width_2) + " ") file.write("Load".center(col_width_2) + " ") file.write("\n") file.write("-" * col1_width +" "+ ("-" * col_width_2 + " ") * 3 + "\n") # Line two of column header file.write("..".ljust(col1_width) + " ") file.write("Amp".center(col_width) + " ") file.write("Phase".center(col_width) + " ") file.write("P (MW)".center(col_width) + " ") file.write("Q (MVAr)".center(col_width) + " ") file.write("P (MW)".center(col_width) + " ") file.write("Q (MVAr)".center(col_width) + " ") file.write("\n") file.write(sep) # Bus rows for bus in buses: file.write(bus.name[:col1_width].ljust(col1_width)) file.write(" %8.3f" % bus.v_magnitude) file.write(" %8.3f" % bus.v_angle) file.write(" %8.2f" % self.case.s_supply(bus).real) file.write(" %8.2f" % self.case.s_supply(bus).imag) file.write(" %8.2f" % self.case.s_demand(bus).real) file.write(" %8.2f" % self.case.s_demand(bus).imag) file.write("\n") # Totals # file.write("..".ljust(col1_width) + " ") # file.write(("..".ljust(col_width) + " ")*2) # file.write(("_"*col_width + " ")*4 + "\n") file.write("..".ljust(col1_width) + " " + "..".ljust(col_width) + " ") file.write("*Total:*".rjust(col_width) + " ") ptot = report.actual_pgen qtot = report.actual_qgen file.write("%8.2f " % ptot) file.write("%8.2f " % qtot) file.write("%8.2f " % report.p_demand) file.write("%8.2f " % report.q_demand) file.write("\n") file.write(sep) del report
[ "def", "write_bus_data", "(", "self", ",", "file", ")", ":", "report", "=", "CaseReport", "(", "self", ".", "case", ")", "buses", "=", "self", ".", "case", ".", "buses", "col_width", "=", "8", "col_width_2", "=", "col_width", "*", "2", "+", "1", "col1_width", "=", "6", "sep", "=", "\"=\"", "*", "6", "+", "\" \"", "+", "(", "\"=\"", "*", "col_width", "+", "\" \"", ")", "*", "6", "+", "\"\\n\"", "file", ".", "write", "(", "sep", ")", "# Line one of column headers", "file", ".", "write", "(", "\"Name\"", ".", "center", "(", "col1_width", ")", "+", "\" \"", ")", "file", ".", "write", "(", "\"Voltage (pu)\"", ".", "center", "(", "col_width_2", ")", "+", "\" \"", ")", "file", ".", "write", "(", "\"Generation\"", ".", "center", "(", "col_width_2", ")", "+", "\" \"", ")", "file", ".", "write", "(", "\"Load\"", ".", "center", "(", "col_width_2", ")", "+", "\" \"", ")", "file", ".", "write", "(", "\"\\n\"", ")", "file", ".", "write", "(", "\"-\"", "*", "col1_width", "+", "\" \"", "+", "(", "\"-\"", "*", "col_width_2", "+", "\" \"", ")", "*", "3", "+", "\"\\n\"", ")", "# Line two of column header", "file", ".", "write", "(", "\"..\"", ".", "ljust", "(", "col1_width", ")", "+", "\" \"", ")", "file", ".", "write", "(", "\"Amp\"", ".", "center", "(", "col_width", ")", "+", "\" \"", ")", "file", ".", "write", "(", "\"Phase\"", ".", "center", "(", "col_width", ")", "+", "\" \"", ")", "file", ".", "write", "(", "\"P (MW)\"", ".", "center", "(", "col_width", ")", "+", "\" \"", ")", "file", ".", "write", "(", "\"Q (MVAr)\"", ".", "center", "(", "col_width", ")", "+", "\" \"", ")", "file", ".", "write", "(", "\"P (MW)\"", ".", "center", "(", "col_width", ")", "+", "\" \"", ")", "file", ".", "write", "(", "\"Q (MVAr)\"", ".", "center", "(", "col_width", ")", "+", "\" \"", ")", "file", ".", "write", "(", "\"\\n\"", ")", "file", ".", "write", "(", "sep", ")", "# Bus rows", "for", "bus", "in", "buses", ":", "file", ".", "write", "(", "bus", ".", "name", "[", ":", "col1_width", "]", ".", "ljust", "(", "col1_width", ")", ")", "file", ".", "write", "(", "\" %8.3f\"", "%", "bus", ".", "v_magnitude", ")", "file", ".", "write", "(", "\" %8.3f\"", "%", "bus", ".", "v_angle", ")", "file", ".", "write", "(", "\" %8.2f\"", "%", "self", ".", "case", ".", "s_supply", "(", "bus", ")", ".", "real", ")", "file", ".", "write", "(", "\" %8.2f\"", "%", "self", ".", "case", ".", "s_supply", "(", "bus", ")", ".", "imag", ")", "file", ".", "write", "(", "\" %8.2f\"", "%", "self", ".", "case", ".", "s_demand", "(", "bus", ")", ".", "real", ")", "file", ".", "write", "(", "\" %8.2f\"", "%", "self", ".", "case", ".", "s_demand", "(", "bus", ")", ".", "imag", ")", "file", ".", "write", "(", "\"\\n\"", ")", "# Totals", "# file.write(\"..\".ljust(col1_width) + \" \")", "# file.write((\"..\".ljust(col_width) + \" \")*2)", "# file.write((\"_\"*col_width + \" \")*4 + \"\\n\")", "file", ".", "write", "(", "\"..\"", ".", "ljust", "(", "col1_width", ")", "+", "\" \"", "+", "\"..\"", ".", "ljust", "(", "col_width", ")", "+", "\" \"", ")", "file", ".", "write", "(", "\"*Total:*\"", ".", "rjust", "(", "col_width", ")", "+", "\" \"", ")", "ptot", "=", "report", ".", "actual_pgen", "qtot", "=", "report", ".", "actual_qgen", "file", ".", "write", "(", "\"%8.2f \"", "%", "ptot", ")", "file", ".", "write", "(", "\"%8.2f \"", "%", "qtot", ")", "file", ".", "write", "(", "\"%8.2f \"", "%", "report", ".", "p_demand", ")", "file", ".", "write", "(", "\"%8.2f \"", "%", "report", ".", "q_demand", ")", "file", ".", "write", "(", "\"\\n\"", ")", "file", ".", "write", "(", "sep", ")", "del", "report" ]
Writes bus data to a ReST table.
[ "Writes", "bus", "data", "to", "a", "ReST", "table", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/rst.py#L87-L146
train
836
rwl/pylon
pylon/io/rst.py
ReSTWriter.write_how_many
def write_how_many(self, file): """ Writes component numbers to a table. """ report = CaseReport(self.case) # Map component labels to attribute names components = [("Bus", "n_buses"), ("Generator", "n_generators"), ("Committed Generator", "n_online_generators"), ("Load", "n_loads"), ("Fixed Load", "n_fixed_loads"), ("Despatchable Load", "n_online_vloads"), ("Shunt", "n_shunts"), ("Branch", "n_branches"), ("Transformer", "n_transformers"), ("Inter-tie", "n_interties"), ("Area", "n_areas") ] # Column 1 width longest = max([len(c[0]) for c in components]) col1_header = "Object" col1_width = longest col2_header = "Quantity" col2_width = len(col2_header) # Row separator sep = "="*col1_width + " " + "="*col2_width + "\n" # Row headers file.write(sep) file.write(col1_header.center(col1_width)) file.write(" ") file.write("%s\n" % col2_header.center(col2_width)) file.write(sep) # Rows for label, attr in components: col2_value = str(getattr(report, attr)) file.write("%s %s\n" % (label.ljust(col1_width), col2_value.rjust(col2_width))) else: file.write(sep) file.write("\n") del report
python
def write_how_many(self, file): """ Writes component numbers to a table. """ report = CaseReport(self.case) # Map component labels to attribute names components = [("Bus", "n_buses"), ("Generator", "n_generators"), ("Committed Generator", "n_online_generators"), ("Load", "n_loads"), ("Fixed Load", "n_fixed_loads"), ("Despatchable Load", "n_online_vloads"), ("Shunt", "n_shunts"), ("Branch", "n_branches"), ("Transformer", "n_transformers"), ("Inter-tie", "n_interties"), ("Area", "n_areas") ] # Column 1 width longest = max([len(c[0]) for c in components]) col1_header = "Object" col1_width = longest col2_header = "Quantity" col2_width = len(col2_header) # Row separator sep = "="*col1_width + " " + "="*col2_width + "\n" # Row headers file.write(sep) file.write(col1_header.center(col1_width)) file.write(" ") file.write("%s\n" % col2_header.center(col2_width)) file.write(sep) # Rows for label, attr in components: col2_value = str(getattr(report, attr)) file.write("%s %s\n" % (label.ljust(col1_width), col2_value.rjust(col2_width))) else: file.write(sep) file.write("\n") del report
[ "def", "write_how_many", "(", "self", ",", "file", ")", ":", "report", "=", "CaseReport", "(", "self", ".", "case", ")", "# Map component labels to attribute names", "components", "=", "[", "(", "\"Bus\"", ",", "\"n_buses\"", ")", ",", "(", "\"Generator\"", ",", "\"n_generators\"", ")", ",", "(", "\"Committed Generator\"", ",", "\"n_online_generators\"", ")", ",", "(", "\"Load\"", ",", "\"n_loads\"", ")", ",", "(", "\"Fixed Load\"", ",", "\"n_fixed_loads\"", ")", ",", "(", "\"Despatchable Load\"", ",", "\"n_online_vloads\"", ")", ",", "(", "\"Shunt\"", ",", "\"n_shunts\"", ")", ",", "(", "\"Branch\"", ",", "\"n_branches\"", ")", ",", "(", "\"Transformer\"", ",", "\"n_transformers\"", ")", ",", "(", "\"Inter-tie\"", ",", "\"n_interties\"", ")", ",", "(", "\"Area\"", ",", "\"n_areas\"", ")", "]", "# Column 1 width", "longest", "=", "max", "(", "[", "len", "(", "c", "[", "0", "]", ")", "for", "c", "in", "components", "]", ")", "col1_header", "=", "\"Object\"", "col1_width", "=", "longest", "col2_header", "=", "\"Quantity\"", "col2_width", "=", "len", "(", "col2_header", ")", "# Row separator", "sep", "=", "\"=\"", "*", "col1_width", "+", "\" \"", "+", "\"=\"", "*", "col2_width", "+", "\"\\n\"", "# Row headers", "file", ".", "write", "(", "sep", ")", "file", ".", "write", "(", "col1_header", ".", "center", "(", "col1_width", ")", ")", "file", ".", "write", "(", "\" \"", ")", "file", ".", "write", "(", "\"%s\\n\"", "%", "col2_header", ".", "center", "(", "col2_width", ")", ")", "file", ".", "write", "(", "sep", ")", "# Rows", "for", "label", ",", "attr", "in", "components", ":", "col2_value", "=", "str", "(", "getattr", "(", "report", ",", "attr", ")", ")", "file", ".", "write", "(", "\"%s %s\\n\"", "%", "(", "label", ".", "ljust", "(", "col1_width", ")", ",", "col2_value", ".", "rjust", "(", "col2_width", ")", ")", ")", "else", ":", "file", ".", "write", "(", "sep", ")", "file", ".", "write", "(", "\"\\n\"", ")", "del", "report" ]
Writes component numbers to a table.
[ "Writes", "component", "numbers", "to", "a", "table", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/rst.py#L312-L355
train
837
rwl/pylon
pylon/io/rst.py
ReSTWriter.write_min_max
def write_min_max(self, file): """ Writes minimum and maximum values to a table. """ report = CaseReport(self.case) col1_header = "Attribute" col1_width = 19 col2_header = "Minimum" col3_header = "Maximum" col_width = 22 sep = "="*col1_width +" "+ "="*col_width +" "+ "="*col_width + "\n" # Row headers file.write(sep) file.write("%s" % col1_header.center(col1_width)) file.write(" ") file.write("%s" % col2_header.center(col_width)) file.write(" ") file.write("%s" % col3_header.center(col_width)) file.write("\n") file.write(sep) # Rows min_val, min_i = getattr(report, "min_v_magnitude") max_val, max_i = getattr(report, "max_v_magnitude") file.write("%s %7.3f p.u. @ bus %2d %7.3f p.u. @ bus %2d\n" % ("Voltage Amplitude".ljust(col1_width), min_val, min_i, max_val, max_i)) min_val, min_i = getattr(report, "min_v_angle") max_val, max_i = getattr(report, "max_v_angle") file.write("%s %16.3f %16.3f\n" % ("Voltage Phase Angle".ljust(col1_width), min_val, max_val)) file.write(sep) file.write("\n") del report
python
def write_min_max(self, file): """ Writes minimum and maximum values to a table. """ report = CaseReport(self.case) col1_header = "Attribute" col1_width = 19 col2_header = "Minimum" col3_header = "Maximum" col_width = 22 sep = "="*col1_width +" "+ "="*col_width +" "+ "="*col_width + "\n" # Row headers file.write(sep) file.write("%s" % col1_header.center(col1_width)) file.write(" ") file.write("%s" % col2_header.center(col_width)) file.write(" ") file.write("%s" % col3_header.center(col_width)) file.write("\n") file.write(sep) # Rows min_val, min_i = getattr(report, "min_v_magnitude") max_val, max_i = getattr(report, "max_v_magnitude") file.write("%s %7.3f p.u. @ bus %2d %7.3f p.u. @ bus %2d\n" % ("Voltage Amplitude".ljust(col1_width), min_val, min_i, max_val, max_i)) min_val, min_i = getattr(report, "min_v_angle") max_val, max_i = getattr(report, "max_v_angle") file.write("%s %16.3f %16.3f\n" % ("Voltage Phase Angle".ljust(col1_width), min_val, max_val)) file.write(sep) file.write("\n") del report
[ "def", "write_min_max", "(", "self", ",", "file", ")", ":", "report", "=", "CaseReport", "(", "self", ".", "case", ")", "col1_header", "=", "\"Attribute\"", "col1_width", "=", "19", "col2_header", "=", "\"Minimum\"", "col3_header", "=", "\"Maximum\"", "col_width", "=", "22", "sep", "=", "\"=\"", "*", "col1_width", "+", "\" \"", "+", "\"=\"", "*", "col_width", "+", "\" \"", "+", "\"=\"", "*", "col_width", "+", "\"\\n\"", "# Row headers", "file", ".", "write", "(", "sep", ")", "file", ".", "write", "(", "\"%s\"", "%", "col1_header", ".", "center", "(", "col1_width", ")", ")", "file", ".", "write", "(", "\" \"", ")", "file", ".", "write", "(", "\"%s\"", "%", "col2_header", ".", "center", "(", "col_width", ")", ")", "file", ".", "write", "(", "\" \"", ")", "file", ".", "write", "(", "\"%s\"", "%", "col3_header", ".", "center", "(", "col_width", ")", ")", "file", ".", "write", "(", "\"\\n\"", ")", "file", ".", "write", "(", "sep", ")", "# Rows", "min_val", ",", "min_i", "=", "getattr", "(", "report", ",", "\"min_v_magnitude\"", ")", "max_val", ",", "max_i", "=", "getattr", "(", "report", ",", "\"max_v_magnitude\"", ")", "file", ".", "write", "(", "\"%s %7.3f p.u. @ bus %2d %7.3f p.u. @ bus %2d\\n\"", "%", "(", "\"Voltage Amplitude\"", ".", "ljust", "(", "col1_width", ")", ",", "min_val", ",", "min_i", ",", "max_val", ",", "max_i", ")", ")", "min_val", ",", "min_i", "=", "getattr", "(", "report", ",", "\"min_v_angle\"", ")", "max_val", ",", "max_i", "=", "getattr", "(", "report", ",", "\"max_v_angle\"", ")", "file", ".", "write", "(", "\"%s %16.3f %16.3f\\n\"", "%", "(", "\"Voltage Phase Angle\"", ".", "ljust", "(", "col1_width", ")", ",", "min_val", ",", "max_val", ")", ")", "file", ".", "write", "(", "sep", ")", "file", ".", "write", "(", "\"\\n\"", ")", "del", "report" ]
Writes minimum and maximum values to a table.
[ "Writes", "minimum", "and", "maximum", "values", "to", "a", "table", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/rst.py#L438-L478
train
838
rwl/pylon
pylon/io/parsing_util.py
make_unique_name
def make_unique_name(base, existing=[], format="%s_%s"): """ Return a name, unique within a context, based on the specified name. @param base: the desired base name of the generated unique name. @param existing: a sequence of the existing names to avoid returning. @param format: a formatting specification for how the name is made unique. """ count = 2 name = base while name in existing: name = format % (base, count) count += 1 return name
python
def make_unique_name(base, existing=[], format="%s_%s"): """ Return a name, unique within a context, based on the specified name. @param base: the desired base name of the generated unique name. @param existing: a sequence of the existing names to avoid returning. @param format: a formatting specification for how the name is made unique. """ count = 2 name = base while name in existing: name = format % (base, count) count += 1 return name
[ "def", "make_unique_name", "(", "base", ",", "existing", "=", "[", "]", ",", "format", "=", "\"%s_%s\"", ")", ":", "count", "=", "2", "name", "=", "base", "while", "name", "in", "existing", ":", "name", "=", "format", "%", "(", "base", ",", "count", ")", "count", "+=", "1", "return", "name" ]
Return a name, unique within a context, based on the specified name. @param base: the desired base name of the generated unique name. @param existing: a sequence of the existing names to avoid returning. @param format: a formatting specification for how the name is made unique.
[ "Return", "a", "name", "unique", "within", "a", "context", "based", "on", "the", "specified", "name", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/parsing_util.py#L167-L180
train
839
pymoca/pymoca
setup.py
call_antlr4
def call_antlr4(arg): "calls antlr4 on grammar file" # pylint: disable=unused-argument, unused-variable antlr_path = os.path.join(ROOT_DIR, "java", "antlr-4.7-complete.jar") classpath = os.pathsep.join([".", "{:s}".format(antlr_path), "$CLASSPATH"]) generated = os.path.join(ROOT_DIR, 'src', 'pymoca', 'generated') cmd = "java -Xmx500M -cp \"{classpath:s}\" org.antlr.v4.Tool {arg:s}" \ " -o {generated:s} -visitor -Dlanguage=Python3".format(**locals()) print(cmd) proc = subprocess.Popen(cmd.split(), cwd=os.path.join(ROOT_DIR, 'src', 'pymoca')) proc.communicate() with open(os.path.join(generated, '__init__.py'), 'w') as fid: fid.write('')
python
def call_antlr4(arg): "calls antlr4 on grammar file" # pylint: disable=unused-argument, unused-variable antlr_path = os.path.join(ROOT_DIR, "java", "antlr-4.7-complete.jar") classpath = os.pathsep.join([".", "{:s}".format(antlr_path), "$CLASSPATH"]) generated = os.path.join(ROOT_DIR, 'src', 'pymoca', 'generated') cmd = "java -Xmx500M -cp \"{classpath:s}\" org.antlr.v4.Tool {arg:s}" \ " -o {generated:s} -visitor -Dlanguage=Python3".format(**locals()) print(cmd) proc = subprocess.Popen(cmd.split(), cwd=os.path.join(ROOT_DIR, 'src', 'pymoca')) proc.communicate() with open(os.path.join(generated, '__init__.py'), 'w') as fid: fid.write('')
[ "def", "call_antlr4", "(", "arg", ")", ":", "# pylint: disable=unused-argument, unused-variable", "antlr_path", "=", "os", ".", "path", ".", "join", "(", "ROOT_DIR", ",", "\"java\"", ",", "\"antlr-4.7-complete.jar\"", ")", "classpath", "=", "os", ".", "pathsep", ".", "join", "(", "[", "\".\"", ",", "\"{:s}\"", ".", "format", "(", "antlr_path", ")", ",", "\"$CLASSPATH\"", "]", ")", "generated", "=", "os", ".", "path", ".", "join", "(", "ROOT_DIR", ",", "'src'", ",", "'pymoca'", ",", "'generated'", ")", "cmd", "=", "\"java -Xmx500M -cp \\\"{classpath:s}\\\" org.antlr.v4.Tool {arg:s}\"", "\" -o {generated:s} -visitor -Dlanguage=Python3\"", ".", "format", "(", "*", "*", "locals", "(", ")", ")", "print", "(", "cmd", ")", "proc", "=", "subprocess", ".", "Popen", "(", "cmd", ".", "split", "(", ")", ",", "cwd", "=", "os", ".", "path", ".", "join", "(", "ROOT_DIR", ",", "'src'", ",", "'pymoca'", ")", ")", "proc", ".", "communicate", "(", ")", "with", "open", "(", "os", ".", "path", ".", "join", "(", "generated", ",", "'__init__.py'", ")", ",", "'w'", ")", "as", "fid", ":", "fid", ".", "write", "(", "''", ")" ]
calls antlr4 on grammar file
[ "calls", "antlr4", "on", "grammar", "file" ]
14b5eb7425e96689de6cc5c10f400895d586a978
https://github.com/pymoca/pymoca/blob/14b5eb7425e96689de6cc5c10f400895d586a978/setup.py#L74-L86
train
840
pymoca/pymoca
setup.py
setup_package
def setup_package(): """ Setup the package. """ with open('requirements.txt', 'r') as req_file: install_reqs = req_file.read().split('\n') cmdclass_ = {'antlr': AntlrBuildCommand} cmdclass_.update(versioneer.get_cmdclass()) setup( version=versioneer.get_version(), name='pymoca', maintainer="James Goppert", maintainer_email="[email protected]", description=DOCLINES[0], long_description="\n".join(DOCLINES[2:]), url='https://github.com/pymoca/pymoca', author='James Goppert', author_email='[email protected]', download_url='https://github.com/pymoca/pymoca', license='BSD', classifiers=[_f for _f in CLASSIFIERS.split('\n') if _f], platforms=["Windows", "Linux", "Solaris", "Mac OS-X", "Unix"], install_requires=install_reqs, tests_require=['coverage >= 3.7.1', 'nose >= 1.3.1'], test_suite='nose.collector', python_requires='>=3.5', packages=find_packages("src"), package_dir={"": "src"}, include_package_data=True, cmdclass=cmdclass_ )
python
def setup_package(): """ Setup the package. """ with open('requirements.txt', 'r') as req_file: install_reqs = req_file.read().split('\n') cmdclass_ = {'antlr': AntlrBuildCommand} cmdclass_.update(versioneer.get_cmdclass()) setup( version=versioneer.get_version(), name='pymoca', maintainer="James Goppert", maintainer_email="[email protected]", description=DOCLINES[0], long_description="\n".join(DOCLINES[2:]), url='https://github.com/pymoca/pymoca', author='James Goppert', author_email='[email protected]', download_url='https://github.com/pymoca/pymoca', license='BSD', classifiers=[_f for _f in CLASSIFIERS.split('\n') if _f], platforms=["Windows", "Linux", "Solaris", "Mac OS-X", "Unix"], install_requires=install_reqs, tests_require=['coverage >= 3.7.1', 'nose >= 1.3.1'], test_suite='nose.collector', python_requires='>=3.5', packages=find_packages("src"), package_dir={"": "src"}, include_package_data=True, cmdclass=cmdclass_ )
[ "def", "setup_package", "(", ")", ":", "with", "open", "(", "'requirements.txt'", ",", "'r'", ")", "as", "req_file", ":", "install_reqs", "=", "req_file", ".", "read", "(", ")", ".", "split", "(", "'\\n'", ")", "cmdclass_", "=", "{", "'antlr'", ":", "AntlrBuildCommand", "}", "cmdclass_", ".", "update", "(", "versioneer", ".", "get_cmdclass", "(", ")", ")", "setup", "(", "version", "=", "versioneer", ".", "get_version", "(", ")", ",", "name", "=", "'pymoca'", ",", "maintainer", "=", "\"James Goppert\"", ",", "maintainer_email", "=", "\"[email protected]\"", ",", "description", "=", "DOCLINES", "[", "0", "]", ",", "long_description", "=", "\"\\n\"", ".", "join", "(", "DOCLINES", "[", "2", ":", "]", ")", ",", "url", "=", "'https://github.com/pymoca/pymoca'", ",", "author", "=", "'James Goppert'", ",", "author_email", "=", "'[email protected]'", ",", "download_url", "=", "'https://github.com/pymoca/pymoca'", ",", "license", "=", "'BSD'", ",", "classifiers", "=", "[", "_f", "for", "_f", "in", "CLASSIFIERS", ".", "split", "(", "'\\n'", ")", "if", "_f", "]", ",", "platforms", "=", "[", "\"Windows\"", ",", "\"Linux\"", ",", "\"Solaris\"", ",", "\"Mac OS-X\"", ",", "\"Unix\"", "]", ",", "install_requires", "=", "install_reqs", ",", "tests_require", "=", "[", "'coverage >= 3.7.1'", ",", "'nose >= 1.3.1'", "]", ",", "test_suite", "=", "'nose.collector'", ",", "python_requires", "=", "'>=3.5'", ",", "packages", "=", "find_packages", "(", "\"src\"", ")", ",", "package_dir", "=", "{", "\"\"", ":", "\"src\"", "}", ",", "include_package_data", "=", "True", ",", "cmdclass", "=", "cmdclass_", ")" ]
Setup the package.
[ "Setup", "the", "package", "." ]
14b5eb7425e96689de6cc5c10f400895d586a978
https://github.com/pymoca/pymoca/blob/14b5eb7425e96689de6cc5c10f400895d586a978/setup.py#L89-L121
train
841
rwl/pylon
contrib/pylontk.py
CaseProperties.body
def body(self, frame): """ Creates the dialog body. Returns the widget that should have initial focus. """ master = Frame(self) master.pack(padx=5, pady=0, expand=1, fill=BOTH) title = Label(master, text="Buses") title.pack(side=TOP) bus_lb = self.bus_lb = Listbox(master, selectmode=SINGLE, width=10) bus_lb.pack(side=LEFT) for bus in self.case.buses: bus_lb.insert(END, bus.name) bus_lb.bind("<<ListboxSelect>>", self.on_bus) self.bus_params = BusProperties(master) return bus_lb
python
def body(self, frame): """ Creates the dialog body. Returns the widget that should have initial focus. """ master = Frame(self) master.pack(padx=5, pady=0, expand=1, fill=BOTH) title = Label(master, text="Buses") title.pack(side=TOP) bus_lb = self.bus_lb = Listbox(master, selectmode=SINGLE, width=10) bus_lb.pack(side=LEFT) for bus in self.case.buses: bus_lb.insert(END, bus.name) bus_lb.bind("<<ListboxSelect>>", self.on_bus) self.bus_params = BusProperties(master) return bus_lb
[ "def", "body", "(", "self", ",", "frame", ")", ":", "master", "=", "Frame", "(", "self", ")", "master", ".", "pack", "(", "padx", "=", "5", ",", "pady", "=", "0", ",", "expand", "=", "1", ",", "fill", "=", "BOTH", ")", "title", "=", "Label", "(", "master", ",", "text", "=", "\"Buses\"", ")", "title", ".", "pack", "(", "side", "=", "TOP", ")", "bus_lb", "=", "self", ".", "bus_lb", "=", "Listbox", "(", "master", ",", "selectmode", "=", "SINGLE", ",", "width", "=", "10", ")", "bus_lb", ".", "pack", "(", "side", "=", "LEFT", ")", "for", "bus", "in", "self", ".", "case", ".", "buses", ":", "bus_lb", ".", "insert", "(", "END", ",", "bus", ".", "name", ")", "bus_lb", ".", "bind", "(", "\"<<ListboxSelect>>\"", ",", "self", ".", "on_bus", ")", "self", ".", "bus_params", "=", "BusProperties", "(", "master", ")", "return", "bus_lb" ]
Creates the dialog body. Returns the widget that should have initial focus.
[ "Creates", "the", "dialog", "body", ".", "Returns", "the", "widget", "that", "should", "have", "initial", "focus", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/pylontk.py#L538-L558
train
842
rwl/pylon
pylon/opf.py
OPF.solve
def solve(self, solver_klass=None): """ Solves an optimal power flow and returns a results dictionary. """ # Start the clock. t0 = time() # Build an OPF model with variables and constraints. om = self._construct_opf_model(self.case) if om is None: return {"converged": False, "output": {"message": "No Ref Bus."}} # Call the specific solver. # if self.opt["verbose"]: # print '\nPYLON Version %s, %s', "0.4.2", "April 2010" if solver_klass is not None: result = solver_klass(om, opt=self.opt).solve() elif self.dc: # if self.opt["verbose"]: # print ' -- DC Optimal Power Flow\n' result = DCOPFSolver(om, opt=self.opt).solve() else: # if self.opt["verbose"]: # print ' -- AC Optimal Power Flow\n' result = PIPSSolver(om, opt=self.opt).solve() result["elapsed"] = time() - t0 if self.opt.has_key("verbose"): if self.opt["verbose"]: logger.info("OPF completed in %.3fs." % result["elapsed"]) return result
python
def solve(self, solver_klass=None): """ Solves an optimal power flow and returns a results dictionary. """ # Start the clock. t0 = time() # Build an OPF model with variables and constraints. om = self._construct_opf_model(self.case) if om is None: return {"converged": False, "output": {"message": "No Ref Bus."}} # Call the specific solver. # if self.opt["verbose"]: # print '\nPYLON Version %s, %s', "0.4.2", "April 2010" if solver_klass is not None: result = solver_klass(om, opt=self.opt).solve() elif self.dc: # if self.opt["verbose"]: # print ' -- DC Optimal Power Flow\n' result = DCOPFSolver(om, opt=self.opt).solve() else: # if self.opt["verbose"]: # print ' -- AC Optimal Power Flow\n' result = PIPSSolver(om, opt=self.opt).solve() result["elapsed"] = time() - t0 if self.opt.has_key("verbose"): if self.opt["verbose"]: logger.info("OPF completed in %.3fs." % result["elapsed"]) return result
[ "def", "solve", "(", "self", ",", "solver_klass", "=", "None", ")", ":", "# Start the clock.", "t0", "=", "time", "(", ")", "# Build an OPF model with variables and constraints.", "om", "=", "self", ".", "_construct_opf_model", "(", "self", ".", "case", ")", "if", "om", "is", "None", ":", "return", "{", "\"converged\"", ":", "False", ",", "\"output\"", ":", "{", "\"message\"", ":", "\"No Ref Bus.\"", "}", "}", "# Call the specific solver.", "# if self.opt[\"verbose\"]:", "# print '\\nPYLON Version %s, %s', \"0.4.2\", \"April 2010\"", "if", "solver_klass", "is", "not", "None", ":", "result", "=", "solver_klass", "(", "om", ",", "opt", "=", "self", ".", "opt", ")", ".", "solve", "(", ")", "elif", "self", ".", "dc", ":", "# if self.opt[\"verbose\"]:", "# print ' -- DC Optimal Power Flow\\n'", "result", "=", "DCOPFSolver", "(", "om", ",", "opt", "=", "self", ".", "opt", ")", ".", "solve", "(", ")", "else", ":", "# if self.opt[\"verbose\"]:", "# print ' -- AC Optimal Power Flow\\n'", "result", "=", "PIPSSolver", "(", "om", ",", "opt", "=", "self", ".", "opt", ")", ".", "solve", "(", ")", "result", "[", "\"elapsed\"", "]", "=", "time", "(", ")", "-", "t0", "if", "self", ".", "opt", ".", "has_key", "(", "\"verbose\"", ")", ":", "if", "self", ".", "opt", "[", "\"verbose\"", "]", ":", "logger", ".", "info", "(", "\"OPF completed in %.3fs.\"", "%", "result", "[", "\"elapsed\"", "]", ")", "return", "result" ]
Solves an optimal power flow and returns a results dictionary.
[ "Solves", "an", "optimal", "power", "flow", "and", "returns", "a", "results", "dictionary", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L79-L110
train
843
rwl/pylon
pylon/opf.py
OPF._construct_opf_model
def _construct_opf_model(self, case): """ Returns an OPF model. """ # Zero the case result attributes. self.case.reset() base_mva = case.base_mva # Check for one reference bus. oneref, refs = self._ref_check(case) if not oneref: #return {"status": "error"} None # Remove isolated components. bs, ln, gn = self._remove_isolated(case) # Update bus indexes. self.case.index_buses(bs) # Convert single-block piecewise-linear costs into linear polynomial. gn = self._pwl1_to_poly(gn) # Set-up initial problem variables. Va = self._get_voltage_angle_var(refs, bs) Pg = self._get_pgen_var(gn, base_mva) if self.dc: # DC model. # Get the susceptance matrices and phase shift injection vectors. B, Bf, Pbusinj, Pfinj = self.case.makeBdc(bs, ln) # Power mismatch constraints (B*Va + Pg = Pd). Pmis = self._power_mismatch_dc(bs, gn, B, Pbusinj, base_mva) # Branch flow limit constraints. Pf, Pt = self._branch_flow_dc(ln, Bf, Pfinj, base_mva) else: # Set-up additional AC-OPF problem variables. Vm = self._get_voltage_magnitude_var(bs, gn) Qg = self._get_qgen_var(gn, base_mva) Pmis, Qmis, Sf, St = self._nln_constraints(len(bs), len(ln)) vl = self._const_pf_constraints(gn, base_mva) # TODO: Generator PQ capability curve constraints. # PQh, PQl = self._pq_capability_curve_constraints(gn) # Branch voltage angle difference limits. ang = self._voltage_angle_diff_limit(bs, ln) if self.dc: vars = [Va, Pg] constraints = [Pmis, Pf, Pt, ang] else: vars = [Va, Vm, Pg, Qg] constraints = [Pmis, Qmis, Sf, St, #PQh, PQL, vl, ang] # Piece-wise linear generator cost constraints. y, ycon = self._pwl_gen_costs(gn, base_mva) if ycon is not None: vars.append(y) constraints.append(ycon) # Add variables and constraints to the OPF model object. opf = OPFModel(case) opf.add_vars(vars) opf.add_constraints(constraints) if self.dc: # user data opf._Bf = Bf opf._Pfinj = Pfinj return opf
python
def _construct_opf_model(self, case): """ Returns an OPF model. """ # Zero the case result attributes. self.case.reset() base_mva = case.base_mva # Check for one reference bus. oneref, refs = self._ref_check(case) if not oneref: #return {"status": "error"} None # Remove isolated components. bs, ln, gn = self._remove_isolated(case) # Update bus indexes. self.case.index_buses(bs) # Convert single-block piecewise-linear costs into linear polynomial. gn = self._pwl1_to_poly(gn) # Set-up initial problem variables. Va = self._get_voltage_angle_var(refs, bs) Pg = self._get_pgen_var(gn, base_mva) if self.dc: # DC model. # Get the susceptance matrices and phase shift injection vectors. B, Bf, Pbusinj, Pfinj = self.case.makeBdc(bs, ln) # Power mismatch constraints (B*Va + Pg = Pd). Pmis = self._power_mismatch_dc(bs, gn, B, Pbusinj, base_mva) # Branch flow limit constraints. Pf, Pt = self._branch_flow_dc(ln, Bf, Pfinj, base_mva) else: # Set-up additional AC-OPF problem variables. Vm = self._get_voltage_magnitude_var(bs, gn) Qg = self._get_qgen_var(gn, base_mva) Pmis, Qmis, Sf, St = self._nln_constraints(len(bs), len(ln)) vl = self._const_pf_constraints(gn, base_mva) # TODO: Generator PQ capability curve constraints. # PQh, PQl = self._pq_capability_curve_constraints(gn) # Branch voltage angle difference limits. ang = self._voltage_angle_diff_limit(bs, ln) if self.dc: vars = [Va, Pg] constraints = [Pmis, Pf, Pt, ang] else: vars = [Va, Vm, Pg, Qg] constraints = [Pmis, Qmis, Sf, St, #PQh, PQL, vl, ang] # Piece-wise linear generator cost constraints. y, ycon = self._pwl_gen_costs(gn, base_mva) if ycon is not None: vars.append(y) constraints.append(ycon) # Add variables and constraints to the OPF model object. opf = OPFModel(case) opf.add_vars(vars) opf.add_constraints(constraints) if self.dc: # user data opf._Bf = Bf opf._Pfinj = Pfinj return opf
[ "def", "_construct_opf_model", "(", "self", ",", "case", ")", ":", "# Zero the case result attributes.", "self", ".", "case", ".", "reset", "(", ")", "base_mva", "=", "case", ".", "base_mva", "# Check for one reference bus.", "oneref", ",", "refs", "=", "self", ".", "_ref_check", "(", "case", ")", "if", "not", "oneref", ":", "#return {\"status\": \"error\"}", "None", "# Remove isolated components.", "bs", ",", "ln", ",", "gn", "=", "self", ".", "_remove_isolated", "(", "case", ")", "# Update bus indexes.", "self", ".", "case", ".", "index_buses", "(", "bs", ")", "# Convert single-block piecewise-linear costs into linear polynomial.", "gn", "=", "self", ".", "_pwl1_to_poly", "(", "gn", ")", "# Set-up initial problem variables.", "Va", "=", "self", ".", "_get_voltage_angle_var", "(", "refs", ",", "bs", ")", "Pg", "=", "self", ".", "_get_pgen_var", "(", "gn", ",", "base_mva", ")", "if", "self", ".", "dc", ":", "# DC model.", "# Get the susceptance matrices and phase shift injection vectors.", "B", ",", "Bf", ",", "Pbusinj", ",", "Pfinj", "=", "self", ".", "case", ".", "makeBdc", "(", "bs", ",", "ln", ")", "# Power mismatch constraints (B*Va + Pg = Pd).", "Pmis", "=", "self", ".", "_power_mismatch_dc", "(", "bs", ",", "gn", ",", "B", ",", "Pbusinj", ",", "base_mva", ")", "# Branch flow limit constraints.", "Pf", ",", "Pt", "=", "self", ".", "_branch_flow_dc", "(", "ln", ",", "Bf", ",", "Pfinj", ",", "base_mva", ")", "else", ":", "# Set-up additional AC-OPF problem variables.", "Vm", "=", "self", ".", "_get_voltage_magnitude_var", "(", "bs", ",", "gn", ")", "Qg", "=", "self", ".", "_get_qgen_var", "(", "gn", ",", "base_mva", ")", "Pmis", ",", "Qmis", ",", "Sf", ",", "St", "=", "self", ".", "_nln_constraints", "(", "len", "(", "bs", ")", ",", "len", "(", "ln", ")", ")", "vl", "=", "self", ".", "_const_pf_constraints", "(", "gn", ",", "base_mva", ")", "# TODO: Generator PQ capability curve constraints.", "# PQh, PQl = self._pq_capability_curve_constraints(gn)", "# Branch voltage angle difference limits.", "ang", "=", "self", ".", "_voltage_angle_diff_limit", "(", "bs", ",", "ln", ")", "if", "self", ".", "dc", ":", "vars", "=", "[", "Va", ",", "Pg", "]", "constraints", "=", "[", "Pmis", ",", "Pf", ",", "Pt", ",", "ang", "]", "else", ":", "vars", "=", "[", "Va", ",", "Vm", ",", "Pg", ",", "Qg", "]", "constraints", "=", "[", "Pmis", ",", "Qmis", ",", "Sf", ",", "St", ",", "#PQh, PQL,", "vl", ",", "ang", "]", "# Piece-wise linear generator cost constraints.", "y", ",", "ycon", "=", "self", ".", "_pwl_gen_costs", "(", "gn", ",", "base_mva", ")", "if", "ycon", "is", "not", "None", ":", "vars", ".", "append", "(", "y", ")", "constraints", ".", "append", "(", "ycon", ")", "# Add variables and constraints to the OPF model object.", "opf", "=", "OPFModel", "(", "case", ")", "opf", ".", "add_vars", "(", "vars", ")", "opf", ".", "add_constraints", "(", "constraints", ")", "if", "self", ".", "dc", ":", "# user data", "opf", ".", "_Bf", "=", "Bf", "opf", ".", "_Pfinj", "=", "Pfinj", "return", "opf" ]
Returns an OPF model.
[ "Returns", "an", "OPF", "model", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L116-L190
train
844
rwl/pylon
pylon/opf.py
OPF._ref_check
def _ref_check(self, case): """ Checks that there is only one reference bus. """ refs = [bus._i for bus in case.buses if bus.type == REFERENCE] if len(refs) == 1: return True, refs else: logger.error("OPF requires a single reference bus.") return False, refs
python
def _ref_check(self, case): """ Checks that there is only one reference bus. """ refs = [bus._i for bus in case.buses if bus.type == REFERENCE] if len(refs) == 1: return True, refs else: logger.error("OPF requires a single reference bus.") return False, refs
[ "def", "_ref_check", "(", "self", ",", "case", ")", ":", "refs", "=", "[", "bus", ".", "_i", "for", "bus", "in", "case", ".", "buses", "if", "bus", ".", "type", "==", "REFERENCE", "]", "if", "len", "(", "refs", ")", "==", "1", ":", "return", "True", ",", "refs", "else", ":", "logger", ".", "error", "(", "\"OPF requires a single reference bus.\"", ")", "return", "False", ",", "refs" ]
Checks that there is only one reference bus.
[ "Checks", "that", "there", "is", "only", "one", "reference", "bus", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L193-L202
train
845
rwl/pylon
pylon/opf.py
OPF._remove_isolated
def _remove_isolated(self, case): """ Returns non-isolated case components. """ # case.deactivate_isolated() buses = case.connected_buses branches = case.online_branches gens = case.online_generators return buses, branches, gens
python
def _remove_isolated(self, case): """ Returns non-isolated case components. """ # case.deactivate_isolated() buses = case.connected_buses branches = case.online_branches gens = case.online_generators return buses, branches, gens
[ "def", "_remove_isolated", "(", "self", ",", "case", ")", ":", "# case.deactivate_isolated()", "buses", "=", "case", ".", "connected_buses", "branches", "=", "case", ".", "online_branches", "gens", "=", "case", ".", "online_generators", "return", "buses", ",", "branches", ",", "gens" ]
Returns non-isolated case components.
[ "Returns", "non", "-", "isolated", "case", "components", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L205-L213
train
846
rwl/pylon
pylon/opf.py
OPF._pwl1_to_poly
def _pwl1_to_poly(self, generators): """ Converts single-block piecewise-linear costs into linear polynomial. """ for g in generators: if (g.pcost_model == PW_LINEAR) and (len(g.p_cost) == 2): g.pwl_to_poly() return generators
python
def _pwl1_to_poly(self, generators): """ Converts single-block piecewise-linear costs into linear polynomial. """ for g in generators: if (g.pcost_model == PW_LINEAR) and (len(g.p_cost) == 2): g.pwl_to_poly() return generators
[ "def", "_pwl1_to_poly", "(", "self", ",", "generators", ")", ":", "for", "g", "in", "generators", ":", "if", "(", "g", ".", "pcost_model", "==", "PW_LINEAR", ")", "and", "(", "len", "(", "g", ".", "p_cost", ")", "==", "2", ")", ":", "g", ".", "pwl_to_poly", "(", ")", "return", "generators" ]
Converts single-block piecewise-linear costs into linear polynomial.
[ "Converts", "single", "-", "block", "piecewise", "-", "linear", "costs", "into", "linear", "polynomial", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L216-L224
train
847
rwl/pylon
pylon/opf.py
OPF._get_voltage_angle_var
def _get_voltage_angle_var(self, refs, buses): """ Returns the voltage angle variable set. """ Va = array([b.v_angle * (pi / 180.0) for b in buses]) Vau = Inf * ones(len(buses)) Val = -Vau Vau[refs] = Va[refs] Val[refs] = Va[refs] return Variable("Va", len(buses), Va, Val, Vau)
python
def _get_voltage_angle_var(self, refs, buses): """ Returns the voltage angle variable set. """ Va = array([b.v_angle * (pi / 180.0) for b in buses]) Vau = Inf * ones(len(buses)) Val = -Vau Vau[refs] = Va[refs] Val[refs] = Va[refs] return Variable("Va", len(buses), Va, Val, Vau)
[ "def", "_get_voltage_angle_var", "(", "self", ",", "refs", ",", "buses", ")", ":", "Va", "=", "array", "(", "[", "b", ".", "v_angle", "*", "(", "pi", "/", "180.0", ")", "for", "b", "in", "buses", "]", ")", "Vau", "=", "Inf", "*", "ones", "(", "len", "(", "buses", ")", ")", "Val", "=", "-", "Vau", "Vau", "[", "refs", "]", "=", "Va", "[", "refs", "]", "Val", "[", "refs", "]", "=", "Va", "[", "refs", "]", "return", "Variable", "(", "\"Va\"", ",", "len", "(", "buses", ")", ",", "Va", ",", "Val", ",", "Vau", ")" ]
Returns the voltage angle variable set.
[ "Returns", "the", "voltage", "angle", "variable", "set", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L230-L240
train
848
rwl/pylon
pylon/opf.py
OPF._get_voltage_magnitude_var
def _get_voltage_magnitude_var(self, buses, generators): """ Returns the voltage magnitude variable set. """ Vm = array([b.v_magnitude for b in buses]) # For buses with generators initialise Vm from gen data. for g in generators: Vm[g.bus._i] = g.v_magnitude Vmin = array([b.v_min for b in buses]) Vmax = array([b.v_max for b in buses]) return Variable("Vm", len(buses), Vm, Vmin, Vmax)
python
def _get_voltage_magnitude_var(self, buses, generators): """ Returns the voltage magnitude variable set. """ Vm = array([b.v_magnitude for b in buses]) # For buses with generators initialise Vm from gen data. for g in generators: Vm[g.bus._i] = g.v_magnitude Vmin = array([b.v_min for b in buses]) Vmax = array([b.v_max for b in buses]) return Variable("Vm", len(buses), Vm, Vmin, Vmax)
[ "def", "_get_voltage_magnitude_var", "(", "self", ",", "buses", ",", "generators", ")", ":", "Vm", "=", "array", "(", "[", "b", ".", "v_magnitude", "for", "b", "in", "buses", "]", ")", "# For buses with generators initialise Vm from gen data.", "for", "g", "in", "generators", ":", "Vm", "[", "g", ".", "bus", ".", "_i", "]", "=", "g", ".", "v_magnitude", "Vmin", "=", "array", "(", "[", "b", ".", "v_min", "for", "b", "in", "buses", "]", ")", "Vmax", "=", "array", "(", "[", "b", ".", "v_max", "for", "b", "in", "buses", "]", ")", "return", "Variable", "(", "\"Vm\"", ",", "len", "(", "buses", ")", ",", "Vm", ",", "Vmin", ",", "Vmax", ")" ]
Returns the voltage magnitude variable set.
[ "Returns", "the", "voltage", "magnitude", "variable", "set", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L243-L255
train
849
rwl/pylon
pylon/opf.py
OPF._get_pgen_var
def _get_pgen_var(self, generators, base_mva): """ Returns the generator active power set-point variable. """ Pg = array([g.p / base_mva for g in generators]) Pmin = array([g.p_min / base_mva for g in generators]) Pmax = array([g.p_max / base_mva for g in generators]) return Variable("Pg", len(generators), Pg, Pmin, Pmax)
python
def _get_pgen_var(self, generators, base_mva): """ Returns the generator active power set-point variable. """ Pg = array([g.p / base_mva for g in generators]) Pmin = array([g.p_min / base_mva for g in generators]) Pmax = array([g.p_max / base_mva for g in generators]) return Variable("Pg", len(generators), Pg, Pmin, Pmax)
[ "def", "_get_pgen_var", "(", "self", ",", "generators", ",", "base_mva", ")", ":", "Pg", "=", "array", "(", "[", "g", ".", "p", "/", "base_mva", "for", "g", "in", "generators", "]", ")", "Pmin", "=", "array", "(", "[", "g", ".", "p_min", "/", "base_mva", "for", "g", "in", "generators", "]", ")", "Pmax", "=", "array", "(", "[", "g", ".", "p_max", "/", "base_mva", "for", "g", "in", "generators", "]", ")", "return", "Variable", "(", "\"Pg\"", ",", "len", "(", "generators", ")", ",", "Pg", ",", "Pmin", ",", "Pmax", ")" ]
Returns the generator active power set-point variable.
[ "Returns", "the", "generator", "active", "power", "set", "-", "point", "variable", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L258-L266
train
850
rwl/pylon
pylon/opf.py
OPF._get_qgen_var
def _get_qgen_var(self, generators, base_mva): """ Returns the generator reactive power variable set. """ Qg = array([g.q / base_mva for g in generators]) Qmin = array([g.q_min / base_mva for g in generators]) Qmax = array([g.q_max / base_mva for g in generators]) return Variable("Qg", len(generators), Qg, Qmin, Qmax)
python
def _get_qgen_var(self, generators, base_mva): """ Returns the generator reactive power variable set. """ Qg = array([g.q / base_mva for g in generators]) Qmin = array([g.q_min / base_mva for g in generators]) Qmax = array([g.q_max / base_mva for g in generators]) return Variable("Qg", len(generators), Qg, Qmin, Qmax)
[ "def", "_get_qgen_var", "(", "self", ",", "generators", ",", "base_mva", ")", ":", "Qg", "=", "array", "(", "[", "g", ".", "q", "/", "base_mva", "for", "g", "in", "generators", "]", ")", "Qmin", "=", "array", "(", "[", "g", ".", "q_min", "/", "base_mva", "for", "g", "in", "generators", "]", ")", "Qmax", "=", "array", "(", "[", "g", ".", "q_max", "/", "base_mva", "for", "g", "in", "generators", "]", ")", "return", "Variable", "(", "\"Qg\"", ",", "len", "(", "generators", ")", ",", "Qg", ",", "Qmin", ",", "Qmax", ")" ]
Returns the generator reactive power variable set.
[ "Returns", "the", "generator", "reactive", "power", "variable", "set", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L269-L277
train
851
rwl/pylon
pylon/opf.py
OPF._nln_constraints
def _nln_constraints(self, nb, nl): """ Returns non-linear constraints for OPF. """ Pmis = NonLinearConstraint("Pmis", nb) Qmis = NonLinearConstraint("Qmis", nb) Sf = NonLinearConstraint("Sf", nl) St = NonLinearConstraint("St", nl) return Pmis, Qmis, Sf, St
python
def _nln_constraints(self, nb, nl): """ Returns non-linear constraints for OPF. """ Pmis = NonLinearConstraint("Pmis", nb) Qmis = NonLinearConstraint("Qmis", nb) Sf = NonLinearConstraint("Sf", nl) St = NonLinearConstraint("St", nl) return Pmis, Qmis, Sf, St
[ "def", "_nln_constraints", "(", "self", ",", "nb", ",", "nl", ")", ":", "Pmis", "=", "NonLinearConstraint", "(", "\"Pmis\"", ",", "nb", ")", "Qmis", "=", "NonLinearConstraint", "(", "\"Qmis\"", ",", "nb", ")", "Sf", "=", "NonLinearConstraint", "(", "\"Sf\"", ",", "nl", ")", "St", "=", "NonLinearConstraint", "(", "\"St\"", ",", "nl", ")", "return", "Pmis", ",", "Qmis", ",", "Sf", ",", "St" ]
Returns non-linear constraints for OPF.
[ "Returns", "non", "-", "linear", "constraints", "for", "OPF", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L283-L291
train
852
rwl/pylon
pylon/opf.py
OPF._const_pf_constraints
def _const_pf_constraints(self, gn, base_mva): """ Returns a linear constraint enforcing constant power factor for dispatchable loads. The power factor is derived from the original value of Pmin and either Qmin (for inductive loads) or Qmax (for capacitive loads). If both Qmin and Qmax are zero, this implies a unity power factor without the need for an additional constraint. """ ivl = array([i for i, g in enumerate(gn) if g.is_load and (g.q_min != 0.0 or g.q_max != 0.0)]) vl = [gn[i] for i in ivl] nvl = len(vl) ng = len(gn) Pg = array([g.p for g in vl]) / base_mva Qg = array([g.q for g in vl]) / base_mva Pmin = array([g.p_min for g in vl]) / base_mva Qmin = array([g.q_min for g in vl]) / base_mva Qmax = array([g.q_max for g in vl]) / base_mva # At least one of the Q limits must be zero (corresponding to Pmax==0). for g in vl: if g.qmin != 0.0 and g.q_max != 0.0: logger.error("Either Qmin or Qmax must be equal to zero for " "each dispatchable load.") # Initial values of PG and QG must be consistent with specified power # factor. This is to prevent a user from unknowingly using a case file # which would have defined a different power factor constraint under a # previous version which used PG and QG to define the power factor. Qlim = (Qmin == 0.0) * Qmax + (Qmax == 0.0) * Qmin if any( abs(Qg - Pg * Qlim / Pmin) > 1e-6 ): logger.error("For a dispatchable load, PG and QG must be " "consistent with the power factor defined by " "PMIN and the Q limits.") # Make Avl, lvl, uvl, for lvl <= Avl * r_[Pg, Qg] <= uvl if nvl > 0: xx = Pmin yy = Qlim pftheta = arctan2(yy, xx) pc = sin(pftheta) qc = -cos(pftheta) ii = array([range(nvl), range(nvl)]) jj = r_[ivl, ivl + ng] Avl = csr_matrix(r_[pc, qc], (ii, jj), (nvl, 2 * ng)) lvl = zeros(nvl) uvl = lvl else: Avl = zeros((0, 2 * ng)) lvl = array([]) uvl = array([]) return LinearConstraint("vl", Avl, lvl, uvl, ["Pg", "Qg"])
python
def _const_pf_constraints(self, gn, base_mva): """ Returns a linear constraint enforcing constant power factor for dispatchable loads. The power factor is derived from the original value of Pmin and either Qmin (for inductive loads) or Qmax (for capacitive loads). If both Qmin and Qmax are zero, this implies a unity power factor without the need for an additional constraint. """ ivl = array([i for i, g in enumerate(gn) if g.is_load and (g.q_min != 0.0 or g.q_max != 0.0)]) vl = [gn[i] for i in ivl] nvl = len(vl) ng = len(gn) Pg = array([g.p for g in vl]) / base_mva Qg = array([g.q for g in vl]) / base_mva Pmin = array([g.p_min for g in vl]) / base_mva Qmin = array([g.q_min for g in vl]) / base_mva Qmax = array([g.q_max for g in vl]) / base_mva # At least one of the Q limits must be zero (corresponding to Pmax==0). for g in vl: if g.qmin != 0.0 and g.q_max != 0.0: logger.error("Either Qmin or Qmax must be equal to zero for " "each dispatchable load.") # Initial values of PG and QG must be consistent with specified power # factor. This is to prevent a user from unknowingly using a case file # which would have defined a different power factor constraint under a # previous version which used PG and QG to define the power factor. Qlim = (Qmin == 0.0) * Qmax + (Qmax == 0.0) * Qmin if any( abs(Qg - Pg * Qlim / Pmin) > 1e-6 ): logger.error("For a dispatchable load, PG and QG must be " "consistent with the power factor defined by " "PMIN and the Q limits.") # Make Avl, lvl, uvl, for lvl <= Avl * r_[Pg, Qg] <= uvl if nvl > 0: xx = Pmin yy = Qlim pftheta = arctan2(yy, xx) pc = sin(pftheta) qc = -cos(pftheta) ii = array([range(nvl), range(nvl)]) jj = r_[ivl, ivl + ng] Avl = csr_matrix(r_[pc, qc], (ii, jj), (nvl, 2 * ng)) lvl = zeros(nvl) uvl = lvl else: Avl = zeros((0, 2 * ng)) lvl = array([]) uvl = array([]) return LinearConstraint("vl", Avl, lvl, uvl, ["Pg", "Qg"])
[ "def", "_const_pf_constraints", "(", "self", ",", "gn", ",", "base_mva", ")", ":", "ivl", "=", "array", "(", "[", "i", "for", "i", ",", "g", "in", "enumerate", "(", "gn", ")", "if", "g", ".", "is_load", "and", "(", "g", ".", "q_min", "!=", "0.0", "or", "g", ".", "q_max", "!=", "0.0", ")", "]", ")", "vl", "=", "[", "gn", "[", "i", "]", "for", "i", "in", "ivl", "]", "nvl", "=", "len", "(", "vl", ")", "ng", "=", "len", "(", "gn", ")", "Pg", "=", "array", "(", "[", "g", ".", "p", "for", "g", "in", "vl", "]", ")", "/", "base_mva", "Qg", "=", "array", "(", "[", "g", ".", "q", "for", "g", "in", "vl", "]", ")", "/", "base_mva", "Pmin", "=", "array", "(", "[", "g", ".", "p_min", "for", "g", "in", "vl", "]", ")", "/", "base_mva", "Qmin", "=", "array", "(", "[", "g", ".", "q_min", "for", "g", "in", "vl", "]", ")", "/", "base_mva", "Qmax", "=", "array", "(", "[", "g", ".", "q_max", "for", "g", "in", "vl", "]", ")", "/", "base_mva", "# At least one of the Q limits must be zero (corresponding to Pmax==0).", "for", "g", "in", "vl", ":", "if", "g", ".", "qmin", "!=", "0.0", "and", "g", ".", "q_max", "!=", "0.0", ":", "logger", ".", "error", "(", "\"Either Qmin or Qmax must be equal to zero for \"", "\"each dispatchable load.\"", ")", "# Initial values of PG and QG must be consistent with specified power", "# factor. This is to prevent a user from unknowingly using a case file", "# which would have defined a different power factor constraint under a", "# previous version which used PG and QG to define the power factor.", "Qlim", "=", "(", "Qmin", "==", "0.0", ")", "*", "Qmax", "+", "(", "Qmax", "==", "0.0", ")", "*", "Qmin", "if", "any", "(", "abs", "(", "Qg", "-", "Pg", "*", "Qlim", "/", "Pmin", ")", ">", "1e-6", ")", ":", "logger", ".", "error", "(", "\"For a dispatchable load, PG and QG must be \"", "\"consistent with the power factor defined by \"", "\"PMIN and the Q limits.\"", ")", "# Make Avl, lvl, uvl, for lvl <= Avl * r_[Pg, Qg] <= uvl", "if", "nvl", ">", "0", ":", "xx", "=", "Pmin", "yy", "=", "Qlim", "pftheta", "=", "arctan2", "(", "yy", ",", "xx", ")", "pc", "=", "sin", "(", "pftheta", ")", "qc", "=", "-", "cos", "(", "pftheta", ")", "ii", "=", "array", "(", "[", "range", "(", "nvl", ")", ",", "range", "(", "nvl", ")", "]", ")", "jj", "=", "r_", "[", "ivl", ",", "ivl", "+", "ng", "]", "Avl", "=", "csr_matrix", "(", "r_", "[", "pc", ",", "qc", "]", ",", "(", "ii", ",", "jj", ")", ",", "(", "nvl", ",", "2", "*", "ng", ")", ")", "lvl", "=", "zeros", "(", "nvl", ")", "uvl", "=", "lvl", "else", ":", "Avl", "=", "zeros", "(", "(", "0", ",", "2", "*", "ng", ")", ")", "lvl", "=", "array", "(", "[", "]", ")", "uvl", "=", "array", "(", "[", "]", ")", "return", "LinearConstraint", "(", "\"vl\"", ",", "Avl", ",", "lvl", ",", "uvl", ",", "[", "\"Pg\"", ",", "\"Qg\"", "]", ")" ]
Returns a linear constraint enforcing constant power factor for dispatchable loads. The power factor is derived from the original value of Pmin and either Qmin (for inductive loads) or Qmax (for capacitive loads). If both Qmin and Qmax are zero, this implies a unity power factor without the need for an additional constraint.
[ "Returns", "a", "linear", "constraint", "enforcing", "constant", "power", "factor", "for", "dispatchable", "loads", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L330-L384
train
853
rwl/pylon
pylon/opf.py
OPF._voltage_angle_diff_limit
def _voltage_angle_diff_limit(self, buses, branches): """ Returns the constraint on the branch voltage angle differences. """ nb = len(buses) if not self.ignore_ang_lim: iang = [i for i, b in enumerate(branches) if (b.ang_min and (b.ang_min > -360.0)) or (b.ang_max and (b.ang_max < 360.0))] iangl = array([i for i, b in enumerate(branches) if b.ang_min is not None])[iang] iangh = array([i for i, b in enumerate(branches) if b.ang_max is not None])[iang] nang = len(iang) if nang > 0: ii = range(nang) + range(nang) jjf = array([b.from_bus._i for b in branches])[iang] jjt = array([b.to_bus._i for b in branches])[iang] jj = r_[jjf, jjt] Aang = csr_matrix(r_[ones(nang), -ones(nang)], (ii, jj)) uang = Inf * ones(nang) lang = -uang lang[iangl] = array([b.ang_min * (pi / 180.0) for b in branches])[iangl] uang[iangh] = array([b.ang_max * (pi / 180.0) for b in branches])[iangh] else: # Aang = csr_matrix((0, nb), dtype=float64) # lang = array([], dtype=float64) # uang = array([], dtype=float64) Aang = zeros((0, nb)) lang = array([]) uang = array([]) else: # Aang = csr_matrix((0, nb), dtype=float64) # lang = array([], dtype=float64) # uang = array([], dtype=float64) # iang = array([], dtype=float64) Aang = zeros((0, nb)) lang = array([]) uang = array([]) return LinearConstraint("ang", Aang, lang, uang, ["Va"])
python
def _voltage_angle_diff_limit(self, buses, branches): """ Returns the constraint on the branch voltage angle differences. """ nb = len(buses) if not self.ignore_ang_lim: iang = [i for i, b in enumerate(branches) if (b.ang_min and (b.ang_min > -360.0)) or (b.ang_max and (b.ang_max < 360.0))] iangl = array([i for i, b in enumerate(branches) if b.ang_min is not None])[iang] iangh = array([i for i, b in enumerate(branches) if b.ang_max is not None])[iang] nang = len(iang) if nang > 0: ii = range(nang) + range(nang) jjf = array([b.from_bus._i for b in branches])[iang] jjt = array([b.to_bus._i for b in branches])[iang] jj = r_[jjf, jjt] Aang = csr_matrix(r_[ones(nang), -ones(nang)], (ii, jj)) uang = Inf * ones(nang) lang = -uang lang[iangl] = array([b.ang_min * (pi / 180.0) for b in branches])[iangl] uang[iangh] = array([b.ang_max * (pi / 180.0) for b in branches])[iangh] else: # Aang = csr_matrix((0, nb), dtype=float64) # lang = array([], dtype=float64) # uang = array([], dtype=float64) Aang = zeros((0, nb)) lang = array([]) uang = array([]) else: # Aang = csr_matrix((0, nb), dtype=float64) # lang = array([], dtype=float64) # uang = array([], dtype=float64) # iang = array([], dtype=float64) Aang = zeros((0, nb)) lang = array([]) uang = array([]) return LinearConstraint("ang", Aang, lang, uang, ["Va"])
[ "def", "_voltage_angle_diff_limit", "(", "self", ",", "buses", ",", "branches", ")", ":", "nb", "=", "len", "(", "buses", ")", "if", "not", "self", ".", "ignore_ang_lim", ":", "iang", "=", "[", "i", "for", "i", ",", "b", "in", "enumerate", "(", "branches", ")", "if", "(", "b", ".", "ang_min", "and", "(", "b", ".", "ang_min", ">", "-", "360.0", ")", ")", "or", "(", "b", ".", "ang_max", "and", "(", "b", ".", "ang_max", "<", "360.0", ")", ")", "]", "iangl", "=", "array", "(", "[", "i", "for", "i", ",", "b", "in", "enumerate", "(", "branches", ")", "if", "b", ".", "ang_min", "is", "not", "None", "]", ")", "[", "iang", "]", "iangh", "=", "array", "(", "[", "i", "for", "i", ",", "b", "in", "enumerate", "(", "branches", ")", "if", "b", ".", "ang_max", "is", "not", "None", "]", ")", "[", "iang", "]", "nang", "=", "len", "(", "iang", ")", "if", "nang", ">", "0", ":", "ii", "=", "range", "(", "nang", ")", "+", "range", "(", "nang", ")", "jjf", "=", "array", "(", "[", "b", ".", "from_bus", ".", "_i", "for", "b", "in", "branches", "]", ")", "[", "iang", "]", "jjt", "=", "array", "(", "[", "b", ".", "to_bus", ".", "_i", "for", "b", "in", "branches", "]", ")", "[", "iang", "]", "jj", "=", "r_", "[", "jjf", ",", "jjt", "]", "Aang", "=", "csr_matrix", "(", "r_", "[", "ones", "(", "nang", ")", ",", "-", "ones", "(", "nang", ")", "]", ",", "(", "ii", ",", "jj", ")", ")", "uang", "=", "Inf", "*", "ones", "(", "nang", ")", "lang", "=", "-", "uang", "lang", "[", "iangl", "]", "=", "array", "(", "[", "b", ".", "ang_min", "*", "(", "pi", "/", "180.0", ")", "for", "b", "in", "branches", "]", ")", "[", "iangl", "]", "uang", "[", "iangh", "]", "=", "array", "(", "[", "b", ".", "ang_max", "*", "(", "pi", "/", "180.0", ")", "for", "b", "in", "branches", "]", ")", "[", "iangh", "]", "else", ":", "# Aang = csr_matrix((0, nb), dtype=float64)", "# lang = array([], dtype=float64)", "# uang = array([], dtype=float64)", "Aang", "=", "zeros", "(", "(", "0", ",", "nb", ")", ")", "lang", "=", "array", "(", "[", "]", ")", "uang", "=", "array", "(", "[", "]", ")", "else", ":", "# Aang = csr_matrix((0, nb), dtype=float64)", "# lang = array([], dtype=float64)", "# uang = array([], dtype=float64)", "# iang = array([], dtype=float64)", "Aang", "=", "zeros", "(", "(", "0", ",", "nb", ")", ")", "lang", "=", "array", "(", "[", "]", ")", "uang", "=", "array", "(", "[", "]", ")", "return", "LinearConstraint", "(", "\"ang\"", ",", "Aang", ",", "lang", ",", "uang", ",", "[", "\"Va\"", "]", ")" ]
Returns the constraint on the branch voltage angle differences.
[ "Returns", "the", "constraint", "on", "the", "branch", "voltage", "angle", "differences", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L387-L430
train
854
rwl/pylon
pylon/opf.py
OPFModel.add_var
def add_var(self, var): """ Adds a variable to the model. """ if var.name in [v.name for v in self.vars]: logger.error("Variable set named '%s' already exists." % var.name) return var.i1 = self.var_N var.iN = self.var_N + var.N - 1 self.vars.append(var)
python
def add_var(self, var): """ Adds a variable to the model. """ if var.name in [v.name for v in self.vars]: logger.error("Variable set named '%s' already exists." % var.name) return var.i1 = self.var_N var.iN = self.var_N + var.N - 1 self.vars.append(var)
[ "def", "add_var", "(", "self", ",", "var", ")", ":", "if", "var", ".", "name", "in", "[", "v", ".", "name", "for", "v", "in", "self", ".", "vars", "]", ":", "logger", ".", "error", "(", "\"Variable set named '%s' already exists.\"", "%", "var", ".", "name", ")", "return", "var", ".", "i1", "=", "self", ".", "var_N", "var", ".", "iN", "=", "self", ".", "var_N", "+", "var", ".", "N", "-", "1", "self", ".", "vars", ".", "append", "(", "var", ")" ]
Adds a variable to the model.
[ "Adds", "a", "variable", "to", "the", "model", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L731-L740
train
855
rwl/pylon
pylon/opf.py
OPFModel.get_var
def get_var(self, name): """ Returns the variable set with the given name. """ for var in self.vars: if var.name == name: return var else: raise ValueError
python
def get_var(self, name): """ Returns the variable set with the given name. """ for var in self.vars: if var.name == name: return var else: raise ValueError
[ "def", "get_var", "(", "self", ",", "name", ")", ":", "for", "var", "in", "self", ".", "vars", ":", "if", "var", ".", "name", "==", "name", ":", "return", "var", "else", ":", "raise", "ValueError" ]
Returns the variable set with the given name.
[ "Returns", "the", "variable", "set", "with", "the", "given", "name", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L750-L757
train
856
rwl/pylon
pylon/opf.py
OPFModel.linear_constraints
def linear_constraints(self): """ Returns the linear constraints. """ if self.lin_N == 0: return None, array([]), array([]) A = lil_matrix((self.lin_N, self.var_N), dtype=float64) l = -Inf * ones(self.lin_N) u = -l for lin in self.lin_constraints: if lin.N: # non-zero number of rows to add Ak = lin.A # A for kth linear constrain set i1 = lin.i1 # starting row index iN = lin.iN # ending row index vsl = lin.vs # var set list kN = -1 # initialize last col of Ak used Ai = lil_matrix((lin.N, self.var_N), dtype=float64) for v in vsl: var = self.get_var(v) j1 = var.i1 # starting column in A jN = var.iN # ending column in A k1 = kN + 1 # starting column in Ak kN = kN + var.N # ending column in Ak if j1 == jN: # FIXME: Single column slicing broken in lil. for i in range(Ai.shape[0]): Ai[i, j1] = Ak[i, k1] else: Ai[:, j1:jN + 1] = Ak[:, k1:kN + 1] A[i1:iN + 1, :] = Ai l[i1:iN + 1] = lin.l u[i1:iN + 1] = lin.u return A.tocsr(), l, u
python
def linear_constraints(self): """ Returns the linear constraints. """ if self.lin_N == 0: return None, array([]), array([]) A = lil_matrix((self.lin_N, self.var_N), dtype=float64) l = -Inf * ones(self.lin_N) u = -l for lin in self.lin_constraints: if lin.N: # non-zero number of rows to add Ak = lin.A # A for kth linear constrain set i1 = lin.i1 # starting row index iN = lin.iN # ending row index vsl = lin.vs # var set list kN = -1 # initialize last col of Ak used Ai = lil_matrix((lin.N, self.var_N), dtype=float64) for v in vsl: var = self.get_var(v) j1 = var.i1 # starting column in A jN = var.iN # ending column in A k1 = kN + 1 # starting column in Ak kN = kN + var.N # ending column in Ak if j1 == jN: # FIXME: Single column slicing broken in lil. for i in range(Ai.shape[0]): Ai[i, j1] = Ak[i, k1] else: Ai[:, j1:jN + 1] = Ak[:, k1:kN + 1] A[i1:iN + 1, :] = Ai l[i1:iN + 1] = lin.l u[i1:iN + 1] = lin.u return A.tocsr(), l, u
[ "def", "linear_constraints", "(", "self", ")", ":", "if", "self", ".", "lin_N", "==", "0", ":", "return", "None", ",", "array", "(", "[", "]", ")", ",", "array", "(", "[", "]", ")", "A", "=", "lil_matrix", "(", "(", "self", ".", "lin_N", ",", "self", ".", "var_N", ")", ",", "dtype", "=", "float64", ")", "l", "=", "-", "Inf", "*", "ones", "(", "self", ".", "lin_N", ")", "u", "=", "-", "l", "for", "lin", "in", "self", ".", "lin_constraints", ":", "if", "lin", ".", "N", ":", "# non-zero number of rows to add", "Ak", "=", "lin", ".", "A", "# A for kth linear constrain set", "i1", "=", "lin", ".", "i1", "# starting row index", "iN", "=", "lin", ".", "iN", "# ending row index", "vsl", "=", "lin", ".", "vs", "# var set list", "kN", "=", "-", "1", "# initialize last col of Ak used", "Ai", "=", "lil_matrix", "(", "(", "lin", ".", "N", ",", "self", ".", "var_N", ")", ",", "dtype", "=", "float64", ")", "for", "v", "in", "vsl", ":", "var", "=", "self", ".", "get_var", "(", "v", ")", "j1", "=", "var", ".", "i1", "# starting column in A", "jN", "=", "var", ".", "iN", "# ending column in A", "k1", "=", "kN", "+", "1", "# starting column in Ak", "kN", "=", "kN", "+", "var", ".", "N", "# ending column in Ak", "if", "j1", "==", "jN", ":", "# FIXME: Single column slicing broken in lil.", "for", "i", "in", "range", "(", "Ai", ".", "shape", "[", "0", "]", ")", ":", "Ai", "[", "i", ",", "j1", "]", "=", "Ak", "[", "i", ",", "k1", "]", "else", ":", "Ai", "[", ":", ",", "j1", ":", "jN", "+", "1", "]", "=", "Ak", "[", ":", ",", "k1", ":", "kN", "+", "1", "]", "A", "[", "i1", ":", "iN", "+", "1", ",", ":", "]", "=", "Ai", "l", "[", "i1", ":", "iN", "+", "1", "]", "=", "lin", ".", "l", "u", "[", "i1", ":", "iN", "+", "1", "]", "=", "lin", ".", "u", "return", "A", ".", "tocsr", "(", ")", ",", "l", ",", "u" ]
Returns the linear constraints.
[ "Returns", "the", "linear", "constraints", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L782-L818
train
857
rwl/pylon
pylon/opf.py
OPFModel.add_constraint
def add_constraint(self, con): """ Adds a constraint to the model. """ if isinstance(con, LinearConstraint): N, M = con.A.shape if con.name in [c.name for c in self.lin_constraints]: logger.error("Constraint set named '%s' already exists." % con.name) return False else: con.i1 = self.lin_N# + 1 con.iN = self.lin_N + N - 1 nv = 0 for vs in con.vs: nv = nv + self.get_var_N(vs) if M != nv: logger.error("Number of columns of A does not match number" " of variables, A is %d x %d, nv = %d", N, M, nv) self.lin_constraints.append(con) elif isinstance(con, NonLinearConstraint): N = con.N if con.name in [c.name for c in self.nln_constraints]: logger.error("Constraint set named '%s' already exists." % con.name) return False else: con.i1 = self.nln_N# + 1 con.iN = self.nln_N + N self.nln_constraints.append(con) else: raise ValueError return True
python
def add_constraint(self, con): """ Adds a constraint to the model. """ if isinstance(con, LinearConstraint): N, M = con.A.shape if con.name in [c.name for c in self.lin_constraints]: logger.error("Constraint set named '%s' already exists." % con.name) return False else: con.i1 = self.lin_N# + 1 con.iN = self.lin_N + N - 1 nv = 0 for vs in con.vs: nv = nv + self.get_var_N(vs) if M != nv: logger.error("Number of columns of A does not match number" " of variables, A is %d x %d, nv = %d", N, M, nv) self.lin_constraints.append(con) elif isinstance(con, NonLinearConstraint): N = con.N if con.name in [c.name for c in self.nln_constraints]: logger.error("Constraint set named '%s' already exists." % con.name) return False else: con.i1 = self.nln_N# + 1 con.iN = self.nln_N + N self.nln_constraints.append(con) else: raise ValueError return True
[ "def", "add_constraint", "(", "self", ",", "con", ")", ":", "if", "isinstance", "(", "con", ",", "LinearConstraint", ")", ":", "N", ",", "M", "=", "con", ".", "A", ".", "shape", "if", "con", ".", "name", "in", "[", "c", ".", "name", "for", "c", "in", "self", ".", "lin_constraints", "]", ":", "logger", ".", "error", "(", "\"Constraint set named '%s' already exists.\"", "%", "con", ".", "name", ")", "return", "False", "else", ":", "con", ".", "i1", "=", "self", ".", "lin_N", "# + 1", "con", ".", "iN", "=", "self", ".", "lin_N", "+", "N", "-", "1", "nv", "=", "0", "for", "vs", "in", "con", ".", "vs", ":", "nv", "=", "nv", "+", "self", ".", "get_var_N", "(", "vs", ")", "if", "M", "!=", "nv", ":", "logger", ".", "error", "(", "\"Number of columns of A does not match number\"", "\" of variables, A is %d x %d, nv = %d\"", ",", "N", ",", "M", ",", "nv", ")", "self", ".", "lin_constraints", ".", "append", "(", "con", ")", "elif", "isinstance", "(", "con", ",", "NonLinearConstraint", ")", ":", "N", "=", "con", ".", "N", "if", "con", ".", "name", "in", "[", "c", ".", "name", "for", "c", "in", "self", ".", "nln_constraints", "]", ":", "logger", ".", "error", "(", "\"Constraint set named '%s' already exists.\"", "%", "con", ".", "name", ")", "return", "False", "else", ":", "con", ".", "i1", "=", "self", ".", "nln_N", "# + 1", "con", ".", "iN", "=", "self", ".", "nln_N", "+", "N", "self", ".", "nln_constraints", ".", "append", "(", "con", ")", "else", ":", "raise", "ValueError", "return", "True" ]
Adds a constraint to the model.
[ "Adds", "a", "constraint", "to", "the", "model", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/opf.py#L821-L854
train
858
rwl/pylon
pylon/ipopf.py
IPOPFSolver._solve
def _solve(self, x0, A, l, u, xmin, xmax): """ Solves using the Interior Point OPTimizer. """ # Indexes of constrained lines. il = [i for i,ln in enumerate(self._ln) if 0.0 < ln.rate_a < 1e10] nl2 = len(il) neqnln = 2 * self._nb # no. of non-linear equality constraints niqnln = 2 * len(il) # no. of lines with constraints user_data = {"A": A, "neqnln": neqnln, "niqnln": niqnln} self._f(x0) Jdata = self._dg(x0, False, user_data) # Hdata = self._h(x0, ones(neqnln + niqnln), None, False, user_data) lmbda = {"eqnonlin": ones(neqnln), "ineqnonlin": ones(niqnln)} H = tril(self._hessfcn(x0, lmbda), format="coo") self._Hrow, self._Hcol = H.row, H.col n = len(x0) # the number of variables xl = xmin xu = xmax gl = r_[zeros(2 * self._nb), -Inf * ones(2 * nl2), l] gu = r_[zeros(2 * self._nb), zeros(2 * nl2), u] m = len(gl) # the number of constraints nnzj = len(Jdata) # the number of nonzeros in Jacobian matrix nnzh = 0#len(H.data) # the number of non-zeros in Hessian matrix f_fcn, df_fcn, g_fcn, dg_fcn, h_fcn = \ self._f, self._df, self._g, self._dg, self._h nlp = pyipopt.create(n, xl, xu, m, gl, gu, nnzj, nnzh, f_fcn, df_fcn, g_fcn, dg_fcn)#, h_fcn) # print dir(nlp) # nlp.str_option("print_options_documentation", "yes") # nlp.int_option("max_iter", 10) # x, zl, zu, obj = nlp.solve(x0) success = nlp.solve(x0, user_data) nlp.close()
python
def _solve(self, x0, A, l, u, xmin, xmax): """ Solves using the Interior Point OPTimizer. """ # Indexes of constrained lines. il = [i for i,ln in enumerate(self._ln) if 0.0 < ln.rate_a < 1e10] nl2 = len(il) neqnln = 2 * self._nb # no. of non-linear equality constraints niqnln = 2 * len(il) # no. of lines with constraints user_data = {"A": A, "neqnln": neqnln, "niqnln": niqnln} self._f(x0) Jdata = self._dg(x0, False, user_data) # Hdata = self._h(x0, ones(neqnln + niqnln), None, False, user_data) lmbda = {"eqnonlin": ones(neqnln), "ineqnonlin": ones(niqnln)} H = tril(self._hessfcn(x0, lmbda), format="coo") self._Hrow, self._Hcol = H.row, H.col n = len(x0) # the number of variables xl = xmin xu = xmax gl = r_[zeros(2 * self._nb), -Inf * ones(2 * nl2), l] gu = r_[zeros(2 * self._nb), zeros(2 * nl2), u] m = len(gl) # the number of constraints nnzj = len(Jdata) # the number of nonzeros in Jacobian matrix nnzh = 0#len(H.data) # the number of non-zeros in Hessian matrix f_fcn, df_fcn, g_fcn, dg_fcn, h_fcn = \ self._f, self._df, self._g, self._dg, self._h nlp = pyipopt.create(n, xl, xu, m, gl, gu, nnzj, nnzh, f_fcn, df_fcn, g_fcn, dg_fcn)#, h_fcn) # print dir(nlp) # nlp.str_option("print_options_documentation", "yes") # nlp.int_option("max_iter", 10) # x, zl, zu, obj = nlp.solve(x0) success = nlp.solve(x0, user_data) nlp.close()
[ "def", "_solve", "(", "self", ",", "x0", ",", "A", ",", "l", ",", "u", ",", "xmin", ",", "xmax", ")", ":", "# Indexes of constrained lines.", "il", "=", "[", "i", "for", "i", ",", "ln", "in", "enumerate", "(", "self", ".", "_ln", ")", "if", "0.0", "<", "ln", ".", "rate_a", "<", "1e10", "]", "nl2", "=", "len", "(", "il", ")", "neqnln", "=", "2", "*", "self", ".", "_nb", "# no. of non-linear equality constraints", "niqnln", "=", "2", "*", "len", "(", "il", ")", "# no. of lines with constraints", "user_data", "=", "{", "\"A\"", ":", "A", ",", "\"neqnln\"", ":", "neqnln", ",", "\"niqnln\"", ":", "niqnln", "}", "self", ".", "_f", "(", "x0", ")", "Jdata", "=", "self", ".", "_dg", "(", "x0", ",", "False", ",", "user_data", ")", "# Hdata = self._h(x0, ones(neqnln + niqnln), None, False, user_data)", "lmbda", "=", "{", "\"eqnonlin\"", ":", "ones", "(", "neqnln", ")", ",", "\"ineqnonlin\"", ":", "ones", "(", "niqnln", ")", "}", "H", "=", "tril", "(", "self", ".", "_hessfcn", "(", "x0", ",", "lmbda", ")", ",", "format", "=", "\"coo\"", ")", "self", ".", "_Hrow", ",", "self", ".", "_Hcol", "=", "H", ".", "row", ",", "H", ".", "col", "n", "=", "len", "(", "x0", ")", "# the number of variables", "xl", "=", "xmin", "xu", "=", "xmax", "gl", "=", "r_", "[", "zeros", "(", "2", "*", "self", ".", "_nb", ")", ",", "-", "Inf", "*", "ones", "(", "2", "*", "nl2", ")", ",", "l", "]", "gu", "=", "r_", "[", "zeros", "(", "2", "*", "self", ".", "_nb", ")", ",", "zeros", "(", "2", "*", "nl2", ")", ",", "u", "]", "m", "=", "len", "(", "gl", ")", "# the number of constraints", "nnzj", "=", "len", "(", "Jdata", ")", "# the number of nonzeros in Jacobian matrix", "nnzh", "=", "0", "#len(H.data) # the number of non-zeros in Hessian matrix", "f_fcn", ",", "df_fcn", ",", "g_fcn", ",", "dg_fcn", ",", "h_fcn", "=", "self", ".", "_f", ",", "self", ".", "_df", ",", "self", ".", "_g", ",", "self", ".", "_dg", ",", "self", ".", "_h", "nlp", "=", "pyipopt", ".", "create", "(", "n", ",", "xl", ",", "xu", ",", "m", ",", "gl", ",", "gu", ",", "nnzj", ",", "nnzh", ",", "f_fcn", ",", "df_fcn", ",", "g_fcn", ",", "dg_fcn", ")", "#, h_fcn)", "# print dir(nlp)", "# nlp.str_option(\"print_options_documentation\", \"yes\")", "# nlp.int_option(\"max_iter\", 10)", "# x, zl, zu, obj = nlp.solve(x0)", "success", "=", "nlp", ".", "solve", "(", "x0", ",", "user_data", ")", "nlp", ".", "close", "(", ")" ]
Solves using the Interior Point OPTimizer.
[ "Solves", "using", "the", "Interior", "Point", "OPTimizer", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/ipopf.py#L44-L86
train
859
rwl/pylon
pyreto/continuous/experiment.py
MarketExperiment.doOutages
def doOutages(self): """ Applies branch outtages. """ assert len(self.branchOutages) == len(self.market.case.branches) weights = [[(False, r), (True, 1 - (r))] for r in self.branchOutages] for i, ln in enumerate(self.market.case.branches): ln.online = weighted_choice(weights[i]) if ln.online == False: print "Branch outage [%s] in period %d." %(ln.name,self.stepid)
python
def doOutages(self): """ Applies branch outtages. """ assert len(self.branchOutages) == len(self.market.case.branches) weights = [[(False, r), (True, 1 - (r))] for r in self.branchOutages] for i, ln in enumerate(self.market.case.branches): ln.online = weighted_choice(weights[i]) if ln.online == False: print "Branch outage [%s] in period %d." %(ln.name,self.stepid)
[ "def", "doOutages", "(", "self", ")", ":", "assert", "len", "(", "self", ".", "branchOutages", ")", "==", "len", "(", "self", ".", "market", ".", "case", ".", "branches", ")", "weights", "=", "[", "[", "(", "False", ",", "r", ")", ",", "(", "True", ",", "1", "-", "(", "r", ")", ")", "]", "for", "r", "in", "self", ".", "branchOutages", "]", "for", "i", ",", "ln", "in", "enumerate", "(", "self", ".", "market", ".", "case", ".", "branches", ")", ":", "ln", ".", "online", "=", "weighted_choice", "(", "weights", "[", "i", "]", ")", "if", "ln", ".", "online", "==", "False", ":", "print", "\"Branch outage [%s] in period %d.\"", "%", "(", "ln", ".", "name", ",", "self", ".", "stepid", ")" ]
Applies branch outtages.
[ "Applies", "branch", "outtages", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/continuous/experiment.py#L133-L143
train
860
rwl/pylon
pyreto/continuous/experiment.py
MarketExperiment.reset_case
def reset_case(self): """ Returns the case to its original state. """ for bus in self.market.case.buses: bus.p_demand = self.pdemand[bus] for task in self.tasks: for g in task.env.generators: g.p = task.env._g0[g]["p"] g.p_max = task.env._g0[g]["p_max"] g.p_min = task.env._g0[g]["p_min"] g.q = task.env._g0[g]["q"] g.q_max = task.env._g0[g]["q_max"] g.q_min = task.env._g0[g]["q_min"] g.p_cost = task.env._g0[g]["p_cost"] g.pcost_model = task.env._g0[g]["pcost_model"] g.q_cost = task.env._g0[g]["q_cost"] g.qcost_model = task.env._g0[g]["qcost_model"] g.c_startup = task.env._g0[g]["startup"] g.c_shutdown = task.env._g0[g]["shutdown"]
python
def reset_case(self): """ Returns the case to its original state. """ for bus in self.market.case.buses: bus.p_demand = self.pdemand[bus] for task in self.tasks: for g in task.env.generators: g.p = task.env._g0[g]["p"] g.p_max = task.env._g0[g]["p_max"] g.p_min = task.env._g0[g]["p_min"] g.q = task.env._g0[g]["q"] g.q_max = task.env._g0[g]["q_max"] g.q_min = task.env._g0[g]["q_min"] g.p_cost = task.env._g0[g]["p_cost"] g.pcost_model = task.env._g0[g]["pcost_model"] g.q_cost = task.env._g0[g]["q_cost"] g.qcost_model = task.env._g0[g]["qcost_model"] g.c_startup = task.env._g0[g]["startup"] g.c_shutdown = task.env._g0[g]["shutdown"]
[ "def", "reset_case", "(", "self", ")", ":", "for", "bus", "in", "self", ".", "market", ".", "case", ".", "buses", ":", "bus", ".", "p_demand", "=", "self", ".", "pdemand", "[", "bus", "]", "for", "task", "in", "self", ".", "tasks", ":", "for", "g", "in", "task", ".", "env", ".", "generators", ":", "g", ".", "p", "=", "task", ".", "env", ".", "_g0", "[", "g", "]", "[", "\"p\"", "]", "g", ".", "p_max", "=", "task", ".", "env", ".", "_g0", "[", "g", "]", "[", "\"p_max\"", "]", "g", ".", "p_min", "=", "task", ".", "env", ".", "_g0", "[", "g", "]", "[", "\"p_min\"", "]", "g", ".", "q", "=", "task", ".", "env", ".", "_g0", "[", "g", "]", "[", "\"q\"", "]", "g", ".", "q_max", "=", "task", ".", "env", ".", "_g0", "[", "g", "]", "[", "\"q_max\"", "]", "g", ".", "q_min", "=", "task", ".", "env", ".", "_g0", "[", "g", "]", "[", "\"q_min\"", "]", "g", ".", "p_cost", "=", "task", ".", "env", ".", "_g0", "[", "g", "]", "[", "\"p_cost\"", "]", "g", ".", "pcost_model", "=", "task", ".", "env", ".", "_g0", "[", "g", "]", "[", "\"pcost_model\"", "]", "g", ".", "q_cost", "=", "task", ".", "env", ".", "_g0", "[", "g", "]", "[", "\"q_cost\"", "]", "g", ".", "qcost_model", "=", "task", ".", "env", ".", "_g0", "[", "g", "]", "[", "\"qcost_model\"", "]", "g", ".", "c_startup", "=", "task", ".", "env", ".", "_g0", "[", "g", "]", "[", "\"startup\"", "]", "g", ".", "c_shutdown", "=", "task", ".", "env", ".", "_g0", "[", "g", "]", "[", "\"shutdown\"", "]" ]
Returns the case to its original state.
[ "Returns", "the", "case", "to", "its", "original", "state", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/continuous/experiment.py#L146-L164
train
861
rwl/pylon
pyreto/continuous/experiment.py
MarketExperiment.doEpisodes
def doEpisodes(self, number=1): """ Do the given numer of episodes, and return the rewards of each step as a list. """ for episode in range(number): print "Starting episode %d." % episode # Initialise the profile cycle. if len(self.profile.shape) == 1: # 1D array self._pcycle = cycle(self.profile) else: assert self.profile.shape[0] >= number self._pcycle = cycle(self.profile[episode, :]) # Scale the initial load. c = self._pcycle.next() for bus in self.market.case.buses: bus.p_demand = self.pdemand[bus] * c # Initialise agents and their tasks. for task, agent in zip(self.tasks, self.agents): agent.newEpisode() task.reset() while False in [task.isFinished() for task in self.tasks]: if True in [task.isFinished() for task in self.tasks]: raise ValueError self._oneInteraction() self.reset_case()
python
def doEpisodes(self, number=1): """ Do the given numer of episodes, and return the rewards of each step as a list. """ for episode in range(number): print "Starting episode %d." % episode # Initialise the profile cycle. if len(self.profile.shape) == 1: # 1D array self._pcycle = cycle(self.profile) else: assert self.profile.shape[0] >= number self._pcycle = cycle(self.profile[episode, :]) # Scale the initial load. c = self._pcycle.next() for bus in self.market.case.buses: bus.p_demand = self.pdemand[bus] * c # Initialise agents and their tasks. for task, agent in zip(self.tasks, self.agents): agent.newEpisode() task.reset() while False in [task.isFinished() for task in self.tasks]: if True in [task.isFinished() for task in self.tasks]: raise ValueError self._oneInteraction() self.reset_case()
[ "def", "doEpisodes", "(", "self", ",", "number", "=", "1", ")", ":", "for", "episode", "in", "range", "(", "number", ")", ":", "print", "\"Starting episode %d.\"", "%", "episode", "# Initialise the profile cycle.", "if", "len", "(", "self", ".", "profile", ".", "shape", ")", "==", "1", ":", "# 1D array", "self", ".", "_pcycle", "=", "cycle", "(", "self", ".", "profile", ")", "else", ":", "assert", "self", ".", "profile", ".", "shape", "[", "0", "]", ">=", "number", "self", ".", "_pcycle", "=", "cycle", "(", "self", ".", "profile", "[", "episode", ",", ":", "]", ")", "# Scale the initial load.", "c", "=", "self", ".", "_pcycle", ".", "next", "(", ")", "for", "bus", "in", "self", ".", "market", ".", "case", ".", "buses", ":", "bus", ".", "p_demand", "=", "self", ".", "pdemand", "[", "bus", "]", "*", "c", "# Initialise agents and their tasks.", "for", "task", ",", "agent", "in", "zip", "(", "self", ".", "tasks", ",", "self", ".", "agents", ")", ":", "agent", ".", "newEpisode", "(", ")", "task", ".", "reset", "(", ")", "while", "False", "in", "[", "task", ".", "isFinished", "(", ")", "for", "task", "in", "self", ".", "tasks", "]", ":", "if", "True", "in", "[", "task", ".", "isFinished", "(", ")", "for", "task", "in", "self", ".", "tasks", "]", ":", "raise", "ValueError", "self", ".", "_oneInteraction", "(", ")", "self", ".", "reset_case", "(", ")" ]
Do the given numer of episodes, and return the rewards of each step as a list.
[ "Do", "the", "given", "numer", "of", "episodes", "and", "return", "the", "rewards", "of", "each", "step", "as", "a", "list", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/continuous/experiment.py#L170-L199
train
862
rwl/pylon
pyreto/continuous/experiment.py
MarketExperiment.reset
def reset(self): """ Sets initial conditions for the experiment. """ self.stepid = 0 for task, agent in zip(self.tasks, self.agents): task.reset() agent.module.reset() agent.history.reset()
python
def reset(self): """ Sets initial conditions for the experiment. """ self.stepid = 0 for task, agent in zip(self.tasks, self.agents): task.reset() agent.module.reset() agent.history.reset()
[ "def", "reset", "(", "self", ")", ":", "self", ".", "stepid", "=", "0", "for", "task", ",", "agent", "in", "zip", "(", "self", ".", "tasks", ",", "self", ".", "agents", ")", ":", "task", ".", "reset", "(", ")", "agent", ".", "module", ".", "reset", "(", ")", "agent", ".", "history", ".", "reset", "(", ")" ]
Sets initial conditions for the experiment.
[ "Sets", "initial", "conditions", "for", "the", "experiment", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/continuous/experiment.py#L249-L258
train
863
rwl/pylon
pyreto/roth_erev.py
RothErev._updatePropensities
def _updatePropensities(self, lastState, lastAction, reward): """ Update the propensities for all actions. The propensity for last action chosen will be updated using the feedback value that resulted from performing the action. If j is the index of the last action chosen, r_j is the reward received for performing j, i is the current action being updated, q_i is the propensity for i, and phi is the recency parameter, then this update function can be expressed as:: q_i = (1-phi) * q_i + E(i, r_j) """ phi = self.recency for action in range(self.module.numActions): carryOver = (1 - phi) * self.module.getValue(lastState, action) experience = self._experience(lastState, action, lastAction,reward) self.module.updateValue(lastState, action, carryOver + experience)
python
def _updatePropensities(self, lastState, lastAction, reward): """ Update the propensities for all actions. The propensity for last action chosen will be updated using the feedback value that resulted from performing the action. If j is the index of the last action chosen, r_j is the reward received for performing j, i is the current action being updated, q_i is the propensity for i, and phi is the recency parameter, then this update function can be expressed as:: q_i = (1-phi) * q_i + E(i, r_j) """ phi = self.recency for action in range(self.module.numActions): carryOver = (1 - phi) * self.module.getValue(lastState, action) experience = self._experience(lastState, action, lastAction,reward) self.module.updateValue(lastState, action, carryOver + experience)
[ "def", "_updatePropensities", "(", "self", ",", "lastState", ",", "lastAction", ",", "reward", ")", ":", "phi", "=", "self", ".", "recency", "for", "action", "in", "range", "(", "self", ".", "module", ".", "numActions", ")", ":", "carryOver", "=", "(", "1", "-", "phi", ")", "*", "self", ".", "module", ".", "getValue", "(", "lastState", ",", "action", ")", "experience", "=", "self", ".", "_experience", "(", "lastState", ",", "action", ",", "lastAction", ",", "reward", ")", "self", ".", "module", ".", "updateValue", "(", "lastState", ",", "action", ",", "carryOver", "+", "experience", ")" ]
Update the propensities for all actions. The propensity for last action chosen will be updated using the feedback value that resulted from performing the action. If j is the index of the last action chosen, r_j is the reward received for performing j, i is the current action being updated, q_i is the propensity for i, and phi is the recency parameter, then this update function can be expressed as:: q_i = (1-phi) * q_i + E(i, r_j)
[ "Update", "the", "propensities", "for", "all", "actions", ".", "The", "propensity", "for", "last", "action", "chosen", "will", "be", "updated", "using", "the", "feedback", "value", "that", "resulted", "from", "performing", "the", "action", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/roth_erev.py#L136-L154
train
864
rwl/pylon
pyreto/roth_erev.py
ProportionalExplorer._forwardImplementation
def _forwardImplementation(self, inbuf, outbuf): """ Proportional probability method. """ assert self.module propensities = self.module.getActionValues(0) summedProps = sum(propensities) probabilities = propensities / summedProps action = eventGenerator(probabilities) # action = drawIndex(probabilities) outbuf[:] = scipy.array([action])
python
def _forwardImplementation(self, inbuf, outbuf): """ Proportional probability method. """ assert self.module propensities = self.module.getActionValues(0) summedProps = sum(propensities) probabilities = propensities / summedProps action = eventGenerator(probabilities) # action = drawIndex(probabilities) outbuf[:] = scipy.array([action])
[ "def", "_forwardImplementation", "(", "self", ",", "inbuf", ",", "outbuf", ")", ":", "assert", "self", ".", "module", "propensities", "=", "self", ".", "module", ".", "getActionValues", "(", "0", ")", "summedProps", "=", "sum", "(", "propensities", ")", "probabilities", "=", "propensities", "/", "summedProps", "action", "=", "eventGenerator", "(", "probabilities", ")", "# action = drawIndex(probabilities)", "outbuf", "[", ":", "]", "=", "scipy", ".", "array", "(", "[", "action", "]", ")" ]
Proportional probability method.
[ "Proportional", "probability", "method", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/roth_erev.py#L254-L267
train
865
rwl/pylon
pylon/io/excel.py
ExcelWriter.write
def write(self, file_or_filename): """ Writes case data to file in Excel format. """ self.book = Workbook() self._write_data(None) self.book.save(file_or_filename)
python
def write(self, file_or_filename): """ Writes case data to file in Excel format. """ self.book = Workbook() self._write_data(None) self.book.save(file_or_filename)
[ "def", "write", "(", "self", ",", "file_or_filename", ")", ":", "self", ".", "book", "=", "Workbook", "(", ")", "self", ".", "_write_data", "(", "None", ")", "self", ".", "book", ".", "save", "(", "file_or_filename", ")" ]
Writes case data to file in Excel format.
[ "Writes", "case", "data", "to", "file", "in", "Excel", "format", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/excel.py#L38-L43
train
866
rwl/pylon
pylon/io/excel.py
ExcelWriter.write_bus_data
def write_bus_data(self, file): """ Writes bus data to an Excel spreadsheet. """ bus_sheet = self.book.add_sheet("Buses") for i, bus in enumerate(self.case.buses): for j, attr in enumerate(BUS_ATTRS): bus_sheet.write(i, j, getattr(bus, attr))
python
def write_bus_data(self, file): """ Writes bus data to an Excel spreadsheet. """ bus_sheet = self.book.add_sheet("Buses") for i, bus in enumerate(self.case.buses): for j, attr in enumerate(BUS_ATTRS): bus_sheet.write(i, j, getattr(bus, attr))
[ "def", "write_bus_data", "(", "self", ",", "file", ")", ":", "bus_sheet", "=", "self", ".", "book", ".", "add_sheet", "(", "\"Buses\"", ")", "for", "i", ",", "bus", "in", "enumerate", "(", "self", ".", "case", ".", "buses", ")", ":", "for", "j", ",", "attr", "in", "enumerate", "(", "BUS_ATTRS", ")", ":", "bus_sheet", ".", "write", "(", "i", ",", "j", ",", "getattr", "(", "bus", ",", "attr", ")", ")" ]
Writes bus data to an Excel spreadsheet.
[ "Writes", "bus", "data", "to", "an", "Excel", "spreadsheet", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/excel.py#L56-L63
train
867
rwl/pylon
pylon/io/excel.py
ExcelWriter.write_branch_data
def write_branch_data(self, file): """ Writes branch data to an Excel spreadsheet. """ branch_sheet = self.book.add_sheet("Branches") for i, branch in enumerate(self.case.branches): for j, attr in enumerate(BRANCH_ATTRS): branch_sheet.write(i, j, getattr(branch, attr))
python
def write_branch_data(self, file): """ Writes branch data to an Excel spreadsheet. """ branch_sheet = self.book.add_sheet("Branches") for i, branch in enumerate(self.case.branches): for j, attr in enumerate(BRANCH_ATTRS): branch_sheet.write(i, j, getattr(branch, attr))
[ "def", "write_branch_data", "(", "self", ",", "file", ")", ":", "branch_sheet", "=", "self", ".", "book", ".", "add_sheet", "(", "\"Branches\"", ")", "for", "i", ",", "branch", "in", "enumerate", "(", "self", ".", "case", ".", "branches", ")", ":", "for", "j", ",", "attr", "in", "enumerate", "(", "BRANCH_ATTRS", ")", ":", "branch_sheet", ".", "write", "(", "i", ",", "j", ",", "getattr", "(", "branch", ",", "attr", ")", ")" ]
Writes branch data to an Excel spreadsheet.
[ "Writes", "branch", "data", "to", "an", "Excel", "spreadsheet", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/excel.py#L66-L73
train
868
rwl/pylon
pylon/io/excel.py
ExcelWriter.write_generator_data
def write_generator_data(self, file): """ Write generator data to file. """ generator_sheet = self.book.add_sheet("Generators") for j, generator in enumerate(self.case.generators): i = generator.bus._i for k, attr in enumerate(GENERATOR_ATTRS): generator_sheet.write(j, 0, i)
python
def write_generator_data(self, file): """ Write generator data to file. """ generator_sheet = self.book.add_sheet("Generators") for j, generator in enumerate(self.case.generators): i = generator.bus._i for k, attr in enumerate(GENERATOR_ATTRS): generator_sheet.write(j, 0, i)
[ "def", "write_generator_data", "(", "self", ",", "file", ")", ":", "generator_sheet", "=", "self", ".", "book", ".", "add_sheet", "(", "\"Generators\"", ")", "for", "j", ",", "generator", "in", "enumerate", "(", "self", ".", "case", ".", "generators", ")", ":", "i", "=", "generator", ".", "bus", ".", "_i", "for", "k", ",", "attr", "in", "enumerate", "(", "GENERATOR_ATTRS", ")", ":", "generator_sheet", ".", "write", "(", "j", ",", "0", ",", "i", ")" ]
Write generator data to file.
[ "Write", "generator", "data", "to", "file", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/excel.py#L76-L84
train
869
rwl/pylon
pylon/io/excel.py
CSVWriter.write
def write(self, file_or_filename): """ Writes case data as CSV. """ if isinstance(file_or_filename, basestring): file = open(file_or_filename, "wb") else: file = file_or_filename self.writer = csv.writer(file) super(CSVWriter, self).write(file)
python
def write(self, file_or_filename): """ Writes case data as CSV. """ if isinstance(file_or_filename, basestring): file = open(file_or_filename, "wb") else: file = file_or_filename self.writer = csv.writer(file) super(CSVWriter, self).write(file)
[ "def", "write", "(", "self", ",", "file_or_filename", ")", ":", "if", "isinstance", "(", "file_or_filename", ",", "basestring", ")", ":", "file", "=", "open", "(", "file_or_filename", ",", "\"wb\"", ")", "else", ":", "file", "=", "file_or_filename", "self", ".", "writer", "=", "csv", ".", "writer", "(", "file", ")", "super", "(", "CSVWriter", ",", "self", ")", ".", "write", "(", "file", ")" ]
Writes case data as CSV.
[ "Writes", "case", "data", "as", "CSV", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/excel.py#L112-L122
train
870
rwl/pylon
pylon/io/excel.py
CSVWriter.write_case_data
def write_case_data(self, file): """ Writes the case data as CSV. """ writer = self._get_writer(file) writer.writerow(["Name", "base_mva"]) writer.writerow([self.case.name, self.case.base_mva])
python
def write_case_data(self, file): """ Writes the case data as CSV. """ writer = self._get_writer(file) writer.writerow(["Name", "base_mva"]) writer.writerow([self.case.name, self.case.base_mva])
[ "def", "write_case_data", "(", "self", ",", "file", ")", ":", "writer", "=", "self", ".", "_get_writer", "(", "file", ")", "writer", ".", "writerow", "(", "[", "\"Name\"", ",", "\"base_mva\"", "]", ")", "writer", ".", "writerow", "(", "[", "self", ".", "case", ".", "name", ",", "self", ".", "case", ".", "base_mva", "]", ")" ]
Writes the case data as CSV.
[ "Writes", "the", "case", "data", "as", "CSV", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/excel.py#L125-L130
train
871
rwl/pylon
pylon/io/excel.py
CSVWriter.write_bus_data
def write_bus_data(self, file): """ Writes bus data as CSV. """ writer = self._get_writer(file) writer.writerow(BUS_ATTRS) for bus in self.case.buses: writer.writerow([getattr(bus, attr) for attr in BUS_ATTRS])
python
def write_bus_data(self, file): """ Writes bus data as CSV. """ writer = self._get_writer(file) writer.writerow(BUS_ATTRS) for bus in self.case.buses: writer.writerow([getattr(bus, attr) for attr in BUS_ATTRS])
[ "def", "write_bus_data", "(", "self", ",", "file", ")", ":", "writer", "=", "self", ".", "_get_writer", "(", "file", ")", "writer", ".", "writerow", "(", "BUS_ATTRS", ")", "for", "bus", "in", "self", ".", "case", ".", "buses", ":", "writer", ".", "writerow", "(", "[", "getattr", "(", "bus", ",", "attr", ")", "for", "attr", "in", "BUS_ATTRS", "]", ")" ]
Writes bus data as CSV.
[ "Writes", "bus", "data", "as", "CSV", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/excel.py#L133-L139
train
872
rwl/pylon
pylon/io/excel.py
CSVWriter.write_branch_data
def write_branch_data(self, file): """ Writes branch data as CSV. """ writer = self._get_writer(file) writer.writerow(BRANCH_ATTRS) for branch in self.case.branches: writer.writerow([getattr(branch, a) for a in BRANCH_ATTRS])
python
def write_branch_data(self, file): """ Writes branch data as CSV. """ writer = self._get_writer(file) writer.writerow(BRANCH_ATTRS) for branch in self.case.branches: writer.writerow([getattr(branch, a) for a in BRANCH_ATTRS])
[ "def", "write_branch_data", "(", "self", ",", "file", ")", ":", "writer", "=", "self", ".", "_get_writer", "(", "file", ")", "writer", ".", "writerow", "(", "BRANCH_ATTRS", ")", "for", "branch", "in", "self", ".", "case", ".", "branches", ":", "writer", ".", "writerow", "(", "[", "getattr", "(", "branch", ",", "a", ")", "for", "a", "in", "BRANCH_ATTRS", "]", ")" ]
Writes branch data as CSV.
[ "Writes", "branch", "data", "as", "CSV", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/excel.py#L142-L148
train
873
rwl/pylon
pylon/io/excel.py
CSVWriter.write_generator_data
def write_generator_data(self, file): """ Write generator data as CSV. """ writer = self._get_writer(file) writer.writerow(["bus"] + GENERATOR_ATTRS) for g in self.case.generators: i = g.bus._i writer.writerow([i] + [getattr(g,a) for a in GENERATOR_ATTRS])
python
def write_generator_data(self, file): """ Write generator data as CSV. """ writer = self._get_writer(file) writer.writerow(["bus"] + GENERATOR_ATTRS) for g in self.case.generators: i = g.bus._i writer.writerow([i] + [getattr(g,a) for a in GENERATOR_ATTRS])
[ "def", "write_generator_data", "(", "self", ",", "file", ")", ":", "writer", "=", "self", ".", "_get_writer", "(", "file", ")", "writer", ".", "writerow", "(", "[", "\"bus\"", "]", "+", "GENERATOR_ATTRS", ")", "for", "g", "in", "self", ".", "case", ".", "generators", ":", "i", "=", "g", ".", "bus", ".", "_i", "writer", ".", "writerow", "(", "[", "i", "]", "+", "[", "getattr", "(", "g", ",", "a", ")", "for", "a", "in", "GENERATOR_ATTRS", "]", ")" ]
Write generator data as CSV.
[ "Write", "generator", "data", "as", "CSV", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/excel.py#L151-L159
train
874
rwl/pylon
pyreto/smart_market.py
SmartMarket.run
def run(self): """ Computes cleared offers and bids. """ # Start the clock. t0 = time.time() # Manage reactive power offers/bids. haveQ = self._isReactiveMarket() # Withhold offers/bids outwith optional price limits. self._withholdOffbids() # Convert offers/bids to pwl functions and update limits. self._offbidToCase() # Compute dispatch points and LMPs using OPF. success = self._runOPF() if success: # Get nodal marginal prices from OPF. gteeOfferPrice, gteeBidPrice = self._nodalPrices(haveQ) # Determine quantity and price for each offer/bid. self._runAuction(gteeOfferPrice, gteeBidPrice, haveQ) logger.info("SmartMarket cleared in %.3fs" % (time.time() - t0)) else: for offbid in self.offers + self.bids: offbid.clearedQuantity = 0.0 offbid.clearedPrice = 0.0 offbid.accepted = False offbid.generator.p = 0.0 logger.error("Non-convergent market OPF. Blackout!") return self.offers, self.bids
python
def run(self): """ Computes cleared offers and bids. """ # Start the clock. t0 = time.time() # Manage reactive power offers/bids. haveQ = self._isReactiveMarket() # Withhold offers/bids outwith optional price limits. self._withholdOffbids() # Convert offers/bids to pwl functions and update limits. self._offbidToCase() # Compute dispatch points and LMPs using OPF. success = self._runOPF() if success: # Get nodal marginal prices from OPF. gteeOfferPrice, gteeBidPrice = self._nodalPrices(haveQ) # Determine quantity and price for each offer/bid. self._runAuction(gteeOfferPrice, gteeBidPrice, haveQ) logger.info("SmartMarket cleared in %.3fs" % (time.time() - t0)) else: for offbid in self.offers + self.bids: offbid.clearedQuantity = 0.0 offbid.clearedPrice = 0.0 offbid.accepted = False offbid.generator.p = 0.0 logger.error("Non-convergent market OPF. Blackout!") return self.offers, self.bids
[ "def", "run", "(", "self", ")", ":", "# Start the clock.", "t0", "=", "time", ".", "time", "(", ")", "# Manage reactive power offers/bids.", "haveQ", "=", "self", ".", "_isReactiveMarket", "(", ")", "# Withhold offers/bids outwith optional price limits.", "self", ".", "_withholdOffbids", "(", ")", "# Convert offers/bids to pwl functions and update limits.", "self", ".", "_offbidToCase", "(", ")", "# Compute dispatch points and LMPs using OPF.", "success", "=", "self", ".", "_runOPF", "(", ")", "if", "success", ":", "# Get nodal marginal prices from OPF.", "gteeOfferPrice", ",", "gteeBidPrice", "=", "self", ".", "_nodalPrices", "(", "haveQ", ")", "# Determine quantity and price for each offer/bid.", "self", ".", "_runAuction", "(", "gteeOfferPrice", ",", "gteeBidPrice", ",", "haveQ", ")", "logger", ".", "info", "(", "\"SmartMarket cleared in %.3fs\"", "%", "(", "time", ".", "time", "(", ")", "-", "t0", ")", ")", "else", ":", "for", "offbid", "in", "self", ".", "offers", "+", "self", ".", "bids", ":", "offbid", ".", "clearedQuantity", "=", "0.0", "offbid", ".", "clearedPrice", "=", "0.0", "offbid", ".", "accepted", "=", "False", "offbid", ".", "generator", ".", "p", "=", "0.0", "logger", ".", "error", "(", "\"Non-convergent market OPF. Blackout!\"", ")", "return", "self", ".", "offers", ",", "self", ".", "bids" ]
Computes cleared offers and bids.
[ "Computes", "cleared", "offers", "and", "bids", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/smart_market.py#L131-L166
train
875
rwl/pylon
pyreto/smart_market.py
SmartMarket._runOPF
def _runOPF(self): """ Computes dispatch points and LMPs using OPF. """ if self.decommit: solver = UDOPF(self.case, dc=(self.locationalAdjustment == "dc")) elif self.locationalAdjustment == "dc": solver = OPF(self.case, dc=True) else: solver = OPF(self.case, dc=False, opt={"verbose": True}) self._solution = solver.solve() # for ob in self.offers + self.bids: # ob.f = solution["f"] return self._solution["converged"]
python
def _runOPF(self): """ Computes dispatch points and LMPs using OPF. """ if self.decommit: solver = UDOPF(self.case, dc=(self.locationalAdjustment == "dc")) elif self.locationalAdjustment == "dc": solver = OPF(self.case, dc=True) else: solver = OPF(self.case, dc=False, opt={"verbose": True}) self._solution = solver.solve() # for ob in self.offers + self.bids: # ob.f = solution["f"] return self._solution["converged"]
[ "def", "_runOPF", "(", "self", ")", ":", "if", "self", ".", "decommit", ":", "solver", "=", "UDOPF", "(", "self", ".", "case", ",", "dc", "=", "(", "self", ".", "locationalAdjustment", "==", "\"dc\"", ")", ")", "elif", "self", ".", "locationalAdjustment", "==", "\"dc\"", ":", "solver", "=", "OPF", "(", "self", ".", "case", ",", "dc", "=", "True", ")", "else", ":", "solver", "=", "OPF", "(", "self", ".", "case", ",", "dc", "=", "False", ",", "opt", "=", "{", "\"verbose\"", ":", "True", "}", ")", "self", ".", "_solution", "=", "solver", ".", "solve", "(", ")", "# for ob in self.offers + self.bids:", "# ob.f = solution[\"f\"]", "return", "self", ".", "_solution", "[", "\"converged\"", "]" ]
Computes dispatch points and LMPs using OPF.
[ "Computes", "dispatch", "points", "and", "LMPs", "using", "OPF", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/smart_market.py#L266-L281
train
876
rwl/pylon
contrib/public/services/simplejson/encoder.py
JSONEncoder.encode
def encode(self, o): """ Return a JSON string representation of a Python data structure. >>> JSONEncoder().encode({"foo": ["bar", "baz"]}) '{"foo":["bar", "baz"]}' """ # This doesn't pass the iterator directly to ''.join() because it # sucks at reporting exceptions. It's going to do this internally # anyway because it uses PySequence_Fast or similar. chunks = list(self.iterencode(o)) return ''.join(chunks)
python
def encode(self, o): """ Return a JSON string representation of a Python data structure. >>> JSONEncoder().encode({"foo": ["bar", "baz"]}) '{"foo":["bar", "baz"]}' """ # This doesn't pass the iterator directly to ''.join() because it # sucks at reporting exceptions. It's going to do this internally # anyway because it uses PySequence_Fast or similar. chunks = list(self.iterencode(o)) return ''.join(chunks)
[ "def", "encode", "(", "self", ",", "o", ")", ":", "# This doesn't pass the iterator directly to ''.join() because it", "# sucks at reporting exceptions. It's going to do this internally", "# anyway because it uses PySequence_Fast or similar.", "chunks", "=", "list", "(", "self", ".", "iterencode", "(", "o", ")", ")", "return", "''", ".", "join", "(", "chunks", ")" ]
Return a JSON string representation of a Python data structure. >>> JSONEncoder().encode({"foo": ["bar", "baz"]}) '{"foo":["bar", "baz"]}'
[ "Return", "a", "JSON", "string", "representation", "of", "a", "Python", "data", "structure", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/contrib/public/services/simplejson/encoder.py#L278-L289
train
877
finklabs/metrics
metrics/compute.py
compute_file_metrics
def compute_file_metrics(processors, language, key, token_list): """use processors to compute file metrics.""" # multiply iterator tli = itertools.tee(token_list, len(processors)) metrics = OrderedDict() # reset all processors for p in processors: p.reset() # process all tokens for p, tl in zip(processors, tli): p.process_file(language, key, tl) # collect metrics from all processors for p in processors: metrics.update(p.metrics) return metrics
python
def compute_file_metrics(processors, language, key, token_list): """use processors to compute file metrics.""" # multiply iterator tli = itertools.tee(token_list, len(processors)) metrics = OrderedDict() # reset all processors for p in processors: p.reset() # process all tokens for p, tl in zip(processors, tli): p.process_file(language, key, tl) # collect metrics from all processors for p in processors: metrics.update(p.metrics) return metrics
[ "def", "compute_file_metrics", "(", "processors", ",", "language", ",", "key", ",", "token_list", ")", ":", "# multiply iterator", "tli", "=", "itertools", ".", "tee", "(", "token_list", ",", "len", "(", "processors", ")", ")", "metrics", "=", "OrderedDict", "(", ")", "# reset all processors", "for", "p", "in", "processors", ":", "p", ".", "reset", "(", ")", "# process all tokens", "for", "p", ",", "tl", "in", "zip", "(", "processors", ",", "tli", ")", ":", "p", ".", "process_file", "(", "language", ",", "key", ",", "tl", ")", "# collect metrics from all processors", "for", "p", "in", "processors", ":", "metrics", ".", "update", "(", "p", ".", "metrics", ")", "return", "metrics" ]
use processors to compute file metrics.
[ "use", "processors", "to", "compute", "file", "metrics", "." ]
fd9974af498831664b9ae8e8f3834e1ec2e8a699
https://github.com/finklabs/metrics/blob/fd9974af498831664b9ae8e8f3834e1ec2e8a699/metrics/compute.py#L8-L26
train
878
Liebeck/IWNLP-py
iwnlp/iwnlp_wrapper.py
IWNLPWrapper.load
def load(self, lemmatizer_path): """ This methods load the IWNLP.Lemmatizer json file and creates a dictionary of lowercased forms which maps each form to its possible lemmas. """ self.lemmatizer = {} with io.open(lemmatizer_path, encoding='utf-8') as data_file: raw = json.load(data_file) for entry in raw: self.lemmatizer[entry["Form"]] = entry["Lemmas"] self.apply_blacklist()
python
def load(self, lemmatizer_path): """ This methods load the IWNLP.Lemmatizer json file and creates a dictionary of lowercased forms which maps each form to its possible lemmas. """ self.lemmatizer = {} with io.open(lemmatizer_path, encoding='utf-8') as data_file: raw = json.load(data_file) for entry in raw: self.lemmatizer[entry["Form"]] = entry["Lemmas"] self.apply_blacklist()
[ "def", "load", "(", "self", ",", "lemmatizer_path", ")", ":", "self", ".", "lemmatizer", "=", "{", "}", "with", "io", ".", "open", "(", "lemmatizer_path", ",", "encoding", "=", "'utf-8'", ")", "as", "data_file", ":", "raw", "=", "json", ".", "load", "(", "data_file", ")", "for", "entry", "in", "raw", ":", "self", ".", "lemmatizer", "[", "entry", "[", "\"Form\"", "]", "]", "=", "entry", "[", "\"Lemmas\"", "]", "self", ".", "apply_blacklist", "(", ")" ]
This methods load the IWNLP.Lemmatizer json file and creates a dictionary of lowercased forms which maps each form to its possible lemmas.
[ "This", "methods", "load", "the", "IWNLP", ".", "Lemmatizer", "json", "file", "and", "creates", "a", "dictionary", "of", "lowercased", "forms", "which", "maps", "each", "form", "to", "its", "possible", "lemmas", "." ]
fd4b81769317476eac0487396cce0faf482a1913
https://github.com/Liebeck/IWNLP-py/blob/fd4b81769317476eac0487396cce0faf482a1913/iwnlp/iwnlp_wrapper.py#L14-L24
train
879
rwl/pylon
pylon/io/common.py
_CaseWriter.write
def write(self, file_or_filename): """ Writes the case data to file. """ if isinstance(file_or_filename, basestring): file = None try: file = open(file_or_filename, "wb") except Exception, detail: logger.error("Error opening %s." % detail) finally: if file is not None: self._write_data(file) file.close() else: file = file_or_filename self._write_data(file) return file
python
def write(self, file_or_filename): """ Writes the case data to file. """ if isinstance(file_or_filename, basestring): file = None try: file = open(file_or_filename, "wb") except Exception, detail: logger.error("Error opening %s." % detail) finally: if file is not None: self._write_data(file) file.close() else: file = file_or_filename self._write_data(file) return file
[ "def", "write", "(", "self", ",", "file_or_filename", ")", ":", "if", "isinstance", "(", "file_or_filename", ",", "basestring", ")", ":", "file", "=", "None", "try", ":", "file", "=", "open", "(", "file_or_filename", ",", "\"wb\"", ")", "except", "Exception", ",", "detail", ":", "logger", ".", "error", "(", "\"Error opening %s.\"", "%", "detail", ")", "finally", ":", "if", "file", "is", "not", "None", ":", "self", ".", "_write_data", "(", "file", ")", "file", ".", "close", "(", ")", "else", ":", "file", "=", "file_or_filename", "self", ".", "_write_data", "(", "file", ")", "return", "file" ]
Writes the case data to file.
[ "Writes", "the", "case", "data", "to", "file", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/io/common.py#L64-L81
train
880
rwl/pylon
pyreto/discrete/task.py
ProfitTask.performAction
def performAction(self, action): """ The action vector is stripped and the only element is cast to integer and given to the super class. """ self.t += 1 super(ProfitTask, self).performAction(int(action[0])) self.samples += 1
python
def performAction(self, action): """ The action vector is stripped and the only element is cast to integer and given to the super class. """ self.t += 1 super(ProfitTask, self).performAction(int(action[0])) self.samples += 1
[ "def", "performAction", "(", "self", ",", "action", ")", ":", "self", ".", "t", "+=", "1", "super", "(", "ProfitTask", ",", "self", ")", ".", "performAction", "(", "int", "(", "action", "[", "0", "]", ")", ")", "self", ".", "samples", "+=", "1" ]
The action vector is stripped and the only element is cast to integer and given to the super class.
[ "The", "action", "vector", "is", "stripped", "and", "the", "only", "element", "is", "cast", "to", "integer", "and", "given", "to", "the", "super", "class", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/discrete/task.py#L120-L126
train
881
rwl/pylon
pyreto/discrete/task.py
ProfitTask.addReward
def addReward(self, r=None): """ A filtered mapping towards performAction of the underlying environment. """ r = self.getReward() if r is None else r # by default, the cumulative reward is just the sum over the episode if self.discount: self.cumulativeReward += power(self.discount, self.samples) * r else: self.cumulativeReward += r
python
def addReward(self, r=None): """ A filtered mapping towards performAction of the underlying environment. """ r = self.getReward() if r is None else r # by default, the cumulative reward is just the sum over the episode if self.discount: self.cumulativeReward += power(self.discount, self.samples) * r else: self.cumulativeReward += r
[ "def", "addReward", "(", "self", ",", "r", "=", "None", ")", ":", "r", "=", "self", ".", "getReward", "(", ")", "if", "r", "is", "None", "else", "r", "# by default, the cumulative reward is just the sum over the episode", "if", "self", ".", "discount", ":", "self", ".", "cumulativeReward", "+=", "power", "(", "self", ".", "discount", ",", "self", ".", "samples", ")", "*", "r", "else", ":", "self", ".", "cumulativeReward", "+=", "r" ]
A filtered mapping towards performAction of the underlying environment.
[ "A", "filtered", "mapping", "towards", "performAction", "of", "the", "underlying", "environment", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/discrete/task.py#L156-L166
train
882
rwl/pylon
pylon/estimator.py
StateEstimator.getV0
def getV0(self, v_mag_guess, buses, generators, type=CASE_GUESS): """ Returns the initial voltage profile. """ if type == CASE_GUESS: Va = array([b.v_angle * (pi / 180.0) for b in buses]) Vm = array([b.v_magnitude for b in buses]) V0 = Vm * exp(1j * Va) elif type == FLAT_START: V0 = ones(len(buses)) elif type == FROM_INPUT: V0 = v_mag_guess else: raise ValueError # Set the voltages of PV buses and the reference bus in the guess. # online = [g for g in self.case.generators if g.online] gbus = [g.bus._i for g in generators] Vg = array([g.v_magnitude for g in generators]) V0[gbus] = Vg * abs(V0[gbus]) / V0[gbus] return V0
python
def getV0(self, v_mag_guess, buses, generators, type=CASE_GUESS): """ Returns the initial voltage profile. """ if type == CASE_GUESS: Va = array([b.v_angle * (pi / 180.0) for b in buses]) Vm = array([b.v_magnitude for b in buses]) V0 = Vm * exp(1j * Va) elif type == FLAT_START: V0 = ones(len(buses)) elif type == FROM_INPUT: V0 = v_mag_guess else: raise ValueError # Set the voltages of PV buses and the reference bus in the guess. # online = [g for g in self.case.generators if g.online] gbus = [g.bus._i for g in generators] Vg = array([g.v_magnitude for g in generators]) V0[gbus] = Vg * abs(V0[gbus]) / V0[gbus] return V0
[ "def", "getV0", "(", "self", ",", "v_mag_guess", ",", "buses", ",", "generators", ",", "type", "=", "CASE_GUESS", ")", ":", "if", "type", "==", "CASE_GUESS", ":", "Va", "=", "array", "(", "[", "b", ".", "v_angle", "*", "(", "pi", "/", "180.0", ")", "for", "b", "in", "buses", "]", ")", "Vm", "=", "array", "(", "[", "b", ".", "v_magnitude", "for", "b", "in", "buses", "]", ")", "V0", "=", "Vm", "*", "exp", "(", "1j", "*", "Va", ")", "elif", "type", "==", "FLAT_START", ":", "V0", "=", "ones", "(", "len", "(", "buses", ")", ")", "elif", "type", "==", "FROM_INPUT", ":", "V0", "=", "v_mag_guess", "else", ":", "raise", "ValueError", "# Set the voltages of PV buses and the reference bus in the guess.", "# online = [g for g in self.case.generators if g.online]", "gbus", "=", "[", "g", ".", "bus", ".", "_i", "for", "g", "in", "generators", "]", "Vg", "=", "array", "(", "[", "g", ".", "v_magnitude", "for", "g", "in", "generators", "]", ")", "V0", "[", "gbus", "]", "=", "Vg", "*", "abs", "(", "V0", "[", "gbus", "]", ")", "/", "V0", "[", "gbus", "]", "return", "V0" ]
Returns the initial voltage profile.
[ "Returns", "the", "initial", "voltage", "profile", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/estimator.py#L300-L321
train
883
rwl/pylon
pylon/estimator.py
StateEstimator.output_solution
def output_solution(self, fd, z, z_est, error_sqrsum): """ Prints comparison of measurements and their estimations. """ col_width = 11 sep = ("=" * col_width + " ") * 4 + "\n" fd.write("State Estimation\n") fd.write("-" * 16 + "\n") fd.write(sep) fd.write("Type".center(col_width) + " ") fd.write("Name".center(col_width) + " ") fd.write("Measurement".center(col_width) + " ") fd.write("Estimation".center(col_width) + " ") fd.write("\n") fd.write(sep) c = 0 for t in [PF, PT, QF, QT, PG, QG, VM, VA]: for meas in self.measurements: if meas.type == t: n = meas.b_or_l.name[:col_width].ljust(col_width) fd.write(t.ljust(col_width) + " ") fd.write(n + " ") fd.write("%11.5f " % z[c]) fd.write("%11.5f\n" % z_est[c]) # fd.write("%s\t%s\t%.3f\t%.3f\n" % (t, n, z[c], z_est[c])) c += 1 fd.write("\nWeighted sum of error squares = %.4f\n" % error_sqrsum)
python
def output_solution(self, fd, z, z_est, error_sqrsum): """ Prints comparison of measurements and their estimations. """ col_width = 11 sep = ("=" * col_width + " ") * 4 + "\n" fd.write("State Estimation\n") fd.write("-" * 16 + "\n") fd.write(sep) fd.write("Type".center(col_width) + " ") fd.write("Name".center(col_width) + " ") fd.write("Measurement".center(col_width) + " ") fd.write("Estimation".center(col_width) + " ") fd.write("\n") fd.write(sep) c = 0 for t in [PF, PT, QF, QT, PG, QG, VM, VA]: for meas in self.measurements: if meas.type == t: n = meas.b_or_l.name[:col_width].ljust(col_width) fd.write(t.ljust(col_width) + " ") fd.write(n + " ") fd.write("%11.5f " % z[c]) fd.write("%11.5f\n" % z_est[c]) # fd.write("%s\t%s\t%.3f\t%.3f\n" % (t, n, z[c], z_est[c])) c += 1 fd.write("\nWeighted sum of error squares = %.4f\n" % error_sqrsum)
[ "def", "output_solution", "(", "self", ",", "fd", ",", "z", ",", "z_est", ",", "error_sqrsum", ")", ":", "col_width", "=", "11", "sep", "=", "(", "\"=\"", "*", "col_width", "+", "\" \"", ")", "*", "4", "+", "\"\\n\"", "fd", ".", "write", "(", "\"State Estimation\\n\"", ")", "fd", ".", "write", "(", "\"-\"", "*", "16", "+", "\"\\n\"", ")", "fd", ".", "write", "(", "sep", ")", "fd", ".", "write", "(", "\"Type\"", ".", "center", "(", "col_width", ")", "+", "\" \"", ")", "fd", ".", "write", "(", "\"Name\"", ".", "center", "(", "col_width", ")", "+", "\" \"", ")", "fd", ".", "write", "(", "\"Measurement\"", ".", "center", "(", "col_width", ")", "+", "\" \"", ")", "fd", ".", "write", "(", "\"Estimation\"", ".", "center", "(", "col_width", ")", "+", "\" \"", ")", "fd", ".", "write", "(", "\"\\n\"", ")", "fd", ".", "write", "(", "sep", ")", "c", "=", "0", "for", "t", "in", "[", "PF", ",", "PT", ",", "QF", ",", "QT", ",", "PG", ",", "QG", ",", "VM", ",", "VA", "]", ":", "for", "meas", "in", "self", ".", "measurements", ":", "if", "meas", ".", "type", "==", "t", ":", "n", "=", "meas", ".", "b_or_l", ".", "name", "[", ":", "col_width", "]", ".", "ljust", "(", "col_width", ")", "fd", ".", "write", "(", "t", ".", "ljust", "(", "col_width", ")", "+", "\" \"", ")", "fd", ".", "write", "(", "n", "+", "\" \"", ")", "fd", ".", "write", "(", "\"%11.5f \"", "%", "z", "[", "c", "]", ")", "fd", ".", "write", "(", "\"%11.5f\\n\"", "%", "z_est", "[", "c", "]", ")", "# fd.write(\"%s\\t%s\\t%.3f\\t%.3f\\n\" % (t, n, z[c], z_est[c]))", "c", "+=", "1", "fd", ".", "write", "(", "\"\\nWeighted sum of error squares = %.4f\\n\"", "%", "error_sqrsum", ")" ]
Prints comparison of measurements and their estimations.
[ "Prints", "comparison", "of", "measurements", "and", "their", "estimations", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pylon/estimator.py#L324-L352
train
884
rwl/pylon
pyreto/auction.py
Auction.run
def run(self): """ Clears a set of bids and offers. """ # Compute cleared offer/bid quantities from total dispatched quantity. self._clearQuantities() # Compute shift values to add to lam to get desired pricing. # lao, fro, lab, frb = self._first_rejected_last_accepted() # Clear offer/bid prices according to auction type. self._clearPrices() # self._clear_prices(lao, fro, lab, frb) # Clip cleared prices according to guarantees and limits. self._clipPrices() self._logClearances() return self.offers, self.bids
python
def run(self): """ Clears a set of bids and offers. """ # Compute cleared offer/bid quantities from total dispatched quantity. self._clearQuantities() # Compute shift values to add to lam to get desired pricing. # lao, fro, lab, frb = self._first_rejected_last_accepted() # Clear offer/bid prices according to auction type. self._clearPrices() # self._clear_prices(lao, fro, lab, frb) # Clip cleared prices according to guarantees and limits. self._clipPrices() self._logClearances() return self.offers, self.bids
[ "def", "run", "(", "self", ")", ":", "# Compute cleared offer/bid quantities from total dispatched quantity.", "self", ".", "_clearQuantities", "(", ")", "# Compute shift values to add to lam to get desired pricing.", "# lao, fro, lab, frb = self._first_rejected_last_accepted()", "# Clear offer/bid prices according to auction type.", "self", ".", "_clearPrices", "(", ")", "# self._clear_prices(lao, fro, lab, frb)", "# Clip cleared prices according to guarantees and limits.", "self", ".", "_clipPrices", "(", ")", "self", ".", "_logClearances", "(", ")", "return", "self", ".", "offers", ",", "self", ".", "bids" ]
Clears a set of bids and offers.
[ "Clears", "a", "set", "of", "bids", "and", "offers", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/auction.py#L85-L103
train
885
rwl/pylon
pyreto/auction.py
Auction._clearQuantity
def _clearQuantity(self, offbids, gen): """ Computes the cleared bid quantity from total dispatched quantity. """ # Filter out offers/bids not applicable to the generator in question. gOffbids = [offer for offer in offbids if offer.generator == gen] # Offers/bids within valid price limits (not withheld). valid = [ob for ob in gOffbids if not ob.withheld] # Sort offers by price in ascending order and bids in decending order. valid.sort(key=lambda ob: ob.price, reverse=[False, True][gen.is_load]) acceptedQty = 0.0 for ob in valid: # Compute the fraction of the block accepted. accepted = (ob.totalQuantity - acceptedQty) / ob.quantity # Clip to the range 0-1. if accepted > 1.0: accepted = 1.0 elif accepted < 1.0e-05: accepted = 0.0 ob.clearedQuantity = accepted * ob.quantity ob.accepted = (accepted > 0.0) # Log the event. # if ob.accepted: # logger.info("%s [%s, %.3f, %.3f] accepted at %.2f MW." % # (ob.__class__.__name__, ob.generator.name, ob.quantity, # ob.price, ob.clearedQuantity)) # else: # logger.info("%s [%s, %.3f, %.3f] rejected." % # (ob.__class__.__name__, ob.generator.name, ob.quantity, # ob.price)) # Increment the accepted quantity. acceptedQty += ob.quantity
python
def _clearQuantity(self, offbids, gen): """ Computes the cleared bid quantity from total dispatched quantity. """ # Filter out offers/bids not applicable to the generator in question. gOffbids = [offer for offer in offbids if offer.generator == gen] # Offers/bids within valid price limits (not withheld). valid = [ob for ob in gOffbids if not ob.withheld] # Sort offers by price in ascending order and bids in decending order. valid.sort(key=lambda ob: ob.price, reverse=[False, True][gen.is_load]) acceptedQty = 0.0 for ob in valid: # Compute the fraction of the block accepted. accepted = (ob.totalQuantity - acceptedQty) / ob.quantity # Clip to the range 0-1. if accepted > 1.0: accepted = 1.0 elif accepted < 1.0e-05: accepted = 0.0 ob.clearedQuantity = accepted * ob.quantity ob.accepted = (accepted > 0.0) # Log the event. # if ob.accepted: # logger.info("%s [%s, %.3f, %.3f] accepted at %.2f MW." % # (ob.__class__.__name__, ob.generator.name, ob.quantity, # ob.price, ob.clearedQuantity)) # else: # logger.info("%s [%s, %.3f, %.3f] rejected." % # (ob.__class__.__name__, ob.generator.name, ob.quantity, # ob.price)) # Increment the accepted quantity. acceptedQty += ob.quantity
[ "def", "_clearQuantity", "(", "self", ",", "offbids", ",", "gen", ")", ":", "# Filter out offers/bids not applicable to the generator in question.", "gOffbids", "=", "[", "offer", "for", "offer", "in", "offbids", "if", "offer", ".", "generator", "==", "gen", "]", "# Offers/bids within valid price limits (not withheld).", "valid", "=", "[", "ob", "for", "ob", "in", "gOffbids", "if", "not", "ob", ".", "withheld", "]", "# Sort offers by price in ascending order and bids in decending order.", "valid", ".", "sort", "(", "key", "=", "lambda", "ob", ":", "ob", ".", "price", ",", "reverse", "=", "[", "False", ",", "True", "]", "[", "gen", ".", "is_load", "]", ")", "acceptedQty", "=", "0.0", "for", "ob", "in", "valid", ":", "# Compute the fraction of the block accepted.", "accepted", "=", "(", "ob", ".", "totalQuantity", "-", "acceptedQty", ")", "/", "ob", ".", "quantity", "# Clip to the range 0-1.", "if", "accepted", ">", "1.0", ":", "accepted", "=", "1.0", "elif", "accepted", "<", "1.0e-05", ":", "accepted", "=", "0.0", "ob", ".", "clearedQuantity", "=", "accepted", "*", "ob", ".", "quantity", "ob", ".", "accepted", "=", "(", "accepted", ">", "0.0", ")", "# Log the event.", "# if ob.accepted:", "# logger.info(\"%s [%s, %.3f, %.3f] accepted at %.2f MW.\" %", "# (ob.__class__.__name__, ob.generator.name, ob.quantity,", "# ob.price, ob.clearedQuantity))", "# else:", "# logger.info(\"%s [%s, %.3f, %.3f] rejected.\" %", "# (ob.__class__.__name__, ob.generator.name, ob.quantity,", "# ob.price))", "# Increment the accepted quantity.", "acceptedQty", "+=", "ob", ".", "quantity" ]
Computes the cleared bid quantity from total dispatched quantity.
[ "Computes", "the", "cleared", "bid", "quantity", "from", "total", "dispatched", "quantity", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/auction.py#L120-L158
train
886
rwl/pylon
pyreto/auction.py
Auction._clearPrices
def _clearPrices(self): """ Clears prices according to auction type. """ for offbid in self.offers + self.bids: if self.auctionType == DISCRIMINATIVE: offbid.clearedPrice = offbid.price elif self.auctionType == FIRST_PRICE: offbid.clearedPrice = offbid.lmbda else: raise ValueError
python
def _clearPrices(self): """ Clears prices according to auction type. """ for offbid in self.offers + self.bids: if self.auctionType == DISCRIMINATIVE: offbid.clearedPrice = offbid.price elif self.auctionType == FIRST_PRICE: offbid.clearedPrice = offbid.lmbda else: raise ValueError
[ "def", "_clearPrices", "(", "self", ")", ":", "for", "offbid", "in", "self", ".", "offers", "+", "self", ".", "bids", ":", "if", "self", ".", "auctionType", "==", "DISCRIMINATIVE", ":", "offbid", ".", "clearedPrice", "=", "offbid", ".", "price", "elif", "self", ".", "auctionType", "==", "FIRST_PRICE", ":", "offbid", ".", "clearedPrice", "=", "offbid", ".", "lmbda", "else", ":", "raise", "ValueError" ]
Clears prices according to auction type.
[ "Clears", "prices", "according", "to", "auction", "type", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/auction.py#L219-L228
train
887
rwl/pylon
pyreto/auction.py
Auction._clipPrices
def _clipPrices(self): """ Clip cleared prices according to guarantees and limits. """ # Guarantee that cleared offer prices are >= offers. if self.guaranteeOfferPrice: for offer in self.offers: if offer.accepted and offer.clearedPrice < offer.price: offer.clearedPrice = offer.price # Guarantee that cleared bid prices are <= bids. if self.guaranteeBidPrice: for bid in self.bids: if bid.accepted and bid.clearedPrice > bid.price: bid.clearedPrice = bid.price # Clip cleared offer prices. if self.limits.has_key("maxClearedOffer"): maxClearedOffer = self.limits["maxClearedOffer"] for offer in self.offers: if offer.clearedPrice > maxClearedOffer: offer.clearedPrice = maxClearedOffer # Clip cleared bid prices. if self.limits.has_key("minClearedBid"): minClearedBid = self.limits["minClearedBid"] for bid in self.bids: if bid.clearedPrice < minClearedBid: bid.clearedPrice = minClearedBid # Make prices uniform across all offers/bids for each generator after # clipping (except for discrim auction) since clipping may only affect # a single block of a multi-block generator. if self.auctionType != DISCRIMINATIVE: for g in self.case.generators: gOffers = [of for of in self.offers if of.generator == g] if gOffers: uniformPrice = max([of.clearedPrice for of in gOffers]) for of in gOffers: of.clearedPrice = uniformPrice gBids = [bid for bid in self.bids if bid.vLoad == g] if gBids: uniformPrice = min([bid.cleared_price for bid in gBids]) for bid in gBids: bid.clearedPrice = uniformPrice
python
def _clipPrices(self): """ Clip cleared prices according to guarantees and limits. """ # Guarantee that cleared offer prices are >= offers. if self.guaranteeOfferPrice: for offer in self.offers: if offer.accepted and offer.clearedPrice < offer.price: offer.clearedPrice = offer.price # Guarantee that cleared bid prices are <= bids. if self.guaranteeBidPrice: for bid in self.bids: if bid.accepted and bid.clearedPrice > bid.price: bid.clearedPrice = bid.price # Clip cleared offer prices. if self.limits.has_key("maxClearedOffer"): maxClearedOffer = self.limits["maxClearedOffer"] for offer in self.offers: if offer.clearedPrice > maxClearedOffer: offer.clearedPrice = maxClearedOffer # Clip cleared bid prices. if self.limits.has_key("minClearedBid"): minClearedBid = self.limits["minClearedBid"] for bid in self.bids: if bid.clearedPrice < minClearedBid: bid.clearedPrice = minClearedBid # Make prices uniform across all offers/bids for each generator after # clipping (except for discrim auction) since clipping may only affect # a single block of a multi-block generator. if self.auctionType != DISCRIMINATIVE: for g in self.case.generators: gOffers = [of for of in self.offers if of.generator == g] if gOffers: uniformPrice = max([of.clearedPrice for of in gOffers]) for of in gOffers: of.clearedPrice = uniformPrice gBids = [bid for bid in self.bids if bid.vLoad == g] if gBids: uniformPrice = min([bid.cleared_price for bid in gBids]) for bid in gBids: bid.clearedPrice = uniformPrice
[ "def", "_clipPrices", "(", "self", ")", ":", "# Guarantee that cleared offer prices are >= offers.", "if", "self", ".", "guaranteeOfferPrice", ":", "for", "offer", "in", "self", ".", "offers", ":", "if", "offer", ".", "accepted", "and", "offer", ".", "clearedPrice", "<", "offer", ".", "price", ":", "offer", ".", "clearedPrice", "=", "offer", ".", "price", "# Guarantee that cleared bid prices are <= bids.", "if", "self", ".", "guaranteeBidPrice", ":", "for", "bid", "in", "self", ".", "bids", ":", "if", "bid", ".", "accepted", "and", "bid", ".", "clearedPrice", ">", "bid", ".", "price", ":", "bid", ".", "clearedPrice", "=", "bid", ".", "price", "# Clip cleared offer prices.", "if", "self", ".", "limits", ".", "has_key", "(", "\"maxClearedOffer\"", ")", ":", "maxClearedOffer", "=", "self", ".", "limits", "[", "\"maxClearedOffer\"", "]", "for", "offer", "in", "self", ".", "offers", ":", "if", "offer", ".", "clearedPrice", ">", "maxClearedOffer", ":", "offer", ".", "clearedPrice", "=", "maxClearedOffer", "# Clip cleared bid prices.", "if", "self", ".", "limits", ".", "has_key", "(", "\"minClearedBid\"", ")", ":", "minClearedBid", "=", "self", ".", "limits", "[", "\"minClearedBid\"", "]", "for", "bid", "in", "self", ".", "bids", ":", "if", "bid", ".", "clearedPrice", "<", "minClearedBid", ":", "bid", ".", "clearedPrice", "=", "minClearedBid", "# Make prices uniform across all offers/bids for each generator after", "# clipping (except for discrim auction) since clipping may only affect", "# a single block of a multi-block generator.", "if", "self", ".", "auctionType", "!=", "DISCRIMINATIVE", ":", "for", "g", "in", "self", ".", "case", ".", "generators", ":", "gOffers", "=", "[", "of", "for", "of", "in", "self", ".", "offers", "if", "of", ".", "generator", "==", "g", "]", "if", "gOffers", ":", "uniformPrice", "=", "max", "(", "[", "of", ".", "clearedPrice", "for", "of", "in", "gOffers", "]", ")", "for", "of", "in", "gOffers", ":", "of", ".", "clearedPrice", "=", "uniformPrice", "gBids", "=", "[", "bid", "for", "bid", "in", "self", ".", "bids", "if", "bid", ".", "vLoad", "==", "g", "]", "if", "gBids", ":", "uniformPrice", "=", "min", "(", "[", "bid", ".", "cleared_price", "for", "bid", "in", "gBids", "]", ")", "for", "bid", "in", "gBids", ":", "bid", ".", "clearedPrice", "=", "uniformPrice" ]
Clip cleared prices according to guarantees and limits.
[ "Clip", "cleared", "prices", "according", "to", "guarantees", "and", "limits", "." ]
916514255db1ae1661406f0283df756baf960d14
https://github.com/rwl/pylon/blob/916514255db1ae1661406f0283df756baf960d14/pyreto/auction.py#L265-L311
train
888
praekeltfoundation/seaworthy
seaworthy/client.py
wait_for_response
def wait_for_response(client, timeout, path='/', expected_status_code=None): """ Try make a GET request with an HTTP client against a certain path and return once any response has been received, ignoring any errors. :param ContainerHttpClient client: The HTTP client to use to connect to the container. :param timeout: Timeout value in seconds. :param path: HTTP path to request. :param int expected_status_code: If set, wait until a response with this status code is received. If not set, the status code will not be checked. :raises TimeoutError: If a request fails to be made within the timeout period. """ # We want time.monotonic on Pythons that have it, otherwise time.time will # have to do. get_time = getattr(time, 'monotonic', time.time) deadline = get_time() + timeout while True: try: # Don't care what the response is, as long as we get one time_left = deadline - get_time() response = client.get( path, timeout=max(time_left, 0.001), allow_redirects=False) if (expected_status_code is None or response.status_code == expected_status_code): return except requests.exceptions.Timeout: # Requests timed out, our time must be up break except Exception: # Ignore other exceptions pass if get_time() >= deadline: break time.sleep(0.1) raise TimeoutError('Timeout waiting for HTTP response.')
python
def wait_for_response(client, timeout, path='/', expected_status_code=None): """ Try make a GET request with an HTTP client against a certain path and return once any response has been received, ignoring any errors. :param ContainerHttpClient client: The HTTP client to use to connect to the container. :param timeout: Timeout value in seconds. :param path: HTTP path to request. :param int expected_status_code: If set, wait until a response with this status code is received. If not set, the status code will not be checked. :raises TimeoutError: If a request fails to be made within the timeout period. """ # We want time.monotonic on Pythons that have it, otherwise time.time will # have to do. get_time = getattr(time, 'monotonic', time.time) deadline = get_time() + timeout while True: try: # Don't care what the response is, as long as we get one time_left = deadline - get_time() response = client.get( path, timeout=max(time_left, 0.001), allow_redirects=False) if (expected_status_code is None or response.status_code == expected_status_code): return except requests.exceptions.Timeout: # Requests timed out, our time must be up break except Exception: # Ignore other exceptions pass if get_time() >= deadline: break time.sleep(0.1) raise TimeoutError('Timeout waiting for HTTP response.')
[ "def", "wait_for_response", "(", "client", ",", "timeout", ",", "path", "=", "'/'", ",", "expected_status_code", "=", "None", ")", ":", "# We want time.monotonic on Pythons that have it, otherwise time.time will", "# have to do.", "get_time", "=", "getattr", "(", "time", ",", "'monotonic'", ",", "time", ".", "time", ")", "deadline", "=", "get_time", "(", ")", "+", "timeout", "while", "True", ":", "try", ":", "# Don't care what the response is, as long as we get one", "time_left", "=", "deadline", "-", "get_time", "(", ")", "response", "=", "client", ".", "get", "(", "path", ",", "timeout", "=", "max", "(", "time_left", ",", "0.001", ")", ",", "allow_redirects", "=", "False", ")", "if", "(", "expected_status_code", "is", "None", "or", "response", ".", "status_code", "==", "expected_status_code", ")", ":", "return", "except", "requests", ".", "exceptions", ".", "Timeout", ":", "# Requests timed out, our time must be up", "break", "except", "Exception", ":", "# Ignore other exceptions", "pass", "if", "get_time", "(", ")", ">=", "deadline", ":", "break", "time", ".", "sleep", "(", "0.1", ")", "raise", "TimeoutError", "(", "'Timeout waiting for HTTP response.'", ")" ]
Try make a GET request with an HTTP client against a certain path and return once any response has been received, ignoring any errors. :param ContainerHttpClient client: The HTTP client to use to connect to the container. :param timeout: Timeout value in seconds. :param path: HTTP path to request. :param int expected_status_code: If set, wait until a response with this status code is received. If not set, the status code will not be checked. :raises TimeoutError: If a request fails to be made within the timeout period.
[ "Try", "make", "a", "GET", "request", "with", "an", "HTTP", "client", "against", "a", "certain", "path", "and", "return", "once", "any", "response", "has", "been", "received", "ignoring", "any", "errors", "." ]
6f10a19b45d4ea1dc3bd0553cc4d0438696c079c
https://github.com/praekeltfoundation/seaworthy/blob/6f10a19b45d4ea1dc3bd0553cc4d0438696c079c/seaworthy/client.py#L205-L248
train
889
praekeltfoundation/seaworthy
seaworthy/client.py
ContainerHttpClient.request
def request(self, method, path=None, url_kwargs=None, **kwargs): """ Make a request against a container. :param method: The HTTP method to use. :param list path: The HTTP path (either absolute or relative). :param dict url_kwargs: Parameters to override in the generated URL. See `~hyperlink.URL`. :param kwargs: Any other parameters to pass to Requests. """ return self._session.request( method, self._url(path, url_kwargs), **kwargs)
python
def request(self, method, path=None, url_kwargs=None, **kwargs): """ Make a request against a container. :param method: The HTTP method to use. :param list path: The HTTP path (either absolute or relative). :param dict url_kwargs: Parameters to override in the generated URL. See `~hyperlink.URL`. :param kwargs: Any other parameters to pass to Requests. """ return self._session.request( method, self._url(path, url_kwargs), **kwargs)
[ "def", "request", "(", "self", ",", "method", ",", "path", "=", "None", ",", "url_kwargs", "=", "None", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "_session", ".", "request", "(", "method", ",", "self", ".", "_url", "(", "path", ",", "url_kwargs", ")", ",", "*", "*", "kwargs", ")" ]
Make a request against a container. :param method: The HTTP method to use. :param list path: The HTTP path (either absolute or relative). :param dict url_kwargs: Parameters to override in the generated URL. See `~hyperlink.URL`. :param kwargs: Any other parameters to pass to Requests.
[ "Make", "a", "request", "against", "a", "container", "." ]
6f10a19b45d4ea1dc3bd0553cc4d0438696c079c
https://github.com/praekeltfoundation/seaworthy/blob/6f10a19b45d4ea1dc3bd0553cc4d0438696c079c/seaworthy/client.py#L90-L104
train
890
praekeltfoundation/seaworthy
seaworthy/client.py
ContainerHttpClient.options
def options(self, path=None, url_kwargs=None, **kwargs): """ Sends an OPTIONS request. :param path: The HTTP path (either absolute or relative). :param url_kwargs: Parameters to override in the generated URL. See `~hyperlink.URL`. :param **kwargs: Optional arguments that ``request`` takes. :return: response object """ return self._session.options(self._url(path, url_kwargs), **kwargs)
python
def options(self, path=None, url_kwargs=None, **kwargs): """ Sends an OPTIONS request. :param path: The HTTP path (either absolute or relative). :param url_kwargs: Parameters to override in the generated URL. See `~hyperlink.URL`. :param **kwargs: Optional arguments that ``request`` takes. :return: response object """ return self._session.options(self._url(path, url_kwargs), **kwargs)
[ "def", "options", "(", "self", ",", "path", "=", "None", ",", "url_kwargs", "=", "None", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "_session", ".", "options", "(", "self", ".", "_url", "(", "path", ",", "url_kwargs", ")", ",", "*", "*", "kwargs", ")" ]
Sends an OPTIONS request. :param path: The HTTP path (either absolute or relative). :param url_kwargs: Parameters to override in the generated URL. See `~hyperlink.URL`. :param **kwargs: Optional arguments that ``request`` takes. :return: response object
[ "Sends", "an", "OPTIONS", "request", "." ]
6f10a19b45d4ea1dc3bd0553cc4d0438696c079c
https://github.com/praekeltfoundation/seaworthy/blob/6f10a19b45d4ea1dc3bd0553cc4d0438696c079c/seaworthy/client.py#L120-L132
train
891
praekeltfoundation/seaworthy
seaworthy/client.py
ContainerHttpClient.head
def head(self, path=None, url_kwargs=None, **kwargs): """ Sends a HEAD request. :param path: The HTTP path (either absolute or relative). :param url_kwargs: Parameters to override in the generated URL. See `~hyperlink.URL`. :param **kwargs: Optional arguments that ``request`` takes. :return: response object """ return self._session.head(self._url(path, url_kwargs), **kwargs)
python
def head(self, path=None, url_kwargs=None, **kwargs): """ Sends a HEAD request. :param path: The HTTP path (either absolute or relative). :param url_kwargs: Parameters to override in the generated URL. See `~hyperlink.URL`. :param **kwargs: Optional arguments that ``request`` takes. :return: response object """ return self._session.head(self._url(path, url_kwargs), **kwargs)
[ "def", "head", "(", "self", ",", "path", "=", "None", ",", "url_kwargs", "=", "None", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "_session", ".", "head", "(", "self", ".", "_url", "(", "path", ",", "url_kwargs", ")", ",", "*", "*", "kwargs", ")" ]
Sends a HEAD request. :param path: The HTTP path (either absolute or relative). :param url_kwargs: Parameters to override in the generated URL. See `~hyperlink.URL`. :param **kwargs: Optional arguments that ``request`` takes. :return: response object
[ "Sends", "a", "HEAD", "request", "." ]
6f10a19b45d4ea1dc3bd0553cc4d0438696c079c
https://github.com/praekeltfoundation/seaworthy/blob/6f10a19b45d4ea1dc3bd0553cc4d0438696c079c/seaworthy/client.py#L134-L146
train
892
praekeltfoundation/seaworthy
seaworthy/client.py
ContainerHttpClient.post
def post(self, path=None, url_kwargs=None, **kwargs): """ Sends a POST request. :param path: The HTTP path (either absolute or relative). :param url_kwargs: Parameters to override in the generated URL. See `~hyperlink.URL`. :param **kwargs: Optional arguments that ``request`` takes. :return: response object """ return self._session.post(self._url(path, url_kwargs), **kwargs)
python
def post(self, path=None, url_kwargs=None, **kwargs): """ Sends a POST request. :param path: The HTTP path (either absolute or relative). :param url_kwargs: Parameters to override in the generated URL. See `~hyperlink.URL`. :param **kwargs: Optional arguments that ``request`` takes. :return: response object """ return self._session.post(self._url(path, url_kwargs), **kwargs)
[ "def", "post", "(", "self", ",", "path", "=", "None", ",", "url_kwargs", "=", "None", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "_session", ".", "post", "(", "self", ".", "_url", "(", "path", ",", "url_kwargs", ")", ",", "*", "*", "kwargs", ")" ]
Sends a POST request. :param path: The HTTP path (either absolute or relative). :param url_kwargs: Parameters to override in the generated URL. See `~hyperlink.URL`. :param **kwargs: Optional arguments that ``request`` takes. :return: response object
[ "Sends", "a", "POST", "request", "." ]
6f10a19b45d4ea1dc3bd0553cc4d0438696c079c
https://github.com/praekeltfoundation/seaworthy/blob/6f10a19b45d4ea1dc3bd0553cc4d0438696c079c/seaworthy/client.py#L148-L160
train
893
ratt-ru/PyMORESANE
pymoresane/iuwt.py
iuwt_decomposition
def iuwt_decomposition(in1, scale_count, scale_adjust=0, mode='ser', core_count=2, store_smoothed=False, store_on_gpu=False): """ This function serves as a handler for the different implementations of the IUWT decomposition. It allows the different methods to be used almost interchangeably. INPUTS: in1 (no default): Array on which the decomposition is to be performed. scale_count (no default): Maximum scale to be considered. scale_adjust (default=0): Adjustment to scale value if first scales are of no interest. mode (default='ser'): Implementation of the IUWT to be used - 'ser', 'mp' or 'gpu'. core_count (default=1): Additional option for multiprocessing - specifies core count. store_smoothed (default=False): Boolean specifier for whether the smoothed image is stored or not. store_on_gpu (default=False): Boolean specifier for whether the decomposition is stored on the gpu or not. OUTPUTS: Returns the decomposition with the additional smoothed coefficients if specified. """ if mode=='ser': return ser_iuwt_decomposition(in1, scale_count, scale_adjust, store_smoothed) elif mode=='mp': return mp_iuwt_decomposition(in1, scale_count, scale_adjust, store_smoothed, core_count) elif mode=='gpu': return gpu_iuwt_decomposition(in1, scale_count, scale_adjust, store_smoothed, store_on_gpu)
python
def iuwt_decomposition(in1, scale_count, scale_adjust=0, mode='ser', core_count=2, store_smoothed=False, store_on_gpu=False): """ This function serves as a handler for the different implementations of the IUWT decomposition. It allows the different methods to be used almost interchangeably. INPUTS: in1 (no default): Array on which the decomposition is to be performed. scale_count (no default): Maximum scale to be considered. scale_adjust (default=0): Adjustment to scale value if first scales are of no interest. mode (default='ser'): Implementation of the IUWT to be used - 'ser', 'mp' or 'gpu'. core_count (default=1): Additional option for multiprocessing - specifies core count. store_smoothed (default=False): Boolean specifier for whether the smoothed image is stored or not. store_on_gpu (default=False): Boolean specifier for whether the decomposition is stored on the gpu or not. OUTPUTS: Returns the decomposition with the additional smoothed coefficients if specified. """ if mode=='ser': return ser_iuwt_decomposition(in1, scale_count, scale_adjust, store_smoothed) elif mode=='mp': return mp_iuwt_decomposition(in1, scale_count, scale_adjust, store_smoothed, core_count) elif mode=='gpu': return gpu_iuwt_decomposition(in1, scale_count, scale_adjust, store_smoothed, store_on_gpu)
[ "def", "iuwt_decomposition", "(", "in1", ",", "scale_count", ",", "scale_adjust", "=", "0", ",", "mode", "=", "'ser'", ",", "core_count", "=", "2", ",", "store_smoothed", "=", "False", ",", "store_on_gpu", "=", "False", ")", ":", "if", "mode", "==", "'ser'", ":", "return", "ser_iuwt_decomposition", "(", "in1", ",", "scale_count", ",", "scale_adjust", ",", "store_smoothed", ")", "elif", "mode", "==", "'mp'", ":", "return", "mp_iuwt_decomposition", "(", "in1", ",", "scale_count", ",", "scale_adjust", ",", "store_smoothed", ",", "core_count", ")", "elif", "mode", "==", "'gpu'", ":", "return", "gpu_iuwt_decomposition", "(", "in1", ",", "scale_count", ",", "scale_adjust", ",", "store_smoothed", ",", "store_on_gpu", ")" ]
This function serves as a handler for the different implementations of the IUWT decomposition. It allows the different methods to be used almost interchangeably. INPUTS: in1 (no default): Array on which the decomposition is to be performed. scale_count (no default): Maximum scale to be considered. scale_adjust (default=0): Adjustment to scale value if first scales are of no interest. mode (default='ser'): Implementation of the IUWT to be used - 'ser', 'mp' or 'gpu'. core_count (default=1): Additional option for multiprocessing - specifies core count. store_smoothed (default=False): Boolean specifier for whether the smoothed image is stored or not. store_on_gpu (default=False): Boolean specifier for whether the decomposition is stored on the gpu or not. OUTPUTS: Returns the decomposition with the additional smoothed coefficients if specified.
[ "This", "function", "serves", "as", "a", "handler", "for", "the", "different", "implementations", "of", "the", "IUWT", "decomposition", ".", "It", "allows", "the", "different", "methods", "to", "be", "used", "almost", "interchangeably", "." ]
b024591ad0bbb69320d08841f28a2c27f62ae1af
https://github.com/ratt-ru/PyMORESANE/blob/b024591ad0bbb69320d08841f28a2c27f62ae1af/pymoresane/iuwt.py#L17-L41
train
894
ratt-ru/PyMORESANE
pymoresane/iuwt.py
iuwt_recomposition
def iuwt_recomposition(in1, scale_adjust=0, mode='ser', core_count=1, store_on_gpu=False, smoothed_array=None): """ This function serves as a handler for the different implementations of the IUWT recomposition. It allows the different methods to be used almost interchangeably. INPUTS: in1 (no default): Array on which the decomposition is to be performed. scale_adjust (no default): Number of omitted scales. mode (default='ser') Implementation of the IUWT to be used - 'ser', 'mp' or 'gpu'. core_count (default=1) Additional option for multiprocessing - specifies core count. store_on_gpu (default=False): Boolean specifier for whether the decomposition is stored on the gpu or not. OUTPUTS: Returns the recomposition. """ if mode=='ser': return ser_iuwt_recomposition(in1, scale_adjust, smoothed_array) elif mode=='mp': return mp_iuwt_recomposition(in1, scale_adjust, core_count, smoothed_array) elif mode=='gpu': return gpu_iuwt_recomposition(in1, scale_adjust, store_on_gpu, smoothed_array)
python
def iuwt_recomposition(in1, scale_adjust=0, mode='ser', core_count=1, store_on_gpu=False, smoothed_array=None): """ This function serves as a handler for the different implementations of the IUWT recomposition. It allows the different methods to be used almost interchangeably. INPUTS: in1 (no default): Array on which the decomposition is to be performed. scale_adjust (no default): Number of omitted scales. mode (default='ser') Implementation of the IUWT to be used - 'ser', 'mp' or 'gpu'. core_count (default=1) Additional option for multiprocessing - specifies core count. store_on_gpu (default=False): Boolean specifier for whether the decomposition is stored on the gpu or not. OUTPUTS: Returns the recomposition. """ if mode=='ser': return ser_iuwt_recomposition(in1, scale_adjust, smoothed_array) elif mode=='mp': return mp_iuwt_recomposition(in1, scale_adjust, core_count, smoothed_array) elif mode=='gpu': return gpu_iuwt_recomposition(in1, scale_adjust, store_on_gpu, smoothed_array)
[ "def", "iuwt_recomposition", "(", "in1", ",", "scale_adjust", "=", "0", ",", "mode", "=", "'ser'", ",", "core_count", "=", "1", ",", "store_on_gpu", "=", "False", ",", "smoothed_array", "=", "None", ")", ":", "if", "mode", "==", "'ser'", ":", "return", "ser_iuwt_recomposition", "(", "in1", ",", "scale_adjust", ",", "smoothed_array", ")", "elif", "mode", "==", "'mp'", ":", "return", "mp_iuwt_recomposition", "(", "in1", ",", "scale_adjust", ",", "core_count", ",", "smoothed_array", ")", "elif", "mode", "==", "'gpu'", ":", "return", "gpu_iuwt_recomposition", "(", "in1", ",", "scale_adjust", ",", "store_on_gpu", ",", "smoothed_array", ")" ]
This function serves as a handler for the different implementations of the IUWT recomposition. It allows the different methods to be used almost interchangeably. INPUTS: in1 (no default): Array on which the decomposition is to be performed. scale_adjust (no default): Number of omitted scales. mode (default='ser') Implementation of the IUWT to be used - 'ser', 'mp' or 'gpu'. core_count (default=1) Additional option for multiprocessing - specifies core count. store_on_gpu (default=False): Boolean specifier for whether the decomposition is stored on the gpu or not. OUTPUTS: Returns the recomposition.
[ "This", "function", "serves", "as", "a", "handler", "for", "the", "different", "implementations", "of", "the", "IUWT", "recomposition", ".", "It", "allows", "the", "different", "methods", "to", "be", "used", "almost", "interchangeably", "." ]
b024591ad0bbb69320d08841f28a2c27f62ae1af
https://github.com/ratt-ru/PyMORESANE/blob/b024591ad0bbb69320d08841f28a2c27f62ae1af/pymoresane/iuwt.py#L43-L64
train
895
ratt-ru/PyMORESANE
pymoresane/iuwt.py
ser_iuwt_decomposition
def ser_iuwt_decomposition(in1, scale_count, scale_adjust, store_smoothed): """ This function calls the a trous algorithm code to decompose the input into its wavelet coefficients. This is the isotropic undecimated wavelet transform implemented for a single CPU core. INPUTS: in1 (no default): Array on which the decomposition is to be performed. scale_count (no default): Maximum scale to be considered. scale_adjust (default=0): Adjustment to scale value if first scales are of no interest. store_smoothed (default=False):Boolean specifier for whether the smoothed image is stored or not. OUTPUTS: detail_coeffs Array containing the detail coefficients. C0 (optional): Array containing the smoothest version of the input. """ wavelet_filter = (1./16)*np.array([1,4,6,4,1]) # Filter-bank for use in the a trous algorithm. # Initialises an empty array to store the coefficients. detail_coeffs = np.empty([scale_count-scale_adjust, in1.shape[0], in1.shape[1]]) C0 = in1 # Sets the initial value to be the input array. # The following loop, which iterates up to scale_adjust, applies the a trous algorithm to the scales which are # considered insignificant. This is important as each set of wavelet coefficients depends on the last smoothed # version of the input. if scale_adjust>0: for i in range(0, scale_adjust): C0 = ser_a_trous(C0, wavelet_filter, i) # The meat of the algorithm - two sequential applications fo the a trous followed by determination and storing of # the detail coefficients. C0 is reassigned the value of C on each loop - C0 is always the smoothest version of the # input image. for i in range(scale_adjust,scale_count): C = ser_a_trous(C0, wavelet_filter, i) # Approximation coefficients. C1 = ser_a_trous(C, wavelet_filter, i) # Approximation coefficients. detail_coeffs[i-scale_adjust,:,:] = C0 - C1 # Detail coefficients. C0 = C if store_smoothed: return detail_coeffs, C0 else: return detail_coeffs
python
def ser_iuwt_decomposition(in1, scale_count, scale_adjust, store_smoothed): """ This function calls the a trous algorithm code to decompose the input into its wavelet coefficients. This is the isotropic undecimated wavelet transform implemented for a single CPU core. INPUTS: in1 (no default): Array on which the decomposition is to be performed. scale_count (no default): Maximum scale to be considered. scale_adjust (default=0): Adjustment to scale value if first scales are of no interest. store_smoothed (default=False):Boolean specifier for whether the smoothed image is stored or not. OUTPUTS: detail_coeffs Array containing the detail coefficients. C0 (optional): Array containing the smoothest version of the input. """ wavelet_filter = (1./16)*np.array([1,4,6,4,1]) # Filter-bank for use in the a trous algorithm. # Initialises an empty array to store the coefficients. detail_coeffs = np.empty([scale_count-scale_adjust, in1.shape[0], in1.shape[1]]) C0 = in1 # Sets the initial value to be the input array. # The following loop, which iterates up to scale_adjust, applies the a trous algorithm to the scales which are # considered insignificant. This is important as each set of wavelet coefficients depends on the last smoothed # version of the input. if scale_adjust>0: for i in range(0, scale_adjust): C0 = ser_a_trous(C0, wavelet_filter, i) # The meat of the algorithm - two sequential applications fo the a trous followed by determination and storing of # the detail coefficients. C0 is reassigned the value of C on each loop - C0 is always the smoothest version of the # input image. for i in range(scale_adjust,scale_count): C = ser_a_trous(C0, wavelet_filter, i) # Approximation coefficients. C1 = ser_a_trous(C, wavelet_filter, i) # Approximation coefficients. detail_coeffs[i-scale_adjust,:,:] = C0 - C1 # Detail coefficients. C0 = C if store_smoothed: return detail_coeffs, C0 else: return detail_coeffs
[ "def", "ser_iuwt_decomposition", "(", "in1", ",", "scale_count", ",", "scale_adjust", ",", "store_smoothed", ")", ":", "wavelet_filter", "=", "(", "1.", "/", "16", ")", "*", "np", ".", "array", "(", "[", "1", ",", "4", ",", "6", ",", "4", ",", "1", "]", ")", "# Filter-bank for use in the a trous algorithm.", "# Initialises an empty array to store the coefficients.", "detail_coeffs", "=", "np", ".", "empty", "(", "[", "scale_count", "-", "scale_adjust", ",", "in1", ".", "shape", "[", "0", "]", ",", "in1", ".", "shape", "[", "1", "]", "]", ")", "C0", "=", "in1", "# Sets the initial value to be the input array.", "# The following loop, which iterates up to scale_adjust, applies the a trous algorithm to the scales which are", "# considered insignificant. This is important as each set of wavelet coefficients depends on the last smoothed", "# version of the input.", "if", "scale_adjust", ">", "0", ":", "for", "i", "in", "range", "(", "0", ",", "scale_adjust", ")", ":", "C0", "=", "ser_a_trous", "(", "C0", ",", "wavelet_filter", ",", "i", ")", "# The meat of the algorithm - two sequential applications fo the a trous followed by determination and storing of", "# the detail coefficients. C0 is reassigned the value of C on each loop - C0 is always the smoothest version of the", "# input image.", "for", "i", "in", "range", "(", "scale_adjust", ",", "scale_count", ")", ":", "C", "=", "ser_a_trous", "(", "C0", ",", "wavelet_filter", ",", "i", ")", "# Approximation coefficients.", "C1", "=", "ser_a_trous", "(", "C", ",", "wavelet_filter", ",", "i", ")", "# Approximation coefficients.", "detail_coeffs", "[", "i", "-", "scale_adjust", ",", ":", ",", ":", "]", "=", "C0", "-", "C1", "# Detail coefficients.", "C0", "=", "C", "if", "store_smoothed", ":", "return", "detail_coeffs", ",", "C0", "else", ":", "return", "detail_coeffs" ]
This function calls the a trous algorithm code to decompose the input into its wavelet coefficients. This is the isotropic undecimated wavelet transform implemented for a single CPU core. INPUTS: in1 (no default): Array on which the decomposition is to be performed. scale_count (no default): Maximum scale to be considered. scale_adjust (default=0): Adjustment to scale value if first scales are of no interest. store_smoothed (default=False):Boolean specifier for whether the smoothed image is stored or not. OUTPUTS: detail_coeffs Array containing the detail coefficients. C0 (optional): Array containing the smoothest version of the input.
[ "This", "function", "calls", "the", "a", "trous", "algorithm", "code", "to", "decompose", "the", "input", "into", "its", "wavelet", "coefficients", ".", "This", "is", "the", "isotropic", "undecimated", "wavelet", "transform", "implemented", "for", "a", "single", "CPU", "core", "." ]
b024591ad0bbb69320d08841f28a2c27f62ae1af
https://github.com/ratt-ru/PyMORESANE/blob/b024591ad0bbb69320d08841f28a2c27f62ae1af/pymoresane/iuwt.py#L66-L111
train
896
ratt-ru/PyMORESANE
pymoresane/iuwt.py
ser_iuwt_recomposition
def ser_iuwt_recomposition(in1, scale_adjust, smoothed_array): """ This function calls the a trous algorithm code to recompose the input into a single array. This is the implementation of the isotropic undecimated wavelet transform recomposition for a single CPU core. INPUTS: in1 (no default): Array containing wavelet coefficients. scale_adjust (no default): Indicates the number of truncated array pages. smoothed_array (default=None): For a complete inverse transform, this must be the smoothest approximation. OUTPUTS: recomposition Array containing the reconstructed image. """ wavelet_filter = (1./16)*np.array([1,4,6,4,1]) # Filter-bank for use in the a trous algorithm. # Determines scale with adjustment and creates a zero array to store the output, unless smoothed_array is given. max_scale = in1.shape[0] + scale_adjust if smoothed_array is None: recomposition = np.zeros([in1.shape[1], in1.shape[2]]) else: recomposition = smoothed_array # The following loops call the a trous algorithm code to recompose the input. The first loop assumes that there are # non-zero wavelet coefficients at scales above scale_adjust, while the second loop completes the recomposition # on the scales less than scale_adjust. for i in range(max_scale-1, scale_adjust-1, -1): recomposition = ser_a_trous(recomposition, wavelet_filter, i) + in1[i-scale_adjust,:,:] if scale_adjust>0: for i in range(scale_adjust-1, -1, -1): recomposition = ser_a_trous(recomposition, wavelet_filter, i) return recomposition
python
def ser_iuwt_recomposition(in1, scale_adjust, smoothed_array): """ This function calls the a trous algorithm code to recompose the input into a single array. This is the implementation of the isotropic undecimated wavelet transform recomposition for a single CPU core. INPUTS: in1 (no default): Array containing wavelet coefficients. scale_adjust (no default): Indicates the number of truncated array pages. smoothed_array (default=None): For a complete inverse transform, this must be the smoothest approximation. OUTPUTS: recomposition Array containing the reconstructed image. """ wavelet_filter = (1./16)*np.array([1,4,6,4,1]) # Filter-bank for use in the a trous algorithm. # Determines scale with adjustment and creates a zero array to store the output, unless smoothed_array is given. max_scale = in1.shape[0] + scale_adjust if smoothed_array is None: recomposition = np.zeros([in1.shape[1], in1.shape[2]]) else: recomposition = smoothed_array # The following loops call the a trous algorithm code to recompose the input. The first loop assumes that there are # non-zero wavelet coefficients at scales above scale_adjust, while the second loop completes the recomposition # on the scales less than scale_adjust. for i in range(max_scale-1, scale_adjust-1, -1): recomposition = ser_a_trous(recomposition, wavelet_filter, i) + in1[i-scale_adjust,:,:] if scale_adjust>0: for i in range(scale_adjust-1, -1, -1): recomposition = ser_a_trous(recomposition, wavelet_filter, i) return recomposition
[ "def", "ser_iuwt_recomposition", "(", "in1", ",", "scale_adjust", ",", "smoothed_array", ")", ":", "wavelet_filter", "=", "(", "1.", "/", "16", ")", "*", "np", ".", "array", "(", "[", "1", ",", "4", ",", "6", ",", "4", ",", "1", "]", ")", "# Filter-bank for use in the a trous algorithm.", "# Determines scale with adjustment and creates a zero array to store the output, unless smoothed_array is given.", "max_scale", "=", "in1", ".", "shape", "[", "0", "]", "+", "scale_adjust", "if", "smoothed_array", "is", "None", ":", "recomposition", "=", "np", ".", "zeros", "(", "[", "in1", ".", "shape", "[", "1", "]", ",", "in1", ".", "shape", "[", "2", "]", "]", ")", "else", ":", "recomposition", "=", "smoothed_array", "# The following loops call the a trous algorithm code to recompose the input. The first loop assumes that there are", "# non-zero wavelet coefficients at scales above scale_adjust, while the second loop completes the recomposition", "# on the scales less than scale_adjust.", "for", "i", "in", "range", "(", "max_scale", "-", "1", ",", "scale_adjust", "-", "1", ",", "-", "1", ")", ":", "recomposition", "=", "ser_a_trous", "(", "recomposition", ",", "wavelet_filter", ",", "i", ")", "+", "in1", "[", "i", "-", "scale_adjust", ",", ":", ",", ":", "]", "if", "scale_adjust", ">", "0", ":", "for", "i", "in", "range", "(", "scale_adjust", "-", "1", ",", "-", "1", ",", "-", "1", ")", ":", "recomposition", "=", "ser_a_trous", "(", "recomposition", ",", "wavelet_filter", ",", "i", ")", "return", "recomposition" ]
This function calls the a trous algorithm code to recompose the input into a single array. This is the implementation of the isotropic undecimated wavelet transform recomposition for a single CPU core. INPUTS: in1 (no default): Array containing wavelet coefficients. scale_adjust (no default): Indicates the number of truncated array pages. smoothed_array (default=None): For a complete inverse transform, this must be the smoothest approximation. OUTPUTS: recomposition Array containing the reconstructed image.
[ "This", "function", "calls", "the", "a", "trous", "algorithm", "code", "to", "recompose", "the", "input", "into", "a", "single", "array", ".", "This", "is", "the", "implementation", "of", "the", "isotropic", "undecimated", "wavelet", "transform", "recomposition", "for", "a", "single", "CPU", "core", "." ]
b024591ad0bbb69320d08841f28a2c27f62ae1af
https://github.com/ratt-ru/PyMORESANE/blob/b024591ad0bbb69320d08841f28a2c27f62ae1af/pymoresane/iuwt.py#L113-L149
train
897
ratt-ru/PyMORESANE
pymoresane/iuwt.py
mp_iuwt_recomposition
def mp_iuwt_recomposition(in1, scale_adjust, core_count, smoothed_array): """ This function calls the a trous algorithm code to recompose the input into a single array. This is the implementation of the isotropic undecimated wavelet transform recomposition for multiple CPU cores. INPUTS: in1 (no default): Array containing wavelet coefficients. scale_adjust (no default): Indicates the number of omitted array pages. core_count (no default): Indicates the number of cores to be used. smoothed_array (default=None): For a complete inverse transform, this must be the smoothest approximation. OUTPUTS: recomposiiton Array containing the reconstructed image. """ wavelet_filter = (1./16)*np.array([1,4,6,4,1]) # Filter-bank for use in the a trous algorithm. # Determines scale with adjustment and creates a zero array to store the output, unless smoothed_array is given. max_scale = in1.shape[0] + scale_adjust if smoothed_array is None: recomposition = np.zeros([in1.shape[1], in1.shape[2]]) else: recomposition = smoothed_array # The following loops call the a trous algorithm code to recompose the input. The first loop assumes that there are # non-zero wavelet coefficients at scales above scale_adjust, while the second loop completes the recomposition # on the scales less than scale_adjust. for i in range(max_scale-1, scale_adjust-1, -1): recomposition = mp_a_trous(recomposition, wavelet_filter, i, core_count) + in1[i-scale_adjust,:,:] if scale_adjust>0: for i in range(scale_adjust-1, -1, -1): recomposition = mp_a_trous(recomposition, wavelet_filter, i, core_count) return recomposition
python
def mp_iuwt_recomposition(in1, scale_adjust, core_count, smoothed_array): """ This function calls the a trous algorithm code to recompose the input into a single array. This is the implementation of the isotropic undecimated wavelet transform recomposition for multiple CPU cores. INPUTS: in1 (no default): Array containing wavelet coefficients. scale_adjust (no default): Indicates the number of omitted array pages. core_count (no default): Indicates the number of cores to be used. smoothed_array (default=None): For a complete inverse transform, this must be the smoothest approximation. OUTPUTS: recomposiiton Array containing the reconstructed image. """ wavelet_filter = (1./16)*np.array([1,4,6,4,1]) # Filter-bank for use in the a trous algorithm. # Determines scale with adjustment and creates a zero array to store the output, unless smoothed_array is given. max_scale = in1.shape[0] + scale_adjust if smoothed_array is None: recomposition = np.zeros([in1.shape[1], in1.shape[2]]) else: recomposition = smoothed_array # The following loops call the a trous algorithm code to recompose the input. The first loop assumes that there are # non-zero wavelet coefficients at scales above scale_adjust, while the second loop completes the recomposition # on the scales less than scale_adjust. for i in range(max_scale-1, scale_adjust-1, -1): recomposition = mp_a_trous(recomposition, wavelet_filter, i, core_count) + in1[i-scale_adjust,:,:] if scale_adjust>0: for i in range(scale_adjust-1, -1, -1): recomposition = mp_a_trous(recomposition, wavelet_filter, i, core_count) return recomposition
[ "def", "mp_iuwt_recomposition", "(", "in1", ",", "scale_adjust", ",", "core_count", ",", "smoothed_array", ")", ":", "wavelet_filter", "=", "(", "1.", "/", "16", ")", "*", "np", ".", "array", "(", "[", "1", ",", "4", ",", "6", ",", "4", ",", "1", "]", ")", "# Filter-bank for use in the a trous algorithm.", "# Determines scale with adjustment and creates a zero array to store the output, unless smoothed_array is given.", "max_scale", "=", "in1", ".", "shape", "[", "0", "]", "+", "scale_adjust", "if", "smoothed_array", "is", "None", ":", "recomposition", "=", "np", ".", "zeros", "(", "[", "in1", ".", "shape", "[", "1", "]", ",", "in1", ".", "shape", "[", "2", "]", "]", ")", "else", ":", "recomposition", "=", "smoothed_array", "# The following loops call the a trous algorithm code to recompose the input. The first loop assumes that there are", "# non-zero wavelet coefficients at scales above scale_adjust, while the second loop completes the recomposition", "# on the scales less than scale_adjust.", "for", "i", "in", "range", "(", "max_scale", "-", "1", ",", "scale_adjust", "-", "1", ",", "-", "1", ")", ":", "recomposition", "=", "mp_a_trous", "(", "recomposition", ",", "wavelet_filter", ",", "i", ",", "core_count", ")", "+", "in1", "[", "i", "-", "scale_adjust", ",", ":", ",", ":", "]", "if", "scale_adjust", ">", "0", ":", "for", "i", "in", "range", "(", "scale_adjust", "-", "1", ",", "-", "1", ",", "-", "1", ")", ":", "recomposition", "=", "mp_a_trous", "(", "recomposition", ",", "wavelet_filter", ",", "i", ",", "core_count", ")", "return", "recomposition" ]
This function calls the a trous algorithm code to recompose the input into a single array. This is the implementation of the isotropic undecimated wavelet transform recomposition for multiple CPU cores. INPUTS: in1 (no default): Array containing wavelet coefficients. scale_adjust (no default): Indicates the number of omitted array pages. core_count (no default): Indicates the number of cores to be used. smoothed_array (default=None): For a complete inverse transform, this must be the smoothest approximation. OUTPUTS: recomposiiton Array containing the reconstructed image.
[ "This", "function", "calls", "the", "a", "trous", "algorithm", "code", "to", "recompose", "the", "input", "into", "a", "single", "array", ".", "This", "is", "the", "implementation", "of", "the", "isotropic", "undecimated", "wavelet", "transform", "recomposition", "for", "multiple", "CPU", "cores", "." ]
b024591ad0bbb69320d08841f28a2c27f62ae1af
https://github.com/ratt-ru/PyMORESANE/blob/b024591ad0bbb69320d08841f28a2c27f62ae1af/pymoresane/iuwt.py#L242-L279
train
898
ratt-ru/PyMORESANE
pymoresane/iuwt.py
gpu_iuwt_decomposition
def gpu_iuwt_decomposition(in1, scale_count, scale_adjust, store_smoothed, store_on_gpu): """ This function calls the a trous algorithm code to decompose the input into its wavelet coefficients. This is the isotropic undecimated wavelet transform implemented for a GPU. INPUTS: in1 (no default): Array on which the decomposition is to be performed. scale_count (no default): Maximum scale to be considered. scale_adjust (no default): Adjustment to scale value if first scales are of no interest. store_smoothed (no default): Boolean specifier for whether the smoothed image is stored or not. store_on_gpu (no default): Boolean specifier for whether the decomposition is stored on the gpu or not. OUTPUTS: detail_coeffs Array containing the detail coefficients. C0 (optional): Array containing the smoothest version of the input. """ # The following simple kernel just allows for the construction of a 3D decomposition on the GPU. ker = SourceModule(""" __global__ void gpu_store_detail_coeffs(float *in1, float *in2, float* out1, int *scale, int *adjust) { const int len = gridDim.x*blockDim.x; const int i = (blockDim.x * blockIdx.x + threadIdx.x); const int j = (blockDim.y * blockIdx.y + threadIdx.y)*len; const int k = (blockDim.z * blockIdx.z + threadIdx.z)*(len*len); const int tid2 = i + j; const int tid3 = i + j + k; if ((blockIdx.z + adjust[0])==scale[0]) { out1[tid3] = in1[tid2] - in2[tid2]; } } """) wavelet_filter = (1./16)*np.array([1,4,6,4,1], dtype=np.float32) # Filter-bank for use in the a trous algorithm. wavelet_filter = gpuarray.to_gpu_async(wavelet_filter) # Initialises an empty array to store the detail coefficients. detail_coeffs = gpuarray.empty([scale_count-scale_adjust, in1.shape[0], in1.shape[1]], np.float32) # Determines whether the array is already on the GPU or not. If not, moves it to the GPU. try: gpu_in1 = gpuarray.to_gpu_async(in1.astype(np.float32)) except: gpu_in1 = in1 # Sets up some working arrays on the GPU to prevent memory transfers. gpu_tmp = gpuarray.empty_like(gpu_in1) gpu_out1 = gpuarray.empty_like(gpu_in1) gpu_out2 = gpuarray.empty_like(gpu_in1) # Sets up some parameters required by the algorithm on the GPU. gpu_scale = gpuarray.zeros([1], np.int32) gpu_adjust = gpuarray.zeros([1], np.int32) gpu_adjust += scale_adjust # Fetches the a trous kernels and sets up the unique storing kernel. gpu_a_trous_row_kernel, gpu_a_trous_col_kernel = gpu_a_trous() gpu_store_detail_coeffs = ker.get_function("gpu_store_detail_coeffs") grid_rows = int(in1.shape[0]//32) grid_cols = int(in1.shape[1]//32) # The following loop, which iterates up to scale_adjust, applies the a trous algorithm to the scales which are # considered insignificant. This is important as each set of wavelet coefficients depends on the last smoothed # version of the input. if scale_adjust>0: for i in range(0, scale_adjust): gpu_a_trous_row_kernel(gpu_in1, gpu_tmp, wavelet_filter, gpu_scale, block=(32,32,1), grid=(grid_cols, grid_rows)) gpu_a_trous_col_kernel(gpu_tmp, gpu_out1, wavelet_filter, gpu_scale, block=(32,32,1), grid=(grid_cols, grid_rows)) gpu_in1, gpu_out1 = gpu_out1, gpu_in1 gpu_scale += 1 # The meat of the algorithm - two sequential applications fo the a trous followed by determination and storing of # the detail coefficients. C0 is reassigned the value of C on each loop - C0 is always the smoothest version of the # input image. for i in range(scale_adjust, scale_count): gpu_a_trous_row_kernel(gpu_in1, gpu_tmp, wavelet_filter, gpu_scale, block=(32,32,1), grid=(grid_cols, grid_rows)) gpu_a_trous_col_kernel(gpu_tmp, gpu_out1, wavelet_filter, gpu_scale, block=(32,32,1), grid=(grid_cols, grid_rows)) # Approximation coefficients. gpu_a_trous_row_kernel(gpu_out1, gpu_tmp, wavelet_filter, gpu_scale, block=(32,32,1), grid=(grid_cols, grid_rows)) gpu_a_trous_col_kernel(gpu_tmp, gpu_out2, wavelet_filter, gpu_scale, block=(32,32,1), grid=(grid_cols, grid_rows)) # Approximation coefficients. gpu_store_detail_coeffs(gpu_in1, gpu_out2, detail_coeffs, gpu_scale, gpu_adjust, block=(32,32,1), grid=(grid_cols, grid_rows, int(scale_count))) # Detail coefficients. gpu_in1, gpu_out1 = gpu_out1, gpu_in1 gpu_scale += 1 # Return values depend on mode. NOTE: store_smoothed does not work if the result stays on the gpu. if store_on_gpu: return detail_coeffs elif store_smoothed: return detail_coeffs.get(), gpu_in1.get() else: return detail_coeffs.get()
python
def gpu_iuwt_decomposition(in1, scale_count, scale_adjust, store_smoothed, store_on_gpu): """ This function calls the a trous algorithm code to decompose the input into its wavelet coefficients. This is the isotropic undecimated wavelet transform implemented for a GPU. INPUTS: in1 (no default): Array on which the decomposition is to be performed. scale_count (no default): Maximum scale to be considered. scale_adjust (no default): Adjustment to scale value if first scales are of no interest. store_smoothed (no default): Boolean specifier for whether the smoothed image is stored or not. store_on_gpu (no default): Boolean specifier for whether the decomposition is stored on the gpu or not. OUTPUTS: detail_coeffs Array containing the detail coefficients. C0 (optional): Array containing the smoothest version of the input. """ # The following simple kernel just allows for the construction of a 3D decomposition on the GPU. ker = SourceModule(""" __global__ void gpu_store_detail_coeffs(float *in1, float *in2, float* out1, int *scale, int *adjust) { const int len = gridDim.x*blockDim.x; const int i = (blockDim.x * blockIdx.x + threadIdx.x); const int j = (blockDim.y * blockIdx.y + threadIdx.y)*len; const int k = (blockDim.z * blockIdx.z + threadIdx.z)*(len*len); const int tid2 = i + j; const int tid3 = i + j + k; if ((blockIdx.z + adjust[0])==scale[0]) { out1[tid3] = in1[tid2] - in2[tid2]; } } """) wavelet_filter = (1./16)*np.array([1,4,6,4,1], dtype=np.float32) # Filter-bank for use in the a trous algorithm. wavelet_filter = gpuarray.to_gpu_async(wavelet_filter) # Initialises an empty array to store the detail coefficients. detail_coeffs = gpuarray.empty([scale_count-scale_adjust, in1.shape[0], in1.shape[1]], np.float32) # Determines whether the array is already on the GPU or not. If not, moves it to the GPU. try: gpu_in1 = gpuarray.to_gpu_async(in1.astype(np.float32)) except: gpu_in1 = in1 # Sets up some working arrays on the GPU to prevent memory transfers. gpu_tmp = gpuarray.empty_like(gpu_in1) gpu_out1 = gpuarray.empty_like(gpu_in1) gpu_out2 = gpuarray.empty_like(gpu_in1) # Sets up some parameters required by the algorithm on the GPU. gpu_scale = gpuarray.zeros([1], np.int32) gpu_adjust = gpuarray.zeros([1], np.int32) gpu_adjust += scale_adjust # Fetches the a trous kernels and sets up the unique storing kernel. gpu_a_trous_row_kernel, gpu_a_trous_col_kernel = gpu_a_trous() gpu_store_detail_coeffs = ker.get_function("gpu_store_detail_coeffs") grid_rows = int(in1.shape[0]//32) grid_cols = int(in1.shape[1]//32) # The following loop, which iterates up to scale_adjust, applies the a trous algorithm to the scales which are # considered insignificant. This is important as each set of wavelet coefficients depends on the last smoothed # version of the input. if scale_adjust>0: for i in range(0, scale_adjust): gpu_a_trous_row_kernel(gpu_in1, gpu_tmp, wavelet_filter, gpu_scale, block=(32,32,1), grid=(grid_cols, grid_rows)) gpu_a_trous_col_kernel(gpu_tmp, gpu_out1, wavelet_filter, gpu_scale, block=(32,32,1), grid=(grid_cols, grid_rows)) gpu_in1, gpu_out1 = gpu_out1, gpu_in1 gpu_scale += 1 # The meat of the algorithm - two sequential applications fo the a trous followed by determination and storing of # the detail coefficients. C0 is reassigned the value of C on each loop - C0 is always the smoothest version of the # input image. for i in range(scale_adjust, scale_count): gpu_a_trous_row_kernel(gpu_in1, gpu_tmp, wavelet_filter, gpu_scale, block=(32,32,1), grid=(grid_cols, grid_rows)) gpu_a_trous_col_kernel(gpu_tmp, gpu_out1, wavelet_filter, gpu_scale, block=(32,32,1), grid=(grid_cols, grid_rows)) # Approximation coefficients. gpu_a_trous_row_kernel(gpu_out1, gpu_tmp, wavelet_filter, gpu_scale, block=(32,32,1), grid=(grid_cols, grid_rows)) gpu_a_trous_col_kernel(gpu_tmp, gpu_out2, wavelet_filter, gpu_scale, block=(32,32,1), grid=(grid_cols, grid_rows)) # Approximation coefficients. gpu_store_detail_coeffs(gpu_in1, gpu_out2, detail_coeffs, gpu_scale, gpu_adjust, block=(32,32,1), grid=(grid_cols, grid_rows, int(scale_count))) # Detail coefficients. gpu_in1, gpu_out1 = gpu_out1, gpu_in1 gpu_scale += 1 # Return values depend on mode. NOTE: store_smoothed does not work if the result stays on the gpu. if store_on_gpu: return detail_coeffs elif store_smoothed: return detail_coeffs.get(), gpu_in1.get() else: return detail_coeffs.get()
[ "def", "gpu_iuwt_decomposition", "(", "in1", ",", "scale_count", ",", "scale_adjust", ",", "store_smoothed", ",", "store_on_gpu", ")", ":", "# The following simple kernel just allows for the construction of a 3D decomposition on the GPU.", "ker", "=", "SourceModule", "(", "\"\"\"\n __global__ void gpu_store_detail_coeffs(float *in1, float *in2, float* out1, int *scale, int *adjust)\n {\n const int len = gridDim.x*blockDim.x;\n const int i = (blockDim.x * blockIdx.x + threadIdx.x);\n const int j = (blockDim.y * blockIdx.y + threadIdx.y)*len;\n const int k = (blockDim.z * blockIdx.z + threadIdx.z)*(len*len);\n const int tid2 = i + j;\n const int tid3 = i + j + k;\n\n if ((blockIdx.z + adjust[0])==scale[0])\n { out1[tid3] = in1[tid2] - in2[tid2]; }\n\n }\n \"\"\"", ")", "wavelet_filter", "=", "(", "1.", "/", "16", ")", "*", "np", ".", "array", "(", "[", "1", ",", "4", ",", "6", ",", "4", ",", "1", "]", ",", "dtype", "=", "np", ".", "float32", ")", "# Filter-bank for use in the a trous algorithm.", "wavelet_filter", "=", "gpuarray", ".", "to_gpu_async", "(", "wavelet_filter", ")", "# Initialises an empty array to store the detail coefficients.", "detail_coeffs", "=", "gpuarray", ".", "empty", "(", "[", "scale_count", "-", "scale_adjust", ",", "in1", ".", "shape", "[", "0", "]", ",", "in1", ".", "shape", "[", "1", "]", "]", ",", "np", ".", "float32", ")", "# Determines whether the array is already on the GPU or not. If not, moves it to the GPU.", "try", ":", "gpu_in1", "=", "gpuarray", ".", "to_gpu_async", "(", "in1", ".", "astype", "(", "np", ".", "float32", ")", ")", "except", ":", "gpu_in1", "=", "in1", "# Sets up some working arrays on the GPU to prevent memory transfers.", "gpu_tmp", "=", "gpuarray", ".", "empty_like", "(", "gpu_in1", ")", "gpu_out1", "=", "gpuarray", ".", "empty_like", "(", "gpu_in1", ")", "gpu_out2", "=", "gpuarray", ".", "empty_like", "(", "gpu_in1", ")", "# Sets up some parameters required by the algorithm on the GPU.", "gpu_scale", "=", "gpuarray", ".", "zeros", "(", "[", "1", "]", ",", "np", ".", "int32", ")", "gpu_adjust", "=", "gpuarray", ".", "zeros", "(", "[", "1", "]", ",", "np", ".", "int32", ")", "gpu_adjust", "+=", "scale_adjust", "# Fetches the a trous kernels and sets up the unique storing kernel.", "gpu_a_trous_row_kernel", ",", "gpu_a_trous_col_kernel", "=", "gpu_a_trous", "(", ")", "gpu_store_detail_coeffs", "=", "ker", ".", "get_function", "(", "\"gpu_store_detail_coeffs\"", ")", "grid_rows", "=", "int", "(", "in1", ".", "shape", "[", "0", "]", "//", "32", ")", "grid_cols", "=", "int", "(", "in1", ".", "shape", "[", "1", "]", "//", "32", ")", "# The following loop, which iterates up to scale_adjust, applies the a trous algorithm to the scales which are", "# considered insignificant. This is important as each set of wavelet coefficients depends on the last smoothed", "# version of the input.", "if", "scale_adjust", ">", "0", ":", "for", "i", "in", "range", "(", "0", ",", "scale_adjust", ")", ":", "gpu_a_trous_row_kernel", "(", "gpu_in1", ",", "gpu_tmp", ",", "wavelet_filter", ",", "gpu_scale", ",", "block", "=", "(", "32", ",", "32", ",", "1", ")", ",", "grid", "=", "(", "grid_cols", ",", "grid_rows", ")", ")", "gpu_a_trous_col_kernel", "(", "gpu_tmp", ",", "gpu_out1", ",", "wavelet_filter", ",", "gpu_scale", ",", "block", "=", "(", "32", ",", "32", ",", "1", ")", ",", "grid", "=", "(", "grid_cols", ",", "grid_rows", ")", ")", "gpu_in1", ",", "gpu_out1", "=", "gpu_out1", ",", "gpu_in1", "gpu_scale", "+=", "1", "# The meat of the algorithm - two sequential applications fo the a trous followed by determination and storing of", "# the detail coefficients. C0 is reassigned the value of C on each loop - C0 is always the smoothest version of the", "# input image.", "for", "i", "in", "range", "(", "scale_adjust", ",", "scale_count", ")", ":", "gpu_a_trous_row_kernel", "(", "gpu_in1", ",", "gpu_tmp", ",", "wavelet_filter", ",", "gpu_scale", ",", "block", "=", "(", "32", ",", "32", ",", "1", ")", ",", "grid", "=", "(", "grid_cols", ",", "grid_rows", ")", ")", "gpu_a_trous_col_kernel", "(", "gpu_tmp", ",", "gpu_out1", ",", "wavelet_filter", ",", "gpu_scale", ",", "block", "=", "(", "32", ",", "32", ",", "1", ")", ",", "grid", "=", "(", "grid_cols", ",", "grid_rows", ")", ")", "# Approximation coefficients.", "gpu_a_trous_row_kernel", "(", "gpu_out1", ",", "gpu_tmp", ",", "wavelet_filter", ",", "gpu_scale", ",", "block", "=", "(", "32", ",", "32", ",", "1", ")", ",", "grid", "=", "(", "grid_cols", ",", "grid_rows", ")", ")", "gpu_a_trous_col_kernel", "(", "gpu_tmp", ",", "gpu_out2", ",", "wavelet_filter", ",", "gpu_scale", ",", "block", "=", "(", "32", ",", "32", ",", "1", ")", ",", "grid", "=", "(", "grid_cols", ",", "grid_rows", ")", ")", "# Approximation coefficients.", "gpu_store_detail_coeffs", "(", "gpu_in1", ",", "gpu_out2", ",", "detail_coeffs", ",", "gpu_scale", ",", "gpu_adjust", ",", "block", "=", "(", "32", ",", "32", ",", "1", ")", ",", "grid", "=", "(", "grid_cols", ",", "grid_rows", ",", "int", "(", "scale_count", ")", ")", ")", "# Detail coefficients.", "gpu_in1", ",", "gpu_out1", "=", "gpu_out1", ",", "gpu_in1", "gpu_scale", "+=", "1", "# Return values depend on mode. NOTE: store_smoothed does not work if the result stays on the gpu.", "if", "store_on_gpu", ":", "return", "detail_coeffs", "elif", "store_smoothed", ":", "return", "detail_coeffs", ".", "get", "(", ")", ",", "gpu_in1", ".", "get", "(", ")", "else", ":", "return", "detail_coeffs", ".", "get", "(", ")" ]
This function calls the a trous algorithm code to decompose the input into its wavelet coefficients. This is the isotropic undecimated wavelet transform implemented for a GPU. INPUTS: in1 (no default): Array on which the decomposition is to be performed. scale_count (no default): Maximum scale to be considered. scale_adjust (no default): Adjustment to scale value if first scales are of no interest. store_smoothed (no default): Boolean specifier for whether the smoothed image is stored or not. store_on_gpu (no default): Boolean specifier for whether the decomposition is stored on the gpu or not. OUTPUTS: detail_coeffs Array containing the detail coefficients. C0 (optional): Array containing the smoothest version of the input.
[ "This", "function", "calls", "the", "a", "trous", "algorithm", "code", "to", "decompose", "the", "input", "into", "its", "wavelet", "coefficients", ".", "This", "is", "the", "isotropic", "undecimated", "wavelet", "transform", "implemented", "for", "a", "GPU", "." ]
b024591ad0bbb69320d08841f28a2c27f62ae1af
https://github.com/ratt-ru/PyMORESANE/blob/b024591ad0bbb69320d08841f28a2c27f62ae1af/pymoresane/iuwt.py#L384-L499
train
899