@enervance/insight-cim-model 0.0.61 → 0.0.63

package/dist/analysis/analysis-neplan/digi-ons.d.ts

@@ -1,14 +1,19 @@
-import { Model } from '../../model/model/Model';
+/** Bestimmung des DigiONS-Score-Wertes für die Digitalisierung von Stationen innerhalb eines Abganges*/
 import { GraphTree } from '../../data-structures/tree/GraphTree';
 import { WNFeeder } from '../../model/extensions/neplan-westnetz/core/WNFeeder';
 import { IFeeder } from '../../interfaces/model/core/IFeeder';
 import { VoltageLevel } from '../../model/core/VoltageLevel';
 import { IIdentifiedObject } from "../../interfaces/model/core/IIdentifiedObject";
 import { BFSCalltime, LeafNodeCalltime, TreeNode } from "../../util/collection/util-tree";
-export declare function rateDigiONS(cimModel: Model, anbindungsdata: IStationanbindung[], valuationVector: IDigiOnsValuationVector): IDigiOnsResult[];
+import { ModelContainer } from '../../model-container/model/ModelContainer';
+export declare function rateDigiONS(cimModel: ModelContainer, anbindungsdata: IStationanbindung[], valuationVector: IDigiOnsValuationVector): IDigiOnsResult[];
 export declare function rateFeederDigiONS(ifeeder: IFeeder, anbindungsdata: IStationanbindung[], valuationVector: IDigiOnsValuationVector, overallStations: number, overallPower: number): Map<string, IDigiOnsValuation>;
+/**
+ * Funktion zum Pruefen, ob in dem gegebenen VoltageLevel eine DigiONS vorhanden ist
+ * bzw. ob das VotlageLevel eine DigiONS ist
+ */
 export declare function isDigiONS(voltageLevel: VoltageLevel): boolean;
