ChainedSwapMove需要将额外的规划变量链接起来（当它来自CountableValueRange)

Question

我正在使用Optaplanner 7.38.0.Final

我实现了一个相对简单的模型，遇到了一些问题。

问题是，我想要不时地中断链以返回仓库，我认为没有必要创建另一个类来进行这种中断，并且在需要重新启动路由时，我包含了一个带有epoch second时间戳的规划变量（时间戳介于一个相对较小的范围之间，下面代码中的startoftrip)。

Optaplanner能够使用给定的xml配置创建求解器，如果我在score calculator上创建一个断点，我可以检查VAR，并看到构造启发式能够创建一个有效的访问链，甚至设置时间戳变量的值。

但几毫秒后，当在第43行调用org.optaplanner.core.impl.heuristic.selector.move.generic.chained.chainedswapmove构造函数（在上面给定版本的原始源代码上）时，求解器遇到NullPointerException

    public ChainedSwapMove(List<GenuineVariableDescriptor<Solution_>> variableDescriptorList,
            List<SingletonInverseVariableSupply> inverseVariableSupplyList, Object leftEntity, Object rightEntity) {
        super(variableDescriptorList, leftEntity, rightEntity);
        oldLeftTrailingEntityList = new ArrayList<>(inverseVariableSupplyList.size());
        oldRightTrailingEntityList = new ArrayList<>(inverseVariableSupplyList.size());
        for (SingletonInverseVariableSupply inverseVariableSupply : inverseVariableSupplyList) {
            oldLeftTrailingEntityList.add(inverseVariableSupply.getInverseSingleton(leftEntity));
            oldRightTrailingEntityList.add(inverseVariableSupply.getInverseSingleton(rightEntity));
        }
    }

变量inverseVariableSupplyList似乎包含一个空引用（它在分析包含常规非链接PlanningVariable的variableDescriptorList时创建此空引用）

package X;

import org.optaplanner.core.api.domain.entity.PlanningEntity;
import org.optaplanner.core.api.domain.variable.AnchorShadowVariable;
import org.optaplanner.core.api.domain.variable.InverseRelationShadowVariable;
import org.optaplanner.core.api.domain.variable.PlanningVariable;
import org.optaplanner.core.api.domain.variable.PlanningVariableGraphType;

import javax.persistence.Transient;
import java.io.Serializable;
import java.time.LocalDateTime;

@PlanningEntity
public class OptimizingVisit implements OptimizingStandstill , Serializable {
    private static final long serialVersionUID = 9163651541108883957L;
    private ContinuousBranchTripSolution solution;
    private Order order;

    private Long startOfTrip;
    private Long start;
    private Long arrivalTime;
    private Long end;
    private Long travelDuration;
    private Long travelDistance;

    private OptimizingStandstill previousStandstill;

    private OptimizingVisit nextStandstill; //shadow variable
    private OptimizingDriver optimizingDriver;

    public OptimizingVisit() {
    }

    public OptimizingVisit(Order order, ContinuousBranchTripSolution solution) {
        this.order = order;
        this.solution = solution;
    }

    public Order getOrder() {
        return order;
    }

    public void setOrder(Order order) {
        this.order = order;
    }

    @AnchorShadowVariable(sourceVariableName = "previousStandstill")
    public OptimizingDriver getOptimizingDriver() {
        return optimizingDriver;
    }

    public void setOptimizingDriver(OptimizingDriver optimizingDriver) {
        this.optimizingDriver = optimizingDriver;
    }

    public Employee getDriver(){
        return this.getOptimizingDriver().getDriver();
    }

    @PlanningVariable( valueRangeProviderRefs = "startTimeCandidates" )
    public Long getStartOfTrip() {
        return startOfTrip;
    }

    public void setStartOfTrip(Long startOfTrip) {
        this.startOfTrip = startOfTrip;
    }

    public Long getTravelDuration() {
        return travelDuration;
    }

    public void setTravelDuration(Long travelDuration) {
        this.travelDuration = travelDuration;
    }

    public Long getTravelDistance() {
        return travelDistance;
    }

    public void setTravelDistance(Long travelDistance) {
        this.travelDistance = travelDistance;
    }

    @PlanningVariable( graphType = PlanningVariableGraphType.CHAINED , valueRangeProviderRefs = { "visitsRange" , "driversRange" } )
    public OptimizingStandstill getPreviousStandstill() {
        return previousStandstill;
    }

    public void setPreviousStandstill(OptimizingStandstill previousStandstill) {
        this.previousStandstill = previousStandstill;
    }

    @Override
    public OptimizingVisit getNextStandstill() {
        return nextStandstill;
    }

    @Override
    public void setNextStandstill(OptimizingVisit nextStandstill) {
        this.nextStandstill = nextStandstill;
    }

    @Override
    public Hexagon getHexagon() {
        return this.getOrder().getShippingAddress().getHexagon();
    }

    public TimeRange getTimeRange() {
        return new TimeRange( this.start , this.end );
    }

    /*Helper Methods*/
    public long getRecursiveStart(){
        if( this.getStartOfTrip() != null ) return this.getStartOfTrip() + 5*60;
        if( this.start != null ) return this.start;
        this.start = this.getPreviousStandstill().getRecursiveEnd();
        return this.start;
    }

    public long getRecursiveArrivalTime(){
        if( this.arrivalTime != null ) return this.arrivalTime;
        this.arrivalTime = this.getRecursiveStart() + solution.getDistanceBetweenHexagons( this.getPreviousStandstill().getHexagon() , this.getHexagon() ).getDuration();
        return this.arrivalTime;
    }

