public static void PopulateBreakerProperties(Outage.Breaker cimBreaker, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimBreaker != null) && (rd != null))
{
OutageConverter.PopulateProtectedSwitchProperties(cimBreaker, rd, importHelper, report);
if (cimBreaker.NoReclosingHasValue)
{
rd.AddProperty(new Property(ModelCode.BREAKER_NORECLOSING, cimBreaker.NoReclosing));
}
}
}
public static void PopulateACLineSegmentProperties(FTN.ACLineSegment cimACLineSegment, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimACLineSegment != null) && (rd != null))
{
PowerTransformerConverter.PopulateConductorProperties(cimACLineSegment, rd);
if (cimACLineSegment.B0chHasValue)
{
rd.AddProperty(new Property(ModelCode.ACLSEGMENT_B0CH, cimACLineSegment.B0ch));
}
if (cimACLineSegment.BchHasValue)
{
rd.AddProperty(new Property(ModelCode.ACLSEGMENT_BCH, cimACLineSegment.Bch));
}
if (cimACLineSegment.G0chHasValue)
{
rd.AddProperty(new Property(ModelCode.ACLSEGMENT_G0CH, cimACLineSegment.G0ch));
}
if (cimACLineSegment.GchHasValue)
{
rd.AddProperty(new Property(ModelCode.ACLSEGMENT_GCH, cimACLineSegment.Gch));
}
if (cimACLineSegment.RHasValue)
{
rd.AddProperty(new Property(ModelCode.ACLSEGMENT_R, cimACLineSegment.R));
}
if (cimACLineSegment.R0HasValue)
{
rd.AddProperty(new Property(ModelCode.ACLSEGMENT_R0, cimACLineSegment.R0));
}
if (cimACLineSegment.XHasValue)
{
rd.AddProperty(new Property(ModelCode.ACLSEGMENT_X, cimACLineSegment.X));
}
if (cimACLineSegment.X0HasValue)
{
rd.AddProperty(new Property(ModelCode.ACLSEGMENT_X0, cimACLineSegment.X0));
}
if (cimACLineSegment.PerLengthImpedanceHasValue)
{
long gid = importHelper.GetMappedGID(cimACLineSegment.PerLengthImpedance.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 ACLineSegment: rdfID \"").Append(cimACLineSegment.PerLengthImpedance.ID).AppendLine(" \" is not mapped to GID!");
}
rd.AddProperty(new Property(ModelCode.ACLSEGMENT_PLIMPEDANCE, gid));
}
}
}
public static void PopulateRegulatingCondEqProperties(FTN.RegulatingCondEq cimRegulatingCondEq, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimRegulatingCondEq != null) && (rd != null))
{
Converter.PopulateConductingEquipmentProperties(cimRegulatingCondEq, rd);
}
}
public static void PopulateEnergyConsumerProperties(FTN.EnergyConsumer cimEnergyConsumer, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimEnergyConsumer != null) && (rd != null))
{
LoadFlowConverter.PopulateConductingEquipmentProperties(cimEnergyConsumer, rd, importHelper, report);
if (cimEnergyConsumer.GroundedHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYCONSUMER_GROUNDED, (short)GetDMSWindingConnection(cimEnergyConsumer.Grounded)));
}
if (cimEnergyConsumer.PhaseConnectionHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYCONSUMER_PHASECONNECTION, (short)GetPhaseShuntConnectionKind(cimEnergyConsumer.PhaseConnection)));
}
if (cimEnergyConsumer.PfixedHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYCONSUMER_PFIXED, cimEnergyConsumer.Pfixed));
}
if (cimEnergyConsumer.PfixedPctHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYCONSUMER_PFIXEDPCT, cimEnergyConsumer.PfixedPct));
}
if (cimEnergyConsumer.QfixedHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYCONSUMER_QFIXED, cimEnergyConsumer.Qfixed));
}
if (cimEnergyConsumer.QfixedPctHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYCONSUMER_QFIXEDPCT, cimEnergyConsumer.QfixedPct));
}
}
}
public static void PopulateSwitchProperties(FTN.Switch cimSwitch, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimSwitch != null) && (rd != null))
{
LoadFlowConverter.PopulateConductingEquipmentProperties(cimSwitch, rd, importHelper, report);
if (cimSwitch.NormalOpenHasValue)
{
rd.AddProperty(new Property(ModelCode.SWITCH_NORMALOPEN, cimSwitch.NormalOpen));
}
}
}
public static void PopulateConductingEquipmentProperties(FTN.ConductingEquipment cimConductingEquipment, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimConductingEquipment != null) && (rd != null))
{
LoadFlowConverter.PopulateEquipmentProperties(cimConductingEquipment, rd);
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 PopulateConductorProperties(FTN.Conductor cimConductor, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimConductor != null) && (rd != null))
{
LoadFlowConverter.PopulateConductingEquipmentProperties(cimConductor, rd, importHelper, report);
if (cimConductor.LengthHasValue)
{
rd.AddProperty(new Property(ModelCode.CONDUCTOR_LENGTH, cimConductor.Length));
}
}
}
public static void PopulateEnergySourceProperties(Outage.EnergySource cimEnergySource, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimEnergySource != null) && (rd != null))
{
OutageConverter.PopulateConductingEquipmentProperties(cimEnergySource, rd, importHelper, report);
}
}
public static void PopulateEnergyConsumerProperties(Outage.EnergyConsumer cimEnergyConsumer, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimEnergyConsumer != null) && (rd != null))
{
OutageConverter.PopulateConductingEquipmentProperties(cimEnergyConsumer, rd, importHelper, report);
}
if (cimEnergyConsumer.LastNameHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYCONSUMER_LASTNAME, cimEnergyConsumer.LastName));
}
if (cimEnergyConsumer.FirstNameHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYCONSUMER_FIRSTNAME, cimEnergyConsumer.FirstName));
}
if (cimEnergyConsumer.TypeHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYCONSUMER_TYPE, (short)GetEnergyConsumerType(cimEnergyConsumer.Type)));
}
}
public static void PopulateAnalogProperties(Outage.Analog cimAnalog, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimAnalog != null) && (rd != null))
{
OutageConverter.PopulateMeasurementProperties(cimAnalog, rd, importHelper, report);
if (cimAnalog.CurrentValueHasValue)
{
rd.AddProperty(new Property(ModelCode.ANALOG_CURRENTVALUE, cimAnalog.CurrentValue));
}
if (cimAnalog.MaxValueHasValue)
{
rd.AddProperty(new Property(ModelCode.ANALOG_MAXVALUE, cimAnalog.MaxValue));
}
if (cimAnalog.MeasurementTypeHasValue)
{
rd.AddProperty(new Property(ModelCode.ANALOG_SIGNALTYPE, (short)GetAnalogMeasurementType(cimAnalog.MeasurementType)));
}
if (cimAnalog.MinValueHasValue)
{
rd.AddProperty(new Property(ModelCode.ANALOG_MINVALUE, cimAnalog.MinValue));
}
if (cimAnalog.NormalValueHasValue)
{
rd.AddProperty(new Property(ModelCode.ANALOG_NORMALVALUE, cimAnalog.NormalValue));
}
if (cimAnalog.DeviationHasValue)
{
rd.AddProperty(new Property(ModelCode.ANALOG_DEVIATION, cimAnalog.Deviation));
}
if (cimAnalog.ScalingFactorHasValue)
{
rd.AddProperty(new Property(ModelCode.ANALOG_SCALINGFACTOR, cimAnalog.ScalingFactor));
}
}
}
public static void PopulateSynchronousMachineProperties(Outage.SynchronousMachine cimSynchronousMachine, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimSynchronousMachine != null) && (rd != null))
{
OutageConverter.PopulateConductingEquipmentProperties(cimSynchronousMachine, rd, importHelper, report);
if (cimSynchronousMachine.CapacityHasValue)
{
rd.AddProperty(new Property(ModelCode.SYNCHRONOUSMACHINE_CAPACITY, cimSynchronousMachine.Capacity));
}
if (cimSynchronousMachine.CurrentRegimeHasValue)
{
rd.AddProperty(new Property(ModelCode.SYNCHRONOUSMACHINE_CURRENTREGIME, cimSynchronousMachine.CurrentRegime));
}
}
}
public static void PopulateDiscreteProperties(Outage.Discrete cimDiscrete, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimDiscrete != null) && (rd != null))
{
OutageConverter.PopulateMeasurementProperties(cimDiscrete, rd, importHelper, report);
if (cimDiscrete.CurrentOpenHasValue)
{
rd.AddProperty(new Property(ModelCode.DISCRETE_CURRENTOPEN, cimDiscrete.CurrentOpen));
}
if (cimDiscrete.MaxValueHasValue)
{
rd.AddProperty(new Property(ModelCode.DISCRETE_MAXVALUE, cimDiscrete.MaxValue));
}
if (cimDiscrete.MeasurementTypeHasValue)
{
rd.AddProperty(new Property(ModelCode.DISCRETE_MEASUREMENTTYPE, (short)GetDiscreteMeasuremetType(cimDiscrete.MeasurementType)));
}
if (cimDiscrete.MinValueHasValue)
{
rd.AddProperty(new Property(ModelCode.DISCRETE_MINVALUE, cimDiscrete.MinValue));
}
if (cimDiscrete.NormalValueHasValue)
{
rd.AddProperty(new Property(ModelCode.DISCRETE_NORMALVALUE, cimDiscrete.NormalValue));
}
}
}
public static void PopulateMeasurementProperties(Outage.Measurement cimMeasurement, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimMeasurement != null) && (rd != null))
{
OutageConverter.PopulateIdentifiedObjectProperties(cimMeasurement, rd);
if (cimMeasurement.AddressHasValue)
{
rd.AddProperty(new Property(ModelCode.MEASUREMENT_ADDRESS, cimMeasurement.Address));
}
if (cimMeasurement.IsInputHasValue)
{
rd.AddProperty(new Property(ModelCode.MEASUREMENT_ISINPUT, cimMeasurement.IsInput));
}
if (cimMeasurement.TerminalHasValue)
{
long gid = importHelper.GetMappedGID(cimMeasurement.Terminal.ID);
if (gid < 0)
{
report.Report.Append("WARNING: Convert ").Append(cimMeasurement.GetType().ToString()).Append(" rdfID: \"").Append(cimMeasurement.ID);
report.Report.Append("\" - Failed to set reference to Terminal: rdfID \"").Append(cimMeasurement.Terminal.ID).AppendLine(" \" is not mapped to GID!");
}
rd.AddProperty(new Property(ModelCode.MEASUREMENT_TERMINAL, gid));
}
}
}
public static void PopulateLoadBreakSwitchProperties(Outage.LoadBreakSwitch cimLoadBreakSwitch, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimLoadBreakSwitch != null) && (rd != null))
{
OutageConverter.PopulateProtectedSwitchProperties(cimLoadBreakSwitch, rd, importHelper, report);
}
}
public static void PopulateSwitchProperties(FTN.Switch cimSwitch, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimSwitch != null) && (rd != null))
{
PowerTransformerConverter.PopulateConductingEquipmentProperties(cimSwitch, rd, importHelper, report);
if (cimSwitch.SwitchingOperationsHasValue)
{
long gid = importHelper.GetMappedGID(cimSwitch.SwitchingOperations.ID);
if (gid < 0)
{
report.Report.Append("WARNING: Convert ").Append(cimSwitch.GetType().ToString()).Append(" rdfID = \"").Append(cimSwitch.ID);
report.Report.Append("\" - Failed to set reference to SwitchingOperation: rdfID \"").Append(cimSwitch.SwitchingOperations.ID).AppendLine(" \" is not mapped to GID!");
}
rd.AddProperty(new Property(ModelCode.SWITCH_SWITCHINGOPERATION, gid));
}
}
}
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 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(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 PopulatePowerTransformerProperties(FTN.PowerTransformer cimPowerTransformer, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimPowerTransformer != null) && (rd != null))
{
LoadFlowConverter.PopulateConductingEquipmentProperties(cimPowerTransformer, rd, importHelper, report);
}
}
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));
}
}
}
public static void PopulateACLineSegmentProperties(FTN.ACLineSegment cimACLineSegment, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimACLineSegment != null) && (rd != null))
{
LoadFlowConverter.PopulateConductorProperties(cimACLineSegment, rd, importHelper, report);
if (cimACLineSegment.XHasValue)
{
rd.AddProperty(new Property(ModelCode.ACLINESEGMENT_X, cimACLineSegment.X));
}
if (cimACLineSegment.X0HasValue)
{
rd.AddProperty(new Property(ModelCode.ACLINESEGMENT_X0, cimACLineSegment.X0));
}
if (cimACLineSegment.RHasValue)
{
rd.AddProperty(new Property(ModelCode.ACLINESEGMENT_R, cimACLineSegment.R));
}
if (cimACLineSegment.R0HasValue)
{
rd.AddProperty(new Property(ModelCode.ACLINESEGMENT_R0, cimACLineSegment.R0));
}
if (cimACLineSegment.BchHasValue)
{
rd.AddProperty(new Property(ModelCode.ACLINESEGMENT_BCH, cimACLineSegment.Bch));
}
if (cimACLineSegment.B0chHasValue)
{
rd.AddProperty(new Property(ModelCode.ACLINESEGMENT_B0CH, cimACLineSegment.B0ch));
}
if (cimACLineSegment.GchHasValue)
{
rd.AddProperty(new Property(ModelCode.ACLINESEGMENT_GCH, cimACLineSegment.Gch));
}
if (cimACLineSegment.G0chHasValue)
{
rd.AddProperty(new Property(ModelCode.ACLINESEGMENT_G0CH, cimACLineSegment.G0ch));
}
}
}
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 PopulateEnergySourceProperties(FTN.EnergySource cimEnergySource, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimEnergySource != null) && (rd != null))
{
LoadFlowConverter.PopulateConductingEquipmentProperties(cimEnergySource, rd, importHelper, report);
if (cimEnergySource.RHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYSOURCE_R, cimEnergySource.R));
}
if (cimEnergySource.R0HasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYSOURCE_R0, cimEnergySource.R0));
}
if (cimEnergySource.RnHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYSOURCE_RN, cimEnergySource.Rn));
}
if (cimEnergySource.XHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYSOURCE_X, cimEnergySource.X));
}
if (cimEnergySource.X0HasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYSOURCE_X0, cimEnergySource.X0));
}
if (cimEnergySource.XnHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYSOURCE_XN, cimEnergySource.Xn));
}
if (cimEnergySource.ActivePowerHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYSOURCE_ACTIVEPOWER, cimEnergySource.ActivePower));
}
if (cimEnergySource.NominalVoltageHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYSOURCE_NOMINALVOLTAGE, cimEnergySource.NominalVoltage));
}
if (cimEnergySource.VoltageAngleHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYSOURCE_VOLTAGEANGLE, cimEnergySource.VoltageAngle));
}
if (cimEnergySource.VoltageMagnitudeHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGYSOURCE_VOLTAGEMAGNITUDE, cimEnergySource.VoltageMagnitude));
}
}
}
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 PopulatePowerTransformerEndProperties(FTN.PowerTransformerEnd cimPowerTransformerEnd, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimPowerTransformerEnd != null) && (rd != null))
{
LoadFlowConverter.PopulateIdentifiedObjectProperties(cimPowerTransformerEnd, rd);
if (cimPowerTransformerEnd.ConnectionKindHasValue)
{
rd.AddProperty(new Property(ModelCode.PTRANSFORMEREND_CONNKIND, (short)GetDMSWindingConnection(cimPowerTransformerEnd.ConnectionKind)));
}
if (cimPowerTransformerEnd.BHasValue)
{
rd.AddProperty(new Property(ModelCode.PTRANSFORMEREND_B, cimPowerTransformerEnd.B));
}
if (cimPowerTransformerEnd.B0HasValue)
{
rd.AddProperty(new Property(ModelCode.PTRANSFORMEREND_B0, cimPowerTransformerEnd.B0));
}
if (cimPowerTransformerEnd.GHasValue)
{
rd.AddProperty(new Property(ModelCode.PTRANSFORMEREND_G, cimPowerTransformerEnd.G));
}
if (cimPowerTransformerEnd.G0HasValue)
{
rd.AddProperty(new Property(ModelCode.PTRANSFORMEREND_G0, cimPowerTransformerEnd.G));
}
if (cimPowerTransformerEnd.RHasValue)
{
rd.AddProperty(new Property(ModelCode.PTRANSFORMEREND_R, cimPowerTransformerEnd.R));
}
if (cimPowerTransformerEnd.R0HasValue)
{
rd.AddProperty(new Property(ModelCode.PTRANSFORMEREND_R0, cimPowerTransformerEnd.R0));
}
if (cimPowerTransformerEnd.XHasValue)
{
rd.AddProperty(new Property(ModelCode.PTRANSFORMEREND_X, cimPowerTransformerEnd.X));
}
if (cimPowerTransformerEnd.X0HasValue)
{
rd.AddProperty(new Property(ModelCode.PTRANSFORMEREND_X0, cimPowerTransformerEnd.X0));
}
if (cimPowerTransformerEnd.RatedSHasValue)
{
rd.AddProperty(new Property(ModelCode.PTRANSFORMEREND_RATEDS, cimPowerTransformerEnd.RatedS));
}
if (cimPowerTransformerEnd.RatedUHasValue)
{
rd.AddProperty(new Property(ModelCode.PTRANSFORMEREND_RATEDU, cimPowerTransformerEnd.RatedU));
}
if (cimPowerTransformerEnd.EndNumberHasValue)
{
rd.AddProperty(new Property(ModelCode.PTRANSFORMEREND_ENDNUMBER, cimPowerTransformerEnd.EndNumber));
}
if (cimPowerTransformerEnd.PowerTransformerHasValue)
{
long gid = importHelper.GetMappedGID(cimPowerTransformerEnd.PowerTransformer.ID);
if (gid < 0)
{
report.Report.Append("WARNING: Convert ").Append(cimPowerTransformerEnd.GetType().ToString()).Append(" rdfID = \"").Append(cimPowerTransformerEnd.ID);
report.Report.Append("\" - Failed to set reference to PowerTransformer: rdfID \"").Append(cimPowerTransformerEnd.PowerTransformer.ID).AppendLine(" \" is not mapped to GID!");
}
rd.AddProperty(new Property(ModelCode.PTRANSFORMEREND_POWERTRANSFORMER, gid));
}
}
}
public static void PopulatePowerSystemResourceProperties(FTN.PowerSystemResource cimPowerSystemResource, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimPowerSystemResource != null) && (rd != null))
{
PowerTransformerConverter.PopulateIdentifiedObjectProperties(cimPowerSystemResource, rd);
}
}
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));
}
}
}
public static void PopulateEquipmentProperties(FTN.Equipment cimEquipment, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimEquipment != null) && (rd != null))
{
PowerTransformerConverter.PopulatePowerSystemResourceProperties(cimEquipment, rd, importHelper, report);
}
}
public static void PopulateRotatingMachineProperties(FTN.RotatingMachine cimRotatingMachine, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimRotatingMachine != null) && (rd != null))
{
Converter.PopulateRegulatingCondEqProperties(cimRotatingMachine, rd, importHelper, report);
}
}
public static void PopulateACLineSegmentProperties(Outage.ACLineSegment cimACLineSegment, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimACLineSegment != null) && (rd != null))
{
OutageConverter.PopulateConductorProperties(cimACLineSegment, rd, importHelper, report);
}
}