Shadow variable
1. Introduction
A shadow variable is a planning variable whose correct value can be deduced from the state of the genuine planning variables. Even though such a variable violates the principle of normalization by definition, in some use cases it can be very practical to use a shadow variable, especially to express the constraints more naturally. For example in vehicle routing with time windows: the arrival time at a customer for a vehicle can be calculated based on the previously visited customers of that vehicle (and the known travel times between two locations).
When the customers for a vehicle change, the arrival time for each customer is automatically adjusted. For more information, see the vehicle routing domain model.
From a score calculation perspective, a shadow variable is like any other planning variable. From an optimization perspective, Timefold effectively only optimizes the genuine variables (and mostly ignores the shadow variables): it just assures that when a genuine variable changes, any dependent shadow variables are changed accordingly.
Any class that has at least one shadow variable, is a planning entity class (even if it has no genuine planning variables).
That class must be defined in the solver configuration and have a A genuine planning entity class has at least one genuine planning variable, but can have shadow variables too. A shadow planning entity class has no genuine planning variables and at least one shadow planning variable. |
There are several built-in shadow variables:
2. Bi-directional variable (inverse relation shadow variable)
Two variables are bi-directional if their instances always point to each other (unless one side points to null
and the other side does not exist).
So if A references B, then B references A.
For a non-chained planning variable, the bi-directional relationship must be a many-to-one relationship. To map a bi-directional relationship between two planning variables, annotate the source side (which is the genuine side) as a normal planning variable:
@PlanningEntity
public class CloudProcess {
@PlanningVariable(...)
public CloudComputer getComputer() {
return computer;
}
public void setComputer(CloudComputer computer) {...}
}
And then annotate the other side (which is the shadow side) with a @InverseRelationShadowVariable
annotation on a Collection
(usually a Set
or List
) property:
@PlanningEntity
public class CloudComputer {
@InverseRelationShadowVariable(sourceVariableName = "computer")
public List<CloudProcess> getProcessList() {
return processList;
}
}
Register this class as a planning entity,
otherwise Timefold won’t detect it and the shadow variable won’t update.
The sourceVariableName
property is the name of the genuine planning variable on the return type of the getter
(so the name of the genuine planning variable on the other side).
The shadow property, which is |
For a chained planning variable, the bi-directional relationship is always a one-to-one relationship. In that case, the genuine side looks like this:
@PlanningEntity
public class Customer ... {
@PlanningVariable(graphType = PlanningVariableGraphType.CHAINED, ...)
public Standstill getPreviousStandstill() {
return previousStandstill;
}
public void setPreviousStandstill(Standstill previousStandstill) {...}
}
And the shadow side looks like this:
@PlanningEntity
public class Standstill {
@InverseRelationShadowVariable(sourceVariableName = "previousStandstill")
public Customer getNextCustomer() {
return nextCustomer;
}
public void setNextCustomer(Customer nextCustomer) {...}
}
Register this class as a planning entity, otherwise Timefold won’t detect it and the shadow variable won’t update.
The input planning problem of a |
3. Anchor shadow variable
An anchor shadow variable is the anchor of a chained variable.
Annotate the anchor property as a @AnchorShadowVariable
annotation:
@PlanningEntity
public class Customer {
@AnchorShadowVariable(sourceVariableName = "previousStandstill")
public Vehicle getVehicle() {...}
public void setVehicle(Vehicle vehicle) {...}
}
This class should already be registered as a planning entity.
The sourceVariableName
property is the name of the chained variable on the same entity class.
4. List variable shadow variables
When the planning entity uses a list variable, its elements can use a number of built-in shadow variables.
4.1. Inverse relation shadow variable
Use the same @InverseRelationShadowVariable
annotation as with basic or chained planning variable to establish bi-directional relationship between the entity and the elements assigned to its list variable.
The type of the inverse shadow variable is the planning entity itself because there is a one-to-many relationship between the entity and the element classes.
The planning entity side has a genuine list variable:
@PlanningEntity
public class Vehicle {
@PlanningListVariable
public List<Customer> getCustomers() {
return customers;
}
public void setCustomers(List<Customer> customers) {...}
}
On the element side:
-
Annotate the class with
@PlanningEntity
to make it a shadow planning entity. -
Register this class as a planning entity, otherwise Timefold won’t detect it and the shadow variable won’t update.
-
Create a property with the genuine planning entity type.
-
Annotate it with
@InverseRelationShadowVariable
and setsourceVariableName
to the name of the genuine planning list variable.
@PlanningEntity
public class Customer {
@InverseRelationShadowVariable(sourceVariableName = "customers")
public Vehicle getVehicle() {
return vehicle;
}
public void setVehicle(Vehicle vehicle) {...}
}
4.2. Previous and next element shadow variable
Use @PreviousElementShadowVariable
or @NextElementShadowVariable
to get a reference to an element that is assigned to the same entity’s list variable one index lower (previous element) or one index higher (next element).
The previous and next element shadow variables may be |
The planning entity side has a genuine list variable:
@PlanningEntity
public class Vehicle {
@PlanningListVariable
public List<Customer> getCustomers() {
return customers;
}
public void setCustomers(List<Customer> customers) {...}
}
On the element side:
@PlanningEntity
public class Customer {
@PreviousElementShadowVariable(sourceVariableName = "customers")
public Customer getPreviousCustomer() {
return previousCustomer;
}
public void setPreviousCustomer(Customer previousCustomer) {...}
@NextElementShadowVariable(sourceVariableName = "customers")
public Customer getNextCustomer() {
return nextCustomer;
}
public void setNextCustomer(Customer nextCustomer) {...}
5. Custom VariableListener
To update a shadow variable, Timefold uses a VariableListener
.
To define a custom shadow variable, write a custom VariableListener
:
implement the interface and annotate it on the shadow variable that needs to change.
@PlanningVariable(...)
public Standstill getPreviousStandstill() {
return previousStandstill;
}
@ShadowVariable(
variableListenerClass = VehicleUpdatingVariableListener.class,
sourceVariableName = "previousStandstill")
public Vehicle getVehicle() {
return vehicle;
}
Register this class as a planning entity if it isn’t already. Otherwise Timefold won’t detect it and the shadow variable won’t update.
The sourceVariableName
is the (genuine or shadow) variable that triggers changes to the annotated shadow variable.
If the source variable is declared on a different class than the annotated shadow variable’s class, also specify the sourceEntityClass
and make sure the shadow variable’s class is registered as a planning entity.
Implement the VariableListener
interface.
For example, the VehicleUpdatingVariableListener
assures that every Customer
in a chain has the same Vehicle
, namely the chain’s anchor.
public class VehicleUpdatingVariableListener implements VariableListener<VehicleRoutingSolution, Customer> {
public void afterEntityAdded(ScoreDirector<VehicleRoutingSolution> scoreDirector, Customer customer) {
updateVehicle(scoreDirector, customer);
}
public void afterVariableChanged(ScoreDirector<VehicleRoutingSolution> scoreDirector, Customer customer) {
updateVehicle(scoreDirector, customer);
}
...
protected void updateVehicle(ScoreDirector<VehicleRoutingSolution> scoreDirector, Customer sourceCustomer) {
Standstill previousStandstill = sourceCustomer.getPreviousStandstill();
Vehicle vehicle = previousStandstill == null ? null : previousStandstill.getVehicle();
Customer shadowCustomer = sourceCustomer;
while (shadowCustomer != null && shadowCustomer.getVehicle() != vehicle) {
scoreDirector.beforeVariableChanged(shadowCustomer, "vehicle");
shadowCustomer.setVehicle(vehicle);
scoreDirector.afterVariableChanged(shadowCustomer, "vehicle");
shadowCustomer = shadowCustomer.getNextCustomer();
}
}
}
A |
Any change of a shadow variable must be told to the |
5.1. Multiple source variables
If your custom variable listener needs multiple source variables to compute the shadow variable, annotate the shadow variable with multiple @ShadowVariable
annotations, one per each source variable.
@PlanningVariable(...)
public ExecutionMode getExecutionMode() {
return executionMode;
}
@PlanningVariable(...)
public Integer getDelay() {
return delay;
}
@ShadowVariable(
variableListenerClass = PredecessorsDoneDateUpdatingVariableListener.class,
sourceVariableName = "executionMode")
@ShadowVariable(
variableListenerClass = PredecessorsDoneDateUpdatingVariableListener.class,
sourceVariableName = "delay")
public Integer getPredecessorsDoneDate() {
return predecessorsDoneDate;
}
5.2. Piggyback shadow variable
If one VariableListener
changes two or more shadow variables (because having two separate VariableListener
s would be inefficient), then annotate only the first shadow variable with @ShadowVariable
and specify the variableListenerClass
there.
Use @PiggybackShadowVariable
on each shadow variable updated by that variable listener and reference the first shadow variable:
@PlanningVariable(...)
public Standstill getPreviousStandstill() {
return previousStandstill;
}
@ShadowVariable(
variableListenerClass = TransportTimeAndCapacityUpdatingVariableListener.class,
sourceVariableName = "previousStandstill")
public Integer getTransportTime() {
return transportTime;
}
@PiggybackShadowVariable(shadowVariableName = "transportTime")
public Integer getCapacity() {
return capacity;
}
5.3. Shadow variable cloning
A shadow variable’s value (just like a genuine variable’s value)
isn’t planning cloned by the default solution cloner,
unless it can easily prove that it must be planning cloned (for example the property type is a planning entity class).
Specifically shadow variables of type List
, Set
, Collection
or Map
usually need to be planning cloned
to avoid corrupting the best solution when the working solution changes.
To planning clone a shadow variable, add @DeepPlanningClone
annotation:
@DeepPlanningClone
@ShadowVariable(...)
private Map<LocalDateTime, Integer> usedManHoursPerDayMap;
6. VariableListener triggering order
All shadow variables are triggered by a VariableListener
, regardless if it’s a built-in or a custom shadow variable.
The genuine and shadow variables form a graph, that determines the order in which the afterEntityAdded()
, afterVariableChanged()
and afterEntityRemoved()
methods are called:
In the example above, D could have also been ordered after E (or F) because there is no direct or indirect dependency between D and E (or F). |
Timefold guarantees that:
-
The first
VariableListener
'safter*()
methods trigger after the last genuine variable has changed. Therefore the genuine variables (A and B in the example above) are guaranteed to be in a consistent state across all its instances (with values A1, A2 and B1 in the example above) because the entireMove
has been applied. -
The second
VariableListener
'safter*()
methods trigger after the last first shadow variable has changed. Therefore the first shadow variable (C in the example above) are guaranteed to be in a consistent state across all its instances (with values C1 and C2 in the example above). And of course the genuine variables too. -
And so forth.
Timefold does not guarantee the order in which the after*()
methods are called for the sameVariableListener
with different parameters (such as A1 and A2 in the example above), although they are likely to be in the order in which they were affected.
By default, Timefold does not guarantee that the events are unique.
For example, if a shadow variable on an entity is changed twice in the same move (for example by two different genuine variables), then that will cause the same event twice on the VariableListener
s that are listening to that original shadow variable.
To avoid dealing with that complexity, overwrite the method requiresUniqueEntityEvents()
to receive unique events at the cost of a small performance penalty:
public class StartTimeUpdatingVariableListener implements VariableListener<TaskAssigningSolution, Task> {
@Override
public boolean requiresUniqueEntityEvents() {
return true;
}
...
}