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"); }