public static void PopulateConductingEquipmentProperties(ConductingEquipment conductingEquipment, ResourceDescription rd, ImportHelper import, TransformAndLoadReport report)
 {
     if ((conductingEquipment != null) && (rd != null))
     {
         PowerTransformerConverter.PopulateEquipmentProperties(conductingEquipment, rd, import, report);
     }
 }
Beispiel #2
0
 public static void PopulateConductingEquipmentProperties(ConductingEquipment ce, ResourceDescription rd)
 {
     if ((ce != null) && (rd != null))
     {
         IES1Converter.PopulateEquipmentProperties(ce, rd);
     }
 }
Beispiel #3
0
 public override void Initialize(ConductingEquipment reference)
 {
     input = reference;
     foreach (ConductingEquipment output in outputs)
     {
         output.Initialize(this);
     }
 }
Beispiel #4
0
 public override void Initialize(ConductingEquipment reference)
 {
     voltage = Sourcevoltage;
     foreach (ConductingEquipment output in outputs)
     {
         output.Initialize(this);
     }
 }
        void PopulateConductingEquipmentProperties(ConductingEquipment x, ResourceDescription rd)
        {
            PopulateEquipmentProperties(x, rd);

            if (x.BaseVoltageHasValue)
            {
                rd.AddProperty(new ReferenceProperty(ModelCode.CONDUCTINGEQUIPMENT_BASEVOLTAGE, GetGID(x.BaseVoltage.ID)));
            }
        }
Beispiel #6
0
        private string CheckIfPropertyNeedsId(string updated_property_info_name, object data)
        {
            switch (updated_property_info_name)
            {
            case "ConnectivityNode.ConnectivityNodeContainer":
                Circuit c = (Circuit)data;
                return(c.MRID);

            case "UsagePoint.ServiceLocation":
                ServiceLocation sl = (ServiceLocation)data;
                return(sl.MRID);

            case "PowerSystemResource.PSRType":
                PSRType psr = (PSRType)data;
                return(psr.Name);

            case "ACLineSegment.PerLengthImpedance":
                PerLengthImpedance pli = (PerLengthImpedance)data;
                return(pli.MRID);

            case "Equipment.EquipmentContainer":
                EquipmentContainer eq = (EquipmentContainer)data;
                return(eq.MRID);

            case "PowerSystemResource.AssetDatasheet":
                AssetInfo ad = (AssetInfo)data;
                return(ad.MRID);

            case "TransformerEnd.Terminal":
                Terminal t = (Terminal)data;
                return(t.MRID);

            case "PowerTransformerEnd.PowerTransformer":
                PowerTransformer pst = (PowerTransformer)data;
                return(pst.MRID);

            case "Terminal.ConductingEquipment":
                ConductingEquipment ce = (ConductingEquipment)data;
                return(ce.MRID);

            case "Terminal.ConnectivityNode":
                ConnectivityNode cn = (ConnectivityNode)data;
                return(cn.MRID);
            }


            return("");
        }
Beispiel #7
0
 public override void Initialize(ConductingEquipment reference)
 {
     input = reference;
 }
 public virtual void Initialize(ConductingEquipment reference)
 {
 }
