public EMSLoadFlowLoadViewModel(EMSLoadFlowLoadRecord reportRecord, bool tabularViewActive)
{
if (reportRecord == null)
{
DMSLogger.Log(DMSLogger.LogLevel.Error, "Parameter reportRecord passed to EMSLoadFlowLoadViewModel(), should not be null.");
return;
}
this.reportRecord = reportRecord;
recordType = (DMSType)ModelCodeHelper.ExtractTypeFromGlobalId(reportRecord.Lid);
DataGridTreeViewItemInfo = new HierarchicalReportRecord();
DataGridTreeViewItemInfo.Lid = reportRecord.Lid;
DataGridTreeViewItemInfo.Level = reportRecord.Level;
DataGridTreeViewItemInfo.ElementIsShownInTabularView = reportRecord.ElementIsShownInTabularView;
if (String.IsNullOrEmpty(reportRecord.Title))
{
DataGridTreeViewItemInfo.Title = DmsTypeToEntityNameMapper.GetAutomatedName((DMSType)ModelCodeHelper.ExtractTypeFromGlobalId(reportRecord.Lid), reportRecord.Lid);
}
else
{
DataGridTreeViewItemInfo.Title = reportRecord.Title;
}
tabularViewIsActive = tabularViewActive;
if (tabularViewActive && !this.reportRecord.ElementIsShownInTabularView)
{
rowIsNotVisible = true;
}
}
private EMSLoadFlowNodeRecord CreateEMSLoadFlowNodeRecord(HierarchicalFilter hierarchyTree, long id)
{
EMSLoadFlowNodeRecord rec = new EMSLoadFlowNodeRecord();
HierarchicalRecordData recordData;
if (!hierarchicalRecordData.TryGetValue(id, out recordData))
{
DMSLogger.Log(DMSLogger.LogLevel.DebugLog, "[EMSLoadFlow]: Record { 0:X} does not exists in hierarchical record data dictionary.", id);
return(rec);
}
if (recordData.Name != null && !recordData.Name.Equals(string.Empty))
{
rec.Title = string.Format("{0}", recordData.Name);
}
else
{
rec.Title = string.Empty;
}
rec.Lid = id;
rec.Level = (byte)hierarchyTreeFilter.GetNodeByLid(id).Level;
EMSLoadFlowRecordBean data = recordData as EMSLoadFlowRecordBean;
if (data != null && (DMSType)ModelCodeHelper.ExtractTypeFromGlobalId(id) == DMSType.BUSNODE)
{
rec.Voltage = data.Voltage;
rec.VoltageLevel = data.VoltageLevel;
rec.PNode = data.PNode;
}
return(rec);
}
public override void UpdateReference(ModelCode referenceId, long localIdOld, long localIdNew)
{
switch (referenceId)
{
case ModelCode.BASEVOLTAGE_BARS:
if (baseVoltage == localIdOld)
{
baseVoltage = localIdNew;
}
else
{
DMSLogger.Log(DMSLogger.LogLevel.Warning, string.Format("Entity (GID = 0x{0:x16}, LID = 0x{1:x16}) doesn't contain reference 0x{2:x16}. Reference isn't updated.", this.GlobalId, this.LocalId, localIdOld));
}
break;
default:
base.UpdateReference(referenceId, localIdOld, localIdNew);
break;
}
}
private List <EMSLoadFlowNodeRecord> CreateEMSLoadFlowNodeRecords()
{
List <EMSLoadFlowNodeRecord> records = new List <EMSLoadFlowNodeRecord>();
try
{
List <long> gids = GetElementsForSelectedCircuits(selectedRecords, ModelCode.BUSNODERESULTSTA, ModelCode.TARESVAL_PARENTCIRCUIT);
FillEMSLoadFlowNodeProperties(gids);
GetElementsNames(gids);
foreach (long id in selectedRecords)
{
EMSLoadFlowNodeRecord circuitRecord = CreateEMSLoadFlowNodeRecord(hierarchyTreeFilter, id);
records.Add(circuitRecord);
if (hierarchyTreeFilter.GetNodeByLid(id).Children == null)
{
continue;
}
foreach (HierarchicalFilterNode childNode in hierarchyTreeFilter.GetNodeByLid(id).Children)
{
if ((DMSType)ModelCodeHelper.ExtractTypeFromGlobalId(childNode.Lid) != DMSType.BUSNODE)
{
continue;
}
MeasurementValueQuality lfQuality;
if (!lfMeasureQuality.TryGetValue(id, out lfQuality) || CheckIsLFStatusDisabled(lfQuality))
{
continue;
}
records.Add(CreateEMSLoadFlowNodeRecord(hierarchyTreeFilter, childNode.Lid));
}
}
}
catch (Exception)
{
DMSLogger.Log(DMSLogger.LogLevel.Error, "[EMSLoadFlow]: Error occurred while creating EMSLoadFlowNode records.");
throw;
}
return(records);
}
private JobResult CreateResult()
{
try
{
hierarchyTreeFilter = containerHierarchyTree;
if (selectedRecords.Count > 0)
{
GetEMSLFQuality(selectedRecords);
HierarchicalRecordData recordData;
if (!hierarchicalRecordData.TryGetValue(selectedRecords[0], out recordData))
{
return(new EMSLoadFlowReportResult(reportType));
}
EMSLoadFlowRecordBean data = recordData as EMSLoadFlowRecordBean;
if ((DMSType)ModelCodeHelper.ExtractTypeFromGlobalId(selectedRecords[0]) != DMSType.NETWORKINFO)
{
if (CheckIsLFStatusDisabled(data.Quality))
{
return(new EMSLoadFlowReportResult(EMSLoadFlowReportType.NoResults));
}
}
}
else
{
return(new EMSLoadFlowReportResult(reportType));
}
return(CreateReportResults());
}
catch (Exception e)
{
DMSLogger.DumpNonFatalExceptionToLog(DMSLogger.LogLevel.DebugLog, e);
return(new JobError(e.Message));
}
}
private JobResult CreateReportResults()
{
switch (reportType)
{
case EMSLoadFlowReportType.Node:
{
List <EMSLoadFlowNodeRecord> records = CreateEMSLoadFlowNodeRecords();
EMSLoadFlowNodeResults results = new EMSLoadFlowNodeResults {
Records = records
};
return(results);
}
case EMSLoadFlowReportType.Generator:
{
List <EMSLoadFlowGeneratorRecord> records = CreateEMSLoadFlowGeneratorRecords();
EMSLoadFlowGeneratorResults results = new EMSLoadFlowGeneratorResults {
Records = records
};
return(results);
}
case EMSLoadFlowReportType.Load:
{
List <EMSLoadFlowLoadRecord> records = CreateEMSLoadFlowLoadRecords();
EMSLoadFlowLoadResults results = new EMSLoadFlowLoadResults {
Records = records
};
return(results);
}
default:
{
DMSLogger.Log(DMSLogger.LogLevel.Error, "[EMSLoadFlow]: Error while creating results for EMSLoadFlow Report.EMSLoadFlowReportType {0} is unsupported.", reportType);
return(new JobError(string.Format("Error while creating results for EMSLoadFlow Report.EMSLoadFlowReportType {0} is unsupported.", reportType)));
}
}
}
/// <summary>
/// Method is used for preparing input data.
/// </summary>
public void PrepareReportData()
{
long mdc = 0;
int iteratorId;
int count;
if (containerHierarchyTree == null || containerHierarchyTree.AllNodes == null)
{
DMSLogger.Log(DMSLogger.LogLevel.DebugLog, "[reportParam]: PrepareReReportData all nodes in hierarchy tree are null.");
return;
}
HierarchicalFilter hierTree = containerHierarchyTree;
hierarchicalRecordData = new Dictionary <long, HierarchicalRecordData>(hierTree.AllNodes.Count);
if (selectedRecords == null)
{
DMSLogger.Log(DMSLogger.LogLevel.DebugLog, "[EMSLoadFlowEMSLF]: PrepareReportData selected record is null.");
return;
}
foreach (long nodeID in selectedRecords.Where(nodeID => !hierarchicalRecordData.ContainsKey(nodeID)))
{
hierarchicalRecordData.Add(nodeID, new EMSLoadFlowRecordBean());
}
// Get Names for all circuits
List <long> nameSources = new List <long>(hierarchicalRecordData.Keys);
if (nameSources.Count <= 0)
{
DMSLogger.Log(DMSLogger.LogLevel.DebugLog, "[EMSLoadFlow]: PrepareReportData selected records count is not possitive.");
return;
}
try
{
mdc = 0;
iteratorId = GdaQuery.GetDescendentValues(0, new List <ModelCode>(new[] { ModelCode.IDOBJ_NAME }), new List <Association>(), nameSources, new List <Association>(), ref mdc);
count = GdaQuery.IteratorResourcesLeft(iteratorId);
while (count > 0)
{
List <ResourceDescription> rds = GdaQuery.IteratorNext(50000, iteratorId);
for (int i = 0; i < rds.Count; i++)
{
hierarchicalRecordData[rds[i].Id].Name = rds[i].GetProperty(ModelCode.IDOBJ_NAME).AsString();
}
count -= rds.Count;
}
GdaQuery.IteratorClose(iteratorId);
mdc = 0;
iteratorId = GdaQuery.GetDescendentValues(0, new List <ModelCode>(new[] { ModelCode.LFRESVAL_QUALITY }), new List <Association>(), nameSources, new List <Association>(), ref mdc);
count = GdaQuery.IteratorResourcesLeft(iteratorId);
while (count > 0)
{
List <ResourceDescription> rds = GdaQuery.IteratorNext(50000, iteratorId);
for (int i = 0; i < rds.Count; i++)
{
EMSLoadFlowRecordBean temp = (EMSLoadFlowRecordBean)hierarchicalRecordData[rds[i].Id];
temp.Quality = (MeasurementValueQuality)rds[i].GetProperty(ModelCode.LFRESVAL_QUALITY).AsInt();
}
count -= rds.Count;
}
GdaQuery.IteratorClose(iteratorId);
}
catch (Exception ex)
{
DMSLogger.Log(DMSLogger.LogLevel.Error, "[EMSLoadFlow]: Error occurred while preparing EMSLoadFlow report data.");
DMSLogger.DumpNonFatalExceptionToLog(DMSLogger.LogLevel.DebugLog, ex);
}
}
