@enervance/insight-cim-model 0.0.1

package/dist/model/model/Model.js

@@ -0,0 +1,792 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = void 0;
+const Voltage_1 = require("../domain/Voltage");
+const UnitSymbol_1 = require("../domain/UnitSymbol");
+const UnitMultiplier_1 = require("../domain/UnitMultiplier");
+const __1 = require("../..");
+const rdf_xml_1 = require("../../constants/rdf-xml");
+const utils_1 = require("../../util/utils");
+const xml_serializer_1 = require("../../util/xml/xml.serializer");
+const DiagramStyle_1 = require("../diagram/DiagramStyle");
+const cim_constants_1 = require("../../constants/cim-constants");
+const EVImportanceScore_1 = require("../extensions/enervance/assets/EVImportanceScore");
+class Model {
+    constructor() {
+        this.nodeBreaker = true;
+        this.cimVersion = 'v16';
+        this.voltages = new Map();
+        this.baseVoltages = new Map();
+        this.substations = new Map();
+        this.voltageLevels = new Map();
+        this.bays = new Map();
+        this.feeders = new Map();
+        this.lines = new Map();
+        this.geographicalRegions = new Map();
+        this.subgeographicalRegions = new Map();
+        this.connectivityNodes = new Map();
+        this.busbarSections = new Map();
+        this.acLineSegments = new Map();
+        this.equivalentBranches = new Map();
+        this.junctions = new Map();
+        this.cuts = new Map();
+        this.jumpers = new Map();
+        this.powerTransformer = new Map();
+        this.powerTransformerEnds = new Map();
+        this.tapChangerControls = new Map();
+        this.ratioTapChangers = new Map();
+        this.ratioTapChangerTables = new Map();
+        this.petersenCoils = new Map();
+        this.switches = new Map();
+        this.breakers = new Map();
+        this.disconnectors = new Map();
+        this.loadBreakSwitches = new Map();
+        this.energySources = new Map();
+        this.energyConsumers = new Map();
+        this.externalNetworkInjections = new Map();
+        this.synchronousMachine = new Map();
+        this.asynchronousMachine = new Map();
+        this.generatingUnit = new Map();
+        this.thermalGeneratingUnit = new Map();
+        this.nuclearGeneratingUnit = new Map();
+        this.hydroGeneratingUnit = new Map();
+        this.windGeneratingUnit = new Map();
+        this.solarGeneratingUnit = new Map();
+        this.fossilFuel = [];
+        this.reactiveCapabilityCurve = new Map();
+        this.curveData = [];
+        this.regulatingControl = new Map();
+        this.terminals = new Map();
+        this.topologicalIslands = new Map();
+        this.topologicalNodes = new Map();
+        this.operationalLimitSets = new Map();
+        this.operationalLimitTypes = new Map();
+        this.currentLimits = new Map();
+        this.svPowerFlow = [];
+        this.svVoltage = [];
+        this.svStatus = [];
+        this.svTapSteps = [];
+        this.objects = new Map();
+        this.psrTypes = new Map();
+        this.outages = new Map();
+        this.switchingActions = new Map();
+        this.switchingPlans = new Map();
+        this.customFaults = new Map();
+        this.assetDeployments = new Map();
+        this.assetOwners = new Map();
+        this.facilities = new Map();
+        this.assetHealthEvents = new Map();
+        this.overheadWireInfos = new Map();
+        this.cableInfos = new Map();
+        this.powerTransformer2WInfo = new Map();
+        this.powerTransformer3WInfo = new Map();
+        this.importanceScore = new Map();
+        this.healthScore = new Map();
+        this.diagrams = new Map();
+        this.diagramStyles = [];
+        this.diagramsArray = [];
+        this.diagramSize = 0;
+        this.diagramObjects = new Map();
+        this.diagramObjectPonts = [];
+        this.locations = new Map();
+        this.coordinateSystems = new Map();
+        this.positionPoints = [];
+        this.diagramStyles.push(new DiagramStyle_1.DiagramStyle(utils_1.generateUUID(), cim_constants_1.DIAGRAM_LAYOUT_TYPES.NODE_BREAKER));
+        this.diagramStyles.push(new DiagramStyle_1.DiagramStyle(utils_1.generateUUID(), cim_constants_1.DIAGRAM_LAYOUT_TYPES.BUS_BRANCH));
+        this.diagramStyles.push(new DiagramStyle_1.DiagramStyle(utils_1.generateUUID(), cim_constants_1.DIAGRAM_LAYOUT_TYPES.GEOSCHEMATIC));
+    }
+    getSubstation(uuid) {
+        return this.substations.get(uuid);
+    }
+    addSubstation(substation) {
+        this.substations.set(substation.getUUID(), substation);
+        this.addObject(substation);
+    }
+    getBay(uuid) {
+        return this.bays.get(uuid);
+    }
+    addBay(bay) {
+        this.bays.set(bay.getUUID(), bay);
+        this.addObject(bay);
+    }
+    getFeeder(uuid) {
+        return this.feeders.get(uuid);
+    }
+    addFeeder(feeder) {
+        this.feeders.set(feeder.getUUID(), feeder);
+        this.addObject(feeder);
+    }
+    getConnectivityNode(uuid) {
+        return this.connectivityNodes.get(uuid);
+    }
+    addConnectivityNode(connectivityNode) {
+        this.connectivityNodes.set(connectivityNode.getUUID(), connectivityNode);
+        this.addObject(connectivityNode);
+    }
+    getOperationalLimitSet(uuid) {
+        return this.operationalLimitSets.get(uuid);
+    }
+    addOperationalLimitSet(operationalLimitSet) {
+        this.operationalLimitSets.set(operationalLimitSet.getUUID(), operationalLimitSet);
+        this.addObject(operationalLimitSet);
+    }
+    getOperationalLimitTypes() {
+        return this.operationalLimitTypes;
+    }
+    getOperationalLimitType(uuid) {
+        return this.operationalLimitTypes.get(uuid);
+    }
+    getOperationalLimitTypeByName(name) {
+        for (const type of this.operationalLimitTypes.values()) {
+            if (type.name === name) {
+                return type;
+            }
+        }
+        return;
+    }
+    addOperationalLimitType(operationalLimitType) {
+        this.operationalLimitTypes.set(operationalLimitType.getUUID(), operationalLimitType);
+        this.addObject(operationalLimitType);
+    }
+    getCurrentLimit(uuid) {
+        return this.currentLimits.get(uuid);
+    }
+    addCurrentLimit(currentLimit) {
+        this.currentLimits.set(currentLimit.getUUID(), currentLimit);
+        this.addObject(currentLimit);
+    }
+    getRegulatingControl(uuid) {
+        return this.regulatingControl.get(uuid);
+    }
+    addRegulatingControl(regulatingControl) {
+        this.regulatingControl.set(regulatingControl.mrid, regulatingControl);
+        this.addObject(regulatingControl);
+    }
+    getVoltageLevel(uuid) {
+        return this.voltageLevels.get(uuid);
+    }
+    addVoltageLevel(voltageLevel) {
+        this.voltageLevels.set(voltageLevel.getUUID(), voltageLevel);
+        this.addObject(voltageLevel);
+    }
+    getBusbarSection(uuid) {
+        return this.busbarSections.get(uuid);
+    }
+    addBusbarSection(busbarSection) {
+        this.busbarSections.set(busbarSection.getUUID(), busbarSection);
+        this.addObject(busbarSection);
+    }
+    getDiagram(uuid) {
+        return this.diagrams.get(uuid);
+    }
+    addDiagram(diagram) {
+        this.diagrams.set(diagram.getUUID(), diagram);
+        this.addObject(diagram);
+        this.diagramSize = this.diagramSize + 1;
+        this.diagramsArray.push(diagram);
+    }
+    getDiagramStyle(name) {
+        for (const diagramStyle of this.diagramStyles) {
+            if (diagramStyle.name === name) {
+                return diagramStyle;
+            }
+        }
+        return;
+    }
+    addDiagramStyle(diagramStyle) {
+        this.diagramStyles.push(diagramStyle);
+    }
+    addFossilFuel(fossilFuel) {
+        this.fossilFuel.push(fossilFuel);
+    }
+    addCurveData(curveData) {
+        this.curveData.push(curveData);
+    }
+    addDiagramObjectPoint(diagramObjectPoint) {
+        ;
+        this.diagramObjectPonts.push(diagramObjectPoint);
+        this.addObject(diagramObjectPoint);
+    }
+    getLocation(uuid) {
+        return this.locations.get(uuid);
+    }
+    addLocation(location) {
+        this.locations.set(location.getUUID(), location);
+        this.addObject(location);
+    }
+    getCoordinateSystem(uuid) {
+        return this.coordinateSystems.get(uuid);
+    }
+    addCoordinateSystem(coordinateSystem) {
+        this.coordinateSystems.set(coordinateSystem.getUUID(), coordinateSystem);
+        this.addObject(coordinateSystem);
+    }
+    getVoltage(voltageNumber) {
+        for (const entry of this.voltages.entries()) {
+            const voltage = entry[1];
+            if (voltage && voltage.value === voltageNumber) {
+                return voltage;
+            }
+        }
+        const voltage = new Voltage_1.Voltage(voltageNumber, UnitMultiplier_1.UnitMultiplier.k, UnitSymbol_1.UnitSymbol.V);
+        this.voltages.set(String(voltageNumber), voltage);
+        return voltage;
+    }
+    getBaseVoltageByUUID(uuid) {
+        return this.baseVoltages.get(uuid);
+    }
+    getBaseVoltage(voltage) {
+        for (const entry of this.baseVoltages.entries()) {
+            const value = entry[1];
+            const nominalVoltage = value.nominalVoltage;
+            if (nominalVoltage && nominalVoltage.value === voltage) {
+                return value;
+            }
+        }
+        return;
+    }
+    getLine(uuid) {
+        return this.lines.get(uuid);
+    }
+    addLine(line) {
+        this.lines.set(line.getUUID(), line);
+        this.addObject(line);
+    }
+    addBaseVoltage(baseVoltage) {
+        this.baseVoltages.set(baseVoltage.getUUID(), baseVoltage);
+        this.addObject(baseVoltage);
+    }
+    getACLineSegment(uuid) {
+        return this.acLineSegments.get(uuid);
+    }
+    addACLineSegment(acLineSegment) {
+        this.acLineSegments.set(acLineSegment.getUUID(), acLineSegment);
+        this.addObject(acLineSegment);
+    }
+    getEquivalentBranch(uuid) {
+        return this.equivalentBranches.get(uuid);
+    }
+    addEquivalentBranch(equivalentBranch) {
+        this.equivalentBranches.set(equivalentBranch.mrid, equivalentBranch);
+        this.addObject(equivalentBranch);
+    }
+    getJunction(uuid) {
+        return this.junctions.get(uuid);
+    }
+    addJunction(junction) {
+        this.junctions.set(junction.getUUID(), junction);
+        this.addObject(junction);
+    }
+    getCut(uuid) {
+        return this.cuts.get(uuid);
+    }
+    addCut(cut) {
+        this.cuts.set(cut.getUUID(), cut);
+        this.addObject(cut);
+    }
+    getJumper(uuid) {
+        return this.jumpers.get(uuid);
+    }
+    addJumper(jumper) {
+        this.jumpers.set(jumper.getUUID(), jumper);
+        this.addObject(jumper);
+    }
+    getDisconnector(uuid) {
+        return this.disconnectors.get(uuid);
+    }
+    addDisconnector(disconnector) {
+        this.disconnectors.set(disconnector.getUUID(), disconnector);
+        this.addObject(disconnector);
+    }
+    getSwitch(uuid) {
+        return this.switches.get(uuid);
+    }
+    addSwitch(swtch) {
+        this.switches.set(swtch.getUUID(), swtch);
+        this.addObject(swtch);
+    }
+    getBreaker(uuid) {
+        return this.breakers.get(uuid);
+    }
+    addBreaker(breaker) {
+        this.breakers.set(breaker.getUUID(), breaker);
+        this.addObject(breaker);
+    }
+    getLoadBreakSwitch(uuid) {
+        return this.loadBreakSwitches.get(uuid);
+    }
+    addLoadBreakSwitch(loadBreakSwitch) {
+        this.loadBreakSwitches.set(loadBreakSwitch.getUUID(), loadBreakSwitch);
+        this.addObject(loadBreakSwitch);
+    }
+    getTerminal(uuid) {
+        return this.terminals.get(uuid);
+    }
+    addTerminal(terminal) {
+        this.terminals.set(terminal.getUUID(), terminal);
+        this.addObject(terminal);
+    }
+    getExternalNetworkInjection(uuid) {
+        return this.externalNetworkInjections.get(uuid);
+    }
+    addExternalNetworkInjection(value) {
+        this.externalNetworkInjections.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    addAnalyticScore(value) {
+        if (value instanceof __1.HealthScore) {
+            this.healthScore.set(value.getUUID(), value);
+        }
+        else if (value instanceof EVImportanceScore_1.EVImportanceScore) {
+            this.importanceScore.set(value.getUUID(), value);
+        }
+        this.addObject(value);
+    }
+    getAnalyticScore(uuid) {
+        return this.objects.get(uuid);
+    }
+    addGeneratingUnit(value) {
+        if (value instanceof __1.ThermalGeneratingUnit) {
+            this.thermalGeneratingUnit.set(value.getUUID(), value);
+        }
+        else if (value instanceof __1.NuclearGeneratingUnit) {
+            this.nuclearGeneratingUnit.set(value.getUUID(), value);
+        }
+        else if (value instanceof __1.HydroGeneratingUnit) {
+            this.hydroGeneratingUnit.set(value.getUUID(), value);
+        }
+        else if (value instanceof __1.WindGeneratingUnit) {
+            this.windGeneratingUnit.set(value.getUUID(), value);
+        }
+        else if (value instanceof __1.SolarGeneratingUnit) {
+            this.solarGeneratingUnit.set(value.getUUID(), value);
+        }
+        else {
+            this.generatingUnit.set(value.getUUID(), value);
+        }
+        this.addObject(value);
+    }
+    getGeneratingUnit(uuid) {
+        return this.objects.get(uuid);
+    }
+    getThermalGeneratingUnit(uuid) {
+        return this.thermalGeneratingUnit.get(uuid);
+    }
+    getNuclearGeneratingUnit(uuid) {
+        return this.nuclearGeneratingUnit.get(uuid);
+    }
+    getHydroGeneratingUnit(uuid) {
+        return this.hydroGeneratingUnit.get(uuid);
+    }
+    getWindGeneratingUnit(uuid) {
+        return this.windGeneratingUnit.get(uuid);
+    }
+    getSolarGeneratingUnit(uuid) {
+        return this.solarGeneratingUnit.get(uuid);
+    }
+    getSynchronousMachine(uuid) {
+        return this.synchronousMachine.get(uuid);
+    }
+    addSynchronousMachine(value) {
+        this.synchronousMachine.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    getAsynchronousMachine(uuid) {
+        return this.asynchronousMachine.get(uuid);
+    }
+    addAsynchronousMachine(value) {
+        this.asynchronousMachine.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    addReactiveCapabilityCurve(value) {
+        this.reactiveCapabilityCurve.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    getReactiveCapabilityCurve(uuid) {
+        return this.reactiveCapabilityCurve.get(uuid);
+    }
+    getEnergySource(uuid) {
+        return this.energySources.get(uuid);
+    }
+    addEnergySource(value) {
+        this.energySources.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    addEnergyConsumer(value) {
+        this.energyConsumers.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    getEnergyConsumer(uuid) {
+        return this.energyConsumers.get(uuid);
+    }
+    getEquipment(uuid) {
+        return this.objects.get(uuid);
+    }
+    getConnectivityNodeContainer(uuid) {
+        return this.objects.get(uuid);
+    }
+    getEquipmentContainer(uuid) {
+        return this.objects.get(uuid);
+    }
+    getConductingEquipment(uuid) {
+        return this.objects.get(uuid);
+    }
+    getDiagramObject(uuid) {
+        return this.diagramObjects.get(uuid);
+    }
+    addDiagramObject(diagramobject) {
+        this.diagramObjects.set(diagramobject.getUUID(), diagramobject);
+        this.addObject(diagramobject);
+    }
+    addTopologicalIsland(value) {
+        this.topologicalIslands.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    getTopologicalNode(uuid) {
+        return this.topologicalNodes.get(uuid);
+    }
+    addTopologicalNode(value) {
+        this.topologicalNodes.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    addPowerTransformer(value) {
+        this.powerTransformer.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    getPowerTransformer(uuid) {
+        return this.powerTransformer.get(uuid);
+    }
+    addPetersenCoil(value) {
+        this.petersenCoils.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    getPetersenCoil(uuid) {
+        return this.petersenCoils.get(uuid);
+    }
+    addPowerTransformerEnd(value) {
+        this.powerTransformerEnds.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    getPowerTransformerEnd(uuid) {
+        return this.powerTransformerEnds.get(uuid);
+    }
+    addSvPowerFlow(value) {
+        this.svPowerFlow.push(value);
+    }
+    addSvVoltage(value) {
+        this.svVoltage.push(value);
+    }
+    addSvStatus(value) {
+        this.svStatus.push(value);
+    }
+    addSvTapStep(value) {
+        this.svTapSteps.push(value);
+    }
+    getPsrType(uuid) {
+        return this.psrTypes.get(uuid);
+    }
+    getPsrTypeAtName(name) {
+        for (const psrType of this.psrTypes.values()) {
+            if (psrType.name === name)
+                return psrType;
+        }
+        return;
+    }
+    addPsrType(psrType) {
+        this.psrTypes.set(psrType.getUUID(), psrType);
+        this.addObject(psrType);
+    }
+    addFacility(value) {
+        this.facilities.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    getFacility(uuid) {
+        return this.facilities.get(uuid);
+    }
+    addAssetDeployment(value) {
+        this.assetDeployments.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    addAssetHealthEvent(value) {
+        this.assetHealthEvents.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    getAssetHealthEvent(uuid) {
+        return this.assetHealthEvents.get(uuid);
+    }
+    getCableInfo(uuid) {
+        return this.cableInfos.get(uuid);
+    }
+    addCableInfo(cableInfo) {
+        this.cableInfos.set(cableInfo.getUUID(), cableInfo);
+        this.addObject(cableInfo);
+    }
+    getOverheadWireInfo(uuid) {
+        return this.overheadWireInfos.get(uuid);
+    }
+    addOverheadWireInfo(overheadWireInfo) {
+        this.overheadWireInfos.set(overheadWireInfo.getUUID(), overheadWireInfo);
+        this.addObject(overheadWireInfo);
+    }
+    addAssetOwner(value) {
+        this.assetOwners.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    getAssetOwner(uuid) {
+        return this.assetOwners.get(uuid);
+    }
+    getWireInfoByName(name) {
+        for (const value of this.overheadWireInfos.values()) {
+            if (value.name === name) {
+                return value;
+            }
+        }
+        for (const value of this.cableInfos.values()) {
+            if (value.name === name) {
+                return value;
+            }
+        }
+    }
+    getPowerTransformer2WInfo(uuid) {
+        return this.powerTransformer2WInfo.get(uuid);
+    }
+    addPowerTransformer2WInfo(powerTransformer2WInfo) {
+        this.powerTransformer2WInfo.set(powerTransformer2WInfo.getUUID(), powerTransformer2WInfo);
+        this.addObject(powerTransformer2WInfo);
+    }
+    getPowerTransformer3WInfo(uuid) {
+        return this.powerTransformer3WInfo.get(uuid);
+    }
+    addPowerTransformer3WInfo(powerTransformer3WInfo) {
+        this.powerTransformer3WInfo.set(powerTransformer3WInfo.getUUID(), powerTransformer3WInfo);
+        this.addObject(powerTransformer3WInfo);
+    }
+    getPowerTransformer2WInfoByName(name) {
+        for (const value of this.powerTransformer2WInfo.values()) {
+            if (value.name === name) {
+                return value;
+            }
+        }
+    }
+    getPowerTransformer3WInfoByName(name) {
+        for (const value of this.powerTransformer3WInfo.values()) {
+            if (value.name === name) {
+                return value;
+            }
+        }
+    }
+    getGeographicalRegion(uuid) {
+        return this.geographicalRegions.get(uuid);
+    }
+    addGeographicalRegion(value) {
+        this.geographicalRegions.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    getSubGeographicalRegion(uuid) {
+        return this.subgeographicalRegions.get(uuid);
+    }
+    addSubGeographicalRegion(value) {
+        this.subgeographicalRegions.set(value.getUUID(), value);
+        this.addObject(value);
+    }
+    getObject(uuid) {
+        return this.objects.get(uuid);
+    }
+    addObject(object) {
+        this.objects.set(object.getUUID(), object);
+    }
+    toJSON(data) {
+        const jsonData = [];
+        for (const value of data.values()) {
+            jsonData.push(value.toJSON());
+        }
+        return jsonData;
+    }
+    sortData() {
+        for (const entry of this.powerTransformer.entries()) {
+            const value = entry[1];
+            if (value) {
+                value.sortTransformerEnds();
+            }
+        }
+        for (const entry of this.diagramObjects.entries()) {
+            const value = entry[1];
+            if (value) {
+                value.sortPoints();
+            }
+        }
+    }
+    purgeData() {
+        this.voltages.clear();
+        this.baseVoltages.clear();
+        this.substations.clear();
+        this.voltageLevels.clear();
+        this.connectivityNodes.clear();
+        this.lines.clear();
+        this.bays.clear();
+        this.feeders.clear();
+        this.geographicalRegions.clear();
+        this.subgeographicalRegions.clear();
+        this.connectivityNodes.clear();
+        this.busbarSections.clear();
+        this.acLineSegments.clear();
+        this.equivalentBranches.clear();
+        this.junctions.clear();
+        this.cuts.clear();
+        this.jumpers.clear();
+        this.powerTransformer.clear();
+        this.powerTransformerEnds.clear();
+        this.tapChangerControls.clear();
+        this.ratioTapChangers.clear();
+        this.ratioTapChangerTables.clear();
+        this.petersenCoils.clear();
+        this.switches.clear();
+        this.breakers.clear();
+        this.disconnectors.clear();
+        this.loadBreakSwitches.clear();
+        this.energySources.clear();
+        this.energyConsumers.clear();
+        this.externalNetworkInjections.clear();
+        this.synchronousMachine.clear();
+        this.asynchronousMachine.clear();
+        this.generatingUnit.clear();
+        this.thermalGeneratingUnit.clear();
+        this.nuclearGeneratingUnit.clear();
+        this.hydroGeneratingUnit.clear();
+        this.windGeneratingUnit.clear();
+        this.solarGeneratingUnit.clear();
+        this.fossilFuel = [];
+        this.reactiveCapabilityCurve.clear();
+        this.curveData = [];
+        this.regulatingControl.clear();
+        this.terminals.clear();
+        this.topologicalIslands.clear();
+        this.topologicalNodes.clear();
+        this.operationalLimitSets.clear();
+        this.operationalLimitTypes.clear();
+        this.currentLimits.clear();
+        this.regulatingControl.clear();
+        this.outages.clear();
+        this.switchingPlans.clear();
+        this.switchingActions.clear();
+        this.customFaults.clear();
+        this.svPowerFlow = [];
+        this.svVoltage = [];
+        this.psrTypes.clear();
+        this.assetDeployments.clear();
+        this.assetOwners.clear();
+        this.facilities.clear();
+        this.assetHealthEvents.clear();
+        this.overheadWireInfos.clear();
+        this.cableInfos.clear();
+        this.powerTransformer2WInfo.clear();
+        this.powerTransformer3WInfo.clear();
+        this.diagrams.clear();
+        this.diagramObjects.clear();
+        this.diagramsArray = [];
+        this.diagramObjectPonts = [];
+        this.locations.clear();
+        this.coordinateSystems.clear();
+        this.positionPoints = [];
+        this.objects.clear();
+    }
+    serializeRDFXML() {
+        const rdfXmlSerializer = new xml_serializer_1.RdfXmlSerializer(this);
+        return rdfXmlSerializer.exportCGMES();
+    }
+    toCIMXML(xmlWriter, modelEQUUID, profiles, dependentModelUUIDs, mas) {
+        const dateTime = new Date().toJSON().slice(0, 19);
+        xmlWriter.startElementNS(rdf_xml_1.RDF_XML.MD_NS_PREFIX, 'FullModel', rdf_xml_1.RDF_XML.MD_NS);
+        utils_1.writeElementAttribute(xmlWriter, rdf_xml_1.RDF_XML.RDF_ABOUT, 'urn:uuid:' + modelEQUUID);
+        utils_1.writeElement(xmlWriter, `${rdf_xml_1.RDF_XML.MD_NS_PREFIX}:Model.created`, dateTime);
+        utils_1.writeElement(xmlWriter, `${rdf_xml_1.RDF_XML.MD_NS_PREFIX}:Model.description`, dateTime);
+        utils_1.writeElement(xmlWriter, `${rdf_xml_1.RDF_XML.MD_NS_PREFIX}:Model.version`, '1');
+        utils_1.writeElement(xmlWriter, `${rdf_xml_1.RDF_XML.MD_NS_PREFIX}:Model.modelingAuthoritySet`, mas);
+        if (dependentModelUUIDs && dependentModelUUIDs.length > 0) {
+            for (const dependentModelUUID of dependentModelUUIDs) {
+                xmlWriter.startElementNS(rdf_xml_1.RDF_XML.MD_NS_PREFIX, 'Model.DependentOn', rdf_xml_1.RDF_XML.MD_NS);
+                utils_1.writeElementAttribute(xmlWriter, rdf_xml_1.RDF_XML.RDF_RESRC, `urn:uuid:${dependentModelUUID}`);
+                xmlWriter.endElement();
+            }
+        }
+        for (const profileName of profiles) {
+            utils_1.writeElement(xmlWriter, `${rdf_xml_1.RDF_XML.MD_NS_PREFIX}:Model.profile`, profileName);
+        }
+        xmlWriter.endElement();
+    }
+    getTapChangerControl(uuid) {
+        return this.tapChangerControls.get(uuid);
+    }
+    addTapChangerControl(tapChangerControl) {
+        this.tapChangerControls.set(tapChangerControl.getUUID(), tapChangerControl);
+        this.addObject(tapChangerControl);
+    }
+    getRatioTapChanger(uuid) {
+        return this.ratioTapChangers.get(uuid);
+    }
+    addRatioTapChanger(ratioTapChanger) {
+        this.ratioTapChangers.set(ratioTapChanger.getUUID(), ratioTapChanger);
+        this.addObject(ratioTapChanger);
+    }
+    getRatioTapChangerTable(uuid) {
+        return this.ratioTapChangerTables.get(uuid);
+    }
+    addRatioTapChangerTable(ratioTapChangerTable) {
+        this.ratioTapChangerTables.set(ratioTapChangerTable.getUUID(), ratioTapChangerTable);
+        this.addObject(ratioTapChangerTable);
+    }
+    resolveParsedAssociations() {
+        this.objects.forEach((cimInstance) => {
+            cimInstance.resolveParsedAssociations(this);
+        });
+        this.positionPoints.forEach((cimInstance) => {
+            cimInstance.resolveParsedAssociations(this);
+        });
+        this.customFaults.forEach((cimInstance) => {
+            cimInstance.resolveParsedAssociations(this);
+        });
+        this.outages.forEach((cimInstance) => {
+            cimInstance.resolveParsedAssociations(this);
+        });
+        this.switchingPlans.forEach((cimInstance) => {
+            cimInstance.resolveParsedAssociations(this);
+        });
+        this.switchingActions.forEach((cimInstance) => {
+            cimInstance.resolveParsedAssociations(this);
+        });
+    }
+    getCoordinateSystemByName(name) {
+        for (const value of this.coordinateSystems.values()) {
+            if (value.name === name) {
+                return value;
+            }
+        }
+        return;
+    }
+    addOutage(outage) {
+        this.outages.set(outage.getUUID(), outage);
+    }
+    getOutage(uuid) {
+        return this.outages.get(uuid);
+    }
+    addCustomFault(fault) {
+        this.customFaults.set(fault.getUUID(), fault);
+    }
+    getCustomFault(uuid) {
+        return this.customFaults.get(uuid);
+    }
+    addSwitchingAction(fault) {
+        this.switchingActions.set(fault.getUUID(), fault);
+    }
+    getSwitchingAction(uuid) {
+        return this.switchingActions.get(uuid);
+    }
+    addSwitchingPlan(fault) {
+        this.switchingPlans.set(fault.getUUID(), fault);
+    }
+    getSwitchingPlan(uuid) {
+        return this.switchingPlans.get(uuid);
+    }
+}
+exports.Model = Model;
+//# sourceMappingURL=Model.js.map