    @Override
    public long getRecursiveEnd(){
        if( this.end != null ) return this.end;
        this.end = this.getRecursiveArrivalTime() + TripsOptimizer.standByDuration;
        return this.end;
    }

    public boolean isEndOfTrip(){
        return this.getNextStandstill() == null || ( ( OptimizingVisit ) this.getNextStandstill()).getStartOfTrip() != null;
    }

    public long endOfTrip(){
        return this.getRecursiveEnd() + TripsOptimizer.standByDuration + solution.getDistanceBetweenHexagons( this.getHexagon() , this.getOptimizingDriver().getHexagon() ).getDuration();
    }

    @Override
    public void cleanTimes() {
        this.start = null;
        this.arrivalTime = null;
        this.end = null;
    }

    public long overlapWith( OptimizingVisit optimizingVisit ){
        if( this.getRecursiveStart() > optimizingVisit.getRecursiveEnd() ) return 0;
        if( this.getRecursiveEnd() < optimizingVisit.getRecursiveStart() ) return 0;

        OptimizingVisit firstEvent;
        OptimizingVisit lastEvent;
        if( this.getRecursiveStart() < optimizingVisit.getRecursiveStart() ){
            firstEvent = this;
            lastEvent = optimizingVisit;
        }else{
            firstEvent = optimizingVisit;
            lastEvent = this;
        }

        if( lastEvent.getRecursiveEnd() < firstEvent.getRecursiveEnd() ) return lastEvent.getRecursiveEnd() - lastEvent.getRecursiveStart();

        return  firstEvent.getRecursiveEnd() - lastEvent.getRecursiveStart();
    }

    public long getTimePenalization(){
        if( this.order == null ) return 0;

        long estimatedArrivalTime = this.getRecursiveArrivalTime();

        TimeRange orderTimeRange = this.getOrder().getTimeRange();

        if( estimatedArrivalTime > orderTimeRange.getEnd() ){
            double secondsOfDifference = estimatedArrivalTime - orderTimeRange.getEnd();

            return (long) Math.pow( secondsOfDifference , this.getOrder().isExpress() ? 2 : 1.5 );
        }

        if( estimatedArrivalTime > orderTimeRange.getStart() ) return 0;

        return (long) Math.pow( orderTimeRange.getStart() - estimatedArrivalTime , 2 );
    }

    @Transient
    public double getCarryOnCash() {
        if( this.order == null ) return 0;
        double r = 0;
        if( this.order.isOnAdvanceMode() ){
            for ( TransactionMatrix tm : this.order.getTransactionMatrix() ) {
                if( !PaymentMethodType.CASH.equals( tm.getPaymentMethodType() ) ) continue;
                r += tm.getAdvance();
            }
        }else{
            for ( TransactionMatrix tm : this.order.getTransactionMatrix() ) {
                if( !PaymentMethodType.CASH.equals( tm.getPaymentMethodType() ) ) continue;
                r += tm.getAmount();
            }
        }

        return r;
    }

    public long getEarlyOrLateSeconds(){
        TimeRange orderTimeRange = this.getOrder().getTimeRange();
        long arrivalTime = this.getRecursiveArrivalTime();
        long r = 0;
        if( arrivalTime < orderTimeRange.getStart() ) r += orderTimeRange.getStart() - arrivalTime;
        if( arrivalTime > orderTimeRange.getEnd() ) r += arrivalTime - orderTimeRange.getEnd();
        return r;
    }

    public long getContinuousOptimizationScore( ContinuousBranchTripSolution solution ) {
        return 0;
        /*if( !( this.getPreviousStandstill() instanceof OptimizingTrip ) ){
            return this.getTimePenalization();
        }
        double r = 0;
        OptimizingTrip trip = (OptimizingTrip) this.getPreviousStandstill();

        for ( DriverShift shift : solution.getDriverShifts() ){
            if( this.getOptimizingDriver().getDriver().computedIdHashCode() != shift.getDriver().computedIdHashCode() ) continue;
            long seconds = Math.max( 0 , trip.getEnd() - shift.getAvailableUntilAsEpochSeconds() );
            r += Math.pow( seconds * 2 , 2 );
        }

        r += 0.25d * Math.max( this.getCarryOnCash() - this.getOptimizingDriver().getDriver().getTrustLevel() , 0 );

        if ( trip.getStart() > solution.getStart() ) {
            r -= 0.5d * ( trip.getEnd() - solution.getStart() );
        }

        r += this.getTimePenalization();

        return (long) r;*/
    }

    @Override
    public String toString() {
        return String.format("OptimizingVisit{  %s  ,  %s  ,  %s  ,  %s , %s min early , %s min late  }",
                this.order.getNumber(),
                this.getOrder().getLowerBoundDelivery(),
                this.getPreviousStandstill() == null ? "" : LocalDateTime.ofEpochSecond( this.getRecursiveArrivalTime() , 0 , BitemporalModel.ZONE_OFFSET ),
                this.getOrder().getUpperBoundDelivery(),
                this.getPreviousStandstill() == null ? "" : Math.max( 0 , ( this.getOrder().getTimeRange().getStart() - this.getRecursiveArrivalTime() ) ) / 60,
                this.getPreviousStandstill() == null ? "" : Math.max( 0 , ( this.getRecursiveArrivalTime() - this.getOrder().getTimeRange().getEnd() ) ) / 60
        );
    }
}

Answer 1

我们最近修复了1961年的计划，其症状与你们在这里的问题有显著的相似之处。请查看OptaPlanner 7.39.0.final（当它退出时）或更晚，您的问题可能会消失。