double GetPowerTransformerRatio(PowerTransformer pt)
{
if (pt.TransformerWindings.Count != 2)
{
return(1);
}
TransformerWinding tw1 = Get(pt.TransformerWindings[0]) as TransformerWinding;
TransformerWinding tw2 = Get(pt.TransformerWindings[1]) as TransformerWinding;
BaseVoltage bv1 = Get(tw1.BaseVoltage) as BaseVoltage;
BaseVoltage bv2 = Get(tw2.BaseVoltage) as BaseVoltage;
Pair <double, double> u = MinMax(bv1.NominalVoltage, bv2.NominalVoltage);
RatioTapChanger rt = null;
if (tw1.RatioTapChanger.Count == 1)
{
rt = Get(tw1.RatioTapChanger[0]) as RatioTapChanger;
}
else if (tw2.RatioTapChanger.Count == 1)
{
rt = Get(tw2.RatioTapChanger[0]) as RatioTapChanger;
}
return(rt != null ? (u.Second + (GetRatioTapChangerStep(rt) - rt.NominalStep) * rt.VoltageStep) / u.First : u.Second / u.First);
}
private ResourceDescription CreateRatioTapChangerResourceDescription(RatioTapChanger cimRatioTapChanger)
{
ResourceDescription rd = null;
if (cimRatioTapChanger != null)
{
long gid = ModelCodeHelper.CreateGlobalId(0, (short)DMSType.RATIOTAPCHANGER, importHelper.CheckOutIndexForDMSType(DMSType.RATIOTAPCHANGER));
rd = new ResourceDescription(gid);
importHelper.DefineIDMapping(cimRatioTapChanger.ID, gid);
SCADAConverter.PopulateRatioTapChangerProperties(cimRatioTapChanger, rd, importHelper, report);
}
return(rd);
}
int GetRatioTapChangerStep(RatioTapChanger rt)
{
for (int i = 0; i < rt.Measurements.Count; ++i)
{
Discrete discrete = Get(rt.Measurements[i]) as Discrete;
int step;
if (discrete != null && discrete.MeasurementType == MeasurementType.TapChangerPosition && discretes.TryGetValue(discrete.GID, out step))
{
return(step);
}
}
return(rt.NominalStep);
}
public void CanDetectObjectModification_NewWithValue()
{
var previousState = new RatioTapChanger
{
mRID = "123",
stepVoltageIncrement = new PerCent
{
Value = 100,
multiplier = UnitMultiplier.k,
unit = UnitSymbol.V
}
};
var newState = previousState.Clone();
// voltage rises to 102 kV
newState.stepVoltageIncrement = new PerCent
{
Value = 102,
multiplier = UnitMultiplier.k,
unit = UnitSymbol.V
};
var dataSetMembers = _differ.GetDiff(new IdentifiedObject[] { previousState }, new IdentifiedObject[] { newState }).ToList();
Assert.That(dataSetMembers.Count, Is.EqualTo(1));
var dataSetMember = dataSetMembers.First();
var cson = dataSetMember.ToPrettyCson();
Console.WriteLine(cson);
var changeSetMember = dataSetMember.Change;
Assert.That(changeSetMember, Is.TypeOf <ObjectModification>());
var objectModification = (ObjectModification)changeSetMember;
var modifications = objectModification.Modifications;
var reverseModifications = dataSetMember.ReverseChange.Modifications;
var forward = GetModification(modifications, nameof(RatioTapChanger.stepVoltageIncrement));
var reverse = GetModification(reverseModifications, nameof(RatioTapChanger.stepVoltageIncrement));
Assert.That(forward.Value is PerCent forwardValue && forwardValue.Value.IsWithinTolerance(102), $"value of {JsonConvert.SerializeObject(forward)} is not close enough to 102");
Assert.That(reverse.Value is PerCent reverseValue && reverseValue.Value.IsWithinTolerance(100), $"value of {JsonConvert.SerializeObject(reverse)} is not close enough to 100");
}
private void ImportRatioTapChanger()
{
SortedDictionary <string, object> cimRatioTapChangers = concreteModel.GetAllObjectsOfType("FTN.RatioTapChanger");
if (cimRatioTapChangers != null)
{
foreach (KeyValuePair <string, object> item in cimRatioTapChangers)
{
RatioTapChanger cimRatioTapChanger = item.Value as RatioTapChanger;
ResourceDescription rd = CreateRatioTapChangerResourceDescription(cimRatioTapChanger);
if (rd != null)
{
delta.AddDeltaOperation(DeltaOpType.Insert, rd, true);
report.Report.Append("RatioTapChanger ID = ").Append(cimRatioTapChanger.ID).Append(" SUCCESSFULLY converted to GID = ").AppendLine(rd.Id.ToString());
}
else
{
report.Report.Append("RatioTapChanger ID = ").Append(cimRatioTapChanger.ID).AppendLine(" FAILED to be converted");
}
}
report.Report.AppendLine();
}
}
void PopulateRatioTapChangerProperties(RatioTapChanger x, ResourceDescription rd)
{
PopulateTapChangerProperties(x, rd);
if (x.NominalStepHasValue)
{
rd.AddProperty(new Int32Property(ModelCode.RATIOTAPCHANGER_NOMINALSTEP, x.NominalStep));
}
if (x.StepCountHasValue)
{
rd.AddProperty(new Int32Property(ModelCode.RATIOTAPCHANGER_STEPCOUNT, x.StepCount));
}
if (x.VoltageStepHasValue)
{
rd.AddProperty(new FloatProperty(ModelCode.RATIOTAPCHANGER_VOLTAGESTEP, x.VoltageStep));
}
if (x.TransformerWindingHasValue)
{
rd.AddProperty(new ReferenceProperty(ModelCode.RATIOTAPCHANGER_TRANSFORMERWINDING, GetGID(x.TransformerWinding.ID)));
}
}
/// <summary>
/// Creates entity for specified global inside the container.
/// </summary>
/// <param name="globalId">Global id of the entity for insert</param>
/// <returns>Created entity (identified object).</returns>
public IdentifiedObject CreateEntity(long globalId)
{
short type = ModelCodeHelper.ExtractTypeFromGlobalId(globalId);
IdentifiedObject io = null;
switch ((DMSType)type)
{
case DMSType.TERMINAL:
io = new Terminal(globalId);
break;
case DMSType.ANALOG:
io = new Analog(globalId);
break;
case DMSType.ASYNCHRONOUSMACHINE:
io = new AsynchronousMachine(globalId);
break;
case DMSType.BREAKER:
io = new Breaker(globalId);
break;
case DMSType.CONNECTIVITYNODE:
io = new ConnectivityNode(globalId);
break;
case DMSType.DISCONNECTOR:
io = new Disconnector(globalId);
break;
case DMSType.DISCRETE:
io = new Discrete(globalId);
break;
case DMSType.POWERTRANSFORMER:
io = new PowerTransformer(globalId);
break;
case DMSType.RATIOTAPCHANGER:
io = new RatioTapChanger(globalId);
break;
case DMSType.SUBSTATION:
io = new Substation(globalId);
break;
case DMSType.TRANSFORMERWINDING:
io = new TransformerWinding(globalId);
break;
default:
string message = String.Format("Failed to create entity because specified type ({0}) is not supported.", type);
CommonTrace.WriteTrace(CommonTrace.TraceError, message);
throw new Exception(message);
}
// Add entity to map
this.AddEntity(io);
return(io);
}
