def init_model(self, **args):
no_ressource = len(self.rcpsp_model.resources_list) == 0
# no_ressource = False
model_type = ("multi-calendar"
if not no_ressource else "multi-calendar-no-ressource")
# model_type = "multi-calendar"
model = Model(files_mzn[model_type])
custom_output_type = args.get("output_type", False)
exact_skills_need = args.get("exact_skills_need", True)
if custom_output_type:
model.output_type = MS_RCPSPSolCP
self.custom_output_type = True
solver = Solver.lookup(map_cp_solver_name[self.cp_solver_name])
resources_list = sorted(
list(self.rcpsp_model.resources_availability.keys()))
self.resources_index = resources_list
instance = Instance(solver, model)
n_res = len(resources_list)
keys = []
if not no_ressource:
instance["n_res"] = n_res
keys += ["n_res"]
if model_type == "multi-calendar":
instance["exact_skills_need"] = exact_skills_need
keys += ["exact_skills_need"]
instance["add_calendar_constraint_unit"] = args.get(
"add_calendar_constraint_unit", False)
keys += ["add_calendar_constraint_unit"]
instance["exact_skills_need"] = exact_skills_need
instance["one_ressource_per_task"] = self.one_ressource_per_task
keys += ["one_ressource_per_task"]
n_tasks = self.rcpsp_model.n_jobs_non_dummy + 2
instance["n_tasks"] = n_tasks
keys += ["n_tasks"]
sorted_tasks = sorted(self.rcpsp_model.mode_details.keys())
n_opt = sum([
len(list(self.rcpsp_model.mode_details[key].keys()))
for key in sorted_tasks
])
instance["n_opt"] = n_opt
keys += ["n_opt"]
modes = []
dur = []
counter = 0
self.modeindex_map = {}
for act in sorted_tasks:
tmp = list(sorted(self.rcpsp_model.mode_details[act].keys()))
# tmp = [counter + x for x in tmp]
for i in range(len(tmp)):
original_mode_index = tmp[i]
mod_index = counter + tmp[i]
tmp[i] = mod_index
self.modeindex_map[mod_index] = {
"task": act,
"original_mode_index": original_mode_index,
}
modes.append(set(tmp))
counter = tmp[-1]
dur = dur + [
self.rcpsp_model.mode_details[act][key]["duration"]
for key in sorted(self.rcpsp_model.mode_details[act].keys())
]
instance["modes"] = modes
keys += ["modes"]
instance["dur"] = dur
keys += ["dur"]
if not no_ressource:
rreq = []
index = 0
for res in resources_list:
rreq.append([])
for task in sorted_tasks:
for mod in sorted(
self.rcpsp_model.mode_details[task].keys()):
rreq[index].append(
int(self.rcpsp_model.mode_details[task][mod][res]))
index += 1
skills_set = sorted(list(self.rcpsp_model.skills_set))
nb_units = len(self.rcpsp_model.employees)
skill_required = []
index = 0
for skill in skills_set:
skill_required.append([])
for task in sorted_tasks:
for mod in sorted(self.rcpsp_model.mode_details[task].keys()):
skill_required[index].append(
int(self.rcpsp_model.mode_details[task][mod].get(
skill, 0)))
index += 1
if True:
if no_ressource:
instance["max_time"] = self.rcpsp_model.horizon
keys += ["max_time"]
else:
one_ressource = list(
self.rcpsp_model.resources_availability.keys())[0]
instance["max_time"] = min(
len(self.rcpsp_model.resources_availability[one_ressource])
- 1,
self.rcpsp_model.horizon,
)
# instance["max_time"] = 2842
keys += ["max_time"]
ressource_capacity_time = [[
int(x)
for x in self.rcpsp_model.resources_availability[res][:(
instance["max_time"] + 1)]
] for res in resources_list]
instance["ressource_capacity_time"] = ressource_capacity_time
keys += ["ressource_capacity_time"]
instance["nb_skill"] = len(self.rcpsp_model.skills_set)
instance["skillreq"] = skill_required
instance["nb_units"] = nb_units
keys += ["nb_skill", "skillreq", "nb_units"]
ressource_unit_capacity_time = [[
1 if x else 0
for x in self.rcpsp_model.employees[j].calendar_employee[:(
instance["max_time"] + 1)]
] for j in sorted(self.rcpsp_model.employees)]
import math
skillunits = [[
int(
math.floor(
self.rcpsp_model.employees[j].dict_skill[s].skill_value))
if s in self.rcpsp_model.employees[j].dict_skill else 0
for s in skills_set
] for j in sorted(self.rcpsp_model.employees)]
self.employees_position = sorted(self.rcpsp_model.employees)
instance["ressource_unit_capacity_time"] = ressource_unit_capacity_time
instance["skillunits"] = skillunits
keys += ["skillunits", "ressource_unit_capacity_time"]
# print('rreq: ', rreq)
if not no_ressource:
instance["rreq"] = rreq
keys += ["rreq"]
rcap = [
int(max(self.rcpsp_model.resources_availability[x]))
for x in resources_list
]
instance["rcap"] = rcap
keys += ["rcap"]
rtype = [
2 if res in self.rcpsp_model.non_renewable_resources else 1
for res in resources_list
]
instance["rtype"] = rtype
keys += ["rtype"]
succ = [
set(self.rcpsp_model.successors[task]) for task in sorted_tasks
]
instance["succ"] = succ
keys += ["succ"]
self.instance = instance
p_s: Union[PartialSolution, None] = args.get("partial_solution", None)
if p_s is not None:
constraint_strings = []
if p_s.start_times is not None:
for task in p_s.start_times:
string = ("constraint start[" + str(task) + "] == " +
str(p_s.start_times[task]) + ";\n")
self.instance.add_string(string)
constraint_strings += [string]
if p_s.partial_permutation is not None:
for t1, t2 in zip(p_s.partial_permutation[:-1],
p_s.partial_permutation[1:]):
string = ("constraint start[" + str(t1) + "] <= start[" +
str(t2) + "];\n")
self.instance.add_string(string)
constraint_strings += [string]
if p_s.list_partial_order is not None:
for l in p_s.list_partial_order:
for t1, t2 in zip(l[:-1], l[1:]):
string = ("constraint start[" + str(t1) +
"] <= start[" + str(t2) + "];\n")
self.instance.add_string(string)
constraint_strings += [string]
if p_s.task_mode is not None:
for task in p_s.start_times:
indexes = [
i for i in self.modeindex_map
if self.modeindex_map[i]["task"] == task
and self.modeindex_map[i]["original_mode_index"] ==
p_s.task_mode[task]
]
if len(indexes) >= 0:
string = "constraint mrun[" + str(
indexes[0]) + "] == 1;"
self.instance.add_string(string)
constraint_strings += [string]
if p_s.start_together is not None:
for t1, t2 in p_s.start_together:
string = ("constraint start[" + str(t1) + "] == start[" +
str(t2) + "];\n")
self.instance.add_string(string)
constraint_strings += [string]
if p_s.start_after_nunit is not None:
for t1, t2, delta in p_s.start_after_nunit:
string = ("constraint start[" + str(t2) + "] >= start[" +
str(t1) + "]+" + str(delta) + ";\n")
self.instance.add_string(string)
constraint_strings += [string]
if p_s.start_at_end_plus_offset is not None:
for t1, t2, delta in p_s.start_at_end_plus_offset:
string = ("constraint start[" + str(t2) + "] >= start[" +
str(t1) + "]+adur[" + str(t1) + "]+" +
str(delta) + ";\n")
self.instance.add_string(string)
constraint_strings += [string]
if p_s.start_at_end is not None:
for t1, t2 in p_s.start_at_end:
string = ("constraint start[" + str(t2) + "] == start[" +
str(t1) + "]+adur[" + str(t1) + "];\n")
self.instance.add_string(string)
constraint_strings += [string]
def setUp(self):
self.solver = Solver.lookup("gecode")
self.instance = Instance(self.solver)
self.instance.add_string(self.code)
def init_model(self, **args):
model = Model(files_mzn["modes"])
solver = Solver.lookup(map_cp_solver_name[self.cp_solver_name])
instance = Instance(solver, model)
n_res = len(list(self.rcpsp_model.resources.keys()))
# print('n_res: ', n_res)
instance["n_res"] = n_res
# rc = [val for val in self.rcpsp_model.resources.values()]
# # print('rc: ', rc)
# instance["rc"] = rc
n_tasks = self.rcpsp_model.n_jobs + 2
# print('n_tasks: ', n_tasks)
instance["n_tasks"] = n_tasks
sorted_tasks = sorted(self.rcpsp_model.mode_details.keys())
# print('mode_details: ', self.rcpsp_model.mode_details)
n_opt = sum([
len(list(self.rcpsp_model.mode_details[key].keys()))
for key in sorted_tasks
])
# print('n_opt: ', n_opt)
instance["n_opt"] = n_opt
modes = []
counter = 0
self.modeindex_map = {}
for act in sorted_tasks:
tmp = list(self.rcpsp_model.mode_details[act].keys())
# tmp = [counter + x for x in tmp]
for i in range(len(tmp)):
original_mode_index = tmp[i]
mod_index = counter + tmp[i]
tmp[i] = mod_index
self.modeindex_map[mod_index] = {
'task': act,
'original_mode_index': original_mode_index
}
modes.append(set(tmp))
counter = tmp[-1]
# print('modes: ', modes)
instance['modes'] = modes
rreq = []
index = 0
for res in self.rcpsp_model.resources.keys():
rreq.append([])
for task in sorted_tasks:
for mod in self.rcpsp_model.mode_details[task].keys():
rreq[index].append(
int(self.rcpsp_model.mode_details[task][mod][res]))
index += 1
# print('rreq: ', rreq)
instance["rreq"] = rreq
rcap = [val for val in self.rcpsp_model.resources.values()]
# print('rcap: ', rcap)
if isinstance(rcap[0], list):
rcap = [int(max(r)) for r in rcap]
instance["rcap"] = rcap
# print('non_renewable_resources:', self.rcpsp_model.non_renewable_resources)
rtype = [
2 if res in self.rcpsp_model.non_renewable_resources else 1
for res in self.rcpsp_model.resources.keys()
]
# print('rtype: ', rtype)
instance["rtype"] = rtype
self.instance: Instance = instance
p_s: Union[PartialSolution, None] = args.get("partial_solution", None)
if p_s is not None:
constraint_strings = []
if p_s.task_mode is not None:
for task in p_s.start_times:
indexes = [
i for i in self.modeindex_map
if self.modeindex_map[i]["task"] == task
and self.modeindex_map[i]["original_mode_index"] ==
p_s.task_mode[task]
]
if len(indexes) >= 0:
print("Index found : ", len(indexes))
string = "constraint mrun[" + str(
indexes[0]) + "] == 1;"
self.instance.add_string(string)
constraint_strings += [string]
from minizinc import Instance, Model, Result, Solver, Status
gecode = Solver.lookup("gecode")
m = Model("mwe_pydata.mzn")
m["test_param"] = 3
# this did not work
#m["test_vals"] = [1, 4, 4]
#m["test_len"] = 3;
# this did not work either
m.add_file("mwe_pydata.dzn")
inst = Instance(gecode, m)
result = inst.solve()
print(result["x"])
def init_model(self, **args):
model = Model(files_mzn["multi-no-bool"])
model.output_type = MRCPSP_Result
solver = Solver.lookup(map_cp_solver_name[self.cp_solver_name])
resources_list = list(self.rcpsp_model.resources.keys())
instance = Instance(solver, model)
n_res = len(resources_list)
# print('n_res: ', n_res)
keys = []
instance["n_res"] = n_res
keys += ["n_res"]
# rc = [val for val in self.rcpsp_model.resources.values()]
# # print('rc: ', rc)
# instance["rc"] = rc
n_tasks = self.rcpsp_model.n_jobs + 2
# print('n_tasks: ', n_tasks)
instance["n_tasks"] = n_tasks
keys += ["n_tasks"]
sorted_tasks = sorted(self.rcpsp_model.mode_details.keys())
# print('mode_details: ', self.rcpsp_model.mode_details)
n_opt = sum([
len(list(self.rcpsp_model.mode_details[key].keys()))
for key in sorted_tasks
])
# print('n_opt: ', n_opt)
instance["n_opt"] = n_opt
keys += ["n_opt"]
modes = []
dur = []
counter = 0
self.modeindex_map = {}
general_counter = 1
for act in sorted_tasks:
tmp = sorted(self.rcpsp_model.mode_details[act].keys())
# tmp = [counter + x for x in tmp]
set_mode_task = set()
for i in range(len(tmp)):
original_mode_index = tmp[i]
set_mode_task.add(general_counter)
self.modeindex_map[general_counter] = {
'task': act,
'original_mode_index': original_mode_index
}
general_counter += 1
modes.append(set_mode_task)
dur = dur + [
self.rcpsp_model.mode_details[act][key]['duration']
for key in tmp
]
# print('modes: ', modes)
instance['modes'] = modes
keys += ["modes"]
# print('dur: ', dur)
instance['dur'] = dur
keys += ["dur"]
rreq = []
index = 0
for res in resources_list:
rreq.append([])
for task in sorted_tasks:
for mod in sorted(self.rcpsp_model.mode_details[task].keys()):
rreq[index].append(
int(self.rcpsp_model.mode_details[task][mod][res]))
index += 1
# print('rreq: ', rreq)
instance["rreq"] = rreq
keys += ["rreq"]
if not self.calendar:
rcap = [self.rcpsp_model.resources[x] for x in resources_list]
else:
rcap = [
int(max(self.rcpsp_model.resources[x])) for x in resources_list
]
# print('rcap: ', rcap)
instance["rcap"] = rcap
keys += ["rcap"]
# print('non_renewable_resources:', self.rcpsp_model.non_renewable_resources)
rtype = [
2 if res in self.rcpsp_model.non_renewable_resources else 1
for res in resources_list
]
# print('rtype: ', rtype)
instance["rtype"] = rtype
keys += ["rtype"]
succ = [
set(self.rcpsp_model.successors[task]) for task in sorted_tasks
]
# print('succ: ', succ)
instance["succ"] = succ
keys += ["succ"]
if self.calendar:
one_ressource = list(self.rcpsp_model.resources.keys())[0]
instance["max_time"] = len(
self.rcpsp_model.resources[one_ressource])
print(instance["max_time"])
keys += ["max_time"]
ressource_capacity_time = [[
int(x) for x in self.rcpsp_model.resources[res]
] for res in resources_list]
# print(instance["max_time"])
# print(len(ressource_capacity_time))
# print([len(x) for x in ressource_capacity_time])
instance["ressource_capacity_time"] = ressource_capacity_time
keys += ["ressource_capacity_time"]
# import pymzn
# pymzn.dict2dzn({key: instance[key] for key in keys},
# fout='rcpsp_.dzn')
self.instance = instance
p_s: Union[PartialSolution, None] = args.get("partial_solution", None)
if p_s is not None:
constraint_strings = []
if p_s.start_times is not None:
for task in p_s.start_times:
string = "constraint start[" + str(task) + "] == " + str(
p_s.start_times[task]) + ";\n"
self.instance.add_string(string)
constraint_strings += [string]
if p_s.partial_permutation is not None:
for t1, t2 in zip(p_s.partial_permutation[:-1],
p_s.partial_permutation[1:]):
string = "constraint start[" + str(
t1) + "] <= start[" + str(t2) + "];\n"
self.instance.add_string(string)
constraint_strings += [string]
if p_s.list_partial_order is not None:
for l in p_s.list_partial_order:
for t1, t2 in zip(l[:-1], l[1:]):
string = "constraint start[" + str(
t1) + "] <= start[" + str(t2) + "];\n"
self.instance.add_string(string)
constraint_strings += [string]
if p_s.task_mode is not None:
for task in p_s.start_times:
indexes = [
i for i in self.modeindex_map
if self.modeindex_map[i]["task"] == task
and self.modeindex_map[i]["original_mode_index"] ==
p_s.task_mode[task]
]
if len(indexes) >= 0:
string = "constraint mrun[" + str(
indexes[0]) + "] == 1;"
self.instance.add_string(string)
constraint_strings += [string]
def init_model(self, **args):
model_type = args.get("model_type", "single")
if model_type == "single-preemptive":
nb_preemptive = args.get("nb_preemptive", 2)
model = Model(files_mzn[model_type])
custom_output_type = args.get("output_type", False)
if custom_output_type:
model.output_type = RCPSPSolCP
self.custom_output_type = True
solver = Solver.lookup(map_cp_solver_name[self.cp_solver_name])
instance = Instance(solver, model)
if model_type == "single-preemptive":
instance["nb_preemptive"] = nb_preemptive
# TODO : make this as options.
instance["possibly_preemptive"] = [
True for task in self.rcpsp_model.mode_details
]
instance["max_preempted"] = 3
n_res = len(list(self.rcpsp_model.resources.keys()))
# print('n_res: ', n_res)
instance["n_res"] = n_res
sorted_resources = sorted(self.rcpsp_model.resources_list)
self.resources_index = sorted_resources
rc = [int(self.rcpsp_model.resources[r]) for r in sorted_resources]
# print('rc: ', rc)
instance["rc"] = rc
n_tasks = self.rcpsp_model.n_jobs + 2
# print('n_tasks: ', n_tasks)
instance["n_tasks"] = n_tasks
sorted_tasks = sorted(self.rcpsp_model.mode_details.keys())
d = [
int(self.rcpsp_model.mode_details[key][1]['duration'])
for key in sorted_tasks
]
# print('d: ', d)
instance["d"] = d
rr = []
index = 0
for res in sorted_resources:
rr.append([])
for task in sorted_tasks:
rr[index].append(
int(self.rcpsp_model.mode_details[task][1][res]))
index += 1
instance["rr"] = rr
suc = [set(self.rcpsp_model.successors[task]) for task in sorted_tasks]
instance["suc"] = suc
self.instance = instance
p_s: Union[PartialSolution, None] = args.get("partial_solution", None)
if p_s is not None:
constraint_strings = []
if p_s.start_times is not None:
for task in p_s.start_times:
string = "constraint s[" + str(task) + "] == " + str(
p_s.start_times[task]) + ";\n"
self.instance.add_string(string)
constraint_strings += [string]
if p_s.partial_permutation is not None:
for t1, t2 in zip(p_s.partial_permutation[:-1],
p_s.partial_permutation[1:]):
string = "constraint s[" + str(t1) + "] <= s[" + str(
t2) + "];\n"
self.instance.add_string(string)
constraint_strings += [string]
if p_s.list_partial_order is not None:
for l in p_s.list_partial_order:
for t1, t2 in zip(l[:-1], l[1:]):
string = "constraint s[" + str(t1) + "] <= s[" + str(
t2) + "];\n"
self.instance.add_string(string)
constraint_strings += [string]
if p_s.start_together is not None:
for t1, t2 in p_s.start_together:
string = "constraint s[" + str(t1) + "] == s[" + str(
t2) + "];\n"
self.instance.add_string(string)
constraint_strings += [string]
if p_s.start_after_nunit is not None:
for t1, t2, delta in p_s.start_after_nunit:
string = "constraint s[" + str(t2) + "] >= s[" + str(
t1) + "]+" + str(delta) + ";\n"
self.instance.add_string(string)
constraint_strings += [string]
if p_s.start_at_end_plus_offset is not None:
for t1, t2, delta in p_s.start_at_end_plus_offset:
string = "constraint s[" + str(t2) + "] >= s[" + str(
t1) + "]+d[" + str(t1) + "]+" + str(delta) + ";\n"
self.instance.add_string(string)
constraint_strings += [string]
if p_s.start_at_end is not None:
for t1, t2 in p_s.start_at_end:
string = "constraint s[" + str(t2) + "] == s[" + str(
t1) + "]+d[" + str(t1) + "];\n"
self.instance.add_string(string)
constraint_strings += [string]
from minizinc import Instance, Model, Solver
import numpy as np
from numpy import savetxt
import sys
import json
chuffed = Solver.lookup("chuffed")
generator = Model("./scripts/minizinc/Dominosa_final.mzn")
generator.add_file("./scripts/minizinc/Dominosa.dzn")
instance = Instance(chuffed, generator)
# Find and print all possible solutions
r = instance.solve(all_solutions=True)
#m = r['temp']
#m = np.array(m,dtype=int)
#n = m.shape[0] - 1
list_sol = []
for i in range(0, len(r)):
list_sol.append(np.array(r[i, 'temp']).flatten())
dictionary_all_solutions = {}
for index, solution in enumerate(list_sol):
cont = 0
dictonary_cards = {}
for i in range(1, int((len(solution) / 2) + 1)):
count = 0
first = -1
for x in range(0, len(solution)):
if (solution[x] == i):
if (count == 0):
if index == 0:
data["W"] = int(line.split()[0])
data["H"] = int(line.split()[1])
elif index == 1:
data["N"] = int(line)
else:
s = line.split()
data["widths"].append(int(s[0]))
data["heights"].append(int(s[1]))
## Prepare the model
solver = Solver.lookup(args.solver)
if args.solver == "gecode":
solver.stdFlags = ['-p', '6'] # use 6 thread
model = Model(args.model)
instance = Instance(solver, model)
# Set the data inside the model
for key in data:
instance[key] = data[key]
result = instance.solve()
print(result.statistics)
print(result)
filename = Path(args.instance).stem
out_name = f"{filename}-out.txt"
report_name = f"{filename}-{args.solver}-report.txt"
if len(args.out_dir) > 0:
out_dir = Path(args.out_dir)
out_path = out_dir / out_name
if __name__ == "__main__":
SOLVABLE = False
outputfile = "f-output4h35"#int(sys.argv[1])
base = 4 #int(sys.argv[2])
assert base > 0
hints = 35
# TODO: Seed not producing reliable results
seed = 54
print("Starting Minizinc Module")
gecode = Solver.lookup("gecode")
model = Model()
model.add_file(os.path.dirname(__file__) +"\\SudokuGeneration.mzn")
model.output_type = Board
instance = Instance(gecode, model)
instance["Base"] = base
result = instance.solve(verbose=True, debug_output=Path("./debug_output.txt"))
kill_b:KillerSudokuBoard = result.solution.getKillerSudoku(base, hints, seed)
print("Sudoku Generation Complete")
print("Starting Cage Generation")
if SOLVABLE:
print("Valid")
kill_b.gen_cages_valid(base*base*base)
else: #Note: Sudokus obtained by the invalid process MAY be solvable, it's just not likely.
print("Invalid")
kill_b.gen_cages_invalid(base*base*base+2)
import sys
sys.path.append("../")
from OptunaMinizinc.Tuning import Tuning
from minizinc import Model, Solver, Instance
tuning = Tuning()
cbc = Solver.lookup("osicbc")
model = Model()
model.add_file("./models/mapping.mzn")
instance = Instance(cbc, model)
instance.add_file("./models/full2x2_mp3.dzn")
tuning.load_instance(instance)
tuning.load_param_from_pcs_file("../pcsFiles/osicbc.json")
params = tuning.start(n_trials=50)
print(params)
from minizinc import Instance, Model, Solver
gecode = Solver.lookup("gecode")
trivial = Model()
trivial.add_string("""
var 1..10: x;
constraint (x mod 2) = 1;
solve ::int_search([x], input_order, indomain_min) maximize x;
""")
instance = Instance(gecode, trivial)
# Find and print all intermediate solutions
result = instance.solve(intermediate_solutions=True)
for i in range(len(result)):
print(result[i, "x"])
end = time.time()
corners_x = result["corners_x"]
corners_y = result["corners_y"]
print("PAPER DIMENSIONS: " + str(width) + "x" + str(height))
print("Elapsed time: " + "%.2f" % (end - start) + " seconds")
concatenation = []
for i in range(len(corners_x)):
concatenation.append([corners_x[i]] + [corners_y[i]] +
[presents_dimensions[i][0]] +
[presents_dimensions[i][1]])
with open("out/" + str(width) + "x" + str(height) + "-out.txt", "w") as f:
f.write(str(width) + " " + str(height) + "\n")
f.write(str(n) + "\n")
for i in range(n):
f.write(
str(presents_dimensions[i][0]) + " " +
str(presents_dimensions[i][1]) + " " + str(corners_x[i]) +
" " + str(corners_y[i]) + "\n")
draw_squares(width, height, concatenation, n)
if len(sys.argv) == 1:
present_wrapping_problem()
elif len(sys.argv) == 2:
f = sys.argv[1]
instance = Instance(Solver.lookup("gecode"), Model("./src/Project.mzn"))
with open("./src/Instances/" + f, "r") as file:
solve_instance(instance, file)
def init_model(self, **args):
model_type = args.get("model_type", None)
if model_type is None:
model_type = "multi" if not self.calendar else "multi-calendar"
model = Model(files_mzn[model_type])
custom_output_type = args.get("output_type", False)
if custom_output_type:
model.output_type = RCPSPSolCP
self.custom_output_type = True
solver = Solver.lookup(map_cp_solver_name[self.cp_solver_name])
resources_list = list(self.rcpsp_model.resources.keys())
self.resources_index = resources_list
instance = Instance(solver, model)
n_res = len(resources_list)
keys = []
instance["n_res"] = n_res
keys += ["n_res"]
n_tasks = self.rcpsp_model.n_jobs + 2
instance["n_tasks"] = n_tasks
keys += ["n_tasks"]
sorted_tasks = sorted(self.rcpsp_model.mode_details.keys())
n_opt = sum(
[
len(list(self.rcpsp_model.mode_details[key].keys()))
for key in sorted_tasks
]
)
instance["n_opt"] = n_opt
keys += ["n_opt"]
modes = []
dur = []
self.modeindex_map = {}
general_counter = 1
for act in sorted_tasks:
tmp = sorted(self.rcpsp_model.mode_details[act].keys())
# tmp = [counter + x for x in tmp]
set_mode_task = set()
for i in range(len(tmp)):
original_mode_index = tmp[i]
set_mode_task.add(general_counter)
self.modeindex_map[general_counter] = {
"task": act,
"original_mode_index": original_mode_index,
}
general_counter += 1
modes.append(set_mode_task)
dur = dur + [
self.rcpsp_model.mode_details[act][key]["duration"] for key in tmp
]
instance["modes"] = modes
keys += ["modes"]
instance["dur"] = dur
keys += ["dur"]
rreq = []
index = 0
for res in resources_list:
rreq.append([])
for task in sorted_tasks:
for mod in sorted(self.rcpsp_model.mode_details[task].keys()):
rreq[index].append(
int(self.rcpsp_model.mode_details[task][mod][res])
)
index += 1
instance["rreq"] = rreq
keys += ["rreq"]
if not self.calendar:
rcap = [int(self.rcpsp_model.resources[x]) for x in resources_list]
else:
rcap = [int(max(self.rcpsp_model.resources[x])) for x in resources_list]
instance["rcap"] = rcap
keys += ["rcap"]
rtype = [
2 if res in self.rcpsp_model.non_renewable_resources else 1
for res in resources_list
]
instance["rtype"] = rtype
keys += ["rtype"]
succ = [set(self.rcpsp_model.successors[task]) for task in sorted_tasks]
instance["succ"] = succ
keys += ["succ"]
if self.calendar:
one_ressource = list(self.rcpsp_model.resources.keys())[0]
instance["max_time"] = len(self.rcpsp_model.resources[one_ressource])
keys += ["max_time"]
ressource_capacity_time = [
[int(x) for x in self.rcpsp_model.resources[res]]
for res in resources_list
]
instance["ressource_capacity_time"] = ressource_capacity_time
keys += ["ressource_capacity_time"]
self.instance = instance
p_s: Union[PartialSolution, None] = args.get("partial_solution", None)
if p_s is not None:
constraint_strings = []
if p_s.start_times is not None:
for task in p_s.start_times:
string = (
"constraint start["
+ str(task)
+ "] == "
+ str(p_s.start_times[task])
+ ";\n"
)
self.instance.add_string(string)
constraint_strings += [string]
if p_s.partial_permutation is not None:
for t1, t2 in zip(
p_s.partial_permutation[:-1], p_s.partial_permutation[1:]
):
string = (
"constraint start[" + str(t1) + "] <= start[" + str(t2) + "];\n"
)
self.instance.add_string(string)
constraint_strings += [string]
if p_s.list_partial_order is not None:
for l in p_s.list_partial_order:
for t1, t2 in zip(l[:-1], l[1:]):
string = (
"constraint start["
+ str(t1)
+ "] <= start["
+ str(t2)
+ "];\n"
)
self.instance.add_string(string)
constraint_strings += [string]
if p_s.task_mode is not None:
for task in p_s.start_times:
indexes = [
i
for i in self.modeindex_map
if self.modeindex_map[i]["task"] == task
and self.modeindex_map[i]["original_mode_index"]
== p_s.task_mode[task]
]
if len(indexes) >= 0:
string = "constraint mrun[" + str(indexes[0]) + "] == 1;"
self.instance.add_string(string)
constraint_strings += [string]
if p_s.start_together is not None:
for t1, t2 in p_s.start_together:
string = (
"constraint start[" + str(t1) + "] == start[" + str(t2) + "];\n"
)
self.instance.add_string(string)
constraint_strings += [string]
if p_s.start_after_nunit is not None:
for t1, t2, delta in p_s.start_after_nunit:
string = (
"constraint start["
+ str(t2)
+ "] >= start["
+ str(t1)
+ "]+"
+ str(delta)
+ ";\n"
)
self.instance.add_string(string)
constraint_strings += [string]
if p_s.start_at_end_plus_offset is not None:
for t1, t2, delta in p_s.start_at_end_plus_offset:
string = (
"constraint start["
+ str(t2)
+ "] >= start["
+ str(t1)
+ "]+adur["
+ str(t1)
+ "]+"
+ str(delta)
+ ";\n"
)
self.instance.add_string(string)
constraint_strings += [string]
if p_s.start_at_end is not None:
for t1, t2 in p_s.start_at_end:
string = (
"constraint start["
+ str(t2)
+ "] == start["
+ str(t1)
+ "]+adur["
+ str(t1)
+ "];\n"
)
self.instance.add_string(string)
constraint_strings += [string]
