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 PopulatePowerTransformerProperties(Outage.PowerTransformer cimPowerTransformer, ResourceDescription rd)
{
if ((cimPowerTransformer != null) && (rd != null))
{
OutageConverter.PopulateEquipmentProperties(cimPowerTransformer, rd);
}
}
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 PopulatePowerSystemResourceProperties(Outage.PowerSystemResource cimPowerSystemResource, ResourceDescription rd)
{
if ((cimPowerSystemResource != null) && (rd != null))
{
OutageConverter.PopulateIdentifiedObjectProperties(cimPowerSystemResource, rd);
}
}
public static void PopulateConnectivityNodeProperties(Outage.ConnectivityNode cimConnectivityNode, ResourceDescription rd)
{
if ((cimConnectivityNode != null) && (rd != null))
{
OutageConverter.PopulateIdentifiedObjectProperties(cimConnectivityNode, rd);
}
}
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 PopulateACLineSegmentProperties(Outage.ACLineSegment cimACLineSegment, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimACLineSegment != null) && (rd != null))
{
OutageConverter.PopulateConductorProperties(cimACLineSegment, rd, importHelper, report);
}
}
public static void PopulateTerminalProperties(Outage.Terminal cimTerminal, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimTerminal != null) && (rd != null))
{
OutageConverter.PopulateIdentifiedObjectProperties(cimTerminal, rd);
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 ConductingEquipment: rdfID\"").Append(cimTerminal.ConductingEquipment.ID).AppendLine(" \" is not mapped to GID!");
}
rd.AddProperty(new Property(ModelCode.TERMINAL_CONDUCTINGEQUIPMENT, gid));
}
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 ConnectivityNode: rdfID\"").Append(cimTerminal.ConnectivityNode.ID).AppendLine(" \" is not mapped to GID!");
}
rd.AddProperty(new Property(ModelCode.TERMINAL_CONNECTIVITYNODE, 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 PopulateDisconnectorProperties(Outage.Disconnector cimDisconnector, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimDisconnector != null) && (rd != null))
{
OutageConverter.PopulateSwitchProperties(cimDisconnector, rd, importHelper, report);
}
}
public static void PopulateFuseProperties(Outage.Fuse cimFuse, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimFuse != null) && (rd != null))
{
OutageConverter.PopulateSwitchProperties(cimFuse, rd, importHelper, report);
}
}
public static void PopulateSwitchProperties(Outage.Switch cimSwitch, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimSwitch != null) && (rd != null))
{
OutageConverter.PopulateConductingEquipmentProperties(cimSwitch, rd, importHelper, report);
}
}
public static void PopulateEquipmentProperties(Outage.Equipment cimEquipment, ResourceDescription rd)
{
if ((cimEquipment != null) && (rd != null))
{
OutageConverter.PopulatePowerSystemResourceProperties(cimEquipment, rd);
}
}
public static void PopulateBaseVoltageProperties(Outage.BaseVoltage cimBaseVoltage, ResourceDescription rd)
{
if ((cimBaseVoltage != null) && (rd != null))
{
OutageConverter.PopulateIdentifiedObjectProperties(cimBaseVoltage, rd);
if (cimBaseVoltage.NominalVoltageHasValue)
{
rd.AddProperty(new Property(ModelCode.BASEVOLTAGE_NOMINALVOLTAGE, cimBaseVoltage.NominalVoltage));
}
}
}
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));
}
}
}
private ResourceDescription CreatSynchronousMachineResourceDescription(Outage.SynchronousMachine cimSynchronousMachine)
{
ResourceDescription rd = null;
if (cimSynchronousMachine != null)
{
long gid = ModelCodeHelper.CreateGlobalId(0, (short)DMSType.SYNCHRONOUSMACHINE, importHelper.CheckOutIndexForDMSType(DMSType.SYNCHRONOUSMACHINE));
rd = new ResourceDescription(gid);
importHelper.DefineIDMapping(cimSynchronousMachine.ID, gid);
OutageConverter.PopulateSynchronousMachineProperties(cimSynchronousMachine, rd, importHelper, report);
}
return(rd);
}
private ResourceDescription CreateDiscreteResourceDescription(Outage.Discrete cimDiscrete)
{
ResourceDescription rd = null;
if (cimDiscrete != null)
{
long gid = ModelCodeHelper.CreateGlobalId(0, (short)DMSType.DISCRETE, importHelper.CheckOutIndexForDMSType(DMSType.DISCRETE));
rd = new ResourceDescription(gid);
importHelper.DefineIDMapping(cimDiscrete.ID, gid);
OutageConverter.PopulateDiscreteProperties(cimDiscrete, rd, importHelper, report);
}
return(rd);
}
private ResourceDescription CreateAnalogResourceDescription(Outage.Analog cimAnalog)
{
ResourceDescription rd = null;
if (cimAnalog != null)
{
long gid = ModelCodeHelper.CreateGlobalId(0, (short)DMSType.ANALOG, importHelper.CheckOutIndexForDMSType(DMSType.ANALOG));
rd = new ResourceDescription(gid);
importHelper.DefineIDMapping(cimAnalog.ID, gid);
OutageConverter.PopulateAnalogProperties(cimAnalog, rd, importHelper, report);
}
return(rd);
}
private ResourceDescription CreateConnectivityNodeResourceDescription(Outage.ConnectivityNode cimConnectivityNode)
{
ResourceDescription rd = null;
if (cimConnectivityNode != null)
{
long gid = ModelCodeHelper.CreateGlobalId(0, (short)DMSType.CONNECTIVITYNODE, importHelper.CheckOutIndexForDMSType(DMSType.CONNECTIVITYNODE));
rd = new ResourceDescription(gid);
importHelper.DefineIDMapping(cimConnectivityNode.ID, gid);
OutageConverter.PopulateConnectivityNodeProperties(cimConnectivityNode, rd);
}
return(rd);
}
private ResourceDescription CreateTerminalResourceDescription(Outage.Terminal cimTerminal)
{
ResourceDescription rd = null;
if (cimTerminal != null)
{
long gid = ModelCodeHelper.CreateGlobalId(0, (short)DMSType.TERMINAL, importHelper.CheckOutIndexForDMSType(DMSType.TERMINAL));
rd = new ResourceDescription(gid);
importHelper.DefineIDMapping(cimTerminal.ID, gid);
OutageConverter.PopulateTerminalProperties(cimTerminal, rd, importHelper, report);
}
return(rd);
}
private ResourceDescription CreateLoadBreakSwitchResourceDescription(Outage.LoadBreakSwitch cimLoadBreakSwitch)
{
ResourceDescription rd = null;
if (cimLoadBreakSwitch != null)
{
long gid = ModelCodeHelper.CreateGlobalId(0, (short)DMSType.LOADBREAKSWITCH, importHelper.CheckOutIndexForDMSType(DMSType.LOADBREAKSWITCH));
rd = new ResourceDescription(gid);
importHelper.DefineIDMapping(cimLoadBreakSwitch.ID, gid);
OutageConverter.PopulateLoadBreakSwitchProperties(cimLoadBreakSwitch, rd, importHelper, report);
}
return(rd);
}
private ResourceDescription CreateACLineSegmentResourceDescription(Outage.ACLineSegment cimACLineSegment)
{
ResourceDescription rd = null;
if (cimACLineSegment != null)
{
long gid = ModelCodeHelper.CreateGlobalId(0, (short)DMSType.ACLINESEGMENT, importHelper.CheckOutIndexForDMSType(DMSType.ACLINESEGMENT));
rd = new ResourceDescription(gid);
importHelper.DefineIDMapping(cimACLineSegment.ID, gid);
OutageConverter.PopulateACLineSegmentProperties(cimACLineSegment, rd, importHelper, report);
}
return(rd);
}
private ResourceDescription CreateEnergySourceResourceDescription(Outage.EnergySource cimEnergySource)
{
ResourceDescription rd = null;
if (cimEnergySource != null)
{
long gid = ModelCodeHelper.CreateGlobalId(0, (short)DMSType.ENERGYSOURCE, importHelper.CheckOutIndexForDMSType(DMSType.ENERGYSOURCE));
rd = new ResourceDescription(gid);
importHelper.DefineIDMapping(cimEnergySource.ID, gid);
OutageConverter.PopulateEnergySourceProperties(cimEnergySource, rd, importHelper, report);
}
return(rd);
}
private ResourceDescription CreateBreakerResourceDescription(Outage.Breaker cimBreaker)
{
ResourceDescription rd = null;
if (cimBreaker != null)
{
long gid = ModelCodeHelper.CreateGlobalId(0, (short)DMSType.BREAKER, importHelper.CheckOutIndexForDMSType(DMSType.BREAKER));
rd = new ResourceDescription(gid);
importHelper.DefineIDMapping(cimBreaker.ID, gid);
OutageConverter.PopulateBreakerProperties(cimBreaker, rd, importHelper, report);
}
return(rd);
}
private ResourceDescription CreateBaseVoltageResourceDescription(Outage.BaseVoltage cimBaseVoltage)
{
ResourceDescription rd = null;
if (cimBaseVoltage != null)
{
long gid = ModelCodeHelper.CreateGlobalId(0, (short)DMSType.BASEVOLTAGE, importHelper.CheckOutIndexForDMSType(DMSType.BASEVOLTAGE));
rd = new ResourceDescription(gid);
importHelper.DefineIDMapping(cimBaseVoltage.ID, gid);
OutageConverter.PopulateBaseVoltageProperties(cimBaseVoltage, rd);
}
return(rd);
}
private ResourceDescription CreateTransformerWindingResourceDescription(Outage.TransformerWinding cimTransformerWinding)
{
ResourceDescription rd = null;
if (cimTransformerWinding != null)
{
long gid = ModelCodeHelper.CreateGlobalId(0, (short)DMSType.TRANSFORMERWINDING, importHelper.CheckOutIndexForDMSType(DMSType.TRANSFORMERWINDING));
rd = new ResourceDescription(gid);
importHelper.DefineIDMapping(cimTransformerWinding.ID, gid);
OutageConverter.PopulateTransformerWindingProperties(cimTransformerWinding, rd, importHelper, report);
}
return(rd);
}
private ResourceDescription CreatePowerTransformerResourceDescription(Outage.PowerTransformer cimPowerTransformer)
{
ResourceDescription rd = null;
if (cimPowerTransformer != null)
{
long gid = ModelCodeHelper.CreateGlobalId(0, (short)DMSType.POWERTRANSFORMER, importHelper.CheckOutIndexForDMSType(DMSType.POWERTRANSFORMER));
rd = new ResourceDescription(gid);
importHelper.DefineIDMapping(cimPowerTransformer.ID, gid);
OutageConverter.PopulatePowerTransformerProperties(cimPowerTransformer, rd);
}
return(rd);
}
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 PopulateTransformerWindingProperties(Outage.TransformerWinding cimTransformerWinding, ResourceDescription rd, ImportHelper importHelper, TransformAndLoadReport report)
{
if ((cimTransformerWinding != null) && (rd != null))
{
OutageConverter.PopulateConductingEquipmentProperties(cimTransformerWinding, rd, importHelper, report);
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.TRANSFORMERWINDING_POWERTRANSFORMER, gid));
}
}
}
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));
}
}
}
