private void FindAllRestrikes(CycleDataResource cycleDataResource)
{
for (int i = 0; i < cycleDataResource.DataGroups.Count; i++)
{
DataGroup dataGroup = cycleDataResource.DataGroups[i];
VIDataGroup viDataGroup = cycleDataResource.VIDataGroups[i];
DataSeries ia = viDataGroup.IA;
DataSeries ib = viDataGroup.IB;
DataSeries ic = viDataGroup.IC;
IEnumerable <Restrike> iaRestrikes = FindRestrikes(ia)
.Select(index => new Restrike(Phase.AN, index));
IEnumerable <Restrike> ibRestrikes = FindRestrikes(ib)
.Select(index => new Restrike(Phase.BN, index));
IEnumerable <Restrike> icRestrikes = FindRestrikes(ic)
.Select(index => new Restrike(Phase.CN, index));
List <Restrike> allRestrikes = Enumerable.Empty <Restrike>()
.Concat(iaRestrikes)
.Concat(ibRestrikes)
.Concat(icRestrikes)
.ToList();
if (allRestrikes.Any())
{
RestrikeLookup.Add(dataGroup, allRestrikes);
}
}
}
public override void Initialize(MeterDataSet meterDataSet)
{
DataGroupsResource dataGroupsResource = meterDataSet.GetResource <DataGroupsResource>();
CycleDataResource cycleDataResource = meterDataSet.GetResource <CycleDataResource>();
FaultDataResource faultDataResource = meterDataSet.GetResource <FaultDataResource>();
for (int i = 0; i < cycleDataResource.DataGroups.Count; i++)
{
DataGroup dataGroup = cycleDataResource.DataGroups[i];
VIDataGroup viDataGroup = cycleDataResource.VIDataGroups[i];
FaultGroup faultGroup;
if (!faultDataResource.FaultLookup.TryGetValue(dataGroup, out faultGroup))
{
faultGroup = null;
}
m_classifications.Add(dataGroup, Classify(meterDataSet, dataGroup, viDataGroup, faultGroup));
}
foreach (DataGroup dataGroup in dataGroupsResource.DataGroups)
{
if (dataGroup.DataSeries.Count > 0)
{
continue;
}
m_classifications.Add(dataGroup, Classify(meterDataSet, dataGroup));
}
}
public override void Initialize(MeterDataSet meterDataSet)
{
CycleDataResource cycleDataResource = meterDataSet.GetResource <CycleDataResource>();
ILightningDataProvider dataProvider = GetDataProvider();
if (dataProvider == null)
{
return;
}
ConnectionStringParser <SettingAttribute, CategoryAttribute> connectionStringParser = new ConnectionStringParser <SettingAttribute, CategoryAttribute>();
connectionStringParser.ParseConnectionString(meterDataSet.ConnectionString, dataProvider);
foreach (DataGroup dataGroup in cycleDataResource.DataGroups)
{
string lineKey = dataGroup.Asset.AssetKey;
DateTime start = dataGroup.StartTime.AddSeconds(-LightningDataSettings.DataProviderTimeWindow);
DateTime end = dataGroup.EndTime.AddSeconds(LightningDataSettings.DataProviderTimeWindow);
List <ILightningStrike> lightningStrikes = dataProvider
.GetLightningStrikes(lineKey, start, end)
.ToList();
LightningStrikeLookup.Add(dataGroup, lightningStrikes);
}
}
private void FindAllTrips(CycleDataResource cycleDataResource)
{
for (int i = 0; i < cycleDataResource.DataGroups.Count; i++)
{
DataGroup dataGroup = cycleDataResource.DataGroups[i];
VICycleDataGroup viCycleDataGroup = cycleDataResource.VICycleDataGroups[i];
IEnumerable <Trip> iaTrips = FindTrips(viCycleDataGroup.IA?.Peak)
.Select(point => new Trip(Phase.AN, point.Time));
IEnumerable <Trip> ibTrips = FindTrips(viCycleDataGroup.IB?.Peak)
.Select(point => new Trip(Phase.BN, point.Time));
IEnumerable <Trip> icTrips = FindTrips(viCycleDataGroup.IC?.Peak)
.Select(point => new Trip(Phase.CN, point.Time));
List <Trip> allTrips = Enumerable.Empty <Trip>()
.Concat(iaTrips)
.Concat(ibTrips)
.Concat(icTrips)
.ToList();
if (allTrips.Any())
{
TripLookup.Add(dataGroup, allTrips);
}
}
}
public override void Initialize(MeterDataSet meterDataSet)
{
CycleDataResource cycleDataResource = meterDataSet.GetResource <CycleDataResource>();
FindAllTrips(cycleDataResource);
FindAllRestrikes(cycleDataResource);
}
public override void Initialize(MeterDataSet meterDataSet)
{
if (!meterDataSet.FilePath.ToLower().Contains("snapshot"))
{
return;
}
IsSnapshot = true;
CycleDataResource cycleDataResource = meterDataSet.GetResource <CycleDataResource>();
for (int i = 0; i < cycleDataResource.DataGroups.Count; i++)
{
ProcessSnapshots(cycleDataResource.SystemFrequency, cycleDataResource.VIDataGroups[i]);
}
}
public override void Initialize(MeterDataSet meterDataSet)
{
DataGroup dataGroup;
VIDataGroup viDataGroup;
CycleDataResource cycleDataResource = meterDataSet.GetResource <CycleDataResource>();
for (int i = 0; i < cycleDataResource.DataGroups.Count; i++)
{
dataGroup = cycleDataResource.DataGroups[i];
viDataGroup = cycleDataResource.VIDataGroups[i];
IEnumerable <Disturbance> transients = DetectTransients(viDataGroup);
if (transients.Any())
{
Transients.Add(dataGroup, transients.ToList());
}
}
}
public override void Initialize(MeterDataSet meterDataSet)
{
CycleDataResource cycleDataResource = meterDataSet.GetResource <CycleDataResource>();
FaultDataResource faultDataResource = meterDataSet.GetResource(() => new FaultDataResource(m_dbAdapterContainer));
FaultGroup faultGroup;
DataGroup dataGroup;
VICycleDataGroup viCycleDataGroup;
for (int i = 0; i < cycleDataResource.DataGroups.Count; i++)
{
dataGroup = cycleDataResource.DataGroups[i];
viCycleDataGroup = cycleDataResource.VICycleDataGroups[i];
if (!faultDataResource.FaultLookup.TryGetValue(dataGroup, out faultGroup))
{
faultGroup = null;
}
m_classifications.Add(dataGroup, Classify(meterDataSet, dataGroup, viCycleDataGroup, faultGroup));
}
}
public override void Initialize(MeterDataSet meterDataSet)
{
CycleDataResource cycleDataResource = meterDataSet.GetResource <CycleDataResource>();
m_systemEvents = GetSystemEvents(cycleDataResource.DataGroups);
}
public override void Initialize(MeterDataSet meterDataSet)
{
CycleDataResource cycleDataResource = CycleDataResource.GetResource(meterDataSet, m_dbAdapterContainer);
m_systemEvents = GetSystemEvents(cycleDataResource.DataGroups);
}
public override void Initialize(MeterDataSet meterDataSet)
{
DataGroup dataGroup;
VIDataGroup viDataGroup;
VICycleDataGroup viCycleDataGroup;
List <Fault> faults;
List <FaultLocationAlgorithm> faultLocationAlgorithms;
FaultLocationDataSet faultLocationDataSet;
ImpedanceExtractor impedanceExtractor;
FaultCurveGenerator faultCurveGenerator;
CycleDataResource cycleDataResource;
bool?faultDetectionLogicResult;
bool defaultFaultDetectionLogicResult;
bool faultValidationLogicResult;
Stopwatch stopwatch;
stopwatch = new Stopwatch();
cycleDataResource = CycleDataResource.GetResource(meterDataSet, m_dbAdapterContainer);
faultLocationAlgorithms = GetFaultLocationAlgorithms(m_dbAdapterContainer.GetAdapter <FaultLocationInfoDataContext>());
Log.Info(string.Format("Executing fault location analysis on {0} events.", cycleDataResource.DataGroups.Count));
for (int i = 0; i < cycleDataResource.DataGroups.Count; i++)
{
dataGroup = cycleDataResource.DataGroups[i];
viDataGroup = cycleDataResource.VIDataGroups[i];
viCycleDataGroup = cycleDataResource.VICycleDataGroups[i];
// Defined channel checks
Log.Debug("Checking defined channels...");
if (viDataGroup.DefinedNeutralVoltages != 3)
{
Log.Debug($"Not enough neutral voltage channels for fault analysis: {viDataGroup.DefinedNeutralVoltages}.");
continue;
}
if (viDataGroup.DefinedCurrents < 3)
{
Log.Debug($"Not enough current channels for fault analysis: {viDataGroup.DefinedNeutralVoltages}.");
continue;
}
// Engineering reasonableness checks
Log.Debug("Checking for engineering reasonableness...");
try
{
stopwatch.Restart();
if (!IsReasonable(dataGroup, viCycleDataGroup))
{
continue;
}
}
finally
{
Log.Debug(stopwatch.Elapsed);
}
// Break into faults and segments
Log.Debug("Classifying data into faults and segments...");
try
{
stopwatch.Restart();
faults = DetectFaults(viDataGroup, viCycleDataGroup);
if (faults.Count > 0)
{
ClassifyFaults(faults, dataGroup, viCycleDataGroup);
}
}
finally
{
Log.Debug(stopwatch.Elapsed);
}
// Check the fault detection logic and the default fault detection logic
faultDetectionLogicResult = CheckFaultDetectionLogic(meterDataSet, dataGroup);
defaultFaultDetectionLogicResult = CheckDefaultFaultDetectionLogic(faults);
// If the fault detection logic detects a fault and the default
// logic does not agree, treat the whole waveform as a fault
if (faultDetectionLogicResult == true && !defaultFaultDetectionLogicResult)
{
faults.Add(new Fault()
{
StartSample = 0,
EndSample = dataGroup[0].DataPoints.Count - 1
});
ClassifyFaults(faults, dataGroup, viCycleDataGroup);
}
// Create the fault location data set and begin populating
// the properties necessary for calculating fault location
faultLocationDataSet = new FaultLocationDataSet();
faultLocationDataSet.LineDistance = dataGroup.Line.Length;
faultLocationDataSet.PrefaultCycle = FirstCycle(viCycleDataGroup);
// Extract impedances from the database
// and into the fault location data set
impedanceExtractor = new ImpedanceExtractor();
impedanceExtractor.FaultLocationDataSet = faultLocationDataSet;
impedanceExtractor.FaultLocationInfo = m_dbAdapterContainer.GetAdapter <FaultLocationInfoDataContext>();
impedanceExtractor.Meter = meterDataSet.Meter;
impedanceExtractor.Line = dataGroup.Line;
if (impedanceExtractor.TryExtractImpedances())
{
// Generate fault curves for fault analysis
Log.Debug("Generating fault curves...");
stopwatch.Restart();
faultCurveGenerator = new FaultCurveGenerator();
faultCurveGenerator.SamplesPerCycle = Transform.CalculateSamplesPerCycle(viDataGroup.VA, m_systemFrequency);
faultCurveGenerator.CycleDataGroup = viCycleDataGroup;
faultCurveGenerator.Faults = faults;
faultCurveGenerator.FaultLocationDataSet = faultLocationDataSet;
faultCurveGenerator.FaultLocationAlgorithms = faultLocationAlgorithms;
faultCurveGenerator.GenerateFaultCurves();
Log.Debug(stopwatch.Elapsed);
// Gather additional info about each fault
// based on the results of the above analysis
foreach (Fault fault in faults)
{
PopulateFaultInfo(fault, dataGroup, viCycleDataGroup);
}
}
// Create a fault group and add it to the lookup table
faultValidationLogicResult = CheckFaultValidationLogic(faults);
m_faultLookup.Add(dataGroup, new FaultGroup(faults, faultDetectionLogicResult, defaultFaultDetectionLogicResult, faultValidationLogicResult));
}
}
