@enervance/insight-cim-model 1.0.0-dev4 → 1.0.0-dev5

package/dist/analysis/analysis-neplan/digi-ons.js

@@ -1,662 +0,0 @@
-/** Bestimmung des DigiONS-Score-Wertes für die Digitalisierung von Stationen innerhalb eines Abganges*/
-import { WNConnectivityNode } from '../../model/extensions/westnetz-neplan/core/WNConnectivityNode';
-import { Graph } from '../../data-structures/graph/graph';
-import { Switch } from '../../model/wires/Switch';
-import { Type } from '../../data-structures/graph/Types';
-import { GraphNode } from '../../data-structures/graph/nodes/GraphNode';
-import { GraphEdge } from '../../data-structures/graph/edges/GraphEdge';
-import { Connection } from '../../data-structures/graph/connections/connection';
-import { ConductingEquipment } from '../../model/core/ConductingEquipment';
-import { EnergyConsumer } from '../../model/wires/EnergyConsumer';
-import { ACLineSegment } from '../../model/wires/ACLineSegment';
-import { ConnectivityNode } from '../../model/core/ConnectivityNode';
-import { WNFacilityKind } from '../../model/extensions/westnetz-neplan/assets/WNFacilityKind';
-import { convertAnyFeederNodeIntoTree } from '../../util/collection/util-graph2tree';
-import { BFSCalltime, breadthFirstTreeTraversal, LeafNodeCalltime } from '../../util/collection/util-tree';
-import { CimAssetAliasNames } from '../../constants/cim-constants';
-import { BusbarSection } from '../../model/wires/BusbarSection';
-/**
- * Funktion zum Auswaehlen der naechsten DigiONS
- * Der Rueckgabewert ist die ausgewaehlte Station
- */
-function chooseDigiONS(digiOnsResultsMap) {
-    const sortedDigiOnsResults = Array.from(digiOnsResultsMap.values()).sort((a, b) => (a.digiOnsRating > b.digiOnsRating) ? 1 : (a.digiOnsRating < b.digiOnsRating) ? -1 : 0);
-    const filterMustCriteriaResults = sortedDigiOnsResults.filter((arg) => arg.openedSwitchesValue > 0);
-    let digiOnsResult = filterMustCriteriaResults.pop();
-    let wasMustCriteria = false;
-    if (digiOnsResult === undefined) {
-        digiOnsResult = sortedDigiOnsResults.pop();
-    }
-    else {
-        wasMustCriteria = true;
-    }
-    let choosenDigiONS = digiOnsResult.wnConnectivityNode;
-    if (!choosenDigiONS)
-        return undefined;
-    choosenDigiONS.setKind(WNFacilityKind.DIGIONS);
-    return { digiOnsResult, wasMustCriteria };
-}
-export function rateDigiONS(cimModel, anbindungsdata, valuationVector) {
-    var _a, _b, _c;
-    const result = [];
-    for (const ifeeder of cimModel.feeders.values()) {
-        // /* Berechne Gesamtwerte (Gesamt-Summe der Leistung und Gesamtanzahl an Stationen) */
-        // let trunkLineContextWrapper: TreeContextWrapper<TrunkLineContext, LeafNodeCalltime> = {
-        //   context: {
-        //     trunkLineLines: [],
-        //     trunkLineNodes: [],
-        //     onTrunkLine: false,
-        //     uniqueTrunkNodes: new Set<IIdentifiedObject>()
-        //   },
-        //   callbackFunc: markAsTrunkLineCallbackFunc
-        // };
-        // let overallPowerWrapper: TreeContextWrapper<OverallPowerContext, LeafNodeCalltime> = {
-        //   context: { nodesVisited: new Set<IIdentifiedObject>(), overallPower: 0 },
-        //   callbackFunc: overallPowerCallbackFunc
-        // }
-        // let feederTreeContext = convertFeederIntoTree(ifeeder as WNFeeder);
-        // leafNodeTraversal(feederTreeContext.leafNodes, trunkLineContextWrapper); //, overallPowerWrapper);
-        let overallPower = 0;
-        for (const wnConnectivityNode of ifeeder.normalEnergizedConnectivityNodes.values()) {
-            for (const terminal of wnConnectivityNode.terminals.values()) {
-                if (terminal.conductingEquipment instanceof EnergyConsumer) {
-                    overallPower += terminal.conductingEquipment.getApparentPower();
-                }
-            }
-        }
-        let overallStations = 0;
-        // for (const node of trunkLineContextWrapper.context.uniqueTrunkNodes) {
-        //   if (node instanceof ConnectivityNode) {
-        //     overallStations++;
-        //   }
-        // }
-        overallStations = 0;
-        for (const wnConnectivityNode of ifeeder.normalEnergizedConnectivityNodes.values()) {
-            const temp = anbindungsdata.find(arg => arg.uuid === wnConnectivityNode.mrid);
-            if (temp !== undefined && temp.type === 'Stammstrecke') {
-                // NEPLAN-Krücke
-                const namePatternToIgnoreStation = /-[\s\S]{2}-[\s\S]{3}$/;
-                if (namePatternToIgnoreStation.test(wnConnectivityNode.name))
-                    continue;
-                overallStations++;
-            }
-        }
-        // const overallPower: number = overallPowerWrapper.context.overallPower;
-        let choosenDigiOns = [];
-        // initiale Bewertung
-        let digiOnsValuationFeeder = rateFeederDigiONS(ifeeder, anbindungsdata, valuationVector, overallStations, overallPower);
-        for (const value of digiOnsValuationFeeder.values()) {
-            result.push({
-                rz: (_b = (_a = value.wnConnectivityNode) === null || _a === void 0 ? void 0 : _a.getAssetUser()) === null || _b === void 0 ? void 0 : _b.name,
-                wnConnectivityNodeID: (_c = value.wnConnectivityNode) === null || _c === void 0 ? void 0 : _c.mrid,
-                usedBaysValue: value.usedBaysValue,
-                openedSwitchesValue: value.openedSwitchesValue,
-                feederFailureValue: value.feederFailureValue,
-                importanceValue: value.importanceScore,
-                healthValue: value.healthScore,
-                geographicalPositionValue: value.geographicalPositionScore,
-                schematicPositionValue: value.schematicPositionScore,
-                powerPositionValue: value.powerPositionScore,
-                operationValue: value.operationScore,
-                kpmValue: value.kpmScore,
-                cabelToOverheadLineValue: value.cableToOverheadLineScore,
-                digiOnsRatingValue: undefined, //value.digiOnsRating,
-                digiOnsPlacementOrder: undefined
-            });
-        }
-        // Setze Anzahl der zu digitalisierenden Stationen
-        let chooseAmount = valuationVector.digitalizationCount;
-        if (chooseAmount === -1) {
-            chooseAmount = digiOnsValuationFeeder.size;
-        }
-        let firstRealIteration = false;
-        // Falls keine DigiONS mehr bewertet wurde, sind alle gewaehlt worden
-        while (chooseAmount > 0 && digiOnsValuationFeeder.size > 0) {
-            const { digiOnsResult: chooseResult, wasMustCriteria } = chooseDigiONS(digiOnsValuationFeeder);
-            const placementOrder = choosenDigiOns.push(chooseResult.wnConnectivityNode);
-            const resultOfPlacedStation = result.find(a => a.wnConnectivityNodeID === chooseResult.wnConnectivityNode.mrid);
-            resultOfPlacedStation.digiOnsPlacementOrder = placementOrder;
-            if (wasMustCriteria) {
-                resultOfPlacedStation.digiOnsRatingValue = 1;
-            }
-            if (!wasMustCriteria && !firstRealIteration) {
-                resultOfPlacedStation.digiOnsRatingValue = chooseResult.digiOnsRating;
-                for (const value of digiOnsValuationFeeder.values()) {
-                    const resultEntry = result.find(a => a.wnConnectivityNodeID === value.wnConnectivityNode.mrid);
-                    if (resultEntry !== undefined && resultEntry.digiOnsPlacementOrder === undefined) {
-                        resultEntry.usedBaysValue = value.usedBaysValue;
-                        resultEntry.openedSwitchesValue = value.openedSwitchesValue;
-                        resultEntry.feederFailureValue = value.feederFailureValue;
-                        resultEntry.importanceValue = value.importanceScore;
-                        resultEntry.healthValue = value.healthScore;
-                        resultEntry.geographicalPositionValue = value.geographicalPositionScore;
-                        resultEntry.schematicPositionValue = value.schematicPositionScore;
-                        resultEntry.powerPositionValue = value.powerPositionScore;
-                        resultEntry.operationValue = value.operationScore;
-                        resultEntry.kpmValue = value.kpmScore;
-                        resultEntry.cabelToOverheadLineValue = value.cableToOverheadLineScore;
-                        resultEntry.digiOnsRatingValue = value.digiOnsRating;
-                    }
-                }
-                firstRealIteration = true;
-            }
-            digiOnsValuationFeeder = rateFeederDigiONS(ifeeder, anbindungsdata, valuationVector, overallStations, overallPower);
-            chooseAmount--;
-        }
-    }
-    return result;
-}
-export function rateFeederDigiONS(ifeeder, anbindungsdata, valuationVector, overallStations, overallPower) {
-    var _a;
-    const digiOnsValuation = new Map();
-    const feeder = ifeeder;
-    for (const wnConnectivityNode of feeder.normalEnergizedConnectivityNodes.values()) {
-        /** HeadNode gehört zur Umspannanlage */
-        if (wnConnectivityNode.name === ((_a = feeder.getHeadNode()) === null || _a === void 0 ? void 0 : _a.name))
-            continue;
-        /** Muffen und Kundenstationen werden nicht digitalisiert */
-        if (!isRelevant4Digitalization(wnConnectivityNode, anbindungsdata))
-            continue;
-        // NEPLAN-Krücke
-        // all stations that end with -XX-XXX should be ignored for the digitalization (X is a wildcard)
-        const namePatternToIgnoreStation = /-[\s\S]{2}-[\s\S]{3}$/;
-        if (namePatternToIgnoreStation.test(wnConnectivityNode.name))
-            continue;
-        // const cnName = voltageLevel.connectivityNodes.find(elem => elem.name?.length === 21);
-        // if (!cnName) continue;
-        const failureRate = wnConnectivityNode.getFailureRate();
-        // Pruefe, ob VoltageLevel bereits zu einer DigiONS geworden ist
-        if (isDigiONS(wnConnectivityNode))
-            continue;
-        // Ermittle zu-berechnende Werte
-        //let calculatedValues: ValueContext = depthFirstSearch(voltageLevel, feeder.getHeadNode(), feeder);
-        let calculatedValues = { resultStations: 0, resultPower: 0, minDistStations: 0, minDistPower: 0 };
-        // for (const cn of voltageLevel.connectivityNodes) {
-        // Erzeuge Baumstruktur
-        let completeTreeContext = convertAnyFeederNodeIntoTree(wnConnectivityNode, feeder);
-        // Shortest-Path Ermittlung bis zur naechsten DigiONS oder Umspannanlage
-        let distanceContext = {
-            context: { stationResult: 0, powerResult: 0, shortestPathFound: false, headNode: feeder.getHeadNode() },
-            callbackFunc: shortestPathCallbackFunc
-        };
-        breadthFirstTreeTraversal(completeTreeContext.rootNode, distanceContext);
-        calculatedValues.minDistStations = distanceContext.context.stationResult;
-        calculatedValues.minDistPower = distanceContext.context.powerResult;
-        // Extrahiere Informationen aus den Kontexten
-        calculatedValues.resultStations = 1 - Math.abs(((distanceContext.context.stationResult) / (0.5 * overallStations)) - 1);
-        calculatedValues.resultPower = 1 - Math.abs(((distanceContext.context.powerResult) / (0.5 * overallPower)) - 1);
-        if (!isFinite(calculatedValues.resultStations))
-            calculatedValues.resultStations = 0;
-        if (!isFinite(calculatedValues.resultPower))
-            calculatedValues.resultPower = 0;
-        if (!digiOnsValuation.has(wnConnectivityNode.getUUID())) {
-            const obj = {
-                name: wnConnectivityNode.name,
-                wnConnectivityNode: wnConnectivityNode,
-                usedBaysValue: getUsedBaysValue(wnConnectivityNode),
-                openedSwitchesValue: getOpenedSwitchesValue(wnConnectivityNode),
-                // feederFailureValue: getFailureRateValue(feeder.getFailureProbability()),
-                feederFailureValue: isFinite(failureRate) ? failureRate : 0,
-                importanceScore: getImportanceScore(wnConnectivityNode),
-                healthScore: getHealthScore(wnConnectivityNode),
-                geographicalPositionScore: 0,
-                schematicPositionScore: calculatedValues.resultStations,
-                powerPositionScore: calculatedValues.resultPower,
-                operationScore: 0,
-                kpmScore: 0,
-                cableToOverheadLineScore: getCableToOverheadLineValue(wnConnectivityNode),
-                digiOnsRating: 0,
-                minDistStations: calculatedValues.minDistStations,
-                sumStations: overallStations,
-                minDistPower: calculatedValues.minDistPower,
-                sumPower: overallPower
-            };
-            obj.digiOnsRating =
-                obj.usedBaysValue * valuationVector.usedBaysWeight +
-                    obj.openedSwitchesValue * valuationVector.openedSwitchesWeight +
-                    obj.feederFailureValue * valuationVector.feederFailureWeight +
-                    obj.importanceScore * valuationVector.importanceWeight +
-                    obj.healthScore * valuationVector.healthWeight +
-                    obj.geographicalPositionScore * valuationVector.geographicalPositionWeight +
-                    obj.schematicPositionScore * valuationVector.schematicPositionWeight +
-                    obj.powerPositionScore * valuationVector.powerPositionWeight +
-                    obj.operationScore * valuationVector.operationWeight +
-                    obj.kpmScore * valuationVector.kpmWeight +
-                    obj.cableToOverheadLineScore * valuationVector.cabelToOverheadLineWeight;
-            digiOnsValuation.set(wnConnectivityNode.getUUID(), obj);
-        }
-    }
-    return digiOnsValuation;
-}
-function getCableToOverheadLineValue(wnConnectivityNode) {
-    var _a;
-    const voltageLevel = wnConnectivityNode.getVoltageLevel();
-    let overheadLinesCount = 0;
-    let cabelCount = 0;
-    for (const cn of voltageLevel.connectivityNodes) {
-        for (const terminal of cn.terminals.values()) {
-            if (terminal.conductingEquipment instanceof ACLineSegment) {
-                const acLineSegment = terminal.conductingEquipment;
-                switch ((_a = acLineSegment.psrType) === null || _a === void 0 ? void 0 : _a.name) {
-                    case CimAssetAliasNames.OverHeadLine: {
-                        overheadLinesCount++;
-                        break;
-                    }
-                    case CimAssetAliasNames.Cable: {
-                        cabelCount++;
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    return (overheadLinesCount * cabelCount > 0) ? 1 : 0;
-}
-/**
- * Funktion zum Pruefen, ob in dem gegebenen VoltageLevel eine DigiONS vorhanden ist
- * bzw. ob das VotlageLevel eine DigiONS ist
- */
-export function isDigiONS(wnConnectivityNode) {
-    switch (wnConnectivityNode.getKind()) {
-        case WNFacilityKind.DIGIONS:
-        case WNFacilityKind.DIGIONS_1:
-        case WNFacilityKind.DIGIONS_6:
-        case WNFacilityKind.DIGIONS_7: {
-            return true;
-        }
-        default: {
-            return false;
-        }
-    }
-}
-function isRelevant4Digitalization(wnConnectivityNode, anbindungsdata) {
-    var _a;
-    const voltageLevel = wnConnectivityNode.getVoltageLevel();
-    if (!voltageLevel)
-        return false;
-    for (const connectivityNode of voltageLevel.connectivityNodes) {
-        const wnCn = connectivityNode;
-        const type = wnCn.getType(); //'Muffe'
-        const owner = wnCn.getAssetOwner();
-        if (type === 'Muffe')
-            return false;
-        if (type === 'Sonstige')
-            return false;
-        if (owner === 'Kundenstation')
-            return false;
-        /** Stichangebundene Stationen werden nicht digitalisiert */
-        if (((_a = anbindungsdata.find(elem => elem.uuid === connectivityNode.mrid)) === null || _a === void 0 ? void 0 : _a.type) === 'Stich')
-            return false;
-    }
-    // schaue, ob das WNConnectivityNode eine Sammelschiene darstellt
-    for (const wnConnectivityNodeTerminal of wnConnectivityNode.terminals.values()) {
-        if (wnConnectivityNodeTerminal.conductingEquipment instanceof BusbarSection) {
-            return false;
-        }
-    }
-    return true;
-}
-function getUsedBaysValue(wnConnectivityNode) {
-    const voltageLevel = wnConnectivityNode.getVoltageLevel();
-    let count = 0;
-    for (const cn of voltageLevel.connectivityNodes) {
-        for (const terminal of cn.terminals.values()) {
-            if (terminal.conductingEquipment instanceof ACLineSegment) {
-                if (terminal.connected)
-                    count++;
-            }
-        }
-    }
-    if (count > 3) {
-        return 1;
-    }
-    else if (count === 3) {
-        return 0.75;
-    }
-    else if (count === 2) {
-        return 0.5;
-    }
-    else {
-        return 0;
-    }
-}
-function getFailureRateValue(value) {
-    if (value >= 1) {
-        return 1;
-    }
-    else if (value >= 0.75) {
-        return 0.9;
-    }
-    else if (value >= 0.5) {
-        return 0.8;
-    }
-    else if (value >= 0.15) {
-        return 0.3;
-    }
-    else if (value >= 0.1) {
-        return 0.1;
-    }
-    else {
-        return 0;
-    }
-}
-function getOpenedSwitchesValue(wnConnectivityNode) {
-    const voltageLevel = wnConnectivityNode.getVoltageLevel();
-    let count = 0;
-    for (const cn of voltageLevel.connectivityNodes) {
-        for (const terminal of cn.terminals.values()) {
-            if (terminal.conductingEquipment instanceof ACLineSegment) {
-                if (!terminal.connected)
-                    count++;
-            }
-            if (terminal.conductingEquipment instanceof Switch) {
-                const swtch = terminal.conductingEquipment;
-                if (!terminal.connected || swtch.getOpen())
-                    count++;
-            }
-        }
-    }
-    if (count > 1) {
-        return 1;
-    }
-    else if (count === 1) {
-        return 0.75;
-    }
-    else {
-        return 0;
-    }
-}
-function getImportanceScore(wnConnectivityNode) {
-    const voltageLevel = wnConnectivityNode.getVoltageLevel();
-    for (const cn of voltageLevel.connectivityNodes) {
-        const score = cn.getImportanceScore();
-        if (score)
-            return score;
-    }
-    return 0;
-}
-function getHealthScore(wnConnectivityNode) {
-    const voltageLevel = wnConnectivityNode.getVoltageLevel();
-    for (const cn of voltageLevel.connectivityNodes) {
-        const score = cn.getHealthScore();
-        if (score)
-            return score;
-    }
-    return 0;
-}
-export function getFeederTreeData(cimModel, ifeeder) {
-    var _a, _b;
-    const feeder = ifeeder;
-    const graph = new Graph(cimModel);
-    const terminals = new Map();
-    const headNode = feeder.getHeadNode();
-    graph.addNode(new GraphNode(headNode.mrid, headNode.name, headNode));
-    /** ConenctivityNodes */
-    for (const cn of feeder.normalEnergizedConnectivityNodes.values()) {
-        graph.addNode(new GraphNode(cn.mrid, cn.name, cn));
-        for (const terminal of cn.terminals.values()) {
-            terminals.set(terminal.mrid, terminal);
-        }
-    }
-    /** Equipments */
-    for (const eq of feeder.additionalGroupedEquipment.values()) {
-        if (eq instanceof Switch) {
-            graph.addEdge(new GraphEdge(eq.mrid, eq.name, eq, Type.Switch, eq.open));
-        }
-        else if (eq instanceof EnergyConsumer) {
-            graph.addEdge(new GraphEdge(eq.mrid, eq.name, eq, Type.EnergyConsumer, false));
-        }
-        else if (eq instanceof ConductingEquipment) {
-            graph.addEdge(new GraphEdge(eq.mrid, eq.name, eq, Type.ConductingEquipment, false));
-        }
-        if (eq instanceof ConductingEquipment) {
-            for (const terminal of eq.terminals.values()) {
-                terminals.set(terminal.mrid, terminal);
-            }
-        }
-    }
-    /** Konnektivität durch Terminals */
-    for (const terminal of terminals.values()) {
-        const node = graph.nodes.get((_a = terminal.connectivityNode) === null || _a === void 0 ? void 0 : _a.mrid);
-        const edge = graph.edges.get((_b = terminal.conductingEquipment) === null || _b === void 0 ? void 0 : _b.mrid);
-        if (node && edge) {
-            const term = new Connection(terminal.mrid, terminal.connected, node, edge);
-            node.addTerminal(term);
-            edge.addTerminal(term);
-            graph.addTerminal(term);
-        }
-    }
-    return graph.createTreeBFS(headNode.mrid);
-}
-/**
- * Callback-Funktion für Shortest-Path bis zur nächsten DigiONS oder Umspannanlage
- */
-export function shortestPathCallbackFunc(treeNode, context, calltime) {
-    var _a;
-    if (context.shortestPathFound)
-        return;
-    if (calltime === BFSCalltime.BFS_NEXT_NODE) {
-        if (treeNode.cimObject instanceof WNConnectivityNode) {
-            const wnNode = treeNode.cimObject;
-            if (wnNode.name === ((_a = context.headNode) === null || _a === void 0 ? void 0 : _a.name) || isDigiONS(wnNode)) {
-                // Iteriere hin zum Root-TreeNode und ermittle die Distanz
-                let crtTreeNode = treeNode;
-                let ignoreValues = true; // Ignoriere die Werte der DigiONS/Umspannanlage
-                while (crtTreeNode) {
-                    // Zaehle ausschliesslich die WNConnectivityNodes und nicht die leitenden Elemente
-                    if (crtTreeNode.cimObject instanceof WNConnectivityNode) {
-                        if (!ignoreValues) {
-                            const namePatternToIgnoreStation = /-[\s\S]{2}-[\s\S]{3}$/;
-                            if (!namePatternToIgnoreStation.test(crtTreeNode.cimObject.name)) {
-                                context.stationResult += 1;
-                            }
-                            for (const terminal of crtTreeNode.cimObject.terminals.values()) {
-                                const condEquip = terminal.conductingEquipment;
-                                // Fuege Leistung hinzu (ausschliesslich die EnergyConsumer)
-                                if (condEquip instanceof EnergyConsumer) {
-                                    context.powerResult += condEquip.getApparentPower();
-                                }
-                            }
-                        }
-                        else {
-                            ignoreValues = false;
-                        }
-                    }
-                    crtTreeNode = crtTreeNode.parent;
-                }
-                // Füge die Leistungen der aktuellen Station als Werte hinzu
-                /*if (crtTreeNode.cimObject instanceof WNConnectivityNode) {
-                  for (const terminal of crtTreeNode.cimObject.terminals.values()) {
-                    const condEquip = terminal.conductingEquipment;
-                    if (condEquip instanceof EnergyConsumer) {
-                      context.powerResult += condEquip.getApparentPower();
-                    }
-                  }
-                }*/
-                context.shortestPathFound = true;
-                return;
-            }
-        }
-    }
-}
-/**
- * Callback-Funktion für das Berechnen der Gesamt-Summe an Leistung
- */
-export function overallPowerCallbackFunc(treeNode, context, calltime) {
-    if (calltime === LeafNodeCalltime.LEAF_NODE_LOOP_TO_ROOT) {
-        if (!context.nodesVisited.has(treeNode.cimObject)) {
-            context.nodesVisited.add(treeNode.cimObject);
-            if (treeNode.cimObject instanceof ConnectivityNode) {
-                for (const terminal of treeNode.cimObject.terminals.values()) {
-                    const condEquip = terminal.conductingEquipment;
-                    // Fuege Leistung hinzu (ausschliesslich die EnergyConsumer)
-                    if (condEquip instanceof EnergyConsumer) {
-                        context.overallPower += condEquip.getApparentPower();
-                    }
-                }
-            }
-        }
-    }
-}
-/**
- * Callback-Funktion für das Berechnen der Gesamtwerte für die DigiONS-Bewertung
- */
-export function overallValueDetermineCallbackFunc(treeNode, context, calltime) {
-    var _a;
-    if (calltime === LeafNodeCalltime.LEAF_NODE_PRE_NEXT) {
-        context.crtWayStack = [];
-        context.isBranchRelevant = false;
-    }
-    else if (calltime === LeafNodeCalltime.LEAF_NODE_POST_NEXT) {
-        if (context.isBranchRelevant) {
-            // werfe das root node weg, da es nicht relevant ist
-            context.crtWayStack.pop();
-            // leere den way-stack schrittweise
-            let crtStackElem = undefined;
-            let first = true;
-            while (crtStackElem = context.crtWayStack.pop()) {
-                if (first) {
-                    first = false;
-                    context.rootNodes.add(crtStackElem);
-                }
-                if (!context.distances.has(crtStackElem.cimObject.mrid)) {
-                    context.distances.set(crtStackElem.cimObject.mrid, context.crtWayStack.length);
-                    context.mridTreeNodeMap.set(crtStackElem.cimObject.mrid, crtStackElem);
-                    // Bilde Rückwärtsstruktur
-                    if (context.crtWayStack.length > 0) {
-                        context.nodesVisitedWay.set(crtStackElem.cimObject.mrid, context.crtWayStack[context.crtWayStack.length - 1]);
-                    }
-                }
-                else {
-                    // CimObjekt ist bereits vorhanden
-                    const crtDistance = context.distances.get(crtStackElem.cimObject.mrid);
-                    // falls kuerzerer weg gefunden, aktualisiere
-                    if (context.crtWayStack.length < crtDistance) {
-                        // aktualisiere die Speicherung
-                        context.distances.set(crtStackElem.cimObject.mrid, context.crtWayStack.length);
-                        context.mridTreeNodeMap.set(crtStackElem.cimObject.mrid, crtStackElem);
-                        // Bilde Rückwärtsstruktur
-                        if (context.crtWayStack.length > 0) {
-                            context.nodesVisitedWay.set(crtStackElem.cimObject.mrid, context.crtWayStack[context.crtWayStack.length - 1]);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    else if (calltime === LeafNodeCalltime.LEAF_NODE_LOOP_TO_ROOT) {
-        if (treeNode.cimObject instanceof ConnectivityNode) {
-            const cNode = treeNode.cimObject;
-            // Wurde eine DigiONS oder eine Umspannanlage gefunden?
-            let resetValues = cNode.name === context.wnFeeder.getHeadNode().name;
-            if (cNode instanceof WNConnectivityNode) {
-                const wnCNode = cNode;
-                if (wnCNode.getKind() === WNFacilityKind.DIGIONS) {
-                    resetValues = true;
-                }
-            }
-            if (resetValues) {
-                context.isBranchRelevant = true;
-                context.crtWayStack = [];
-            }
-            if (context.isBranchRelevant) {
-                context.crtWayStack.push(treeNode);
-            }
-        }
-    }
-    else if (calltime === LeafNodeCalltime.END) {
-        for (const rootChildNode of context.rootNodes) {
-            if (context.mridTreeNodeMap.has(rootChildNode.cimObject.mrid)) {
-                let crtElem = context.mridTreeNodeMap.get(rootChildNode.cimObject.mrid);
-                while (crtElem) {
-                    const cNode = crtElem.cimObject;
-                    if (!(cNode.name === ((_a = context.wnFeeder.getHeadNode()) === null || _a === void 0 ? void 0 : _a.name) || cNode.getKind() === WNFacilityKind.DIGIONS)) {
-                        // ignoriere die Werte der DigiONS oder Umspannanlage (letzter Knoten bevor die while-Schleife abbricht)
-                        for (const terminal of cNode.terminals.values()) {
-                            const condEquip = terminal.conductingEquipment;
-                            // Fuege Leistung hinzu (ausschliesslich die EnergyConsumer)
-                            if (condEquip instanceof EnergyConsumer) {
-                                context.overallPower += condEquip.getApparentPower();
-                            }
-                        }
-                        context.overallStations += 1;
-                    }
-                    crtElem = context.nodesVisitedWay.get(crtElem.cimObject.mrid);
-                }
-            }
-            else {
-                // case: Direkter Nachbar zu einer DigiONS oder Umspannanlage
-            }
-        }
-    }
-}
-/**
- * Callback-Funktion für das Berechnen der Werte zur Bewertung und Auswahl von DigiONS
- */
-export function calculateDigiONSValuesCallbackFunc(treeNode, context, calltime) {
-    if (calltime === LeafNodeCalltime.LEAF_NODE_PRE_NEXT) {
-        context.branchStations = 0;
-        context.branchPower = 0;
-        context.isBranchRelevant = false;
-    }
-    else if (calltime === LeafNodeCalltime.LEAF_NODE_POST_NEXT) {
-        // Branch muss relevant sein
-        if (context.isBranchRelevant) {
-            context.allBranchesStations.push(context.branchStations);
-            context.allBranchesPower.push(context.branchPower);
-            context.overallStations += context.branchStations;
-            context.overallPower += context.branchPower;
-        }
-    }
-    else if (calltime === LeafNodeCalltime.LEAF_NODE_LOOP_TO_ROOT) {
-        context.ignoreValues = false;
-        if (treeNode.cimObject instanceof ConnectivityNode) {
-            const cNode = treeNode.cimObject;
-            let resetValues = cNode.name === context.wnFeeder.getHeadNode().name;
-            if (cNode instanceof WNConnectivityNode) {
-                const wnCNode = cNode;
-                if (wnCNode.getKind() === WNFacilityKind.DIGIONS) {
-                    resetValues = true;
-                }
-            }
-            if (resetValues) {
-                context.branchStations = 0;
-                context.branchPower = 0;
-                context.isBranchRelevant = true;
-                context.ignoreValues = true;
-            }
-            for (const terminal of cNode.terminals.values()) {
-                const condEquip = terminal.conductingEquipment;
-                // Fuege Leistung hinzu (ausschliesslich die EnergyConsumer)
-                if (!context.ignoreValues) {
-                    if (condEquip instanceof EnergyConsumer) {
-                        context.branchPower += condEquip.getApparentPower();
-                    }
-                }
-            }
-            // Inkrementiere Anzahl Stationen
-            if (!context.ignoreValues && treeNode.parent)
-                context.branchStations += 1;
-        }
-    }
-    else if (calltime === LeafNodeCalltime.END) {
-        // Berechne die Werte entsprechend der gegebenen Formeln
-        context.resultStationsValue = 0;
-        context.resultPowerValue = 0;
-        for (const branchStationsValue of context.allBranchesStations) {
-            context.resultStationsValue += branchStationsValue / (0.5 * context.overallStations);
-        }
-        context.resultStationsValue /= context.allBranchesStations.length;
-        for (const branchPowerValue of context.allBranchesPower) {
-            context.resultPowerValue += branchPowerValue / (0.5 * context.overallPower);
-        }
-        context.resultPowerValue /= context.allBranchesPower.length;
-        // Falls keine Power-Values/Stationen summiert wurden, wurde vorab durch 0 geteilt.
-        // Pruefe daher, ob Werte finit sind
-        if (!isFinite(context.resultStationsValue))
-            context.resultStationsValue = 0;
-        if (!isFinite(context.resultPowerValue))
-            context.resultPowerValue = 0;
-    }
-}
-//# sourceMappingURL=digi-ons.js.map