private FaultSegment CreateFaultSegment(int eventID, Fault fault, SegmentType faultSegmentType)
{
return(new FaultSegment()
{
EventID = eventID,
SegmentTypeID = faultSegmentType.ID,
StartTime = fault.InceptionTime,
EndTime = fault.ClearingTime,
StartSample = fault.StartSample,
EndSample = fault.EndSample
});
}
public void SummarizeFault()
{
using (AdoDataConnection connection = MeterDataSet.CreateDbConnection())
{
TableOperations <Event> eventTable = new TableOperations <Event>(connection);
TableOperations <SegmentType> segmentTypeTable = new TableOperations <SegmentType>(connection);
TableOperations <openXDA.Model.FaultGroup> faultGroupTable = new TableOperations <openXDA.Model.FaultGroup>(connection);
TableOperations <FaultSegment> faultSegmentTable = new TableOperations <FaultSegment>(connection);
TableOperations <FaultSummary> faultSummaryTable = new TableOperations <FaultSummary>(connection);
Event evt = eventTable.GetEvent(MeterDataSet.FileGroup, DataGroup);
SegmentType faultSegmentType = segmentTypeTable.GetOrAdd("Fault");
// Create a fault group row for the whole group of faults
if (FaultGroup.FaultDetectionLogicResult != false || FaultGroup.FaultValidationLogicResult != false)
{
faultGroupTable.AddNewRecord(CreateFaultGroup(evt.ID, FaultGroup));
}
for (int faultIndex = 0; faultIndex < FaultGroup.Faults.Count; faultIndex++)
{
Fault fault = FaultGroup.Faults[faultIndex];
// Create a fault segment for the fault itself
faultSegmentTable.AddNewRecord(CreateFaultSegment(evt.ID, fault, faultSegmentType));
// Create fault segments for each fault type found within the fault
foreach (Fault.Segment segment in fault.Segments)
{
string segmentTypeName = string.Format("{0} Fault", segment.FaultType).Replace("ABC", "3-Phase");
SegmentType segmentType = segmentTypeTable.GetOrAdd(segmentTypeName);
faultSegmentTable.AddNewRecord(CreateFaultSegment(evt.ID, segment, segmentType));
}
// Create the fault summary rows for this fault
foreach (FaultSummary faultSummary in CreateFaultSummaries(evt.ID, faultIndex + 1, fault))
{
faultSummaryTable.AddNewRecord(faultSummary);
}
}
// Generate fault curves for each algorithm used to analyze the fault
TableOperations <FaultCurve> faultCurveTable = new TableOperations <FaultCurve>(connection);
TableOperations <FaultCurveStatistic> faultCurveStatisticTable = new TableOperations <FaultCurveStatistic>(connection);
if (FaultGroup.Faults.Any())
{
for (int i = 0; i < FaultGroup.Faults[0].Curves.Count; i++)
{
FaultCurve faultCurve = CreateFaultCurve(evt.ID, i);
faultCurveTable.AddNewRecord(faultCurve);
faultCurve.ID = connection.ExecuteScalar <int>("SELECT @@IDENTITY");
for (int faultIndex = 0; faultIndex < FaultGroup.Faults.Count; faultIndex++)
{
Fault fault = FaultGroup.Faults[faultIndex];
if (fault.Curves[i].Series.DataPoints.Count == 0)
{
continue;
}
FaultCurveStatistic faultCurveStatistic = new FaultCurveStatistic()
{
FaultCurveID = faultCurve.ID,
FaultNumber = faultIndex + 1,
Maximum = ToDbFloat(fault.Curves[i].Maximum),
Minimum = ToDbFloat(fault.Curves[i].Minimum),
Average = ToDbFloat(fault.Curves[i].Average),
StandardDeviation = ToDbFloat(fault.Curves[i].StandardDeviation)
};
faultCurveStatisticTable.AddNewRecord(faultCurveStatistic);
}
}
}
}
}
private IEnumerable <FaultSummary> CreateFaultSummaries(int eventID, int faultNumber, Fault fault)
{
foreach (Fault.Summary summary in fault.Summaries)
{
// Calculate the duration of the fault in seconds
double durationSeconds = fault.Duration.TotalSeconds;
// Create the fault summary record to be written to the database
yield return(new FaultSummary()
{
EventID = eventID,
Algorithm = summary.DistanceAlgorithm,
FaultNumber = faultNumber,
CalculationCycle = fault.CalculationCycle,
Distance = ToDbFloat(summary.Distance),
CurrentMagnitude = ToDbFloat(fault.CurrentMagnitude),
CurrentLag = ToDbFloat(fault.CurrentLag),
PrefaultCurrent = ToDbFloat(fault.PrefaultCurrent),
PostfaultCurrent = ToDbFloat(fault.PostfaultCurrent),
ReactanceRatio = ToDbFloat(fault.ReactanceRatio),
Inception = fault.InceptionTime,
DurationSeconds = durationSeconds,
DurationCycles = durationSeconds * m_systemFrequency,
FaultType = fault.Type.ToString(),
IsSelectedAlgorithm = summary.IsSelectedAlgorithm,
IsValid = summary.IsValid,
IsSuppressed = fault.IsSuppressed
});
}
}
private List<XElement> GetSegmentElements(Fault fault)
{
return fault.Segments
.Select(GetSegmentElement)
.ToList();
}
private XElement GetSegmentElement(Fault.Segment segment)
{
double duration = (segment.EndTime - segment.StartTime).TotalSeconds;
return new XElement("segment",
new XElement("type", segment.FaultType),
new XElement("start",
new XElement("time", segment.StartTime.ToString(DateTimeFormat)),
new XElement("index", segment.StartSample)),
new XElement("end",
new XElement("time", segment.EndTime.ToString(DateTimeFormat)),
new XElement("index", segment.EndSample)),
new XElement("duration",
new XElement("seconds", duration.ToString(DoubleFormat)),
new XElement("cycles", (duration * m_systemFrequency).ToString(DoubleFormat))));
}
private XElement GetFaultElement(Fault fault)
{
DateTime startTime = fault.InceptionTime;
DateTime endTime = fault.ClearingTime;
int startSample = fault.StartSample;
int endSample = fault.EndSample;
double duration = fault.Duration.TotalSeconds;
foreach (Fault.Summary summary in fault.Summaries)
{
if (!summary.IsSelectedAlgorithm)
continue;
return new XElement("fault",
new XElement("type", fault.Type),
new XElement("distance", summary.Distance),
new XElement("algorithm", summary.DistanceAlgorithm),
new XElement("calculationCycle", fault.CalculationCycle),
new XElement("faultCurrent", fault.CurrentMagnitude),
new XElement("inception",
new XElement("time", startTime.ToString(DateTimeFormat)),
new XElement("sample", startSample)
),
new XElement("clearing",
new XElement("time", endTime.ToString(DateTimeFormat)),
new XElement("sample", endSample)
),
new XElement("duration",
new XElement("seconds", duration.ToString(DoubleFormat)),
new XElement("cycles", (duration * m_systemFrequency).ToString(DoubleFormat))
),
GetSegmentElements(fault)
);
}
return new XElement("fault");
}
private FaultCauseMetrics CreateFaultCauseMetrics(int eventID, int faultNumber, Fault fault)
{
double?ToDBFloat(double num) =>
!double.IsNaN(num) ? (double?)num : null;
return(new FaultCauseMetrics()
{
EventID = eventID,
FaultNumber = faultNumber,
TreeFaultResistance = ToDBFloat(fault.TreeFaultResistance),
LightningMilliseconds = ToDBFloat(fault.LightningMilliseconds),
InceptionDistanceFromPeak = ToDBFloat(fault.InceptionDistanceFromPeak),
PrefaultThirdHarmonic = ToDBFloat(fault.PrefaultThirdHarmonic),
GroundCurrentRatio = ToDBFloat(fault.GroundCurrentRatio),
LowPrefaultCurrentRatio = ToDBFloat(fault.LowPrefaultCurrentRatio)
});
}
