def run_scenario(input_file, timesteps, scenario, result_dir, plot_periods={}):
""" run an urbs model for given input, time steps and scenario
Args:
input_file: filename to an Excel spreadsheet for urbs.read_excel
timesteps: a list of timesteps, e.g. range(0,8761)
scenario: a scenario function that modifies the input data dict
result_dir: directory name for result spreadsheet and plots
Returns:
the urbs model instance
"""
# scenario name, read and modify data for scenario
sce = scenario.__name__
data = urbs.read_excel(input_file)
data = scenario(data)
# create model
prob = urbs.create_model(data, timesteps)
if PYOMO3:
prob = prob.create()
# refresh time stamp string and create filename for logfile
now = prob.created
log_filename = os.path.join(result_dir, '{}.log').format(sce)
# solve model and read results
optim = SolverFactory('glpk') # cplex, glpk, gurobi, ...
optim = setup_solver(optim, logfile=log_filename)
result = optim.solve(prob, tee=True)
if PYOMO3:
prob.load(result)
else:
prob.solutions.load_from(result)
# copy input file in result directory
cdir = os.getcwd()
respath = os.path.join(cdir, result_dir)
shutil.copy(input_file,respath)
# write report to spreadsheet
urbs.report(
prob,
os.path.join(result_dir, '{}.xlsx').format(sce),
prob.com_demand, prob.sit)
# store optimisation problem for later re-analysis
urbs.save(
prob,
os.path.join(result_dir, '{}.pgz').format(sce))
urbs.result_figures(
prob,
os.path.join(result_dir, '{}'.format(sce)),
plot_title_prefix=sce.replace('_', ' ').title(),
periods=plot_periods)
return prob
def run_scenario(input_file, timesteps, scenario, result_dir,
plot_tuples=None, plot_periods=None, report_tuples=None):
""" run an urbs model for given input, time steps and scenario
Args:
input_file: filename to an Excel spreadsheet for urbs.read_excel
timesteps: a list of timesteps, e.g. range(0,8761)
scenario: a scenario function that modifies the input data dict
result_dir: directory name for result spreadsheet and plots
plot_tuples: (optional) list of plot tuples (c.f. urbs.result_figures)
plot_periods: (optional) dict of plot periods (c.f. urbs.result_figures)
report_tuples: (optional) list of (sit, com) tuples (c.f. urbs.report)
Returns:
the urbs model instance
"""
# scenario name, read and modify data for scenario
sce = scenario.__name__
data = urbs.read_excel(input_file)
data = scenario(data)
# create model
prob = urbs.create_model(data, timesteps)
# refresh time stamp string and create filename for logfile
now = prob.created
log_filename = os.path.join(result_dir, '{}.log').format(sce)
# solve model and read results
optim = SolverFactory('glpk') # cplex, glpk, gurobi, ...
optim = setup_solver(optim, logfile=log_filename)
result = optim.solve(prob, tee=True)
# copy input file to result directory
shutil.copyfile(input_file, os.path.join(result_dir, input_file))
# save problem solution (and input data) to HDF5 file
urbs.save(prob, os.path.join(result_dir, '{}.h5'.format(sce)))
# write report to spreadsheet
urbs.report(
prob,
os.path.join(result_dir, '{}.xlsx').format(sce),
report_tuples=report_tuples)
# result plots
urbs.result_figures(
prob,
os.path.join(result_dir, '{}'.format(sce)),
plot_title_prefix=sce.replace('_', ' '),
plot_tuples=plot_tuples,
periods=plot_periods,
figure_size=(24, 9))
return prob
def _check_available(name):
from pyomo.opt.base import (UnknownSolver, SolverFactory)
try:
opt = SolverFactory(name)
except:
return False
if opt is None or isinstance(opt, UnknownSolver):
return False
elif (name == "gurobi") and \
(not GUROBISHELL.license_is_valid()):
return False
elif (name == "baron") and \
(not BARONSHELL.license_is_valid()):
return False
else:
return (opt.available(exception_flag=False)) and \
((not hasattr(opt,'executable')) or \
(opt.executable() is not None))
def run_scenario(input_file, timesteps, scenario, result_dir, plot_periods={}):
""" run an urbs model for given input, time steps and scenario
Args:
input_file: filename to an Excel spreadsheet for urbs.read_excel
timesteps: a list of timesteps, e.g. range(0,8761)
scenario: a scenario function that modifies the input data dict
result_dir: directory name for result spreadsheet and plots
Returns:
the urbs model instance
"""
# scenario name, read and modify data for scenario
sce = scenario.__name__
data = urbs.read_excel(input_file)
data = scenario(data)
# create model
prob = urbs.create_model(data, timesteps)
# refresh time stamp string and create filename for logfile
now = prob.created
log_filename = os.path.join(result_dir, "{}.log").format(sce)
# solve model and read results
optim = SolverFactory("glpk") # cplex, glpk, gurobi, ...
optim = setup_solver(optim, logfile=log_filename)
result = optim.solve(prob, tee=True)
# copy input file to result directory
shutil.copyfile(input_file, os.path.join(result_dir, input_file))
# write report to spreadsheet
urbs.report(prob, os.path.join(result_dir, "{}.xlsx").format(sce), prob.com_demand, prob.sit)
urbs.result_figures(
prob,
os.path.join(result_dir, "{}".format(sce)),
plot_title_prefix=sce.replace("_", " ").title(),
periods=plot_periods,
)
return prob
def run_scenario(input_file, solver, timesteps, scenario, result_dir, dt,
objective,
plot_tuples=None, plot_sites_name=None, plot_periods=None,
report_tuples=None, report_sites_name=None):
""" run an urbs model for given input, time steps and scenario
Args:
input_file: filename to an Excel spreadsheet for urbs.read_excel
timesteps: a list of timesteps, e.g. range(0,8761)
scenario: a scenario function that modifies the input data dict
result_dir: directory name for result spreadsheet and plots
dt: length of each time step (unit: hours)
plot_tuples: (optional) list of plot tuples (c.f. urbs.result_figures)
plot_sites_name: (optional) dict of names for sites in plot_tuples
plot_periods: (optional) dict of plot periods(c.f. urbs.result_figures)
report_tuples: (optional) list of (sit, com) tuples (c.f. urbs.report)
report_sites_name: (optional) dict of names for sites in report_tuples
Returns:
the urbs model instance
"""
# start time measurement
t_start = time.time()
# scenario name, read and modify data for scenario
sce = scenario.__name__
data = read_excel(input_file)
data = scenario(data)
validate_input(data)
# measure time to read file
t_read = time.time() - t_start
print("Time to read file: %.2f sec" % t_read)
t = time.time()
# create model
prob = create_model(data, dt, timesteps, objective)
# prob.write('model.lp', io_options={'symbolic_solver_labels':True})
# measure time to create model
t_model = time.time() - t
print("Time to create model: %.2f sec" % t_model)
# refresh time stamp string and create filename for logfile
# now = prob.created
log_filename = os.path.join(result_dir, '{}.log').format(sce)
t = time.time()
# solve model and read results
optim = SolverFactory(solver) # cplex, glpk, gurobi, ...
optim = setup_solver(optim, logfile=log_filename)
result = optim.solve(prob, tee=True)
assert str(result.solver.termination_condition) == 'optimal'
# measure time to solve
t_solve = time.time() - t
print("Time to solve model: %.2f sec" % t_solve)
t = time.time()
# save problem solution (and input data) to HDF5 file
save(prob, os.path.join(result_dir, '{}.h5'.format(sce)))
# # measure time to save solution
# save_time = time.time() - t
# print("Time to save solution in HDF5 file: %.2f sec" % save_time)
# t = time.time()
# write report to spreadsheet
report(
prob,
os.path.join(result_dir, '{}.xlsx').format(sce),
report_tuples=report_tuples,
report_sites_name=report_sites_name)
# result plots
result_figures(
prob,
os.path.join(result_dir, '{}'.format(sce)),
timesteps,
plot_title_prefix=sce.replace('_', ' '),
plot_tuples=plot_tuples,
plot_sites_name=plot_sites_name,
periods=plot_periods,
figure_size=(24, 9))
t_repplot = time.time() - t
print("Time to report and plot: %.2f sec" % t_repplot)
# measure time to run scenario
t_sce = time.time() - t_start
print("Time to run scenario: %.2f sec" % t_sce)
# write time measurements into file "timelog.txt" in result directory
timelog = open(os.path.join(result_dir, "timelog.txt"), "a")
timelog.write("%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%s\n"
% (t_sce, t_read, t_model, t_solve, t_repplot, sce))
return prob
def _get_task_data(self, ah, *args, **kwds):
opt = kwds.pop('solver', kwds.pop('opt', None))
if opt is None:
raise ActionManagerError(
"No solver passed to %s, use keyword option 'solver'" %
(type(self).__name__))
deactivate_opt = False
if isinstance(opt, six.string_types):
deactivate_opt = True
opt = SolverFactory(opt, solver_io=kwds.pop('solver_io', None))
#
# The following block of code is taken from the OptSolver.solve()
# method, which we do not directly invoke with this interface
#
#
# If the inputs are models, then validate that they have been
# constructed! Collect suffix names to try and import from solution.
#
for arg in args:
if isinstance(arg, (Block, IBlockStorage)):
if isinstance(arg, Block):
if not arg.is_constructed():
raise RuntimeError(
"Attempting to solve model=%s with unconstructed "
"component(s)" % (arg.name))
# import suffixes must be on the top-level model
if isinstance(arg, Block):
model_suffixes = list(name for (name,comp) \
in pyomo.core.base.suffix.\
active_import_suffix_generator(arg))
else:
assert isinstance(arg, IBlockStorage)
model_suffixes = list(name for (name,comp) \
in pyomo.core.base.component_suffix.\
import_suffix_generator(arg,
active=True,
descend_into=False,
return_key=True))
if len(model_suffixes) > 0:
kwds_suffixes = kwds.setdefault('suffixes', [])
for name in model_suffixes:
if name not in kwds_suffixes:
kwds_suffixes.append(name)
#
# Handle ephemeral solvers options here. These
# will override whatever is currently in the options
# dictionary, but we will reset these options to
# their original value at the end of this method.
#
ephemeral_solver_options = {}
ephemeral_solver_options.update(kwds.pop('options', {}))
ephemeral_solver_options.update(
OptSolver._options_string_to_dict(kwds.pop('options_string', '')))
#
# Force pyomo.opt to ignore tests for availability, at least locally.
#
del_available = bool('available' not in kwds)
kwds['available'] = True
opt._presolve(*args, **kwds)
problem_file_string = None
with open(opt._problem_files[0], 'r') as f:
problem_file_string = f.read()
#
# Delete this option, to ensure that the remote worker does the check for
# availability.
#
if del_available:
del kwds['available']
#
# We can't pickle the options object itself - so extract a simple
# dictionary of solver options and re-construct it on the other end.
#
solver_options = {}
for key in opt.options:
solver_options[key] = opt.options[key]
solver_options.update(ephemeral_solver_options)
#
# NOTE: let the distributed node deal with the warm-start
# pick up the warm-start file, if available.
#
warm_start_file_string = None
warm_start_file_name = None
if hasattr(opt, "_warm_start_solve"):
if opt._warm_start_solve and \
(opt._warm_start_file_name is not None):
warm_start_file_name = opt._warm_start_file_name
with open(warm_start_file_name, 'r') as f:
warm_start_file_string = f.read()
data = pyutilib.misc.Bunch(opt=opt.type, \
file=problem_file_string, \
filename=opt._problem_files[0], \
warmstart_file=warm_start_file_string, \
warmstart_filename=warm_start_file_name, \
kwds=kwds, \
solver_options=solver_options, \
suffixes=opt._suffixes)
self._args[ah.id] = args
self._opt_data[ah.id] = (opt._smap_id, opt._load_solutions,
opt._select_index,
opt._default_variable_value)
if deactivate_opt:
opt.deactivate()
return data
# read vertices and edges from shapefiles...
vertex = geopandas.read_file(vertex_file)
edge = geopandas.read_file(edge_file)
# ... and set indices to agree with Excel format
vertex.set_index(['Vertex'], inplace=True)
edge.set_index(['Edge', 'Vertex1', 'Vertex2'], inplace=True)
# at this point, rundh.py and rundhshp.py work identically!
# dhmin.create_model must not rely on vertex/edge DataFrames to contain any
# geometry information
# get model
# create instance
# solver interface (GLPK)
prob = dhmin.create_model(vertex, edge, params, timesteps)
solver = SolverFactory('glpk')
result = solver.solve(prob, timelimit=30, tee=True)
prob.solutions.load_from(result)
# use special-purpose function to plot power flows (works unchanged!)
dhmintools.plot_flows_min(prob)
# read time-independent variable values to DataFrame
# (list all variables using dhmin.list_entities(instance, 'variables')
caps = dhmin.get_entities(prob, ['Pmax', 'x'])
costs = dhmin.get_entity(prob, 'costs')
# remove Edge from index, so that edge and caps are both indexed on
# (vertex, vertex) tuples, i.e. their indices match for identical edges
edge.reset_index('Edge', inplace=True)
edge = pdshp.read_shp(edge_shapefile)
edge = edge.set_index('Edge')
edge = edge.join(total_area)
edge = edge.fillna(0)
# load nodes
vertex = pdshp.read_shp(vertex_shapefile)
# load spreadsheet data
data = rivus.read_excel(data_spreadsheet)
# create & solve model
prob = rivus.create_model(data, vertex, edge)
if PYOMO3:
prob = prob.create() # no longer needed in Pyomo 4
optim = SolverFactory('glpk')
optim = setup_solver(optim)
result = optim.solve(prob, tee=True)
if PYOMO3:
prob.load(result) # no longer needed in Pyomo 4
# load results
costs, Pmax, Kappa_hub, Kappa_process = rivus.get_constants(prob)
source, flows, hub_io, proc_io, proc_tau = rivus.get_timeseries(prob)
result_dir = os.path.join('result', os.path.basename(base_directory))
# create result directory if not existing already
if not os.path.exists(result_dir):
os.makedirs(result_dir)
def load():
DownloadFactory.register('gjh')(get_gjh)
SolverFactory.register('contrib.gjh',
doc='Interface to the AMPL GJH "solver"')(GJHSolver)
def test_df_insert_query(self):
"""Are the stored dataframes and the retrieved ones identical?
- Comparison form of frames is *after* create_model. (index is set)
- Comparison form expects that input dataframes only have meaningful
columns. (See pull request #23)
- Only implemented dataframes are tested.
Note
----
Requires a ``config.json`` file in the root of rivus-repo with the
database credentials. For Example:
::
{
"db" : {
"user" : "postgres",
"pass" : "postgres",
"host" : "localhost",
"base" : "rivus"
}
}
"""
conf_path = os.path.join(pdir(pdir(pdir(__file__))), 'config.json')
config = []
with open(conf_path) as conf:
config = json.load(conf)
# DB connection
_user = config['db']['user']
_pass = config['db']['pass']
_host = config['db']['host']
_base = config['db']['base']
engine_string = ('postgresql://{}:{}@{}/{}'.format(
_user, _pass, _host, _base))
engine = create_engine(engine_string)
proj_name = 'mnl'
base_directory = os.path.join('data', proj_name)
data_spreadsheet = os.path.join(base_directory, 'data.xlsx')
data = read_excel(data_spreadsheet)
# data_bup = data.copy()
vertex, edge = square_grid()
vert_init_commodities(vertex, ['Elec', 'Gas'], [('Elec', 0, 100000)])
extend_edge_data(edge)
prob = create_model(data, vertex, edge)
solver = SolverFactory(config['solver'])
solver = setup_solver(solver, log_to_console=False)
solver.solve(prob, tee=True)
test_id = rdb.init_run(engine, runner='Unittest')
rdb.store(engine, prob, run_id=test_id)
this_df = None
dfs = data.keys()
for df in dfs:
if df == 'hub':
continue # is not implemented yet
this_df = data[df]
print(df)
re_df = rdb.df_from_table(engine, df, test_id)
self.assertTrue(all(
this_df.fillna(0) == re_df.reindex(this_df.index).fillna(0)),
msg=('{}: Original and retrieved frames'
' are not identical'.format(df)))
# Add implemented result dataframes
cost, pmax, kappa_hub, kappa_process = get_constants(prob)
source, _, _, _, _, = get_timeseries(prob)
results = dict(source=source,
cost=cost,
pmax=pmax,
kappa_hub=kappa_hub,
kappa_process=kappa_process)
dfs = ['source', 'cost', 'pmax', 'kappa_hub', 'kappa_process']
for df in dfs:
this_df = results[df]
print(df)
re_df = rdb.df_from_table(engine, df, test_id)
self.assertTrue(all(
this_df.fillna(0) == re_df.reindex(this_df.index).fillna(0)),
msg=('{}: Original and retrieved frames'
' are not identical'.format(df)))
def run_scenario(input_file,
timesteps,
scenario,
result_dir,
dt,
plot_tuples=None,
plot_sites_name=None,
plot_periods=None,
report_tuples=None,
report_sites_name=None):
""" run an urbs model for given input, time steps and scenario
Args:
input_file: filename to an Excel spreadsheet for urbs.read_excel
timesteps: a list of timesteps, e.g. range(0,8761)
scenario: a scenario function that modifies the input data dict
result_dir: directory name for result spreadsheet and plots
dt: length of each time step (unit: hours)
plot_tuples: (optional) list of plot tuples (c.f. urbs.result_figures)
plot_sites_name: (optional) dict of names for sites in plot_tuples
plot_periods: (optional) dict of plot periods(c.f. urbs.result_figures)
report_tuples: (optional) list of (sit, com) tuples (c.f. urbs.report)
report_sites_name: (optional) dict of names for sites in report_tuples
Returns:
the urbs model instance
"""
# scenario name, read and modify data for scenario
sce = scenario.__name__
data = urbs.read_excel(input_file)
data = scenario(data)
urbs.validate_input(data)
# create model
prob = urbs.create_model(data, dt, timesteps)
# refresh time stamp string and create filename for logfile
now = prob.created
log_filename = os.path.join(result_dir, '{}.log').format(sce)
# solve model and read results
optim = SolverFactory('glpk') # cplex, glpk, gurobi, ...
optim = setup_solver(optim, logfile=log_filename)
result = optim.solve(prob, tee=True)
# save problem solution (and input data) to HDF5 file
urbs.save(prob, os.path.join(result_dir, '{}.h5'.format(sce)))
# write report to spreadsheet
urbs.report(prob,
os.path.join(result_dir, '{}.xlsx').format(sce),
report_tuples=report_tuples,
report_sites_name=report_sites_name)
# result plots
urbs.result_figures(prob,
os.path.join(result_dir, '{}'.format(sce)),
timesteps,
plot_title_prefix=sce.replace('_', ' '),
plot_tuples=plot_tuples,
plot_sites_name=plot_sites_name,
periods=plot_periods,
figure_size=(24, 9))
return prob
def EFAlgorithmBuilder(options, scenario_tree):
solution_writer_plugins = ExtensionPoint(ISolutionWriterExtension)
for plugin in solution_writer_plugins:
plugin.disable()
solution_plugins = []
if len(options.solution_writer) > 0:
for this_extension in options.solution_writer:
if this_extension in sys.modules:
print("User-defined EF solution writer module="
+this_extension+" already imported - skipping")
else:
print("Trying to import user-defined EF "
"solution writer module="+this_extension)
# make sure "." is in the PATH.
original_path = list(sys.path)
sys.path.insert(0,'.')
pyutilib.misc.import_file(this_extension)
print("Module successfully loaded")
sys.path[:] = original_path # restore to what it was
# now that we're sure the module is loaded, re-enable this
# specific plugin. recall that all plugins are disabled
# by default in phinit.py, for various reasons. if we want
# them to be picked up, we need to enable them explicitly.
import inspect
module_to_find = this_extension
if module_to_find.rfind(".py"):
module_to_find = module_to_find.rstrip(".py")
if module_to_find.find("/") != -1:
module_to_find = module_to_find.split("/")[-1]
for name, obj in inspect.getmembers(sys.modules[module_to_find], inspect.isclass):
import pyomo.util
# the second condition gets around goofyness related to issubclass returning
# True when the obj is the same as the test class.
if issubclass(obj, pyomo.util.plugin.SingletonPlugin) and name != "SingletonPlugin":
for plugin in solution_writer_plugins(all=True):
if isinstance(plugin, obj):
plugin.enable()
solution_plugins.append(plugin)
ef_solver = SolverFactory(options.solver_type,
solver_io=options.solver_io)
if isinstance(ef_solver, UnknownSolver):
raise ValueError("Failed to create solver of type="+
options.solver_type+
" for use in extensive form solve")
if len(options.solver_options) > 0:
print("Initializing ef solver with options="
+str(options.solver_options))
ef_solver.set_options("".join(options.solver_options))
if options.mipgap is not None:
if (options.mipgap < 0.0) or (options.mipgap > 1.0):
raise ValueError("Value of the mipgap parameter for the EF "
"solve must be on the unit interval; "
"value specified="+str(options.mipgap))
ef_solver.options.mipgap = float(options.mipgap)
ef_solver_manager = SolverManagerFactory(options.solver_manager_type,
host=options.pyro_host,
port=options.pyro_port)
if ef_solver_manager is None:
raise ValueError("Failed to create solver manager of type="
+options.solver_type+
" for use in extensive form solve")
binding_instance = CreateExtensiveFormInstance(options, scenario_tree)
ef = ExtensiveFormAlgorithm(options,
binding_instance,
scenario_tree,
ef_solver_manager,
ef_solver,
solution_plugins=solution_plugins)
return ef
def construct_ef_writer_options_parser(usage_string):
solver_list = SolverFactory.services()
solver_list = sorted( filter(lambda x: '_' != x[0], solver_list) )
solver_help = \
"Specify the solver with which to solve the extensive form. The " \
"following solver types are currently supported: %s; Default: cplex"
solver_help %= ', '.join( solver_list )
parser = OptionParser()
parser.usage=usage_string
inputOpts = OptionGroup( parser, 'Input Options' )
scenarioTreeOpts = OptionGroup( parser, 'Scenario Tree Options' )
efOpts = OptionGroup( parser, 'EF Options' )
ccOpts = OptionGroup( parser, 'Chance Constraint Options' )
solverOpts = OptionGroup( parser, 'Solver Options' )
outputOpts = OptionGroup( parser, 'Output Options' )
otherOpts = OptionGroup( parser, 'Other Options' )
parser.add_option_group( inputOpts )
parser.add_option_group( scenarioTreeOpts )
parser.add_option_group( efOpts )
parser.add_option_group( ccOpts )
parser.add_option_group( solverOpts )
parser.add_option_group( outputOpts )
parser.add_option_group( otherOpts )
inputOpts.add_option('-i','--instance-directory',
help='The directory in which all instance (reference and scenario) definitions are stored. This option is required if no callback is found in the model file.',
action='store',
dest='instance_directory',
type='string',
default=None)
inputOpts.add_option('-m','--model-directory',
help='The directory in which all model (reference and scenario) definitions are stored. Default is ".".',
action='store',
dest='model_directory',
type='string',
default='.')
def objective_sense_callback(option, opt_str, value, parser):
if value in ('min','minimize',minimize):
parser.values.objective_sense = minimize
elif value in ('max','maximize',maximize):
parser.values.objective_sense = maximize
else:
parser.values.objective_sense = None
inputOpts.add_option('-o','--objective-sense-stage-based',
help='The objective sense to use for the auto-generated scenario instance objective, which is equal to the '
'sum of the scenario-tree stage costs. Default is None, indicating an Objective has been declared on the '
'reference model.',
action="callback",
dest="objective_sense",
type="choice",
choices=[maximize,'max','maximize',minimize,'min','minimize',None],
default=None,
callback=objective_sense_callback)
scenarioTreeOpts.add_option('--scenario-tree-seed',
help="The random seed associated with manipulation operations on the scenario tree (e.g., down-sampling). Default is None, indicating unassigned.",
action="store",
dest="scenario_tree_random_seed",
type="int",
default=random.getrandbits(100))
scenarioTreeOpts.add_option('--scenario-tree-downsample-fraction',
help="The proportion of the scenarios in the scenario tree that are actually used. Specific scenarios are selected at random. Default is 1.0, indicating no down-sampling.",
action="store",
dest="scenario_tree_downsample_fraction",
type="float",
default=1.0)
efOpts.add_option('--cvar-weight',
help='The weight associated with the CVaR term in the risk-weighted objective formulation. Default is 1.0. If the weight is 0, then *only* a non-weighted CVaR cost will appear in the EF objective - the expected cost component will be dropped.',
action='store',
dest='cvar_weight',
type='float',
default=1.0)
efOpts.add_option('--generate-weighted-cvar',
help='Add a weighted CVaR term to the primary objective',
action='store_true',
dest='generate_weighted_cvar',
default=False)
efOpts.add_option('--risk-alpha',
help='The probability threshold associated with cvar (or any future) risk-oriented performance metrics. Default is 0.95.',
action='store',
dest='risk_alpha',
type='float',
default=0.95)
ccOpts.add_option('--cc-alpha',
help='The probability threshold associated with a chance constraint. The RHS will be one minus this value. Default is 0.',
action='store',
dest='cc_alpha',
type='float',
default=0.0)
ccOpts.add_option('--cc-indicator-var',
help='The name of the binary variable to be used to construct a chance constraint. Default is None, which indicates no chance constraint.',
action='store',
dest='cc_indicator_var',
type='string',
default=None)
solverOpts.add_option('--mipgap',
help='Specifies the mipgap for the EF solve.',
action='store',
dest='mipgap',
type='float',
default=None)
solverOpts.add_option('--solve',
help='Following write of the extensive form model, solve it.',
action='store_true',
dest='solve_ef',
default=False)
solverOpts.add_option('--solver',
help=solver_help,
action='store',
dest='solver_type',
type='string',
default='cplex')
solverOpts.add_option('--solver-io',
help='The type of IO used to execute the solver. Different solvers support different types of IO, but the following are common options: lp - generate LP files, nl - generate NL files, python - direct Python interface, os - generate OSiL XML files.',
action='store',
dest='solver_io',
default=None)
solverOpts.add_option('--solver-manager',
help='The type of solver manager used to coordinate scenario sub-problem solves. Default is serial.',
action='store',
dest='solver_manager_type',
type='string',
default='serial')
solverOpts.add_option('--pyro-host',
help="The hostname to bind on when searching for a Pyro nameserver.",
action="store",
dest="pyro_host",
default=None)
solverOpts.add_option('--pyro-port',
help="The port to bind on when searching for a Pyro nameserver.",
action="store",
dest="pyro_port",
type="int",
default=None)
solverOpts.add_option('--solver-options',
help='Solver options for the extensive form problem.',
action='append',
dest='solver_options',
type='string',
default=[])
solverOpts.add_option('--disable-warmstarts',
help="Disable warm-starts of EF solves. Default is False.",
action="store_true",
dest="disable_warmstarts",
default=False)
solverOpts.add_option('--shutdown-pyro',
help="Shut down all Pyro-related components associated with the Pyro solver manager (if specified), including the dispatch server, name server, and any mip servers. Default is False.",
action="store_true",
dest="shutdown_pyro",
default=False)
solverOpts.add_option('--shutdown-pyro-workers',
help="Shut down PH solver servers on exit, leaving dispatcher and nameserver running. Default is False.",
action="store_true",
dest="shutdown_pyro_workers",
default=False)
outputOpts.add_option('--output-file',
help="The name of the extensive form output file (currently only LP and NL file formats are supported). If the option name does not end in '.lp' or '.nl', then the output format will be determined by the value of the --solver-io option, and the appropriate ending suffix will be added to the name. Default is 'efout'.",
action='store',
dest='output_file',
type='string',
default="efout")
outputOpts.add_option('--symbolic-solver-labels',
help='When interfacing with the solver, use symbol names derived from the model. For example, \"my_special_variable[1_2_3]\" instead of \"v1\". Useful for debugging. When using the ASL interface (--solver-io=nl), generates corresponding .row (constraints) and .col (variables) files. The ordering in these files provides a mapping from ASL index to symbolic model names.',
action='store_true',
dest='symbolic_solver_labels',
default=False)
outputOpts.add_option('--output-solver-log',
help='Output solver log during the extensive form solve.',
action='store_true',
dest='output_solver_log',
default=False)
outputOpts.add_option('--solution-writer',
help='The plugin invoked to write the scenario tree solution. Defaults to the empty list.',
action='append',
dest='solution_writer',
type='string',
default = [])
outputOpts.add_option('--verbose',
help='Generate verbose output, beyond the usual status output. Default is False.',
action='store_true',
dest='verbose',
default=False)
outputOpts.add_option('--output-times',
help="Output timing statistics for various EF components",
action="store_true",
dest="output_times",
default=False)
outputOpts.add_option('--output-instance-construction-time',
help="Output timing statistics for instance construction (client-side only when using PHPyro",
action="store_true",
dest="output_instance_construction_time",
default=False)
otherOpts.add_option('--disable-gc',
help='Disable the python garbage collecter. Default is False.',
action='store_true',
dest='disable_gc',
default=False)
otherOpts.add_option('-k','--keep-solver-files',
help='Retain temporary input and output files for solve.',
action='store_true',
dest='keep_solver_files',
default=False)
otherOpts.add_option('--profile',
help='Enable profiling of Python code. The value of this option is the number of functions that are summarized.',
action='store',
dest='profile',
type="int",
default=0)
otherOpts.add_option('--traceback',
help='When an exception is thrown, show the entire call stack. Ignored if profiling is enabled. Default is False.',
action='store_true',
dest='traceback',
default=False)
otherOpts.add_option('--compile-scenario-instances',
help="Replace all linear constraints on scenario instances with a more memory efficient sparse matrix representation. Default is False.",
action="store_true",
dest="compile_scenario_instances",
default=False)
return parser
def run_scenario(input_files, Solver, timesteps, scenario, result_dir, dt,
objective, plot_tuples=None, plot_sites_name=None,
plot_periods=None, report_tuples=None,
report_sites_name=None):
""" run an urbs model for given input, time steps and scenario
Args:
- input_files: filenames of input Excel spreadsheets
- Solver: the user specified solver
- timesteps: a list of timesteps, e.g. range(0,8761)
- scenario: a scenario function that modifies the input data dict
- result_dir: directory name for result spreadsheet and plots
- dt: length of each time step (unit: hours)
- objective: objective function chosen (either "cost" or "CO2")
- plot_tuples: (optional) list of plot tuples (c.f. urbs.result_figures)
- plot_sites_name: (optional) dict of names for sites in plot_tuples
- plot_periods: (optional) dict of plot periods
(c.f. urbs.result_figures)
- report_tuples: (optional) list of (sit, com) tuples
(c.f. urbs.report)
- report_sites_name: (optional) dict of names for sites in
report_tuples
Returns:
the urbs model instance
"""
# sets a modeled year for non-intertemporal problems
#(necessary for consitency)
year = date.today().year
# scenario name, read and modify data for scenario
sce = scenario.__name__
data = read_input(input_files,year)
data = scenario(data)
validate_input(data)
# create model
prob = create_model(data, dt, timesteps, objective)
# prob.write('model.lp', io_options={'symbolic_solver_labels':True})
# refresh time stamp string and create filename for logfile
log_filename = os.path.join(result_dir, '{}.log').format(sce)
# solve model and read results
optim = SolverFactory(Solver) # cplex, glpk, gurobi, ...
optim = setup_solver(optim, logfile=log_filename)
result = optim.solve(prob, tee=True)
assert str(result.solver.termination_condition) == 'optimal'
# save problem solution (and input data) to HDF5 file
save(prob, os.path.join(result_dir, '{}.h5'.format(sce)))
# write report to spreadsheet
report(
prob,
os.path.join(result_dir, '{}.xlsx').format(sce),
report_tuples=report_tuples,
report_sites_name=report_sites_name)
# result plots
result_figures(
prob,
os.path.join(result_dir, '{}'.format(sce)),
timesteps,
plot_title_prefix=sce.replace('_', ' '),
plot_tuples=plot_tuples,
plot_sites_name=plot_sites_name,
periods=plot_periods,
figure_size=(24, 9))
return prob
def _get_task_data(self, ah, *args, **kwds):
opt = kwds.pop('solver', kwds.pop('opt', None))
if opt is None:
raise ActionManagerError(
"No solver passed to %s, use keyword option 'solver'"
% (type(self).__name__) )
deactivate_opt = False
if isinstance(opt, six.string_types):
deactivate_opt = True
opt = SolverFactory(opt, solver_io=kwds.pop('solver_io', None))
#
# The following block of code is taken from the OptSolver.solve()
# method, which we do not directly invoke with this interface
#
#
# If the inputs are models, then validate that they have been
# constructed! Collect suffix names to try and import from solution.
#
for arg in args:
if isinstance(arg, Block):
if not arg.is_constructed():
raise RuntimeError(
"Attempting to solve model=%s with unconstructed "
"component(s)" % (arg.name,) )
model_suffixes = list(name for (name,comp) \
in active_import_suffix_generator(arg))
if len(model_suffixes) > 0:
kwds_suffixes = kwds.setdefault('suffixes',[])
for name in model_suffixes:
if name not in kwds_suffixes:
kwds_suffixes.append(name)
#
# Handle ephemeral solvers options here. These
# will override whatever is currently in the options
# dictionary, but we will reset these options to
# their original value at the end of this method.
#
ephemeral_solver_options = {}
ephemeral_solver_options.update(kwds.pop('options', {}))
ephemeral_solver_options.update(
OptSolver._options_string_to_dict(kwds.pop('options_string', '')))
#
# Force pyomo.opt to ignore tests for availability, at least locally.
#
del_available = bool('available' not in kwds)
kwds['available'] = True
opt._presolve(*args, **kwds)
problem_file_string = None
with open(opt._problem_files[0], 'r') as f:
problem_file_string = f.read()
#
# Delete this option, to ensure that the remote worker does the check for
# availability.
#
if del_available:
del kwds['available']
#
# We can't pickle the options object itself - so extract a simple
# dictionary of solver options and re-construct it on the other end.
#
solver_options = {}
for key in opt.options:
solver_options[key]=opt.options[key]
solver_options.update(ephemeral_solver_options)
#
# NOTE: let the distributed node deal with the warm-start
# pick up the warm-start file, if available.
#
warm_start_file_string = None
warm_start_file_name = None
if hasattr(opt, "_warm_start_solve"):
if opt._warm_start_solve and \
(opt._warm_start_file_name is not None):
warm_start_file_name = opt._warm_start_file_name
with open(warm_start_file_name, 'r') as f:
warm_start_file_string = f.read()
data = pyutilib.misc.Bunch(opt=opt.type, \
file=problem_file_string, \
filename=opt._problem_files[0], \
warmstart_file=warm_start_file_string, \
warmstart_filename=warm_start_file_name, \
kwds=kwds, \
solver_options=solver_options, \
suffixes=opt._suffixes)
self._args[ah.id] = args
self._opt_data[ah.id] = (opt._smap_id,
opt._load_solutions,
opt._select_index,
opt._default_variable_value)
if deactivate_opt:
opt.deactivate()
return data
def _perform_queue(self, ah, *args, **kwds):
"""
Perform the queue operation. This method returns the ActionHandle,
and the ActionHandle status indicates whether the queue was successful.
"""
solver = kwds.pop('solver', kwds.pop('opt', None))
if solver is None:
raise ActionManagerError(
"No solver passed to %s, use keyword option 'solver'" %
(type(self).__name__))
if not isinstance(solver, six.string_types):
solver_name = solver.name
if solver_name == 'asl':
solver_name = \
os.path.basename(solver.executable())
else:
solver_name = solver
solver = None
#
# Handle ephemeral solvers options here. These
# will override whatever is currently in the options
# dictionary, but we will reset these options to
# their original value at the end of this method.
#
user_solver_options = {}
# make sure to transfer the options dict on the
# solver plugin if the user does not use a string
# to identify the neos solver. The ephemeral
# options must also go after these.
if solver is not None:
user_solver_options.update(solver.options)
user_solver_options.update(kwds.pop('options', {}))
user_solver_options.update(
OptSolver._options_string_to_dict(kwds.pop('options_string', '')))
opt = SolverFactory('_neos')
opt._presolve(*args, **kwds)
#
# Map NEOS name, using lowercase convention in Pyomo
#
if len(self._solvers) == 0:
for name in self.kestrel.solvers():
if name.endswith('AMPL'):
self._solvers[name[:-5].lower()] = name[:-5]
if solver_name not in self._solvers:
raise ActionManagerError(
"Solver '%s' is not recognized by NEOS. "
"Solver names recognized:\n%s" %
(solver_name, str(sorted(self._solvers.keys()))))
#
# Apply kestrel
#
# Set the kestrel_options environment
#
neos_sname = self._solvers[solver_name].lower()
os.environ[
'kestrel_options'] = 'solver=%s' % self._solvers[solver_name]
#
# Set the <solver>_options environment
#
solver_options = {}
for key in opt.options:
solver_options[key] = opt.options[key]
solver_options.update(user_solver_options)
options = opt._get_options_string(solver_options)
if not options == "":
os.environ[neos_sname + '_options'] = options
#
# Generate an XML string using these two environment variables
#
xml = self.kestrel.formXML(opt._problem_files[0])
(jobNumber, password) = self.kestrel.submit(xml)
ah.job = jobNumber
ah.password = password
#
# Cleanup
#
del os.environ['kestrel_options']
try:
del os.environ[neos_sname + "_options"]
except:
pass
#
# Store action handle, and return
#
self._ah[jobNumber] = ah
self._neos_log[jobNumber] = (0, "")
self._opt_data[jobNumber] = (opt, opt._smap_id, opt._load_solutions,
opt._select_index,
opt._default_variable_value)
self._args[jobNumber] = args
return ah
edge = pdshp.read_shp(edge_shapefile)
edge = edge.set_index('Edge')
edge = edge.join(total_area)
edge = edge.fillna(0)
# load nodes
vertex = pdshp.read_shp(vertex_shapefile)
# load spreadsheet data
data = rivus.read_excel(data_spreadsheet)
# create and solve model
prob = rivus.create_model(data, vertex, edge)
if PYOMO3:
prob = prob.create() # no longer needed in Pyomo 4<
solver = SolverFactory('glpk')
result = solver.solve(prob, tee=True)
if PYOMO3:
prob.load(result) #no longer needed in Pyomo 4<
# load results
costs, Pmax, Kappa_hub, Kappa_process = rivus.get_constants(prob)
source, flows, hub_io, proc_io, proc_tau = rivus.get_timeseries(prob)
result_dir = os.path.join('result', os.path.basename(base_directory))
# create result directory if not existing already
if not os.path.exists(result_dir):
os.makedirs(result_dir)
rivus.save(prob, os.path.join(result_dir, 'prob.pgz'))
def run_scenario(input_files, Solver, timesteps, scenario, result_dir, dt,
objective, plot_tuples=None, plot_sites_name=None,
plot_periods=None, report_tuples=None,
report_sites_name=None):
""" run an urbs model for given input, time steps and scenario
Args:
- input_files: filenames of input Excel spreadsheets
- Solver: the user specified solver
- timesteps: a list of timesteps, e.g. range(0,8761)
- scenario: a scenario function that modifies the input data dict
- result_dir: directory name for result spreadsheet and plots
- dt: length of each time step (unit: hours)
- objective: objective function chosen (either "cost" or "CO2")
- plot_tuples: (optional) list of plot tuples (c.f. urbs.result_figures)
- plot_sites_name: (optional) dict of names for sites in plot_tuples
- plot_periods: (optional) dict of plot periods
(c.f. urbs.result_figures)
- report_tuples: (optional) list of (sit, com) tuples
(c.f. urbs.report)
- report_sites_name: (optional) dict of names for sites in
report_tuples
Returns:
the urbs model instance
"""
# sets a modeled year for non-intertemporal problems
# (necessary for consitency)
year = date.today().year
# scenario name, read and modify data for scenario
sce = scenario.__name__
data = read_input(input_files, year)
data = scenario(data)
validate_input(data)
validate_dc_objective(data, objective)
# create model
prob = create_model(data, dt, timesteps, objective)
# prob.write('model.lp', io_options={'symbolic_solver_labels':True})
# refresh time stamp string and create filename for logfile
log_filename = os.path.join(result_dir, '{}.log').format(sce)
# solve model and read results
optim = SolverFactory(Solver) # cplex, glpk, gurobi, ...
optim = setup_solver(optim, logfile=log_filename)
result = optim.solve(prob, tee=True)
assert str(result.solver.termination_condition) == 'optimal'
# save problem solution (and input data) to HDF5 file
save(prob, os.path.join(result_dir, '{}.h5'.format(sce)))
# write report to spreadsheet
report(
prob,
os.path.join(result_dir, '{}.xlsx').format(sce),
report_tuples=report_tuples,
report_sites_name=report_sites_name)
# result plots
result_figures(
prob,
os.path.join(result_dir, '{}'.format(sce)),
timesteps,
plot_title_prefix=sce.replace('_', ' '),
plot_tuples=plot_tuples,
plot_sites_name=plot_sites_name,
periods=plot_periods,
figure_size=(24, 9))
return prob
# read vertices and edges from shapefiles...
vertex = geopandas.read_file(vertex_file)
edge = geopandas.read_file(edge_file)
# ... and set indices to agree with Excel format
vertex.set_index(['Vertex'], inplace=True)
edge.set_index(['Edge', 'Vertex1', 'Vertex2'], inplace=True)
# at this point, rundh.py and rundhshp.py work identically!
# dhmin.create_model must not rely on vertex/edge DataFrames to contain any
# geometry information
# get model
# create instance
# solver interface (GLPK)
prob = dhmin.create_model(vertex, edge, params, timesteps)
solver = SolverFactory('glpk')
result = solver.solve(prob, timelimit=30, tee=True)
prob.solutions.load_from(result)
# use special-purpose function to plot power flows (works unchanged!)
dhmintools.plot_flows_min(prob)
# read time-independent variable values to DataFrame
# (list all variables using dhmin.list_entities(instance, 'variables')
caps = dhmin.get_entities(prob, ['Pmax', 'x'])
costs = dhmin.get_entity(prob, 'costs')
# remove Edge from index, so that edge and caps are both indexed on
# (vertex, vertex) tuples, i.e. their indices match for identical edges
edge.reset_index('Edge', inplace=True)
def _perform_queue(self, ah, *args, **kwds):
"""
Perform the queue operation. This method returns the ActionHandle,
and the ActionHandle status indicates whether the queue was successful.
"""
solver = kwds.pop('solver', kwds.pop('opt', None))
if solver is None:
raise ActionManagerError(
"No solver passed to %s, use keyword option 'solver'"
% (type(self).__name__) )
if not isinstance(solver, six.string_types):
solver_name = solver.name
if solver_name == 'asl':
solver_name = \
os.path.basename(solver.executable())
else:
solver_name = solver
solver = None
#
# Handle ephemeral solvers options here. These
# will override whatever is currently in the options
# dictionary, but we will reset these options to
# their original value at the end of this method.
#
user_solver_options = {}
# make sure to transfer the options dict on the
# solver plugin if the user does not use a string
# to identify the neos solver. The ephemeral
# options must also go after these.
if solver is not None:
user_solver_options.update(solver.options)
user_solver_options.update(
kwds.pop('options', {}))
user_solver_options.update(
OptSolver._options_string_to_dict(kwds.pop('options_string', '')))
opt = SolverFactory('_neos')
opt._presolve(*args, **kwds)
#
# Map NEOS name, using lowercase convention in Pyomo
#
if len(self._solvers) == 0:
for name in self.kestrel.solvers():
if name.endswith('AMPL'):
self._solvers[ name[:-5].lower() ] = name[:-5]
if solver_name not in self._solvers:
raise ActionManagerError(
"Solver '%s' is not recognized by NEOS. "
"Solver names recognized:\n%s"
% (solver_name, str(sorted(self._solvers.keys()))))
#
# Apply kestrel
#
# Set the kestrel_options environment
#
neos_sname = self._solvers[solver_name].lower()
os.environ['kestrel_options'] = 'solver=%s' % self._solvers[solver_name]
#
# Set the <solver>_options environment
#
solver_options = {}
for key in opt.options:
solver_options[key]=opt.options[key]
solver_options.update(user_solver_options)
options = opt._get_options_string(solver_options)
if not options == "":
os.environ[neos_sname+'_options'] = options
#
# Generate an XML string using these two environment variables
#
xml = self.kestrel.formXML(opt._problem_files[0])
(jobNumber, password) = self.kestrel.submit(xml)
ah.job = jobNumber
ah.password = password
#
# Cleanup
#
del os.environ['kestrel_options']
try:
del os.environ[neos_sname+"_options"]
except:
pass
#
# Store action handle, and return
#
self._ah[jobNumber] = ah
self._neos_log[jobNumber] = (0, "")
self._opt_data[jobNumber] = (opt,
opt._smap_id,
opt._load_solutions,
opt._select_index,
opt._default_variable_value)
self._args[jobNumber] = args
return ah
def process(self, data):
self._worker_task_return_queue = self._current_task_client
data = pyutilib.misc.Bunch(**data)
if hasattr(data, 'action') and \
data.action == 'Pyomo_pyro_mip_server_shutdown':
print("Received shutdown request")
self._worker_shutdown = True
return
time_start = time.time()
with pyutilib.services.TempfileManager.push():
#
# Construct the solver on this end, based on the input
# type stored in "data.opt". This is slightly more
# complicated for asl-based solvers, whose real executable
# name is stored in data.solver_options["solver"].
#
with SolverFactory(data.opt) as opt:
if opt is None:
self._worker_error = True
return TaskProcessingError(
"Problem constructing solver `" + data.opt + "'")
# here is where we should set any options required by
# the solver, available as specific attributes of the
# input data object.
solver_options = data.solver_options
del data.solver_options
for key, value in solver_options.items():
setattr(opt.options, key, value)
problem_filename_suffix = os.path.split(data.filename)[1]
temp_problem_filename = \
pyutilib.services.TempfileManager.\
create_tempfile(suffix="."+problem_filename_suffix)
with open(temp_problem_filename, 'w') as f:
f.write(data.file)
if data.warmstart_filename is not None:
warmstart_filename_suffix = \
os.path.split(data.warmstart_filename)[1]
temp_warmstart_filename = \
pyutilib.services.TempfileManager.\
create_tempfile(suffix="."+warmstart_filename_suffix)
with open(temp_warmstart_filename, 'w') as f:
f.write(data.warmstart_file)
assert opt.warm_start_capable()
assert (('warmstart' in data.kwds) and \
data.kwds['warmstart'])
data.kwds['warmstart_file'] = temp_warmstart_filename
now = datetime.datetime.now()
if self._verbose:
print(
str(now) + ": Applying solver=" + data.opt +
" to solve problem=" + temp_problem_filename)
sys.stdout.flush()
results = opt.solve(temp_problem_filename, **data.kwds)
assert results._smap_id is None
# NOTE: This results object contains solutions,
# because no model is provided (just a model file).
# Also, the results._smap_id value is None.
results.pyomo_solve_time = time.time() - time_start
now = datetime.datetime.now()
if self._verbose:
print(
str(now) + ": Solve completed - number of solutions=" +
str(len(results.solution)))
sys.stdout.flush()
# PYTHON3 / PYRO4 Fix
# The default serializer in Pyro4 is not pickle and does not
# support user defined types (e.g., the results object).
# Therefore, we pickle the results object before sending it
# over the wire so the user does not need to change the Pyro
# serializer.
results = pickle.dumps(results, protocol=pickle.HIGHEST_PROTOCOL)
if using_pyro4:
#
# The standard bytes object returned by pickle.dumps must be
# converted to base64 to avoid errors sending over the
# wire with Pyro4. Also, the base64 bytes must be wrapped
# in a str object to avoid a different set of Pyro4 errors
# related to its default serializer (Serpent)
if six.PY3:
results = str(base64.encodebytes(results))
else:
results = base64.encodestring(results)
return results
def apply_optimizer(data, instance=None):
"""
Perform optimization with a concrete instance
Required:
instance: Problem instance.
Returned:
results: Optimization results.
opt: Optimizer object.
"""
#
if not data.options.runtime.logging == 'quiet':
sys.stdout.write('[%8.2f] Applying solver\n' %
(time.time() - start_time))
sys.stdout.flush()
#
#
# Create Solver and Perform Optimization
#
solver = data.options.solvers[0].solver_name
if solver is None:
raise ValueError("Problem constructing solver: no solver specified")
if len(data.options.solvers[0].suffixes) > 0:
for suffix_name in data.options.solvers[0].suffixes:
if suffix_name[0] in ['"', "'"]:
suffix_name = suffix[1:-1]
# Don't redeclare the suffix if it already exists
suffix = getattr(instance, suffix_name, None)
if suffix is None:
setattr(instance, suffix_name, Suffix(direction=Suffix.IMPORT))
else:
raise ValueError("Problem declaring solver suffix %s. A component "\
"with that name already exists on model %s."
% (suffix_name, instance.name))
if getattr(data.options.solvers[0].options, 'timelimit', 0) == 0:
data.options.solvers[0].options.timelimit = None
#
# Default results
#
results = None
#
# Figure out the type of solver manager
#
solver_mngr_name = None
if data.options.solvers[0].manager is None:
solver_mngr_name = 'serial'
elif not data.options.solvers[0].manager in SolverManagerFactory:
raise ValueError("Unknown solver manager %s" %
data.options.solvers[0].manager)
else:
solver_mngr_name = data.options.solvers[0].manager
#
# Create the solver manager
#
solver_mngr_kwds = {}
if data.options.solvers[0].pyro_host is not None:
solver_mngr_kwds['host'] = data.options.solvers[0].pyro_host
if data.options.solvers[0].pyro_port is not None:
solver_mngr_kwds['port'] = data.options.solvers[0].pyro_port
with SolverManagerFactory(solver_mngr_name,
**solver_mngr_kwds) as solver_mngr:
if solver_mngr is None:
msg = "Problem constructing solver manager '%s'"
raise ValueError(msg % str(data.options.solvers[0].manager))
#
# Setup keywords for the solve
#
keywords = {}
if (data.options.runtime.keep_files or \
data.options.postsolve.print_logfile):
keywords['keepfiles'] = True
if data.options.model.symbolic_solver_labels:
keywords['symbolic_solver_labels'] = True
if data.options.model.file_determinism != 1:
keywords['file_determinism'] = data.options.model.file_determinism
keywords['tee'] = data.options.runtime.stream_output
keywords['timelimit'] = getattr(data.options.solvers[0].options,
'timelimit', 0)
keywords['report_timing'] = data.options.runtime.report_timing
# FIXME: solver_io and executable are not being used
# in the case of a non-serial solver manager
#
# Call the solver
#
if solver_mngr_name == 'serial':
#
# If we're running locally, then we create the
# optimizer and pass it into the solver manager.
#
sf_kwds = {}
sf_kwds['solver_io'] = data.options.solvers[0].io_format
if data.options.solvers[0].solver_executable is not None:
sf_kwds['executable'] = data.options.solvers[
0].solver_executable
with SolverFactory(solver, **sf_kwds) as opt:
if opt is None:
raise ValueError("Problem constructing solver `%s`" %
str(solver))
from pyomo.core.base.plugin import registered_callback
for name in registered_callback:
opt.set_callback(name, registered_callback[name])
if len(data.options.solvers[0].options) > 0:
opt.set_options(data.options.solvers[0].options)
#opt.set_options(" ".join("%s=%s" % (key, value)
# for key, value in data.options.solvers[0].options.iteritems()
# if not key == 'timelimit'))
if not data.options.solvers[0].options_string is None:
opt.set_options(data.options.solvers[0].options_string)
#
# Use the solver manager to call the optimizer
#
results = solver_mngr.solve(instance, opt=opt, **keywords)
else:
#
# Get the solver option arguments
#
if len(
data.options.solvers[0].options
) > 0 and not data.options.solvers[0].options_string is None:
# If both 'options' and 'options_string' were specified, then create a
# single options string that is passed to the solver.
ostring = " ".join("%s=%s" % (key, value) for key, value in
data.options.solvers[0].options.iteritems()
if not value is None)
keywords['options'] = ostring + ' ' + data.options.solvers[
0].options_string
elif len(data.options.solvers[0].options) > 0:
keywords['options'] = data.options.solvers[0].options
else:
keywords['options'] = data.options.solvers[0].options_string
#
# If we're running remotely, then we pass the optimizer name to the solver
# manager.
#
results = solver_mngr.solve(instance, opt=solver, **keywords)
if (pympler_available is True) and \
(data.options.runtime.profile_memory >= 1):
global memory_data
mem_used = muppy.get_size(muppy.get_objects())
if mem_used > data.local.max_memory:
data.local.max_memory = mem_used
print(" Total memory = %d bytes following optimization" % mem_used)
return pyutilib.misc.Options(results=results, opt=solver, local=data.local)
vert_init_commodities(vertex, ('Elec', 'Gas', 'Heat'),
[('Elec', 0, 100000), ('Gas', 0, 5000)])
profile_log['grid_data'] = timenow() - extendgrid
# Non spatial input
data_spreadsheet = os.path.join(base_directory, 'data.xlsx')
excelread = timenow()
data = read_excel(data_spreadsheet)
profile_log['excel_read'] = timenow() - excelread
# Create and solve model
rivusmain = timenow()
prob = create_model(data, vertex, edge)
profile_log['rivus_main'] = timenow() - rivusmain
solver = SolverFactory(config['solver'])
solver = setup_solver(solver)
startsolver = timenow()
result = solver.solve(prob, tee=True)
profile_log['solver'] = timenow() - startsolver
# Handling results
if not os.path.exists(result_dir):
os.makedirs(result_dir)
if SAVE_PICKLE:
print('Saving pickle...')
rivuspickle = timenow()
save(prob, os.path.join(result_dir, 'prob.pgz'))
profile_log['save_data'] = timenow() - rivuspickle
def run_scenario(scenario):
# scenario name
sce = scenario.__name__
sce_nice_name = sce.replace('_', ' ').title()
# prepare input data
data = rivus.read_excel(data_spreadsheet)
vertex = pdshp.read_shp(vertex_shapefile)
edge = prepare_edge(edge_shapefile, building_shapefile)
# apply scenario function to input data
data, vertex, edge = scenario(data, vertex, edge)
# create & solve model
prob = rivus.create_model(data, vertex, edge)
if PYOMO3:
prob = prob.create() # no longer needed in Pyomo 4+
optim = SolverFactory('gurobi')
optim = setup_solver(optim)
result = optim.solve(prob, tee=True)
if PYOMO3:
prob.load(result) # no longer needed in Pyomo 4+
# create result directory if not existent
result_dir = os.path.join('result', os.path.basename(base_directory))
if not os.path.exists(result_dir):
os.makedirs(result_dir)
# report
rivus.report(prob, os.path.join(result_dir, 'report.xlsx'))
# plots
for com, plot_type in [('Elec', 'caps'), ('Heat', 'caps'), ('Gas', 'caps'),
('Elec', 'peak'), ('Heat', 'peak')]:
# two plot variants
for plot_annotations in [False, True]:
# create plot
fig = rivus.plot(prob,
com,
mapscale=False,
tick_labels=False,
plot_demand=(plot_type == 'peak'),
annotations=plot_annotations)
plt.title('')
# save to file
for ext, transp in [('png', True), ('png', False), ('pdf', True)]:
transp_str = ('-transp' if transp and ext != 'pdf' else '')
annote_str = ('-annote' if plot_annotations else '')
# determine figure filename from scenario name, plot type,
# commodity, transparency, annotations and extension
fig_filename = '{}-{}-{}{}{}.{}'.format(
sce, plot_type, com, transp_str, annote_str, ext)
fig_filename = os.path.join(result_dir, fig_filename)
fig.savefig(fig_filename,
dpi=300,
bbox_inches='tight',
transparent=transp)
return prob
def _perform_queue(self, ah, *args, **kwds):
"""
Perform the queue operation. This method returns the ActionHandle,
and the ActionHandle status indicates whether the queue was successful.
"""
solver = kwds.pop('solver', kwds.pop('opt', None))
if solver is None:
raise ActionManagerError(
"No solver passed to %s, use keyword option 'solver'"
% (type(self).__name__) )
if not isinstance(solver, six.string_types):
solver = solver.name
#
# Handle ephemeral solvers options here. These
# will override whatever is currently in the options
# dictionary, but we will reset these options to
# their original value at the end of this method.
#
ephemeral_solver_options = {}
ephemeral_solver_options.update(kwds.pop('options', {}))
ephemeral_solver_options.update(
OptSolver._options_string_to_dict(kwds.pop('options_string', '')))
opt = SolverFactory('_neos')
opt._presolve(*args, **kwds)
#
# Map NEOS name, using lowercase convention in Pyomo
#
if len(self._solvers) == 0:
for name in self.kestrel.solvers():
if name.endswith('AMPL'):
self._solvers[ name[:-5].lower() ] = name[:-5]
if not solver in self._solvers:
raise ActionManagerError("Solver '%s' is not recognized by NEOS" % solver)
#
# Apply kestrel
#
os.environ['kestrel_options'] = 'solver=%s' % self._solvers[solver]
solver_options = {}
for key in opt.options:
solver_options[key]=opt.options[key]
solver_options.update(ephemeral_solver_options)
options = opt._get_options_string(solver_options)
if not options == "":
os.environ[self._solvers[solver].lower()+'_options'] = opt._get_options_string()
xml = self.kestrel.formXML(opt._problem_files[0])
(jobNumber, password) = self.kestrel.submit(xml)
ah.job = jobNumber
ah.password = password
#
# Store action handle, and return
#
self._ah[jobNumber] = ah
self._neos_log[jobNumber] = (0, "")
self._opt_data[jobNumber] = (opt,
opt._smap_id,
opt._load_solutions,
opt._select_index,
opt._default_variable_value)
self._args[jobNumber] = args
return ah
edge = pdshp.read_shp(edge_shapefile)
edge = edge.set_index('Edge')
edge = edge.join(total_area)
edge = edge.fillna(0)
# load nodes
vertex = pdshp.read_shp(vertex_shapefile)
# load spreadsheet data
data = rivus.read_excel(data_spreadsheet)
# create & solve model
prob = rivus.create_model(data, vertex, edge)
if PYOMO3:
prob = prob.create() # no longer needed in Pyomo 4
optim = SolverFactory('glpk')
optim = setup_solver(optim)
result = optim.solve(prob, tee=True)
if PYOMO3:
prob.load(result) # no longer needed in Pyomo 4
# load results
costs, Pmax, Kappa_hub, Kappa_process = rivus.get_constants(prob)
source, flows, hub_io, proc_io, proc_tau = rivus.get_timeseries(prob)
result_dir = os.path.join('result', os.path.basename(base_directory))
# create result directory if not existing already
if not os.path.exists(result_dir):
os.makedirs(result_dir)
# Equation 10
m.C2Constraint = Constraint(m.Tm, rule=C2_constraint_rule)
# Equation 11
#m.dsmup2Constraint = Constraint(m.tm, rule=dsmup2_constraint_rule)
# Power
m.power1Constraint = Constraint(m.tm, rule=power1_constraint_rule)
m.power2Constraint = Constraint(m.tm, rule=power2_constraint_rule)
# Objective
m.obj = Objective(rule=obj_expression_cost, sense=minimize)
###############################################################################
# SOLVE
# solve model and read results
optim = SolverFactory('cbc')
result = optim.solve(m, tee=False)
# Check obj or var example
print('Objective:', m.obj())
output(m)
filename = os.path.join(os.path.dirname(__file__),
'./Comparisson/dsm_pyomo.lp')
m.write(filename, io_options={'symbolic_solver_labels': True})
#import pdb; pdb.set_trace()
import pyomo.environ
from pyomo.opt.base import SolverFactory
# config
data_file = 'mnl.xlsx'
params = {'r_heat':0.07} # only specify changed values
timesteps = [(1600,.8),(1040,.5)] # list of (duration [hours], scaling_factor) tuples
# annual fulload hours = sum(t, duration[t]*sf[t]) = 1800
# read vertices and edges from Excel data_file
# lines 2 and 3 are just a fancy way of writing
# vertex = dfs['Vertex']
# edge = dfs['Edge']
# while scaling better when the number of spreadsheets increase
data = dhmin.read_excel(data_file)
vertex, edge = data['Vertex'], data['Edge']
# get model
# create instance
# solver interface (GLPK)
prob = dhmin.create_model(vertex, edge, params, timesteps)
optim = SolverFactory('glpk')
prob.write('rundh.lp', io_options={'symbolic_solver_labels':True})
result = optim.solve(prob, timelimit=30, tee=True)
prob.solutions.load_from(result)
# use special-purpose function to plot power flows
dhmintools.plot_flows_min(prob)
def run_scenario(input_file, timesteps, scenario, result_dir):
""" run an urbs model for given input, time steps and scenario
Args:
input_file: filename to an Excel spreadsheet for urbs.read_excel
timesteps: a list of timesteps, e.g. range(0,8761)
scenario: a scenario function that modifies the input data dict
result_dir: directory name for result spreadsheet and plots
Returns:
the urbs model instance
"""
# scenario name, read and modify data for scenario
sce = scenario.__name__
data = urbs.read_excel(input_file)
data = scenario(data)
# create model, solve it, read results
prob = urbs.create_model(data, timesteps)
optim = SolverFactory('glpk') # cplex, glpk, gurobi, ...
result = optim.solve(prob, tee=True)
prob.solutions.load_from(result)
# refresh time stamp string
now = prob.created
# write report to spreadsheet
urbs.report(
prob,
os.path.join(result_dir, '{}-{}.xlsx').format(sce, now),
prob.com_demand, prob.sit)
# store optimisation problem for later re-analysis
urbs.save(
prob,
os.path.join(result_dir, '{}-{}.pgz').format(sce, now))
# add or change plot colors
my_colors = {
'Vled Haven': (230, 200, 200),
'Stryworf Key': (200, 230, 200),
'Qlyph Archipelago': (200, 200, 230),
'Jepid Island': (215,215,215)}
for country, color in my_colors.items():
urbs.COLORS[country] = color
# create timeseries plot for each demand (site, commodity) timeseries
for sit, com in prob.demand.columns:
# create figure
fig = urbs.plot(prob, com, sit)
# change the figure title
ax0 = fig.get_axes()[0]
nice_sce_name = sce.replace('_', ' ').title()
new_figure_title = ax0.get_title().replace(
'Energy balance of ', '{}: '.format(nice_sce_name))
ax0.set_title(new_figure_title)
# save plot to files
for ext in ['png', 'pdf']:
fig_filename = os.path.join(
result_dir, '{}-{}-{}-{}.{}').format(sce, com, sit, now, ext)
fig.savefig(fig_filename, bbox_inches='tight')
return prob
