Trace a utility network

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
view.when(async () => {
  // Check if webMap contains utility networks.
  if (webMap.utilityNetworks.length > 0 ) {

    // Assigns the utility network at index 0 to utilityNetwork.
    utilityNetwork = webMap.utilityNetworks.getItemAt(0);

    // Triggers the loading of the UtilityNetwork instance.
    await utilityNetwork.load();

    // Loop through the shared named trace configuarations
    utilityNetwork.sharedNamedTraceConfigurations.forEach((namedTraceConfig) => {
      // Print to the console the globalIds and their corresponding trace configuration name
      console.log(namedTraceConfig.globalId + " - " + namedTraceConfig.title);
    });
  }
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
const unTraceConfiguration = new UNTraceConfiguration({
  domainNetworkName: "Electric",
  tierName: "Electric Distribution",
  subnetworkName: "RMT003",
  includeContainers: true,
  validateConsistency: true,
  // Traversability
  conditionBarriers: [
    {
      name: "E:Device Status",
      type: "networkAttribute",
      operator: "equal",
      value: 1,
      combineUsingOr: false,
      isSpecificValue: true
    }
  ],
  traversabilityScope: "junctionsAndEdges"
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
view.when(async () => {
  // Check if webMap contains utility networks.
  if (webMap.utilityNetworks.length > 0 ) {

    // Assigns the utility network at index 0 to utilityNetwork.
    utilityNetwork = webMap.utilityNetworks.getItemAt(0);

    // Triggers the loading of the UtilityNetwork instance.
    await utilityNetwork.load();

    // Get shared named trace configurations from your Utility Network
    const sharedNamedTraceConfigurations = utilityNetwork.sharedNamedTraceConfigurations;

    // Find a shared named trace configuration from the GlobalId and use it to create a new UNTraceConfiguration object
    const traceConfiguration = sharedNamedTraceConfigurations.find((sharedNamedTraceConfig) => sharedNamedTraceConfig.globalId === "{537295F6-BFE2-4E0F-AD0D-DA7F7719F9DD}");
    const unTraceConfiguration = new UNTraceConfiguration(traceConfiguration.traceConfiguration.toJSON());

    // Overwrite the subnetwork name property
    unTraceConfiguration.subnetworkName = "myNewSubnetwork";
  }
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Fires after a user clicks on the view.
view.on("click", async (mapEvent) => {
  // Prevent the event bubbling up the event chain.
  mapEvent.stopPropagation();

  // Check to see if any graphics in the view intersect the given screen x, y coordinates.
  const hitTestResult = await view.hitTest(mapEvent);

  // Get Electric Distribution Line features only by using the GlobalId.
  const electricLines = hitTestResult.results.filter((result) => result.graphic.layer.globalId === "{537295F6-BFE2-4E0F-AD0D-DA7F7719F9DD}");

  // Get the GlobalID of the feature where the trace will start traversing the Utility Network.
  myGlobalId = electricLines[0].graphic.attributes.globalid

  // Define percentage along line to place trace location.
  const myPercentageAlong = 0.5;

  // Create trace location (starting point).
  const startingPoint = new TraceLocation({
    globalId: myGlobalId,
    percentAlong: myPercentageAlong,
    type: "starting-point"
  });
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Get named trace configurations.
const sharedNamedTraceConfigurations = utilityNetwork.sharedNamedTraceConfigurations;

// Find a specific named trace configuration from a GlobalId
const namedTraceConfiguration = sharedNamedTraceConfigurations.find((traceConfig) => traceConfig.globalId === "{537295F6-BFE2-4E0F-AD0D-DA7F7719F9DD}");

// Define an array with starting points, barriers.
const myTraceLocations = [startingPoint, barrier];

// Define how the trace will be executed.
const traceParameters = new TraceParameters({
  namedTraceConfigurationGlobalId: namedTraceConfiguration.globalId,
  traceLocations: myTraceLocations
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Execute a trace to get a TraceResult.
const traceResult = await trace.trace(utilityNetwork.networkServiceUrl, traceParameters);

if (traceResult.aggregatedGeometry) {
  // Display results on the map.
  if (traceResult.aggregatedGeometry.multipoint) {
    const multipointGraphic = new Graphic({
      geometry: {
        type: "multipoint",
        points: traceResult.aggregatedGeometry.multipoint.points,
        spatialReference: utilityNetwork.spatialReference
      },
      symbol: myPointSymbol
    });

    traceResultsGraphicsLayer.graphics.add(multipointGraphic);
  }
}