public static void PopulatePointProperties(FTN.Point cimPoint, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
        {
            if ((cimPoint != null) && (rd != null))
            {
                PowerTransformerConverter.PopulateIdentifiedObjectProperties(cimPoint, rd);

                if (cimPoint.LongitudeHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.POINT_LONGITUDE, cimPoint.Longitude));
                }

                if (cimPoint.LatitudeHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.POINT_LATITUDE, cimPoint.Latitude));
                }

                if (cimPoint.LineHasValue)
                {
                    long gid = importHelper.GetMappedGID(cimPoint.Line.ID);
                    if (gid < 0)
                    {
                        report.Report.Append("WARNING: Convert ").Append(cimPoint.GetType().ToString()).Append(" rdfID = \"").Append(cimPoint.ID);
                        report.Report.Append("\" - Failed to set reference to ACLINESEGMENT: rdfID \"").Append(cimPoint.Line.ID).AppendLine(" \" is not mapped to GID!");
                    }
                    rd.AddProperty(new Property(ModelCode.POINT_LINE, gid));
                }
            }
        }
示例#2
0
        public static void PopulateTerminalProperties(FTN.Terminal cimTerminal, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
        {
            if ((cimTerminal != null) && (rd != null))
            {
                PowerTransformerConverter.PopulateIdentifiedObjectProperties(cimTerminal, rd);

                if (cimTerminal.ConnectivityNodeHasValue)
                {
                    long gid = importHelper.GetMappedGID(cimTerminal.ConnectivityNode.ID);
                    if (gid < 0)
                    {
                        report.Report.Append("WARNING: Convert ").Append(cimTerminal.GetType().ToString()).Append(" rdfID = \"").Append(cimTerminal.ID);
                        report.Report.Append("\" - Failed to set reference to Terminal: rdfID \"").Append(cimTerminal.ConnectivityNode.ID).AppendLine(" \" is not mapped to GID!");
                    }
                    rd.AddProperty(new Property(ModelCode.TERMINAL_CONNODE, gid));
                }

                if (cimTerminal.ConductingEquipmentHasValue)
                {
                    long gid = importHelper.GetMappedGID(cimTerminal.ConductingEquipment.ID);
                    if (gid < 0)
                    {
                        report.Report.Append("WARNING: Convert ").Append(cimTerminal.GetType().ToString()).Append(" rdfID = \"").Append(cimTerminal.ID);
                        report.Report.Append("\" - Failed to set reference to Terminal: rdfID \"").Append(cimTerminal.ConductingEquipment.ID).AppendLine(" \" is not mapped to GID!");
                    }
                    rd.AddProperty(new Property(ModelCode.TERMINAL_CONDEQ, gid));
                }
            }
        }
示例#3
0
 public static void PopulatePowerSystemResourceProperties(FTN.PowerSystemResource cimPowerSystemResource, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
 {
     if ((cimPowerSystemResource != null) && (rd != null))
     {
         PowerTransformerConverter.PopulateIdentifiedObjectProperties(cimPowerSystemResource, rd);
     }
 }
示例#4
0
        public static void PopulateSeriesCompensatorProperties(FTN.SeriesCompensator cimSeriesCompensator, ResourceDescription rd)
        {
            if ((cimSeriesCompensator != null) && (rd != null))
            {
                PowerTransformerConverter.PopulateConductingEquipmentProperties(cimSeriesCompensator, rd);

                if (cimSeriesCompensator.RHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.SERIESCOMP_R, cimSeriesCompensator.R));
                }

                if (cimSeriesCompensator.R0HasValue)
                {
                    rd.AddProperty(new Property(ModelCode.SERIESCOMP_R0, cimSeriesCompensator.R0));
                }

                if (cimSeriesCompensator.XHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.SERIESCOMP_X, cimSeriesCompensator.X));
                }

                if (cimSeriesCompensator.X0HasValue)
                {
                    rd.AddProperty(new Property(ModelCode.SERIESCOMP_X0, cimSeriesCompensator.X0));
                }
            }
        }
示例#5
0
 public static void PopulateConductingEquipmentProperties(FTN.ConductingEquipment cimConductingEquipment, ResourceDescription rd)
 {
     if ((cimConductingEquipment != null) && (rd != null))
     {
         PowerTransformerConverter.PopulateEquipmentProperties(cimConductingEquipment, rd);
     }
 }
