def run_model(self, model, scenario, is_dods=True, override_env=None):
'''Run the scenario from the specified model.
Returns:
a dict with the output tables.
'''
variables = {}
variables['inputs'] = self.handler.get_inputs(model, scenario)
variables['output_lock'] = get_environment().output_lock
variables['outputs'] = {}
self.override_env = None
if isinstance(get_environment(), LocalEnvironment):
if override_env is None:
override_env = _WorkerEnvironmentOverride(get_environment())
self.override_env = override_env
with OverrideEnvironment(self.override_env):
saved_environ = os.environ.copy()
try:
if is_dods:
os.environ['IS_DODS'] = 'True'
os.environ['DOCPLEX_CONTEXT'] = 'solver.auto_publish=True'
with self.handler.get_input_stream(model, scenario,
'model.py') as m:
try:
contents = m.read()
if not isinstance(contents, str):
contents = contents.decode('utf-8')
exec(contents, variables)
except SyntaxError as err:
error_class = err.__class__.__name__
detail = err.args[0]
line_number = err.lineno
imsg = 'File "model.py", line %s\n' % line_number
imsg += err.text.rstrip() + '\n'
spaces = ' ' * (err.offset -
1) if err.offset > 1 else ''
imsg += spaces + "^\n"
imsg += '%s: %s\n' % (error_class, detail)
raise InterpreterError(imsg)
except Exception as err:
error_class = err.__class__.__name__
detail = err.args[0]
_, _, tb = sys.exc_info()
ttb = traceback.extract_tb(tb)
ttb[1] = ('model.py', ttb[1][1], ttb[1][2],
get_line_of_model(ttb[1][1], self.handler,
model, scenario))
line_number = ttb[1][1]
ttb = ttb[1:]
s = traceback.format_list(ttb)
imsg = (''.join(s))
imsg += '%s: %s\n' % (error_class, detail)
raise InterpreterError(imsg)
return variables['outputs']
finally:
os.environ = saved_environ
def __init__(self, l, D, L, ek, name):
t0 = time.time()
print("iniciovalerio")
x = {}
y = [] #variavel auxiliar para imprimir a construção de arcos
p = [] #variável auxiliar para construção das restrições
q = [] #variável auxiliar para construção das restrições
r1 = [] #variável auxiliar para construção das restrições
r2 = [] #variável auxiliar para construção das restrições
d = [] #variável auxiliar para a construção da demanda
f = []
vcm = Model(name='valeriodecarvalho')
lmin = np.amin(l)
self.criterio2(L, lmin, x, vcm)
self.criterio1(l, x, vcm, L)
self.getvar(vcm, y)
#print(y)
z = []
self.conservF(vcm, p, q, L, l, f, r1, r2, D, d, ek)
for k in range(0, len(L)):
z.append(vcm.get_var_by_name('z_' + str(k)))
#print(z)
self.getvar(vcm, y)
consts = []
n = vcm.number_of_constraints
for i in range(n):
consts.append(vcm.get_constraint_by_index(i))
vcms = vcm.solve(url=None, key=None, log_output=True)
tempo = time.time() - t0,
reseau = open(name, 'w', 0)
reseau.write('Função Objetivo: ' + str(vcm.solution.get_objective_value))
reseau.write('\nTempo Total: ' + str(tempo))
reseau.close()
with get_environment().get_output_stream("solution.json") as fp:
vcm.solution.export(fp, "json")
def run_optimization(self):
self.area_discr()
self.dec_var()
self.general_constr()
self.charge_constr()
self.time_constr()
self.create_obj_funct()
#self.plp.update()
# self.cm.write("cplex.lp") # write to LP file
#self.plp.setParam('Timelimit', 5) # Time limit in seconds
#self.plp.setParam('MIPGap', .1) # Set a gap at which it stops with 0.1 equal to 10 percent
self.cm.print_information()
s = self.cm.solve()
self.cm.display()
if s:
qty_vars = self.cm.find_matching_vars(pattern="q_")
for fv in qty_vars:
food_name = fv.name[2:]
print("Buy {0:<25} = {1:9.6g}".format(food_name,
fv.solution_value))
self.cm.report_kpis()
# Save the CPLEX solution as "solution.json" program output
with get_environment().get_output_stream("solution.json") as fp:
self.cm.solution.export(fp, "json")
else:
print("* model has no solution")
def get_environment():
""" Get the environment descriptor
Returns:
Environment descriptor, None if none
"""
return None if runenv is None else runenv.get_environment()
def new_solver_created(solver):
""" Add environment solver listener if needed
Args:
solver: Solver to update
"""
# Check if environment package not present
if runenv is None:
return
# Check no environment
env = runenv.get_environment()
if env is None:
return
# Retrieve auto_publish context
pctx = solver.context.solver.auto_publish
if pctx is True:
# Create default context to retrieve always default values
pctx = Context()
elif not isinstance(pctx, Context):
return
# Check no local publish
if isinstance(env, runenv.LocalEnvironment) and not pctx.local_publish:
return
# Add solver listener
solver.add_listener(EnvSolverListener(env, pctx))
def write_output_table(self, df, context,
output_property_name=None,
output_name=None):
'''Publishes the output `df`.
The `context` is used to control the output name:
- If context.solver.auto_publish is true, the `df` is written using
output_name.
- If context.solver.auto_publish is false, This method does nothing.
- If context.solver.auto_publish.output_property_name is true,
then `df` is written using output_name.
- If context.solver.auto_publish.output_propert_name is None or
False, this method does nothing.
- If context.solver.auto_publish.output_propert_name is a string,
it is used as a name to publish the df
Example:
A solver can be defined as publishing a result as data frame::
class SomeSolver(PublishResultAsDf)
def __init__(self, output_customizer):
# output something if context.solver.autopublish.somesolver_output is set
self.output_table_property_name = 'somesolver_output'
# output filename unless specified by somesolver_output:
self.default_output_table_name = 'somesolver.csv'
# customizer if users wants one
self.output_table_customizer = output_customizer
# uses pandas.DataFrame if possible, otherwise will use namedtuples
self.output_table_using_df = True
def solve(self):
# do something here and return a result as a df
result = pandas.DataFrame(columns=['A','B','C'])
return result
Example usage::
solver = SomeSolver()
results = solver.solve()
solver.write_output_table(results)
'''
prop = value_if_defined(self, 'output_table_property_name')
prop = output_property_name if output_property_name else prop
default_name = value_if_defined(self, 'default_output_table_name')
default_name = output_name if output_name else default_name
names = get_auto_publish_names(context, prop, default_name)
use_df = value_if_defined(self, 'output_table_using_df', True)
if names:
env = get_environment()
customizer = value_if_defined(self, 'output_table_customizer', identity_func)
for name in names:
r = customizer(df)
if pandas and use_df:
env.write_df(r, name)
else:
# assume r is a namedtuple
write_csv(env, r, r[0]._fields, name)
def _get_environment(solver, prop):
""" Get the environment to call, checking if auto-publish is required.
Args:
solver: Source CPO solver
prop: Auto_publish specific property that should be checked
Returns:
Environment to call, None if none
"""
# Check if environment available
if not ENVIRONMENT_PRESENT:
return None
# Skip if environment is local
env = runenv.get_environment()
if isinstance(env, runenv.LocalEnvironment):
return None
# Check auto_publish config
pblsh = solver.context.solver.auto_publish
if (pblsh is None) or not (
(pblsh is True) or
(isinstance(pblsh, Context) and pblsh.get_attribute(prop))):
return None
# Return
return env
def _init_listener(self, solver):
""" Initialize this listener
Args:
solver: Calling solver
Returns:
True if listener is OK, False if should be removed from solver.
"""
# Check if environment package not present
self.env = None if runenv is None else runenv.get_environment()
if self.env is None:
return False
# Retrieve auto_publish context
pctx = solver.context.solver.auto_publish
if pctx is True:
# Create default context to retrieve always default values
pctx = Context()
elif not isinstance(pctx, Context):
return False
self.publish_context = pctx
# Check no local publish
if isinstance(self.env,
runenv.LocalEnvironment) and not pctx.local_publish:
return False
# Keep as listener
return True
def notify_solution(self, incumbents):
super(KpiRecorder, self).notify_solution(incumbents)
publish_name_fn = self.publish_name_fn
if self._last_accept:
self._report_count += 1
# build a name/value dictionary with builtin values
k = self._model.kpis_as_dict(self.current_solution, use_names=True)
name_values = {publish_name_fn(kn): kv for kn, kv in iteritems(k)}
# This must be this value for the current objective
name_values['PROGRESS_CURRENT_OBJECTIVE'] = self.current_solution.objective_value
# predefined keys, not KPIs
# name_values[publish_name_fn('_objective')] = self.current_solution.objective_value
name_values[publish_name_fn('_time')] = self._last_time
self._kpis.append(name_values)
# usually publish kpis in environment...
if self.publish_hook is not None:
self.publish_hook(name_values)
# save kpis.csv table
context = self._model.context
if auto_publising_kpis_table_names(context) is not None:
write_kpis_table(env=get_environment(),
context=context,
model=self._model,
solution=self.current_solution)
def notify_solution(self, sol):
pdata = self.current_progress_data
publish_name_fn = self.publish_name_fn
# 1. build a dict from formatted names to kpi values.
name_values = {
publish_name_fn(kp.name): kp.compute(sol)
for kp in self.model.iter_kpis()
}
# 2. add predefined keys for obj, time.
name_values['PROGRESS_CURRENT_OBJECTIVE'] = sol.objective_value
name_values[publish_name_fn('_time')] = pdata.time
# 3. store it (why???)
self._kpi_dicts.append(name_values)
# usually publish kpis in environment...
if self.publish_hook is not None:
self.publish_hook(name_values)
# save kpis.csv table
context = self._context
if auto_publising_kpis_table_names(context) is not None:
write_kpis_table(env=get_environment(),
context=context,
model=self.model,
solution=sol)
def is_in_docplex_worker():
try:
import docplex.util.environment as runenv
is_in_worker = isinstance(runenv.get_environment(), runenv.WorkerEnvironment)
except:
is_in_worker = False
return is_in_worker
def __init__(self, **kwargs):
super(SolverContext, self).__init__(**kwargs)
self.log_output = False
self.max_threads = get_environment().get_available_core_count()
self.auto_publish = create_default_auto_publish_context()
self.kpi_reporting = BaseContext()
from docplex.mp.progress import ProgressClock
self.kpi_reporting.filter_level = ProgressClock.Gap
def get_all_inputs():
result = {}
env = get_environment()
for iname in [f for f in os.listdir('.') if splitext(f)[1] == '.csv']:
df = env.read_df(iname, index_col=None)
datasetname, _ = splitext(iname)
result[datasetname] = df
return result
def run_LP(num_types, names, prices, procs, gbRAM, freestorage,
max_cost_in_previous_time_window, account_limits, min_cores,
min_ram, min_free_storage, max_cost_hour, ram_per_job,
procs_per_job, aws_instances, **kwargs):
avoid_instances = set()
rpj_helper = zip(names, procs)
ppj_helper = zip(names, gbRAM)
a1 = filter(lambda x: x[1] < ram_per_job, rpj_helper)
a2 = filter(lambda x: x[1] < procs_per_job, ppj_helper)
avoidp = a1 + a2
avoid_names = map(lambda x: x[0], avoidp)
serversp = zip(names, max_cost_in_previous_time_window, [0] * num_types,
account_limits)
server_characteristicsp = zip(names, procs, gbRAM, freestorage)
servers = filter(lambda x: x[0] not in avoid_names, serversp)
server_characteristics = filter(lambda x: x[0] not in avoid_names,
server_characteristicsp)
job_parameters = []
job_parameters.append(("min_cores", min_cores, min_cores * 5))
job_parameters.append(("min_ram", min_ram, min_ram * 5))
job_parameters.append(
("min_free_storage", min_free_storage, min_free_storage * 5))
Server = namedtuple("Instance", ["name", "cost", "qmin", "qmax"])
Job_param = namedtuple("Param", ["name", "qmin", "qmax"])
server = [Server(*s) for s in servers]
assert (len(server) > 0)
params = [Job_param(*j) for j in job_parameters]
server_info = {(sc[0], params[j].name): sc[1 + j]
for sc in server_characteristics
for j in range(len(job_parameters))}
mdl = Model(name='Instance Bidding')
qty = {
s: mdl.integer_var(lb=s.qmin, ub=s.qmax, name=s.name)
for s in server
}
for p in params:
amount = mdl.sum(qty[s] * server_info[s.name, p.name] for s in server)
mdl.add_range(p.qmin, amount, p.qmax)
mdl.add_kpi(amount, publish_name="Total %s" % p.name)
mdl.minimize(mdl.sum(qty[s] * s.cost for s in server))
mdl.print_information()
url = None
key = None
if not mdl.solve(url=url, key=key):
print("*** Problem has no solution")
else:
mdl.float_precision = 3
print("* model solved as function:")
mdl.report()
mdl.print_solution()
mdl.report_kpis()
mdl.export_as_lp("cplex.lp")
os.system("cat cplex.lp")
# Save the CPLEX solution as "solution.json" program output
with get_environment().get_output_stream("instances.json") as fp:
mdl.solution.export(fp, "json")
return
def get_environment():
""" Returns the Environment object that represents the actual execution environment.
Returns:
Environment descriptor, None if none.
"""
# Check if environment available
if not ENVIRONMENT_PRESENT:
return None
return runenv.get_environment()
def write_all_outputs(outputs):
'''Write all dataframes in ``outputs`` as .csv.
Args:
outputs: The map of outputs 'outputname' -> 'output df'
'''
for (name, df) in iteritems(outputs):
csv_file = '%s.csv' % name
with get_environment().get_output_stream(csv_file) as fp:
fp.write(df.to_csv(index=False))
def get_all_inputs():
'''Utility method to read a list of files and return a tuple with all
read data frames.
Returns:
a map { datasetname: data frame }
'''
result = {}
env = get_environment()
for iname in [f for f in os.listdir('.') if splitext(f)[1] == '.csv']:
with env.get_input_stream(iname) as in_stream:
df = pandas.read_csv(in_stream)
datasetname, _ = splitext(iname)
result[datasetname] = df
return result
def write_all_outputs(outputs):
'''Write all dataframes in ``outputs`` as .csv.
Args:
outputs: The map of outputs 'outputname' -> 'output df'
'''
global output_lock
with output_lock:
for (name, df) in iteritems(outputs):
csv_file = '%s.csv' % name
with get_environment().get_output_stream(csv_file) as fp:
fp.write(df.to_csv(index=False))
if len(outputs) == 0:
print("Warning: no outputs written")
def get_all_inputs():
'''Utility method to read a list of files and return a tuple with all
read data frames.
Returns:
a map { datasetname: data frame }
'''
result = {}
env = get_environment()
for iname in [f for f in os.listdir('.') if splitext(f)[1] == '.csv']:
df = env.read_df(iname, index_col=None)
datasetname, _ = splitext(iname)
result[datasetname] = df
return result
def set_stop_callback(cb):
env = get_environment()
try:
env.set_stop_callback(cb)
except AttributeError:
# env.set_stop_callback does not exists -> older version of docplex
# use work around
try:
import docplex.worker.solvehook as worker_env
hook = worker_env.get_solve_hook()
if hook:
hook.set_stop_callback(cb)
finally:
# ignore errors
pass
def write_all_outputs(outputs):
'''Write all dataframes in ``outputs`` as .csv.
Args:
outputs: The map of outputs 'outputname' -> 'output df'
'''
for (name, df) in iteritems(outputs):
csv_file = '%s.csv' % name
print(csv_file)
with get_environment().get_output_stream(csv_file) as fp:
if sys.version_info[0] < 3:
fp.write(df.to_csv(index=False, encoding='utf8'))
else:
fp.write(df.to_csv(index=False).encode(encoding='utf8'))
if len(outputs) == 0:
print("Warning: no outputs written")
def notify_solution(self, sol):
env = get_environment()
pdata = self.current_progress_data
context = self._context
# 1. Start with empty table
name_values = {}
# 2. add predefined keys for obj, time.
name_values['PROGRESS_CURRENT_OBJECTIVE'] = sol.objective_value
# 3. store it (why???)
self._kpi_dicts.append(name_values)
# new stats for https://github.ibm.com/IBMDecisionOptimization/dd-planning/issues/2491
if env.is_dods():
name_values['PROGRESS_GAP'] = pdata.mip_gap
name_values['PROGRESS_BEST_OBJECTIVE'] = pdata.best_bound
name_values['STAT.cplex.solve.explored'] = pdata.current_nb_nodes
name_values['STAT.cplex.solve.opened'] = pdata.remaining_nb_nodes
name_values[
'STAT.cplex.solve.iterationCount'] = pdata.current_nb_iterations
name_values['STAT.cplex.solve.elapsedTime'] = pdata.time
# add KPIs
publish_name_fn = self.publish_name_fn
name_values.update({
publish_name_fn(kp.name): kp.compute(sol)
for kp in self.model.iter_kpis()
})
name_values[publish_name_fn('_time')] = pdata.time
# usually publish kpis in environment...
if self.publish_hook is not None:
self.publish_hook(name_values)
# save kpis.csv table
if auto_publishing_kpis_table_names(context) is not None:
write_kpis_table(env=env,
context=context,
model=self.model,
solution=sol)
def main(instances, verbose=False):
env = Environment()
env.print_information()
dir_path = os.path.dirname(os.path.realpath(__file__))
solutions = []
for index, instance in enumerate(instances):
data, h, w, problem_class = instance
data = sorted(data, key=itemgetter(0), reverse=True)
try:
mdl = build_model(data, w, h)
if verbose:
print(mdl.export_to_string())
mdl.print_information()
mdl.export_as_lp(dir_path + "/" + mdl.name + "_" + str(index) +
'.lp')
if mdl.solve(log_output=verbose):
if verbose:
mdl.float_precision = 3
print("* model solved as function:")
mdl.print_solution()
mdl.report_kpis()
# Save the CPLEX solution as "solution.json" program output
with get_environment().get_output_stream(
dir_path + "/" + mdl.name + "_" + str(index) +
"_solution.json") as fp:
mdl.solution.export(fp, "json")
else:
print("* model has no solution")
except Exception as e:
# Problem with more than 1000 variables
print(e)
Alternatively, Context.make_default_context() searches the PYTHONPATH for
the following files:
* cplex_config.py
* cplex_config_<hostname>.py
* docloud_config.py (must only contain context.solver.docloud configuration)
These files contain the credentials and other properties. For example,
something similar to::
context.solver.docloud.url = "https://docloud.service.com/job_manager/rest/v1"
context.solver.docloud.key = "example api_key"
"""
url = None
key = None
mdl = build_diet_model()
# Solve the model. If a key has been specified above, the solve
# will use IBM Decision Optimization on cloud.
if not mdl.solve(url=url, key=key):
print("*** Problem has no solution")
else:
mdl.float_precision = 3
print("* model solved as function:")
mdl.print_solution()
mdl.report_kpis()
# Save the CPLEX solution as "solution.json" program output
with get_environment().get_output_stream("solution.json") as fp:
mdl.solution.export(fp, "json")
def set_stop_callback(cb):
env = get_environment()
env.abort_callbacks += [cb]
# 3rd constraint: there is a fixed number of coffee shops to open.
# Total nb of open coffee shops
mdl.add_constraint(
mdl.sum(ambulance_vars[c_loc]
for c_loc in ambulance_locations) == nb_ambulances)
# #### Express the objective
# The objective is to minimize the total distance from libraries to coffee shops so that a book reader always gets to our coffee shop easily.
# Minimize total distance from points to hubs
total_distance = mdl.sum(
(1 / locations_prob[b])**2 * link_vars[c_loc, b] * get_distance(c_loc, b)
for c_loc in ambulance_locations for b in locations)
mdl.minimize(total_distance)
mdl.print_information()
assert mdl.solve(), "!!! Solve of the model fails"
# ### Step 6: Investigate the solution and then run an example analysis
# The solution can be analyzed by displaying the location of the coffee shops on a map.
total_distance = mdl.objective_value
open_ambulances = [
c_loc for c_loc in ambulance_locations
if ambulance_vars[c_loc].solution_value == 1
]
from docplex.util.environment import get_environment
env = get_environment()
with env.get_output_stream("ambulances.csv") as f:
pd.DataFrame(open_ambulances).to_csv(f, index=False, quotechar='"')
context.solver.add_log_to_solution = False
Detailed description
--------------------
"""
from docplex.cp.utils import *
from docplex.cp.parameters import CpoParameters, ALL_PARAMETER_NAMES
import sys, socket, os, traceback
# Check if running in a worker environment
try:
import docplex.util.environment as runenv
IS_IN_WORKER = isinstance(runenv.get_environment(),
runenv.WorkerEnvironment)
except:
IS_IN_WORKER = False
# CP Optimizer Interactive executable name
CPO_EXEC_INTERACTIVE = "cpoptimizer" + (".exe" if IS_WINDOWS else "")
# CP Optimizer Interactive executable name
CPO_LIBRARY = "lib_cpo_solver_12100" + (".dll" if IS_WINDOWS else ".so")
# Determine path extension to search executables
python_home = os.path.dirname(os.path.abspath(sys.executable))
if IS_WINDOWS:
PATH_EXTENSION = [os.path.join(python_home, "Scripts")]
appdata = os.environ.get('APPDATA')
def get_line_of_model(n):
env = get_environment()
with env.get_input_stream('model.py') as m:
lines = m.readlines()
return lines[n - 1].decode("utf-8")
df_sol_starts['resources'] = df_sol_starts.index.get_level_values(
'resources')
df_sol_starts['periods'] = df_sol_starts.index.get_level_values('periods')
df_sol_starts.columns = ['value', 'resources', 'periods']
df_sol_starts = df_sol_starts.reset_index(drop=True)
df_sol_works = df_decision_vars.work.apply(
lambda v: v.solution_value).unstack(level='resources')
df_sol_works = df_sol_works.stack(level='resources').to_frame()
df_sol_works['resources'] = df_sol_works.index.get_level_values(
'resources')
df_sol_works['periods'] = df_sol_works.index.get_level_values('periods')
df_sol_works.columns = ['value', 'resources', 'periods']
df_sol_works = df_sol_works.reset_index(drop=True)
df_sol_nr = df_decision_vars_res.nr.apply(
lambda v: v.solution_value).to_frame()
df_sol_nr['resources'] = df_sol_nr.index
df_sol_nr = df_sol_nr.reset_index(drop=True)
outputs = {}
outputs['starts'] = df_sol_starts
outputs['works'] = df_sol_works
outputs['nr'] = df_sol_nr
else:
print " Infeasible"
outputs = {}
from docplex.util.environment import get_environment
get_environment().store_solution(outputs)
def run_NG_RAN_model_fase_3(FO_fase_1, FO_fase_2):
"""
This method uses the topology main structure to calculate the optimal solution of the fase 3
:rtype: This method returns the optimal value of the fase 3
"""
print("Running Fase - 3")
print("-----------------------------------------------------------------------------------------------------------")
alocation_time_start = time.time()
# read the topology data at the json file
read_topology_500()
# read_topology()
# dsgs = dsg_structure()
dsgs = dsg_structure_500()
rus = ru_location_500()
# rus = ru_location()
# # print the RU's location
# for ru in rus:
# print(rus[ru])
# create the set of O's (functional splits)
# O's(id, O_cpu, O_ram)
O1 = Os(1, 2, 2)
O2 = Os(2, 2, 2)
O3 = Os(3, 2, 2)
O4 = Os(4, 2, 2)
O5 = Os(5, 2, 2)
O6 = Os(6, 2, 2)
O7 = Os(7, 2, 2)
O8 = Os(8, 2, 2)
# set of O's
conj_Os = {1: O1, 2: O2, 3: O3, 4: O4, 5: O5, 6: O6}
#set of DSG priority
dsg_p = {1: 4, 2: 1, 4: 6, 5: 5, 6: 10, 7: 9, 8: 25, 9: 7, 10: 8}
# create the fase 1 model
mdl = Model(name='NGRAN Problem3', log_output=True)
# tuple that will be used by the decision variable
i = [(p, d, b) for p in paths for d in dsgs for b in rus if paths[p].seq[2] == rus[b].RC]
# Decision variable X
mdl.x = mdl.binary_var_dict(i, name='x')
#Fase 3 Objective Function
mdl.minimize(mdl.sum(mdl.sum(mdl.x[it] * dsg_p[it[1]] for it in i if it[1] == dsg) for dsg in dsgs))
# Constraint fase 2
mdl.add_constraint(mdl.sum(mdl.min(1, mdl.sum(mdl.x[it] for it in i if it[1] == dsg)) for dsg in dsgs) == FO_fase_2)
# Constraint fase 1
mdl.add_constraint(mdl.sum(mdl.min(1, mdl.sum(mdl.x[it] for it in i if c in paths[it[0]].seq)) for c in rcs if rcs[c].id != 0) - mdl.sum(mdl.sum(mdl.max(0, (mdl.sum(mdl.x[it] for it in i if ((o in dsgs[it[1]].Os_CU and paths[it[0]].seq[0] == rcs[c].id) or (o in dsgs[it[1]].Os_DU and paths[it[0]].seq[1] == rcs[c].id) or (o in dsgs[it[1]].Os_RU and paths[it[0]].seq[2] == rcs[c].id))) - 1)) for o in conj_Os) for c in rcs) == FO_fase_1)
# Constraint 1 (4)
for b in rus:
mdl.add_constraint(mdl.sum(mdl.x[it] for it in i if it[2] == b) == 1, 'unicity')
# Constrains 1.1 (N)
mdl.add_constraint(mdl.sum(mdl.x[it] for it in i if paths[it[0]].target != rus[it[2]].RC) == 0, 'path')
# constraint 1.2 (N) quebras de 2 so pode escolher caminhos de 2 quebras
mdl.add_constraint(mdl.sum(mdl.x[it] for it in i if paths[it[0]].seq[0] != 0 and (
it[1] == 6 or it[1] == 7 or it[1] == 8 or it[1] == 9 or it[1] == 10)) == 0, 'dsgs_path_pick')
# constraint 1.3 (N) quebras de 3 so pode escolher caminhos de 3 quebras
mdl.add_constraint(mdl.sum(mdl.x[it] for it in i if
paths[it[0]].seq[0] == 0 and it[1] != 6 and it[1] != 7 and it[1] != 8 and it[1] != 9 and
it[1] != 10) == 0, 'dsgs_path_pick2')
# contraint 1.4 (N) quebras de 1 so pode escolher caminhos de 1 quebras
mdl.add_constraint(
mdl.sum(mdl.x[it] for it in i if paths[it[0]].seq[0] == 0 and paths[it[0]].seq[1] == 0 and it[1] != 8) == 0,
'dsgs_path_pick3')
# contraint 1.5 (N) caminhos de 2 RC's nao podem usar D-RAN
mdl.add_constraint(
mdl.sum(mdl.x[it] for it in i if paths[it[0]].seq[0] == 0 and paths[it[0]].seq[1] != 0 and it[1] == 8) == 0,
'dsgs_path_pick4')
# #constraint 1.6 (N) caminhos devem ir para o RC que esta posicionado o RU
for ru in rus:
mdl.add_constraint(
mdl.sum(mdl.x[it] for it in i if paths[it[0]].seq[2] != rus[ru].RC and it[2] == rus[ru].id) == 0)
# Constraint 2 (5)
for l in links:
for k in links:
if l[0] == k[1] and l[1] == k[0]:
break
mdl.add_constraint(mdl.sum(mdl.x[it] * dsgs[it[1]].bw_BH for it in i if l in paths[it[0]].p1) + mdl.sum(
mdl.x[it] * dsgs[it[1]].bw_MH for it in i if l in paths[it[0]].p2) + mdl.sum(
mdl.x[it] * dsgs[it[1]].bw_FH for it in i if l in paths[it[0]].p3) +
mdl.sum(mdl.x[it] * dsgs[it[1]].bw_BH for it in i if k in paths[it[0]].p1) + mdl.sum(
mdl.x[it] * dsgs[it[1]].bw_MH for it in i if k in paths[it[0]].p2) + mdl.sum(
mdl.x[it] * dsgs[it[1]].bw_FH for it in i if k in paths[it[0]].p3)
<= capacity[l], 'links_bw')
# Constraint 3 (6)
for it in i:
mdl.add_constraint((mdl.x[it] * paths[it[0]].delay_p1) <= dsgs[it[1]].delay_BH, 'delay_req_p1')
# Constraint 4 (7)
for it in i:
mdl.add_constraint((mdl.x[it] * paths[it[0]].delay_p2) <= dsgs[it[1]].delay_MH, 'delay_req_p2')
# Constraint 5 (8)
for it in i:
mdl.add_constraint((mdl.x[it] * paths[it[0]].delay_p3 <= dsgs[it[1]].delay_FH), 'delay_req_p3')
# Constraint 6 (9)
for c in rcs:
mdl.add_constraint(
mdl.sum(mdl.x[it] * dsgs[it[1]].cpu_CU for it in i if c == paths[it[0]].seq[0]) + mdl.sum(
mdl.x[it] * dsgs[it[1]].cpu_DU for it in i if c == paths[it[0]].seq[1]) + mdl.sum(
mdl.x[it] * dsgs[it[1]].cpu_RU for it in i if c == paths[it[0]].seq[2]) <= rcs[c].cpu,
'rcs_cpu_usage')
# Constraint 7 (9) RAM
# for c in rcs:
# mdl.add_constraint(
# mdl.sum(mdl.x[it] * dsgs[it[1]].ram_CU for it in i if c == paths[it[0]].seq[0]) + mdl.sum(
# mdl.x[it] * dsgs[it[1]].ram_DU for it in i if c == paths[it[0]].seq[1]) + mdl.sum(
# mdl.x[it] * dsgs[it[1]].ram_RU for it in i if c == paths[it[0]].seq[2]) <= rcs[c].ram,
# 'rcs_ram_usage')
alocation_time_end = time.time()
start_time = time.time()
warm_start = mdl.new_solution()
for it in f2_vars:
warm_start.add_var_value(mdl.x[it], 1)
#warm_start.set_objective_value(3)
print(warm_start)
mdl.add_mip_start(warm_start)
mdl.solve()
end_time = time.time()
print("Stage 3 - Alocation Time: {}".format(alocation_time_end - alocation_time_start))
print("Stage 3 - Enlapsed Time: {}".format(end_time - start_time))
for it in i:
if mdl.x[it].solution_value == 1:
print("x{} -> {}".format(it, mdl.x[it].solution_value))
print(paths[it[0]].seq)
with get_environment().get_output_stream("solution.json") as fp:
mdl.solution.export(fp, "json")
disp_Os = {}
for rc in rcs:
disp_Os[rc] = {"O1": 0, "O2": 0, "O3": 0, "O4": 0, "O5": 0, "O6": 0, "O7": 0, "O8": 0}
for it in i:
for rc in rcs:
if mdl.x[it].solution_value == 1:
if rc in paths[it[0]].seq:
seq = paths[it[0]].seq
if rc == seq[0]:
os = dsgs[it[1]].Os_CU
for o in os:
if o != 0:
dct = disp_Os[rc]
dct["O{}".format(o)] += 1
disp_Os[rc] = dct
if rc == seq[1]:
os = dsgs[it[1]].Os_DU
for o in os:
if o != 0:
dct = disp_Os[rc]
dct["O{}".format(o)] += 1
disp_Os[rc] = dct
if rc == seq[2]:
os = dsgs[it[1]].Os_RU
for o in os:
if o != 0:
dct = disp_Os[rc]
dct["O{}".format(o)] += 1
disp_Os[rc] = dct
print("FO: {}".format(mdl.solution.get_objective_value()))
for rc in disp_Os:
print(str(rc) + str(disp_Os[rc]))
if __name__ == '__main__':
"""DOcplexcloud credentials can be specified with url and api_key in the code block below.
Alternatively, Context.make_default_context() searches the PYTHONPATH for
the following files:
* cplex_config.py
* cplex_config_<hostname>.py
* docloud_config.py (must only contain context.solver.docloud configuration)
These files contain the credentials and other properties. For example,
something similar to::
context.solver.docloud.url = "https://docloud.service.com/job_manager/rest/v1"
context.solver.docloud.key = "example api_key"
"""
url = None
key = None
cutstock_model = DefaultCutStockMasterModel()
# Solve the model. If a key has been specified above, the solve
# will use IBM Decision Optimization on cloud.
if cutstock_model.run(url=url, key=key):
cutstock_model.print_solution()
# Save the solution as "solution.json" program output.
with get_environment().get_output_stream("solution.json") as fp:
cutstock_model.save_solution_as_json(fp)
