public void ReplaceNodeByOtherNode(Id nodeId, INode otherNode)
{
if (Contains(otherNode))
{
otherNode = GetNode(otherNode.GetId());
}
INodes predecessors = GetPredecessorNodes(nodeId);
INodes successors = GetSuccessorNodes(nodeId);
RemoveNode(nodeId, false);
// predecessors --> roots
if (predecessors != null)
{
foreach (var predecessor in predecessors)
{
AddEdge(new Edge(predecessor, otherNode));
}
}
// leafs --> successors
if (successors != null)
{
foreach (var successor in successors)
{
AddEdge(new Edge(otherNode, successor));
}
}
}
public INodes GetPredecessorNodesRecursive(INode startNode)
{
INodes allPredecessors = new Nodes();
Stack <INode> stack = new Stack <INode>();
stack.Push(startNode);
while (stack.Any())
{
INode poppedNode = stack.Pop();
if (poppedNode.Equals(startNode) == false)
{
allPredecessors.Add(poppedNode);
}
INodes predecessors = GetPredecessorNodes(poppedNode.GetId());
if (predecessors != null)
{
foreach (var predecessor in predecessors)
{
stack.Push(predecessor);
}
}
}
if (allPredecessors.Any() == false)
{
return(null);
}
return(allPredecessors);
}
public void ReplaceNodeByDirectedGraph(Id nodeId, IDirectedGraph <INode> graphToInsert)
{
INodes predecessors = GetPredecessorNodes(nodeId);
INodes successors = GetSuccessorNodes(nodeId);
RemoveNode(nodeId, false);
// predecessors --> roots
if (predecessors != null)
{
foreach (var predecessor in predecessors)
{
foreach (var rootNode in graphToInsert.GetRootNodes())
{
AddEdge(new Edge(predecessor, rootNode));
}
}
}
// leafs --> successors
if (successors != null)
{
foreach (var leaf in graphToInsert.GetLeafNodes())
{
foreach (var successor in successors)
{
AddEdge(new Edge(leaf, successor));
}
}
}
// add all edges from graphToInsert
AddEdges(graphToInsert.GetEdges());
}
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 AddEdges(INode fromNode, INodes nodes)
{
foreach (var toNode in nodes)
{
AddEdge(new Edge(fromNode, toNode));
}
}
public void RebuildUI()
{
INodes.Clear();
IPath.Clear();
SetView.Nodes[0].Nodes.Clear();
foreach (var s in InImages)
{
SetView.Nodes[0].Nodes.Add(s.Name + "[" + s.Imgs.Count + "]");
foreach (var i in s.Imgs)
{
var nn = SetView.Nodes[0].Nodes[SetView.Nodes[0].Nodes.Count - 1].Nodes.Add("F:" + i.Name);
INodes.Add(nn);
IPath.Add(nn, i);
}
}
SetView.Nodes[1].Nodes.Clear();
foreach (var s in OutImages)
{
SetView.Nodes[1].Nodes.Add(s.Name + "[" + s.Imgs.Count + "]");
foreach (var i in s.Imgs)
{
var nn = SetView.Nodes[1].Nodes[SetView.Nodes[1].Nodes.Count - 1].Nodes.Add("F:" + i.Name);
ONodes.Add(nn);
OPath.Add(nn, i);
}
}
}
public NodeController(
INodes nodes,
IBlockParser blockParser
)
{
this.nodes = nodes ?? throw new ArgumentNullException(nameof(nodes));
this.blockParser = blockParser ?? throw new ArgumentNullException(nameof(blockParser));
}
public StatusController(
INodes nodes,
ZMQSubscriptionService subscriptionService
)
{
this.nodes = nodes ?? throw new ArgumentNullException(nameof(nodes));
this.subscriptionService = subscriptionService ?? throw new ArgumentNullException(nameof(subscriptionService));
}
public static void CreateConfirmations(SimulationInterval simulationInterval)
{
/*ISimulator simulator = new Simulator();
* simulator.ProcessCurrentInterval(simulationInterval, _orderGenerator);*/
// --> (Martin's impl) does not work correctly, use trivial impl instead TODO: Just an info for you Martin
IDbTransactionData dbTransactionData =
ZppConfiguration.CacheManager.GetDbTransactionData();
IAggregator aggregator = ZppConfiguration.CacheManager.GetAggregator();
// customerOrderParts: set finished if all childs are finished
DemandToProviderGraph demandToProviderGraph = new DemandToProviderGraph();
INodes rootNodes = demandToProviderGraph.GetRootNodes();
foreach (var rootNode in rootNodes)
{
if (rootNode.GetEntity().GetType() == typeof(CustomerOrderPart))
{
CustomerOrderPart customerOrderPart = (CustomerOrderPart)rootNode.GetEntity();
customerOrderPart.SetReadOnly();
bool allChildsAreFinished = true;
foreach (var stockExchangeProvider in aggregator.GetAllChildProvidersOf(
customerOrderPart))
{
if (stockExchangeProvider.IsFinished() == false)
{
allChildsAreFinished = false;
break;
}
}
if (allChildsAreFinished)
{
customerOrderPart.SetFinished();
}
}
}
// no confirmations: some nodes has no state (PrO) or must be adapted differently (COPs)
// confirmations only for: stockExchanges, purchaseOrderParts, operations
Type[] typesToAdapt = new Type[]
{
typeof(StockExchangeDemand), typeof(StockExchangeProvider),
typeof(PurchaseOrderPart), typeof(ProductionOrderOperation)
};
// operations
AdaptState(dbTransactionData.ProductionOrderOperationGetAll(), simulationInterval,
typesToAdapt);
// demands
AdaptState(dbTransactionData.DemandsGetAll(), simulationInterval, typesToAdapt);
// provider
AdaptState(dbTransactionData.ProvidersGetAll(), simulationInterval, typesToAdapt);
}
/**
* No need to traverse --> graph is ready, just do some modifications:
* remove ProductionOrderBoms, replace ProductionOrder by operationGraph, ...
*/
private DemandToProviderGraph CreateGraph3()
{
IDbTransactionData dbTransactionData =
ZppConfiguration.CacheManager.GetDbTransactionData();
DemandToProviderGraph demandToProviderGraph = new DemandToProviderGraph();
// replace ProductionOrder by operationGraph
foreach (var productionOrder in dbTransactionData.ProductionOrderGetAll())
{
if (productionOrder.IsReadOnly() == false)
{
var productionOrderBomNode = new Node(productionOrder);
if (demandToProviderGraph.Contains(productionOrderBomNode))
{
OperationGraph operationGraph =
new OperationGraph((ProductionOrder)productionOrder);
INodes leafOfOperationGraph = operationGraph.GetLeafNodes();
demandToProviderGraph.ReplaceNodeByDirectedGraph(productionOrderBomNode, operationGraph);
/*// remove all arrows from leaf, since material must be ready to the
* // corresponding operation not to first operation
* INodes successorsOfLeaf =
* demandToProviderGraph.GetSuccessorNodes(leafOfOperationGraph.GetAny());
* foreach (var successor in successorsOfLeaf)
* {
* demandToProviderGraph.RemoveEdge(leafOfOperationGraph.GetAny(), successor);
* }*/// --> somehow not neccessary
}
}
}
// connect every ProductionOrderBom successor to its operation
foreach (var productionOrderBom in dbTransactionData.ProductionOrderBomGetAll())
{
if (productionOrderBom.IsReadOnly() == false)
{
var productionOrderBomNode = new Node(productionOrderBom);
if (demandToProviderGraph.Contains(productionOrderBomNode))
{
ProductionOrderOperation productionOrderOperation =
((ProductionOrderBom)productionOrderBom).GetProductionOrderOperation();
INodes successorNodes =
demandToProviderGraph.GetSuccessorNodes(productionOrderBom.GetId());
demandToProviderGraph.RemoveNode(productionOrderBomNode.GetId(), false);
foreach (var successor in successorNodes)
{
demandToProviderGraph.AddEdge(
new Edge(new Node(productionOrderOperation), successor));
}
}
}
}
return(demandToProviderGraph);
}
/** basic principle:
*
* put A on the list -> {A}
* put B on the list -> {A,B}
* put C on the list -> {A,B,C}
* since C is a leaf, print the list (A,B,C)
* remove C from the list -> {A,B}
* put D on the list -> {A,B,D}
* since D is a leaf, print the list (A,B,D)
*/
public static List <IEdge> CreateGraphFor(INode root, Type type, IDirectedGraph <INode> directedGraph)
{
Stack <INode> stack = new Stack <INode>();
Stack <INode> pathProductionOrders = new Stack <INode>();
INode lastProductionOrder = null;
List <IEdge> edges = new List <IEdge>();
stack.Push(root);
while (stack.Any())
{
// Do something
INode popped = stack.Pop();
if (popped.GetEntity().GetType() == type)
{
pathProductionOrders.Push(popped);
if (lastProductionOrder == null)
{
lastProductionOrder = popped;
}
else
{
edges.Add(new Edge(lastProductionOrder, popped));
lastProductionOrder = popped;
}
}
// Push other objects on the stack.
INodes successorNodes = directedGraph.GetSuccessorNodes(popped);
if (successorNodes != null)
{
foreach (var successorNode in successorNodes)
{
stack.Push(successorNode);
}
}
// popped is a leaf, remove it from path if it was a PrO
else
{
if (lastProductionOrder != null && lastProductionOrder.Equals(popped))
{
pathProductionOrders.Pop();
if (pathProductionOrders.Any())
{
lastProductionOrder = pathProductionOrders.Pop();
pathProductionOrders.Push(lastProductionOrder);
}
}
}
}
return(edges);
}
public void TestGetRoots()
{
INode[] nodes = EntityFactory.CreateDummyNodes(7);
IDirectedGraph <INode> directedGraph = CreateBinaryDirectedGraph(nodes);
INodes roots = directedGraph.GetRootNodes();
Assert.True(roots != null, "There should be roots in the graph.");
Assert.True(roots.Contains(nodes[0]), $"Leafs do not contain node {nodes[0]}.");
Assert.True(roots.Count() == 1, "Roots must contain exact one node.");
}
private void CreateGraph2()
{
INodes roots = GetRootNodes();
StackSet <IEdge> newEdges = new StackSet <IEdge>();
foreach (var rootNode in roots)
{
newEdges.PushAll(CreateGraphFor(rootNode, typeof(ProductionOrder), this));
}
Clear();
AddEdges(newEdges);
}
public void TestGetLeafs()
{
INode[] nodes = EntityFactory.CreateDummyNodes(7);
IDirectedGraph <INode> directedGraph = CreateBinaryDirectedGraph(nodes);
INodes leafs = directedGraph.GetLeafNodes();
Assert.True(leafs != null, "There should be leafs in the graph.");
for (int i = 3; i < 7; i++)
{
Assert.True(leafs.Contains(nodes[i]), $"Leafs do not contain node {nodes[i]}.");
}
}
public Node(
DataBinding dataBinding,
IDataStorage dataStorage,
INodes nodes,
int nodeId,
int nodeCount)
{
DataBinding = dataBinding;
DataStorage = dataStorage;
Nodes = nodes;
NodeId = nodeId;
NodeCount = nodeId;
}
public override bool Equals(object obj)
{
INodes i = obj as INodes;
if (i != null)
{
return(this.Equals(i));
}
else
{
return(base.Equals(obj));
}
}
public async Task <LinearWeight[]> GetLinearWeigthsAsync(INodes nodes, ICellRequest cell)
{
int N = nodes.Lons.Length;
LinearWeight[] weights = new LinearWeight[N];
for (int i = 0; i < N; i++)
{
weights[i] = new LinearWeight(N - i - 1, cell.LatMax * (i + 1));
}
return(weights);
}
public List <ILinkDemandAndProvider> GetEdgesFrom(Id nodeId)
{
List <ILinkDemandAndProvider> demandAndProviders = new List <ILinkDemandAndProvider>();
INode node = GetNode(nodeId);
INodes successors = GetSuccessorNodes(nodeId);
foreach (var successor in successors)
{
ILinkDemandAndProvider demandAndProviderLink =
GetDemandOrProviderLink(node, successor);
demandAndProviders.Add(demandAndProviderLink);
}
return(demandAndProviders);
}
public List <ILinkDemandAndProvider> GetEdgesTo(Id nodeId)
{
List <ILinkDemandAndProvider> demandAndProviders = new List <ILinkDemandAndProvider>();
INode node = GetNode(nodeId);
INodes predecessors = GetPredecessorNodes(nodeId);
foreach (var predecessor in predecessors)
{
ILinkDemandAndProvider demandAndProviderLink =
GetDemandOrProviderLink(predecessor, node);
demandAndProviders.Add(demandAndProviderLink);
}
return(demandAndProviders);
}
/**
* 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.");
}
}
}
/**
* @return: all leafs of all operationGraphs
*/
private IStackSet <ProductionOrderOperation> CreateS(
IDirectedGraph <INode> operationGraph)
{
INodes leafs = operationGraph.GetLeafNodes();
IStackSet <ProductionOrderOperation> S = new StackSet <ProductionOrderOperation>();
if (leafs != null)
{
foreach (var leaf in leafs)
{
S.Push((ProductionOrderOperation)leaf.GetEntity());
}
}
return(S);
}
public StartupChecker(INodeRepository nodeRepository,
INodes nodes,
IRpcClientFactory rpcClientFactory,
IMinerId minerId,
IBlockParser blockParser,
IDbManager dbManager,
INotificationsHandler notificationsHandler,
ILogger <StartupChecker> logger)
{
this.rpcClientFactory = rpcClientFactory ?? throw new ArgumentNullException(nameof(rpcClientFactory));
this.nodeRepository = nodeRepository ?? throw new ArgumentNullException(nameof(nodeRepository));
this.nodes = nodes ?? throw new ArgumentNullException(nameof(nodes));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.blockParser = blockParser ?? throw new ArgumentNullException(nameof(blockParser));
this.dbManager = dbManager ?? throw new ArgumentNullException(nameof(dbManager));
this.minerId = minerId ?? throw new ArgumentNullException(nameof(nodeRepository));
this.notificationsHandler = notificationsHandler ?? throw new ArgumentNullException(nameof(notificationsHandler));
}
public INodes GetRootNodes()
{
INodes roots = new Nodes();
foreach (var node in _nodes)
{
INodes predecessors = GetPredecessorNodes(node.GetNode());
if (predecessors == null)
{
roots.Add(node.GetNode());
}
}
if (roots.Any() == false)
{
return(null);
}
return(roots);
}
public INodes GetLeafNodes()
{
INodes leafs = new Nodes();
foreach (var node in _nodes)
{
INodes successors = GetSuccessorNodes(node.GetNode());
if (successors == null || successors.Any() == false)
{
leafs.Add(node.GetNode());
}
}
if (leafs.Any() == false)
{
return(null);
}
return(leafs);
}
public void TestGetPredecessorNodesRecursive()
{
INode[] nodes = EntityFactory.CreateDummyNodes(6);
IDirectedGraph <INode> directedGraph = CreateBinaryDirectedGraph(nodes);
foreach (var node in nodes)
{
INodes predecessors = directedGraph.GetPredecessorNodes(node);
if (predecessors == null)
{
continue;
}
INodes predecessorsRecursive = directedGraph.GetPredecessorNodesRecursive(node);
Assert.True(predecessorsRecursive.Contains(node) == false);
foreach (var predecessor in predecessors)
{
Assert.True(predecessorsRecursive.Contains(predecessor));
}
}
}
public void TestGetSuccessorNodes()
{
INode[] nodes = EntityFactory.CreateDummyNodes(7);
IDirectedGraph <INode> directedGraph = CreateBinaryDirectedGraph(nodes);
INodes leafs = directedGraph.GetLeafNodes();
foreach (var node in nodes)
{
INodes successors = directedGraph.GetSuccessorNodes(node);
bool isLeaf = leafs.Contains(node);
if (isLeaf)
{
Assert.True(successors == null, "A leaf cannot have successors.");
}
else
{
Assert.True(successors != null, "A non-leaf MUST have successors.");
}
}
}
public void TestGetPredecessorNodes()
{
INode[] nodes = EntityFactory.CreateDummyNodes(7);
IDirectedGraph <INode> directedGraph = CreateBinaryDirectedGraph(nodes);
INodes roots = directedGraph.GetRootNodes();
foreach (var node in nodes)
{
INodes predecessors = directedGraph.GetPredecessorNodes(node);
bool isRoot = roots.Contains(node);
if (isRoot)
{
Assert.True(predecessors == null, "A root cannot have predecessors.");
}
else
{
Assert.True(predecessors != null, "A non-root MUST have predecessors.");
}
}
}
///
///
/// <summary>
/// A depth-first-search (DFS) traversal of given tree
/// </summary>
/// <returns>
/// The List of the traversed nodes in exact order
/// </returns>
public INodes TraverseDepthFirst(Action <INode, INodes, INodes> action,
CustomerOrderPart startNode)
{
var stack = new Stack <INode>();
Dictionary <INode, bool> discovered = new Dictionary <INode, bool>();
INodes traversed = new Nodes();
stack.Push(new Node(startNode));
INode parentNode;
while (stack.Any())
{
INode poppedNode = stack.Pop();
// init dict if node not yet exists
if (!discovered.ContainsKey(poppedNode))
{
discovered[poppedNode] = false;
}
// if node is not discovered
if (!discovered[poppedNode])
{
traversed.Add(poppedNode);
discovered[poppedNode] = true;
INodes childNodes = GetSuccessorNodes(poppedNode);
action(poppedNode, childNodes, traversed);
if (childNodes != null)
{
foreach (INode node in childNodes)
{
stack.Push(node);
}
}
}
}
return(traversed);
}
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}'");
}
private void Traverse(INode node, INode lastProductionOrder, List <IEdge> edges)
{
if (node.GetEntity().GetType() == typeof(ProductionOrder))
{
if (lastProductionOrder != null)
{
// connect
edges.Add(new Edge(lastProductionOrder, node));
}
lastProductionOrder = node;
}
INodes successorNodes = GetSuccessorNodes(node);
if (successorNodes != null)
{
foreach (var successorNode in successorNodes)
{
Traverse(successorNode, lastProductionOrder, edges);
}
}
}
public SpiralDeployer(INodes nodes, INodeFactory nodeFactory, ILocation[] field,
IRandomizerFactory randFactory)
{
Initialize(nodes, nodeFactory, field, randFactory);
}
public SimulationCompleteEvent(INodes Nodes)
{
nodes = Nodes;
}
public void Initialize(INodes nodes, IEventManager eventMgr)
{
panelObjsHelper = new PanelObjHelper(panelObjs);
c = panelObjsHelper.GetDoubleByName("SoundSpeed");
bitrate = panelObjsHelper.GetDoubleByName("Bitrate");
processingDelay = panelObjsHelper.GetDoubleByName("ProcessingDelay");
overheadBytes = panelObjsHelper.GetIntByName("OverheadBytes");
freq = panelObjsHelper.GetDoubleByName("frequency");
transmitPower = panelObjsHelper.GetDoubleByName("transmitPower");
minReceivePower = panelObjsHelper.GetDoubleByName("receivePower");
noiseLevel = panelObjsHelper.GetDoubleByName("noiseLevel");
k = panelObjsHelper.GetDoubleByName("spreadingCoef");
this.nodes = nodes;
this.eventMgr = eventMgr;
maxRange = getMaxRange(transmitPower, minReceivePower);
l2nodes = new L2Nodes();
NodesIterator nodesIterator = new NodesIterator(this.nodes);
while (!nodesIterator.IsDone())
l2nodes.AddL2Node(new L2Node(nodesIterator.Next().ID, minReceivePower, noiseLevel));
isInitialized = true;
}
public UWAPhysicalProcessor(INodes nodes, IEventManager eventMgr)
{
Initialize(nodes, eventMgr);
}
public NodesIterator(INodes nodes)
{
index = 0;
this.nodes = nodes.NodeQueue;
}
public void Initialize(INodes nodes, INodeFactory nodeFactory, ILocation[] field,
IRandomizerFactory randFactory)
{
this.nodes = nodes;
this.nodeFactory = nodeFactory;
this.randFactory = randFactory;
if (field is XYDoubleLocation[])
this.field = (XYDoubleLocation[])field;
else
throw new InvalidCastException("RandomDeployer must take XYDoubleLocation field");
panelObjsHelper = new PanelObjHelper(panelObjs);
a = panelObjsHelper.GetIntByName("a");
b = panelObjsHelper.GetDoubleByName("b");
nodeDistance = panelObjsHelper.GetDoubleByName("NodeDistance");
isInitialized = true;
}
public PEQTestApplication(IEventManager eventMgr, INodes nodes,
IRandomizer randomizer, ILocation[] field)
{
Initialize(eventMgr, nodes, randomizer, field);
}
/* / \
* // | \\
* / | \
* | */
public void Initialize(IEventManager eventMgr, INodes nodes,
IRandomizer randomizer, ILocation[] field)
{
this.eventMgr = eventMgr;
this.nodes = nodes;
this.randomizer = randomizer;
if (field is XYDoubleLocation[])
this.field = (XYDoubleLocation[])field;
else
{
isInitialized = false;
return;
}
panelObjsHelper = new PanelObjHelper(panelObjs);
this.eventSize = panelObjsHelper.GetDoubleByName("EventSize");
this.eventMeanTime = panelObjsHelper.GetDoubleByName("EventMeanTime");
this.eventFreq = panelObjsHelper.GetDoubleByName("EventFreq");
this.numOccurances = panelObjsHelper.GetIntByName("NumOccurances");
//this.finalEvent = panelObjsHelper.GetBoolByName("FinalEvent");
isInitialized = true;
}
public FQN_RandomDetectionEventGenerator(IEventManager eventMgr, INodes nodes,
IRandomizer randomizer, ILocation[] field)
{
Initialize(eventMgr, nodes, randomizer, field);
}
public void Initialize(IEventManager eventMgr, INodes nodes,
IRandomizer randomizer, ILocation[] field)
{
panelObjsHelper = new PanelObjHelper(panelObjs);
this.eventMgr = eventMgr;
this.nodes = nodes;
this.randomizer = randomizer;
this.field = (XYDoubleLocation[])field;
this.endTime = panelObjsHelper.GetDoubleByName("EndTime");
}