示例#6
0
        public static void PopulateIrregularTimePointProperties(FTN.IrregularTimePoint cimIrregularTimePoint, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
        {
            if ((cimIrregularTimePoint != null) && (rd != null))
            {
                PowerTransformerConverter.PopulateIdentifiedObjectProperties(cimIrregularTimePoint, rd);

                if (cimIrregularTimePoint.TimeHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.IRREGULARTIMEPOINT_TIME, cimIrregularTimePoint.Time));
                }
                if (cimIrregularTimePoint.Value1HasValue)
                {
                    rd.AddProperty(new Property(ModelCode.IRREGULARTIMEPOINT_VALUE1, cimIrregularTimePoint.Value1));
                }
                if (cimIrregularTimePoint.Value2HasValue)
                {
                    rd.AddProperty(new Property(ModelCode.IRREGULARTIMEPOINT_VALUE2, cimIrregularTimePoint.Value2));
                }

                if (cimIrregularTimePoint.IntervalScheduleHasValue)
                {
                    long gid = importHelper.GetMappedGID(cimIrregularTimePoint.IntervalSchedule.ID);
                    if (gid < 0)
                    {
                        report.Report.Append("WARNING: Convert ").Append(cimIrregularTimePoint.GetType().ToString()).Append(" rdfID = \"").Append(cimIrregularTimePoint.ID);
                        report.Report.Append("\" - Failed to set reference to IntervalSchedule: rdfID \"").Append(cimIrregularTimePoint.IntervalSchedule.ID).AppendLine(" \" is not mapped to GID!");
                    }
                    rd.AddProperty(new Property(ModelCode.IRREGULARTIMEPOINT_IRREGULARIINTERVALSCHEDULE, gid));
                }
            }
        }
