A question about FJSP

[EasonCon]

I am optimizing a FJSP problem. In my model, allocation is defined as @planning entity, which has two variables: execution mode and previous allocation. Previous allocation is defined as a chained variable, and its anchor is Resource. Resource and execution mode are one-to-one correspondence. When the variable execution mode changes (from one resource to another), I hope that another variable previous allocation will move to the new Resource chain.
The sourcevariable of Anchor Shadow is previous allocation. I found that anchor does not support Listener. How can I implement this process? Or can you provide a new model idea?
Chain like: Resource1 -> allocation1 -> allocation2

[Christopher-Chianelli]

You would need to implement a custom move. The custom move would update the execution mode and resources of an entire chain.

Alternatively, since execution mode and resource are one to one, and resource is an anchor, could you make the execution mode variable a fact on the resource, and access it from the allocation using an anchor shadow variable:

@AnchorShadowVariable(sourceVariableName = "previousAllocation")
Resource resource;

public ExecutionMode getExecutionMode() {
    return resource.getExecutionMode();
}

We are currently working on a framework to make writing custom moves easier; stay tuned.

[EasonCon]

Thanks for your answer! @Christopher-Chianelli
Another question is about AnchorShadow.I defined Resource as anchor,which SourceVariable is PlanningVariable previous allocation.As you mentioned above,I need to implement a custom move when execution mode changed.If I tell the solver in my custom move that PlanningVariable previous allocation has changed from previous allocation 1 to 2, the solver can automaticly update the "AnchorShadow" ?

package Domain.Allocation;

import DataStruct.ExecutionMode;
import DataStruct.Operation;
import Listen.StartTimeListener;
import ai.timefold.solver.core.api.domain.entity.PlanningEntity;
import ai.timefold.solver.core.api.domain.valuerange.CountableValueRange;
import ai.timefold.solver.core.api.domain.valuerange.ValueRangeFactory;
import ai.timefold.solver.core.api.domain.valuerange.ValueRangeProvider;
import ai.timefold.solver.core.api.domain.variable.*;
import lombok.Getter;
import lombok.Setter;

import java.util.List;

@Getter
@Setter
@PlanningEntity
public class Allocation extends AllocationOrResource {
    private Operation operation;
    private List<Allocation> predecessorsAllocations;  // In craft path
    private List<Allocation> successorsAllocations;

    // variables
    @PlanningVariable(valueRangeProviderRefs = {"executionModes"})
    private ExecutionMode executionMode;

    @PlanningVariable(graphType = PlanningVariableGraphType.CHAINED)
    private AllocationOrResource previous;

    @PlanningVariable(valueRangeProviderRefs = {"delayRange"})
    private int delay;  // minutes

    // shadow
    @AnchorShadowVariable(sourceVariableName = "previous")
    private AllocationOrResource resourceNode;

    @InverseRelationShadowVariable(sourceVariableName = "previous")
    private AllocationOrResource next;

    @ShadowVariable(variableListenerClass = StartTimeListener.class, sourceVariableName = "previous")
    private long startTime;
    private long endTime;

    // value range
    @ValueRangeProvider(id = "executionModes")
    public List<ExecutionMode> getExecutionModes() {
        return operation.getExecutionModes();
    }

    @ValueRangeProvider(id = "delayRange")
    public CountableValueRange<Integer> getDelayRange() {
        return ValueRangeFactory.createIntValueRange(0, 500, 10);
    }


    public Allocation() {
    }
}

[EasonCon]

I am trying to solve a FJSP,maybe the search space is very large.

[Christopher-Chianelli]

All shadow variables are automatically updated/recomputed as long as there are the proper beforeVariableChanged/afterVariableChanged on their source variables. This recomputation happens when doMoveOnGenuineVariables returns, although you can force it to happen earlier/within the move by calling scoreDirector.triggerVariableListeners (which is useful if you are use those variables in the custom move itself).

[EasonCon]

@Christopher-Chianelli Thanks for your answer! It's really helpful for my working.
If I want to adjust a value range dynamically while running,could I define the value as a shadow? Such as:

    @ShadowVariable(variableListenerClass = PreviousAllocationRangeListener.class, sourceVariableName = "previous")
    @ValueRangeProvider(id = "previousRange")
    private List<AllocationOrResource> possiblePreviousAllocation = new ArrayList<>();

[Christopher-Chianelli]

@ValueRangeProvider is not needed for Shadow Variables; @ValueRangeProvider is only needed for geninue variables (that is, @PlanningVariable and @PlanningListVariable). A shadow variable can take any value; a shadow variable value is derived strictly from its sources.

A @ValueRangeProvider cannot be a shadow variable. It can, however, be a method defined on an entity, which will be called before solving and give each entity an independent value range (does not work for list variable).

Do note the ScoreDirector API for dynamically adding entities to a problem aren't consistently supported (see #1154). To dynamically add planning values/entities during solving, do a ProblemChange or create a new instance of Solver (see https://docs.timefold.ai/timefold-solver/latest/responding-to-change/responding-to-change#problemChange).

To prevent moves that use invalid values from being selected, use filtered selection (see https://docs.timefold.ai/timefold-solver/latest/optimization-algorithms/overview#filteredSelection).