public static void AddOrder(int OrderNumber, Order Order)
{
if (Orders == null)
Orders = new Dictionary<int, Order>();
Orders.Add(OrderNumber, Order);
}
public void AddOrder(Order order)
{
if (order.OrderNumber == 0)
return;
int LastMatrixID = 287;
int NewMatrixID = order.MatrixID;
int PreviousMatrixID = Orders.Count == 1 ? LastMatrixID : Orders[Orders.Count - 2].MatrixID;
double OldTravelTime = TravelTime;
TravelTime -= Data.DistanceMatrix[PreviousMatrixID, LastMatrixID].TravelTime;
TravelTime += Data.DistanceMatrix[PreviousMatrixID, NewMatrixID].TravelTime;
TravelTime += Data.DistanceMatrix[NewMatrixID, LastMatrixID].TravelTime;
TravelTime += order.EmptyingTimeInSeconds;
Weight += order.VolumePerContainer * order.NumberOfContainers;
Orders.Insert(Orders.Count - 1, order);
order.AddOrderOccurrence(this);
if (partOfSolution != null)
{
partOfSolution.TravelTimeScore -= OldTravelTime - TravelTime;
partOfSolution.AddPlannedOccurrence(order.OrderNumber, this);
}
}
public OrderTracker(Order Order, List<Days> OrderDayRestrictions)
{
this.Order = Order;
this.OrderNumber = Order.OrderNumber;
this.OrderDayRestrictions = new List<Days>(OrderDayRestrictions);
this.OrderDayOccurrences = Days.None;
}
public void AddOrderAt(Order newOrder, Order orderToInsertAfter)
{
if (newOrder.OrderNumber == 0 || orderToInsertAfter.OrderNumber == 0)
return;
int IndexOfOrderToInsertAfter = Orders.FindIndex(o => o.OrderNumber == orderToInsertAfter.OrderNumber);
if (IndexOfOrderToInsertAfter == -1)
return;
if (IndexOfOrderToInsertAfter >= Orders.Count - 2)
{
AddOrder(newOrder);
return;
}
int NextMatrixID = Orders[IndexOfOrderToInsertAfter + 1].MatrixID;
int NewMatrixID = newOrder.MatrixID;
int PreviousMatrixID = orderToInsertAfter.MatrixID;
double OldTravelTime = TravelTime;
TravelTime -= Data.DistanceMatrix[PreviousMatrixID, NextMatrixID].TravelTime;
TravelTime += Data.DistanceMatrix[PreviousMatrixID, NewMatrixID].TravelTime;
TravelTime += Data.DistanceMatrix[NewMatrixID, NextMatrixID].TravelTime;
TravelTime += newOrder.EmptyingTimeInSeconds;
Weight += newOrder.VolumePerContainer * newOrder.NumberOfContainers;
Orders.Insert(IndexOfOrderToInsertAfter + 1, newOrder);
newOrder.AddOrderOccurrence(this);
if (partOfSolution != null)
{
partOfSolution.TravelTimeScore -= OldTravelTime - TravelTime;
partOfSolution.AddPlannedOccurrence(newOrder.OrderNumber, this);
}
}
private bool CanAddOrderCheck(Order order)
{
if (order.OrderNumber == 0)
return false;
if (Orders.Contains(order))
return false;
if (Weight + (order.VolumePerContainer * order.NumberOfContainers) > 100000)
return false;
return order.CanBeAddedOnDay(this.Day);
}
public void SwapOrders(Order firstOrder, Order secondOrder, Order thirdOrder)
{
if (firstOrder.OrderNumber == 0 || secondOrder.OrderNumber == 0 || thirdOrder.OrderNumber == 0)
return;
int indexOfTheFirstOrder = Orders.FindIndex(o => o.OrderNumber == firstOrder.OrderNumber);
int indexOfTheSecondOrder = Orders.FindIndex(o => o.OrderNumber == secondOrder.OrderNumber);
int indexOfTheThirdOrder = Orders.FindIndex(o => o.OrderNumber == thirdOrder.OrderNumber);
if (indexOfTheFirstOrder == -1 || indexOfTheSecondOrder == -1 || indexOfTheThirdOrder == -1)
return;
if (indexOfTheFirstOrder > indexOfTheSecondOrder)
{
if (indexOfTheFirstOrder > indexOfTheThirdOrder)
{
if (indexOfTheSecondOrder > indexOfTheThirdOrder)
{
AddOrderAt(secondOrder, firstOrder);
RemoveOrder(firstOrder);
AddOrderAt(thirdOrder, secondOrder);
RemoveOrder(secondOrder);
AddOrderAt(firstOrder, thirdOrder);
RemoveOrder(thirdOrder);
}
else
{
AddOrderAt(secondOrder, firstOrder);
RemoveOrder(firstOrder);
AddOrderAt(firstOrder, thirdOrder);
RemoveOrder(thirdOrder);
AddOrderAt(thirdOrder, secondOrder);
RemoveOrder(secondOrder);
}
}
else
{
AddOrderAt(firstOrder, thirdOrder);
RemoveOrder(thirdOrder);
AddOrderAt(secondOrder, firstOrder);
RemoveOrder(firstOrder);
AddOrderAt(thirdOrder, secondOrder);
RemoveOrder(secondOrder);
}
}
else
{
if (indexOfTheSecondOrder > indexOfTheThirdOrder)
{
if (indexOfTheFirstOrder > indexOfTheThirdOrder)
{
AddOrderAt(thirdOrder, secondOrder);
RemoveOrder(secondOrder);
AddOrderAt(secondOrder, firstOrder);
RemoveOrder(firstOrder);
AddOrderAt(firstOrder, thirdOrder);
RemoveOrder(thirdOrder);
}
else
{
AddOrderAt(thirdOrder, secondOrder);
RemoveOrder(secondOrder);
AddOrderAt(firstOrder, thirdOrder);
RemoveOrder(thirdOrder);
AddOrderAt(secondOrder, firstOrder);
RemoveOrder(firstOrder);
}
}
else
{
AddOrderAt(firstOrder, thirdOrder);
RemoveOrder(thirdOrder);
AddOrderAt(thirdOrder, secondOrder);
RemoveOrder(secondOrder);
AddOrderAt(secondOrder, firstOrder);
RemoveOrder(firstOrder);
}
}
}
public void RemoveOrder(Order order)
{
if (order.OrderNumber == 0)
return;
int OldMatrixID = order.MatrixID;
int indexOfOldOrder = Orders.FindIndex(o => o.OrderNumber == order.OrderNumber);
int PreviousMatrixID = (indexOfOldOrder - 1) >= 0 ? Orders[indexOfOldOrder - 1].MatrixID : 287;
int NextMatrixID = indexOfOldOrder < Orders.Count - 2 ? Orders[indexOfOldOrder + 1].MatrixID : 287;
double OldTravelTime = TravelTime;
TravelTime -= Data.DistanceMatrix[OldMatrixID, NextMatrixID].TravelTime;
TravelTime -= Data.DistanceMatrix[PreviousMatrixID, OldMatrixID].TravelTime;
TravelTime += Data.DistanceMatrix[PreviousMatrixID, NextMatrixID].TravelTime;
TravelTime -= order.EmptyingTimeInSeconds;
Weight -= order.VolumePerContainer * order.NumberOfContainers;
Orders.Remove(order);
order.RemoveOrderOccurrence(this);
if (partOfSolution != null)
{
partOfSolution.TravelTimeScore -= OldTravelTime - TravelTime;
partOfSolution.RemovePlannedOccurrence(order.OrderNumber, this);
}
}
public void HalfSwapOrders(Order firstOrder, Order secondOrder, Order thirdOrder)
{
RemoveOrder(thirdOrder);
AddOrderAt(thirdOrder, secondOrder);
RemoveOrder(secondOrder);
AddOrderAt(secondOrder, firstOrder);
}
public bool CanSwapOrderFromDifferentRoutes(Order newOrder, Order oldOrder, double timeLimit = 43200.0d)
{
if (newOrder.OrderNumber == 0 || oldOrder.OrderNumber == 0)
return false;
int tempWeight = Weight;
tempWeight -= oldOrder.VolumePerContainer * oldOrder.NumberOfContainers;
tempWeight += newOrder.VolumePerContainer * newOrder.NumberOfContainers;
if (tempWeight > 100000)
return false;
int oldOrderIndex = Orders.FindIndex(o => o.OrderNumber == oldOrder.OrderNumber);
int preOldMatrixID = Orders[oldOrderIndex == 0 ? Orders.Count - 1 : oldOrderIndex - 1].MatrixID;
int postOldMatrixID = Orders[oldOrderIndex + 1].MatrixID;
double tempTT = TravelTime;
tempTT -= Data.DistanceMatrix[preOldMatrixID, oldOrder.MatrixID].TravelTime;
tempTT -= Data.DistanceMatrix[oldOrder.MatrixID, postOldMatrixID].TravelTime;
tempTT += Data.DistanceMatrix[preOldMatrixID, newOrder.MatrixID].TravelTime;
tempTT += Data.DistanceMatrix[newOrder.MatrixID, postOldMatrixID].TravelTime;
tempTT -= oldOrder.EmptyingTimeInSeconds;
tempTT += newOrder.EmptyingTimeInSeconds;
return tempTT < timeLimit;
}
public bool CanSwapOrder(Order firstOrder, Order secondOrder, Order thirdOrder, double timeLimit = 43200.0d)
{
if (firstOrder.OrderNumber == 0 || secondOrder.OrderNumber == 0 || secondOrder.OrderNumber == 0)
return false;
int firstOrderIndex = Orders.FindIndex(o => o.OrderNumber == firstOrder.OrderNumber);
int preFirstOrderIndex = firstOrderIndex == 0 ? Orders.Count - 1 : firstOrderIndex - 1;
int secondOrderIndex = Orders.FindIndex(o => o.OrderNumber == secondOrder.OrderNumber);
int preSecondOrderIndex = secondOrderIndex == 0 ? Orders.Count - 1 : secondOrderIndex - 1;
int thirdOrderIndex = Orders.FindIndex(o => o.OrderNumber == thirdOrder.OrderNumber);
int preThirdOrderIndex = thirdOrderIndex == 0 ? Orders.Count - 1 : thirdOrderIndex - 1;
int preFirstMatrixID = Orders[preFirstOrderIndex].MatrixID;
int firstOrderMatrixID = firstOrder.MatrixID;
int postFirstMatrixID = Orders[firstOrderIndex + 1].MatrixID;
int preSecondMatrixID = Orders[preSecondOrderIndex].MatrixID;
int secondOrderMatrixID = secondOrder.MatrixID;
int postSecondMatrixID = Orders[secondOrderIndex + 1].MatrixID;
int preThirdMatrixID = Orders[preThirdOrderIndex].MatrixID;
int thirdOrderMatrixID = thirdOrder.MatrixID;
int postThirdMatrixID = Orders[thirdOrderIndex + 1].MatrixID;
double tempTT = TravelTime;
tempTT -= Data.DistanceMatrix[preFirstMatrixID, firstOrderMatrixID].TravelTime;
tempTT -= Data.DistanceMatrix[firstOrderMatrixID, postFirstMatrixID].TravelTime;
tempTT += Data.DistanceMatrix[preFirstMatrixID, thirdOrderMatrixID].TravelTime;
tempTT += Data.DistanceMatrix[thirdOrderMatrixID, postFirstMatrixID].TravelTime;
tempTT -= Data.DistanceMatrix[preSecondMatrixID, secondOrderMatrixID].TravelTime;
tempTT -= Data.DistanceMatrix[secondOrderMatrixID, postSecondMatrixID].TravelTime;
tempTT += Data.DistanceMatrix[preSecondMatrixID, firstOrderMatrixID].TravelTime;
tempTT += Data.DistanceMatrix[firstOrderMatrixID, postSecondMatrixID].TravelTime;
tempTT -= Data.DistanceMatrix[preThirdMatrixID, thirdOrderMatrixID].TravelTime;
tempTT -= Data.DistanceMatrix[thirdOrderMatrixID, postThirdMatrixID].TravelTime;
tempTT += Data.DistanceMatrix[preThirdMatrixID, secondOrderMatrixID].TravelTime;
tempTT += Data.DistanceMatrix[secondOrderMatrixID, postThirdMatrixID].TravelTime;
return tempTT < timeLimit;
}
public bool CanAddOrderAtStart(Order order, double timeLimit = 43200.0d)
{
if (CanAddOrderCheck(order))
{
double tempTT = TravelTime;
tempTT -= Data.DistanceMatrix[287, Orders[0].MatrixID].TravelTime;
tempTT += Data.DistanceMatrix[287, order.MatrixID].TravelTime;
tempTT += Data.DistanceMatrix[order.MatrixID, Orders[0].MatrixID].TravelTime;
tempTT += order.EmptyingTimeInSeconds;
return tempTT < timeLimit;
}
else
return false;
}
public bool CanAddOrderAfter(Order order, Order orderToInsertAfter, double timeLimit = 43200.0d)
{
if (orderToInsertAfter.OrderNumber == 0)
return false;
if (CanAddOrderCheck(order))
{
for (int i = 0; i < Orders.Count; i++)
if (Orders[i] == orderToInsertAfter)
{
double tempTT = TravelTime;
int PreviousMatrixID = Orders[i].MatrixID;
int NextMatrixID = Orders[i + 1].MatrixID;
tempTT -= Data.DistanceMatrix[PreviousMatrixID, NextMatrixID].TravelTime;
tempTT += Data.DistanceMatrix[PreviousMatrixID, order.MatrixID].TravelTime;
tempTT += Data.DistanceMatrix[order.MatrixID, NextMatrixID].TravelTime;
tempTT += order.EmptyingTimeInSeconds;
return tempTT < timeLimit;
}
return false;
}
else
return false;
}
public bool CanAddOrder(Order order, double timeLimit = 43200.0d)
{
if (CanAddOrderCheck(order))
{
double tempTT = TravelTime;
int PreviousMatrixID = Orders.Count == 1 ? 287 : Orders[Orders.Count - 2].MatrixID;
tempTT -= Data.DistanceMatrix[PreviousMatrixID, 287].TravelTime;
tempTT += Data.DistanceMatrix[PreviousMatrixID, order.MatrixID].TravelTime;
tempTT += Data.DistanceMatrix[order.MatrixID, 287].TravelTime;
tempTT += order.EmptyingTimeInSeconds;
return tempTT < timeLimit;
}
else
return false;
}
public void RemoveOrderFromCluster(Order toRemove)
{
toRemove.RemoveAvailableOrderFromCluster();
AvailableOrdersInCluster.Remove(toRemove);
}
public void AddOrderToCluster(Order toAdd)
{
AvailableOrdersInCluster.Add(toAdd);
toAdd.PutInCluster(this);
}