示例#7
0
        public static void PopulateSwitchingOperationProperties(FTN.SwitchingOperation cimSwitchingOperation, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
        {
            if ((cimSwitchingOperation != null) && (rd != null))
            {
                PowerTransformerConverter.PopulateIdentifiedObjectProperties(cimSwitchingOperation, rd);

                if (cimSwitchingOperation.NewStateHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.SWITCHINGOPERATION_NEWSTATE, (short)GetDMSSwichState(cimSwitchingOperation.NewState)));
                }
                if (cimSwitchingOperation.OperationTimeHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.SWITCHINGOPERATION_OPERATIONTIME, cimSwitchingOperation.OperationTime));
                }

                if (cimSwitchingOperation.OutageScheduleHasValue)
                {
                    long gid = importHelper.GetMappedGID(cimSwitchingOperation.OutageSchedule.ID);
                    if (gid < 0)
                    {
                        report.Report.Append("WARNING: Convert ").Append(cimSwitchingOperation.GetType().ToString()).Append(" rdfID = \"").Append(cimSwitchingOperation.ID);
                        report.Report.Append("\" - Failed to set reference to OutageSchedule: rdfID \"").Append(cimSwitchingOperation.OutageSchedule.ID).AppendLine(" \" is not mapped to GID!");
                    }
                    rd.AddProperty(new Property(ModelCode.SWITCHINGOPERATION_OUTAGESCHEDULE, gid));
                }
            }
        }
 public static void PopulateConnectivityNodeContainerProperties(FTN.ConnectivityNodeContainer cimConnectivityNodeContainer, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
 {
     if ((cimConnectivityNodeContainer != null) && (rd != null))
     {
         PowerTransformerConverter.PopulatePowerSystemResourceProperties(cimConnectivityNodeContainer, rd, importHelper, report);
     }
 }
示例#9
0
        public static void PopulateConductingEquipmentProperties(FTN.ConductingEquipment cimConductingEquipment, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
        {
            if ((cimConductingEquipment != null) && (rd != null))
            {
                PowerTransformerConverter.PopulateEquipmentProperties(cimConductingEquipment, rd, importHelper, report);

                if (cimConductingEquipment.PhasesHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.CONDEQ_PHASES, (short)GetDMSPhaseCode(cimConductingEquipment.Phases)));
                }
                if (cimConductingEquipment.RatedVoltageHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.CONDEQ_RATEDVOLTAGE, cimConductingEquipment.RatedVoltage));
                }
                if (cimConductingEquipment.BaseVoltageHasValue)
                {
                    long gid = importHelper.GetMappedGID(cimConductingEquipment.BaseVoltage.ID);
                    if (gid < 0)
                    {
                        report.Report.Append("WARNING: Convert ").Append(cimConductingEquipment.GetType().ToString()).Append(" rdfID = \"").Append(cimConductingEquipment.ID);
                        report.Report.Append("\" - Failed to set reference to BaseVoltage: rdfID \"").Append(cimConductingEquipment.BaseVoltage.ID).AppendLine(" \" is not mapped to GID!");
                    }
                    rd.AddProperty(new Property(ModelCode.CONDEQ_BASVOLTAGE, gid));
                }
            }
        }
 public static void PopulateEquipmentContainerProperties(EquipmentContainer equipContainer, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
 {
     if ((equipContainer != null) && (rd != null))
     {
         PowerTransformerConverter.PopulateConnectivityNodeContainerProperties(equipContainer, rd, importHelper, report);
     }
 }
 public static void PopulateEquipmentProperties(FTN.Equipment cimEquipment, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
 {
     if ((cimEquipment != null) && (rd != null))
     {
         PowerTransformerConverter.PopulatePowerSystemResourceProperties(cimEquipment, rd, importHelper, report);
         if (cimEquipment.AggregateHasValue)
         {
             rd.AddProperty(new Property(ModelCode.EQUIPMENT_AGGREGATE, cimEquipment.Aggregate));
         }
         if (cimEquipment.NormallyInServiceHasValue)
         {
             rd.AddProperty(new Property(ModelCode.EQUIPMENT_NORMALLYSERVICE, cimEquipment.NormallyInService));
         }
         if (cimEquipment.EquipmentContainerHasValue)
         {
             long gid = importHelper.GetMappedGID(cimEquipment.EquipmentContainer.ID);
             if (gid < 0)
             {
                 report.Report.Append("WARNING: Convert ").Append(cimEquipment.GetType().ToString()).Append(" rdfID = \"").Append(cimEquipment.ID);
                 report.Report.Append("\" - Failed to set reference to EquipmentContainer: rdfID \"").Append(cimEquipment.EquipmentContainer.ID).AppendLine(" \" is not mapped to GID!");
             }
             rd.AddProperty(new Property(ModelCode.EQUIPMENT_EC, gid));
         }
     }
 }
        public static void PopulateACLineSegmentProperties(FTN.ACLineSegment cimACLineSegment, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
        {
            if ((cimACLineSegment != null) && (rd != null))
            {
                PowerTransformerConverter.PopulateConductorProperties(cimACLineSegment, rd, importHelper, report);

                if (cimACLineSegment.RatedCurrentHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.ACLINESEGMENT_CURRENTFLOW, cimACLineSegment.RatedCurrent));
                }

                if (cimACLineSegment.FeederCableHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.ACLINESEGMENT_FEEDERCABLE, cimACLineSegment.FeederCable));
                }

                if (cimACLineSegment.EquipmentContainerHasValue)
                {
                    long gid = importHelper.GetMappedGID(cimACLineSegment.EquipmentContainer.ID);
                    if (gid < 0)
                    {
                        report.Report.Append("WARNING: Convert ").Append(cimACLineSegment.GetType().ToString()).Append(" rdfID = \"").Append(cimACLineSegment.ID);
                        report.Report.Append("\" - Failed to set reference to EquipmentContainer: rdfID \"").Append(cimACLineSegment.EquipmentContainer.ID).AppendLine(" \" is not mapped to GID!");
                    }
                    rd.AddProperty(new Property(ModelCode.EQUIPMENT_CONTAINER, gid));
                }
            }
        }
        public static void PopulateEnergyConsumerProperties(FTN.EnergyConsumer cimEnergyConsumer, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
        {
            if ((cimEnergyConsumer != null) && (rd != null))
            {
                PowerTransformerConverter.PopulateConductingEquipmentProperties(cimEnergyConsumer, rd, importHelper, report);

                if (cimEnergyConsumer.PfixedHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.ENERGYCONSUMER_PFIXED, cimEnergyConsumer.Pfixed));
                }

                if (cimEnergyConsumer.QfixedHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.ENERGYCONSUMER_QFIXED, cimEnergyConsumer.Qfixed));
                }

                if (cimEnergyConsumer.EquipmentContainerHasValue)
                {
                    long gid = importHelper.GetMappedGID(cimEnergyConsumer.EquipmentContainer.ID);
                    if (gid < 0)
                    {
                        report.Report.Append("WARNING: Convert ").Append(cimEnergyConsumer.GetType().ToString()).Append(" rdfID = \"").Append(cimEnergyConsumer.ID);
                        report.Report.Append("\" - Failed to set reference to EquipmentContainer: rdfID \"").Append(cimEnergyConsumer.EquipmentContainer.ID).AppendLine(" \" is not mapped to GID!");
                    }
                    rd.AddProperty(new Property(ModelCode.EQUIPMENT_CONTAINER, gid));
                }
            }
        }
        public static void PopulateSubGeographicalRegionProperties(FTN.SubGeographicalRegion cimSubGeographicalRegion, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
        {
            if ((cimSubGeographicalRegion != null) && (rd != null))
            {
                PowerTransformerConverter.PopulateIdentifiedObjectProperties(cimSubGeographicalRegion, rd);

                if (cimSubGeographicalRegion.LongitudeHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.SUBGEOGRAPHICALREGION_LONGITUDE, cimSubGeographicalRegion.Longitude));
                }

                if (cimSubGeographicalRegion.LatitudeHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.SUBGEOGRAPHICALREGION_LATITUDE, cimSubGeographicalRegion.Latitude));
                }

                if (cimSubGeographicalRegion.RegionHasValue)
                {
                    long gid = importHelper.GetMappedGID(cimSubGeographicalRegion.Region.ID);
                    if (gid < 0)
                    {
                        report.Report.Append("WARNING: Convert ").Append(cimSubGeographicalRegion.GetType().ToString()).Append(" rdfID = \"").Append(cimSubGeographicalRegion.ID);
                        report.Report.Append("\" - Failed to set reference to GeograhicalRegion: rdfID \"").Append(cimSubGeographicalRegion.Region.ID).AppendLine(" \" is not mapped to GID!");
                    }
                    rd.AddProperty(new Property(ModelCode.SUBGEOGRAPHICALREGION_GEOREG, gid));
                }
            }
        }
