Adding new object by increasing stream cardinality conditionally

[Boyankovachev]

Hello! I have a (maybe) complicated question.

I am attempting to build a constraint, for calculating minimum pause between shifts at least once a week.
I have ShiftAssignmentByAbr class that contains the PlanningVariable - Employee. It also contains information about the shift, day, week and etc...
I am currently using the groupBy building block to group the ShiftAssignment's by employee and week and it works great!

return factory.forEach(ShiftAssignmentByAbr.class)
                .groupBy(
                        (shiftAssignmentByAbr -> shiftAssignmentByAbr.getEmployee()),
                        (shiftAssignmentByAbr -> shiftAssignmentByAbr.getShiftDay().getWeek()),
                        toList((shiftAssignmentByAbr) -> shiftAssignmentByAbr)
                )
                .filter(
                        (employee, week, shiftAssignmentByAbrs) -> !ConstraintUtilities.doesWeekContainMinimumPauseAtLeastOnceWeekByAbr(employee, week, shiftAssignmentByAbrs)
                )
                .penalizeBigDecimal(ConstraintNames.MIN_PAUSE_ONCE_A_WEEK.getDefaultValue())
                .asConstraint(ConstraintNames.MIN_PAUSE_ONCE_A_WEEK.getName());

My problem is the following. The previous Sunday could contain a night shift. The ShiftAssignment that contains the previous Sunday would have the same Employee, but different Week. In order to make my calculation 100% correct, I would need to add this ShiftAssignment somehow to the constraint stream, if it exists. If it does not, it would be null.

Essentialy I want to go from:
TriConstraintStream<Employee, Week, List<ShiftAssignmentByAbr>
to
QuadConstraintStream<Employee, Week, List<ShiftAssignmentByAbr>, ShiftAssignmentByAbr>
where the 4th element is the last week's Sunday shift, if it exists.

I looked into using join, or concat, but I couldn't find a way to make it work with any of them.
The only I found to achieve my is to only group them by employee and toList(...) and make my own custom handler.

        factory.forEach(ShiftAssignmentByAbr.class)
                .groupBy(
                        (shiftAssignmentByAbr -> shiftAssignmentByAbr.getEmployee()),
                        toList((shiftAssignmentByAbr) -> shiftAssignmentByAbr)
                )
                .filter(((employee, shiftAssignmentByAbrs) -> {
                        return customMethod(...)    
                }))

This solution would work, but it would be slow, inconvenient, and negate incremental score calculation.

Is it possible to achieve this through the Timefold API directly?
Any advice would be helpful!
Thank you and sorry for the long question!

[greyhairredbear]

I think joining should work here...

You could create a stream that contains all Sunday night shifts:

var sundayNightShifts = factory.forEach(ShiftAssignmentByAbr.class).filter((s)-> s.getShiftDay() == DayOfWeek.SUNDAY && s.isNightShift())

and then join that to your grouped shifts

factory.forEach(ShiftAssignmentByAbr.class)
                .groupBy(
                        (shiftAssignmentByAbr -> shiftAssignmentByAbr.getEmployee()),
                        (shiftAssignmentByAbr -> shiftAssignmentByAbr.getShiftDay().getWeek()),
                        toList((shiftAssignmentByAbr) -> shiftAssignmentByAbr)
                )
				// new code here
				.join(sundayNightShifts, Joiners.equal(((e, week, s) -> week), (sundayNightShift -> sundayNightShift.week + 1))
				// you probably will have to adjust the code for your filter function a bit ;)
                .filter(
                        (employee, week, shiftAssignmentByAbrs) -> !ConstraintUtilities.doesWeekContainMinimumPauseAtLeastOnceWeekByAbr(employee, week, shiftAssignmentByAbrs)
                )
                .penalizeBigDecimal(ConstraintNames.MIN_PAUSE_ONCE_A_WEEK.getDefaultValue())
                .asConstraint(ConstraintNames.MIN_PAUSE_ONCE_A_WEEK.getName());

Important note: This way, if there is no Sunday night shift entity for a group, this group will not be included in the result of the join, which is probably undesirable. There might be a way to work around this using Timefold's API, but I'm not sure (did not find anything like a left join. Maintainers might know more about that @triceo?). If feasible, you could ensure your data starts correctly (i.e. with last Sunday's shift pinned). Might not be the most beautiful solution.

Sorry, its a bit sloppy and might contain syntax errors, just quickly jotted it down. But I suppose the concept should work.

[Boyankovachev]

Thank you for the response.
I was thinking about this approach, but the problem is the join works as inner join, thus all weeks following up empty Sunday would be missing. If I could make it work like left-join it would be very nice.

[greyhairredbear]

With the code above, they would only be missing if you don't have any entities for that day. So what I meant with "ensuring your data starts correctly" is to ensure there is an entity of ShiftAssignmentByAbr for every Sunday before the weeks you are planning. Might be unassigned. And if you don't want to change that assignment, then you could pin it.

You only would need to check in the filter if the Sunday night shift has the same employee as your existing group.

I'm not aware of the exact nature of the constraint, so there might be other ways to work around this.

Also, another note (might not apply here): If there is any way to quantify the severity of a violation of this constraint (maybe something like overall hours worked), weighing the constraint might make sense to guide the solver to less unfair solutions.

[Christopher-Chianelli]

Right now, to do a left outer join, you concat the join with an ifDoesNotExist:

var joiner =  Joiners.equal(((e, week, s) -> week), (sundayNightShift -> sundayNightShift.week + 1);
var base = factory.forEach(ShiftAssignmentByAbr.class)
                .groupBy(
                        (shiftAssignmentByAbr -> shiftAssignmentByAbr.getEmployee()),
                        (shiftAssignmentByAbr -> shiftAssignmentByAbr.getShiftDay().getWeek()),
                        toList((shiftAssignmentByAbr) -> shiftAssignmentByAbr)
                );

return base.join(sundayNightShifts, joiner)
    .concat(base.ifNotExists(sundayNightShifts, joiner))
    .filter((employee, week, shiftAssignmentByAbrs, maybeSundayNightShift) -> !ConstraintUtilities.doesWeekContainMinimumPauseAtLeastOnceWeekByAbr(employee, week, shiftAssignmentByAbrs))
    .penalizeBigDecimal(ConstraintNames.MIN_PAUSE_ONCE_A_WEEK.getDefaultValue())
    .asConstraint(ConstraintNames.MIN_PAUSE_ONCE_A_WEEK.getName());

[greyhairredbear]

Oh, that's nice, I learned something :) Thank you for sharing!

[Boyankovachev]

Little update. This trick absolutely worked! Thanks :)

[triceo]

We have a complement building block which may help, but its usefulness is limited on account of only working with the first component of a tuple.

The need for more powerful joins has been coming up lately. We have an issue which includes a lot of our random thoughts on the topic - but so far, no major effort was invested. It may change.