コード例 #1
0
        public RecloserState(RecloserLayout recloser)
        {
            Recloser = recloser;
            First    = new Stack <NodeLayout>();
            Second   = new Stack <NodeLayout>();
            NodeLayout n1 = recloser.Node1;
            NodeLayout n2 = recloser.Node2;

            if (n1.Y < n2.Y)
            {
                NodeLayout t = n1;
                n1 = n2;
                n2 = t;
            }

            while (n1.Y > n2.Y)
            {
                First.Push(n1);
                n1 = n1.Parent;
            }

            while (n1 != n2)
            {
                First.Push(n1);
                Second.Push(n2);
                n1 = n1.Parent;
                n2 = n2.Parent;
            }

            Parent = n1;
            Depth  = recloser.Node1.Y - n1.Y;
        }
コード例 #2
0
        void Redraw()
        {
            if (!topologyChanged || topology == null || measurements == null || root == null)
            {
                return;
            }

            topologyChanged = false;

            List <GraphicsElement> elements = new List <GraphicsElement>();
            List <GraphicsLine>    lines    = new List <GraphicsLine>();

            foreach (NodeLayout tree in root.Children)
            {
                Stack <NodeLayout> stack = new Stack <NodeLayout>();
                stack.Push(tree);

                while (stack.Count > 0)
                {
                    NodeLayout node = stack.Pop();
                    elements.Add(new GraphicsElement(node, GetNodeColor(node.IO)));

                    foreach (NodeLayout child in node.Children)
                    {
                        lines.Add(new GraphicsLine(node, child, GetLineColor(node.IO, child.IO)));
                        stack.Push(child);
                    }
                }
            }

            foreach (RecloserLayout r in reclosers)
            {
                elements.Add(new GraphicsElement(r, GetNodeColor(r.IO)));
                lines.Add(new GraphicsLine(r.Node1, r, GetLineColor(r.Node1.IO, r.IO)));
                lines.Add(new GraphicsLine(r.Node2, r, GetLineColor(r.Node2.IO, r.IO)));
            }

            this.elements   = elements;
            this.lines      = lines;
            loadFlowChanged = true;
        }
コード例 #3
0
 public RecloserLayout(RecloserNode r, NodeLayout node1, NodeLayout node2)
 {
     Node1    = node1;
     Node2    = node2;
     Recloser = r;
 }
コード例 #4
0
 public NodeLayout(NodeLayout parent, Node node)
 {
     Node     = node;
     Parent   = parent;
     Children = new List <NodeLayout>();
 }
コード例 #5
0
        void ReorderChildren(NodeLayout node, List <RecloserState> recloserStates)
        {
            List <NodeLayout> children = new List <NodeLayout>(node.Children.Count + 2)
            {
                null, null
            };
            List <uint> depths = new List <uint>()
            {
                uint.MaxValue
            };

            foreach (RecloserState r in recloserStates)
            {
                NodeLayout n1         = r.First.Count > 0 ? r.First.Peek() : null;
                NodeLayout n2         = r.Second.Count > 0 ? r.Second.Peek() : null;
                int        indexNode1 = n1 == null ? -1 : node.Children.IndexOf(n1);
                int        indexNode2 = n2 == null ? -1 : node.Children.IndexOf(n2);

                if (indexNode1 >= 0)
                {
                    r.First.Pop();
                }

                if (indexNode2 >= 0)
                {
                    r.Second.Pop();
                }

                if (indexNode1 >= 0)
                {
                    if (indexNode2 >= 0)
                    {
                        //handle parent, reorder First and Second
                        int i1 = children.IndexOf(n1);
                        int i2 = children.IndexOf(n2);

                        if (i1 >= 0)
                        {
                            if (i2 <= 0)
                            {
                                uint d;

                                if (depths[i1 - 1] > depths[i1])
                                {
                                    i2 = i1;
                                    d  = depths[i1 - 1];
                                }
                                else
                                {
                                    i2 = i1 + 1;
                                    d  = depths[i1];
                                }

                                children.Insert(i2, n2);
                                depths.Insert(i1, d);
                            }
                        }
                        else
                        {
                            if (i2 >= 0)
                            {
                                uint d;

                                if (depths[i2 - 1] > depths[i2])
                                {
                                    i1 = i2;
                                    d  = depths[i2 - 1];
                                }
                                else
                                {
                                    i1 = i2 + 1;
                                    d  = depths[i2];
                                }

                                children.Insert(i1, n1);
                                depths.Insert(i2, d);
                            }
                            else
                            {
                                int  insertIndex;
                                int  depthIndex;
                                uint d1 = depths[0];
                                uint d2 = depths[depths.Count - 1];
                                uint d;

                                if (d1 >= d2)
                                {
                                    insertIndex = 1;
                                    depthIndex  = 1;
                                    d           = d1;
                                }
                                else
                                {
                                    insertIndex = children.Count - 1;
                                    depthIndex  = children.Count;
                                    d           = d2;
                                }

                                children.Insert(insertIndex, n1);
                                children.Insert(insertIndex + 1, n2);
                                depths.Insert(insertIndex, d);
                                depths.Insert(insertIndex + 1, d);

                                i1 = insertIndex;
                                i2 = insertIndex + 1;
                            }
                        }

                        if (i1 > i2)
                        {
                            int t = i1;
                            i1 = i2;
                            i2 = t;

                            r.Swap();
                        }

                        for (int i = i1; i < i2; ++i)
                        {
                            depths[i] = Math.Min(depths[i], r.Depth);
                        }
                    }
                    else
                    {
                        //first goes right
                        int index = children.IndexOf(n1);

                        if (index < 0)
                        {
                            uint maxd = 0;
                            int  maxi = depths.Count - 1;

                            for (int i = depths.Count - 1; i >= 0; --i)
                            {
                                if (depths[i] > maxd)
                                {
                                    maxd = depths[i];
                                    maxi = i;
                                }
                            }

                            children.Insert(maxi + 1, n1);
                            depths.Insert(maxi + 1, Math.Min(r.Depth, maxd));

                            for (int i = maxi + 2; i < depths.Count; ++i)
                            {
                                if (depths[i] > r.Depth)
                                {
                                    depths[i] = r.Depth;
                                }
                            }
                        }
                        else
                        {
                            for (int i = index; i < depths.Count; ++i)
                            {
                                if (depths[i] > r.Depth)
                                {
                                    depths[i] = r.Depth;
                                }
                            }
                        }
                    }
                }
                else
                {
                    //second goes left
                    if (indexNode2 >= 0)
                    {
                        int index = children.IndexOf(n2);

                        if (index < 0)
                        {
                            uint maxd = 0;
                            int  maxi = 0;

                            for (int i = 0; i < depths.Count; ++i)
                            {
                                if (depths[i] > maxd)
                                {
                                    maxd = depths[i];
                                    maxi = i;
                                }
                            }

                            children.Insert(maxi + 1, n2);
                            depths.Insert(maxi, Math.Min(r.Depth, maxd));

                            for (int i = maxi - 1; i >= 0; --i)
                            {
                                if (depths[i] > r.Depth)
                                {
                                    depths[i] = r.Depth;
                                }
                            }
                        }
                        else
                        {
                            for (int i = index - 1; i >= 0; --i)
                            {
                                if (depths[i] > r.Depth)
                                {
                                    depths[i] = r.Depth;
                                }
                            }
                        }
                    }
                    else
                    {
                        //nothing
                    }
                }
            }

            children.RemoveAt(0);
            children.RemoveAt(children.Count - 1);

            uint maxDepth = 0;
            int  maxIndex = 0;

            for (int i = 0; i < depths.Count; ++i)
            {
                if (depths[i] > maxDepth)
                {
                    maxDepth = depths[i];
                    maxIndex = i;
                }
            }

            foreach (NodeLayout child in node.Children)
            {
                if (!children.Contains(child))
                {
                    children.Insert(maxIndex, child);
                }
            }

            node.Children.Clear();
            node.Children.AddRange(children);
        }
