void FindATierFromDomainNetworkNameAndTierName(UtilityNetwork utilityNetwork, string domainNetworkName, string tierName)
{
#region Find a Tier given a Domain Network name and Tier name
using (UtilityNetworkDefinition utilityNetworkDefinition = utilityNetwork.GetDefinition())
{
DomainNetwork domainNetwork = utilityNetworkDefinition.GetDomainNetwork(domainNetworkName);
Tier tier = domainNetwork.GetTier(tierName);
}
#endregion
}
protected override async void OnClick()
{
try
{
string unLayerName = "Electric Utility Network";
string domainNetworkName = "ElectricTransmission";
string tierName = "AC High Voltage";
Layer unLayer = await GetLayerByName(MapView.Active.Map, unLayerName);
UtilityNetwork utilityNetwork = await GetUNByLayer(unLayer);
await QueuedTask.Run(() =>
{
using (UtilityNetworkDefinition utilityNetworkDefinition = utilityNetwork.GetDefinition())
{
DomainNetwork domainNetwork = utilityNetworkDefinition.GetDomainNetwork(domainNetworkName);
Tier tier = domainNetwork.GetTier(tierName);
using (SubnetworkManager subnetworkManager = utilityNetwork.GetSubnetworkManager())
{
Subnetwork dirtySubnetwork = subnetworkManager.GetSubnetworks(tier, SubnetworkStates.Dirty).FirstOrDefault();
try
{
if (dirtySubnetwork != null)
{
SubnetworkController subnetworkController = dirtySubnetwork.GetControllers().First();
subnetworkManager.DisableControllerInEditOperation(subnetworkController.Element);
utilityNetwork.ValidateNetworkTopologyInEditOperation();
dirtySubnetwork.Update();
// Redraw map and clear cache
MapView.Active.Redraw(true);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
// utilityNetwork.ValidateNetworkTopology();
});
}
catch (Exception ex)
{
MessageBox.Show($"An exception occurred: {ex.Message}");
}
}
/// <summary>
/// This routine validates the utility network schema matches what we are expecting
/// </summary>
/// <param name="utilityNetwork"></param>
/// <returns>true if the data model has all of the correct schema</returns>
private bool ValidateDataModel(UtilityNetwork utilityNetwork)
{
bool dataModelIsValid = false;
using (UtilityNetworkDefinition utilityNetworkDefinition = utilityNetwork.GetDefinition())
{
try
{
DomainNetwork electricDomainNetwork = utilityNetworkDefinition.GetDomainNetwork(ElectricDomainNetwork);
Tier mediumVoltageTier = electricDomainNetwork.GetTier(MediumVoltageTier);
NetworkAttribute phaseNetworkAttribute = utilityNetworkDefinition.GetNetworkAttribute(PhaseAttributeName);
NetworkAttribute loadNetworkAttribute = utilityNetworkDefinition.GetNetworkAttribute(LoadAttributeName);
if (utilityNetworkDefinition.GetAvailableCategories().Contains(ServicePointCategory))
{
dataModelIsValid = true;
}
}
catch (Exception) { };
}
return(dataModelIsValid);
}
private static void ExecuteTrace(Guid traceStartGuid, string geodatabasePath)
{
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(geodatabasePath))))
{
IReadOnlyList <UtilityNetworkDefinition> utilityNetworkDefinitions = geodatabase.GetDefinitions <UtilityNetworkDefinition>();
string utilityNetworkName = string.Empty;
if (utilityNetworkDefinitions.Count < 0 || utilityNetworkDefinitions.Count > 1)
{
return;
}
// Get utility network name from the dataset
foreach (UtilityNetworkDefinition definition in utilityNetworkDefinitions)
{
utilityNetworkName = definition.GetName();
Console.WriteLine($"Utility network name: {utilityNetworkName}");
definition.Dispose();
}
// Open utility network
using (UtilityNetwork utilityNetwork = geodatabase.OpenDataset <UtilityNetwork>(utilityNetworkName))
using (UtilityNetworkDefinition utilityNetworkDefinition = utilityNetwork.GetDefinition())
{
using (NetworkSource networkSource = utilityNetworkDefinition.GetNetworkSource("ElectricDevice"))
using (AssetGroup assetGroup = networkSource.GetAssetGroup("Medium Voltage Transformer"))
using (AssetType assetType = assetGroup.GetAssetType("Overhead Single Phase"))
{
DomainNetwork domainNetwork = utilityNetworkDefinition.GetDomainNetwork("Electric");
Tier sourceTier = domainNetwork.GetTier("Electric Distribution");
TraceConfiguration traceConfiguration = sourceTier.GetTraceConfiguration();
// Get downstream side of the terminal
Terminal terminal = null;
if (assetType.IsTerminalConfigurationSupported())
{
TerminalConfiguration terminalConfiguration = assetType.GetTerminalConfiguration();
IReadOnlyList <Terminal> terminals = terminalConfiguration.Terminals;
terminal = terminals.First(t => !t.IsUpstreamTerminal);
}
// Create an element to begin a trace
Element startingPointElement = utilityNetwork.CreateElement(assetType, traceStartGuid, terminal);
List <Element> startingPoints = new List <Element>();
startingPoints.Add(startingPointElement);
// Get trace manager
using (TraceManager traceManager = utilityNetwork.GetTraceManager())
{
// Set trace configurations
TraceArgument traceArgument = new TraceArgument(startingPoints);
traceArgument.Configuration = traceConfiguration;
// Get downstream tracer
Tracer tracer = traceManager.GetTracer <DownstreamTracer>();
// Execuate downstream trace
IReadOnlyList <Result> traceResults = tracer.Trace(traceArgument);
// Display trace results in console
foreach (Result result in traceResults)
{
if (result is ElementResult)
{
ElementResult elementResult = result as ElementResult;
IReadOnlyList <Element> elements = elementResult.Elements;
Console.WriteLine("Trace result elements:");
foreach (Element element in elements)
{
Console.WriteLine($"\t OID: {element.ObjectID}, Name:{element.AssetType.Name}");
}
}
else if (result is FunctionOutputResult)
{
FunctionOutputResult functionResult = result as FunctionOutputResult;
IReadOnlyList <FunctionOutput> functionOutputs = functionResult.FunctionOutputs;
Console.WriteLine("Trace result function outputs:");
foreach (FunctionOutput functionOut in functionOutputs)
{
Console.WriteLine($"\t Function result:{functionOut.Value}, name: {functionOut.Function}");
}
}
else if (result is AggregatedGeometryResult)
{
AggregatedGeometryResult aggResults = result as AggregatedGeometryResult;
Polyline aggregatedLine = aggResults.Line as Polyline;
Multipoint aggregatedPoint = aggResults.Point as Multipoint;
Polygon aggregatedPolygon = aggResults.Polygon as Polygon;
}
}
}
}
}
}
}
/// <summary>
/// GenerateReport
///
/// This routine takes a feature layer that references a feature class that participates in a utility network.
/// It returns a set of data to display on the UI thread.
///
///
/// </summary>
public LoadTraceResults GenerateReport(Layer selectedLayer)
{
// Create a new results object. We use this class to pass back a set of data from the worker thread to the UI thread
LoadTraceResults results = new LoadTraceResults();
// Initialize a number of geodatabase objects
using (UtilityNetwork utilityNetwork = UtilityNetworkUtils.GetUtilityNetworkFromLayer(selectedLayer))
{
if (utilityNetwork == null)
{
results.Message = "Please select a utility network layer.";
results.Success = false;
}
else
{
using (Geodatabase utilityNetworkGeodatabase = utilityNetwork.GetDatastore() as Geodatabase)
using (UtilityNetworkDefinition utilityNetworkDefinition = utilityNetwork.GetDefinition())
using (Geodatabase defaultGeodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(Project.Current.DefaultGeodatabasePath))))
using (TraceManager traceManager = utilityNetwork.GetTraceManager())
{
// First check to make sure we have a feature service workspace. Utility Network functionality requires this.
if (utilityNetworkGeodatabase.GetGeodatabaseType() != GeodatabaseType.Service)
{
results.Message = "A feature service workspace connection is required.";
results.Success = false;
return(results);
}
// Get a row from the starting points table in the default project workspace. This table is created the first time the user creates a starting point
// If the table is missing or empty, a null row is returned
using (Row startingPointRow = GetStartingPointRow(defaultGeodatabase, ref results))
{
if (startingPointRow != null)
{
// Convert starting point row into network element
Element startingPointElement = GetElementFromPointRow(startingPointRow, utilityNetwork, utilityNetworkDefinition);
// Obtain a tracer object
DownstreamTracer downstreamTracer = traceManager.GetTracer <DownstreamTracer>();
// Get the network attributes that we will use in our trace
using (NetworkAttribute phasesNetworkAttribute = GetAttribute(utilityNetworkDefinition, PhaseAttributeNames))
using (NetworkAttribute loadNetworkAttribute = GetAttribute(utilityNetworkDefinition, LoadAttributeNames))
using (NetworkAttribute deviceStatusNetworkAttribute = GetAttribute(utilityNetworkDefinition, DeviceStatusAttributeNames))
{
if (phasesNetworkAttribute == null || loadNetworkAttribute == null || deviceStatusNetworkAttribute == null)
{
results.Success = false;
results.Message = "This add-in requires network attributes for phase, service load, and device status.\n";
return(results);
}
// Get the Tier for Medium Voltage Radial
DomainNetwork electricDomainNetwork = utilityNetworkDefinition.GetDomainNetwork(ElectricDomainNetwork);
Tier mediumVoltageTier = electricDomainNetwork.GetTier(MediumVoltageTier);
// Set up the trace configuration
TraceConfiguration traceConfiguration = new TraceConfiguration();
// Configure the trace to use the electric domain network
traceConfiguration.DomainNetwork = electricDomainNetwork;
// Take the default TraceConfiguration from the Tier for Traversability
Traversability tierTraceTraversability = mediumVoltageTier.TraceConfiguration.Traversability;
traceConfiguration.Traversability.FunctionBarriers = tierTraceTraversability.FunctionBarriers;
traceConfiguration.IncludeBarriersWithResults = mediumVoltageTier.TraceConfiguration.IncludeBarriersWithResults;
traceConfiguration.Traversability.Scope = tierTraceTraversability.Scope;
ConditionalExpression baseCondition = tierTraceTraversability.Barriers as ConditionalExpression;
// Create a condition to only return features that have the service point category
ConditionalExpression servicePointCategoryCondition = new CategoryComparison(CategoryOperator.IsEqual, ServicePointCategory);
// Create function to sum loads on service points where phase = A
ConditionalExpression aPhaseCondition = new NetworkAttributeComparison(phasesNetworkAttribute, Operator.DoesNotIncludeTheValues, APhase);
Add aPhaseLoad = new Add(loadNetworkAttribute, servicePointCategoryCondition);
// Create function to sum loads on service points where phase = B
ConditionalExpression bPhaseCondition = new NetworkAttributeComparison(phasesNetworkAttribute, Operator.DoesNotIncludeTheValues, BPhase);
Add bPhaseLoad = new Add(loadNetworkAttribute, servicePointCategoryCondition);
// Create function to sum loads on service points where phase = C
ConditionalExpression cPhaseCondition = new NetworkAttributeComparison(phasesNetworkAttribute, Operator.DoesNotIncludeTheValues, CPhase);
Add cPhaseLoad = new Add(loadNetworkAttribute, servicePointCategoryCondition);
// Set the output condition to only return features that have the service point category
traceConfiguration.OutputCondition = servicePointCategoryCondition;
// Create starting point list and trace argument object
List <Element> startingPointList = new List <Element>()
{
startingPointElement
};
TraceArgument traceArgument = new TraceArgument(startingPointList);
traceArgument.Configuration = traceConfiguration;
// Trace on the A phase
traceConfiguration.Traversability.Barriers = new Or(baseCondition, aPhaseCondition);
traceConfiguration.Functions = new List <Function>()
{
aPhaseLoad
};
traceArgument.Configuration = traceConfiguration;
try
{
IReadOnlyList <Result> resultsA = downstreamTracer.Trace(traceArgument);
ElementResult elementResult = resultsA.OfType <ElementResult>().First();
results.NumberServicePointsA = elementResult.Elements.Count;
FunctionOutputResult functionOutputResult = resultsA.OfType <FunctionOutputResult>().First();
results.TotalLoadA = (double)functionOutputResult.FunctionOutputs.First().Value;
}
catch (ArcGIS.Core.Data.GeodatabaseUtilityNetworkException e)
{
//No A phase connectivity to source
if (!e.Message.Equals("No subnetwork source was discovered."))
{
results.Success = false;
results.Message += e.Message;
}
}
// Trace on the B phase
traceConfiguration.Traversability.Barriers = new Or(baseCondition, bPhaseCondition);
traceConfiguration.Functions = new List <Function>()
{
bPhaseLoad
};
traceArgument.Configuration = traceConfiguration;
try
{
IReadOnlyList <Result> resultsB = downstreamTracer.Trace(traceArgument);
ElementResult elementResult = resultsB.OfType <ElementResult>().First();
results.NumberServicePointsB = elementResult.Elements.Count;
FunctionOutputResult functionOutputResult = resultsB.OfType <FunctionOutputResult>().First();
results.TotalLoadB = (double)functionOutputResult.FunctionOutputs.First().Value;
}
catch (ArcGIS.Core.Data.GeodatabaseUtilityNetworkException e)
{
// No B phase connectivity to source
if (!e.Message.Equals("No subnetwork source was discovered."))
{
results.Success = false;
results.Message += e.Message;
}
}
// Trace on the C phase
traceConfiguration.Traversability.Barriers = new Or(baseCondition, cPhaseCondition);
traceConfiguration.Functions = new List <Function>()
{
cPhaseLoad
};
traceArgument.Configuration = traceConfiguration;
try
{
IReadOnlyList <Result> resultsC = downstreamTracer.Trace(traceArgument);
ElementResult elementResult = resultsC.OfType <ElementResult>().First();
results.NumberServicePointsC = elementResult.Elements.Count;
FunctionOutputResult functionOutputResult = resultsC.OfType <FunctionOutputResult>().First();
results.TotalLoadC = (double)functionOutputResult.FunctionOutputs.First().Value;
}
catch (ArcGIS.Core.Data.GeodatabaseUtilityNetworkException e)
{
// No C phase connectivity to source
if (!e.Message.Equals("No subnetwork source was discovered."))
{
results.Success = false;
results.Message += e.Message;
}
}
}
// append success message to the output string
results.Message += "Trace successful.";
results.Success = true;
}
}
}
}
}
return(results);
}