Configure subnetwork trace

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 // Copyright 2022 Esri. // // Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. // You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific // language governing permissions and limitations under the License.  using Esri.ArcGISRuntime.Data; using Esri.ArcGISRuntime.Security; using Esri.ArcGISRuntime.UtilityNetworks; using System.Diagnostics;  namespace ArcGIS.Samples.ConfigureSubnetworkTrace {  [ArcGIS.Samples.Shared.Attributes.Sample(  name: "Configure subnetwork trace",  category: "Utility network",  description: "Get a server-defined trace configuration for a given tier and modify its traversability scope, add new condition barriers and control what is included in the subnetwork trace result.",  instructions: "The sample loads with a server-defined trace configuration from a tier. Check or uncheck which options to include in the trace - such as containers or barriers. Use the selection boxes to define a new condition network attribute comparison, and then use 'Add' to add the it to the trace configuration. Tap 'Trace' to run a subnetwork trace with this modified configuration from a default starting location.",  tags: new[] { "category comparison", "condition barriers", "network analysis", "network attribute comparison", "subnetwork trace", "trace configuration", "traversability", "utility network", "validate consistency" })]  public partial class ConfigureSubnetworkTrace : ContentPage  {  // Feature service for an electric utility network in Naperville, Illinois.  private const string FeatureServiceUrl = "https://sampleserver7.arcgisonline.com/server/rest/services/UtilityNetwork/NapervilleElectric/FeatureServer";  private UtilityNetwork _utilityNetwork;  private UtilityTier _sourceTier;   // For creating the default starting location.  private const string DeviceTableName = "Electric Distribution Device";  private const string AssetGroupName = "Service Point";  private const string AssetTypeName = "Three Phase Low Voltage Meter";  private const string GlobalId = "{3AEC2649-D867-4EA7-965F-DBFE1F64B090}";  private UtilityElement _startingLocation;   // For creating the default trace configuration.  private const string DomainNetworkName = "ElectricDistribution";  private const string TierName = "Medium Voltage Radial";   // Holding the initial conditional expression.  private UtilityTraceConditionalExpression _initialExpression;   public ConfigureSubnetworkTrace()  {  InitializeComponent();  _ = Initialize();  }   private async Task Initialize()  {  // As of ArcGIS Enterprise 10.8.1, using utility network functionality requires a licensed user. The following login for the sample server is licensed to perform utility network operations.  AuthenticationManager.Current.ChallengeHandler = new ChallengeHandler(async (info) =>  {  try  {  // WARNING: Never hardcode login information in a production application. This is done solely for the sake of the sample.  string sampleServer7User = "viewer01";  string sampleServer7Pass = "I68VGU^nMurF";  return await AccessTokenCredential.CreateAsync(info.ServiceUri, sampleServer7User, sampleServer7Pass);  }  catch (Exception ex)  {  Debug.WriteLine(ex.Message);  return null;  }  });   try  {  // Create and load the utility network.  _utilityNetwork = new UtilityNetwork(new ServiceGeodatabase(new Uri(FeatureServiceUrl)));  await _utilityNetwork.LoadAsync();   // Build the choice lists for network attribute comparison.  Attributes.ItemsSource = _utilityNetwork.Definition.NetworkAttributes.Where(i => i.IsSystemDefined == false).ToList();  Operators.ItemsSource = Enum.GetValues(typeof(UtilityAttributeComparisonOperator));   // Create a default starting location.  UtilityNetworkSource networkSource = _utilityNetwork.Definition.GetNetworkSource(DeviceTableName);  UtilityAssetGroup assetGroup = networkSource.GetAssetGroup(AssetGroupName);  UtilityAssetType assetType = assetGroup.GetAssetType(AssetTypeName);  Guid globalId = Guid.Parse(GlobalId);  _startingLocation = _utilityNetwork.CreateElement(assetType, globalId);   // Set the terminal for this location. (For our case, we use the 'Load' terminal.)  _startingLocation.Terminal = _startingLocation.AssetType.TerminalConfiguration?.Terminals.FirstOrDefault(term => term.Name == "Load");   // Get a default trace configuration from a tier to update the UI.  UtilityDomainNetwork domainNetwork = _utilityNetwork.Definition.GetDomainNetwork(DomainNetworkName);  _sourceTier = domainNetwork.GetTier(TierName);   if (_sourceTier.GetDefaultTraceConfiguration().Traversability.Barriers is UtilityTraceConditionalExpression expression)  {  ConditionBarrierExpression.Text = ExpressionToString(expression);  _initialExpression = expression;  }   // Set the traversability scope.  _sourceTier.GetDefaultTraceConfiguration().Traversability.Scope = UtilityTraversabilityScope.Junctions;  }  catch (Exception ex)  {  await Application.Current.Windows[0].Page.DisplayAlert("Error", ex.Message, "OK");  }  }   private string ExpressionToString(UtilityTraceConditionalExpression expression)  {  if (expression is UtilityCategoryComparison categoryComparison)  {  return $"`{categoryComparison.Category.Name}` {categoryComparison.ComparisonOperator}";  }  else if (expression is UtilityNetworkAttributeComparison attributeComparison)  {  // Check if attribute domain is a coded value domain.  if (attributeComparison.NetworkAttribute.Domain is CodedValueDomain domain)  {  // Get the coded value using the the attribute comparison value and attribute data type.  UtilityNetworkAttributeDataType dataType = attributeComparison.NetworkAttribute.DataType;  object attributeValue = ConvertToDataType(attributeComparison.Value, attributeComparison.NetworkAttribute.DataType);  CodedValue codedValue = domain.CodedValues.FirstOrDefault(value => ConvertToDataType(value.Code, dataType).Equals(attributeValue));  return $"`{attributeComparison.NetworkAttribute.Name}` {attributeComparison.ComparisonOperator} `{codedValue?.Name}`";  }  else  {  return $"`{attributeComparison.NetworkAttribute.Name}` {attributeComparison.ComparisonOperator} `{attributeComparison.OtherNetworkAttribute?.Name ?? attributeComparison.Value}`";  }  }  else if (expression is UtilityTraceAndCondition andCondition)  {  return $"({ExpressionToString(andCondition.LeftExpression)}) AND\n ({ExpressionToString(andCondition.RightExpression)})";  }  else if (expression is UtilityTraceOrCondition orCondition)  {  return $"({ExpressionToString(orCondition.LeftExpression)}) OR\n ({ExpressionToString(orCondition.RightExpression)})";  }  else  {  return null;  }  }   private object ConvertToDataType(object otherValue, UtilityNetworkAttributeDataType dataType)  {  switch (dataType)  {  case UtilityNetworkAttributeDataType.Boolean:  return Convert.ToBoolean(otherValue);   case UtilityNetworkAttributeDataType.Double:  return Convert.ToDouble(otherValue);   case UtilityNetworkAttributeDataType.Float:  return Convert.ToSingle(otherValue);   case UtilityNetworkAttributeDataType.Integer:  return Convert.ToInt32(otherValue);  }  throw new NotSupportedException();  }   private void OnAttributeChanged(object sender, System.EventArgs e)  {  // Update the UI to show the correct value entry for the attribute.  ValueEntry.Text = string.Empty;   if (Attributes.SelectedItem is UtilityNetworkAttribute attribute)  {  if (attribute.Domain is CodedValueDomain domain)  {  ValueSelection.ItemsSource = domain.CodedValues.ToList();  ValueSelection.IsVisible = true;  ValueEntry.IsVisible = false;  }  else  {  ValueSelection.IsVisible = false;  ValueEntry.IsVisible = true;  }  }  }   private async void OnTrace(object sender, System.EventArgs e)  {  if (_utilityNetwork == null || _startingLocation == null)  {  return;  }  try  {  // Create utility trace parameters for the starting location.  UtilityTraceParameters parameters = new UtilityTraceParameters(UtilityTraceType.Subnetwork, new[] { _startingLocation });  parameters.TraceConfiguration = _sourceTier.GetDefaultTraceConfiguration();   // Trace the utility network.  IEnumerable<UtilityTraceResult> results = await _utilityNetwork.TraceAsync(parameters);   // Get the first result.  UtilityElementTraceResult elementResult = results?.FirstOrDefault() as UtilityElementTraceResult;   // Display the number of elements found by the trace.  await Application.Current.Windows[0].Page.DisplayAlert("Trace Result", $"`{elementResult?.Elements?.Count ?? 0}` elements found.", "OK");  }  catch (Exception ex)  {  await Application.Current.Windows[0].Page.DisplayAlert("Error", $"{ex.Message}\nFor a working barrier condition, try \"Transformer Load\" Equal \"15\".", "OK");  }  }   private void OnReset(object sender, System.EventArgs e)  {  // Reset the barrier condition to the initial value.  UtilityTraceConfiguration traceConfiguration = _sourceTier.GetDefaultTraceConfiguration();  traceConfiguration.Traversability.Barriers = _initialExpression;  ConditionBarrierExpression.Text = ExpressionToString(_initialExpression);  }   private async void OnAddCondition(object sender, EventArgs e)  {  try  {  UtilityTraceConfiguration traceConfiguration = _sourceTier.GetDefaultTraceConfiguration();  if (traceConfiguration == null)  {  traceConfiguration = new UtilityTraceConfiguration();  }  if (traceConfiguration.Traversability == null)  {  traceConfiguration.Traversability = new UtilityTraversability();  }   // NOTE: You may also create a UtilityCategoryComparison with UtilityNetworkDefinition.Categories and UtilityCategoryComparisonOperator.  if (Attributes.SelectedItem is UtilityNetworkAttribute attribute  && Operators.SelectedItem is UtilityAttributeComparisonOperator attributeOperator)  {  object otherValue;  // If the value is a coded value.  if (attribute.Domain is CodedValueDomain && ValueSelection.SelectedItem is CodedValue codedValue)  {  otherValue = ConvertToDataType(codedValue.Code, attribute.DataType);  }  // If the value is free entry.  else  {  otherValue = ConvertToDataType(ValueEntry.Text.Trim(), attribute.DataType);  }  // NOTE: You may also create a UtilityNetworkAttributeComparison with another NetworkAttribute.  UtilityTraceConditionalExpression expression = new UtilityNetworkAttributeComparison(attribute, attributeOperator, otherValue);  if (traceConfiguration.Traversability.Barriers is UtilityTraceConditionalExpression otherExpression)  {  // NOTE: You may also combine expressions with UtilityTraceAndCondition  expression = new UtilityTraceOrCondition(otherExpression, expression);  }  traceConfiguration.Traversability.Barriers = expression;  ConditionBarrierExpression.Text = ExpressionToString(expression);  }  }  catch (Exception ex)  {  await Application.Current.Windows[0].Page.DisplayAlert("Error", ex.Message, "OK");  }  }   private void IncludeBarriersChanged(object sender, ToggledEventArgs e)  {  _sourceTier.GetDefaultTraceConfiguration().IncludeBarriers = e.Value;  }   private void IncludeContainersChanged(object sender, ToggledEventArgs e)  {  _sourceTier.GetDefaultTraceConfiguration().IncludeContainers = e.Value;  }  } }