public static TopologyDto ToDto(this TopologyModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var topology = new TopologyDto
{
TotalDepth = model.TotalDepth,
TotalLogicalCores = model.TotalLogicalCores,
TotalPhysicalCores = model.TotalLogicalCores,
Root = new CpuNodeDto
{
Name = model.Root.Name,
Value = model.Root.Value,
NodeType = model.Root.NodeType,
OsIndex = model.Root.OsIndex
}
};
if (model.Root.Children != null)
{
topology.Root.Children = new List <CpuNodeDto>();
foreach (var child in model.Root.Children)
{
topology.Root.Children.Add(CreateChild(child));
}
}
if (model.Root.MemoryChildren != null)
{
topology.Root.MemoryChildren = new List <CpuNodeDto>();
foreach (var child in model.Root.MemoryChildren)
{
topology.Root.MemoryChildren.Add(CreateChild(child));
}
}
return(topology);
}
private async Task UpdateLoadFlowFromRecloser(TopologyModel topology, Dictionary <long, float> loadOfFeeders)
{
string verboseMessage = $"{baseLogString} UpdateLoadFlowFromRecloser method called.";
Logger.LogVerbose(verboseMessage);
if (topology == null)
{
string message = $"{baseLogString} UpdateLoadFlowFromRecloser => Topologies are null.";
Logger.LogError(message);
throw new Exception(message);
}
foreach (var recloserGid in reclosers)
{
if (topology.GetElementByGid(recloserGid, out ITopologyElement recloser))
{
await CalculateLoadFlowFromRecloser(recloser, topology, loadOfFeeders);
}
}
}
/// <summary>
/// Finds the last id for an existing Topology.
/// </summary>
/// <param name="mapTopology">[in] Topology, The topology object.</param>
/// <returns>
/// Returns the Last Id for the topology object passed
/// </returns>
private int FindLastTopoId(TopologyModel mapTopology)
{
long intLastTopoId = 0;
// Get all the Edges in the topology
FullEdgeCollection edgeCollection = mapTopology.GetFullEdges();
// Loop through all the nodes
foreach (FullEdge fullEdge in edgeCollection)
{
if (intLastTopoId < fullEdge.ID)
{
intLastTopoId = fullEdge.ID;
}
}
// Get all the Polygons in the topology
PolygonCollection polygonCollection = mapTopology.GetPolygons();
// Loop through all the nodes
foreach (Polygon polygon in polygonCollection)
{
if (intLastTopoId < polygon.ID)
{
intLastTopoId = polygon.ID;
}
}
// Get all the Nodes in the topology
NodeCollection nodeCollection = mapTopology.GetNodes();
// Loop through all the nodes
foreach (Node node in nodeCollection)
{
if (intLastTopoId < node.ID)
{
intLastTopoId = node.ID;
}
}
return (int)intLastTopoId;
}
public async Task <TopologyModel> CreateGraphTopology(long firstElementGid, string whoIsCalling)
{
Logger.LogVerbose($"{baseLogString} CreateGraphTopology method called, by {whoIsCalling}.");
ITopologyElement currentFider = null;
Logger.LogDebug($"{baseLogString} CreateGraphTopology => Calling GetElementModels method from model provider.");
var modelProviderClient = CeModelProviderClient.CreateClient();
var dict = await modelProviderClient.GetElementModels();
elements = TransformDictionary(dict);
Logger.LogDebug($"{baseLogString} CreateGraphTopology => GetElementModels method from model provider has been called successfully.");
Logger.LogDebug($"{baseLogString} CreateGraphTopology => Calling GetConnections method from model provider.");
modelProviderClient = CeModelProviderClient.CreateClient();
connections = await modelProviderClient.GetConnections();
Logger.LogDebug($"{baseLogString} CreateGraphTopology => GetConnections method from model provider has been called successfully.");
Logger.LogDebug($"{baseLogString} CreateGraphTopology => Calling GetReclosers method from model provider.");
modelProviderClient = CeModelProviderClient.CreateClient();
reclosers = await modelProviderClient.GetReclosers();
Logger.LogDebug($"{baseLogString} CreateGraphTopology => GetReclosers method from model provider has been called successfully.");
Logger.LogDebug($"{baseLogString} CreateGraphTopology => Creating topology from first element with GID {firstElementGid:X16} started.");
visited = new HashSet <long>();
stack = new Stack <long>();
fields = new List <Field>();
TopologyModel topology = new TopologyModel
{
FirstNode = firstElementGid
};
try
{
stack.Push(firstElementGid);
ITopologyElement currentElement;
long currentElementId = 0;
while (stack.Count > 0)
{
currentElementId = stack.Pop();
if (!visited.Contains(currentElementId))
{
visited.Add(currentElementId);
}
if (!elements.TryGetValue(currentElementId, out currentElement))
{
string message = $"{baseLogString} CreateGraphTopology => Failed to build topology.Topology does not contain element with GID {currentElementId:X16}.";
Logger.LogError(message);
return(topology);
//throw new Exception(message);
}
List <long> referencedElements = GetReferencedElementsWithoutIgnorables(currentElementId);
foreach (var element in referencedElements)
{
if (elements.TryGetValue(element, out ITopologyElement newNode))
{
if (!reclosers.Contains(element))
{
ConnectTwoNodes(newNode, currentElement);
stack.Push(element);
}
else
{
currentElement.SecondEnd.Add(newNode);
if (newNode.FirstEnd == null)
{
newNode.FirstEnd = currentElement;
}
else
{
newNode.SecondEnd.Add(currentElement);
}
if (!topology.TopologyElements.ContainsKey(newNode.Id))
{
topology.AddElement(newNode);
}
}
}
else
{
Logger.LogError($"{baseLogString} CreateGraphTopology => Element with GID {element:X16} does not exist in collection of elements.");
}
}
if (currentElement is Feeder)
{
currentFider = currentElement;
}
else
{
currentElement.Feeder = currentFider;
}
topology.AddElement(currentElement);
}
foreach (var field in fields)
{
topology.AddElement(field);
}
//long size = 0;
//using (Stream stream = new MemoryStream())
//{
// BinaryFormatter formatter = new BinaryFormatter();
// formatter.Serialize(stream, topology);
// size = stream.Length;
//}
//using (FileStream writer = new FileStream(@"E:\LogFiles\Topology.txt", FileMode.OpenOrCreate))
//{
// DataContractSerializer serializer = new DataContractSerializer(topology.GetType());
// serializer.WriteObject(writer, topology);
//}
}
catch (Exception e)
{
Logger.LogError($"{baseLogString} Uhvacen eksepsn. {e.Message} {e.StackTrace}");
}
Logger.LogDebug($"{baseLogString} CreateGraphTopology => Topology successfully created.");
return(topology);
}
public async Task <UIModel> ConvertTopologyToUIModel(TopologyModel topology)
{
string verboseMessage = $"{baseLogString} ConvertTopologyToUIModel method called.";
Logger.LogVerbose(verboseMessage);
if (topology == null)
{
string message = $"{baseLogString} ConvertTopologyToUIModel => Provider topology is null.";
Logger.LogError(message);
throw new Exception(message);
}
UIModel uIModel = new UIModel();
Stack <long> stack = new Stack <long>();
Logger.LogDebug($"{baseLogString} ConvertTopologyToUIModel => Calling GetReclosers method from model provider client.");
var modelProviderClient = CeModelProviderClient.CreateClient();
var reclosers = await modelProviderClient.GetReclosers();
Logger.LogDebug($"{baseLogString} ConvertTopologyToUIModel => GetReclosers method from model provider client has been called successfully.");
uIModel.FirstNode = topology.FirstNode;
stack.Push(topology.FirstNode);
long nextElementGid;
while (stack.Count > 0)
{
nextElementGid = stack.Pop();
if (topology.GetElementByGid(nextElementGid, out ITopologyElement element))
{
if (!reclosers.Contains(nextElementGid))
{
foreach (var child in element.SecondEnd)
{
long nextElement = child.Id;
if (ModelCodeHelper.ExtractTypeFromGlobalId(child.Id) == 0)
{
if (child is Field field && field.Members.Count > 0)
{
nextElement = field.Members.First().Id;
}
else
{
string message = $"{baseLogString} ConvertTopologyToUIModel => Error while getting field in Topology to UIModel convert. Element is not field or field is empty.";
Logger.LogError(message);
throw new Exception(message);
}
}
uIModel.AddRelation(element.Id, nextElement);
stack.Push(nextElement);
}
}
List <UIMeasurement> measurements = new List <UIMeasurement>();
foreach (var measurementGid in element.Measurements.Keys)
{
DMSType type = (DMSType)ModelCodeHelper.ExtractTypeFromGlobalId(measurementGid);
if (type == DMSType.ANALOG)
{
Logger.LogDebug($"{baseLogString} ConvertTopologyToUIModel => Calling GetAnalogMeasurement method from measurement provider client for measurement GID {measurementGid:X16}.");
var measurementProviderClient = MeasurementProviderClient.CreateClient();
AnalogMeasurement analogMeasurement = await measurementProviderClient.GetAnalogMeasurement(measurementGid);
Logger.LogDebug($"{baseLogString} ConvertTopologyToUIModel => GetAnalogMeasurement method from measurement provider client has been called successfully.");
measurements.Add(new UIMeasurement()
{
Gid = analogMeasurement.Id,
Type = analogMeasurement.GetMeasurementType(),
Value = analogMeasurement.GetCurrentValue()
});
}
else if (type == DMSType.DISCRETE)
{
Logger.LogDebug($"{baseLogString} ConvertTopologyToUIModel => Calling GetDiscreteMeasurement method from measurement provider client for measurement GID {measurementGid:X16}.");
var measurementProviderClient = MeasurementProviderClient.CreateClient();
DiscreteMeasurement discreteMeasurement = await measurementProviderClient.GetDiscreteMeasurement(measurementGid);
Logger.LogDebug($"{baseLogString} ConvertTopologyToUIModel => GetDiscreteMeasurement method from measurement provider client has been called successfully.");
measurements.Add(new UIMeasurement()
{
Gid = discreteMeasurement.Id,
Type = discreteMeasurement.GetMeasurementType(),
Value = discreteMeasurement.GetCurrentValue()
});
}
}
if (!uIModel.Nodes.ContainsKey(element.Id))
{
UINode newUINode = new UINode()
{
Id = element.Id,
Name = element.Name,
Mrid = element.Mrid,
Description = element.Description,
DMSType = element.DmsType,
NominalVoltage = element.NominalVoltage,
Measurements = measurements,
IsActive = element.IsActive,
IsRemote = element.IsRemote,
NoReclosing = element.NoReclosing
};
uIModel.AddNode(newUINode);
}
}
/// <summary>
/// Selects a point on the centroid of the polygon object and returns the point
/// that references to the polygon object.
/// </summary>
/// <param name="polygon"> [out] Polygon topology object.</param>
/// <param name="mapTopology">[in] Map topology object.</param>
/// <returns>
/// Returns true if successful.
/// </returns>
private bool GetPolygonPtr(ref Polygon polygon, TopologyModel mapTopology)
{
Point3d selectedPoint = new Point3d(0.0, 0.0, 0.0);
string promptString = "Select a point inside a polygon of the Topology\n";
MapApplication app = HostMapApplicationServices.Application;
Editor editor = app.GetDocument(app.ActiveProject).Editor;
PromptPointResult promptPtRes = editor.GetPoint(promptString);
if (promptPtRes.Status == PromptStatus.OK)
{
selectedPoint = promptPtRes.Value;
Point3d ac3dPoint = HelperFunctions.Ucs2Wcs(selectedPoint);
try
{
polygon = mapTopology.FindPolygon(ac3dPoint);
}
catch (MapException e)
{
Utility.AcadEditor.WriteMessage(string.Format("\nERROR: Unable to find the polygon with error code: {0}.", e.ErrorCode));
return false;
}
}
else
{
Utility.AcadEditor.WriteMessage("\nERROR: unable to execute getpoint function.");
return false;
}
return true;
}
public async Task <TopologyModel> UpdateLoadFlow(TopologyModel inputTopology)
{
string verboseMessage = $"{baseLogString} UpdateLoadFlow method called.";
Logger.LogVerbose(verboseMessage);
TopologyModel topology = inputTopology;
try
{
Dictionary <long, float> loadOfFeeders = new Dictionary <long, float>();
feeders = new Dictionary <long, ITopologyElement>();
syncMachines = new Dictionary <long, ITopologyElement>();
dailyCurves = DailyCurveReader.ReadDailyCurves();
Logger.LogDebug($"{baseLogString} UpdateLoadFlow => Getting reclosers from model provider.");
var modelProviderClient = CeModelProviderClient.CreateClient();
reclosers = await modelProviderClient.GetReclosers();
Logger.LogDebug($"{baseLogString} UpdateLoadFlow => Reclosers were delivered successfully.");
if (topology == null)
{
string message = $"{baseLogString} UpdateLoadFlow => Topology is null.";
Logger.LogWarning(message);
//throw new Exception(message);
return(topology);
}
await CalculateLoadFlow(topology, loadOfFeeders);
await UpdateLoadFlowFromRecloser(topology, loadOfFeeders);
foreach (var syncMachine in syncMachines.Values)
{
await SyncMachine(syncMachine, loadOfFeeders);
}
var commands = new Dictionary <long, float>();
var modbusData = new Dictionary <long, AnalogModbusData>();
foreach (var loadFeeder in loadOfFeeders)
{
if (feeders.TryGetValue(loadFeeder.Key, out ITopologyElement feeder))
{
long signalGid = 0;
foreach (var measurement in feeder.Measurements)
{
if (measurement.Value.Equals(AnalogMeasurementType.FEEDER_CURRENT.ToString()))
{
signalGid = measurement.Key;
}
}
if (signalGid != 0)
{
Logger.LogDebug($"{baseLogString} UpdateLoadFlow => Calling SendAnalogCommand method from measurement provider. Measurement GID {signalGid:X16}, Value {loadFeeder.Value}.");
commands.Add(signalGid, loadFeeder.Value);
AlarmType alarmType = (loadFeeder.Value >= 36) ? AlarmType.HIGH_ALARM : AlarmType.NO_ALARM;
modbusData.Add(signalGid, new AnalogModbusData(loadFeeder.Value, alarmType, signalGid, CommandOriginType.CE_COMMAND));
}
else
{
Logger.LogWarning($"{baseLogString} UpdateLoadFlow => Feeder with GID 0x{feeder.Id:X16} does not have FEEDER_CURRENT measurement.");
}
}
}
var measurementProviderClient = MeasurementProviderClient.CreateClient();
await measurementProviderClient.SendMultipleAnalogCommand(commands, CommandOriginType.CE_COMMAND);
Logger.LogDebug($"{baseLogString} UpdateLoadFlow => SendAnalogCommand method from measurement provider successfully finished.");
Logger.LogDebug($"{baseLogString} UpdateLoadFlow => Calling update analog measurement method from measurement provider.");
await measurementProviderClient.UpdateAnalogMeasurement(modbusData);
Logger.LogDebug($"{baseLogString} UpdateLoadFlow => Update analog measurement method from measurement provider successfully finished.");
}
catch (Exception e)
{
string errorMessage = $"{baseLogString} UpdateLoadFlow => Exception: {e.Message}";
Logger.LogError(errorMessage, e);
}
return(topology);
}
private async Task <TopologyModel> CalculateLoadFlowFromRecloser(ITopologyElement recloser, TopologyModel topology, Dictionary <long, float> loadOfFeeders)
{
string verboseMessage = $"{baseLogString} CalculateLoadFlowFromRecloser method called. Element with GID {recloser?.Id:X16}.";
Logger.LogVerbose(verboseMessage);
if (recloser == null)
{
string message = $"{baseLogString} CalculateLoadFlowUpsideDown => NULL value has been passed instead of recloser.";
Logger.LogError(message);
throw new Exception(message);
}
if (topology == null)
{
string message = $"{baseLogString} CalculateLoadFlowUpsideDown => NULL value has been passed instead of topology.";
Logger.LogError(message);
throw new Exception(message);
}
long measurementGid = 0;
if (recloser.Measurements.Count == 1)
{
//dogovor je da prekidaci imaju samo discrete measurement
measurementGid = recloser.Measurements.First().Key;
}
else
{
Logger.LogWarning($"{baseLogString} CalculateLoadFlowUpsideDown => Recloser with GID {recloser.Id:X16} does not have proper measurements.");
}
bool isEnergized = false;
if (recloser.FirstEnd != null && recloser.SecondEnd.Count == 1)
{
if (recloser.FirstEnd.IsActive && !recloser.SecondEnd.First().IsActive)
{
Tuple <bool, float> tuple = await IsElementEnergized(recloser);
isEnergized = tuple.Item1;
float load = tuple.Item2;
if (isEnergized)
{
await CalculateLoadFlowUpsideDown(recloser.SecondEnd.First(), recloser.Id, recloser.FirstEnd.Feeder, loadOfFeeders);
}
else if (!recloser.IsActive)
{
Thread thread = new Thread(async() => await CommandToRecloser(measurementGid, (int)DiscreteCommandingType.CLOSE, CommandOriginType.CE_COMMAND, recloser));
thread.Start();
}
}
else if (!recloser.FirstEnd.IsActive && recloser.SecondEnd.First().IsActive)
{
Tuple <bool, float> tuple = await IsElementEnergized(recloser);
isEnergized = tuple.Item1;
float load = tuple.Item2;
if (isEnergized)
{
await CalculateLoadFlowUpsideDown(recloser.FirstEnd, recloser.Id, recloser.SecondEnd.First().Feeder, loadOfFeeders);
}
else if (!recloser.IsActive)
{
Thread thread = new Thread(async() => await CommandToRecloser(measurementGid, (int)DiscreteCommandingType.CLOSE, CommandOriginType.CE_COMMAND, recloser));
thread.Start();
}
}
else if (recloser.IsActive)
{
Logger.LogDebug($"{baseLogString} TurnOnAllMeasurement => Calling SendDiscreteCommand method from measurement provider. Measurement GID {measurementGid:X16}, Value 1.");
var measurementProviderClient = MeasurementProviderClient.CreateClient();
await measurementProviderClient.SendSingleDiscreteCommand(measurementGid, (int)DiscreteCommandingType.OPEN, CommandOriginType.CE_COMMAND);
Logger.LogDebug($"{baseLogString} TurnOnAllMeasurement => SendDiscreteCommand method from measurement provider successfully finished.");
recloser.IsActive = false;
}
}
else
{
Logger.LogDebug($"{baseLogString} TurnOnAllMeasurement => Recloser with GID {recloser.Id:X16} does not have both ends, or have more than one on one end.");
}
return(topology);
}
private async Task CalculateLoadFlow(TopologyModel topology, Dictionary <long, float> loadOfFeeders)
{
string verboseMessage = $"{baseLogString} CalculateLoadFlow method called.";
Logger.LogVerbose(verboseMessage);
if (topology == null)
{
string message = $"{baseLogString} CalculateLoadFlow => Topologies are null.";
Logger.LogError(message);
throw new Exception(message);
}
if (topology.GetElementByGid(topology.FirstNode, out ITopologyElement firsElement))
{
Stack <ITopologyElement> stack = new Stack <ITopologyElement>();
stack.Push(firsElement);
ITopologyElement nextElement;
long currentFider = 0;
while (stack.Count > 0)
{
nextElement = stack.Pop();
if (nextElement is Field field)
{
stack.Push(field.Members.First());
}
else
{
if (nextElement is Feeder)
{
currentFider = nextElement.Id;
if (!feeders.ContainsKey(currentFider))
{
feeders.Add(currentFider, nextElement);
}
}
Tuple <bool, float> tuple = await IsElementEnergized(nextElement);
bool isEnergized = tuple.Item1;
float load = tuple.Item2;
if (!isEnergized)
{
await DeEnergizeElementsUnder(nextElement);
}
else
{
if (loadOfFeeders.ContainsKey(currentFider))
{
loadOfFeeders[currentFider] += load;
}
else
{
loadOfFeeders.Add(currentFider, load);
}
foreach (var child in nextElement.SecondEnd)
{
if (!reclosers.Contains(child.Id))
{
stack.Push(child);
}
}
}
}
}
}
else
{
Logger.LogDebug($"{baseLogString} CalculateLoadFlowFirst => Element with GID {topology?.FirstNode:X16} does not exist in collection.");
}
Logger.LogVerbose($"{baseLogString} CalculateLoadFlowFirst => Calulate load flow finished.");
}
public Task <TopologyModel> UpdateLoadFlow(TopologyModel topology)
{
return(InvokeWithRetryAsync(client => client.Channel.UpdateLoadFlow(topology)));
}
public Task <UIModel> ConvertTopologyToUIModel(TopologyModel topology)
{
return(InvokeWithRetryAsync(client => client.Channel.ConvertTopologyToUIModel(topology)));
}
/// <summary>
/// Selects a node.
/// </summary>
/// <param name="selectedNode">[out] The selected node.</param>
/// <param name="promptString">[in] The prompt string.</param>
/// <param name="mapTopology">[in] Map topology object.</param>
/// <returns>
/// Returns true if successful.
/// </returns>
private bool SelectNode(ref Node selectedNode, string promptString, TopologyModel mapTopology)
{
// Select the node
Point3d selectedPoints = new Point3d(0.0,0.0,0.0);
ObjectId objSelectedNode = new ObjectId();
MapApplication app = HostMapApplicationServices.Application;
Editor editor = app.GetDocument(app.ActiveProject).Editor;
PromptPointOptions option = new PromptPointOptions(string.Concat(promptString, "\n"));
option.AllowNone = true;
PromptPointResult promptPtRes = editor.GetPoint(option);
if (promptPtRes.Status == PromptStatus.OK)
{
selectedPoints = promptPtRes.Value;
Point3d ac3dPoint = HelperFunctions.Ucs2Wcs(selectedPoints);
double distance = 0.0;
// Create the Node from the point selected
try
{
mapTopology.FindNode(ref selectedNode, ref distance, ac3dPoint);
return true;
}
catch (MapException e)
{
Utility.AcadEditor.WriteMessage(string.Format("\nERROR: Unable to find node for read with error code: {0}.", e.ErrorCode));
return false;
}
}
return false;
}
public static ResultDto ToDto(this ResultModel resultModel, CpuModel cpuModel, TopologyModel topologyModel)
{
if (resultModel == null)
{
throw new ArgumentNullException(nameof(resultModel));
}
if (cpuModel == null)
{
throw new ArgumentNullException(nameof(cpuModel));
}
if (topologyModel == null)
{
throw new ArgumentNullException(nameof(topologyModel));
}
var resultDto = new ResultDto
{
TimeStamp = resultModel.TimeStamp,
Id = resultModel.Id,
Elpida =
new ElpidaDto
{
Compiler = new CompilerDto
{
Name = resultModel.Elpida.Compiler.Name,
Version = resultModel.Elpida.Compiler.Version
},
Version = new VersionDto
{
Build = resultModel.Elpida.Version.Build,
Major = resultModel.Elpida.Version.Major,
Minor = resultModel.Elpida.Version.Minor,
Revision = resultModel.Elpida.Version.Revision
}
},
Affinity = resultModel.Affinity.ToList(),
Result =
new BenchmarkResultDto
{
Name = resultModel.Result.Name,
TaskResults = resultModel.Result.TaskResults.Select(d => new TaskResultDto
{
Description = d.Description,
Name = d.Name,
Suffix = d.Suffix,
Time = d.Time,
Type = d.Type,
Value = d.Value,
InputSize = d.InputSize,
Outliers = d.Outliers.Select(o => o.ToDto()).ToList(),
Statistics = d.Statistics.ToDto()
}).ToList()
},
System = new SystemDto
{
Os = new OsDto
{
Category = resultModel.System.Os.Category,
Name = resultModel.System.Os.Name,
Version = resultModel.System.Os.Version
},
Cpu = cpuModel.ToDto(),
Timing = resultModel.System.Timing.ToDto(),
Memory =
new MemoryDto
{
PageSize = resultModel.System.Memory.PageSize,
TotalSize = resultModel.System.Memory.TotalSize
},
Topology = topologyModel.ToDto(),
}
};
return(resultDto);
}
/// <summary>
/// Adds selected entities to the new topology object
/// </summary>
/// <param name="mapTopology">[in] Map topology object.</param>
/// <param name="topologyType">[in] The type of topology.</param>
/// <returns>
/// Returns true if successful.
/// </returns>
private bool SelectTopologyEntities(TopologyModel mapTopology, TopologyTypes topologyType)
{
ObjectIdCollection edgeObjIds = new ObjectIdCollection();
ObjectIdCollection nodeObjIds = new ObjectIdCollection();
// Get the required selection sets
switch (topologyType)
{
case TopologyTypes.Polygon:
case TopologyTypes.Linear:
Utility.AcadEditor.WriteMessage("\nSelect links to add to the new topology: ");
if (HelperFunctions.SelectIds(edgeObjIds) == PromptStatus.Cancel)
{
return false;
}
// Convert the selection sets to arrays of object ids
break;
case TopologyTypes.Point:
Utility.AcadEditor.WriteMessage("\nSelect nodes to add to the new topology: ");
if (HelperFunctions.SelectIds(nodeObjIds) == PromptStatus.Cancel)
{
return false;
}
break;
}
// Open the topology for Write
try
{
mapTopology.Open(Autodesk.Gis.Map.Topology.OpenMode.ForWrite);
}
catch (MapException e)
{
Utility.AcadEditor.WriteMessage(String.Format("\nERROR: Unable to open Topology {0} for write with error code: {1}.",mapTopology.Name , e.ErrorCode));
return false;
}
if (topologyType == TopologyTypes.Polygon)
{
// This is polygon topology, add edges to the topology.
if (edgeObjIds.Count > 0)
{
try
{
mapTopology.AddPolygons(edgeObjIds);
}
catch (MapException e)
{
mapTopology.Close();
Utility.AcadEditor.WriteMessage(String.Format("\nERROR: Failed to add links to topology with error code: {0}.", e.ErrorCode));
return false;
}
}
}
else if (topologyType == TopologyTypes.Linear)
{
// This is network topology, add edges to the topology.
if (edgeObjIds.Count > 0)
{
foreach (ObjectId objId in edgeObjIds)
{
FullEdge returnedEdge = null;
try
{
returnedEdge = mapTopology.AddCurveObject(objId);
}
catch (MapException e)
{
mapTopology.Close();
Utility.AcadEditor.WriteMessage(String.Format("\nERROR: Failed to add links to topology with error code: {0}.", e.ErrorCode));
return false;
}
}
}
}
// The node objects could be added to Polygon/Netware/Node topology
if ((topologyType == TopologyTypes.Polygon || topologyType == TopologyTypes.Linear) && edgeObjIds.Count > 0 ||
topologyType == TopologyTypes.Point)
{
if (nodeObjIds.Count > 0)
{
foreach (ObjectId objId in nodeObjIds)
{
Node returnedNode = null;
try
{
returnedNode = mapTopology.AddPointObject(objId);
}
catch (MapException e)
{
mapTopology.Close();
Utility.AcadEditor.WriteMessage(String.Format("\nERROR: Failed to add nodes to topology with error code: {0}.", e.ErrorCode));
return false;
}
}
}
}
mapTopology.Close();
return true;
}
public ITopology CreateGraphTopology(long firstElementGid)
{
ITopologyElement currentFider = null;
elements = Provider.Instance.ModelProvider.GetElementModels();
connections = Provider.Instance.ModelProvider.GetConnections();
reclosers = Provider.Instance.ModelProvider.GetReclosers();
logger.LogInfo($"Creating topology from first element with GID 0x{firstElementGid.ToString("X16")}.");
visited = new HashSet <long>();
stack = new Stack <long>();
fields = new List <Field>();
ITopology topology = new TopologyModel
{
FirstNode = firstElementGid
};
stack.Push(firstElementGid);
ITopologyElement currentElement;
long currentElementId = 0;
while (stack.Count > 0)
{
currentElementId = stack.Pop();
if (!visited.Contains(currentElementId))
{
visited.Add(currentElementId);
}
if (!elements.TryGetValue(currentElementId, out currentElement))
{
logger.LogFatal($"Failed to build topology.Topology elements do not contain element with GID 0x{currentElementId.ToString("X16")}.");
}
foreach (var element in GetReferencedElementsWithoutIgnorables(currentElementId))
{
if (elements.TryGetValue(element, out ITopologyElement newNode))
{
if (!reclosers.Contains(element))
{
ConnectTwoNodes(newNode, currentElement);
stack.Push(element);
}
else
{
currentElement.SecondEnd.Add(newNode);
if (newNode.FirstEnd == null)
{
newNode.FirstEnd = currentElement;
}
else
{
newNode.SecondEnd.Add(currentElement);
}
if (!topology.TopologyElements.ContainsKey(newNode.Id))
{
topology.AddElement(newNode);
}
}
}
else
{
logger.LogError($"[GraphBuilder] Element with GID 0x{element.ToString("X16")} does not exist in collection of elements.");
}
}
if (currentElement is Feeder)
{
currentFider = currentElement;
}
else
{
currentElement.Feeder = currentFider;
}
topology.AddElement(currentElement);
}
foreach (var field in fields)
{
topology.AddElement(field);
}
logger.LogInfo("Topology successfully created.");
return(topology);
}
