public AddResult(Schedule s, Order order, int orderIndex, Node nextTo, int loopIndex, int dayIndex, int truckIndex, double delta) : base(s)
{
this.order = order;
this.orderIndex = orderIndex;
nextTos = new List <Node>()
{
nextTo
};
loopIndices = new List <int>()
{
loopIndex
};
dayIndices = new List <int>()
{
dayIndex
};
truckIndices = new List <int>()
{
truckIndex
};
deltas = new List <double>()
{
delta
};
}
public override void ApplyOperator()
{
state.Days[day, truck].RemoveNodeFromLoop(toDelete, loop);
Order o = toDelete.Data;
state.totalTime += (delta - 4 * o.Frequency * o.TimeToEmpty); // Delta should be only change in drivetime, so should not include the penalty.
state.totalPenalty += 3 * o.Frequency * o.TimeToEmpty;
state.nonPlannedOrders.Add(toDelete.Data);
}
public AddResult(Schedule s, Order order, int orderIndex, List <Node> nextTos, List <int> loopIndices, List <int> dayIndices, List <int> truckIndices, List <double> deltas) : base(s)
{
this.order = order;
this.orderIndex = orderIndex;
this.nextTos = nextTos;
this.loopIndices = loopIndices;
this.dayIndices = dayIndices;
this.truckIndices = truckIndices;
this.deltas = deltas;
}
public Node AddOrderToLoop(Order order, Node nextTo, int loopIndex)
{
//Console.WriteLine($"Timeleft before AddOrder: {Loops[loopIndex].Duration}");
TimeLeft += Loops[loopIndex].Duration;
Node res = Loops[loopIndex].AddOrder(order, nextTo);
TimeLeft -= Loops[loopIndex].Duration;
return(res);
}
public Node AppendNext(Order o)
{
Node n = new Node(o)
{
Prev = this,
Next = Next
};
Next.Prev = n;
Next = n;
return(n);
}
public Node AddOrder(Order order, Node nextTo)
{
Cluster = order.Cluster;
Duration += (order.TimeToEmpty
+ GD.JourneyTime[nextTo.Data.MatrixId, order.MatrixId]
+ GD.JourneyTime[order.MatrixId, nextTo.Next.Data.MatrixId]
- GD.JourneyTime[nextTo.Data.MatrixId, nextTo.Next.Data.MatrixId]);
Node n = nextTo.AppendNext(order);
RoomLeft -= (order.NumContainers * order.VolPerContainer * 0.2);
Count++;
return(n);
}
public bool EvaluateOptimalAddition(Order order, out Node opt, out double newRoomLeft, out double td, Node excluded)
{
td = 0;
opt = null;
newRoomLeft = RoomLeft - (order.NumContainers * order.VolPerContainer) * 0.2; // Het gecomprimeerde gewicht dat erbij zou komen
if (newRoomLeft <= 0)
{
return(false); // Toevoegen zal de gewichtsconstraint schenden
}
double best = GD.JourneyTime[order.MatrixId, Start.Data.MatrixId];
opt = Start;
Node curr = Start.Next;
while (!curr.IsDump)
{
if (excluded != null && curr.Data.OrderId == excluded.Data.OrderId)
{
//Console.WriteLine("Encountered " + curr.Data.OrderId);
curr = curr.Next;
continue;
}
double t = GD.JourneyTime[order.MatrixId, curr.Data.MatrixId];
if (t < best)
{
opt = curr;
best = t;
}
curr = curr.Next;
}
double tNext = GD.JourneyTime[order.MatrixId, opt.Next.Data.MatrixId];
double tPrev = GD.JourneyTime[order.MatrixId, opt.Prev.Data.MatrixId];
if (tPrev < tNext && (excluded != null && opt.Data.OrderId == excluded.Data.OrderId))
{
opt = opt.Prev;
}
td = (order.TimeToEmpty
+ GD.JourneyTime[opt.Data.MatrixId, order.MatrixId]
+ GD.JourneyTime[order.MatrixId, opt.Next.Data.MatrixId]
- GD.JourneyTime[opt.Data.MatrixId, opt.Next.Data.MatrixId]);
return(true);
}
public bool EvaluateAddition(Order order, out Node bestNode, out double bestDeltaTime, out int bestLoop, bool evaluateCluster = false, Node excluded = null)
{
bestNode = null;
bestDeltaTime = double.MaxValue;
bestLoop = -1;
for (int i = 0; i < Loops.Count; i++)
{
Loop loop = Loops[i];
if (evaluateCluster && loop.Cluster != -1 && loop.Cluster != order.Cluster)
{
continue;
}
if (loop.EvaluateOptimalAddition(order, out Node lOpt, out double _, out double lTd, excluded))
{
if (TimeLeft >= lTd && lTd < bestDeltaTime)
{
bestNode = lOpt;
bestDeltaTime = lTd;
bestLoop = i;
}
}
}
if (order.JourneyTimeFromDump + order.JourneyTimeToDump + order.TimeToEmpty + 30 <= TimeLeft && order.JourneyTimeFromDump + order.JourneyTimeToDump + order.TimeToEmpty + 30 <= bestDeltaTime)
{
AddLoop();
TimeLeft -= 30;
bestLoop = Loops.Count - 1;
bestDeltaTime = order.JourneyTimeFromDump + order.JourneyTimeToDump + order.TimeToEmpty + 30;
bestNode = Loops[bestLoop].Start;
}
if (bestLoop == -1)
{
if (order.JourneyTimeFromDump + order.JourneyTimeToDump + order.TimeToEmpty + 30 <= TimeLeft) // Check if adding new loop helps
{
AddLoop();
TimeLeft -= 30;
bestLoop = Loops.Count - 1;
bestDeltaTime = order.JourneyTimeFromDump + order.JourneyTimeToDump + order.TimeToEmpty + 30;
bestNode = Loops[bestLoop].Start;
}
return(false);
}
return(true);
}
public void RemoveNode(Node n)
{
Order order = n.Data;
Duration -= order.TimeToEmpty + GD.JourneyTime[n.Prev.Data.MatrixId, order.MatrixId] + GD.JourneyTime[order.MatrixId, n.Next.Data.MatrixId];
Duration += GD.JourneyTime[n.Prev.Data.MatrixId, n.Next.Data.MatrixId];
//n.Remove();
Node p = n.Next;
n.Next.Prev = n.Prev;
n.Prev.Next = n.Next;
n.Prev = null;
n.Next = null;
RoomLeft += (order.NumContainers * order.VolPerContainer * 0.2);
Count--;
}
public Node(Order o)
{
IsDump = false;
Data = o;
}
public Node()
{
IsDump = true;
Data = GD.Dump;
Prev = Next = this;
}
public override double GetTotalDelta()
{
Order o = toDelete.Data;
return((delta - 4 * o.Frequency * o.TimeToEmpty) + 3 * o.Frequency * o.TimeToEmpty);
}
