public GanttChart(IDirectedGraph <INode> orderOperationGraph)
{
Dictionary <Id, List <Interval> > groups = new Dictionary <Id, List <Interval> >();
foreach (var graphNode in orderOperationGraph.GetNodes())
{
IScheduleNode node = graphNode.GetNode().GetEntity();
if (node.GetType() != typeof(ProductionOrderOperation) && node.GetType() != typeof(PurchaseOrderPart))
{
continue;
}
GanttChartBar ganttChartBar = new GanttChartBar();
ganttChartBar.operation = node.GetId().ToString();
ganttChartBar.operationId = node.GetId().ToString();
ganttChartBar.resource = DetermineFreeGroup(groups,
new Interval(node.GetId(), node.GetStartTimeBackward(), node.GetEndTimeBackward())).ToString();
;
ganttChartBar.start = node.GetStartTimeBackward().GetValue().ToString();
ganttChartBar.end = node.GetEndTimeBackward().GetValue().ToString();
ganttChartBar.groupId = ganttChartBar.resource;
AddGanttChartBar(ganttChartBar);
}
}
public string GetGraphizString(IScheduleNode node)
{
switch (node)
{
case StockExchangeProvider t1:
return(GetGraphizString(t1));
case PurchaseOrderPart t2:
return(GetGraphizString(t2));
case ProductionOrder t3:
return(GetGraphizString(t3));
case ProductionOrderOperation t4:
return(GetGraphizString(t4));
case StockExchangeDemand t5:
return(GetGraphizString(t5));
case ProductionOrderBom t6:
return(GetGraphizString(t6));
case CustomerOrderPart t7:
return(GetGraphizString(t7));
case Node t8:
throw new MrpRunException("Call getEntity() before calling this method.");
default: return(node.ToString());
}
}
public void TestGetAny()
{
IStackSet <IScheduleNode> stackSet = new StackSet <IScheduleNode>();
IScheduleNode testNumber = new DummyNode(1);
IScheduleNode testNumber2 = new DummyNode(5);
stackSet.Push(testNumber);
stackSet.Push(testNumber2);
IScheduleNode poppedElement = stackSet.GetAny();
Assert.True(
(poppedElement.Equals(testNumber2) || poppedElement.Equals(testNumber)) &&
stackSet.Count() == 2, "PopAny didn't work.");
}
private ILinkDemandAndProvider GetDemandOrProviderLink(INode tailGraphNode,
INode headGraphNode)
{
ILinkDemandAndProvider demandAndProviderLink;
IScheduleNode tail = tailGraphNode.GetEntity();
if (tail is Demand)
{
demandAndProviderLink = new T_DemandToProvider(tail.GetId(),
headGraphNode.GetEntity().GetId(), null);
}
else if (tail is Provider)
{
demandAndProviderLink = new T_ProviderToDemand(tail.GetId(),
headGraphNode.GetEntity().GetId(), null);
}
else
{
throw new MrpRunException("Not expected type.");
}
return(demandAndProviderLink);
}
/**
* Top-down
*/
public void ScheduleBackward()
{
// S = {0} (alle einplanbaren Operations/Demands/Providers)
if (_clearOldTimes)
{
// d_0 = 0
foreach (var uniqueNode in _orderOperationGraph.GetAllUniqueNodes())
{
IScheduleNode uniqueScheduleNode = uniqueNode.GetEntity();
if (uniqueScheduleNode.IsReadOnly() == false &&
uniqueScheduleNode.GetType() != typeof(CustomerOrderPart))
{
uniqueScheduleNode.ClearStartTimeBackward();
uniqueScheduleNode.ClearEndTimeBackward();
}
}
}
// while S nor empty do
while (_S.Any())
{
INode i = _S.Pop();
IScheduleNode iAsScheduleNode = i.GetEntity();
INodes successorNodes = _orderOperationGraph.GetSuccessorNodes(i);
if (successorNodes != null && successorNodes.Any())
{
foreach (var successor in successorNodes)
{
_S.Push(successor);
IScheduleNode successorScheduleNode = successor.GetEntity();
if (successorScheduleNode.IsReadOnly())
{
continue;
}
// Konservativ vorwärtsterminieren ist korrekt,
// aber rückwärts muss wenn immer möglich terminiert werden
// (prüfe parents und ermittle minStart und setze das)
INodes predecessorNodes =
_orderOperationGraph.GetPredecessorNodes(successor);
DueTime minStartTime = iAsScheduleNode.GetStartTimeBackward();
if (minStartTime == null)
{
throw new MrpRunException(
"How can the StartTime of an already scheduled node be null ?");
}
foreach (var predecessorNode in predecessorNodes)
{
DueTime predecessorsStartTime =
predecessorNode.GetEntity().GetStartTimeBackward();
if (predecessorsStartTime != null &&
predecessorsStartTime.IsSmallerThan(minStartTime))
{
minStartTime = predecessorsStartTime;
}
}
if (successorScheduleNode.GetType() == typeof(CustomerOrderPart))
{
throw new MrpRunException(
"Only a root node can be a CustomerOrderPart.");
}
if (successorScheduleNode.IsReadOnly() == false)
{
successorScheduleNode.SetEndTimeBackward(minStartTime);
}
}
}
}
}
public void ScheduleForward()
{
Stack <INode> S = new Stack <INode>();
// d_0 = 0
foreach (var node in _orderOperationGraph.GetLeafNodes())
{
IScheduleNode scheduleNode = node.GetEntity();
if (scheduleNode.IsReadOnly() == false &&
scheduleNode.GetStartTimeBackward().IsSmallerThan(_simulationInterval.GetStart()))
{
// implicitly the due/endTime will also be set accordingly
scheduleNode.SetStartTimeBackward(_simulationInterval.GetStart());
S.Push(node);
}
else // no forward scheduling is needed
{
}
}
// while S nor empty do
while (S.Any())
{
INode i = S.Pop();
IScheduleNode iAsScheduleNode = (IScheduleNode)i.GetEntity();
INodes predecessors = _orderOperationGraph.GetPredecessorNodes(i);
if (predecessors != null && predecessors.Any())
{
foreach (var predecessor in predecessors)
{
IScheduleNode predecessorScheduleNode = predecessor.GetEntity();
// if predecessor starts before endTime of current d/p --> change that
if (predecessorScheduleNode.IsReadOnly() == false && predecessorScheduleNode
.GetStartTimeBackward().IsSmallerThan(iAsScheduleNode.GetEndTimeBackward()))
{
// COPs are not allowed to change
if (predecessorScheduleNode.GetType() != typeof(CustomerOrderPart))
{
// don't take getDueTime() since in case of a demand,
// this will be the startTime, which is to early
// This must be the maximum endTime of all childs !!!
DueTime maxEndTime = iAsScheduleNode.GetEndTimeBackward();
foreach (var successor in _orderOperationGraph.GetSuccessorNodes(
predecessor))
{
DueTime successorsEndTime = successor.GetEntity().GetEndTimeBackward();
if (successorsEndTime.IsGreaterThan(maxEndTime))
{
maxEndTime = successorsEndTime;
}
}
predecessorScheduleNode.SetStartTimeBackward(maxEndTime);
}
}
S.Push(predecessor);
}
}
}
}
/**
* put one of the other classes inheriting INode in it like ProductionOrder...
*/
public Node(IScheduleNode entity)
{
_entity = entity;
_id = entity.GetId();
}
