private ITopologyElement GetPopulatedElement(ResourceDescription rs)
{
string errorMessage = $"[NMSManager] Failed to populate element with GID 0x{rs.Id:X16}. ";
ITopologyElement topologyElement = new TopologyElement(rs.Id);
try
{
DMSType type = GetDMSTypeOfTopologyElement(rs.Id);
topologyElement.Mrid = rs.GetProperty(ModelCode.IDOBJ_MRID).AsString();
topologyElement.Name = rs.GetProperty(ModelCode.IDOBJ_NAME).AsString();
topologyElement.Description = rs.GetProperty(ModelCode.IDOBJ_DESCRIPTION).AsString();
topologyElement.DmsType = type.ToString();
if (rs.ContainsProperty(ModelCode.CONDUCTINGEQUIPMENT_ISREMOTE))
{
topologyElement.IsRemote = rs.GetProperty(ModelCode.CONDUCTINGEQUIPMENT_ISREMOTE).AsBool();
}
else
{
topologyElement.IsRemote = false;
}
if (rs.ContainsProperty(ModelCode.BREAKER_NORECLOSING))
{
topologyElement.NoReclosing = rs.GetProperty(ModelCode.BREAKER_NORECLOSING).AsBool();
if (!topologyElement.NoReclosing)
{
topologyElement = new Recloser(topologyElement);
}
}
else
{
topologyElement.NoReclosing = true;
}
if (rs.ContainsProperty(ModelCode.CONDUCTINGEQUIPMENT_BASEVOLTAGE))
{
long baseVoltageGid = rs.GetProperty(ModelCode.CONDUCTINGEQUIPMENT_BASEVOLTAGE).AsLong();
if (BaseVoltages.TryGetValue(baseVoltageGid, out float voltage))
{
topologyElement.NominalVoltage = voltage;
}
else if (baseVoltageGid == 0)
{
logger.LogError($"{errorMessage} BaseVoltage with GID 0x{baseVoltageGid.ToString("X16")} does not exist in baseVoltages collection.");
}
}
else
{
topologyElement.NominalVoltage = 0;
}
if (rs.ContainsProperty(ModelCode.BREAKER_NORECLOSING) && !rs.GetProperty(ModelCode.BREAKER_NORECLOSING).AsBool())
{
Reclosers.Add(topologyElement.Id);
}
if (rs.ContainsProperty(ModelCode.ENERGYCONSUMER_TYPE))
{
topologyElement = new EnergyConsumer(topologyElement)
{
Type = (EnergyConsumerType)rs.GetProperty(ModelCode.ENERGYCONSUMER_TYPE).AsEnum()
};
}
if (type == DMSType.SYNCHRONOUSMACHINE)
{
topologyElement = new SynchronousMachine(topologyElement);
if (rs.ContainsProperty(ModelCode.SYNCHRONOUSMACHINE_CAPACITY))
{
((SynchronousMachine)topologyElement).Capacity = rs.GetProperty(ModelCode.SYNCHRONOUSMACHINE_CAPACITY).AsFloat();
}
if (rs.ContainsProperty(ModelCode.SYNCHRONOUSMACHINE_CURRENTREGIME))
{
((SynchronousMachine)topologyElement).CurrentRegime = rs.GetProperty(ModelCode.SYNCHRONOUSMACHINE_CURRENTREGIME).AsFloat();
}
}
}
catch (Exception ex)
{
logger.LogError($"{errorMessage} Could not get all properties.Excepiton message: {ex.Message}");
}
return(topologyElement);
}
private async Task <ITopologyElement> GetPopulatedElement(ResourceDescription rs)
{
string verboseMessage = $"{baseLogString} entering GetPopulatedElement method.";
Logger.LogVerbose(verboseMessage);
ITopologyElement topologyElement = new TopologyElement(rs.Id);
try
{
DMSType type = GetDMSTypeOfTopologyElement(rs.Id);
topologyElement.Mrid = rs.GetProperty(ModelCode.IDOBJ_MRID).AsString();
topologyElement.Name = rs.GetProperty(ModelCode.IDOBJ_NAME).AsString();
topologyElement.Description = rs.GetProperty(ModelCode.IDOBJ_DESCRIPTION).AsString();
topologyElement.DmsType = type.ToString();
if (rs.ContainsProperty(ModelCode.CONDUCTINGEQUIPMENT_ISREMOTE))
{
topologyElement.IsRemote = rs.GetProperty(ModelCode.CONDUCTINGEQUIPMENT_ISREMOTE).AsBool();
}
else
{
topologyElement.IsRemote = false;
}
if (rs.ContainsProperty(ModelCode.BREAKER_NORECLOSING))
{
topologyElement.NoReclosing = rs.GetProperty(ModelCode.BREAKER_NORECLOSING).AsBool();
if (!topologyElement.NoReclosing)
{
topologyElement = new Recloser(topologyElement);
}
}
else
{
topologyElement.NoReclosing = true;
}
if (rs.ContainsProperty(ModelCode.CONDUCTINGEQUIPMENT_BASEVOLTAGE))
{
long baseVoltageGid = rs.GetProperty(ModelCode.CONDUCTINGEQUIPMENT_BASEVOLTAGE).AsLong();
var voltageResult = await BaseVoltages.TryGetValueAsync(baseVoltageGid);
if (voltageResult.HasValue)
{
topologyElement.NominalVoltage = voltageResult.Value;
}
else if (baseVoltageGid == 0)
{
Logger.LogError($"{baseLogString} GetPopulatedElement => BaseVoltage with GID {baseVoltageGid:X16} does not exist in baseVoltages collection.");
}
}
else
{
topologyElement.NominalVoltage = 0;
}
if (rs.ContainsProperty(ModelCode.BREAKER_NORECLOSING) && !rs.GetProperty(ModelCode.BREAKER_NORECLOSING).AsBool())
{
var reclosersResult = await Reclosers.TryGetValueAsync(ReliableDictionaryNames.Reclosers);
if (reclosersResult.HasValue)
{
var reclosers = reclosersResult.Value;
reclosers.Add(topologyElement.Id);
await Reclosers.SetAsync(ReliableDictionaryNames.Reclosers, reclosers);
}
else
{
Logger.LogWarning($"{baseLogString} Reliable collection '{ReliableDictionaryNames.Reclosers}' was not defined yet. Handling...");
await Reclosers.SetAsync(ReliableDictionaryNames.Reclosers, new HashSet <long>() { topologyElement.Id });
}
}
if (rs.ContainsProperty(ModelCode.ENERGYCONSUMER_TYPE))
{
topologyElement = new EnergyConsumer(topologyElement)
{
Type = (EnergyConsumerType)rs.GetProperty(ModelCode.ENERGYCONSUMER_TYPE).AsEnum()
};
}
if (type == DMSType.SYNCHRONOUSMACHINE)
{
topologyElement = new SynchronousMachine(topologyElement);
if (rs.ContainsProperty(ModelCode.SYNCHRONOUSMACHINE_CAPACITY))
{
((SynchronousMachine)topologyElement).Capacity = rs.GetProperty(ModelCode.SYNCHRONOUSMACHINE_CAPACITY).AsFloat();
}
if (rs.ContainsProperty(ModelCode.SYNCHRONOUSMACHINE_CURRENTREGIME))
{
((SynchronousMachine)topologyElement).CurrentRegime = rs.GetProperty(ModelCode.SYNCHRONOUSMACHINE_CURRENTREGIME).AsFloat();
}
}
}
catch (Exception e)
{
Logger.LogError($"{baseLogString} GetPopulatedElement => Could not get all properties." +
$"{Environment.NewLine}Excepiton message: {e.Message}" +
$"{Environment.NewLine} Stack trace: {e.StackTrace}");
}
return(topologyElement);
}
public bool TryGetAllModelEntities(
out Dictionary <long, ITopologyElement> topologyElements,
out Dictionary <long, List <long> > elementConnections,
out HashSet <long> reclosers,
out List <long> energySources)
{
TopologyElements.Clear();
Measurements.Clear();
EnergySources.Clear();
ElementConnections.Clear();
MeasurementToConnectedTerminalMap.Clear();
TerminalToConnectedElementsMap.Clear();
BaseVoltages.Clear();
Reclosers.Clear();
bool success = true;
try
{
logger.LogInfo("Getting all network model elements and converting them...");
GetBaseVoltages().Wait();
Parallel.For(0, ConcreteModels.Count, (i) =>
{
var model = ConcreteModels.ElementAt(i);
if (model != ModelCode.BASEVOLTAGE)
{
List <ModelCode> properties = modelResourcesDesc.GetAllPropertyIds(model);
var elements = networkModelGDA.GetExtentValues(model, properties).Result;
foreach (var element in elements)
{
TransformToTopologyElement(element);
}
}
});
foreach (var measurement in Measurements.Values)
{
PutMeasurementsInElements(measurement);
Provider.Instance.MeasurementProvider.AddMeasurementElementPair(measurement.Id, measurement.ElementId);
}
foreach (var element in TopologyElements.Values)
{
if (element.Measurements.Count == 0)
{
CreateNoScadaMeasurement(element);
}
}
topologyElements = TopologyElements;
elementConnections = ElementConnections;
reclosers = Reclosers;
energySources = EnergySources;
}
catch (Exception ex)
{
logger.LogError($"[NMSManager] Failed in get all network model elements. Exception message: {ex.Message}");
topologyElements = null;
elementConnections = null;
reclosers = null;
energySources = null;
success = false;
}
return(success);
}
public async Task <IModelDelta> TryGetAllModelEntitiesAsync()
{
string verboseMessage = $"{baseLogString} entering TryGetAllModelEntities method.";
Logger.LogVerbose(verboseMessage);
while (!ReliableDictionariesInitialized)
{
await Task.Delay(1000);
}
ModelDelta modelDelta = new ModelDelta();
try
{
//var clearTasks = new List<Task>
//{
await TopologyElements.ClearAsync();
await Measurements.ClearAsync();
await EnergySources.ClearAsync();
await ElementConnections.ClearAsync();
await MeasurementToConnectedTerminalMap.ClearAsync();
await TerminalToConnectedElementsMap.ClearAsync();
await BaseVoltages.ClearAsync();
await Reclosers.ClearAsync();
//};
//Task.WaitAll(clearTasks.ToArray());
await energySources.SetAsync(ReliableDictionaryNames.EnergySources, new List <long>());
await reclosers.SetAsync(ReliableDictionaryNames.Reclosers, new HashSet <long>());
Logger.LogDebug($"{baseLogString} TryGetAllModelEntities => Getting all network model elements and converting them.");
await GetBaseVoltagesAsync();
foreach (var model in ConcreteModels)
{
if (model != ModelCode.BASEVOLTAGE)
{
List <ModelCode> properties = modelResourcesDesc.GetAllPropertyIds(model);
var elements = await networkModelGda.GetExtentValuesAsync(model, properties);
foreach (var element in elements)
{
try
{
await TransformToTopologyElementAsync(element);
}
catch (Exception e)
{
Logger.LogError($"{baseLogString} TryGetAllModelEntitiesAsync failed." +
$" {Environment.NewLine} {e.Message} " +
$"{Environment.NewLine} {e.StackTrace}");
}
}
}
}
//Parallel.For(0, ConcreteModels.Count, async (i) =>
//{
// var model = ConcreteModels.ElementAt(i);
// if (model != ModelCode.BASEVOLTAGE)
// {
// List<ModelCode> properties = modelResourcesDesc.GetAllPropertyIds(model);
// var elements = await networkModelGda.GetExtentValuesAsync(model, properties);
// foreach (var element in elements)
// {
// try
// {
// await TransformToTopologyElementAsync(element);
// }
// catch (Exception e)
// {
// Logger.LogError($"{baseLogString} TryGetAllModelEntitiesAsync failed." +
// $" {Environment.NewLine} {e.Message} " +
// $"{Environment.NewLine} {e.StackTrace}");
// }
// }
// }
//});
var enumerableMeasurements = await Measurements.GetEnumerableDictionaryAsync();
List <IMeasurement> updatedMeasurements = new List <IMeasurement>(enumerableMeasurements.Count);
foreach (var measurement in enumerableMeasurements.Values)
{
var elementId = await PutMeasurementsInElements(measurement);
var measurementProviderClient = MeasurementProviderClient.CreateClient();
await measurementProviderClient.AddMeasurementElementPair(measurement.Id, elementId);
updatedMeasurements.Add(measurement);
}
foreach (var updatedMeas in updatedMeasurements)
{
await Measurements.SetAsync(updatedMeas.Id, updatedMeas);
}
var enumerableTopologyElements = await TopologyElements.GetEnumerableDictionaryAsync();
List <ITopologyElement> updatedElements = new List <ITopologyElement>(enumerableTopologyElements.Count);
foreach (var element in enumerableTopologyElements.Values)
{
if (element.Measurements.Count == 0)
{
await CreateNoScadaMeasurementAsync(element);
updatedElements.Add(element);
}
}
foreach (var updatedEl in updatedElements)
{
await TopologyElements.SetAsync(updatedEl.Id, updatedEl);
}
modelDelta.TopologyElements = enumerableTopologyElements;
modelDelta.ElementConnections = await ElementConnections.GetEnumerableDictionaryAsync();
var reclosersResult = await Reclosers.TryGetValueAsync(ReliableDictionaryNames.Reclosers);
if (reclosersResult.HasValue)
{
modelDelta.Reclosers = reclosersResult.Value;
}
else
{
Logger.LogWarning($"{baseLogString} Reliable collection '{ReliableDictionaryNames.Reclosers}' was not defined yet. Handling...");
await Reclosers.SetAsync(ReliableDictionaryNames.Reclosers, new HashSet <long>());
modelDelta.Reclosers = new HashSet <long>();
}
var enegySourcesResult = await EnergySources.TryGetValueAsync(ReliableDictionaryNames.EnergySources);
if (reclosersResult.HasValue)
{
modelDelta.EnergySources = enegySourcesResult.Value;
}
else
{
Logger.LogWarning($"{baseLogString} Reliable collection '{ReliableDictionaryNames.EnergySources}' was not defined yet. Handling...");
await EnergySources.SetAsync(ReliableDictionaryNames.EnergySources, new List <long>());
modelDelta.EnergySources = new List <long>();
}
}
catch (Exception e)
{
string message = $"{baseLogString} TryGetAllModelEntities => Failed in get all network model elements." +
$"{Environment.NewLine} Exception message: {e.Message}" +
$"{Environment.NewLine} Stack trace: {e.StackTrace}";
Logger.LogError(message);
throw new Exception(message);
}
return(modelDelta);
}
