def test_create_cumulative_wrong_type(self):
"""take the single task/single resource and display output"""
ps.SchedulingProblem("CreateCumulativeWrongType", horizon=10)
with self.assertRaises(ValueError):
ps.CumulativeWorker("MachineA", size=1)
with self.assertRaises(ValueError):
ps.CumulativeWorker("MachineA", size=2.5)
def test_optional_cumulative(self):
"""Same as above, but with an optional taskand an horizon of 2.
t2 should not be scheduled."""
pb_bs = ps.SchedulingProblem("OptionalCumulative", 2)
# tasks
t1 = ps.FixedDurationTask("T1", duration=2)
t2 = ps.FixedDurationTask("T2", duration=2, optional=True)
t3 = ps.FixedDurationTask("T3", duration=2)
# workers
r1 = ps.CumulativeWorker("Machine1", size=2)
# resource assignment
t1.add_required_resource(r1)
t2.add_required_resource(r1)
# constraints
pb_bs.add_constraint(ps.TaskStartAt(t2, 1))
# plot solution
solver = ps.SchedulingSolver(pb_bs)
solution = solver.solve()
self.assertTrue(solution)
self.assertTrue(solution.tasks[t1.name].scheduled)
self.assertTrue(solution.tasks[t3.name].scheduled)
self.assertFalse(solution.tasks[t2.name].scheduled)
def test_json_export_1(self):
pb = ps.SchedulingProblem("JSONExport1", horizon=10)
# tasks
task_1 = ps.FixedDurationTask("task1", duration=3)
task_2 = ps.VariableDurationTask("task2")
task_3 = ps.ZeroDurationTask("task3")
# buffers
buffer_1 = ps.NonConcurrentBuffer("Buffer1", initial_state=10)
buffer_2 = ps.NonConcurrentBuffer("Buffer2", initial_state=0)
# resources
worker_1 = ps.Worker("Worker1")
worker_2 = ps.Worker("Worker2")
worker_3 = ps.Worker("Worker3")
sw_1 = ps.SelectWorkers([worker_1, worker_2, worker_3])
sw_2 = ps.SelectWorkers([worker_1, worker_2, worker_3])
sw_3 = ps.SelectWorkers([worker_1, worker_2, worker_3])
ps.CumulativeWorker("CumulMachine1", size=3)
ps.CumulativeWorker("CumulMachine2", size=7)
# assign resources to tasks
task_1.add_required_resources([worker_1, worker_2])
task_2.add_required_resource(sw_1)
task_3.add_required_resource(sw_2)
# task constraints
ps.TaskPrecedence(task_1, task_2)
ps.TaskStartAt(task_1, 5)
ps.TaskUnloadBuffer(task_1, buffer_1, quantity=3)
ps.TaskLoadBuffer(task_1, buffer_2, quantity=2)
# resource constraints
ps.SameWorkers(sw_1, sw_2)
ps.DistinctWorkers(sw_2, sw_3)
ps.WorkLoad(worker_1, {(0, 6): 3, (19, 24): 4}, kind="exact")
ps.ResourceUnavailable(worker_1, [(1, 3), (6, 8)])
ps.ResourceTasksDistance(worker_1,
distance=4,
mode="exact",
list_of_time_intervals=[[10, 18]])
# export to json
solver = ps.SchedulingSolver(pb)
ps.export_json_to_file(pb, solver, "test_export_1.json")
def test_cumulative_select_worker_1(self):
pb_bs = ps.SchedulingProblem("CumulativeSelectWorker", 2)
# tasks
t1 = ps.FixedDurationTask("T1", duration=2)
t2 = ps.FixedDurationTask("T2", duration=2)
# workers
r1 = ps.CumulativeWorker("Machine1", size=2)
r2 = ps.CumulativeWorker("Machine2", size=2)
# resource assignment
t1.add_required_resource(ps.SelectWorkers([r1, r2], 1))
t2.add_required_resource(ps.SelectWorkers([r1, r2], 1))
# plot solution
solver = ps.SchedulingSolver(pb_bs)
solution = solver.solve()
self.assertTrue(solution)
def test_cumulative_productivity(self):
"""Horizon should be 4, 100/29=3.44."""
problem = ps.SchedulingProblem("CumulativeProductivity")
t_1 = ps.VariableDurationTask("t1", work_amount=100)
worker_1 = ps.CumulativeWorker("CumulWorker", size=3, productivity=29)
t_1.add_required_resource(worker_1)
problem.add_objective_makespan()
solution = ps.SchedulingSolver(problem).solve()
self.assertTrue(solution)
self.assertEqual(solution.horizon, 4)
def test_cumulative_hosp(self):
n = 16
capa = 4
pb_bs = ps.SchedulingProblem("Hospital", horizon=int(n / capa))
# workers
r1 = ps.CumulativeWorker("Room", size=capa)
for i in range(n):
t = ps.FixedDurationTask("T%i" % (i + 1), duration=1)
t.add_required_resource(r1)
solver = ps.SchedulingSolver(pb_bs)
solution = solver.solve()
self.assertTrue(solution)
def test_cumulative_2(self):
pb_bs = ps.SchedulingProblem("Cumulative2", 3)
# tasks
t1 = ps.FixedDurationTask("T1", duration=2)
t2 = ps.FixedDurationTask("T2", duration=2)
# workers
r1 = ps.CumulativeWorker("Machine1", size=2)
# resource assignment
t1.add_required_resource(r1)
t2.add_required_resource(r1)
# constraints
pb_bs.add_constraint(ps.TaskStartAt(t2, 1))
# plot solution
solver = ps.SchedulingSolver(pb_bs)
solution = solver.solve()
self.assertTrue(solution)
def test_cumulative_cost(self):
problem = ps.SchedulingProblem("CumulativeCost", horizon=5)
t_1 = ps.FixedDurationTask("t1", duration=5)
t_2 = ps.FixedDurationTask("t2", duration=5)
t_3 = ps.FixedDurationTask("t3", duration=5)
worker_1 = ps.CumulativeWorker("CumulWorker",
size=3,
cost=ps.ConstantCostPerPeriod(5))
t_1.add_required_resource(worker_1)
t_2.add_required_resource(worker_1)
t_3.add_required_resource(worker_1)
cost_ind = problem.add_indicator_resource_cost([worker_1])
solution = ps.SchedulingSolver(problem).solve()
self.assertTrue(solution)
self.assertEqual(solution.indicators[cost_ind.name], 25)
solution = ps.SchedulingSolver(problem).solve()
self.assertTrue(solution)
def test_cumulative_4(self):
pb_bs = ps.SchedulingProblem("ResourceUnavailableCumulative1", 10)
# tasks
t1 = ps.FixedDurationTask("T1", duration=2)
t2 = ps.FixedDurationTask("T2", duration=2)
t3 = ps.FixedDurationTask("T3", duration=2)
# workers
r1 = ps.CumulativeWorker("Machine1", size=3)
# resource assignment
t1.add_required_resource(r1)
t2.add_required_resource(r1)
t3.add_required_resource(r1)
ps.ResourceUnavailable(r1, [(1, 10)])
# plot solution
solver = ps.SchedulingSolver(pb_bs) # , debug=True)
solution = solver.solve()
self.assertFalse(solution)
def test_create_cumulative(self):
"""take the single task/single resource and display output"""
ps.SchedulingProblem("CreateCumulative", horizon=10)
cumulative_worker = ps.CumulativeWorker("MachineA", size=4)
self.assertEqual(len(cumulative_worker.cumulative_workers), 4)