or-tools - add constraint to jobshop problem - or-tools

Question

I would like to extend a bit the job shop example given here.
Given each machine has power consumption and at any given time (duration unit) there's a max power consumption on all machines, i would like to prevent overlap only if the sum of all machine consumptions passes a fixed value.
var allJobs =
new[] {
new[] {
// job0
new { machine = 0, duration = 3, power = 5 }, // task0
new { machine = 1, duration = 2, power = 2 }, // task1
new { machine = 2, duration = 2, power = 1 }, // task2
}.ToList(),
new[] {
// job1
new { machine = 0, duration = 2, power = 5 }, // task0
new { machine = 2, duration = 1, power = 2 }, // task1
new { machine = 1, duration = 4, power = 1}, // task2
}.ToList(),
new[] {
// job2
new { machine = 1, duration = 4, power = 1 }, // task0
new { machine = 2, duration = 3, power = 2 }, // task1
}.ToList(),
}.ToList();
The "flexible job job" example covers interval overlap but not the sum of a new variable and with the addon of this must be checked on every duration unit.
Any pointers on how i can achieve this?
Regards

Answer 1

For each task, create an interval. Use this interval in the no_overlap constraint of the corresponding machine.
Then add a cumulative constraint with the fixed value from the description as capacity.
Then for each task, add a demand (interval of the task, power of the task) to the cumulative constraint using this method: https://google.github.io/or-tools/dotnet/classGoogle_1_1OrTools_1_1Sat_1_1CumulativeConstraint.html#a922ab6a70999c054e9e94aa2dfb96be4

Answer 2

indeed that's the way to go.
i was able to implement it using your directions.
then i tryed to extend it a little further using the same method.
each machine, has a 'type', and and sum of power per 'type' could not exced a given value.
i grouped the intervals by type then call noOverlap on them.
But ive making a mistake somewhere as it aint correctly calculating despite give a solution.
//id, type
var machinesTypes = new[] {
1, 1, 2
};
var allJobs =
new[] {
new[] {
// job0
new { machine = 0, duration = 3, power = 5, type = 1 }, // task0
new { machine = 1, duration = 2, power = 4, type = 1 }, // task1
new { machine = 2, duration = 1, power = 2, type = 2 } , // task2
}.ToList()
}.ToList();
int numMachines = 0;
foreach (var job in allJobs)
{
foreach (var task in job)
{
numMachines = Math.Max(numMachines, 1 + task.machine);
}
}
int[] allMachines = Enumerable.Range(0, numMachines).ToArray();
// Computes horizon dynamically as the sum of all durations.
int horizon = 0;
foreach (var job in allJobs)
{
foreach (var task in job)
{
horizon += task.duration;
}
}
// Creates the model.
CpModel model = new CpModel();
//full power capacity Constraint
IntVar full_power_capacity = model.NewIntVar(0, 11, $"full_power_capacity");
CumulativeConstraint cc_full_power = model.AddCumulative(full_power_capacity);
//type power constraint
Dictionary<int, CumulativeConstraint> cc_all_machines = new Dictionary<int, CumulativeConstraint>();
foreach (int machine in allMachines)
{
int machineType = machinesTypes[allMachines[machine]];
if (!cc_all_machines.ContainsKey(machineType))
{
IntVar type_power_capacity = model.NewIntVar(0, 6, $"type_power_capacity_{machineType}");
CumulativeConstraint cc_type_power = model.AddCumulative(type_power_capacity);
cc_all_machines.Add(machineType, cc_type_power);
}
}
Dictionary<Tuple<int, int>, Tuple<IntVar, IntVar, IntervalVar>> allTasks = new Dictionary<Tuple<int, int>, Tuple<IntVar, IntVar, IntervalVar>>(); // (start, end, duration)
Dictionary<int, List<IntervalVar>> machineToIntervals = new Dictionary<int, List<IntervalVar>>();
Dictionary<int, List<IntervalVar>> machineTypesToIntervals = new Dictionary<int, List<IntervalVar>>();
for (int jobID = 0; jobID < allJobs.Count(); ++jobID)
{
var job = allJobs[jobID];
for (int taskID = 0; taskID < job.Count(); ++taskID)
{
var task = job[taskID];
String suffix = $"_{jobID}_{taskID}";
IntVar start = model.NewIntVar(0, horizon, "start" + suffix);
IntVar end = model.NewIntVar(0, horizon, "end" + suffix);
IntervalVar interval = model.NewIntervalVar(start, task.duration, end, "interval" + suffix);
var key = Tuple.Create(jobID, taskID);
allTasks[key] = Tuple.Create(start, end, interval);
if (!machineToIntervals.ContainsKey(task.machine))
{
machineToIntervals.Add(task.machine, new List<IntervalVar>());
}
machineToIntervals[task.machine].Add(interval);
cc_full_power.AddDemand(interval, task.power);
string suffix_2 = $"_{task.type}";
IntVar start_2 = model.NewIntVar(0, horizon, "start_2" + suffix_2);
IntVar end_2 = model.NewIntVar(0, horizon, "end_2" + suffix_2);
IntervalVar interval_2 = model.NewIntervalVar(start_2, task.duration, end_2, "interval_2" + suffix_2);
if (!machineTypesToIntervals.ContainsKey(task.type))
{
machineTypesToIntervals.Add(task.type, new List<IntervalVar>());
}
machineTypesToIntervals[task.type].Add(interval_2);
cc_all_machines[task.type].AddDemand(interval_2, task.power);
}
}
// Create and add disjunctive constraints.
foreach (int machine in allMachines)
{
model.AddNoOverlap(machineToIntervals[machine]);
}
foreach (var item in cc_all_machines)
{
model.AddNoOverlap(machineTypesToIntervals[item.Key]);
}
// Makespan objective.
IntVar objVar = model.NewIntVar(0, horizon, "makespan");
model.Minimize(objVar);
// Solve
CpSolver solver = new CpSolver();
CpSolverStatus status = solver.Solve(model);