示例#15
0
        public static void PopulateCurveDataProperties(FTN.CurveData cimCurveData, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
        {
            if ((cimCurveData != null) && (rd != null))
            {
                PowerTransformerConverter.PopulateIdentifiedObjectProperties(cimCurveData, rd);

                if (cimCurveData.XvalueHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.CURVEDATA_XVALUE, cimCurveData.Xvalue));
                }
                if (cimCurveData.Y1valueHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.CURVEDATA_Y1VALUE, cimCurveData.Y1value));
                }
                if (cimCurveData.Y2valueHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.CURVEDATA_Y2VALUE, cimCurveData.Y2value));
                }
                if (cimCurveData.Y3valueHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.CURVEDATA_Y3VALUE, cimCurveData.Y3value));
                }

                if (cimCurveData.CurveHasValue)
                {
                    long gid = importHelper.GetMappedGID(cimCurveData.Curve.ID);
                    if (gid < 0)
                    {
                        report.Report.Append("WARNING: Convert ").Append(cimCurveData.GetType().ToString()).Append(" rdfID = \"").Append(cimCurveData.ID);
                        report.Report.Append("\" - Failed to set reference to Curve: rdfID \"").Append(cimCurveData.Curve.ID).AppendLine(" \" is not mapped to GID!");
                    }
                    rd.AddProperty(new Property(ModelCode.CURVEDATA_CURVE, gid));
                }
            }
        }
 public static void PopulateSwitchProperties(Switch s, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
 {
     if (s != null && rd != null)
     {
         PowerTransformerConverter.PopulateConductingEquipmentProperties(s, rd, importHelper, report);
         if (s.NormalOpenHasValue)
         {
             rd.AddProperty(new Property(ModelCode.SWITCH_NORMOPEN, s.NormalOpen));
         }
         if (s.RatedCurrentHasValue)
         {
             rd.AddProperty(new Property(ModelCode.SWITCH_RATEDCURRENT, s.RatedCurrent));
         }
         if (s.RetainedHasValue)
         {
             rd.AddProperty(new Property(ModelCode.SWITCH_RETAINED, s.Retained));
         }
         if (s.SwitchOnCountHasValue)
         {
             rd.AddProperty(new Property(ModelCode.SWITCH_ONCOUNT, s.SwitchOnCount));
         }
         if (s.SwitchOnDateHasValue)
         {
             rd.AddProperty(new Property(ModelCode.SWITCH_ONDATE, s.SwitchOnDate));
         }
     }
 }
示例#17
0
        public static void PopulateBasicIntervalScheduleProperties(FTN.BasicIntervalSchedule cimBasicIntervalSchedule, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
        {
            if ((cimBasicIntervalSchedule != null) && (rd != null))
            {
                PowerTransformerConverter.PopulateIdentifiedObjectProperties(cimBasicIntervalSchedule, rd);

                if (cimBasicIntervalSchedule.StartTimeHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.BASICINTERVALSCHEDULE_STARTTIME, cimBasicIntervalSchedule.StartTime));
                }
                if (cimBasicIntervalSchedule.Value1MultiplierHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.BASICINTERVALSCHEDULE_VALUE1MULTIPLIER, (short)GetDMSUnitMultiplier(cimBasicIntervalSchedule.Value1Multiplier)));
                }
                if (cimBasicIntervalSchedule.Value1UnitHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.BASICINTERVALSCHEDULE_VALUE1UNIT, (short)GetDMSUnitSymbol(cimBasicIntervalSchedule.Value1Unit)));
                }
                if (cimBasicIntervalSchedule.Value2MultiplierHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.BASICINTERVALSCHEDULE_VALUE2MULTIPLIER, (short)GetDMSUnitMultiplier(cimBasicIntervalSchedule.Value2Multiplier)));
                }
                if (cimBasicIntervalSchedule.Value2UnitHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.BASICINTERVALSCHEDULE_VALUE2UNIT, (short)GetDMSUnitSymbol(cimBasicIntervalSchedule.Value2Unit)));
                }
            }
        }
 public static void PopulateProtectedSwitchProperties(ProtectedSwitch ps, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
 {
     if (ps != null && rd != null)
     {
         PowerTransformerConverter.PopulateSwitchProperties(ps, rd, importHelper, report);
     }
 }
示例#19
0
 public static void PopulateOutageScheduleProperties(FTN.OutageSchedule cimOutageSchedule, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
 {
     if ((cimOutageSchedule != null) && (rd != null))
     {
         PowerTransformerConverter.PopulateIrregularIntervalScheduleProperties(cimOutageSchedule, rd, importHelper, report);
     }
 }
 public static void PopulateDisconnectorProperties(Disconnector d, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
 {
     if (d != null && rd != null)
     {
         PowerTransformerConverter.PopulateSwitchProperties(d, rd, importHelper, report);
     }
 }
示例#21
0
 public static void PopulateGroundDisconnectorProperties(FTN.GroundDisconnector cimGroundDisconnector, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
 {
     if ((cimGroundDisconnector != null) && (rd != null))
     {
         PowerTransformerConverter.PopulateSwitchProperties(cimGroundDisconnector, rd, importHelper, report);
     }
 }
        public static void PopulateBasicIntervalScheduleProperties(BasicIntervalSchedule b, ResourceDescription rd)
        {
            if (b != null && rd != null)
            {
                PowerTransformerConverter.PopulateIdentifiedObjectProperties(b, rd);

                if (b.StartTimeHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.BINTERVALSCHEDULE_STARTTIME, b.StartTime));
                }
                if (b.Value1MultiplierHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.BINTERVALSCHEDULE_V1MULTIPLIER, (short)GetDMSUnitMultiplier(b.Value1Multiplier)));
                }
                if (b.Value1UnitHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.BINTERVALSCHEDULE_V1UNIT, (short)GetDMSUNitSymbol(b.Value1Unit)));
                }
                if (b.Value2MultiplierHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.BINTERVALSCHEDULE_V2MULTIPLIER, (short)GetDMSUnitMultiplier(b.Value2Multiplier)));
                }
                if (b.Value2UnitHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.BINTERVALSCHEDULE_V2UNIT, (short)GetDMSUNitSymbol(b.Value2Unit)));
                }
            }
        }
