public void AddJob(DriverNode driver, IList <JobNode> jobs)
{
if (DriverJobs != null)
{
DriverJobs.Add(new KeyValuePair <DriverNode, IList <JobNode> >(driver, jobs));
}
}
///// <summary>
///// Creates a route solution from a list of nodes
///// </summary>
///// <param name="nodes"></param>
///// <returns></returns>
public NodeRouteSolution CreateRouteSolution(IEnumerable <INode> nodes, DriverNode driverNode)
{
var routeSolution = new NodeRouteSolution
{
DriverNode = driverNode,
StartTime = driverNode.Driver.EarliestStartTime,
Nodes = nodes.ToList()
};
var allNodes = routeSolution.AllNodes;
// calculate route statistics
for (int i = 0; i < allNodes.Count; i++)
{
// create node plan
var node = allNodes[i];
// add node trip length
routeSolution.RouteStatistics += node.RouteStatistics;
var previousNode = i == 0 ? null : allNodes[i - 1];
if (previousNode != null)
{
var statistics = CalculateRouteStatistics(previousNode, node);
routeSolution.RouteStatistics += statistics;
}
}
return(routeSolution);
}
public void TestSerializeNullException()
{
IGraphController graphController = new GraphController(null);
IStorage storage = null;
IVisualNode node = new DriverNode(graphController, Configurations.DriverInitialTextValue);
Assert.Throws <ArgumentNullException>(() =>
{
node.Serialize(storage);
});
}
public void TestDeserilaizeOperationException()
{
IGraphController graphController = new GraphController(null);
IStorage storage = new BinaryStorage();
IVisualNode node = new DriverNode(graphController, Configurations.DriverInitialTextValue);
ulong signature = Utilities.MakeEightCC('T', 'E', 'S', 'T', ' ', ' ', ' ', ' ');
storage.WriteUnsignedInteger(signature, 21);
storage.Seek(0, SeekOrigin.Begin);
bool result = node.Deserialize(storage);
Assert.AreEqual(result, false);
}
public void TestRecordNodeModficationForUndo00()
{
GraphController graphController = new GraphController(null);
UndoRedoRecorder urr = new UndoRedoRecorder(graphController);
List <IVisualNode> nodeList = new List <IVisualNode>();
DriverNode node = new DriverNode(graphController);
nodeList.Add(node);
Assert.Throws <InvalidOperationException>(() =>
{
urr.RecordNodeModificationForUndo(nodeList);
});
}
/// <summary>
/// Generates node sequence iteration
/// </summary>
/// <param name="nodes"></param>
/// <param name="driverNode"> </param>
/// <returns></returns>
public virtual NodeRouteSolution GenerateRouteSolution(IList <INode> nodes, DriverNode driverNode)
{
IList <INode> processedNodes = new List <INode>();
INode currentNode = driverNode;
var startTime = driverNode.Driver.EarliestStartTime;
var currentNodeEndTime = startTime;
var cumulativeRouteStatistics = new RouteStatistics();
int exitCounter = 0;
while (exitCounter++ < 1000)
{
// getting avaiable nodes that have not been processed
var feasibleNodeTimings = GetFeasibleNodes(nodes, driverNode, processedNodes, currentNodeEndTime, cumulativeRouteStatistics);
if (!feasibleNodeTimings.Any())
{
break;
}
var feasibleNodeTimingsByNode = feasibleNodeTimings.ToDictionary(f => f.Node);
// build probability matrix for the available nodes
var probabilityData = _probabilityMatrix.BuildProbabilityDataMatrix(currentNode, feasibleNodeTimings);
// find a suitable node based on the cumulative probability
var selectedNode = (INode)_probabilityMatrix.GetNominatedElement(probabilityData);
processedNodes.Add(selectedNode);
currentNode = selectedNode;
// now we update the current node's end time
var selectedNodeTiming = feasibleNodeTimingsByNode[selectedNode];
if (processedNodes.Count == 1 && selectedNodeTiming.DepartureTime != currentNodeEndTime)
{
startTime = selectedNodeTiming.DepartureTime;
}
currentNodeEndTime = selectedNodeTiming.EndExecutionTime;
cumulativeRouteStatistics = selectedNodeTiming.CumulativeRouteStatistics;
}
// create solution object
var result = _routeService.CreateRouteSolution(processedNodes, driverNode);
result.StartTime = startTime;
return(result);
}
private bool PassesFilterCriteria(DriverNode driverNode, JobNode jobNode, List <INode> filteredAvailableNodes)
{
if (!driverNode.Driver.IsHazmat && jobNode.Job.IsHazmat)
{
return(false);
}
if (!driverNode.Driver.IsFlatbed && jobNode.Job.IsFlatbed)
{
return(false);
}
if (driverNode.Driver.Priority < jobNode.Job.Priority)
{
return(false);
}
return(true);
}
/// <summary>
/// Gets the best solution between a new list of <see cref="INode"/> and a current best <see cref="NodeRouteSolution"/>
/// </summary>
/// <param name="nodes"></param>
/// <param name="driverNode"> </param>
/// <param name="bestSolution"></param>
/// <returns>the best solution</returns>
public NodeRouteSolution GetBestFeasableSolution(IEnumerable <INode> nodes, DriverNode driverNode, NodeRouteSolution bestSolution)
{
// create solution
var routeSolution = CreateRouteSolution(driverNode, nodes);
// check feasibility
if (IsFeasableRouteSolution(routeSolution))
{
if (bestSolution != null)
{
routeSolution = GetBestSolution(bestSolution, routeSolution);
}
}
else
{
routeSolution = bestSolution;
}
return(routeSolution);
}
private void FillDrivers()
{
DriverNode resultAlias = null;
Employee employeeAlias = null;
driversList = UoW.Session.QueryOver <Employee>(() => employeeAlias)
.Where(
() => employeeAlias.Status != EmployeeStatus.IsFired &&
(employeeAlias.Category == EmployeeCategory.driver || employeeAlias.Category == EmployeeCategory.forwarder) &&
!employeeAlias.VisitingMaster
)
.SelectList(list => list
.Select(() => employeeAlias.Id).WithAlias(() => resultAlias.Id)
.Select(() => employeeAlias.Name).WithAlias(() => resultAlias.Name)
.Select(() => employeeAlias.LastName).WithAlias(() => resultAlias.LastName)
.Select(() => employeeAlias.Category).WithAlias(() => resultAlias.Category)
.Select(() => employeeAlias.FirstWorkDay).WithAlias(() => resultAlias.FirstWorkDay))
.OrderBy(e => e.LastName).Asc.ThenBy(x => x.Name).Asc
.TransformUsing(Transformers.AliasToBean <DriverNode>())
.List <DriverNode>();
}
public void TestHandleSaveGraphAndLoadGraph()
{
try
{
GraphController graphController1 = new GraphController(null);
IVisualNode node1 = new CodeBlockNode(graphController1, "Double Click and Type");
IVisualNode node2 = new DriverNode(graphController1, Configurations.DriverInitialTextValue);
IVisualNode node3 = new FunctionNode(graphController1, "", "-", "double,double");
IVisualNode node4 = new IdentifierNode(graphController1, "c");
string filePath = Path.GetTempPath() + "test.bin";
graphController1.DoSaveGraph(filePath);
GraphController graphController2 = new GraphController(null, filePath);
Assert.AreEqual(4, graphController2.GetVisualNodes().Count);
}
finally
{
File.Delete(Path.GetTempPath() + "test.bin");
}
}
public void TestSerializeDeserialize()
{
IGraphController graphController = new GraphController(null);
IStorage storage = new BinaryStorage();
IVisualNode node1 = new DriverNode(graphController, Configurations.DriverInitialTextValue);
IVisualNode node2 = new DriverNode(graphController, Configurations.DriverInitialTextValue);
node1.Serialize(storage);
storage.Seek(0, SeekOrigin.Begin);
node2.Deserialize(storage);
Assert.AreEqual(NodeType.Driver, node2.VisualType);
Assert.AreEqual(node1.NodeId, node2.NodeId);
Assert.AreEqual(true, ((DriverNode)node2).Dirty);
Assert.AreEqual(((DriverNode)node1).Text, ((DriverNode)node2).Text);
Assert.AreEqual(((DriverNode)node1).Caption, ((DriverNode)node2).Caption);
Assert.AreEqual(node1.X, node2.X);
Assert.AreEqual(node1.Y, node2.Y);
Assert.Null(node2.GetInputSlots());
Assert.AreEqual(1, node2.GetOutputSlots().Length);
}
private bool PassesFilterCriteria(DriverNode driverNode, JobNode jobNode)
{
if (!driverNode.Driver.IsHazmatEligible && jobNode.Job.IsHazmat)
{
return(false);
}
if (!driverNode.Driver.IsShortHaulEligible && jobNode.Job.IsShortHaul)
{
return(false);
}
if (!driverNode.Driver.IsLongHaulEligible && jobNode.Job.IsLongHaul)
{
return(false);
}
if (driverNode.Driver.OrderType > 0 && driverNode.Driver.OrderType > jobNode.Job.OrderType)
{
return(false);
}
return(true);
}
public bool JobNodeTimings(IList <Job> jobs, Driver driver, out List <NodeTiming> nodeTimings, out IList <int> ints)
{
nodeTimings = new List <NodeTiming>();
ints = new List <int>();
if (driver == null || jobs == null || !jobs.Any())
{
{
return(true);
}
}
var jobNodes = jobs.Select((job, i) => _jobNodeService.CreateJobNode(job, null, i != 0)).Cast <INode>().ToList();
var driverNode = new DriverNode(driver);
var processedNodes = new List <INode>();
var cumulativeRouteStatistics = new RouteStatistics();
//var routeSolution = GenerateRouteSolution(jobNodes, driverNode);
//GetFeasibleNodes(jobNodes, driverNode, processedNodes, )
//var isFirstStop = processedNodes.Count == 0;
//var currentNode = isFirstStop ? driverNode : processedNodes.Last();
// first check feasibility for driver to first node
var nodeTimingResult = _routeStatisticsService.GetNodeTiming(
driverNode, jobNodes.FirstOrDefault(), driverNode.WindowStart, cumulativeRouteStatistics);
if (!nodeTimingResult.IsFeasableTimeWindow)
{
// all are infeasible
{
ints = jobNodes.Select(p => p.Id).ToList();
return(true);
}
}
nodeTimings = new List <NodeTiming>()
{
nodeTimingResult
};
for (int i = 1; i < jobNodes.Count; i++)
{
var currentNode = (JobNode)jobNodes[i];
var lastNode = jobNodes[i - 1];
var iterationStartTime = nodeTimingResult.EndExecutionTime;
nodeTimingResult = _routeStatisticsService.GetNodeTiming(
lastNode, currentNode, iterationStartTime, cumulativeRouteStatistics);
nodeTimingResult.CumulativeRouteStatistics = cumulativeRouteStatistics + nodeTimingResult.CumulativeRouteStatistics;
if (_routeExitFunction.ExeedsExitCriteria(nodeTimingResult.CumulativeRouteStatistics, driverNode.Driver))
{
nodeTimingResult.IsFeasableTimeWindow = false;
}
nodeTimings.Add(nodeTimingResult);
}
var lastLeg = _routeStatisticsService.GetRouteStatistics(nodeTimingResult.Node, driverNode, nodeTimingResult.EndExecutionTime);
var finalRouteStatistics = nodeTimingResult.CumulativeRouteStatistics + lastLeg;
if (_routeExitFunction.ExeedsExitCriteria(finalRouteStatistics, driverNode.Driver))
{
nodeTimingResult.IsFeasableTimeWindow = false;
}
nodeTimings.Add(nodeTimingResult);
return(false);
}
public virtual NodeRouteSolution GenerateIterativeRouteSolution(IList <INode> nodes, DriverNode driverNode, bool reOrder = true)
{
IList <INode> processedNodes = new List <INode>();
INode currentNode = driverNode;
var startTime = driverNode.Driver.EarliestStartTimeSpan;
var currentNodeEndTime = startTime;
var cumulativeRouteStatistics = new RouteStatistics();
nodes = SortINodes(nodes, driverNode.Driver, reOrder).ToList();
int exitCounter = 0;
while (exitCounter++ < 1000)
{
nodes = nodes.Where(x => !processedNodes.Select(y => y.Id).ToList().Contains(x.Id)).ToList();
// getting avaiable nodes that have not been processed
if (!nodes.Any())
{
break;
}
var feasibleNodeTimingsList = SortINodes(nodes, driverNode.Driver, reOrder).ToList();
var firstHitFeasibleNodeTiming = feasibleNodeTimingsList.FirstOrDefault(y => y.WindowEnd > currentNodeEndTime);
if (firstHitFeasibleNodeTiming == null)
{
break;
}
var firstHitFeasibleNodeTimingNode = firstHitFeasibleNodeTiming;
var selectedNode = firstHitFeasibleNodeTimingNode;
var selectedJobNode = selectedNode is JobNode ? selectedNode as JobNode : null;
var processedRouteStops = processedNodes.SelectMany(x => x.RouteStops);
var provisionalRouteStops = new Queue <RouteStop>();
foreach (var processedRouteStop in processedRouteStops)
{
provisionalRouteStops.Enqueue(processedRouteStop);
}
foreach (var routeStop in selectedNode.RouteStops)
{
provisionalRouteStops.Enqueue(routeStop);
}
var tempJob = new Job
{
RouteStops = provisionalRouteStops.Select(x => x).ToList(),
IsHazmat = selectedJobNode != null && selectedJobNode.Job != null ? selectedJobNode.Job.IsHazmat : false
};
var tempJobNode = _jobNodeService.CreateJobNode(tempJob, driverNode.Driver.EarliestStartTimeSpan, false);
if (!tempJobNode.IsInvalid)
{
var serviceTimeIndex = _jobNodeService.GetMatrixIndex("ServiceTime");
var waitTimeIndex = _jobNodeService.GetMatrixIndex("WaitTime");
var travelTimeIndex = _jobNodeService.GetMatrixIndex("TravelTime");
var entryCount = tempJobNode.RouteStatisticsMatrix.GetLength(1);
var travelTime = TimeSpan.Zero;
var serviceTime = TimeSpan.Zero;
var waitTime = TimeSpan.Zero;
for (var i = 0; i < entryCount; i++)
{
travelTime += TimeSpan.FromSeconds(tempJobNode.RouteStatisticsMatrix[travelTimeIndex, i]);
serviceTime += TimeSpan.FromSeconds(tempJobNode.RouteStatisticsMatrix[serviceTimeIndex, i]);
waitTime += TimeSpan.FromSeconds(tempJobNode.RouteStatisticsMatrix[waitTimeIndex, i]);
}
var statistics = new RouteStatistics
{
TotalExecutionTime = serviceTime,
TotalIdleTime = waitTime,
TotalTravelTime = travelTime,
TotalQueueTime = TimeSpan.Zero
};
if (!_routeExitFunction.ExeedsExitCriteria(statistics, driverNode.Driver) &&
_routeExitFunction.MeetsPortCriteria(tempJobNode.RouteStops, driverNode.Driver) &&
PassesFilterCriteria(driverNode, tempJobNode, new List <INode>())
)
{
processedNodes.Add(selectedNode);
driverNode.Driver.EarliestStartTime = tempJobNode.WindowStart.Ticks;
}
else
{
nodes.RemoveAt(0);
}
}
else
{
nodes.RemoveAt(0);
}
}
// create solution object, adjust start time
var result = _routeService.CreateRouteSolution(driverNode, processedNodes);
var driverStartTicks = Math.Max(driverNode.Driver.EarliestStartTime, startTime.Ticks);
result.StartTime = TimeSpan.FromTicks(driverStartTicks);
var s = string.Join("\t", result.Nodes.Select(f => "[" + f.Id + "]").ToArray());
Console.WriteLine(s);
Console.WriteLine(result.RouteStatistics.ToString());
return(result);
}
/// <summary>
/// Generates node sequence iteration
/// </summary>
/// <param name="nodes"></param>
/// <param name="driverNode"> </param>
/// <returns></returns>
public virtual NodeRouteSolution GenerateRouteSolution(IList <INode> nodes, DriverNode driverNode)
{
IList <INode> processedNodes = new List <INode>();
INode currentNode = driverNode;
var startTime = driverNode.Driver.EarliestStartTimeSpan;
var currentNodeEndTime = startTime;
var cumulativeRouteStatistics = new RouteStatistics();
int exitCounter = 0;
while (exitCounter++ < 1000)
{
// getting avaiable nodes that have not been processed
var feasibleNodeTimings = GetFeasibleNodes(nodes, driverNode, processedNodes, currentNodeEndTime, cumulativeRouteStatistics);
if (!feasibleNodeTimings.Any())
{
break;
}
var feasibleNodeTimingsByNode = feasibleNodeTimings.ToDictionary(f => f.Node);
// build probability matrix for the available nodes
var probabilityData = _probabilityMatrix.BuildProbabilityDataMatrix(currentNode, feasibleNodeTimings);
// find a suitable node based on the cumulative probability
var selectedNode = (INode)_probabilityMatrix.GetNominatedElement(probabilityData);
selectedNode.DepartureTime = feasibleNodeTimingsByNode[selectedNode].DepartureTime; // set the Departure Time
// break if we nominated the driver node
if (selectedNode == driverNode)
{
break;
}
processedNodes.Add(selectedNode);
currentNode = selectedNode;
// now we update the current node's end time
var selectedNodeTiming = feasibleNodeTimingsByNode[selectedNode];
if (processedNodes.Count == 1 && selectedNodeTiming.DepartureTime != currentNodeEndTime.Ticks)
{
startTime = new TimeSpan(selectedNodeTiming.DepartureTime);
}
currentNodeEndTime = selectedNodeTiming.EndExecutionTime;
cumulativeRouteStatistics = selectedNodeTiming.CumulativeRouteStatistics;
var processedRouteStops = processedNodes.SelectMany(x => x.RouteStops);
var provisionalRouteStops = new Queue <RouteStop>();
foreach (var processedRouteStop in processedRouteStops)
{
provisionalRouteStops.Enqueue(processedRouteStop);
}
foreach (var routeStop in selectedNode.RouteStops)
{
provisionalRouteStops.Enqueue(routeStop);
}
var tempJob = new Job
{
RouteStops = provisionalRouteStops.Select(x => x).ToList()
};
var tempJobNode = _jobNodeService.CreateJobNode(tempJob, driverNode.Driver.EarliestStartTimeSpan, false);
if (!tempJobNode.IsInvalid)
{
var serviceTimeIndex = _jobNodeService.GetMatrixIndex("ServiceTime");
var waitTimeIndex = _jobNodeService.GetMatrixIndex("WaitTime");
var travelTimeIndex = _jobNodeService.GetMatrixIndex("TravelTime");
var entryCount = tempJobNode.RouteStatisticsMatrix.GetLength(1);
var travelTime = TimeSpan.Zero;
var serviceTime = TimeSpan.Zero;
var waitTime = TimeSpan.Zero;
for (var i = 0; i < entryCount; i++)
{
travelTime += TimeSpan.FromSeconds(tempJobNode.RouteStatisticsMatrix[travelTimeIndex, i]);
serviceTime += TimeSpan.FromSeconds(tempJobNode.RouteStatisticsMatrix[serviceTimeIndex, i]);
waitTime += TimeSpan.FromSeconds(tempJobNode.RouteStatisticsMatrix[waitTimeIndex, i]);
}
var statistics = new RouteStatistics
{
TotalExecutionTime = serviceTime,
TotalIdleTime = waitTime,
TotalTravelTime = travelTime,
TotalQueueTime = TimeSpan.Zero
};
if (!_routeExitFunction.ExeedsExitCriteria(statistics, driverNode.Driver))
{
processedNodes.Add(selectedNode);
driverNode.Driver.EarliestStartTime = tempJobNode.WindowStart.Ticks;
}
}
}
// create solution object, adjust start time
var result = _routeService.CreateRouteSolution(driverNode, processedNodes);
var driverStartTicks = Math.Max(driverNode.Driver.EarliestStartTime, startTime.Ticks);
result.StartTime = TimeSpan.FromTicks(driverStartTicks);
var s = string.Join("\t", result.Nodes.Select(f => "[" + f.Id + "]").ToArray());
Console.WriteLine(s);
Console.WriteLine(result.RouteStatistics.ToString());
return(result);
}
/// <summary>
/// Creates route assignments from the given trucks and jobs
/// </summary>
/// <param name="drivers">the list of drivers available to run routes</param>
/// <param name="defaultDriver">a default driver to use if there are more routes generated than drivers</param>
/// <param name="jobs">a list of jobs to optimize</param>
/// <returns></returns>
public virtual Solution BuildSolution(IList <Driver> drivers, Driver defaultDriver, IList <Job> jobs)
{
if (drivers == null)
{
throw new ArgumentNullException("drivers");
}
if (jobs == null)
{
throw new ArgumentNullException("jobs");
}
if (defaultDriver == null)
{
throw new ArgumentNullException("defaultDriver");
}
if (jobs.Count == 0)
{
throw new OptimizationException("Need at least one job to build solution");
}
if (!_initialized)
{
throw new OptimizationException("Optimizer not intialized. Call Initialize() prior to building solutions.");
}
if (_isExecuting)
{
//throw new OptimizationException("Cannot BuildSolution while another BuildSolution is executing.");
}
// begin execution
_isExecuting = true;
_isCancelling = false;
CurrentBestSolution = null;
// clear pheromone matrix
_pheromoneMatrix.Clear();
// Create driver nodes
var driverNodes = drivers.Select(driver => new DriverNode(driver)).ToList();
// Create job nodes
var jobNodes = jobs.Select((job, i) => _jobNodeService.CreateJobNode(job, defaultDriver.EarliestStartTimeSpan)).ToList();
if (!DisallowPlaceholderDriver)
{
// create placeholder drivers (for worst case scenario)
var placeholderDriversToCreate = jobNodes.Count() - driverNodes.Count();
if (placeholderDriversToCreate > 0)
{
var placeholderDriverNode = new DriverNode(defaultDriver);
for (int i = 0; i < placeholderDriversToCreate; i++)
{
driverNodes.Add(placeholderDriverNode);
}
}
}
// build solution
var bestSolution = BuildSolution(defaultDriver, jobNodes.Cast <INode>().ToList(), driverNodes);
// done executing
_isExecuting = false;
_isCancelling = false;
CurrentBestSolution = bestSolution;
return(bestSolution);
}
///// <summary>
///// Creates a route solution from a list of nodes
///// </summary>
///// <param name="nodes"></param>
///// <returns></returns>
public NodeRouteSolution CreateRouteSolution(DriverNode driverNode, IEnumerable <INode> nodes)
{
var startTime = driverNode.Driver.EarliestStartTimeSpan;
var firstJobNode = nodes.FirstOrDefault();
// adjust the start time
if (firstJobNode != null)
{
// there may have been waiting for the driver to leave, do not count that as idle time
// update the currentTime to the JobNode WindowEnd, less travel time
var connection = _nodeService.GetNodeConnection(driverNode, nodes.First());
if (firstJobNode.WindowEnd.Subtract(connection.RouteStatistics.TotalTravelTime) > startTime)
{
startTime = firstJobNode.WindowEnd.Subtract(connection.RouteStatistics.TotalTravelTime);
}
}
var routeSolution = new NodeRouteSolution
{
DriverNode = driverNode,
StartTime = startTime,
Nodes = nodes.ToList()
};
var allNodes = routeSolution.AllNodes;
var currentTime = startTime;
// calculate route statistics
for (int i = 0; i < allNodes.Count; i++)
{
// create node plan
var node = allNodes[i];
var previousNode = i > 0 ? allNodes[i - 1] : null;
// insert waiting time as per JobNode windows
if (i >= 1 && node is JobNode && previousNode is JobNode)
{
// there may have been waiting for the driver to leave, do not count that as idle time
// update the currentTime to the JobNode WindowEnd, less travel time
var connection = _nodeService.GetNodeConnection(previousNode, node);
if (node.WindowEnd.Subtract(connection.RouteStatistics.TotalTravelTime) > currentTime)
{
// waiting found
var waitingTime = node.WindowEnd.Subtract(currentTime);
var currentStatistics = routeSolution.RouteStatistics;
currentStatistics.TotalIdleTime = currentStatistics.TotalIdleTime.Add(waitingTime);
routeSolution.RouteStatistics = currentStatistics;
currentTime = currentTime.Add(waitingTime);
}
}
// add node trip length
var stats = _routeStatisticsService.GetRouteStatistics(node, currentTime, previousNode);
routeSolution.RouteStatistics += stats;
// currentTime = startTime + routeSolution.RouteStatistics.TotalTime;
if (previousNode != null)
{
var statistics = _routeStatisticsService.GetRouteStatistics(previousNode, node, currentTime);
routeSolution.RouteStatistics += statistics;
}
currentTime = startTime + routeSolution.RouteStatistics.TotalTime;
}
return(routeSolution);
}
public virtual List <NodeTiming> GetFeasibleNodes(IList <INode> availableNodes, DriverNode driverNode, IList <INode> processedNodes,
TimeSpan currentNodeEndTime, RouteStatistics cumulativeRouteStatistics)
{
var isFirstStop = (processedNodes.Count == 0);
var currentNode = isFirstStop ? driverNode : processedNodes.Last();
if (currentNode is JobNode)
{
;
}
var filteredAvailableNodes = new List <INode>();
// filter available nodes based on predefined criteria
foreach (var availableNode in availableNodes)
{
if (availableNode is JobNode)
{
//if (PassesFilterCriteria(driverNode, (JobNode)availableNode))
{
filteredAvailableNodes.Add(availableNode);
}
}
else
{
filteredAvailableNodes.Add(availableNode); // we are only filtering JobNodes
}
}
availableNodes = filteredAvailableNodes.ToList();
// get the node timings for all of the available nodes
var nodeTimings = availableNodes.Except(processedNodes)
.Select(nextNode => _nodeService.GetNodeTiming(currentNode, nextNode, currentNodeEndTime, cumulativeRouteStatistics))
.ToList();
var feasibleNodes = new List <NodeTiming>();
foreach (var nodeTiming in nodeTimings.Where(f => f.IsFeasableTimeWindow))
{
var finalConnection = _nodeService.GetNodeConnection(nodeTiming.Node, driverNode);
var finalRouteStatistics = nodeTiming.CumulativeRouteStatistics + finalConnection.RouteStatistics;
if (!_routeExitFunction.ExeedsExitCriteria(finalRouteStatistics, driverNode.Driver))
{
feasibleNodes.Add(nodeTiming);
}
}
return(feasibleNodes);
}
public virtual List <NodeTiming> GetFeasibleNodes(IList <INode> availableNodes, DriverNode driverNode, IList <INode> processedNodes,
TimeSpan currentNodeEndTime, RouteStatistics cumulativeRouteStatistics)
{
var isFirstStop = (processedNodes.Count == 0);
var currentNode = isFirstStop ? driverNode : processedNodes.Last();
var filteredAvailableNodes = new List <INode>();
var updatedNodes = new List <INode>();
if (currentNode is JobNode)
{
// update nodes to adjust for potentially shortened execution time
foreach (var n in availableNodes)
{
if (n is JobNode)
{
var node = _jobNodeService.CreateJobNode(((JobNode)n).Job, currentNodeEndTime,
IsExecutionTimeIgnored(currentNode, n));
updatedNodes.Add(node);
}
else
{
updatedNodes.Add(n);
}
}
availableNodes = updatedNodes.ToList();
}
// filter available nodes based on predefined criteria
foreach (var availableNode in availableNodes)
{
if (availableNode is JobNode)
{
if (PassesFilterCriteria(driverNode, (JobNode)availableNode, filteredAvailableNodes))
{
filteredAvailableNodes.Add(availableNode);
}
else
{
;
}
}
else
{
filteredAvailableNodes.Add(availableNode); // we are only filtering JobNodes
}
}
availableNodes = filteredAvailableNodes.ToList();
// get the node timings for all of the available nodes
var unprocessedNodes = availableNodes.Where(x => !processedNodes.Select(y => y.Id).ToList().Contains(x.Id));
unprocessedNodes = new List <INode>();
foreach (var availableNode in availableNodes)
{
var processedNodesIds = processedNodes.Select(x => x.Id);
if (!processedNodesIds.Contains(availableNode.Id))
{
unprocessedNodes = unprocessedNodes.Concat(new List <INode> {
availableNode
});
}
}
var nodeTimings = unprocessedNodes.Select(nextNode =>
_routeStatisticsService.GetNodeTiming(currentNode, nextNode, currentNodeEndTime, cumulativeRouteStatistics));
var feasibleNodes = new List <NodeTiming>();
foreach (var nodeTiming in nodeTimings.Where(f => f.IsFeasableTimeWindow))
{
// calculate for return home to driver node
var lastLeg = _routeStatisticsService.GetRouteStatistics(nodeTiming.Node, driverNode, nodeTiming.EndExecutionTime);
var finalRouteStatistics = nodeTiming.CumulativeRouteStatistics + lastLeg;
if (!_routeExitFunction.ExeedsExitCriteria(finalRouteStatistics, driverNode.Driver))
{
feasibleNodes.Add(nodeTiming);
}
}
return(feasibleNodes);
}
public void MakeVariableSelector()
{
MethodInfo privMethod = logixNodeSelector.GetType().GetMethod("BuildUI", BindingFlags.NonPublic | BindingFlags.Instance);
//privMethod.Invoke(logixNodeSelector,new object[] { "LogiX/Variables" });
//FieldInfo fi = typeof(LogixNodeSelector).GetField("_container", BindingFlags.NonPublic | BindingFlags.Instance);
//Slot container = (Slot)fi.GetValue(logixNodeSelector);
Slot variableNodesContainer = nodesContainerSlot[0][0][0];
Slot typeSelectTemplate = mainSlot.AddSlot("Type select template");
Slot variableNodesContainer2 = variableNodesContainer.Duplicate();
variableNodesContainer2.AttachComponent <DynamicVariableSpace>();
DynamicValueVariable <string> genericType = variableNodesContainer2.AttachComponent <DynamicValueVariable <string> >();
genericType.VariableName.Value = "GenericType";
variableNodesContainer2.SetParent(typeSelectTemplate);
variableNodesContainer2[0].Destroy();
for (int i = 0; i < variableNodesContainer2.ChildrenCount; i++)
{
Debug.Log(variableNodesContainer2[i]);
Slot s = variableNodesContainer2[i];
var buttonRelay = s.GetComponent <ButtonRelay <string> >();
ValueField <string> store = s.AttachComponent <ValueField <string> >();
Debug.Log(buttonRelay.Argument.Value);
//store.Value.Value = LogixHelper.GetNodeVisualType(WorkerManager.GetType(buttonRelay.Argument.Value)).ToString();
Type type = WorkerManager.GetType(buttonRelay.Argument.Value);
Image componentInChildren = s.GetComponentInChildren <Image>((Predicate <Image>)null, false);
System.Type nodeVisualType = LogixHelper.GetNodeVisualType(type);
componentInChildren.Sprite.Target = (IAssetProvider <Sprite>)LogixHelper.GetTypeSprite(this.World, nodeVisualType.GetDimensions(), typeof(Delegate).IsAssignableFrom(nodeVisualType));
componentInChildren.PreserveAspect.Value = false;
store.Value.Value = BaseX.TypeHelper.TryGetAlias(type) ?? type.FullName;
DynamicValueVariable <string> dynamicvar = s.AttachComponent <DynamicValueVariable <string> >();
dynamicvar.VariableName.Value = "GenericType";
FormatString formatString = s.AttachComponent <FormatString>();
formatString.Parameters.Add();
formatString.Parameters.Add();
Cast_string_To_object cast1 = s.AttachComponent <Cast_string_To_object>();
cast1.In.Value = dynamicvar.Value.ReferenceID;
Cast_string_To_object cast2 = s.AttachComponent <Cast_string_To_object>();
cast2.In.Value = store.Value.ReferenceID;
formatString.Parameters[0].Value = cast1.ReferenceID;
formatString.Parameters[1].Value = cast2.ReferenceID;
ValueField <string> format = s.AttachComponent <ValueField <string> >();
format.Value.Value = "{0}[{1}]";
formatString.Format.Value = format.Value.ReferenceID;
DriverNode <string> driver = s.AttachComponent <DriverNode <string> >();
driver.Source.Value = formatString.Str.ReferenceID;
driver.DriveTarget.Target = buttonRelay.Argument;
}
//this.RunSynchronously(() =>
//{
// variableNodesContainer2.ForeachChild((Action<FrooxEngine.Slot>) (s =>
// {
// Debug.Log(s);
// //var buttonRelay = s.GetComponent<ButtonRelay<string>>();
// //Debug.Log(buttonRelay.ToString());
// //ValueField<string> store = s.AttachComponent<ValueField<string>>();
// //store.Value.Value = LogixHelper.GetNodeVisualType(WorkerManager.GetType(buttonRelay.Argument.Value)).ToString();
// //store.Value.Value = Type.GetType(buttonRelay.Argument.Value).GetContentType().ToString();
// //Debug.Log(buttonRelay.Argument.Value);
// //store.Value.Value = buttonRelay.Argument;
// //store.Value.Value = typeof(bool2).ToString();
// //DynamicValueVariable<string> dynamicvar = s.AttachComponent<DynamicValueVariable<string>>();
// //dynamicvar.VariableName.Value = "GenericType";
// //FormatString formatString = s.AttachComponent<FormatString>();
// //formatString.Parameters.Add();
// //formatString.Parameters.Add();
// //Cast_string_To_object cast1 = s.AttachComponent<Cast_string_To_object>();
// //cast1.In.Value = dynamicvar.Value.ReferenceID;
// //Cast_string_To_object cast2 = s.AttachComponent<Cast_string_To_object>();
// //cast2.In.Value = store.Value.ReferenceID;
// //formatString.Parameters[0].Value = cast1.ReferenceID;
// //formatString.Parameters[1].Value = cast2.ReferenceID;
// //ValueField<string> format = s.AttachComponent<ValueField<string>>();
// //format.Value.Value = "{0}[{1}]";
// //formatString.Format.Value = format.Value.ReferenceID;
// //DriverNode<string> driver = s.AttachComponent<DriverNode<string>>();
// //driver.Source.Value = formatString.Str.ReferenceID;
// //driver.DriveTarget.Target = buttonRelay.Argument;
// }));
//});
privMethod.Invoke(logixNodeSelector, new object[] { "LogiX", false });
}
/// <summary>
/// Creates route assignments from the given trucks and jobs
/// </summary>
/// <param name="drivers"></param>
/// <param name="defaultDriver"> </param>
/// <param name="jobs"></param>
/// <returns></returns>
public virtual Solution BuildSolution(IList <Driver> drivers, Driver defaultDriver, IList <Job> jobs)
{
if (drivers == null)
{
throw new ArgumentNullException("drivers");
}
if (jobs == null)
{
throw new ArgumentNullException("jobs");
}
if (defaultDriver == null)
{
throw new ArgumentNullException("defaultDriver");
}
if (jobs.Count == 0)
{
throw new OptimizationException("Need at least one job to build solution");
}
if (!_initialized)
{
throw new OptimizationException("Optimizer not intialized. Call Initialize() prior to building solutions.");
}
_isCancelling = false;
// clear pheromone matrix
_pheromoneMatrix.Clear();
// Create driver nodes
var driverNodes = drivers.Select(driver => new DriverNode(driver))
.OrderBy(f => _randomNumberGenerator.Next())
.ToList();
foreach (var driverNode in driverNodes)
{
driverNode.Priority = 1; // init priority
}
// Create job nodes
foreach (var job in jobs)
{
switch (job.OrderType)
{
case 3:
job.Priority = 1;
break;
case 2:
job.Priority = 2;
break;
case 1:
job.Priority = 3;
break;
default:
job.Priority = 1;
break;
}
}
var jobNodes = new List <JobNode>();
foreach (var job in jobs.OrderBy(f => _randomNumberGenerator.Next()))
{
var jobNode = _nodeFactory.CreateJobNode(job); // create node, set priority
jobNode.RouteStatistics = _routeStopService.CalculateRouteStatistics(jobNode.RouteStops);
jobNodes.Add(jobNode);
}
// create dummy drivers (for worst case scenario)
var dummyDriversToCreate = jobNodes.Count() - driverNodes.Count();
if (dummyDriversToCreate > 0)
{
var dummyDriverNode = new DriverNode(defaultDriver);
for (int i = 0; i < dummyDriversToCreate; i++)
{
driverNodes.Add(dummyDriverNode);
}
}
// build solution
var bestSolution = BuildSolution(defaultDriver, jobNodes.Cast <INode>().ToList(), driverNodes);
_isCancelling = false;
return(bestSolution);
}
