def solve_model(mdl):
mdl.parameters.timelimit = 120
# Call to custom code to update parameters value
custom_code.update_solver_params(mdl.parameters)
# Update parameters value based on environment variables definition
cplex_param_env_prefix = 'ma.cplex.'
cplex_params = [name.qualified_name for name in mdl.parameters.generate_params()]
for param in cplex_params:
env_param = cplex_param_env_prefix + param
param_value = get_environment().get_parameter(env_param)
if param_value:
# Updating parameter value
print("Updated value for parameter %s = %s" % (param, param_value))
parameters = mdl.parameters
for p in param.split('.')[1:]:
parameters = parameters.__getattribute__(p)
parameters.set(param_value)
msol = mdl.solve(log_output=True)
if not msol:
print("!!! Solve of the model fails")
if mdl.get_solve_status() == JobSolveStatus.INFEASIBLE_SOLUTION or mdl.get_solve_status() == JobSolveStatus.INFEASIBLE_OR_UNBOUNDED_SOLUTION:
crefiner = ConflictRefiner()
conflicts = crefiner.refine_conflict(model, log_output=True)
export_conflicts(conflicts)
print 'Solve status: ', mdl.get_solve_status()
mdl.report()
return msol
def solve_model(mdl):
mdl.parameters.timelimit = 120
msol = mdl.solve(log_output=True)
if not msol:
print("!!! Solve of the model fails")
if mdl.get_solve_status() == JobSolveStatus.INFEASIBLE_SOLUTION:
crefiner = ConflictRefiner()
conflicts = crefiner.refine_conflict(model, log_output=True)
export_conflicts(conflicts)
print 'Solve status: ', mdl.get_solve_status()
mdl.report()
return msol
def solve(self, refine_conflict: bool = False, **kwargs) -> docplex.mp.solution.SolveSolution:
msol = self.mdl.solve(**kwargs) # log_output=True
if msol is not None:
print('Found a solution')
self.mdl.report()
self.mdl.print_solution()
else:
print('No solution')
if refine_conflict:
print('Conflict Refiner:')
crefiner = ConflictRefiner() # Create an instance of the ConflictRefiner
conflicts = crefiner.refine_conflict(self.mdl) # Run the conflict refiner
# ConflictRefiner.display_conflicts(conflicts) #Display the results
for c in conflicts:
print(
c.element) # Display conflict result in a little more compact format than ConflictRefiner.display_conflicts
return msol
rx = Relaxer()
rx.relax(mdl)
print("number_of_relaxations= " + str(rx.number_of_relaxations))
rx.print_information()
mdl.report()
print(f"* status after relaxation is: {mdl.solve_details.status}")
#print(mdl.solution)
print()
print("------ starting conflict refiner")
print()
cr = ConflictRefiner()
conflicts = cr.refine_conflict(mdl)
conflicts.display()
# for conflict in conflicts:
# st = conflict.status
# ct = conflict.element
# label = conflict.name
# label_type = type(conflict.element)
# if isinstance(conflict.element, VarLbConstraintWrapper) \
# or isinstance(conflict.element, VarUbConstraintWrapper):
# ct = conflict.element.get_constraint()
#
# # Print conflict information in console
# print("Conflict involving constraint: %s" % label)
# print(" \tfor: %s" % ct)
def run(self):
objective = self.model.sum(self.PriceProv[j]
for j in range(self.nr_vms))
self.model.minimize(objective)
# self.model.prettyprint("out")
self.model.export_as_lp(self.cplexLPPath)
# self.model.export_as_mps("nou")
vmPrice = []
vmType = []
a_mat = []
self.get_current_time()
starttime = time.time()
xx = self.model.solve()
stoptime = time.time()
print("CPLEX: ", self.model.get_solve_status(),
self.model.get_statistics)
if dc.status.JobSolveStatus.OPTIMAL_SOLUTION == self.model.get_solve_status(
):
print(self.model.solve_details)
print("CPLEX vmType")
# Variables for offers description
vmType = self._get_solution_vm_type()
print("\nvmPrice")
for index, var in self.PriceProv.items():
print(var.solution_value, end=" ")
vmPrice.append(var.solution_value)
print("\nVm Aquired")
for index, var in self.vm.items():
print(var.solution_value, end=" ")
print()
l = []
col = 0
for index, var in self.a.items():
if col == self.problem.nrVM:
a_mat.append(l)
l = []
col = 0
col += 1
l.append(int(var.solution_value))
a_mat.append(l)
print("\nAllocation matrix M x N", self.nrVM, self.nrComp)
for l in a_mat:
print(l)
print(xx.get_objective_value())
else:
print("Unsolve CPLEX")
print(self.model.get_time_limit())
cr = ConflictRefiner()
conflicts = cr.refine_conflict(self.model)
print(self.model.get_solve_status())
for conflict in conflicts:
st = conflict.status
ct = conflict.element
label = conflict.name
label_type = type(conflict.element)
if isinstance(conflict.element, VarLbConstraintWrapper)\
or isinstance(conflict.element, VarUbConstraintWrapper):
ct = conflict.element.get_constraint()
# Print conflict information in console
print("Conflict involving constraint: %s" % label)
print(" \tfor: %s" % ct)
return xx.get_objective_value(
) / 1000, vmPrice, stoptime - starttime, a_mat, vmType
def solve(self):
if self.uc.solve():
def prepare_output_df(sol_var_val_df):
output_df = sol_var_val_df.copy().to_frame()
output_df['unit'] = output_df.index.get_level_values('unit')
output_df['period'] = output_df.index.get_level_values(
'period')
output_df.columns = ['value', 'unit', 'period']
output_df = output_df.reset_index(drop=True)
output_df['period'] = output_df['period'].apply(
lambda p: "{:03}".format(p))
output_df = output_df[['period', 'unit', 'value']]
return output_df
df_thrm_prod = prepare_output_df(
self.df_thrm_vars.p.apply(lambda z: z.solution_value))
df_rnwb_prod = prepare_output_df(
self.df_rnwb_vars.p_rnwb.apply(lambda z: z.solution_value))
df_thrm_in_use = prepare_output_df(
self.df_thrm_vars.in_use.apply(lambda z: z.solution_value))
df_thrm_started = prepare_output_df(
self.df_thrm_vars.on.apply(lambda z: z.solution_value))
df_thrm_stopped = prepare_output_df(
self.df_thrm_vars.off.apply(lambda z: z.solution_value))
df_plan = self.__prepare_plan_df(df_thrm_in_use, df_thrm_started,
df_thrm_stopped)
all_kpis = [(kp.name, kp.compute()) for kp in self.uc.iter_kpis()]
kpis_bd = pd.DataFrame(all_kpis, columns=['kpi', 'value'])
kpis_bd = kpis_bd.append(
{
'kpi': 'cplex time',
'value': "{:.3f}".format(self.uc.get_solve_details().time)
},
ignore_index=True)
kpis_cost = kpis_bd.loc[kpis_bd['kpi'].str.contains("Cost")]
kpis_cost['value'] = kpis_cost.apply(lambda x: round(x.value, 0),
axis=1)
kpis_plan = kpis_bd.loc[~kpis_bd['kpi'].str.contains("Cost")]
df_q_r_tot, df_q_r_dif = self.__prepare_reserve_kpi_df(kpis_bd)
kpis_bd = kpis_bd.loc[~kpis_bd['kpi'].str.contains("_TOT_")]
df_P_agg = self.__prepare_production_kpi_df(
df_thrm_prod, df_rnwb_prod)
self._sc_outputs['thermal_prod'] = df_thrm_prod
self._sc_outputs['renewable_prod'] = df_rnwb_prod
self._sc_outputs['thermal_in_use'] = df_thrm_in_use
self._sc_outputs['thermal_started'] = df_thrm_started
self._sc_outputs['thermal_stopped'] = df_thrm_stopped
self._sc_outputs['plan'] = df_plan
self._sc_outputs['cost_kpis_high'] = kpis_cost.loc[(
kpis_cost['kpi'].str.contains("Economic")
| kpis_cost['kpi'].str.contains("Variable"))]
self._sc_outputs['cost_kpis_low'] = kpis_cost.loc[(
~kpis_cost['kpi'].str.contains("Economic")
& ~kpis_cost['kpi'].str.contains("Variable"))]
self._sc_outputs['plan_kpis'] = kpis_plan
self._sc_outputs['all_kpis'] = kpis_bd
self._sc_outputs['p_r_tot'] = df_q_r_tot
self._sc_outputs['p_r_dif'] = df_q_r_dif
self._sc_outputs['production'] = df_P_agg
self._sc_outputs['production_rnwb'] = df_rnwb_prod
else:
all_kpis = [("Feasibility", 0)]
kpis_bd = pd.DataFrame(all_kpis, columns=['kpi', 'value'])
self._sc_outputs['kpis'] = kpis_bd
from docplex.mp.conflict_refiner import ConflictRefiner
infeas_cons = ConflictRefiner().refine_conflict(self.uc)
print(infeas_cons)