-export declare function getFeederTreeData(cimModel: Model, ifeeder: IFeeder): GraphTree;
+export declare function getFeederTreeData(cimModel: ModelContainer, ifeeder: IFeeder): GraphTree;
 export interface IDigiOnsValuation {
     name: string;
     model: any;
@@ -30,17 +35,30 @@ export interface IDigiOnsValuation {
     sumPower: number;
 }
 export interface IDigiOnsValuationVector {
+    /** Anzahl der zu digitalisierenden Stationen
+     * -1 kein Limit*/
     digitalizationCount: number;
+    /** Gewichtung: Anzahl belegter Kabelfelder */
     usedBaysWeight: number;
+    /** Gewichtung: Anzahl offener Trennstellen  */
     openedSwitchesWeight: number;
+    /** Gewichtung: Strang Ausfallwahrscheinlichkeit CAIFI */
     feederFailureWeight: number;
+    /** Gewichtung: Wichtigkeit (ZUWO) -> Analytic/ImportanceScore */
     importanceWeight: number;
+    /** Gewichtung: strategischer Zustand (ZUWO) -> Analytic/HealthScore */
     healthWeight: number;
+    /** Gewichtung: geografische Position im Abgang */
     geographicalPositionWeight: number;
+    /** Gewichtung: schematische Mitte im Abgang (gleiche Anzahl Stationen vor und nach der DigiONS) */
     schematicPositionWeight: number;
+    /** Gewichtung: Lage der Station bezogen auf die Leistungsmitte (Last, nicht Einspeisung) */
     powerPositionWeight: number;
+    /** Gewichtung: Bedeutung der Station für Systemführung (als von der Systemführung „subjektiv“ vorgegebener Wert vs. automatisierte Logik, die die Sicht der Betriebsführung abbildet) */
     operationWeight: number;
+    /** Gewichtung: Sonderposition (Anforderung KPM) */
     kpmWeight: number;
+    /** Gewichtung: Übergang Kabel zu Freileitung (vice versa) */
     cabelToOverheadLineWeight: number;
 }
 export interface IDigiOnsResult {
@@ -50,7 +68,9 @@ export interface IDigiOnsResult {
     usedBaysValue: number;
     openedSwitchesValue: number;
     feederFailureValue: number;
+    /** Gewichtung: Wichtigkeit (ZUWO) -> Analytic/ImportanceScore */
     importanceValue: number;
+    /** Gewichtung: strategischer Zustand (ZUWO) -> Analytic/HealthScore */
     healthValue: number;
     geographicalPositionValue: number;
     schematicPositionValue: number;
@@ -61,24 +81,47 @@ export interface IDigiOnsResult {
     digiOnsRatingValue: number;
     digiOnsPlacementOrder: number;
 }
+/** Stammstrecke oder Stich */
 export interface IStationanbindung {
     uuid: string;
     type: string;
 }
+/**
+ * Kontext für Shortest-Path bis zur nächsten DigiONS oder Umspannanlage
+ */
 export interface ShortestPathContext {
+    /** Anzahl der Stationen von der betrachteten Station zur nächstgelegenen Fernsteuermöglichkeit */
     stationResult: number;
+    /** Summe der Leistung von der betrachteten Station zur nächstgelegenen Fernsteuermöglichkeit */
     powerResult: number;
+    /** HeadNode des Feeders */
     headNode: IIdentifiedObject;
+    /** true, insofern auf eine nächstgelegenen Fernsteuermöglichkeit gestossen wurde */
     shortestPathFound: boolean;
 }
+/**
+ * Callback-Funktion für Shortest-Path bis zur nächsten DigiONS oder Umspannanlage
+ */
 export declare function shortestPathCallbackFunc(treeNode: Readonly<TreeNode>, context: ShortestPathContext, calltime: Readonly<BFSCalltime>): void;
+/**
+ * Kontext für das Berechnen der Gesamt-Summe an Leistung
+ */
 export interface OverallPowerContext {
+    /** Bereits besuchte Knoten (verhindert, dass ein Knoten doppelt in die Gesamt-Leistung einfliesst) */
     nodesVisited: Set<IIdentifiedObject>;
+    /** Gesamtanzahl der Leistungen aller Stationen (Stammstrecke(n) und Stiche) des Abgangs */
     overallPower: number;
 }
+/**
+ * Callback-Funktion für das Berechnen der Gesamt-Summe an Leistung
+ */
 export declare function overallPowerCallbackFunc(treeNode: Readonly<TreeNode>, context: OverallPowerContext, calltime: Readonly<LeafNodeCalltime>): void;
+/**
+ * Kontext für das Berechnen der Gesamtwerte für die DigiONS-Bewertung
+ */
 export interface OverallValueDetermineContext {
     wnFeeder: WNFeeder;
+    /** Menge von relevanten TreeNodes, die Einfluss auf die gesamten Werte haben*/
     crtWayStack: TreeNode[];
     distances: Map<string, number>;
     mridTreeNodeMap: Map<string, TreeNode>;
@@ -88,7 +131,13 @@ export interface OverallValueDetermineContext {
     overallPower: number;
     isBranchRelevant: boolean;
 }
+/**
+ * Callback-Funktion für das Berechnen der Gesamtwerte für die DigiONS-Bewertung
+ */
 export declare function overallValueDetermineCallbackFunc(treeNode: Readonly<TreeNode>, context: OverallValueDetermineContext, calltime: Readonly<LeafNodeCalltime>): void;
+/**
+ * Kontext für das Berechnen der Werte zur Bewertung und Auswahl von DigiONS
+ */
 export interface CalculateDigiONSValuesContext {
     wnFeeder: WNFeeder;
     resultStationsValue: number;
@@ -102,4 +151,7 @@ export interface CalculateDigiONSValuesContext {
     isBranchRelevant: boolean;
     ignoreValues: boolean;
 }
+/**
+ * Callback-Funktion für das Berechnen der Werte zur Bewertung und Auswahl von DigiONS
+ */
 export declare function calculateDigiONSValuesCallbackFunc(treeNode: Readonly<TreeNode>, context: CalculateDigiONSValuesContext, calltime: Readonly<LeafNodeCalltime>): void;

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

@@ -1,4 +1,5 @@
 "use strict";
+/** Bestimmung des DigiONS-Score-Wertes für die Digitalisierung von Stationen innerhalb eines Abganges*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateDigiONSValuesCallbackFunc = exports.overallValueDetermineCallbackFunc = exports.overallPowerCallbackFunc = exports.shortestPathCallbackFunc = exports.getFeederTreeData = exports.isDigiONS = exports.rateFeederDigiONS = exports.rateDigiONS = void 0;
 const WNConnectivityNode_1 = require("../../model/extensions/neplan-westnetz/core/WNConnectivityNode");
@@ -19,6 +20,10 @@ const util_tree_1 = require("../../util/collection/util-tree");
 const util_excel_1 = require("../../util/collection/util-excel");
 const cim_asset_types_1 = require("../../constants/cim-asset-types");
 const util_graph_1 = require("../../util/collection/util-graph");
+/**
+ * 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);
@@ -26,8 +31,10 @@ function chooseDigiONS(digiOnsResultsMap) {
     if (digiOnsResult === undefined) {
         digiOnsResult = sortedDigiOnsResults.pop();
     }
+    // Setze digiOns-Markierung
     let choosenDigiONS = undefined;
     if (digiOnsResult.model instanceof VoltageLevel_1.VoltageLevel) {
+        // case VoltageLevel
         for (const cnNode of digiOnsResult.model.connectivityNodes) {
             if (cnNode.name === digiOnsResult.name) {
                 choosenDigiONS = cnNode;
@@ -36,6 +43,7 @@ function chooseDigiONS(digiOnsResultsMap) {
         }
     }
     else {
+        // case WNConnectivityNode
         choosenDigiONS = digiOnsResult.model;
     }
     if (!choosenDigiONS)
@@ -44,19 +52,24 @@ function chooseDigiONS(digiOnsResultsMap) {
     return choosenDigiONS;
 }
 function rateDigiONS(cimModel, anbindungsdata, valuationVector) {
-    var _a;
     const result = [];
     for (const ifeeder of cimModel.feeders.values()) {
+        /* Berechne Gesamtwerte (Gesamt-Summe der Leistung und Gesamtanzahl an Stationen) */
         let trunkLineContextWrapper = {
-            context: { trunkLineLines: [], trunkLineNodes: [], onTrunkLine: false, uniqueTrunkNodes: new Set() },
+            context: {
+                trunkLineLines: [],
+                trunkLineNodes: [],
+                onTrunkLine: false,
+                uniqueTrunkNodes: new Set()
+            },
             callbackFunc: util_graph_1.markAsTrunkLineCallbackFunc
         };
         let overallPowerWrapper = {
             context: { nodesVisited: new Set(), overallPower: 0 },
             callbackFunc: overallPowerCallbackFunc
         };
-        let feederTreeContext = util_graph2tree_1.convertFeederIntoTree(ifeeder);
-        util_tree_1.leafNodeTraversal(feederTreeContext.leafNodes, trunkLineContextWrapper, overallPowerWrapper);
+        let feederTreeContext = (0, util_graph2tree_1.convertFeederIntoTree)(ifeeder);
+        (0, util_tree_1.leafNodeTraversal)(feederTreeContext.leafNodes, trunkLineContextWrapper, overallPowerWrapper);
         let overallStations = 0;
         for (const node of trunkLineContextWrapper.context.uniqueTrunkNodes) {
             if (node instanceof ConnectivityNode_1.ConnectivityNode) {
@@ -65,14 +78,15 @@ function rateDigiONS(cimModel, anbindungsdata, valuationVector) {
         }
         const overallPower = overallPowerWrapper.context.overallPower;
         let choosenDigiOns = [];
+        // initiale Bewertung
         let digiOnsValuationFeeder = rateFeederDigiONS(ifeeder, anbindungsdata, valuationVector, overallStations, overallPower);
         let initialFeederRateResults = digiOnsValuationFeeder;
         for (const value of initialFeederRateResults.values()) {
             const wnConnectivityNode = value.model.connectivityNodes.find(elem => elem);
             result.push({
                 voltageLevelUUID: value.model.mrid,
-                rz: (_a = wnConnectivityNode === null || wnConnectivityNode === void 0 ? void 0 : wnConnectivityNode.getAssetUser()) === null || _a === void 0 ? void 0 : _a.name,
-                connectivityNodeUUID: wnConnectivityNode === null || wnConnectivityNode === void 0 ? void 0 : wnConnectivityNode.mrid,
+                rz: wnConnectivityNode?.getAssetUser()?.name,
+                connectivityNodeUUID: wnConnectivityNode?.mrid,
                 usedBaysValue: value.usedBaysValue,
                 openedSwitchesValue: value.openedSwitchesValue,
                 feederFailureValue: value.feederFailureValue,
@@ -88,19 +102,27 @@ function rateDigiONS(cimModel, anbindungsdata, valuationVector) {
                 digiOnsPlacementOrder: undefined
             });
         }
+        /* BEGIN: Excel-Export DigiONS Bewertung */
         const excelExportEnabled = false;
+        //const feederEndsWith: string = "019";
+        //const exportIterationAmount = 7;
         let excelSheetNames = [];
         let excelSheetValues = [];
+        /* END: Excel-Export DigiONS Bewertung */
+        // Setze Anzahl der zu digitalisierenden Stationen
         let chooseAmount = valuationVector.digitalizationCount;
         if (chooseAmount === -1) {
             chooseAmount = digiOnsValuationFeeder.size;
         }
+        // Falls keine DigiONS mehr bewertet wurde, sind alle gewaehlt worden
         while (chooseAmount > 0 && digiOnsValuationFeeder.size > 0) {
             const chooseResult = chooseDigiONS(digiOnsValuationFeeder);
             const placementOrder = choosenDigiOns.push(chooseResult);
-            if (excelExportEnabled) {
-                const values = util_excel_1.convertDigiOnsValuationsToRowwiseValues(digiOnsValuationFeeder);
-                values.unshift(util_excel_1.createDigiOnsValuationTableHeader());
+            /* BEGIN: Excel-Export DigiONS Bewertung */
+            if (excelExportEnabled /*&& ifeeder.name.endsWith(feederEndsWith)*/) {
+                //if (placementOrder <= exportIterationAmount) {
+                const values = (0, util_excel_1.convertDigiOnsValuationsToRowwiseValues)(digiOnsValuationFeeder);
+                values.unshift((0, util_excel_1.createDigiOnsValuationTableHeader)());
                 values.push([""]);
                 let choosenResultExcel = [];
                 choosenResultExcel.push("Ausgewählte Station:");
@@ -108,44 +130,55 @@ function rateDigiONS(cimModel, anbindungsdata, valuationVector) {
                 values.push(choosenResultExcel);
                 excelSheetValues.push(values);
                 excelSheetNames.push(`Iteration ${placementOrder}`);
+                //}
             }
+            /* END: Excel-Export DigiONS Bewertung */
             result.find(a => a.voltageLevelUUID === chooseResult.getVoltageLevel().mrid).digiOnsPlacementOrder = placementOrder;
             digiOnsValuationFeeder = rateFeederDigiONS(ifeeder, anbindungsdata, valuationVector, overallStations, overallPower);
             chooseAmount--;
         }
-        if (excelExportEnabled) {
-            util_excel_1.exportDataAsXLSX({ filepath: `${ifeeder.name}`, sheetNames: excelSheetNames, sheetValues: excelSheetValues });
+        /* BEGIN: Excel-Export DigiONS Bewertung */
+        if (excelExportEnabled /*&& ifeeder.name.endsWith(feederEndsWith)*/) {
+            (0, util_excel_1.exportDataAsXLSX)({ filepath: `${ifeeder.name}`, sheetNames: excelSheetNames, sheetValues: excelSheetValues });
         }
+        /* END: Excel-Export DigiONS Bewertung */
     }
     return result;
 }
 exports.rateDigiONS = rateDigiONS;
 function rateFeederDigiONS(ifeeder, anbindungsdata, valuationVector, overallStations, overallPower) {
-    var _a;
     const digiOnsValuation = new Map();
     const feeder = ifeeder;
     for (const cn of feeder.normalEnergizedConnectivityNodes.values()) {
         const voltageLevel = cn.getVoltageLevel();
-        if (cn.name === ((_a = feeder.getHeadNode()) === null || _a === void 0 ? void 0 : _a.name))
+        /** HeadNode gehört zur Schwerpunktstation */
+        if (cn.name === feeder.getHeadNode()?.name)
             continue;
+        /** Muffen und Kundenstationen werden nicht digitalisiert */
         if (!isRelevant4Digitalization(voltageLevel, anbindungsdata))
             continue;
-        const cnName = voltageLevel.connectivityNodes.find(elem => { var _a; return ((_a = elem.name) === null || _a === void 0 ? void 0 : _a.length) === 21; });
+        const cnName = voltageLevel.connectivityNodes.find(elem => elem.name?.length === 21);
         if (!cnName)
             continue;
         const failureRate = cn.getFailureRate();
+        // Pruefe, ob VoltageLevel bereits zu einer DigiONS geworden ist
         if (isDigiONS(voltageLevel))
             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) {
-            let completeTreeContext = util_graph2tree_1.convertAnyFeederNodeIntoTree(cn, feeder);
+            // Erzeuge Baumstruktur
+            let completeTreeContext = (0, util_graph2tree_1.convertAnyFeederNodeIntoTree)(cn, feeder);
+            // Shortest-Path Ermittlung bis zur naechsten DigiONS oder Umspannanlage
             let distanceContext = {
                 context: { stationResult: 0, powerResult: 0, shortestPathFound: false, headNode: feeder.getHeadNode() },
                 callbackFunc: shortestPathCallbackFunc
             };
-            util_tree_1.breadthFirstTreeTraversal(completeTreeContext.rootNode, distanceContext);
+            (0, util_tree_1.breadthFirstTreeTraversal)(completeTreeContext.rootNode, distanceContext);
             calculatedValues.minDistStations = distanceContext.context.stationResult;
             calculatedValues.minDistPower = distanceContext.context.powerResult;
+            // Extrahiere Informationen aus den Kontexten
             calculatedValues.resultStations =
                 (distanceContext.context.stationResult) / (0.5 * overallStations);
             calculatedValues.resultPower =
@@ -161,6 +194,7 @@ function rateFeederDigiONS(ifeeder, anbindungsdata, valuationVector, overallStat
                 model: voltageLevel,
                 usedBaysValue: getUsedBaysValue(voltageLevel),
                 openedSwitchesValue: getOpenedSwitchesValue(voltageLevel),
+                // feederFailureValue: getFailureRateValue(feeder.getFailureProbability()),
                 feederFailureValue: isFinite(failureRate) ? failureRate : 0,
                 importanceScore: getImportanceScore(voltageLevel),
                 healthScore: getHealthScore(voltageLevel),
@@ -195,14 +229,13 @@ function rateFeederDigiONS(ifeeder, anbindungsdata, valuationVector, overallStat
 }
 exports.rateFeederDigiONS = rateFeederDigiONS;
 function getCabelToOverheadLineValue(voltageLevel) {
-    var _a;
     let overheadLinesCount = 0;
     let cabelCount = 0;
     for (const cn of voltageLevel.connectivityNodes) {
         for (const terminal of cn.terminals.values()) {
             if (terminal.conductingEquipment instanceof ACLineSegment_1.ACLineSegment) {
                 const acLineSegment = terminal.conductingEquipment;
-                switch ((_a = acLineSegment.psrType) === null || _a === void 0 ? void 0 : _a.name) {
+                switch (acLineSegment.psrType?.name) {
                     case cim_asset_types_1.CIM_ASSET_NAMES.OverHeadLine: {
                         overheadLinesCount++;
                         break;
@@ -217,6 +250,10 @@ function getCabelToOverheadLineValue(voltageLevel) {
     }
     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
+ */
 function isDigiONS(voltageLevel) {
     for (const cn of voltageLevel.connectivityNodes) {
         const wnCn = cn;
@@ -235,16 +272,16 @@ function isDigiONS(voltageLevel) {
 }
 exports.isDigiONS = isDigiONS;
 function isRelevant4Digitalization(voltageLevel, anbindungsdata) {
-    var _a;
     for (const cn of voltageLevel.connectivityNodes) {
         const wnCn = cn;
-        const type = wnCn.getType();
+        const type = wnCn.getType(); //'Muffe'
         const owner = wnCn.getAssetOwner();
         if (type === 'Muffe')
             return false;
         if (owner === 'Kundenstation')
             return false;
-        if (((_a = anbindungsdata.find(elem => elem.uuid === cn.mrid)) === null || _a === void 0 ? void 0 : _a.type) === 'Stich')
+        /** Stichangebundene Stationen werden nicht digitalisiert */
+        if (anbindungsdata.find(elem => elem.uuid === cn.mrid)?.type === 'Stich')
             return false;
     }
     return true;
@@ -334,18 +371,19 @@ function getHealthScore(voltageLevel) {
     return 0;
 }
 function getFeederTreeData(cimModel, ifeeder) {
-    var _a, _b;
     const feeder = ifeeder;
     const graph = new graph_1.Graph(cimModel);
     const terminals = new Map();
     const headNode = feeder.getHeadNode();
     graph.addNode(new GraphNode_1.GraphNode(headNode.mrid, headNode.name, headNode));
+    /** ConenctivityNodes */
     for (const cn of feeder.normalEnergizedConnectivityNodes.values()) {
         graph.addNode(new GraphNode_1.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_1.Switch) {
             graph.addEdge(new GraphEdge_1.GraphEdge(eq.mrid, eq.name, eq, Types_1.Type.Switch, eq.open));
@@ -362,9 +400,10 @@ function getFeederTreeData(cimModel, ifeeder) {
             }
         }
     }
+    /** 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);
+        const node = graph.nodes.get(terminal.connectivityNode?.mrid);
+        const edge = graph.edges.get(terminal.conductingEquipment?.mrid);
         if (node && edge) {
             const term = new connection_1.Connection(terminal.mrid, terminal.connected, node, edge);
             node.addTerminal(term);
@@ -375,22 +414,27 @@ function getFeederTreeData(cimModel, ifeeder) {
     return graph.createTreeBFS(headNode.mrid);
 }
 exports.getFeederTreeData = getFeederTreeData;
+/**
+ * Callback-Funktion für Shortest-Path bis zur nächsten DigiONS oder Umspannanlage
+ */
 function shortestPathCallbackFunc(treeNode, context, calltime) {
-    var _a;
     if (context.shortestPathFound)
         return;
     if (calltime === util_tree_1.BFSCalltime.BFS_NEXT_NODE) {
         if (treeNode.cimObject instanceof WNConnectivityNode_1.WNConnectivityNode) {
             const wnNode = treeNode.cimObject;
-            if (wnNode.name === ((_a = context.headNode) === null || _a === void 0 ? void 0 : _a.name) || wnNode.getKind() === WNFacilityKind_1.WNFacilityKind.DIGIONS) {
+            if (wnNode.name === context.headNode?.name || wnNode.getKind() === WNFacilityKind_1.WNFacilityKind.DIGIONS) {
+                // Iteriere hin zum Root-TreeNode und ermittle die Distanz
                 let crtTreeNode = treeNode;
-                let ignoreValues = true;
+                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_1.WNConnectivityNode) {
                         if (!ignoreValues) {
                             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_1.EnergyConsumer) {
                                     context.powerResult += condEquip.getApparentPower();
                                 }
@@ -402,6 +446,15 @@ function shortestPathCallbackFunc(treeNode, context, calltime) {
                     }
                     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;
             }
@@ -409,6 +462,9 @@ function shortestPathCallbackFunc(treeNode, context, calltime) {
     }
 }
 exports.shortestPathCallbackFunc = shortestPathCallbackFunc;
+/**
+ * Callback-Funktion für das Berechnen der Gesamt-Summe an Leistung
+ */
 function overallPowerCallbackFunc(treeNode, context, calltime) {
     if (calltime === util_tree_1.LeafNodeCalltime.LEAF_NODE_LOOP_TO_ROOT) {
         if (!context.nodesVisited.has(treeNode.cimObject)) {
@@ -416,6 +472,7 @@ function overallPowerCallbackFunc(treeNode, context, calltime) {
             if (treeNode.cimObject instanceof ConnectivityNode_1.ConnectivityNode) {
                 for (const terminal of treeNode.cimObject.terminals.values()) {
                     const condEquip = terminal.conductingEquipment;
+                    // Fuege Leistung hinzu (ausschliesslich die EnergyConsumer)
                     if (condEquip instanceof EnergyConsumer_1.EnergyConsumer) {
                         context.overallPower += condEquip.getApparentPower();
                     }
@@ -425,15 +482,19 @@ function overallPowerCallbackFunc(treeNode, context, calltime) {
     }
 }
 exports.overallPowerCallbackFunc = overallPowerCallbackFunc;
+/**
+ * Callback-Funktion für das Berechnen der Gesamtwerte für die DigiONS-Bewertung
+ */
 function overallValueDetermineCallbackFunc(treeNode, context, calltime) {
-    var _a;
     if (calltime === util_tree_1.LeafNodeCalltime.LEAF_NODE_PRE_NEXT) {
         context.crtWayStack = [];
         context.isBranchRelevant = false;
     }
     else if (calltime === util_tree_1.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()) {
@@ -444,15 +505,20 @@ function overallValueDetermineCallbackFunc(treeNode, context, calltime) {
                 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]);
                         }
@@ -464,6 +530,7 @@ function overallValueDetermineCallbackFunc(treeNode, context, calltime) {
     else if (calltime === util_tree_1.LeafNodeCalltime.LEAF_NODE_LOOP_TO_ROOT) {
         if (treeNode.cimObject instanceof ConnectivityNode_1.ConnectivityNode) {
             const cNode = treeNode.cimObject;
+            // Wurde eine DigiONS oder eine Umspannanlage gefunden?
             let resetValues = cNode.name === context.wnFeeder.getHeadNode().name;
             if (cNode instanceof WNConnectivityNode_1.WNConnectivityNode) {
                 const wnCNode = cNode;
@@ -486,9 +553,11 @@ function overallValueDetermineCallbackFunc(treeNode, context, calltime) {
                 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_1.WNFacilityKind.DIGIONS)) {
+                    if (!(cNode.name === context.wnFeeder.getHeadNode()?.name || cNode.getKind() === WNFacilityKind_1.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_1.EnergyConsumer) {
                                 context.overallPower += condEquip.getApparentPower();
                             }
@@ -499,11 +568,15 @@ function overallValueDetermineCallbackFunc(treeNode, context, calltime) {
                 }
             }
             else {
+                // case: Direkter Nachbar zu einer DigiONS oder Umspannanlage
             }
         }
     }
 }
 exports.overallValueDetermineCallbackFunc = overallValueDetermineCallbackFunc;
+/**
+ * Callback-Funktion für das Berechnen der Werte zur Bewertung und Auswahl von DigiONS
+ */
 function calculateDigiONSValuesCallbackFunc(treeNode, context, calltime) {
     if (calltime === util_tree_1.LeafNodeCalltime.LEAF_NODE_PRE_NEXT) {
         context.branchStations = 0;
@@ -511,6 +584,7 @@ function calculateDigiONSValuesCallbackFunc(treeNode, context, calltime) {
         context.isBranchRelevant = false;
     }
     else if (calltime === util_tree_1.LeafNodeCalltime.LEAF_NODE_POST_NEXT) {
+        // Branch muss relevant sein
         if (context.isBranchRelevant) {
             context.allBranchesStations.push(context.branchStations);
             context.allBranchesPower.push(context.branchPower);
@@ -537,17 +611,20 @@ function calculateDigiONSValuesCallbackFunc(treeNode, context, calltime) {
             }
             for (const terminal of cNode.terminals.values()) {
                 const condEquip = terminal.conductingEquipment;
+                // Fuege Leistung hinzu (ausschliesslich die EnergyConsumer)
                 if (!context.ignoreValues) {
                     if (condEquip instanceof EnergyConsumer_1.EnergyConsumer) {
                         context.branchPower += condEquip.getApparentPower();
                     }
                 }
             }
+            // Inkrementiere Anzahl Stationen
             if (!context.ignoreValues && treeNode.parent)
                 context.branchStations += 1;
         }
     }
     else if (calltime === util_tree_1.LeafNodeCalltime.END) {
+        // Berechne die Werte entsprechend der gegebenen Formeln
         context.resultStationsValue = 0;
         context.resultPowerValue = 0;
         for (const branchStationsValue of context.allBranchesStations) {
@@ -558,6 +635,8 @@ function calculateDigiONSValuesCallbackFunc(treeNode, context, calltime) {
             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))