Beispiel #9
0
        public IEnumerable <IdentifiedObject> Transform(CimContext context, IEnumerable <IdentifiedObject> inputParam)
        {
            FeederInfoContext feederContext = new FeederInfoContext(context);

            feederContext.CreateFeederObjects();

            List <IdentifiedObject> input = inputParam.ToList();

            HashSet <PhysicalNetworkModel.IdentifiedObject> dropList = new HashSet <IdentifiedObject>();
            List <PhysicalNetworkModel.IdentifiedObject>    addList  = new List <IdentifiedObject>();

            // AssetInfo to Asset ref dictionary
            Dictionary <string, string> assetInfoToAssetRef = new Dictionary <string, string>();

            foreach (var inputCimObject in input)
            {
                if (inputCimObject is PhysicalNetworkModel.Asset)
                {
                    var asset = inputCimObject as PhysicalNetworkModel.Asset;

                    if (asset.AssetInfo != null && !assetInfoToAssetRef.ContainsKey(asset.AssetInfo.@ref))
                    {
                        assetInfoToAssetRef.Add(asset.AssetInfo.@ref, asset.mRID);
                    }
                }
            }

            // Asset to Equipment ref dictionary
            Dictionary <string, string> assetToEquipmentRef = new Dictionary <string, string>();

            foreach (var inputCimObject in input)
            {
                if (inputCimObject is PhysicalNetworkModel.PowerSystemResource)
                {
                    var psr = inputCimObject as PhysicalNetworkModel.PowerSystemResource;
                    if (psr.Assets != null)
                    {
                        assetToEquipmentRef.Add(psr.Assets.@ref, psr.mRID);
                    }
                }
            }

            // Set busbar names to station + voltagelevel + bay
            foreach (var inputCimObject in input)
            {
                if (inputCimObject is BusbarSection)
                {
                    var bus = inputCimObject as BusbarSection;

                    var st = bus.GetSubstation(true, context);

                    bus.name = st.name + "_" + GetVoltageLevelStr(bus.BaseVoltage) + "_" + bus.name;

                    var feederInfo = feederContext.GeConductingEquipmentFeederInfo(bus);
                    if (feederInfo != null && feederInfo.Feeders != null && feederInfo.Feeders.Count > 0)
                    {
                        var feeder = feederInfo.Feeders[0];

                        if (feeder.ConnectionPoint.Substation != null)
                        {
                            bus.description = feeder.ConnectionPoint.Substation.name;
                        }
                    }
                }
            }

            // Set feeder name on junction connectivity nodes between cables
            foreach (var inputCimObject in input)
            {
                if (inputCimObject is ConnectivityNode)
                {
                    var cn = inputCimObject as ConnectivityNode;

                    if (cn.mRID == "c540b203-e442-7027-824c-bc561b3de47d")
                    {
                    }

                    var cnEqs = context.GetConnections(cn);

                    if (cnEqs.Count > 0)
                    {
                        if (cnEqs.All(e => e.ConductingEquipment is ACLineSegment))
                        {
                            var eq = cnEqs.First().ConductingEquipment;

                            var feederInfo = feederContext.GeConductingEquipmentFeederInfo(eq);

                            if (feederInfo != null && feederInfo.Feeders != null && feederInfo.Feeders.Count > 0)
                            {
                                var feeder = feederInfo.Feeders[0];

                                if (feeder.ConnectionPoint.Substation != null)
                                {
                                    cn.description = feeder.ConnectionPoint.Substation.name;
                                }
                            }
                        }
                    }
                }
            }

            // Set peterson coil name to station + gis name + min og max
            foreach (var inputCimObject in input)
            {
                if (inputCimObject is PetersenCoil)
                {
                    var coil = inputCimObject as PetersenCoil;

                    var st = coil.GetSubstation(true, context);

                    if (coil.Asset != null && coil.Asset.AssetInfo != null && coil.Asset.AssetInfo.@ref != null)
                    {
                        var coilInfo = context.GetObject <PetersenCoilInfoExt>(coil.Asset.AssetInfo.@ref);

                        coil.name = st.name + " " + coil.name;

                        if (coilInfo != null && coilInfo.minimumCurrent != null && coilInfo.maximumCurrent != null)
                        {
                            coil.name += " " + (int)coilInfo?.minimumCurrent?.Value + "-" + (int)coilInfo?.maximumCurrent?.Value;
                        }
                        else
                        {
                            Logger.Log(LogLevel.Warning, "Slukkepole på station: " + st.name + " mangler værdier.");
                        }
                    }
                    else
                    {
                        coil.name = st.name + " " + coil.name + " 0-0";
                    }
                }
            }

            // Set reactor coil (linear shunt compensator) to station + gis name + min og max
            foreach (var inputCimObject in input)
            {
                if (inputCimObject is LinearShuntCompensator)
                {
                    var coil = inputCimObject as LinearShuntCompensator;

                    var st = coil.GetSubstation(true, context);

                    if (coil.Asset != null && coil.Asset.AssetInfo != null && coil.Asset.AssetInfo.@ref != null)
                    {
                        var coilInfo = context.GetObject <LinearShuntCompensatorInfoExt>(coil.Asset.AssetInfo.@ref);

                        coil.name = st.name + " " + coil.name;

                        if (coilInfo != null && coilInfo.minimumReactivePower != null && coilInfo.maximumReactivePower != null)
                        {
                            coil.name += " " + (int)coilInfo?.minimumReactivePower?.Value + "-" + (int)coilInfo?.maximumReactivePower?.Value;
                        }
                        else
                        {
                            Logger.Log(LogLevel.Warning, "Reaktorspole på station: " + st.name + " mangler værdier.");
                        }
                    }
                    else
                    {
                        coil.name = st.name + " " + coil.name + " 0-0";
                    }
                }
            }

            // Remove injection > 50 kV
            foreach (var inputCimObject in input)
            {
                if (inputCimObject is ExternalNetworkInjection)
                {
                    var inj = inputCimObject as ExternalNetworkInjection;

                    if (inj.BaseVoltage > 50000)
                    {
                        dropList.Add(inj);

                        var injConnections = context.GetConnections(inj);

                        foreach (var injCon in injConnections)
                        {
                            dropList.Add(injCon.Terminal);
                        }
                    }
                }
            }

            // Fix and check objects
            foreach (var inputCimObject in input)
            {
                // Remove switch gear busbar asset model information (because PF complain about missing type, and Konstant/Thue says he don't want types into PF for now
                if (inputCimObject is BusbarSectionInfo)
                {
                    BusbarSectionInfo bsi = inputCimObject as BusbarSectionInfo;
                    bsi.AssetModel = null;

                    var assetMrid = assetInfoToAssetRef[inputCimObject.mRID];
                    var asset     = context.GetObject <PhysicalNetworkModel.Asset>(assetMrid);
                    asset.type       = null;
                    asset.name       = null;
                    asset.AssetModel = null;
                }

                // Remove asset manufacture information on busbars and switches
                if (inputCimObject is BusbarSection || inputCimObject is Switch)
                {
                    ConductingEquipment ci = inputCimObject as ConductingEquipment;
                    var asset = context.GetObject <PhysicalNetworkModel.Asset>(ci.Assets.@ref);
                    asset.type       = null;
                    asset.name       = null;
                    asset.AssetModel = null;
                }

                // Remove measurment current transformer and cts sitting on voltage level < 60 kV
                if (inputCimObject is CurrentTransformer && !((CurrentTransformer)inputCimObject).PSRType.ToLower().Contains("kundemaaling"))
                {
                    var ct = inputCimObject as CurrentTransformer;

                    bool ctIsDropped = false;

                    try
                    {
                        var ctTerminal = context.GetObject <Terminal>(ct.Terminal.@ref);

                        var ctEq = context.GetObject <ConductingEquipment>(ctTerminal.ConductingEquipment.@ref);

                        if (ctEq.BaseVoltage < 60000)
                        {
                            dropList.Add(ct);
                            ctIsDropped = true;
                        }
                    }
                    catch (ArgumentException ex)
                    {
                        dropList.Add(ct);
                        ctIsDropped = true;
                    }

                    // Move CT to line end, transformer end

                    var st = ct.GetSubstation(true, context);

                    foreach (var eq in st.GetEquipments(context))
                    {
                        // If component inside same bay as ct
                        if (eq is ConductingEquipment && eq.EquipmentContainer.@ref == ct.EquipmentContainer.@ref)
                        {
                            var ci = eq as ConductingEquipment;

                            var ciConnections = context.GetConnections(ci);


                            foreach (var ciConnection in ciConnections)
                            {
                                var ciNeighbors = context.GetConnections(ciConnection.ConnectivityNode).Where(c => c.ConductingEquipment != ci).ToList();

                                if (ciNeighbors.Any(c => c.ConductingEquipment is ACLineSegment))
                                {
                                    ct.Terminal.@ref = ciConnection.Terminal.mRID;
                                }
                                else if (ciNeighbors.Any(c => c.ConductingEquipment is PowerTransformer))
                                {
                                    ct.Terminal.@ref = ciConnection.Terminal.mRID;
                                }
                                else if (ciNeighbors.Count == 0)
                                {
                                    ct.Terminal.@ref = ciConnection.Terminal.mRID;
                                }
                            }
                        }
                    }
                }

                // Check that current transformer infos has currents
                if (inputCimObject is CurrentTransformerInfoExt)
                {
                    var ctInfo    = inputCimObject as CurrentTransformerInfoExt;
                    var assetMrid = assetInfoToAssetRef[ctInfo.mRID];
                    var eqMrid    = assetToEquipmentRef[assetMrid];

                    var ct      = context.GetObject <CurrentTransformerExt>(eqMrid);
                    var ctAsset = context.GetObject <PhysicalNetworkModel.Asset>(assetMrid);

                    if (ct.PSRType != null && ct.PSRType == "StromTransformer")
                    {
                        // Make sure primary and secondary current is set, because otherwise PF import fails
                        if (ctInfo.primaryCurrent == null)
                        {
                            var stName  = ct.GetSubstation(true, context).name;
                            var bayName = ct.GetBay(true, context).name;

                            Logger.Log(LogLevel.Warning, "CT Missing primary current. Will not be transfered to PF: " + stName + " " + bayName);
                            ctInfo.primaryCurrent = new CurrentFlow()
                            {
                                Value = 0, unit = UnitSymbol.A
                            };

                            dropList.Add(ct);
                            dropList.Add(ctAsset);
                            dropList.Add(ctInfo);
                        }

                        if (ctInfo.secondaryCurrent == null)
                        {
                            var stName  = ct.GetSubstation(true, context).name;
                            var bayName = ct.GetBay(true, context).name;

                            Logger.Log(LogLevel.Warning, "CT Missing secondary current: " + stName + " " + bayName);
                            ctInfo.secondaryCurrent = new CurrentFlow()
                            {
                                Value = 0, unit = UnitSymbol.A
                            };
                        }
                    }
                    else
                    {
                        dropList.Add(ct);
                        dropList.Add(ctAsset);
                        dropList.Add(ctInfo);
                    }
                }

                // Remove potential transformers sitting on voltage level < 60 kV
                if (inputCimObject is PotentialTransformer)
                {
                    var pt = inputCimObject as PotentialTransformer;

                    // If terminal point to object we don't have including - i.e. some 400 volt component - don't bother with the CT
                    if (context.GetAllObjects().Exists(o => o.mRID == pt.Terminal.@ref))
                    {
                        var ptTerminal = context.GetObject <Terminal>(pt.Terminal.@ref);

                        var ptEq = context.GetObject <ConductingEquipment>(ptTerminal.ConductingEquipment.@ref);

                        if (ptEq.BaseVoltage < 60000)
                        {
                            dropList.Add(pt);
                        }
                    }
                    else
                    {
                        dropList.Add(pt);
                    }
                }

                // Check that potential transformer info has voltages
                if (inputCimObject is PotentialTransformerInfoExt)
                {
                    var vtInfo = inputCimObject as PotentialTransformerInfoExt;

                    var assetMrid = assetInfoToAssetRef[vtInfo.mRID];
                    var eqMrid    = assetToEquipmentRef[assetMrid];

                    var vtAsset = context.GetObject <PhysicalNetworkModel.Asset>(assetMrid);
                    var vt      = context.GetObject <PotentialTransformer>(eqMrid);
                    var vtSt    = vt.GetSubstation(true, context);

                    // Make sure primary and secondary voltage is set, because otherwise PF import fails
                    if (vtInfo.primaryVoltage == null)
                    {
                        vtInfo.primaryVoltage = new Voltage()
                        {
                            Value = 0, unit = UnitSymbol.V
                        };

                        var stName  = vt.GetSubstation(true, context).name;
                        var bayName = vt.GetBay(true, context).name;

                        Logger.Log(LogLevel.Warning, "VT Missing primary voltage. VT will not be transfered to PF." + stName + " " + bayName);

                        dropList.Add(vt);
                        dropList.Add(vtAsset);
                        dropList.Add(vtInfo);
                    }
                    else if (vtInfo.secondaryVoltage == null)
                    {
                        vtInfo.secondaryVoltage = new Voltage()
                        {
                            Value = 0, unit = UnitSymbol.V
                        };

                        var stName  = vt.GetSubstation(true, context).name;
                        var bayName = vt.GetBay(true, context).name;

                        Logger.Log(LogLevel.Warning, "VT Missing secondary voltage. VI will not be transfered to PF." + stName + " " + bayName);

                        dropList.Add(vt);
                        dropList.Add(vtAsset);
                        dropList.Add(vtInfo);
                    }
                }


                // Set relay names to station + bay
                if (inputCimObject is ProtectionEquipment)
                {
                    var relay = inputCimObject as ProtectionEquipment;

                    // get relay station and bay via the switch it is connected to
                    if (relay.ProtectedSwitches != null && relay.ProtectedSwitches.Length > 0)
                    {
                        try
                        {
                            var peSw = context.GetObject <PowerSystemResource>(relay.ProtectedSwitches[0].@ref);
                            var bay  = peSw.GetBay(true, context);
                            var st   = peSw.GetSubstation(true, context);

                            relay.name = st.name + " " + bay.name;
                        }
                        catch (Exception ex)
                        {
                            Logger.Log(LogLevel.Warning, "Cannot find switch: " + relay.ProtectedSwitches[0].@ref + " connected to replay: " + inputCimObject.mRID);
                        }
                    }
                    else
                    {
                        dropList.Add(inputCimObject);
                    }
                }

                // Set electrical values on internal substation cables to 0
                if (inputCimObject is ACLineSegment)
                {
                    var acls = inputCimObject as ACLineSegment;

                    if (acls.PSRType == "InternalCable")
                    {
                        // Set name to internal cable
                        acls.name = "Internal Cable";

                        // Set length to 1 meter
                        acls.length.Value = 1;

                        // Set value to zero
                        acls.r = new Resistance()
                        {
                            Value = 0
                        };
                        acls.r0 = new Resistance()
                        {
                            Value = 0
                        };
                        acls.x = new Reactance()
                        {
                            Value = 0
                        };
                        acls.x0 = new Reactance()
                        {
                            Value = 0
                        };
                        acls.bch = new Susceptance()
                        {
                            Value = 0
                        };
                        acls.b0ch = new Susceptance()
                        {
                            Value = 0
                        };
                        acls.gch = new Conductance()
                        {
                            Value = 0
                        };
                        acls.g0ch = new Conductance()
                        {
                            Value = 0
                        };
                    }
                }

                // Sæt transformer vikling navn og r,x,b,g værdier på vikling 2 til 0
                if (inputCimObject is PowerTransformerEndExt)
                {
                    var ptEnd = inputCimObject as PowerTransformerEndExt;

                    var pt = context.GetObject <PowerTransformer>(ptEnd.PowerTransformer.@ref);

                    ptEnd.name = pt.Substation.name + "_" + pt.name + "_T" + ptEnd.endNumber;

                    /* Don't calculate r,x,b,g anymore.
                     * if (ptEnd.endNumber == "1")
                     * {
                     *  ptEnd.b0 = new Susceptance() { Value = 0 };
                     *  ptEnd.g0 = new Conductance() { Value = 0 };
                     *
                     *  if (ptEnd.ratedU == null ||
                     *      ptEnd.ratedS == null ||
                     *      ptEnd.excitingCurrentZero == null ||
                     *      ptEnd.loss == null ||
                     *      ptEnd.lossZero == null ||
                     *      ptEnd.uk == null)
                     *  {
                     *      // FIX: burde måske logge fejl, men PF skal nok brokke sig
                     *  }
                     *  else
                     *  {
                     *      // Beregn r: loss * (ratedU / ratedS * 1000)^2
                     *      ptEnd.r = new Resistance() { Value = ptEnd.loss.Value * Math.Pow((ptEnd.ratedU.Value / (ptEnd.ratedS.Value * 1000)), 2) };
                     *
                     *      // Beregn g: (LossZero / ratedU^2)
                     *      double g = ptEnd.lossZero.Value / Math.Pow(ptEnd.ratedU.Value, 2);
                     *      ptEnd.g = new Conductance() { Value = g };
                     *
                     *      // Beregn YOC: (excitingCurrentZero*ratedS)/(100 * (ratedU^2))
                     *      double yoc = (ptEnd.excitingCurrentZero.Value * (ptEnd.ratedS.Value * 1000)) / (100 * Math.Pow(ptEnd.ratedU.Value, 2));
                     *
                     *      // Beregn b: SQRT(YOC^2-g^2)
                     *      ptEnd.b = new Susceptance()
                     *      {
                     *          Value = Math.Sqrt(Math.Pow(yoc, 2) - Math.Pow(g, 2))
                     *      };
                     *
                     *      // Beregn Zk: (uk*ratedU^2)/(100*ratedS)
                     *      double zk = (ptEnd.uk.Value * Math.Pow(ptEnd.ratedU.Value, 2)) / (100 * (ptEnd.ratedS.Value * 1000));
                     *
                     *      // Beregn x: SQRT(Zk^2-r^2)
                     *      ptEnd.x = new Reactance()
                     *      {
                     *          Value = Math.Sqrt(
                     *              Math.Pow(zk, 2) - Math.Pow(ptEnd.r.Value, 2)
                     *         )
                     *      };
                     *  }
                     * }
                     */

                    if (ptEnd.endNumber == "2")
                    {
                        // Set value to zero
                        ptEnd.r = new Resistance()
                        {
                            Value = 0
                        };
                        ptEnd.r0 = new Resistance()
                        {
                            Value = 0
                        };
                        ptEnd.x = new Reactance()
                        {
                            Value = 0
                        };
                        ptEnd.x0 = new Reactance()
                        {
                            Value = 0
                        };
                        ptEnd.b = new Susceptance()
                        {
                            Value = 0
                        };
                        ptEnd.b0 = new Susceptance()
                        {
                            Value = 0
                        };
                        ptEnd.g = new Conductance()
                        {
                            Value = 0
                        };
                        ptEnd.g0 = new Conductance()
                        {
                            Value = 0
                        };
                    }
                }

                // Remove 'TRF' from transformer name
                if (inputCimObject is PowerTransformer)
                {
                    inputCimObject.name = inputCimObject.name.Replace("TRF", "");
                }

                // Ensure bay name is max 32 charaters
                if (inputCimObject is IdentifiedObject && inputCimObject.name != null && inputCimObject.name.Length > 32)
                {
                    inputCimObject.name = inputCimObject.name.Substring(0, 32);
                }

                // Set name of disconnectors to ADSK
                if (inputCimObject is Disconnector)
                {
                    inputCimObject.name = "ADSK";
                }

                // Set name of disconnectors to ADSK
                if (inputCimObject is Fuse)
                {
                    inputCimObject.name = "SIKRING";
                }

                // Ensure connectivity nodes / busbars have proper names.
                // Needed by Konstant to support short circuit result extracts etc. PF uses the name of the node/busbar in reports.
                // Also needed to support time series import (Jakob busbar naming)
                if (inputCimObject is ConnectivityNode)
                {
                    var cn = inputCimObject as ConnectivityNode;

                    if (cn.mRID == "1663a3a8-a706-726a-8de5-7f57e2f9e68b")
                    {
                    }

                    if (cn.name == null || cn.name.Length == 0)
                    {
                        var cnNeighbors = cn.GetNeighborConductingEquipments(context);

                        var pt  = cnNeighbors.Find(o => o is PowerTransformer) as PowerTransformer;
                        var bus = cnNeighbors.Find(o => o is BusbarSection);

                        if (pt != null)
                        {
                            var stVoltageLevels = context.GetSubstationVoltageLevels(pt.Substation);

                            var    ptConnections     = context.GetConnections(pt);
                            var    ptTerminal        = ptConnections.First(c => c.ConnectivityNode == cn);
                            var    ptEnds            = pt.GetEnds(context);
                            var    ptEnd             = ptEnds.Find(e => e.Terminal.@ref == ptTerminal.Terminal.mRID);
                            double ptEndVoltageLevel = ptEnd.BaseVoltage;

                            if (pt.name != null)
                            {
                                // HACK SHOULD BE CLEANED UP
                                // Terminal actual exist in source, but get trown away in filter, because nothing connected to it

                                if (!ptConnections.Exists(c => c.Terminal.sequenceNumber == "2"))
                                {
                                    Logger.Log(LogLevel.Info, "Station: " + pt.Substation.name + " Trafo: " + pt.name + " mangler secondær skinne. Vil bliver oprettet");

                                    var ptLvCn = new ConnectivityNode()
                                    {
                                        mRID = Guid.NewGuid().ToString(), name = pt.GetSubstation(true, context).name + "_" + GetVoltageLevelStr(400) + "_" + pt.name.Replace("TRF", "")
                                    };

                                    addList.Add(ptLvCn);

                                    if (stVoltageLevels.Exists(o => o.BaseVoltage == 400))
                                    {
                                        var vl = stVoltageLevels.First(o => o.BaseVoltage == 400);

                                        _mappingContext.ConnectivityNodeToVoltageLevel.Add(ptLvCn, vl);
                                    }
                                    else
                                    {
                                        var vl = new DAX.CIM.PhysicalNetworkModel.VoltageLevel()
                                        {
                                            mRID = Guid.NewGuid().ToString(),
                                            name = "0,4 kV",
                                            EquipmentContainer1 = new VoltageLevelEquipmentContainer()
                                            {
                                                @ref = pt.Substation.mRID
                                            },
                                            BaseVoltage = 400
                                        };

                                        addList.Add(vl);

                                        stVoltageLevels.Add(vl);
                                        _mappingContext.ConnectivityNodeToVoltageLevel.Add(ptLvCn, vl);
                                    }

                                    var ptLvTerminal = new Terminal()
                                    {
                                        mRID             = Guid.NewGuid().ToString(),
                                        phases           = PhaseCode.ABCN,
                                        phasesSpecified  = true,
                                        sequenceNumber   = "2",
                                        ConnectivityNode = new TerminalConnectivityNode()
                                        {
                                            @ref = ptLvCn.mRID
                                        },
                                        ConductingEquipment = new TerminalConductingEquipment {
                                            @ref = pt.mRID
                                        }
                                    };

                                    var ptEnd2 = context.GetPowerTransformerEnds(pt).First(p => p.endNumber == "2");
                                    ptEnd2.Terminal = new TransformerEndTerminal()
                                    {
                                        @ref = ptLvTerminal.mRID
                                    };

                                    addList.Add(ptLvTerminal);
                                }
                            }



                            // IF the PT END CN is connected to a conducting equipment
                            if (cnNeighbors.Exists(o => !(o is PowerTransformer) && o.BaseVoltage > 0.0))
                            {
                                ptEndVoltageLevel = cnNeighbors.First(o => !(o is PowerTransformer) && o.BaseVoltage > 0.0).BaseVoltage;

                                if (stVoltageLevels.Exists(o => o.BaseVoltage == ptEndVoltageLevel))
                                {
                                    var vl = stVoltageLevels.First(o => o.BaseVoltage == ptEndVoltageLevel);

                                    _mappingContext.ConnectivityNodeToVoltageLevel.Add(cn, vl);
                                }
                            }
                            // IF the PT END CN is *not* connected to anything
                            else
                            {
                                // Set CN to PT END voltage level
                                var vl = stVoltageLevels.First(o => o.BaseVoltage == ptEndVoltageLevel);
                                _mappingContext.ConnectivityNodeToVoltageLevel.Add(cn, vl);

                                // If 60 kV transformer secondary side
                                if (ptEndVoltageLevel < 20000 && ptEndVoltageLevel > 5000)
                                {
                                    if (ptEnds.Exists(e => e.BaseVoltage == 60000))
                                    {
                                        EnergyConsumer ec = new EnergyConsumer()
                                        {
                                            mRID = GUIDHelper.CreateDerivedGuid(Guid.Parse(pt.mRID), 1001, true).ToString(),
                                            name = pt.GetSubstation(true, context).name + "_" + GetVoltageLevelStr(ptEndVoltageLevel) + "_" + pt.name.Replace("TRF", ""),
                                            EquipmentContainer = new EquipmentEquipmentContainer()
                                            {
                                                @ref = vl.mRID
                                            },
                                            BaseVoltage = vl.BaseVoltage
                                        };

                                        Terminal ecTerm = new Terminal()
                                        {
                                            mRID = GUIDHelper.CreateDerivedGuid(Guid.Parse(pt.mRID), 1002, true).ToString(),
                                            name = ec.name + "_T1",
                                            ConductingEquipment = new TerminalConductingEquipment()
                                            {
                                                @ref = ec.mRID
                                            },
                                            ConnectivityNode = new TerminalConnectivityNode()
                                            {
                                                @ref = cn.mRID
                                            }
                                        };

                                        addList.Add(ec);
                                        addList.Add(ecTerm);
                                    }
                                }
                            }

                            cn.name = pt.GetSubstation(true, context).name + "_" + GetVoltageLevelStr(ptEndVoltageLevel) + "_" + pt.name.Replace("TRF", "");

                            /*
                             * // Hvis trafo deler node med skinne, eller node er 400 volt, så brug jakob navngivning
                             * if (bus != null || ptEndVoltageLevel == 400)
                             *  cn.name = pt.GetSubstation(true, context).name + "_" + GetVoltageLevelStr(ptEndVoltageLevel) + "_" + pt.name.Replace("TRF", "");
                             * else
                             *  cn.name = "CN";
                             */
                        }
                        else if (bus != null && bus.name != null)
                        {
                            cn.name        = bus.name;
                            cn.description = bus.description;
                        }
                        else
                        {
                            var bay = cn.GetBay(false, context);

                            if (bay != null)
                            {
                                if (cnNeighbors.Count == 1 || cnNeighbors.Exists(n => !(n is Switch)))
                                {
                                    cn.name = bay.name + " ENDE";
                                }
                                else
                                {
                                    cn.name = bay.name;
                                }
                            }
                            else
                            {
                                cn.name = "CN";
                            }
                        }
                    }
                }
            }

            // return objects, except the one dropped
            foreach (var inputObj in input)
            {
                if (!dropList.Contains(inputObj))
                {
                    yield return(inputObj);
                }
            }

            // yield added objects,
            foreach (var inputObj in addList)
            {
                yield return(inputObj);
            }
        }
 void PopulateTapChangerProperties(ConductingEquipment x, ResourceDescription rd)
 {
     PopulatePowerSystemResourceProperties(x, rd);
 }
        public NetworkModel(NetworkModelDownload download)
        {
            Dictionary <long, IdentifiedObject> terminalContainer = download.Containers[DMSType.Terminal];
            Dictionary <long, IdentifiedObject> conNodeContainer  = download.Containers[DMSType.ConnectivityNode];

            List <Node> trees = new List <Node>();
            Dictionary <long, RecloserNode> reclosers = new Dictionary <long, RecloserNode>();

            foreach (KeyValuePair <long, IdentifiedObject> source in download.Containers[DMSType.EnergySource])
            {
                if (source.Value == null)
                {
                    continue;
                }

                Node         root  = new Node(null, source.Value);
                Stack <Node> stack = new Stack <Node>();
                stack.Push(root);

                while (stack.Count > 0)
                {
                    Node             node = stack.Pop();
                    IdentifiedObject io   = node.io;
                    DMSType          type = ModelCodeHelper.GetTypeFromGID(io.GID);

                    switch (type)
                    {
                    case DMSType.ConnectivityNode:
                    {
                        foreach (long terminalGID in ((ConnectivityNode)io).Terminals)
                        {
                            long condEqGID = ((Terminal)terminalContainer[terminalGID]).ConductingEquipment;

                            if (condEqGID == node.parent.io.GID)
                            {
                                continue;
                            }

                            DMSType             condEqType = ModelCodeHelper.GetTypeFromGID(condEqGID);
                            ConductingEquipment condEq     = (ConductingEquipment)download.Containers[condEqType][condEqGID];

                            if (condEq is Recloser)
                            {
                                RecloserNode rn;
                                if (reclosers.TryGetValue(condEqGID, out rn))
                                {
                                    if (rn.node2 == null)
                                    {
                                        rn.node2 = node;
                                    }
                                }
                                else
                                {
                                    reclosers.Add(condEqGID, new RecloserNode(condEq)
                                        {
                                            node1 = node
                                        });
                                }

                                continue;
                            }

                            Node childNode = new Node(node, condEq);
                            node.children.Add(childNode);
                            stack.Push(childNode);
                        }
                    }
                    break;

                    case DMSType.TransformerWinding:
                    {
                        TransformerWinding tw = io as TransformerWinding;

                        if (tw == null)
                        {
                            break;
                        }

                        PowerTransformer pt = GetInternal(download.Containers, tw.PowerTransformer) as PowerTransformer;

                        if (pt == null)
                        {
                            break;
                        }

                        foreach (long twGID in pt.TransformerWindings)
                        {
                            if (twGID == tw.GID || (node.parent != null && twGID == node.parent.io.GID))
                            {
                                continue;
                            }

                            TransformerWinding twChild = GetInternal(download.Containers, twGID) as TransformerWinding;

                            if (twChild == null)
                            {
                                continue;
                            }

                            Node childNode = new Node(node, twChild);
                            node.children.Add(childNode);
                            stack.Push(childNode);
                        }

                        foreach (long terminalGID in tw.Terminals)
                        {
                            long conNodeGID = ((Terminal)terminalContainer[terminalGID]).ConnectivityNode;

                            if (node.parent != null && conNodeGID == node.parent.io.GID)
                            {
                                continue;
                            }

                            Node childNode = new Node(node, conNodeContainer[conNodeGID]);
                            node.children.Add(childNode);
                            stack.Push(childNode);
                        }
                    }
                    break;

                    default:
                    {
                        ConductingEquipment condEq = io as ConductingEquipment;

                        if (condEq == null)
                        {
                            break;
                        }

                        foreach (long terminalGID in condEq.Terminals)
                        {
                            long conNodeGID = ((Terminal)terminalContainer[terminalGID]).ConnectivityNode;

                            if (node.parent != null && conNodeGID == node.parent.io.GID)
                            {
                                continue;
                            }

                            Node childNode = new Node(node, conNodeContainer[conNodeGID]);
                            node.children.Add(childNode);
                            stack.Push(childNode);
                        }
                    }
                    break;
                    }
                }

                trees.Add(root);
            }

            this.trees      = trees;
            this.reclosers  = reclosers;
            this.containers = download.Containers;
        }