示例#23
0
 public static void PopulateDCLineSegmentProperties(FTN.DCLineSegment cimDCLineSegment, ResourceDescription rd)
 {
     if ((cimDCLineSegment != null) && (rd != null))
     {
         PowerTransformerConverter.PopulateConductorProperties(cimDCLineSegment, rd);
     }
 }
 public static void PopulateIrregularIntervlScheduleProperties(IrregularIntervalSchedule i, ResourceDescription rd)
 {
     if (i != null && rd != null)
     {
         PowerTransformerConverter.PopulateBasicIntervalScheduleProperties(i, rd);
     }
 }
示例#25
0
 public static void PopulatePerLengthImpedanceProperties(FTN.PerLengthImpedance cimPerLengthImpedance, ResourceDescription rd)
 {
     if ((cimPerLengthImpedance != null) && (rd != null))
     {
         PowerTransformerConverter.PopulateIdentifiedObjectProperties(cimPerLengthImpedance, rd);
     }
 }
        public static void PopulateRegularTimePointProperties(RegularTimePoint r, ResourceDescription rd, ImportHelper i, TransformAndLoadReport report)
        {
            if (r != null && rd != null)
            {
                PowerTransformerConverter.PopulateIdentifiedObjectProperties(r, rd);

                if (r.SequenceNumberHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.REGULARTIMEPOINT_SEQUENCENO, r.SequenceNumber));
                }
                if (r.Value1HasValue)
                {
                    rd.AddProperty(new Property(ModelCode.REGULARTIMEPOINT_VALUE1, r.Value1));
                }
                if (r.Value2HasValue)
                {
                    rd.AddProperty(new Property(ModelCode.REGULARTIMEPOINT_VALUE2, r.Value2));
                }
                if (r.IntervalScheduleHasValue)
                {
                    long gid = i.GetMappedGID(r.IntervalSchedule.ID);
                    if (gid < 0)
                    {
                        report.Report.Append("WARNING: Convert ").Append(r.GetType().ToString()).Append(" rdfID = \"").Append(r.ID);
                        report.Report.Append("\" - Failed to set reference to IntervalSchedule: rdfID \"").Append(r.IntervalSchedule.ID).AppendLine(" \" is not mapped to GID!");
                    }
                    else
                    {
                        rd.AddProperty(new Property(ModelCode.REGULARTIMEPOINT_INTERVALSCHEDULE, gid));
                    }
                }
            }
        }
