private void TraverseDemandToProviderGraph(INode node,
IStackSet <INode> visitedProductionOrders)
{
if (node.GetEntity().GetType() == typeof(ProductionOrderBom))
{
// remove, ProductionOrderBoms will be ignored and replaced by operations
RemoveNode(node, true);
}
else if (node.GetEntity().GetType() == typeof(ProductionOrder) &&
visitedProductionOrders.Contains(node) == false)
{
// insert it like it is in ProductionOrderToOperationGraph
OperationGraph operationGraph =
new OperationGraph((ProductionOrder)node.GetEntity());
ReplaceNodeByDirectedGraph(node, operationGraph);
visitedProductionOrders.Push(node);
}
INodes successorNodes = GetSuccessorNodes(node);
if (successorNodes == null)
{
return;
}
foreach (var successor in successorNodes)
{
TraverseDemandToProviderGraph(successor, visitedProductionOrders);
}
}
public void TestGetEdges()
{
IDirectedGraph <INode> directedGraph = new DirectedGraph();
INode[] nodes = EntityFactory.CreateDummyNodes(3);
INode a = nodes[0];
INode b = nodes[1];
INode c = nodes[2];
// create a -> b -> c
IEdge ab = new Edge(a, b);
IEdge bc = new Edge(b, c);
directedGraph.AddEdge(ab);
directedGraph.AddEdge(bc);
List <IEdge> expectedEdges = new List <IEdge>();
expectedEdges.Add(ab);
expectedEdges.Add(bc);
IStackSet <IEdge> actualEdges = directedGraph.GetEdges();
foreach (var actualEdge in actualEdges)
{
Assert.True(expectedEdges.Contains(actualEdge),
$"I have not added this edge {actualEdge}. Where comes that from?");
}
foreach (var expectedEdge in expectedEdges)
{
Assert.True(actualEdges.Contains(expectedEdge),
$"This edge {expectedEdge} was not returned.");
}
}
/**
* Bottom-Up-Traversal
*/
private void ValidatePredecessorOperationsTransitionTimeIsCorrect(
IStackSet <ProductionOrderOperation> predecessorOperations,
ProductionOrderOperation lastOperation,
IDirectedGraph <INode> operationGraph,
IStackSet <INode> traversedOperations)
{
if (predecessorOperations == null)
{
return;
}
foreach (var currentPredecessor in predecessorOperations)
{
if (currentPredecessor.GetType() == typeof(ProductionOrderOperation))
{
ProductionOrderOperation currentOperation = currentPredecessor;
traversedOperations.Push(new Node(currentPredecessor));
// transition time MUST be before the start of Operation
int expectedStartBackwardLowerLimit =
lastOperation.GetValue().EndBackward.GetValueOrDefault() +
TransitionTimer.GetTransitionTimeFactor() *
currentOperation.GetValue().Duration;
int actualStartBackward = currentOperation.GetValue().StartBackward
.GetValueOrDefault();
Assert.True(actualStartBackward >= expectedStartBackwardLowerLimit,
$"The transition time between the operations is not correct: " +
$"expectedStartBackward: {expectedStartBackwardLowerLimit}, actualStartBackward {actualStartBackward}");
INodes predecessorNodesRecursive =
operationGraph.GetPredecessorNodesRecursive(new Node(currentPredecessor));
if (predecessorNodesRecursive != null)
{
IStackSet <ProductionOrderOperation> newPredecessorNodes =
new StackSet <ProductionOrderOperation>(
predecessorNodesRecursive.Select(x =>
(ProductionOrderOperation)x.GetEntity()));
ValidatePredecessorOperationsTransitionTimeIsCorrect(newPredecessorNodes,
currentOperation, operationGraph, traversedOperations);
}
}
else
{
throw new MrpRunException(
"ProductionOrderToOperationGraph should only contain productionOrders/operations.");
}
}
}
public void TestBackwardSchedulingTransitionTimeBetweenOperationsIsCorrect(
string testConfigurationFileName)
{
InitThisTest(testConfigurationFileName);
IDbTransactionData dbTransactionData =
ZppConfiguration.CacheManager.ReloadTransactionData();
IDirectedGraph <INode> operationGraph =
new OperationGraph(new OrderOperationGraph());
IStackSet <INode> innerLeafs =
operationGraph.GetLeafNodes().ToStackSet();
IStackSet <INode> traversedNodes = new StackSet <INode>();
foreach (var leaf in innerLeafs)
{
INodes predecessorNodesRecursive =
operationGraph.GetPredecessorNodesRecursive(leaf);
IStackSet <ProductionOrderOperation> newPredecessorNodes =
new StackSet <ProductionOrderOperation>(
predecessorNodesRecursive.Select(x =>
(ProductionOrderOperation)x.GetEntity()));
ProductionOrderOperation
lastOperation = (ProductionOrderOperation)leaf.GetEntity();
ValidatePredecessorOperationsTransitionTimeIsCorrect(newPredecessorNodes,
lastOperation, operationGraph, traversedNodes);
traversedNodes.Push(leaf);
}
int expectedTraversedOperationCount =
new Stack <ProductionOrderOperation>(
dbTransactionData.ProductionOrderOperationGetAll()).Count();
int actualTraversedOperationCount = traversedNodes.Count();
Assert.True(actualTraversedOperationCount.Equals(expectedTraversedOperationCount),
$"expectedTraversedOperationCount {expectedTraversedOperationCount} " +
$"doesn't equal actualTraversedOperationCount {actualTraversedOperationCount}'");
}
public override string ToString()
{
string mystring = "";
IStackSet <IEdge> edges = GetEdges();
if (edges == null)
{
return(mystring);
}
foreach (var edge in edges)
{
string tailsGraphvizString =
Graphviz.GetGraphizString(edge.GetTailNode().GetEntity());
string headsGraphvizString =
Graphviz.GetGraphizString(edge.GetHeadNode().GetEntity());
mystring += $"\"{tailsGraphvizString}\" -> " + $"\"{headsGraphvizString}\"";
mystring += ";" + Environment.NewLine;
// }
}
return(mystring);
}
