public override void Execute(MeterDataSet meterDataSet)
{
MeterInfoDataContext meterInfo;
DoubleEndedFaultDistanceTableAdapter doubleEndedFaultDistanceAdapter;
List <SystemEventResource.SystemEvent> systemEvents;
MeterData.EventDataTable systemEventTable;
double lineLength;
ComplexNumber nominalImpedance;
List <Mapping> mappings;
int leftEventID;
int rightEventID;
VICycleDataGroup leftCycleDataGroup;
VICycleDataGroup rightCycleDataGroup;
meterInfo = m_dbAdapterContainer.GetAdapter <MeterInfoDataContext>();
doubleEndedFaultDistanceAdapter = m_dbAdapterContainer.GetAdapter <DoubleEndedFaultDistanceTableAdapter>();
// Get a time range for querying each system event that contains events in this meter data set
systemEvents = SystemEventResource.GetResource(meterDataSet, m_dbAdapterContainer).SystemEvents;
foreach (SystemEventResource.SystemEvent systemEvent in systemEvents)
{
// Get the full collection of events from the database that comprise the system event that overlaps this time range
systemEventTable = m_dbAdapterContainer.GetAdapter <EventTableAdapter>().GetSystemEvent(systemEvent.StartTime, systemEvent.EndTime, m_timeTolerance);
foreach (IGrouping <int, MeterData.EventRow> lineGrouping in systemEventTable.GroupBy(evt => evt.LineID))
{
// Make sure this line connects two known meter locations
if (meterInfo.MeterLocationLines.Count(mll => mll.LineID == lineGrouping.Key) != 2)
{
continue;
}
// Determine the length of the line
lineLength = meterInfo.Lines
.Where(line => line.ID == lineGrouping.Key)
.Select(line => (double?)line.Length)
.FirstOrDefault() ?? double.NaN;
if (double.IsNaN(lineLength))
{
continue;
}
// Determine the nominal impedance of the line
nominalImpedance = m_dbAdapterContainer.GetAdapter <FaultLocationInfoDataContext>().LineImpedances
.Where(lineImpedance => lineImpedance.LineID == lineGrouping.Key)
.Select(lineImpedance => new ComplexNumber(lineImpedance.R1, lineImpedance.X1))
.FirstOrDefault();
if (!nominalImpedance.AllAssigned)
{
continue;
}
leftEventID = 0;
rightEventID = 0;
leftCycleDataGroup = null;
rightCycleDataGroup = null;
// Attempt to match faults during this system event that occurred
// on one end of the line with faults that occurred during this
// system even on the other end of the line
mappings = GetMappings(lineGrouping);
foreach (Mapping mapping in mappings)
{
if (mapping.Left.FaultType == FaultType.None || mapping.Right.FaultType == FaultType.None)
{
continue;
}
// Get the cycle data for each of the two mapped faults
if (mapping.Left.Fault.EventID != leftEventID)
{
leftEventID = mapping.Left.Fault.EventID;
leftCycleDataGroup = GetCycleData(leftEventID);
}
if (mapping.Right.Fault.EventID != rightEventID)
{
rightEventID = mapping.Right.Fault.EventID;
rightCycleDataGroup = GetCycleData(rightEventID);
}
if ((object)leftCycleDataGroup == null || (object)rightCycleDataGroup == null)
{
continue;
}
// Make sure there are no other threads calculating double-ended fault distance for this mapping,
// and that double-ended distance has not already been calculated and entered into the database
lock (FaultSummaryIDLock)
{
if (FaultSummaryIDs.Contains(mapping.Left.Fault.ID))
{
continue;
}
if (FaultSummaryIDs.Contains(mapping.Right.Fault.ID))
{
continue;
}
if (doubleEndedFaultDistanceAdapter.GetCountBy(mapping.Left.Fault.ID) > 0)
{
continue;
}
if (doubleEndedFaultDistanceAdapter.GetCountBy(mapping.Right.Fault.ID) > 0)
{
continue;
}
FaultSummaryIDs.Add(mapping.Left.Fault.ID);
FaultSummaryIDs.Add(mapping.Right.Fault.ID);
}
// Initialize the mappings with additional data needed for double-ended fault location
mapping.Left.Initialize(m_dbAdapterContainer, leftCycleDataGroup, m_systemFrequency);
mapping.Right.Initialize(m_dbAdapterContainer, rightCycleDataGroup, m_systemFrequency);
// Execute the double-ended fault location algorithm
ExecuteFaultLocationAlgorithm(lineLength, nominalImpedance, mapping.Left, mapping.Right);
ExecuteFaultLocationAlgorithm(lineLength, nominalImpedance, mapping.Right, mapping.Left);
// Create rows in the DoubleEndedFaultDistance table
CreateFaultDistanceRow(lineLength, mapping.Left, mapping.Right);
CreateFaultDistanceRow(lineLength, mapping.Right, mapping.Left);
// Add these nodes to the collection of processed mapping nodes
m_processedMappingNodes.Add(mapping.Left);
m_processedMappingNodes.Add(mapping.Right);
}
}
}
// Create a row in the FaultCurve table for every event that now has double-ended fault distance curves
foreach (IGrouping <int, MappingNode> grouping in m_processedMappingNodes.GroupBy(node => node.Fault.EventID))
{
CreateFaultCurveRow(grouping);
}
}
public override void Execute(MeterDataSet meterDataSet)
{
// Get a time range for querying each system event that contains events in this meter data set
SystemEventResource systemEventResource = meterDataSet.GetResource <SystemEventResource>();
List <SystemEventResource.SystemEvent> systemEvents = systemEventResource.SystemEvents;
if (systemEvents.Count == 0)
{
return;
}
using (AdoDataConnection connection = meterDataSet.CreateDbConnection())
{
TableOperations <openXDA.Model.Line> lineTable = new TableOperations <openXDA.Model.Line>(connection);
TableOperations <AssetLocation> meterLocationLineTable = new TableOperations <AssetLocation>(connection);
TableOperations <Event> eventTable = new TableOperations <Event>(connection);
TableOperations <DoubleEndedFaultDistance> doubleEndedFaultDistanceTable = new TableOperations <DoubleEndedFaultDistance>(connection);
TableOperations <FaultCurve> faultCurveTable = new TableOperations <FaultCurve>(connection);
List <MappingNode> processedMappingNodes = new List <MappingNode>();
foreach (SystemEventResource.SystemEvent systemEvent in systemEvents)
{
// Get the full collection of events from the database that comprise the system event that overlaps this time range
List <Event> dbSystemEvent = eventTable.GetSystemEvent(systemEvent.StartTime, systemEvent.EndTime, m_timeTolerance);
foreach (IGrouping <int, Event> lineGrouping in dbSystemEvent.GroupBy(evt => evt.AssetID))
{
// Make sure this line connects two known meter locations
int meterLocationCount = meterLocationLineTable.QueryRecordCountWhere("AssetID = {0}", lineGrouping.Key);
if (meterLocationCount != 2)
{
continue;
}
// Determine the length of the line
double lineLength = lineTable
.QueryRecordsWhere("ID = {0}", lineGrouping.Key)
.Select(line =>
{
line.ConnectionFactory = meterDataSet.CreateDbConnection;
return(line.Path[0].Length);
})
.DefaultIfEmpty(double.NaN)
.First();
if (double.IsNaN(lineLength))
{
continue;
}
// Determine the nominal impedance of the line
ComplexNumber nominalImpedance = new ComplexNumber(
lineTable.QueryRecordsWhere("ID = {0}", lineGrouping.Key).Select(line =>
{
line.ConnectionFactory = meterDataSet.CreateDbConnection;
return(line.Path[0].R1);
}).FirstOrDefault(),
lineTable.QueryRecordsWhere("ID = {0}", lineGrouping.Key).Select(line =>
{
line.ConnectionFactory = meterDataSet.CreateDbConnection;
return(line.Path[0].X1);
}).FirstOrDefault());
if (!nominalImpedance.AllAssigned)
{
continue;
}
int leftEventID = 0;
int rightEventID = 0;
VICycleDataGroup leftCycleDataGroup = null;
VICycleDataGroup rightCycleDataGroup = null;
// Attempt to match faults during this system event that occurred
// on one end of the line with faults that occurred during this
// system even on the other end of the line
List <Mapping> mappings = GetMappings(connection, lineGrouping);
foreach (Mapping mapping in mappings)
{
if (mapping.Left.FaultType == FaultType.None || mapping.Right.FaultType == FaultType.None)
{
continue;
}
// Get the cycle data for each of the two mapped faults
if (mapping.Left.Fault.EventID != leftEventID)
{
leftEventID = mapping.Left.Fault.EventID;
leftCycleDataGroup = GetCycleData(connection, leftEventID);
}
if (mapping.Right.Fault.EventID != rightEventID)
{
rightEventID = mapping.Right.Fault.EventID;
rightCycleDataGroup = GetCycleData(connection, rightEventID);
}
if (leftCycleDataGroup == null || rightCycleDataGroup == null)
{
continue;
}
if (leftCycleDataGroup.IA == null || leftCycleDataGroup.IB == null || leftCycleDataGroup.IC == null)
{
continue;
}
if (rightCycleDataGroup.IA == null || rightCycleDataGroup.IB == null || rightCycleDataGroup.IC == null)
{
continue;
}
// Make sure double-ended distance has not already been calculated and entered into the database
RecordRestriction recordRestriction =
new RecordRestriction("LocalFaultSummaryID = {0}", mapping.Left.Fault.ID) |
new RecordRestriction("RemoteFaultSummaryID = {0}", mapping.Left.Fault.ID) |
new RecordRestriction("LocalFaultSummaryID = {0}", mapping.Right.Fault.ID) |
new RecordRestriction("RemoteFaultSummaryID = {0}", mapping.Right.Fault.ID);
if (doubleEndedFaultDistanceTable.QueryRecordCount(recordRestriction) > 0)
{
continue;
}
// Initialize the mappings with additional data needed for double-ended fault location
mapping.Left.Initialize(connection, leftCycleDataGroup, m_systemFrequency);
mapping.Right.Initialize(connection, rightCycleDataGroup, m_systemFrequency);
// Execute the double-ended fault location algorithm
ExecuteFaultLocationAlgorithm(lineLength, nominalImpedance, mapping.Left, mapping.Right);
ExecuteFaultLocationAlgorithm(lineLength, nominalImpedance, mapping.Right, mapping.Left);
try
{
// Create rows in the DoubleEndedFaultDistance table
DoubleEndedFaultDistance leftDistance = CreateDoubleEndedFaultDistance(lineLength, mapping.Left, mapping.Right);
DoubleEndedFaultDistance rightDistance = CreateDoubleEndedFaultDistance(lineLength, mapping.Right, mapping.Left);
doubleEndedFaultDistanceTable.AddNewRecord(leftDistance);
doubleEndedFaultDistanceTable.AddNewRecord(rightDistance);
// Add these nodes to the collection of processed mapping nodes
processedMappingNodes.Add(mapping.Left);
processedMappingNodes.Add(mapping.Right);
}
catch (Exception ex)
{
// Ignore errors regarding unique key constraints
// which can occur as a result of a race condition
bool isUniqueViolation = ExceptionHandler.IsUniqueViolation(ex);
if (!isUniqueViolation)
{
throw;
}
}
}
}
// Create a row in the FaultCurve table for every event that now has double-ended fault distance curves
foreach (IGrouping <int, MappingNode> grouping in processedMappingNodes.GroupBy(node => node.Fault.EventID))
{
FaultCurve faultCurve = CreateFaultCurve(connection, grouping);
faultCurveTable.AddNewRecord(faultCurve);
}
}
}
}