public RVC118.Model.RVC118Data._OutputsMeta FillOutputMeta()
{
TypeMapping outputMeta = MappingCompiler.GetTypeMapping(OutputMapping);
Reset();
return(FillRVC118Data_OutputsMeta(outputMeta));
}
public openLSE.Model.LSE.EstimatorOutput FillOutputData()
{
TypeMapping outputMapping = MappingCompiler.GetTypeMapping(OutputMapping);
Reset();
return(FillLSEEstimatorOutput(outputMapping));
}
protected AlignmentCoordinator.SampleWindow GetSampleWindow(ArrayMapping arrayMapping, out MeasurementKey[] keys)
{
IEnumerable <FieldMapping> signalMappings = MappingCompiler.TraverseSignalMappings(arrayMapping);
keys = signalMappings.SelectMany(mapping => SignalLookup.GetMeasurementKeys(mapping.Expression)).ToArray();
return(CreateSampleWindow(arrayMapping));
}
public RVC118.Model.RVC118Data.Outputs FillOutputData()
{
TypeMapping outputMapping = MappingCompiler.GetTypeMapping(OutputMapping);
Reset();
return(FillRVC118DataOutputs(outputMapping));
}
/// <summary>
/// Creates a new <see cref="MapperBase"/>.
/// </summary>
/// <param name="framework">Container object for framework elements.</param>
/// <param name="unmapper">Object that handles conversion of data from data structures into measurements.</param>
/// <param name="inputMapping">Input mapping name.</param>
protected MapperBase(Framework framework, string inputMapping)
{
m_framework = framework;
m_minimumRetentionLock = new object();
m_minimumRetentionTimes = new Dictionary <MeasurementKey, TimeSpan>();
m_mappingRetentionTimes = new Dictionary <MeasurementKey, TimeSpan>();
m_retentionTimes = new Dictionary <MeasurementKey, TimeSpan>();
UDTCompiler udtCompiler = new UDTCompiler();
m_mappingCompiler = new MappingCompiler(udtCompiler);
string udtPath = Path.Combine("Model", "UserDefinedTypes.ecaidl");
string mappingPath = Path.Combine("Model", "UserDefinedMappings.ecamap");
udtCompiler.Compile(udtPath);
m_mappingCompiler.Compile(mappingPath);
m_keys = new List <MeasurementKey[]>();
m_timeWindowKeys = new List <MeasurementKey[]>();
m_mappingCollections = new List <TypeMapping[]>();
m_inputMapping = inputMapping;
if ((object)m_mappingCompiler.GetTypeMapping(inputMapping) == null)
{
throw new InvalidOperationException($"Unable to find input mapping \"{inputMapping}\" in mapping file ({mappingPath})!");
}
}
protected int GetUDTArrayTypeMappingCount(ArrayMapping arrayMapping)
{
// UDT[] where each array element is the same mapping, but represent different times
if (arrayMapping.WindowSize != 0.0M)
{
MeasurementKey[] keys;
AlignmentCoordinator.SampleWindow sampleWindow = GetSampleWindow(arrayMapping, out keys);
m_lastKeyIndex = m_keyIndex;
m_cachedMapping = GetTypeMapping(arrayMapping);
m_cachedFrames = AlignmentCoordinator.GetFrames(keys, CurrentFrameTime, sampleWindow);
return(m_cachedFrames.Count);
}
// UDT[] where each array element is the same time (relative to now), but represent different mappings
if (arrayMapping.RelativeTime != 0.0M)
{
MeasurementKey[] keys;
AlignmentCoordinator.SampleWindow sampleWindow = GetSampleWindow(arrayMapping, out keys);
CurrentFrame = AlignmentCoordinator.GetFrame(keys, CurrentFrameTime, sampleWindow);
m_cachedMappings = MappingCompiler.EnumerateTypeMappings(arrayMapping.Expression).ToArray();
return(m_cachedMappings.Length);
}
// UDT[] where each array element is the same time, but represent different mappings
m_cachedMappings = MappingCompiler.EnumerateTypeMappings(arrayMapping.Expression).ToArray();
return(m_cachedMappings.Length);
}
public openLSE.Model.LSE._EstimatorOutputMeta FillOutputMeta()
{
TypeMapping outputMeta = MappingCompiler.GetTypeMapping(OutputMapping);
Reset();
return(FillLSE_EstimatorOutputMeta(outputMeta));
}
private void BuildTimeWindowKeys(TypeMapping inputMapping)
{
foreach (FieldMapping fieldMapping in inputMapping.FieldMappings)
{
ArrayMapping arrayMapping = fieldMapping as ArrayMapping;
DataType fieldType = fieldMapping.Field.Type;
DataType underlyingType = (fieldType as ArrayType)?.UnderlyingType;
Action addTimeWindowKeys = () =>
{
IEnumerable <FieldMapping> signalMappings = MappingCompiler.TraverseSignalMappings(arrayMapping);
MeasurementKey[] keys = signalMappings.SelectMany(mapping => SignalLookup.GetMeasurementKeys(mapping.Expression)).ToArray();
m_timeWindowKeys.Add(keys);
};
// ReSharper disable once PossibleNullReferenceException
if (fieldType.IsArray && underlyingType.IsUserDefined && (arrayMapping.WindowSize != 0.0M || arrayMapping.RelativeTime != 0.0M))
{
addTimeWindowKeys();
}
else if (fieldType.IsArray && underlyingType.IsUserDefined)
{
m_mappingCompiler.EnumerateTypeMappings(fieldMapping.Expression).ToList().ForEach(BuildTimeWindowKeys);
}
else if (fieldType.IsUserDefined)
{
BuildTimeWindowKeys(m_mappingCompiler.GetTypeMapping(fieldMapping.Expression));
}
}
}
public Beta_Application_CTPT_LineZ.Model.GPA._Line_dataMeta FillOutputMeta()
{
TypeMapping outputMeta = MappingCompiler.GetTypeMapping(OutputMapping);
Reset();
return(FillGPA_Line_dataMeta(outputMeta));
}
public UnmapperBase(Framework framework, MappingCompiler mappingCompiler, string outputMapping)
{
m_framework = framework;
m_mappingCompiler = mappingCompiler;
m_outputMapping = outputMapping;
m_keys = new List <MeasurementKey[]>();
}
public SEL421_PowerCalculator.Model.SEL421.Outputs FillOutputData()
{
TypeMapping outputMapping = MappingCompiler.GetTypeMapping(OutputMapping);
Reset();
return(FillSEL421Outputs(outputMapping));
}
public string UpdateMapping(string udtFileContents, string mappingFileContents, string identifier, string newident)
{
StringReader udtsr = new StringReader(udtFileContents);
StringReader mappingsr = new StringReader(mappingFileContents);
UDTCompiler udtCompiler = new UDTCompiler();
udtCompiler.Compile(udtsr);
MappingCompiler mappingCompiler = new MappingCompiler(udtCompiler);
mappingCompiler.Compile(mappingsr);
foreach (TypeMapping tm in mappingCompiler.DefinedMappings)
{
if (tm.Identifier == identifier)
{
tm.Identifier = newident;
}
}
MappingWriter mappingWriter = new MappingWriter();
mappingWriter.Mappings.AddRange(mappingCompiler.DefinedMappings);
StringBuilder sb = new StringBuilder();
mappingWriter.Write(new StringWriter(sb));
return(sb.ToString());
}
public SEL421_PowerCalculator.Model.SEL421._OutputsMeta FillOutputMeta()
{
TypeMapping outputMeta = MappingCompiler.GetTypeMapping(OutputMapping);
Reset();
return(FillSEL421_OutputsMeta(outputMeta));
}
protected IDictionary <MeasurementKey, IMeasurement> GetRelativeFrame(FieldMapping fieldMapping)
{
IEnumerable <FieldMapping> signalMappings = MappingCompiler.TraverseSignalMappings(fieldMapping);
MeasurementKey[] keys = signalMappings.SelectMany(mapping => SignalLookup.GetMeasurementKeys(mapping.Expression)).ToArray();
AlignmentCoordinator.SampleWindow sampleWindow = CreateSampleWindow(fieldMapping);
return(AlignmentCoordinator.GetFrame(keys, CurrentFrameTime, sampleWindow));
}
public IEnumerable <IMeasurement> Unmap(RVC118.Model.RVC118Data.Outputs outputData, RVC118.Model.RVC118Data._OutputsMeta outputMeta)
{
List <IMeasurement> measurements = new List <IMeasurement>();
TypeMapping outputMapping = MappingCompiler.GetTypeMapping(OutputMapping);
CollectFromRVC118DataOutputs(measurements, outputMapping, outputData, outputMeta);
return(measurements);
}
public IEnumerable <IMeasurement> Unmap(openLSE.Model.LSE.EstimatorOutput outputData, openLSE.Model.LSE._EstimatorOutputMeta outputMeta)
{
List <IMeasurement> measurements = new List <IMeasurement>();
TypeMapping outputMapping = MappingCompiler.GetTypeMapping(OutputMapping);
CollectFromLSEEstimatorOutput(measurements, outputMapping, outputData, outputMeta);
return(measurements);
}
public IEnumerable <IMeasurement> Unmap(Beta_Application_CTPT_LineZ.Model.GPA.Line_data outputData, Beta_Application_CTPT_LineZ.Model.GPA._Line_dataMeta outputMeta)
{
List <IMeasurement> measurements = new List <IMeasurement>();
TypeMapping outputMapping = MappingCompiler.GetTypeMapping(OutputMapping);
CollectFromGPALine_data(measurements, outputMapping, outputData, outputMeta);
return(measurements);
}
public Unmapper(Framework framework, MappingCompiler mappingCompiler)
: base(framework, mappingCompiler, SystemSettings.OutputMapping)
{
Algorithm.Output.CreateNew = () => new Algorithm.Output()
{
OutputData = FillOutputData(),
OutputMeta = FillOutputMeta()
};
}
public IEnumerable <IMeasurement> Unmap(SEL421_PowerCalculator.Model.SEL421.Outputs outputData, SEL421_PowerCalculator.Model.SEL421._OutputsMeta outputMeta)
{
List <IMeasurement> measurements = new List <IMeasurement>();
TypeMapping outputMapping = MappingCompiler.GetTypeMapping(OutputMapping);
CollectFromSEL421Outputs(measurements, outputMapping, outputData, outputMeta);
return(measurements);
}
public void FixOutputMapping(string filePath, string contents)
{
MappingCompiler mappingCompiler = CreateOutputMappingCompiler();
if (mappingCompiler.BatchErrors.Any(ex => ex.FilePath == filePath))
{
File.WriteAllText(filePath, contents);
}
}
public IEnumerable <IMeasurement> Unmap(TVA_LSETestHarness.Model.ECA.PhasorCollection outputData, TVA_LSETestHarness.Model.ECA._PhasorCollectionMeta outputMeta)
{
List <IMeasurement> measurements = new List <IMeasurement>();
TypeMapping outputMapping = MappingCompiler.GetTypeMapping(OutputMapping);
Reset();
CollectFromECAPhasorCollection(measurements, outputMapping, outputData, outputMeta);
return(measurements);
}
public IEnumerable <IMeasurement> Unmap(NullOutput outputData, _NullOutputMeta outputMeta)
{
List <IMeasurement> measurements = new List <IMeasurement>();
TypeMapping outputMapping = MappingCompiler.GetTypeMapping(OutputMapping);
Reset();
CollectFromLSENullOutput(measurements, outputMapping, outputData, outputMeta);
return(measurements);
}
protected DotNetProjectGeneratorBase(string projectName, MappingCompiler compiler, string fileSuffix, string subFolder, string arrayMarker = "[]")
{
m_projectName = projectName;
m_compiler = compiler;
m_settings = new ProjectSettings();
m_fileSuffix = fileSuffix;
m_subFolder = subFolder;
m_arrayMarker = arrayMarker;
// ReSharper disable once VirtualMemberCallInConstructor
m_primitiveTypes = GetPrimitiveTypeMap();
}
public override void Map(IDictionary <MeasurementKey, IMeasurement> measurements)
{
m_index = 0;
SignalLookup.UpdateMeasurementLookup(measurements);
TypeMapping inputMapping = MappingCompiler.GetTypeMapping(InputMapping);
Real_Time_Calculator.Model.VT.VI_pair input = CreateVTVI_pair(inputMapping);
Real_Time_Calculator.Model.VT.Line_parameters output = Algorithm.Execute(input);
// TODO: Later versions will publish output to the openECA server
}
public override void Map(IDictionary <MeasurementKey, IMeasurement> measurements)
{
SignalLookup.UpdateMeasurementLookup(measurements);
TypeMapping inputMapping = MappingCompiler.GetTypeMapping(InputMapping);
TVA_LSETestHarness.Model.ECA.PhasorCollection inputData = CreateECAPhasorCollection(inputMapping);
KeyIndex = 0;
TVA_LSETestHarness.Model.ECA._PhasorCollectionMeta inputMeta = CreateECA_PhasorCollectionMeta(inputMapping);
Algorithm.Output algorithmOutput = Algorithm.Execute(inputData, inputMeta);
Subscriber.SendMeasurements(m_unmapper.Unmap(algorithmOutput.OutputData, algorithmOutput.OutputMeta));
}
public override void Map(IDictionary <MeasurementKey, IMeasurement> measurements)
{
SignalLookup.UpdateMeasurementLookup(measurements);
TypeMapping inputMapping = MappingCompiler.GetTypeMapping(InputMapping);
LVC.Model.test.Input inputData = CreatetestInput(inputMapping);
KeyIndex = 0;
LVC.Model.test._InputMeta inputMeta = Createtest_InputMeta(inputMapping);
Algorithm.Output algorithmOutput = Algorithm.Execute(inputData, inputMeta);
// TODO: Later versions will publish output to the openECA server
}
public override void Map(IDictionary <MeasurementKey, IMeasurement> measurements)
{
SignalLookup.UpdateMeasurementLookup(measurements);
TypeMapping inputMapping = MappingCompiler.GetTypeMapping(InputMapping);
Reset();
Beta_Application_CTPT_LineZ.Model.GPA.Measurement_set inputData = CreateGPAMeasurement_set(inputMapping);
Reset();
Beta_Application_CTPT_LineZ.Model.GPA._Measurement_setMeta inputMeta = CreateGPA_Measurement_setMeta(inputMapping);
Algorithm.Output algorithmOutput = Algorithm.Execute(inputData, inputMeta);
Subscriber.SendMeasurements(m_unmapper.Unmap(algorithmOutput.OutputData, algorithmOutput.OutputMeta));
}
public override void Map(IDictionary <MeasurementKey, IMeasurement> measurements)
{
SignalLookup.UpdateMeasurementLookup(measurements);
TypeMapping inputMapping = MappingCompiler.GetTypeMapping(InputMapping);
Reset();
LVC118.Model.LVC118Data.Inputs inputData = CreateLVC118DataInputs(inputMapping);
Reset();
LVC118.Model.LVC118Data._InputsMeta inputMeta = CreateLVC118Data_InputsMeta(inputMapping);
Algorithm.Output algorithmOutput = Algorithm.Execute(inputData, inputMeta);
Subscriber.SendMeasurements(m_unmapper.Unmap(algorithmOutput.OutputData, algorithmOutput.OutputMeta));
}
public override void Map(IDictionary <MeasurementKey, IMeasurement> measurements)
{
SignalLookup.UpdateMeasurementLookup(measurements);
TypeMapping inputMapping = MappingCompiler.GetTypeMapping(InputMapping);
LseTestHarness.Model.ECA.PhasorCollection inputData = CreateECAPhasorCollection(inputMapping);
KeyIndex = 0;
LseTestHarness.Model.ECA._PhasorCollectionMeta inputMeta = CreateECA_PhasorCollectionMeta(inputMapping);
MainWindow.WriteMessage("Executing..");
Algorithm.Output algorithmOutput = Algorithm.Execute(inputData, inputMeta);
// TODO: Later versions will publish output to the openECA server
}
public void UpdateUDT(UserDefinedType udt, string oldCat, string oldIdent)
{
UDTCompiler udtCompiler = CreateUDTCompiler();
MappingCompiler mappingCompiler = new MappingCompiler(udtCompiler);
mappingCompiler.Scan(s_udmDirectory);
foreach (UserDefinedType dt in udtCompiler.DefinedTypes.OfType <UserDefinedType>())
{
if (dt.Category == oldCat && dt.Identifier == oldIdent)
{
dt.Fields.Clear();
foreach (UDTField dataType in udt.Fields)
{
dt.Fields.Add(dataType);
}
dt.Category = udt.Category;
dt.Identifier = udt.Identifier;
}
}
string categoryPath = Path.Combine(s_udtDirectory, oldCat);
string typePath = Path.Combine(categoryPath, oldIdent + ".ecaidl");
lock (s_udtLock)
{
File.Delete(typePath);
if (!Directory.EnumerateFileSystemEntries(categoryPath).Any())
{
Directory.Delete(categoryPath);
}
}
UDTWriter udtWriter = new UDTWriter();
udtWriter.Types.AddRange(udtCompiler.DefinedTypes.OfType <UserDefinedType>());
lock (s_udtLock)
udtWriter.WriteFiles(s_udtDirectory);
MappingWriter mappingWriter = new MappingWriter();
mappingWriter.Mappings.AddRange(mappingCompiler.DefinedMappings);
lock (s_udmLock)
mappingWriter.WriteFiles(s_udmDirectory);
}
