예제 #1
0
 private static void AddWalkToResult(IntermidiateTraceResult result, SpanEquipmentWithRelatedInfo spanEquipment, SegmentWalk segmentWalk)
 {
     if (!result.SegmentWalksBySpanEquipmentId.ContainsKey(spanEquipment.Id))
     {
         result.SegmentWalksBySpanEquipmentId[spanEquipment.Id] = new List <SegmentWalk>()
         {
             segmentWalk
         }
     }
     ;
     else
     {
         result.SegmentWalksBySpanEquipmentId[spanEquipment.Id].Add(segmentWalk);
     }
 }
예제 #2
0
        private IntermidiateTraceResult GatherNetworkGraphTraceInformation(List <SpanEquipmentWithRelatedInfo> spanEquipmentsToTrace, Guid?traceThisSpanSegmentIdOnly)
        {
            IntermidiateTraceResult result = new();

            // Trace all segments of all span equipments
            foreach (var spanEquipment in spanEquipmentsToTrace)
            {
                // Add walks for each span segment in the span equipment
                foreach (var spanStructure in spanEquipment.SpanStructures)
                {
                    foreach (var spanSegment in spanStructure.SpanSegments)
                    {
                        if (traceThisSpanSegmentIdOnly != null && traceThisSpanSegmentIdOnly != spanSegment.Id)
                        {
                            continue;
                        }

                        var spanTraceResult = _utilityNetwork.Graph.TraceSegment(spanSegment.Id);

                        // We're dealing with a connected segment if non-empty trace result is returned
                        if (spanTraceResult.Upstream.Length > 0)
                        {
                            var segmentWalk = new SegmentWalk(spanSegment.Id);

                            for (int downstreamIndex = spanTraceResult.Downstream.Length - 1; downstreamIndex > 0; downstreamIndex--)
                            {
                                var item = spanTraceResult.Downstream[downstreamIndex];

                                if (item is UtilityGraphConnectedSegment connectedSegment)
                                {
                                    // Snatch walk of interest id
                                    Guid walkOfInterestId = AddWalkOfInterestToResult(result, connectedSegment);

                                    var segmentHop = new SegmentWalkHop()
                                    {
                                        FromNodeId       = ((UtilityGraphConnectedTerminal)spanTraceResult.Downstream[downstreamIndex + 1]).NodeOfInterestId,
                                        ToNodeId         = ((UtilityGraphConnectedTerminal)spanTraceResult.Downstream[downstreamIndex - 1]).NodeOfInterestId,
                                        WalkOfInterestId = walkOfInterestId
                                    };

                                    segmentWalk.Hops.Add(segmentHop);
                                }
                            }

                            for (int upstreamIndex = 0; upstreamIndex < spanTraceResult.Upstream.Length; upstreamIndex++)
                            {
                                var item = spanTraceResult.Upstream[upstreamIndex];

                                if (item is UtilityGraphConnectedSegment connectedSegment)
                                {
                                    // Snatch walk of interest id
                                    var walkOfInterestId = AddWalkOfInterestToResult(result, connectedSegment);

                                    if (upstreamIndex == 0)
                                    {
                                        var segmentHop = new SegmentWalkHop()
                                        {
                                            FromNodeId       = ((UtilityGraphConnectedTerminal)spanTraceResult.Downstream[1]).NodeOfInterestId,
                                            ToNodeId         = ((UtilityGraphConnectedTerminal)spanTraceResult.Upstream[upstreamIndex + 1]).NodeOfInterestId,
                                            WalkOfInterestId = walkOfInterestId
                                        };

                                        segmentWalk.Hops.Add(segmentHop);
                                    }
                                    else
                                    {
                                        var segmentHop = new SegmentWalkHop()
                                        {
                                            FromNodeId       = ((UtilityGraphConnectedTerminal)spanTraceResult.Upstream[upstreamIndex - 1]).NodeOfInterestId,
                                            ToNodeId         = ((UtilityGraphConnectedTerminal)spanTraceResult.Upstream[upstreamIndex + 1]).NodeOfInterestId,
                                            WalkOfInterestId = walkOfInterestId
                                        };

                                        segmentWalk.Hops.Add(segmentHop);
                                    }
                                }
                            }

                            AddWalkToResult(result, spanEquipment, segmentWalk);
                        }
                        // We're dealing with an unconnected segment
                        else
                        {
                            if (_utilityNetwork.Graph.TryGetGraphElement <UtilityGraphDisconnectedSegment>(spanSegment.Id, out var disconnectedSegment))
                            {
                                var disconnectedSpanSegment = disconnectedSegment.SpanSegment(_utilityNetwork);

                                // if disconnected segment has been cut
                                if (disconnectedSpanSegment.FromNodeOfInterestIndex > 0 || disconnectedSpanSegment.ToNodeOfInterestIndex < (spanEquipment.NodesOfInterestIds.Length - 1))
                                {
                                    var segmentHop = new SegmentWalkHop()
                                    {
                                        FromNodeId       = spanEquipment.NodesOfInterestIds[disconnectedSpanSegment.FromNodeOfInterestIndex],
                                        ToNodeId         = spanEquipment.NodesOfInterestIds[disconnectedSpanSegment.ToNodeOfInterestIndex],
                                        WalkOfInterestId = spanEquipment.WalkOfInterestId
                                    };

                                    var segmentWalk = new SegmentWalk(spanSegment.Id);

                                    segmentWalk.Hops.Add(segmentHop);
                                    AddWalkToResult(result, spanEquipment, segmentWalk);
                                }
                            }
                        }
                    }
                }

                // Add walk that covers the whole span equipment, unless we're tracing specific segment that has no connections and cuts
                if (traceThisSpanSegmentIdOnly == null || result.SegmentWalksBySpanEquipmentId.Count == 0)
                {
                    var spanEquipmentSegmentHop = new SegmentWalkHop()
                    {
                        FromNodeId       = spanEquipment.NodesOfInterestIds.First(),
                        ToNodeId         = spanEquipment.NodesOfInterestIds.Last(),
                        WalkOfInterestId = spanEquipment.WalkOfInterestId
                    };

                    // Snatch walk of interest id
                    if (!result.InterestList.Contains(spanEquipment.WalkOfInterestId))
                    {
                        result.InterestList.Add(spanEquipment.WalkOfInterestId);
                    }

                    var walk = new SegmentWalk(spanEquipment.Id)
                    {
                        Hops = new List <SegmentWalkHop>()
                        {
                            spanEquipmentSegmentHop
                        }
                    };

                    if (result.SegmentWalksBySpanEquipmentId.ContainsKey(spanEquipment.Id))
                    {
                        result.SegmentWalksBySpanEquipmentId[spanEquipment.Id].Add(walk);
                    }
                    else
                    {
                        result.SegmentWalksBySpanEquipmentId.Add(spanEquipment.Id, new List <SegmentWalk> {
                            walk
                        });
                    }
                }
            }

            return(result);
        }