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

package/dist/analysis/analysis-neplan/contingency-analysis.neplan.westnetz.js

@@ -1,25 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContingencyAnalysisNeplanWestnetz = void 0;
-const ACLineSegment_1 = require("../../model/wires/ACLineSegment");
-const EVSwitchingPlanKind_1 = require("../../model/extensions/enervance/operations/EVSwitchingPlanKind");
-const WNConnectivityNode_1 = require("../../model/extensions/westnetz-neplan/core/WNConnectivityNode");
-const WNOutage_1 = require("../../model/extensions/westnetz-neplan/operations/WNOutage");
-const common_utils_1 = require("../../utils2/common.utils");
-const ConductingEquipment_1 = require("../../model/core/ConductingEquipment");
-const EVTerminal_1 = require("../../model/extensions/enervance/core/EVTerminal");
-const WNFaultConnectivityNode_1 = require("../../model/extensions/westnetz-neplan/faults/WNFaultConnectivityNode");
-const etl_neplan_contingency_analysis_1 = require("../../etl/etl-neplan/etl-neplan-contingency-analysis");
-const SwitchActionKind_1 = require("../../model/operations/SwitchActionKind");
-const neplan_contingency_analysis_1 = require("../../etl/etl-neplan/neplan-contingency-analysis");
-const sparql_utils_1 = require("../../util/sparql/sparql-utils");
-const ExternalNetworkInjection_1 = require("../../model/wires/ExternalNetworkInjection");
-const Switch_1 = require("../../model/wires/Switch");
-const WNSwitchTypeKind_1 = require("../../model/extensions/westnetz-neplan/core/WNSwitchTypeKind");
-const EnergySource_1 = require("../../model/wires/EnergySource");
-const EnergyConsumer_1 = require("../../model/wires/EnergyConsumer");
-class ContingencyAnalysisNeplanWestnetz {
+import { ACLineSegment } from '../../model/wires/ACLineSegment';
+import { EVSwitchingPlanKind } from '../../model/extensions/enervance/operations/EVSwitchingPlanKind';
+import { WNConnectivityNode } from '../../model/extensions/westnetz-neplan/core/WNConnectivityNode';
+import { WNOutage } from '../../model/extensions/westnetz-neplan/operations/WNOutage';
+import { CommonUtils } from '../../utils2/common.utils';
+import { ConductingEquipment } from '../../model/core/ConductingEquipment';
+import { EVTerminal } from '../../model/extensions/enervance/core/EVTerminal';
+import { WNFaultConnectivityNode } from '../../model/extensions/westnetz-neplan/faults/WNFaultConnectivityNode';
+import { createSwitchingPlan, createTerminalAction } from '../../etl/etl-neplan/etl-neplan-contingency-analysis';
+import { SwitchActionKind } from '../../model/operations/SwitchActionKind';
+import { createSwitchAction } from '../../etl/etl-neplan/neplan-contingency-analysis';
+import { getInsertDataPartStatement } from '../../util/sparql/sparql-utils';
+import { ExternalNetworkInjection } from '../../model/wires/ExternalNetworkInjection';
+import { Switch } from '../../model/wires/Switch';
+import { WNSwitchTypeKind } from '../../model/extensions/westnetz-neplan/core/WNSwitchTypeKind';
+import { EnergySource } from '../../model/wires/EnergySource';
+import { EnergyConsumer } from '../../model/wires/EnergyConsumer';
+export class ContingencyAnalysisNeplanWestnetz {
     static performContingencyAnalysis(modelContainer) {
+        var _a, _b, _c;
         const insertSPARQL = new Array;
         const report = new Array();
         report.push(`Netz ${modelContainer.modelsContainer.graphUri}`);
@@ -29,12 +27,12 @@ class ContingencyAnalysisNeplanWestnetz {
             /** relevante Ausfälle
              *  1 Ausfall des ersten ConnectivityNodes im Abgang
              *  2 Alle ConnectivityNodes mit drei und mehr ACLineSegments */
-            const outageNodes = Array.from(feeder.normalHeadTerminal.values())?.map(it => it.connectivityNode);
+            const outageNodes = (_a = Array.from(feeder.normalHeadTerminal.values())) === null || _a === void 0 ? void 0 : _a.map(it => it.connectivityNode);
             for (const cn of wnFeeder.normalEnergizedConnectivityNodes.values()) {
                 // Muffen sind für N-1-Betrachtung nicht relevant
                 // if (cn.getType() === CimAssetAliasNames.Muffe) continue;
                 const connectedACLineSegments = Array.from(cn.terminals.values())
-                    .filter(t => t.isClosed() && t.conductingEquipment instanceof ACLineSegment_1.ACLineSegment)
+                    .filter(t => t.isClosed() && t.conductingEquipment instanceof ACLineSegment)
                     .length;
                 /** ab 3 ACLineSegments ist der Knoten für die Ausfallanalyse relevant */
                 if (connectedACLineSegments >= 3)
@@ -43,18 +41,18 @@ class ContingencyAnalysisNeplanWestnetz {
             const resupplyResults = ContingencyAnalysisNeplanWestnetz.findRessuplySwitchingActions(outageNodes, modelContainer);
             for (const resupplyResult of resupplyResults.values()) {
                 // Ausfall
-                const outageNode = resupplyResult.find(it => it.faultConnectivityNode)?.faultConnectivityNode;
+                const outageNode = (_b = resupplyResult.find(it => it.faultConnectivityNode)) === null || _b === void 0 ? void 0 : _b.faultConnectivityNode;
                 if (outageNode === undefined) {
                     continue;
                 }
                 // Freischaltungsmaßnahme
-                const deenergizedAction = resupplyResult.find(it => it.deenergizedActions)?.deenergizedActions;
+                const deenergizedAction = (_c = resupplyResult.find(it => it.deenergizedActions)) === null || _c === void 0 ? void 0 : _c.deenergizedActions;
                 // Schaltmaßnahmen ohne Zyklen
                 const resupplyActionsWithoudCycles = resupplyResult.filter(it => !it.cycle);
                 // Schaltmaßnahmen mit vollständiger Wiederversorgung
-                const fullyResuppliedActions = resupplyActionsWithoudCycles.filter(it => it.resupplyType === EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply);
+                const fullyResuppliedActions = resupplyActionsWithoudCycles.filter(it => it.resupplyType === EVSwitchingPlanKind.fullyResupply);
                 // Schaltmaßnahmen mit partieller Wiederversorgung
-                const partiallyResuppliedActionsAll = resupplyActionsWithoudCycles.filter(it => it.resupplyType === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply);
+                const partiallyResuppliedActionsAll = resupplyActionsWithoudCycles.filter(it => it.resupplyType === EVSwitchingPlanKind.partiallyResupply);
                 const partiallyResuppliedActions = ContingencyAnalysisNeplanWestnetz.findWithSmallestDeenergizedNodes(partiallyResuppliedActionsAll);
                 report.push(`Ausfall ${outageNode.getUUID()} | ${outageNode.name}\n
                     \tSchaltmaßnahmen mit vollständiger Wiederversorgung: ${fullyResuppliedActions.length}\n
@@ -64,18 +62,18 @@ class ContingencyAnalysisNeplanWestnetz {
                     continue;
                 /** Ausfallschaltmaßnahme anlegen */
                 const faultCN = outageNode;
-                const outageNew = new WNOutage_1.WNOutage(common_utils_1.CommonUtils.generateUUID(), `Ausfall-${faultCN.name}`, `${wnFeeder.shortName}`, '', wnFeeder.baseIRI);
+                const outageNew = new WNOutage(CommonUtils.generateUUID(), `Ausfall-${faultCN.name}`, `${wnFeeder.shortName}`, '', wnFeeder.baseIRI);
                 modelContainer.addOutage(outageNew);
                 insertSPARQL.push(outageNew.createNewStatementSPARQL());
                 /** Equipments */
                 for (const object of wnFeeder.additionalGroupedEquipment.values()) {
-                    if (object instanceof ConductingEquipment_1.ConductingEquipment) {
+                    if (object instanceof ConductingEquipment) {
                         insertSPARQL.push(outageNew.addOutageIsolationEquipment(object));
                     }
-                    else if (object instanceof WNConnectivityNode_1.WNConnectivityNode) {
+                    else if (object instanceof WNConnectivityNode) {
                         insertSPARQL.push(outageNew.addOutageIsolationConnectivityNodes(object));
                     }
-                    else if (object instanceof EVTerminal_1.EVTerminal) {
+                    else if (object instanceof EVTerminal) {
                         // TBD
                     }
                 }
@@ -84,16 +82,16 @@ class ContingencyAnalysisNeplanWestnetz {
                     insertSPARQL.push(outageNew.addOutageIsolationConnectivityNodes(object));
                 }
                 /** Fault */
-                const cnFaultNew = new WNFaultConnectivityNode_1.WNFaultConnectivityNode(common_utils_1.CommonUtils.generateUUID(), `${faultCN.name}`, '', '', wnFeeder.baseIRI);
+                const cnFaultNew = new WNFaultConnectivityNode(CommonUtils.generateUUID(), `${faultCN.name}`, '', '', wnFeeder.baseIRI);
                 modelContainer.addCustomFault(cnFaultNew);
                 insertSPARQL.push(cnFaultNew.createNewStatementSPARQL());
                 insertSPARQL.push(cnFaultNew.setConnectivityNode(faultCN));
                 insertSPARQL.push(cnFaultNew.setOutage(outageNew));
                 /** SwitchingPlan de-energise*/
-                const switchingPlanDeEnergise = (0, etl_neplan_contingency_analysis_1.createSwitchingPlan)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Ausfall`, -1, 'de-energise', outageNew, insertSPARQL);
+                const switchingPlanDeEnergise = createSwitchingPlan(CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Ausfall`, -1, 'de-energise', outageNew, insertSPARQL);
                 modelContainer.addSwitchingPlan(switchingPlanDeEnergise);
                 /** SwitchingActions de-energise*/
-                const switchingActionDeEnergise = (0, etl_neplan_contingency_analysis_1.createTerminalAction)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Ausfall Freischaltung`, SwitchActionKind_1.SwitchActionKind.open, switchingPlanDeEnergise, insertSPARQL);
+                const switchingActionDeEnergise = createTerminalAction(CommonUtils.generateUUID(), wnFeeder.baseIRI, `Ausfall Freischaltung`, SwitchActionKind.open, switchingPlanDeEnergise, insertSPARQL);
                 modelContainer.addSwitchingAction(switchingActionDeEnergise);
                 for (const switchElement of deenergizedAction) {
                     if (switchElement.type === 'ViaSwitch') {
@@ -104,10 +102,10 @@ class ContingencyAnalysisNeplanWestnetz {
                     }
                 }
                 /** SwitchingPlan re-energise*/
-                const switchingPlanRestore = (0, etl_neplan_contingency_analysis_1.createSwitchingPlan)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, '0', 're-energise', outageNew, insertSPARQL);
+                const switchingPlanRestore = createSwitchingPlan(CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, '0', 're-energise', outageNew, insertSPARQL);
                 modelContainer.addSwitchingPlan(switchingPlanRestore);
                 /** SwitchingAction re-energise*/
-                const switchingActionRestore = (0, etl_neplan_contingency_analysis_1.createTerminalAction)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, SwitchActionKind_1.SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
+                const switchingActionRestore = createTerminalAction(CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
                 modelContainer.addSwitchingAction(switchingActionRestore);
                 for (const switchElement of deenergizedAction) {
                     if (switchElement.type === 'ViaSwitch') {
@@ -120,25 +118,25 @@ class ContingencyAnalysisNeplanWestnetz {
                 for (let i = 0; i < actions.length; i++) {
                     const action = actions[i];
                     // Bei partieller Wiederversorgung wird zunächst max 2 Maßahmen berücksichtigt.
-                    if (action.resupplyType === EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply) {
+                    if (action.resupplyType === EVSwitchingPlanKind.partiallyResupply) {
                         if (i > 3)
                             continue;
                     }
                     /** SwitchingPlan restore*/
-                    const switchingPlanRestore = (0, etl_neplan_contingency_analysis_1.createSwitchingPlan)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, (i + 1), 'energise', outageNew, insertSPARQL);
+                    const switchingPlanRestore = createSwitchingPlan(CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltmaßnahme-Restore`, (i + 1), 'energise', outageNew, insertSPARQL);
                     insertSPARQL.push(switchingPlanRestore.setKind(action.resupplyType));
                     modelContainer.addSwitchingPlan(switchingPlanRestore);
                     /** Wiederversorgungsmaßnahmen */
                     for (const switchAction of action.switchElements) {
                         /** Switch-Element */
                         if (switchAction.swtch) {
-                            const switchingActionRestore = (0, neplan_contingency_analysis_1.createSwitchAction)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind_1.SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
+                            const switchingActionRestore = createSwitchAction(CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
                             modelContainer.addSwitchingAction(switchingActionRestore);
                             insertSPARQL.push(switchingActionRestore.setSwitch(switchAction.swtch));
                         }
                         /** Switch-Element */
                         for (const terminal of switchAction.terminals) {
-                            const switchingActionRestore = (0, etl_neplan_contingency_analysis_1.createTerminalAction)(common_utils_1.CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind_1.SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
+                            const switchingActionRestore = createTerminalAction(CommonUtils.generateUUID(), wnFeeder.baseIRI, `Schaltung-Restore`, SwitchActionKind.close, switchingPlanRestore, insertSPARQL);
                             modelContainer.addSwitchingAction(switchingActionRestore);
                             insertSPARQL.push(switchingActionRestore.addTerminal(terminal));
                         }
@@ -155,12 +153,13 @@ class ContingencyAnalysisNeplanWestnetz {
                         PREFIX entsoe:	 	      <http://entsoe.eu/CIM/SchemaExtension/3/1#>
                         PREFIX westnetzneplan:  <http://westnetzneplan.de/CIM/Extensions#>
                         PREFIX enervance:       <http://enervance.com/CIM/Extensions#>
-                        ${(0, sparql_utils_1.getInsertDataPartStatement)(graphURI, insertSPARQL)}
+                        ${getInsertDataPartStatement(graphURI, insertSPARQL)}
         `
         ];
         return { sparql: sparql, report: report };
     }
     static findRessuplySwitchingActions(outageConnectivityNodes, baseModel) {
+        var _a, _b, _c, _d;
         const evaluatedResupplyActions = new Map();
         const terminals = (Array.from(baseModel.terminals.values()));
         const allCNs = (Array.from(baseModel.connectivityNodes.values()));
@@ -171,32 +170,34 @@ class ContingencyAnalysisNeplanWestnetz {
             const deeenrgizedTerminalUUIDs = new Array();
             const deeenrgizedCn = new Array(faultConnectivityNode);
             changedPath.forEach(it => {
+                var _a;
                 if (it.type === 'ViaSwitch') {
                     deeenrgizedTerminalUUIDs.push(...Array.from(it.switchInstance.terminals.values()).map(it => it.getUUID()));
-                    deeenrgizedCn.push(...Array.from(it.switchInstance.terminals.values()).map(it => it?.connectivityNode));
+                    deeenrgizedCn.push(...Array.from(it.switchInstance.terminals.values()).map(it => it === null || it === void 0 ? void 0 : it.connectivityNode));
                 }
                 if (it.type === 'ViaSchaltbarerNode') {
                     deeenrgizedTerminalUUIDs.push(it.terminal.getUUID());
-                    deeenrgizedCn.push(it.terminal?.connectivityNode);
+                    deeenrgizedCn.push((_a = it.terminal) === null || _a === void 0 ? void 0 : _a.connectivityNode);
                 }
             });
             // Fehler elektrisch isolieren
             this.invertSwitchStates(changedPath);
             const failedSubstation = faultConnectivityNode.getSubstation();
-            const feederHeadNode = failedSubstation.getPsrType()?.getName() === 'Umspannanlage';
+            const feederHeadNode = ((_a = failedSubstation.getPsrType()) === null || _a === void 0 ? void 0 : _a.getName()) === 'Umspannanlage';
             // 1. CNs der ausgefallenen Station ignorieren
             const failedCNs = feederHeadNode ? [faultConnectivityNode] : allCNs.filter(cn => cn.getSubstation().getUUID() === failedSubstation.getUUID());
-            const failedFeeder = feederHeadNode ? Array.from(faultConnectivityNode.terminals.values()).find(it => it.conductingEquipment?.getAdditionalEquipmentContainer())?.conductingEquipment?.getAdditionalEquipmentContainer() : failedSubstation.getNormalEnergizingFeeder();
+            const failedFeeder = feederHeadNode ? (_c = (_b = Array.from(faultConnectivityNode.terminals.values()).find(it => { var _a; return (_a = it.conductingEquipment) === null || _a === void 0 ? void 0 : _a.getAdditionalEquipmentContainer(); })) === null || _b === void 0 ? void 0 : _b.conductingEquipment) === null || _c === void 0 ? void 0 : _c.getAdditionalEquipmentContainer() : failedSubstation.getNormalEnergizingFeeder();
             if (!failedFeeder) {
                 console.log(`faultCN ${faultConnectivityNode.getName()} | ${faultConnectivityNode.description} hat keinen Feeder`);
                 continue;
             }
             // CNs der Ortsnetzstationen (nicht Umspannanlage, nicht failed)
             const candidateCNs = allCNs.filter(cn => {
-                return (cn.getSubstation().getPsrType()?.getName() !== 'Umspannanlage' && // alle CNs von Umspannanlagen
+                var _a, _b;
+                return (((_a = cn.getSubstation().getPsrType()) === null || _a === void 0 ? void 0 : _a.getName()) !== 'Umspannanlage' && // alle CNs von Umspannanlagen
                     cn.getSubstation().getUUID() !== failedSubstation.getUUID()) && // alle CNs der ausgefallenen ONS
-                    cn.getSubstation()?.getNormalEnergizingFeeder() && // Substation muss einen Abgang besitzen
-                    cn?.additionalConnectivityNodeContainer; // Substation muss einen Abgang besitzen
+                    ((_b = cn.getSubstation()) === null || _b === void 0 ? void 0 : _b.getNormalEnergizingFeeder()) && // Substation muss einen Abgang besitzen
+                    (cn === null || cn === void 0 ? void 0 : cn.additionalConnectivityNodeContainer); // Substation muss einen Abgang besitzen
             });
             // 3. Suche nach CNs, die spannungslos sind
             const disconnectedCNs = candidateCNs.filter(cn => !ContingencyAnalysisNeplanWestnetz.isNodeSupplied(cn, terminals.filter(t => !failedCNs.includes(t.connectivityNode)), switches, externalNetworkInjections));
@@ -212,8 +213,8 @@ class ContingencyAnalysisNeplanWestnetz {
                 console.log(`Prüfe Combo ${combinations.indexOf(combo)}`);
                 for (const combination of combo) {
                     console.log('\tinvolved CNs');
-                    combination.terminals.forEach(t => console.log(`\t\t${t.connectivityNode?.getUUID()}`));
-                    console.log('\tinvolved Switches', combination.swtch?.getUUID(), switches.find(it => it.getUUID() === combination.swtch?.getUUID()) !== undefined);
+                    combination.terminals.forEach(t => { var _a; return console.log(`\t\t${(_a = t.connectivityNode) === null || _a === void 0 ? void 0 : _a.getUUID()}`); });
+                    console.log('\tinvolved Switches', (_d = combination.swtch) === null || _d === void 0 ? void 0 : _d.getUUID(), switches.find(it => { var _a; return it.getUUID() === ((_a = combination.swtch) === null || _a === void 0 ? void 0 : _a.getUUID()); }) !== undefined);
                     console.log('\tinvolved Feeder');
                     combination.feeders.forEach(feeder => console.log(`\t\t${feeder.name}`));
                     involvedFeeder.push(...combination.feeders.filter(it => it));
@@ -233,14 +234,14 @@ class ContingencyAnalysisNeplanWestnetz {
                 // Abgang auf Zyklen prüfen
                 const cycle = ContingencyAnalysisNeplanWestnetz.hasCycleInFeeder(involvedFeeder, terminals, switches);
                 const resupplyResult = {
-                    uuid: common_utils_1.CommonUtils.generateUUID(),
+                    uuid: CommonUtils.generateUUID(),
                     faultConnectivityNode: faultConnectivityNode,
                     deenergizedActions: changedPath,
                     cycle: cycle,
                     switchElements: combo,
                     deenergezedConnectivityNodes: disconnectedCNs,
                     resuppledConnectivityNodes: new Array(),
-                    resupplyType: EVSwitchingPlanKind_1.EVSwitchingPlanKind.noResupply
+                    resupplyType: EVSwitchingPlanKind.noResupply
                 };
                 resupplyResults.push(resupplyResult);
                 for (const cn of disconnectedCNs) {
@@ -252,10 +253,10 @@ class ContingencyAnalysisNeplanWestnetz {
                 }
                 // resupplyType
                 if (resupplyResult.deenergezedConnectivityNodes.length === resupplyResult.resuppledConnectivityNodes.length) {
-                    resupplyResult.resupplyType = EVSwitchingPlanKind_1.EVSwitchingPlanKind.fullyResupply;
+                    resupplyResult.resupplyType = EVSwitchingPlanKind.fullyResupply;
                 }
                 else if (resupplyResult.resuppledConnectivityNodes.length > 0) {
-                    resupplyResult.resupplyType = EVSwitchingPlanKind_1.EVSwitchingPlanKind.partiallyResupply;
+                    resupplyResult.resupplyType = EVSwitchingPlanKind.partiallyResupply;
                 }
                 const resuppledConnectivityNodesUUID = resupplyResult.resuppledConnectivityNodes.map(it => it.getUUID());
                 resupplyResult.deenergezedConnectivityNodes.forEach(it => {
@@ -277,11 +278,15 @@ class ContingencyAnalysisNeplanWestnetz {
         return evaluatedResupplyActions;
     }
     static hasCycleInFeeder(involvedFeeders, allTerminals, allSwitches) {
-        const feederUUID = involvedFeeders.map(it => it.getUUID())?.filter(it => it);
+        var _a;
+        const feederUUID = (_a = involvedFeeders.map(it => it.getUUID())) === null || _a === void 0 ? void 0 : _a.filter(it => it);
         // 1. Relevante ACLineSegment-Terminals filtern
-        const feederTerminals = allTerminals.filter(it => feederUUID.includes(it.connectivityNode?.additionalConnectivityNodeContainer?.getUUID()) && it.connected);
-        const relevantTerminals = feederTerminals.filter(t => t.getConnectivityNode()?.getSubstation()?.getPsrType()?.getName() !== "Umspannanlage" &&
-            (t.conductingEquipment instanceof ACLineSegment_1.ACLineSegment || t.conductingEquipment instanceof Switch_1.Switch));
+        const feederTerminals = allTerminals.filter(it => { var _a, _b; return feederUUID.includes((_b = (_a = it.connectivityNode) === null || _a === void 0 ? void 0 : _a.additionalConnectivityNodeContainer) === null || _b === void 0 ? void 0 : _b.getUUID()) && it.connected; });
+        const relevantTerminals = feederTerminals.filter(t => {
+            var _a, _b, _c;
+            return ((_c = (_b = (_a = t.getConnectivityNode()) === null || _a === void 0 ? void 0 : _a.getSubstation()) === null || _b === void 0 ? void 0 : _b.getPsrType()) === null || _c === void 0 ? void 0 : _c.getName()) !== "Umspannanlage" &&
+                (t.conductingEquipment instanceof ACLineSegment || t.conductingEquipment instanceof Switch);
+        });
         // 2. Geschlossene Switches mit einem Feeder
         const aaa = allSwitches.find(it => it.getUUID() === 'ad29f120-a6c0-4577-9adf-af7562b289f6');
         const closedSwitches = allSwitches.filter(sw => !sw.open);
@@ -311,14 +316,17 @@ class ContingencyAnalysisNeplanWestnetz {
             if (sw.getUUID() === 'ad29f120-a6c0-4577-9adf-af7562b289f6') {
                 console.log();
             }
-            const swTerminals = allTerminals.filter(t => t.conductingEquipment?.getUUID() === sw?.getUUID() &&
-                t.connected &&
-                feederUUID.includes(t.connectivityNode?.additionalConnectivityNodeContainer?.getUUID()));
+            const swTerminals = allTerminals.filter(t => {
+                var _a, _b, _c;
+                return ((_a = t.conductingEquipment) === null || _a === void 0 ? void 0 : _a.getUUID()) === (sw === null || sw === void 0 ? void 0 : sw.getUUID()) &&
+                    t.connected &&
+                    feederUUID.includes((_c = (_b = t.connectivityNode) === null || _b === void 0 ? void 0 : _b.additionalConnectivityNodeContainer) === null || _c === void 0 ? void 0 : _c.getUUID());
+            });
             if (swTerminals.length === 2) {
-                const [a, b] = swTerminals.map(t => t.getConnectivityNode()?.getUUID());
+                const [a, b] = swTerminals.map(t => { var _a; return (_a = t.getConnectivityNode()) === null || _a === void 0 ? void 0 : _a.getUUID(); });
                 console.log('union', sw.getUUID(), a, b);
                 union(a, b);
-                switchFeedersArray.push(...swTerminals.map(it => it.connectivityNode?.additionalConnectivityNodeContainer));
+                switchFeedersArray.push(...swTerminals.map(it => { var _a; return (_a = it.connectivityNode) === null || _a === void 0 ? void 0 : _a.additionalConnectivityNodeContainer; }));
             }
         }
         // 5. Adjazenzmatrix basierend auf den "komprimierten" Knoten
@@ -341,11 +349,11 @@ class ContingencyAnalysisNeplanWestnetz {
         const feeders = new Set([...involvedFeeders, ...switchFeeders]);
         for (const feeder of feeders) {
             for (const eq of feeder.getAdditionalGroupedEquipments().values()) {
-                if (!(eq instanceof ACLineSegment_1.ACLineSegment || eq instanceof Switch_1.Switch))
+                if (!(eq instanceof ACLineSegment || eq instanceof Switch))
                     continue;
-                const lineTerminals = relevantTerminals.filter(t => t.conductingEquipment?.getUUID() === eq?.getUUID());
+                const lineTerminals = relevantTerminals.filter(t => { var _a; return ((_a = t.conductingEquipment) === null || _a === void 0 ? void 0 : _a.getUUID()) === (eq === null || eq === void 0 ? void 0 : eq.getUUID()); });
                 if (lineTerminals.length === 2) {
-                    const [a, b] = lineTerminals.map(t => t.connectivityNode?.getUUID());
+                    const [a, b] = lineTerminals.map(t => { var _a; return (_a = t.connectivityNode) === null || _a === void 0 ? void 0 : _a.getUUID(); });
                     addEdgeCompressed(a, b);
                 }
             }
@@ -397,6 +405,7 @@ class ContingencyAnalysisNeplanWestnetz {
         }
     }
     static isNodeSupplied(startNode, terminals, switches, externalInjections) {
+        var _a, _b;
         const visitedCN = new Set();
         const visitedEquipments = new Set();
         const equipmentIsOpen = new Set();
@@ -406,11 +415,11 @@ class ContingencyAnalysisNeplanWestnetz {
         }
         const cnToTerminals = new Map();
         for (const t of terminals) {
-            if (!t?.connected)
+            if (!(t === null || t === void 0 ? void 0 : t.connected))
                 continue;
-            if (!t?.connectivityNode)
+            if (!(t === null || t === void 0 ? void 0 : t.connectivityNode))
                 continue;
-            const cnUUID = t.connectivityNode?.getUUID();
+            const cnUUID = (_a = t.connectivityNode) === null || _a === void 0 ? void 0 : _a.getUUID();
             if (!cnToTerminals.has(cnUUID))
                 cnToTerminals.set(cnUUID, []);
             cnToTerminals.get(cnUUID).push(t);
@@ -422,9 +431,9 @@ class ContingencyAnalysisNeplanWestnetz {
             if (visitedCN.has(currentId))
                 continue;
             visitedCN.add(currentId);
-            const cnTerminals = cnToTerminals.get(currentId) ?? [];
+            const cnTerminals = (_b = cnToTerminals.get(currentId)) !== null && _b !== void 0 ? _b : [];
             for (const terminal of cnTerminals) {
-                if (!terminal?.conductingEquipment)
+                if (!(terminal === null || terminal === void 0 ? void 0 : terminal.conductingEquipment))
                     continue;
                 const eq = terminal.conductingEquipment;
                 const eqId = eq.getUUID();
@@ -434,7 +443,7 @@ class ContingencyAnalysisNeplanWestnetz {
                     continue;
                 visitedEquipments.add(eqId);
                 // Prüfe: Ist das Equipment ein ExternalNetworkInjection?
-                if (eq instanceof ExternalNetworkInjection_1.ExternalNetworkInjection) {
+                if (eq instanceof ExternalNetworkInjection) {
                     const isExternalNetworkInjection = externalInjections.some(ext => ext.getUUID() === eq.getUUID());
                     if (isExternalNetworkInjection)
                         return true;
@@ -443,9 +452,9 @@ class ContingencyAnalysisNeplanWestnetz {
                 for (const otherTerminal of eq.terminals.values()) {
                     if (otherTerminal.getUUID() === terminal.getUUID())
                         continue;
-                    if (!otherTerminal?.connected)
+                    if (!(otherTerminal === null || otherTerminal === void 0 ? void 0 : otherTerminal.connected))
                         continue;
-                    if (!otherTerminal?.connectivityNode)
+                    if (!(otherTerminal === null || otherTerminal === void 0 ? void 0 : otherTerminal.connectivityNode))
                         continue;
                     const nextCN = otherTerminal.connectivityNode;
                     const nextId = nextCN.getUUID();
@@ -458,6 +467,7 @@ class ContingencyAnalysisNeplanWestnetz {
         return false;
     }
     static findOpenedSwitchesToOtherFeeders(failedConnectivityNodes, failedFeeder, baseModel) {
+        var _a;
         const results = new Array();
         // Relevante Switches finden
         const switches = [...baseModel.switches.values(), ...baseModel.loadBreakSwitches.values(), ...baseModel.disconnectors.values(), ...baseModel.breakers.values()];
@@ -465,10 +475,10 @@ class ContingencyAnalysisNeplanWestnetz {
             // Nur nicht verbundene Switsches
             if (!swtch.open)
                 continue;
-            const switchTerminals = Array.from(swtch.terminals.values())?.filter(it => it.connectivityNode && !failedConnectivityNodes.includes(it.connectivityNode));
+            const switchTerminals = (_a = Array.from(swtch.terminals.values())) === null || _a === void 0 ? void 0 : _a.filter(it => it.connectivityNode && !failedConnectivityNodes.includes(it.connectivityNode));
             // sind an der Switch-Kombination ACLineSegments von anderen Abgängen angeschlossen
             const switchConnectivityNodes = switchTerminals.map(it => it.connectivityNode);
-            const feeder = switchConnectivityNodes.map(it => it.additionalConnectivityNodeContainer?.getUUID()).filter(it => it);
+            const feeder = switchConnectivityNodes.map(it => { var _a; return (_a = it.additionalConnectivityNodeContainer) === null || _a === void 0 ? void 0 : _a.getUUID(); }).filter(it => it);
             // Wenn Feederanzahl < 2 ist, dann ist mind. einer ConnectivityNode spannungslos
             if (feeder.length < 2)
                 continue;
@@ -476,9 +486,9 @@ class ContingencyAnalysisNeplanWestnetz {
                 return Array.from(it.terminals.values()).map(it => it.conductingEquipment);
             });
             // in ein eindimensionales Array überführen
-            const flattenSwitchConductingEquipments = switchConductingEquipments2dArray?.flat();
+            const flattenSwitchConductingEquipments = switchConductingEquipments2dArray === null || switchConductingEquipments2dArray === void 0 ? void 0 : switchConductingEquipments2dArray.flat();
             // Datenfehler filtern -> Terminal hat kein conductingEquipment und ist keinem Abgang zugeordnet
-            const switchConductingEquipments = flattenSwitchConductingEquipments?.filter(it => it && it.getAdditionalEquipmentContainer());
+            const switchConductingEquipments = flattenSwitchConductingEquipments === null || flattenSwitchConductingEquipments === void 0 ? void 0 : flattenSwitchConductingEquipments.filter(it => it && it.getAdditionalEquipmentContainer());
             if ( /*ceFeeder?.getUUID() !== failedFeeder.getUUID() &&*/!feeder.includes(failedFeeder.getUUID()))
                 continue;
             const feeders = feeder.map(it => baseModel.getFeeder(it));
@@ -491,6 +501,7 @@ class ContingencyAnalysisNeplanWestnetz {
         return results;
     }
     static findOpenedTerminalsToOtherFeeders(connectivityNodes, deeenrgizedTerminalUUIDs, failedFeeder, baseModel) {
+        var _a, _b;
         // Relevante Terminals finden
         const results = new Array();
         for (const terminal of baseModel.terminals.values()) {
@@ -502,20 +513,20 @@ class ContingencyAnalysisNeplanWestnetz {
             if (!terminal.conductingEquipment || !terminal.connectivityNode)
                 continue;
             // Verbundungen zu Switches werden übersprungen
-            if (terminal.conductingEquipment instanceof Switch_1.Switch)
+            if (terminal.conductingEquipment instanceof Switch)
                 continue;
             // Verbundungen zu Switches Lasten und Einspeisern werden übersprungen
-            if (terminal.conductingEquipment instanceof EnergySource_1.EnergySource)
+            if (terminal.conductingEquipment instanceof EnergySource)
                 continue;
-            if (terminal.conductingEquipment instanceof EnergyConsumer_1.EnergyConsumer)
+            if (terminal.conductingEquipment instanceof EnergyConsumer)
                 continue;
             if (connectivityNodes.includes(terminal.connectivityNode))
                 continue;
             const connectivityNode = terminal.connectivityNode;
             // Nur Terminals mit einer Verbindung zum Feeder des betrachteten ConnectivityNodes, um offene Trennstellen zwischen anderen Abgängen zu ignorieren
-            const ceFeeder = terminal.conductingEquipment?.getAdditionalEquipmentContainer();
-            const cnFeeder = connectivityNode.getSubstation()?.getNormalEnergizingFeeder();
-            if (ceFeeder?.getUUID() !== failedFeeder.getUUID() && cnFeeder?.getUUID() !== failedFeeder.getUUID())
+            const ceFeeder = (_a = terminal.conductingEquipment) === null || _a === void 0 ? void 0 : _a.getAdditionalEquipmentContainer();
+            const cnFeeder = (_b = connectivityNode.getSubstation()) === null || _b === void 0 ? void 0 : _b.getNormalEnergizingFeeder();
+            if ((ceFeeder === null || ceFeeder === void 0 ? void 0 : ceFeeder.getUUID()) !== failedFeeder.getUUID() && (cnFeeder === null || cnFeeder === void 0 ? void 0 : cnFeeder.getUUID()) !== failedFeeder.getUUID())
                 continue;
             // Offene Trennstellen zu Objekten ohne Feeder werden nicht betrachtet, da spannungslose Querverbindungen zu anderen UAs
             if (!ceFeeder || !cnFeeder)
@@ -543,9 +554,9 @@ class ContingencyAnalysisNeplanWestnetz {
                 continue;
             visitedNodes.add(nodeId);
             const lastStep = path[path.length - 1];
-            const lastEquipment = lastStep?.equipment;
+            const lastEquipment = lastStep === null || lastStep === void 0 ? void 0 : lastStep.equipment;
             // Prüfe auf schaltbaren Node
-            if ((currentNode.switchable === WNSwitchTypeKind_1.WNSwitchTypeKind.S || currentNode.switchable === WNSwitchTypeKind_1.WNSwitchTypeKind.E) && !visitedSchaltbareNodes.has(nodeId)) {
+            if ((currentNode.switchable === WNSwitchTypeKind.S || currentNode.switchable === WNSwitchTypeKind.E) && !visitedSchaltbareNodes.has(nodeId)) {
                 visitedSchaltbareNodes.add(nodeId);
                 const matchedTerminals = new Array();
                 // Finde den Terminal, der mit dem letzten Equipment verbunden ist
@@ -575,11 +586,11 @@ class ContingencyAnalysisNeplanWestnetz {
                 continue;
             }
             for (const terminal of currentNode.terminals.values()) {
-                const equipment = terminal?.conductingEquipment;
+                const equipment = terminal === null || terminal === void 0 ? void 0 : terminal.conductingEquipment;
                 if (!equipment)
                     continue;
                 // Switch behandeln (aber nur einmal pro UUID)
-                if (equipment instanceof Switch_1.Switch) {
+                if (equipment instanceof Switch) {
                     const switchId = equipment.getUUID();
                     if (!visitedSwitches.has(switchId)) {
                         visitedSwitches.add(switchId);
@@ -595,7 +606,7 @@ class ContingencyAnalysisNeplanWestnetz {
                 for (const otherTerminal of equipment.terminals.values()) {
                     if (otherTerminal === terminal)
                         continue;
-                    const nextNode = otherTerminal?.connectivityNode;
+                    const nextNode = otherTerminal === null || otherTerminal === void 0 ? void 0 : otherTerminal.connectivityNode;
                     if (!nextNode || visitedNodes.has(nextNode.getUUID()))
                         continue;
                     toVisit.push({
@@ -714,5 +725,4 @@ class ContingencyAnalysisNeplanWestnetz {
         return reachableNodes;
     }
 }
-exports.ContingencyAnalysisNeplanWestnetz = ContingencyAnalysisNeplanWestnetz;
 //# sourceMappingURL=contingency-analysis.neplan.westnetz.js.map