public static void PopulateACLineSegmentProperties(FTN.ACLineSegment cimACLineSeg, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimACLineSeg != null) && (rd != null))
{
OMSConverter.PopulateConductorProperties(cimACLineSeg, 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 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 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));
}
}
}
}
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 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(ProtectedSwitch ps, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if (ps != null && rd != null)
{
PowerTransformerConverter.PopulateSwitchProperties(ps, rd, importHelper, report);
}
}
public static void PopulateConnectivityNodeContainerProperties(FTN.ConnectivityNodeContainer cimConnNCon, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimConnNCon != null) && (rd != null))
{
OMSConverter.PopulatePowerSystemResourceProperties(cimConnNCon, rd, importHelper, report);
}
}
public static void PopulateConnecttivityNodeProperties(FTN.ConnectivityNode cimConnecNode, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimConnecNode != null) && (rd != null))
{
OMSConverter.PopulateIdentifiedObjectProperties(cimConnecNode, rd);
if (cimConnecNode.ConnectivityNodeContainerHasValue)
{
long gid = importHelper.GetMappedGID(cimConnecNode.ConnectivityNodeContainer.ID);
if (gid < 0)
{
report.Report.Append("WARNING: Convert ").Append(cimConnecNode.GetType().ToString()).Append(" rdfID = \"").Append(cimConnecNode.ID);
report.Report.Append("\" - Failed to set reference to PowerTransformer: rdfID \"").Append(cimConnecNode.ConnectivityNodeContainer.ID).AppendLine(" \" is not mapped to GID!");
}
rd.AddProperty(new Property(ModelCode.CONNECTNODE_CONNECTNODECONT, gid));
}
}
}
public static void PopulateAnalogProperties(FTN.Analog cimAnalog, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimAnalog != null) && (rd != null))
{
OMSConverter.PopulateMeasurmentProperties(cimAnalog, rd, importHelper, report);
if (cimAnalog.MinValueHasValue)
{
rd.AddProperty(new Property(ModelCode.ANALOG_MINVAL, cimAnalog.MinValue));
}
if (cimAnalog.MaxValueHasValue)
{
rd.AddProperty(new Property(ModelCode.ANALOG_MAXVAL, cimAnalog.MaxValue));
}
if (cimAnalog.NormalValueHasValue)
{
rd.AddProperty(new Property(ModelCode.ANALOG_NORMVAL, cimAnalog.NormalValue));
}
}
}
public static void PopulateDiscreteProperties(FTN.Discrete cimDiscrete, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimDiscrete != null) && (rd != null))
{
OMSConverter.PopulateMeasurmentProperties(cimDiscrete, rd, importHelper, report);
if (cimDiscrete.MinValueHasValue)
{
rd.AddProperty(new Property(ModelCode.DISCRETE_MINVAL, cimDiscrete.MinValue));
}
if (cimDiscrete.MaxValueHasValue)
{
rd.AddProperty(new Property(ModelCode.DISCRETE_MAXVAL, cimDiscrete.MaxValue));
}
if (cimDiscrete.NormalValueHasValue)
{
rd.AddProperty(new Property(ModelCode.DISCRETE_NORMVAL, cimDiscrete.NormalValue));
}
if (cimDiscrete.ValidCommandsHasValue)
{
rd.AddProperty(new Property(ModelCode.DISCRETE_VALIDCOMMANDS, GetDMSCommand(cimDiscrete.ValidCommands)));
}
if (cimDiscrete.ValidStatesHasValue)
{
rd.AddProperty(new Property(ModelCode.DISCRETE_VALIDSTATES, GetDMSStates(cimDiscrete.ValidStates)));
}
}
}
public static void PopulateMeasurmentProperties(FTN.Measurement cimMeasurment, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimMeasurment != null) && (rd != null))
{
OMSConverter.PopulateIdentifiedObjectProperties(cimMeasurment, rd);
if (cimMeasurment.DirectionHasValue)
{
rd.AddProperty(new Property(ModelCode.MEASUREMENT_DIRECTION, (short)cimMeasurment.Direction));
}
if (cimMeasurment.MeasurementTypeHasValue)
{
rd.AddProperty(new Property(ModelCode.MEASUREMENT_TYPE, cimMeasurment.MeasurementType));
}
if (cimMeasurment.UnitSymbolHasValue)
{
var unitSym = GetDMSUnitSymbol(cimMeasurment.UnitSymbol);
rd.AddProperty(new Property(ModelCode.MEASUREMENT_UNITSYMB, (short)unitSym));
//rd.AddProperty(new Property(ModelCode.MEASUREMENT_UNITSYMB, (long)cimMeasurment.UnitSymbol));
//rd.AddProperty(new Property(ModelCode.MEASUREMENT_UNITSYMB, (short)cimMeasurment.UnitSymbol));
//rd.AddProperty(new Property(ModelCode.MEASUREMENT_UNITSYMB, cimMeasurment.UnitSymbol.ToString()));
}
if (cimMeasurment.PowerSystemResourceHasValue)
{
long gid = importHelper.GetMappedGID(cimMeasurment.PowerSystemResource.ID);
if (gid < 0)
{
report.Report.Append("WARNING: Convert ").Append(cimMeasurment.GetType().ToString()).Append(" rdfID = \"").Append(cimMeasurment.ID);
report.Report.Append("\" - Failed to set reference to TransformerWinding: rdfID \"").Append(cimMeasurment.PowerSystemResource.ID).AppendLine(" \" is not mapped to GID!");
}
rd.AddProperty(new Property(ModelCode.MEASUREMENT_PSR, gid));
}
}
}
public static void PopulateEnergyConsumerProperties(FTN.EnergyConsumer cimEnergyConsumer, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimEnergyConsumer != null) && (rd != null))
{
OMSConverter.PopulateConductingEquipmentProperties(cimEnergyConsumer, rd, importHelper, report);
if (cimEnergyConsumer.PfixedHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGCONSUMER_PFIXED, cimEnergyConsumer.Pfixed));
}
if (cimEnergyConsumer.QfixedHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGCONSUMER_QFIXED, cimEnergyConsumer.Qfixed));
}
}
}
public static void PopulateEnergySourceProperties(FTN.EnergySource cimEnergySource, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimEnergySource != null) && (rd != null))
{
OMSConverter.PopulateConductingEquipmentProperties(cimEnergySource, rd, importHelper, report);
if (cimEnergySource.ActivePowerHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGSOURCE_ACTPOW, cimEnergySource.ActivePower));
}
if (cimEnergySource.NominalVoltageHasValue)
{
rd.AddProperty(new Property(ModelCode.ENERGSOURCE_NOMVOLT, cimEnergySource.NominalVoltage));
}
}
}
public static void PopulatePowerSystemResourceProperties(PowerSystemResource powerSystemResource, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if (powerSystemResource != null && rd != null)
{
PowerTransformerConverter.PopulateIdentifiedObjectProperties(powerSystemResource, rd);
if (powerSystemResource.OutageScheduleHasValue)
{
long gid = importHelper.GetMappedGID(powerSystemResource.OutageSchedule.ID);
if (gid < 0)
{
report.Report.Append("WARNING: Convert ").Append(powerSystemResource.GetType().ToString()).Append(" rdfID = \"").Append(powerSystemResource.ID);
report.Report.Append("\" - Failed to set reference to OutageSchedule: rdfID \"").Append(powerSystemResource.OutageSchedule.ID).AppendLine(" \" is not mapped to GID!");
}
else
{
rd.AddProperty(new Property(ModelCode.PSR_OUTAGESCHEDULE, gid));
}
}
}
}
public static void PopulateTerminalProperties(FTN.Terminal cimTerminal, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimTerminal != null) && (rd != null))
{
OMSConverter.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 TransformerWinding: rdfID \"").Append(cimTerminal.ConnectivityNode.ID).AppendLine(" \" is not mapped to GID!");
}
rd.AddProperty(new Property(ModelCode.TERMINAL_CONNECTNODE, 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 TransformerWinding: rdfID \"").Append(cimTerminal.ConductingEquipment.ID).AppendLine(" \" is not mapped to GID!");
}
rd.AddProperty(new Property(ModelCode.TERMINAL_CONDEQUIP, 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);
if (cimEquipment.AggregateHasValue)
{
rd.AddProperty(new Property(ModelCode.EQUIPMENT_AGGREGATE, cimEquipment.Aggregate));
}
if (cimEquipment.NormallyInServiceHasValue)
{
rd.AddProperty(new Property(ModelCode.EQUIPEMNT_NORMINSERVICE, cimEquipment.NormallyInService));
}
}
}
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 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));
}
}
}
public static void PopulatePowerTransformerProperties(FTN.PowerTransformer cimPowerTransformer, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimPowerTransformer != null) && (rd != null))
{
PowerTransformerConverter.PopulateEquipmentProperties(cimPowerTransformer, rd, importHelper, report);
if (cimPowerTransformer.FunctionHasValue)
{
rd.AddProperty(new Property(ModelCode.POWERTR_FUNC, (short)GetDMSTransformerFunctionKind(cimPowerTransformer.Function)));
}
if (cimPowerTransformer.AutotransformerHasValue)
{
rd.AddProperty(new Property(ModelCode.POWERTR_AUTO, cimPowerTransformer.Autotransformer));
}
}
}
public static void PopulateDisconnectorProperties(Disconnector d, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if (d != null && rd != null)
{
PowerTransformerConverter.PopulateSwitchProperties(d, rd, importHelper, report);
}
}
public static void PopulateTransformerWindingProperties(FTN.TransformerWinding cimTransformerWinding, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimTransformerWinding != null) && (rd != null))
{
PowerTransformerConverter.PopulateConductingEquipmentProperties(cimTransformerWinding, rd, importHelper, report);
if (cimTransformerWinding.ConnectionTypeHasValue)
{
rd.AddProperty(new Property(ModelCode.POWERTRWINDING_CONNTYPE, (short)GetDMSWindingConnection(cimTransformerWinding.ConnectionType)));
}
if (cimTransformerWinding.GroundedHasValue)
{
rd.AddProperty(new Property(ModelCode.POWERTRWINDING_GROUNDED, cimTransformerWinding.Grounded));
}
if (cimTransformerWinding.RatedSHasValue)
{
rd.AddProperty(new Property(ModelCode.POWERTRWINDING_RATEDS, cimTransformerWinding.RatedS));
}
if (cimTransformerWinding.RatedUHasValue)
{
rd.AddProperty(new Property(ModelCode.POWERTRWINDING_RATEDU, cimTransformerWinding.RatedU));
}
if (cimTransformerWinding.WindingTypeHasValue)
{
rd.AddProperty(new Property(ModelCode.POWERTRWINDING_WINDTYPE, (short)GetDMSWindingType(cimTransformerWinding.WindingType)));
}
if (cimTransformerWinding.PhaseToGroundVoltageHasValue)
{
rd.AddProperty(new Property(ModelCode.POWERTRWINDING_PHASETOGRNDVOLTAGE, cimTransformerWinding.PhaseToGroundVoltage));
}
if (cimTransformerWinding.PhaseToPhaseVoltageHasValue)
{
rd.AddProperty(new Property(ModelCode.POWERTRWINDING_PHASETOPHASEVOLTAGE, cimTransformerWinding.PhaseToPhaseVoltage));
}
if (cimTransformerWinding.PowerTransformerHasValue)
{
long gid = importHelper.GetMappedGID(cimTransformerWinding.PowerTransformer.ID);
if (gid < 0)
{
report.Report.Append("WARNING: Convert ").Append(cimTransformerWinding.GetType().ToString()).Append(" rdfID = \"").Append(cimTransformerWinding.ID);
report.Report.Append("\" - Failed to set reference to PowerTransformer: rdfID \"").Append(cimTransformerWinding.PowerTransformer.ID).AppendLine(" \" is not mapped to GID!");
}
rd.AddProperty(new Property(ModelCode.POWERTRWINDING_POWERTRW, gid));
}
}
}
public static void PopulateOutageScheduleProperties(OutageSchedule o, ResourceDescription rd, ImportHelper i, TransformAndLoadReport report)
{
if (o != null && rd != null)
{
PowerTransformerConverter.PopulateIrregularIntervlScheduleProperties(o, rd);
}
}
public static void PopulateWindingTestProperties(FTN.WindingTest cimWindingTest, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimWindingTest != null) && (rd != null))
{
PowerTransformerConverter.PopulateIdentifiedObjectProperties(cimWindingTest, rd);
if (cimWindingTest.LeakageImpedanceHasValue)
{
rd.AddProperty(new Property(ModelCode.WINDINGTEST_LEAKIMPDN, cimWindingTest.LeakageImpedance));
}
if (cimWindingTest.LoadLossHasValue)
{
rd.AddProperty(new Property(ModelCode.WINDINGTEST_LOADLOSS, cimWindingTest.LoadLoss));
}
if (cimWindingTest.NoLoadLossHasValue)
{
rd.AddProperty(new Property(ModelCode.WINDINGTEST_NOLOADLOSS, cimWindingTest.NoLoadLoss));
}
if (cimWindingTest.PhaseShiftHasValue)
{
rd.AddProperty(new Property(ModelCode.WINDINGTEST_PHASESHIFT, cimWindingTest.PhaseShift));
}
if (cimWindingTest.LeakageImpedance0PercentHasValue)
{
rd.AddProperty(new Property(ModelCode.WINDINGTEST_LEAKIMPDN0PERCENT, cimWindingTest.LeakageImpedance0Percent));
}
if (cimWindingTest.LeakageImpedanceMaxPercentHasValue)
{
rd.AddProperty(new Property(ModelCode.WINDINGTEST_LEAKIMPDNMAXPERCENT, cimWindingTest.LeakageImpedanceMaxPercent));
}
if (cimWindingTest.LeakageImpedanceMinPercentHasValue)
{
rd.AddProperty(new Property(ModelCode.WINDINGTEST_LEAKIMPDNMINPERCENT, cimWindingTest.LeakageImpedanceMinPercent));
}
if (cimWindingTest.From_TransformerWindingHasValue)
{
long gid = importHelper.GetMappedGID(cimWindingTest.From_TransformerWinding.ID);
if (gid < 0)
{
report.Report.Append("WARNING: Convert ").Append(cimWindingTest.GetType().ToString()).Append(" rdfID = \"").Append(cimWindingTest.ID);
report.Report.Append("\" - Failed to set reference to TransformerWinding: rdfID \"").Append(cimWindingTest.From_TransformerWinding.ID).AppendLine(" \" is not mapped to GID!");
}
rd.AddProperty(new Property(ModelCode.WINDINGTEST_POWERTRWINDING, gid));
}
}
}
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 PopulatePowerSystemResourceProperties(FTN.PowerSystemResource cimPowerSystemResource, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimPowerSystemResource != null) && (rd != null))
{
PowerTransformerConverter.PopulateIdentifiedObjectProperties(cimPowerSystemResource, rd);
if (cimPowerSystemResource.CustomTypeHasValue)
{
rd.AddProperty(new Property(ModelCode.PSR_CUSTOMTYPE, cimPowerSystemResource.CustomType));
}
if (cimPowerSystemResource.LocationHasValue)
{
long gid = importHelper.GetMappedGID(cimPowerSystemResource.Location.ID);
if (gid < 0)
{
report.Report.Append("WARNING: Convert ").Append(cimPowerSystemResource.GetType().ToString()).Append(" rdfID = \"").Append(cimPowerSystemResource.ID);
report.Report.Append("\" - Failed to set reference to Location: rdfID \"").Append(cimPowerSystemResource.Location.ID).AppendLine(" \" is not mapped to GID!");
}
rd.AddProperty(new Property(ModelCode.PSR_LOCATION, gid));
}
}
}
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 PopulateEquipmentProperties(FTN.Equipment cimEquipment, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimEquipment != null) && (rd != null))
{
PowerTransformerConverter.PopulatePowerSystemResourceProperties(cimEquipment, rd, importHelper, report);
if (cimEquipment.PrivateHasValue)
{
rd.AddProperty(new Property(ModelCode.EQUIPMENT_ISPRIVATE, cimEquipment.Private));
}
if (cimEquipment.IsUndergroundHasValue)
{
rd.AddProperty(new Property(ModelCode.EQUIPMENT_ISUNDERGROUND, cimEquipment.IsUnderground));
}
}
}
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 PopulateConductorProperties(FTN.Conductor cimConductor, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimConductor != null) && (rd != null))
{
OMSConverter.PopulateConductingEquipmentProperties(cimConductor, rd, importHelper, report);
if (cimConductor.LengthHasValue)
{
rd.AddProperty(new Property(ModelCode.CONDUCTOR_LEN, cimConductor.Length));
}
}
}