コード例 #6
0
        void Layout()
        {
            if (!networkModelChanged || networkModel == null)
            {
                return;
            }

            networkModelChanged = false;

            Tuple <List <Node>, List <RecloserNode> > model = networkModel.GetTreesAndReclosers();

            Dictionary <Node, NodeLayout> recloserConNodes = new Dictionary <Node, NodeLayout>(model.Item2.Count * 2);

            foreach (RecloserNode rn in model.Item2)
            {
                recloserConNodes[rn.node1] = null;
                recloserConNodes[rn.node2] = null;
            }

            NodeLayout root = new NodeLayout(null, null);

            foreach (Node tree in model.Item1)
            {
                NodeLayout treeRoot = new NodeLayout(root, tree);
                NodeLayout node     = treeRoot;
                uint       y        = 0;

                do
                {
                    node.Y = y;

                    if (recloserConNodes.ContainsKey(node.Node))
                    {
                        recloserConNodes[node.Node] = node;
                    }

                    if (node.Children.Count < node.Node.children.Count)
                    {
                        node = new NodeLayout(node, node.Node.children[node.Children.Count]);
                        ++y;
                        continue;
                    }

                    node.Parent.Children.Add(node);
                    node = node.Parent;
                    --y;
                }while(node != root);
            }

            List <RecloserLayout> reclosers      = new List <RecloserLayout>(model.Item2.Count);
            List <RecloserState>  recloserStates = new List <RecloserState>(model.Item2.Count);

            foreach (RecloserNode rn in model.Item2)
            {
                RecloserLayout r = new RecloserLayout(rn, recloserConNodes[rn.node1], recloserConNodes[rn.node2]);
                reclosers.Add(r);
                recloserStates.Add(new RecloserState(r));
            }

            recloserStates.Sort();

            {
                NodeLayout  node  = root;
                Stack <int> stack = new Stack <int>();
                stack.Push(0);
                uint x = 0;

                do
                {
                    int i = stack.Pop();

                    if (i == 0)
                    {
                        ReorderChildren(node, recloserStates);
                    }

                    if (i < node.Children.Count)
                    {
                        node = node.Children[i];
                        stack.Push(i + 1);
                        stack.Push(0);
                        continue;
                    }

                    if (node.Children.Count > 0)
                    {
                        foreach (NodeLayout child in node.Children)
                        {
                            node.X += child.X;
                        }

                        node.X /= (uint)node.Children.Count;
                    }
                    else
                    {
                        node.X = x += (node.IO != null && ModelCodeHelper.GetTypeFromGID(node.IO.GID) == DMSType.EnergyConsumer) ? 2 : 1;
                    }

                    node = node.Parent;
                }while(node != null);
            }

            this.root      = root;
            this.reclosers = reclosers;

            topologyChanged = true;
        }