示例#27
0
        public static void PopulatePhaseImpedanceDataProperties(PhaseImpedanceData cimPhaseImpedanceData, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
        {
            if ((cimPhaseImpedanceData != null) && (rd != null))
            {
                PowerTransformerConverter.PopulateIdentifiedObjectProperties(cimPhaseImpedanceData, rd);

                if (cimPhaseImpedanceData.RHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.PHASEIMPDTA_R, cimPhaseImpedanceData.R));
                }
                if (cimPhaseImpedanceData.BHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.PHASEIMPDTA_B, cimPhaseImpedanceData.B));
                }
                if (cimPhaseImpedanceData.SequenceNumberHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.PHASEIMPDTA_SEQNUM, cimPhaseImpedanceData.SequenceNumber));
                }
                if (cimPhaseImpedanceData.XHasValue)
                {
                    rd.AddProperty(new Property(ModelCode.PHASEIMPDTA_X, cimPhaseImpedanceData.X));
                }
                if (cimPhaseImpedanceData.PhaseImpedanceHasValue)
                {
                    long gid = importHelper.GetMappedGID(cimPhaseImpedanceData.PhaseImpedance.ID);
                    if (gid < 0)
                    {
                        report.Report.Append("WARNING: Convert ").Append(cimPhaseImpedanceData.GetType().ToString()).Append(" rdfID = \"").Append(cimPhaseImpedanceData.ID);
                        report.Report.Append("\" - Failed to set reference to PhaseImpedance: rdfID \"").Append(cimPhaseImpedanceData.PhaseImpedance.ID).AppendLine(" \" is not mapped to GID!");
                    }
                    rd.AddProperty(new Property(ModelCode.ACLINESGMNT_PERLGTHIMPDNC, gid));
                }
            }
        }
 public static void PopulateOutageScheduleProperties(OutageSchedule o, ResourceDescription rd, ImportHelper i, TransformAndLoadReport report)
 {
     if (o != null && rd != null)
     {
         PowerTransformerConverter.PopulateIrregularIntervlScheduleProperties(o, rd);
     }
 }
示例#29
0
 public static void PopulateConductingEquipmentProperties(FTN.ConductingEquipment cimConductingEquipment, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
 {
     if ((cimConductingEquipment != null) && (rd != null))
     {
         PowerTransformerConverter.PopulateEquipmentProperties(cimConductingEquipment, rd, importHelper, report);
     }
 }
 public static void PopulateProtectedSwitchProperties(FTN.ProtectedSwitch cimProtectedSwitch, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
 {
     if ((cimProtectedSwitch != null) && (rd != null))
     {
         PowerTransformerConverter.PopulateSwitchProperties(cimProtectedSwitch, rd, importHelper, report);
     }
 }