public void VerifyThatParametersWithoutStateDependenciesWork()
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.dataCollectorParameterTestFixture.iteration, this.dataCollectorParameterTestFixture.cat1.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <NoActualStateRow>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.dataCollectorParameterTestFixture.option).ToList();
var node = dataSource.CreateNodes(
hierarchy,
nestedElementTree).First();
Assert.AreEqual(1, node.GetColumns <DataCollectorStateDependentPerRowDoubleParameter <NoActualStateRow> >().Count());
Assert.IsTrue(node.GetTable().Columns.Contains("ParameterName"));
Assert.IsTrue(node.GetTable().Columns.Contains("ParameterState"));
Assert.IsTrue(node.GetTable().Columns.Contains("ParameterValue"));
Assert.AreEqual(1, node.GetTable().Rows.Count);
Assert.AreEqual("typeOne", node.GetTable().Rows[0]["ParameterName"]);
Assert.AreEqual(DBNull.Value, node.GetTable().Rows[0]["ParameterState"]);
Assert.AreEqual(11D, node.GetTable().Rows[0]["ParameterValue"]);
}
private void VerifyRecursiveStructure(params ElementUsage[] levels)
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.iteration, this.cat1.ShortName)
.AddLevel(this.cat2.ShortName, 3)
.AddLevel(this.cat3.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <Row>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.option).ToList();
// tabular representation built, category hierarchy considered, unneeded subtrees pruned
var rows = dataSource.GetTable(hierarchy, nestedElementTree).Rows;
Assert.AreEqual(2, rows.Count);
if (levels.Length == 2)
{
ValidateRow(rows[1], this.ed1, levels[0], levels[1], null, this.eu7);
}
if (levels.Length == 3)
{
ValidateRow(rows[1], this.ed1, levels[0], levels[1], levels[2], this.eu7);
}
}
public void VerifyThatValuesAreCalculatedCorrectly(string valueArrayValue, double expectedValue1, double expectedValue2)
{
this.dataCollectorParameterTestFixture.ed1.Parameter.First().ValueSet.First().Published = new ValueArray <string>(new [] { valueArrayValue });
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.dataCollectorParameterTestFixture.iteration, this.dataCollectorParameterTestFixture.cat1.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <Row>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.dataCollectorParameterTestFixture.option).ToList();
var node = dataSource.CreateNodes(
hierarchy,
nestedElementTree).First();
var culture = new CultureInfo("en-GB")
{
NumberFormat =
{
NumberDecimalSeparator = ",",
NumberGroupSeparator = "."
}
};
System.Threading.Thread.CurrentThread.CurrentCulture = culture;
Assert.AreEqual(1, node.GetColumns <DataCollectorDoubleParameter <Row> >().Count());
Assert.AreEqual(expectedValue1, (double)node.GetTable().Rows[0]["TypeOne"]);
culture.NumberFormat.NumberDecimalSeparator = ".";
culture.NumberFormat.NumberGroupSeparator = ",";
Assert.AreEqual(expectedValue2, (double)node.GetTable().Rows[0]["TypeOne"]);
}
public void VerifyParameterShortNameInitialization()
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.iteration, this.cat1.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <Row>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.option).ToList();
var node = dataSource.CreateNodes(
hierarchy,
nestedElementTree).First();
var parameter1 = node.GetColumns <TestParameter1>().Single();
Assert.AreEqual("type1", parameter1.FieldName);
var parameter2 = node.GetColumns <TestParameter2>().Single();
Assert.AreEqual("type2", parameter2.FieldName);
var computedParameter = node.GetColumns <ComputedTestParameter>().Single();
Assert.IsNull(computedParameter.FieldName);
}
/// <summary>
/// Assemble the <see cref="IExcelRow{Thing}"/>s
/// </summary>
public void Assemble()
{
var nestedElementExcelRows = new List <NestedElementExcelRow>();
IEnumerable <NestedElement> nestedElements;
if (this.iteration.TopElement == null)
{
nestedElements = Enumerable.Empty <NestedElement>();
}
else
{
var nestedElementTreeGenerator = new NestedElementTreeGenerator();
nestedElements = nestedElementTreeGenerator.Generate(this.option, this.owner, false);
}
// Order the nestedElements by shortname. The Shortname of an NestedElement
// is related to the path of a NestedElement
nestedElements = nestedElements.OrderBy(ne => ne.ShortName);
foreach (var nestedElement in nestedElements)
{
var nestedElementExcelRow = new NestedElementExcelRow(nestedElement, this.owner);
nestedElementExcelRows.Add(nestedElementExcelRow);
}
foreach (var nestedElementExcelRow in nestedElementExcelRows)
{
var deeprows = nestedElementExcelRow.GetContainedRowsDeep();
this.excelRows.AddRange(deeprows);
}
}
public void VerifyThatNestedElementExcelRowNameSpacesAreSetForOption()
{
var parameter = new Parameter(Guid.NewGuid(), this.cache, this.uri)
{
ParameterType = this.length,
Owner = this.systemEngineering,
Scale = this.meter
};
var parameterValueSet = new ParameterValueSet(Guid.NewGuid(), this.cache, this.uri)
{
Manual = new ValueArray <string>(new List <string> {
"A"
}),
Computed = new ValueArray <string>(new List <string> {
"B"
}),
Formula = new ValueArray <string>(new List <string> {
"C"
}),
ValueSwitch = ParameterSwitchKind.MANUAL
};
parameter.ValueSet.Add(parameterValueSet);
this.satellite.Parameter.Add(parameter);
var nestedElementTreeGenerator = new NestedElementTreeGenerator();
var nestedElements = nestedElementTreeGenerator.Generate(this.option, this.systemEngineering);
var elementList = nestedElements.ToList();
var rootnode = elementList.SingleOrDefault(ne => ne.ElementUsage.Count == 0);
Assert.IsNotNull(rootnode);
var rootElementExcelRow = new NestedElementExcelRow(rootnode, this.systemEngineering);
var spacesRoot = new string(' ', 3);
Assert.False(rootElementExcelRow.Name.StartsWith(spacesRoot));
using (var nodeelement = elementList.SingleOrDefault(ne => ne.ElementUsage.Count > 0))
{
Assert.IsNotNull(nodeelement);
var rootNodeParameter = elementList.Single(ne => ne.ShortName == "SAT");
var nestedParameter = rootNodeParameter.NestedParameter.Single();
nodeelement.NestedParameter.Add(nestedParameter);
var nestedElementExcelRow = new NestedElementExcelRow(nodeelement, this.systemEngineering);
var nestedParameterExcelRow = nestedElementExcelRow.GetContainedRows().ToList()[0];
var spacesElement = new string(' ', 3 * Math.Abs(nestedElementExcelRow.Level));
Assert.True(nestedElementExcelRow.Name.StartsWith(spacesElement));
var spacesParameter = new string(' ', 3 * Math.Abs(nestedParameterExcelRow.Level));
Assert.AreEqual(nestedElementExcelRow.Level + 1, nestedParameterExcelRow.Level);
Assert.True(nestedParameterExcelRow.Name.StartsWith(spacesParameter));
}
}
public void VerifyThatNestedParameterExcelRowPropertiesAreSetForParameterSubscription()
{
var parameter = new Parameter(Guid.NewGuid(), this.cache, this.uri)
{
ParameterType = this.length,
Scale = this.meter,
Owner = this.systemEngineering
};
var parameterValueSet = new ParameterValueSet(Guid.NewGuid(), this.cache, this.uri)
{
Manual = new ValueArray <string>(new List <string> {
"A"
}),
Computed = new ValueArray <string>(new List <string> {
"B"
}),
Formula = new ValueArray <string>(new List <string> {
"C"
}),
ValueSwitch = ParameterSwitchKind.MANUAL
};
parameter.ValueSet.Add(parameterValueSet);
this.satellite.Parameter.Add(parameter);
var parameterSubscription = new ParameterSubscription(Guid.NewGuid(), this.cache, this.uri)
{
Owner = this.powerEngineering
};
var parameterSubscriptionValueSet = new ParameterSubscriptionValueSet(Guid.NewGuid(), this.cache, this.uri)
{
Manual = new ValueArray <string>(new List <string> {
"AA"
}),
ValueSwitch = ParameterSwitchKind.MANUAL,
SubscribedValueSet = parameterValueSet
};
parameterSubscription.ValueSet.Add(parameterSubscriptionValueSet);
parameter.ParameterSubscription.Add(parameterSubscription);
var nestedElementTreeGenerator = new NestedElementTreeGenerator();
var nestedElements = nestedElementTreeGenerator.Generate(this.option, this.powerEngineering);
var rootnode = nestedElements.Single(ne => ne.ShortName == "SAT");
var nestedparameter = rootnode.NestedParameter.Single();
var excelRow = new NestedParameterExcelRow(nestedparameter);
Assert.AreEqual("=SAT.l", excelRow.ActualValue);
Assert.AreEqual("SAT\\l\\option1\\", excelRow.ModelCode);
Assert.AreEqual("Length", excelRow.Name);
Assert.AreEqual("PWR [SYS]", excelRow.Owner);
Assert.AreEqual("l [m]", excelRow.ParameterTypeShortName);
Assert.AreEqual("NPS", excelRow.Type);
}
public void VerifyThatMultipleParametersOfSameTypeAreAllowed()
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.dataCollectorParameterTestFixture.iteration, this.dataCollectorParameterTestFixture.cat1.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <CorrectRow>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.dataCollectorParameterTestFixture.option).ToList();
Assert.DoesNotThrow(() => dataSource.CreateNodes(hierarchy, nestedElementTree));
}
public void VerifyThatMultipleParametersOfDifferentTypesAreNotAllowed()
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.dataCollectorParameterTestFixture.iteration, this.dataCollectorParameterTestFixture.cat1.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <ErrorRow>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.dataCollectorParameterTestFixture.option).ToList();
Assert.Throws <InvalidOperationException>(() => dataSource.CreateNodes(hierarchy, nestedElementTree));
}
public void VerifyMultiRootStructureWithParameterCheck()
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.iteration, this.cat2.ShortName)
.AddLevel(this.cat3.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <Row>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.option).ToList();
// tabular representation built, category hierarchy considered, unneeded subtrees pruned, don't return rows that have no parameters set
var rows = dataSource.GetTable(hierarchy, nestedElementTree, true).Rows;
Assert.AreEqual(0, rows.Count);
}
public async Task SetUp()
{
var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "Data", "allvaluesettypes.zip");
this.uri = new Uri(path);
this.credentials = new Credentials("admin", "pass", this.uri);
this.dal = new JsonFileDal();
this.session = new Session(this.dal, this.credentials);
await this.session.Open();
this.nestedElementTreeGenerator = new NestedElementTreeGenerator();
}
public void VerifyThatNodeIdentifiesCategories()
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.iteration, this.cat1.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <Row>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.option).ToList();
var node = dataSource.CreateNodes(
hierarchy,
nestedElementTree).First();
Assert.AreEqual(2, node.GetColumns <DataCollectorCategory <Row> >().Count());
}
private void VerifyRecursiveStructureWithDenySkipCategorie(bool shouldBeFound, params ElementUsage[] levels)
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.iteration, this.cat1.ShortName)
.AddLevel(this.cat2.ShortName, 3)
.AddLevel(this.cat3.ShortName).DenySkipUnknownCategories()
.Build();
var dataSource = new DataCollectorNodesCreator <Row>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.option).ToList();
// tabular representation built, category hierarchy considered, unneeded subtrees pruned
var rows = dataSource.GetTable(hierarchy, nestedElementTree).Rows;
Assert.AreEqual(shouldBeFound ? 2 : 1, rows.Count);
}
public void VerifyThatCorrectColumnNameIsUsed()
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.dataCollectorParameterTestFixture.iteration, this.dataCollectorParameterTestFixture.cat1.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <Row>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.dataCollectorParameterTestFixture.option).ToList();
var node = dataSource.CreateNodes(
hierarchy,
nestedElementTree).First();
Assert.AreEqual(1, node.GetColumns <DataCollectorDoubleParameter <Row> >().Count());
Assert.IsTrue(node.GetTable().Columns.Contains("TypeOne"));
}
private void VerifyStructureWithDenySkipCategories(ElementUsage row2Result)
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.iteration, this.cat1.ShortName)
.AddLevel(this.cat2.ShortName)
.AddLevel(this.cat3.ShortName).DenySkipUnknownCategories()
.Build();
var dataSource = new DataCollectorNodesCreator <Row>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.option).ToList();
// tabular representation built, category hierarchy considered, unneeded subtrees pruned
var rows = dataSource.GetTable(hierarchy, nestedElementTree).Rows;
Assert.AreEqual(1, rows.Count);
ValidateRow(rows[0], this.ed1, this.eu12p1, this.eu2p31);
}
public void VerifyElementUsageCategoryValueInitialization()
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.iteration, this.cat2.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <Row>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.option).ToList();
var node = dataSource.CreateNodes(
hierarchy,
nestedElementTree).First();
var categories = node.GetColumns <DataCollectorCategory <Row> >().ToList();
Assert.AreEqual(false, categories.Single(x => x.ShortName == "cat1").Value);
Assert.AreEqual(true, categories.Single(x => x.ShortName == "cat2").Value);
}
public void VerifyComputedParameterInitialization()
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.iteration, this.cat1.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <Row>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.option).ToList();
var node = dataSource.CreateNodes(
hierarchy,
nestedElementTree).First();
var computedParameter = node.GetColumns <ComputedTestParameter>().Single();
Assert.AreEqual(null, computedParameter.ValueSets);
Assert.AreEqual(null, computedParameter.Owner);
}
public void VerifyMultiRootStructure()
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.iteration, this.cat2.ShortName)
.AddLevel(this.cat3.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <Row>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.option).ToList();
// tabular representation built, category hierarchy considered, unneeded subtrees pruned
var rows = dataSource.GetTable(hierarchy, nestedElementTree).Rows;
Assert.AreEqual(2, rows.Count);
ValidateRow(rows[0], this.eu12p1, this.eu2p31);
ValidateRow(rows[1], this.eu4, this.eu7);
}
public void VerifyCategorySubCategoryInCategoryHierarchy()
{
this.ed1.Category.Add(this.subCat);
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.iteration, this.subCat.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <Row>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.option).ToList();
var node = dataSource.CreateNodes(
hierarchy,
nestedElementTree).First();
Assert.AreEqual(false, node.GetTable().Columns.Contains(this.superCat.ShortName));
Assert.AreEqual(true, node.GetTable().Columns.Contains(this.subCat.ShortName));
}
public void VerifyCategorySubCategoryActualCategory()
{
this.ed1.Category.Add(this.subCat);
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.iteration, this.cat1.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <Row3>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.option).ToList();
var node = dataSource.CreateNodes(
hierarchy,
nestedElementTree).First();
var categoryColumns = node.GetColumns <DataCollectorCategory <Row3> >().ToList();
Assert.AreEqual(this.subCat, categoryColumns.Single(x => x.ShortName == this.superCat.ShortName).ActualCategory);
}
public void VerifyThatNodeIdentifiesCollectParentValueParameters()
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.iteration, this.cat1.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <CollectParentValuesRow>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.option).ToList();
var dataTable = dataSource.GetTable(
hierarchy,
nestedElementTree);
Assert.IsTrue(dataTable.Columns.Contains($"{nameof(CollectParentValuesRow.parameter1)}"));
Assert.IsTrue(dataTable.Columns.Contains($"{nameof(CollectParentValuesRow.parameter2)}"));
Assert.IsTrue(dataTable.Columns.Contains($"{nameof(CollectParentValuesRow.ComputedParameter)}"));
Assert.IsTrue(dataTable.Columns.Contains($"{nameof(CollectParentValuesRow.parameter1)}_{this.cat1.ShortName}"));
Assert.IsTrue(dataTable.Columns.Contains($"{nameof(CollectParentValuesRow.ComputedParameter)}_{this.cat1.ShortName}"));
}
public void VerifyThatNestedParameterExcelRowPropertiesAreSetForParameterWithTextParameterType()
{
var parameter = new Parameter(Guid.NewGuid(), this.cache, this.uri)
{
ParameterType = this.text,
Owner = this.systemEngineering
};
var parameterValueSet = new ParameterValueSet(Guid.NewGuid(), this.cache, this.uri)
{
Manual = new ValueArray <string>(new List <string> {
"A"
}),
Computed = new ValueArray <string>(new List <string> {
"B"
}),
Formula = new ValueArray <string>(new List <string> {
"C"
}),
ValueSwitch = ParameterSwitchKind.MANUAL
};
parameter.ValueSet.Add(parameterValueSet);
this.satellite.Parameter.Add(parameter);
var nestedElementTreeGenerator = new NestedElementTreeGenerator();
var nestedElements = nestedElementTreeGenerator.Generate(this.option, this.systemEngineering);
var rootnode = nestedElements.Single(ne => ne.ShortName == "SAT");
var nestedparameter = rootnode.NestedParameter.Single();
var excelRow = new NestedParameterExcelRow(nestedparameter);
Assert.AreEqual("=SAT.txt", excelRow.ActualValue);
Assert.AreEqual("SAT\\txt\\option1\\", excelRow.ModelCode);
Assert.AreEqual("Text", excelRow.Name);
Assert.AreEqual("SYS", excelRow.Owner);
Assert.AreEqual("txt", excelRow.ParameterTypeShortName);
Assert.AreEqual("NP", excelRow.Type);
}
public void VerifyNestedParameterInitialization()
{
var hierarchy = new CategoryDecompositionHierarchy
.Builder(this.iteration, this.cat2.ShortName)
.Build();
var dataSource = new DataCollectorNodesCreator <Row>();
var nestedElementTree = new NestedElementTreeGenerator().Generate(this.option).ToList();
var node = dataSource.CreateNodes(
hierarchy,
nestedElementTree).First(x => x.ElementBase.Iid == this.eu2.Iid);
var parameter1 = node.GetColumns <TestParameter1>().Single();
Assert.AreEqual("-21", parameter1.ValueSets.FirstOrDefault()?.ActualValue.First());
Assert.AreEqual(this.elementOwner, parameter1.Owner);
var parameter2 = node.GetColumns <TestParameter2>().Single();
Assert.AreEqual("-22", parameter2.ValueSets.FirstOrDefault()?.ActualValue.First());
Assert.AreEqual(this.elementOwner, parameter2.Owner);
}
public void VerifyGetChildrenWorks()
{
var nestedElementTreeGenerator = new NestedElementTreeGenerator();
var nestedElements = nestedElementTreeGenerator.Generate(this.option, this.domain).ToList();
Assert.AreEqual(7, nestedElements.Count);
var children = nestedElements.First(x => x.IsRootElement).GetChildren(nestedElements).ToList();
Assert.AreEqual(1, children.Count);
Assert.AreEqual(this.elementUsage1.Name, children.First().Name);
var children2 = children.First().GetChildren(nestedElements).ToList();
Assert.AreEqual(3, children2.Count);
Assert.AreEqual(this.elementUsage2.Name, children2.First().Name);
var sameInstanceElementUsageNestedElement1 = nestedElements.Single(x => x.ElementUsage.LastOrDefault() == this.elementUsage3_1);
var sameInstanceElementUsageNestedElement2 = nestedElements.Single(x => x.ElementUsage.LastOrDefault() == this.elementUsage3_2);
Assert.AreEqual(1, sameInstanceElementUsageNestedElement1.GetChildren(nestedElements).Count());
Assert.AreEqual(1, sameInstanceElementUsageNestedElement2.GetChildren(nestedElements).Count());
}
public void VerifyThatNestedParameterExcelRowPropertiesAreSetForCompoundParameter()
{
var compoundParameterType = new CompoundParameterType(Guid.NewGuid(), this.cache, this.uri)
{
Name = "coordinate",
ShortName = "coord"
};
var component_1 = new ParameterTypeComponent(Guid.NewGuid(), this.cache, this.uri)
{
ParameterType = this.length,
Scale = this.meter,
ShortName = "x"
};
compoundParameterType.Component.Add(component_1);
var component_2 = new ParameterTypeComponent(Guid.NewGuid(), this.cache, this.uri)
{
ParameterType = this.text,
ShortName = "txt"
};
compoundParameterType.Component.Add(component_2);
var parameter = new Parameter(Guid.NewGuid(), this.cache, this.uri)
{
ParameterType = compoundParameterType,
Owner = this.systemEngineering
};
var parameterValueSet = new ParameterValueSet(Guid.NewGuid(), this.cache, this.uri)
{
Manual = new ValueArray <string>(new List <string> {
"A", "A1"
}),
Computed = new ValueArray <string>(new List <string> {
"B", "B1"
}),
Formula = new ValueArray <string>(new List <string> {
"C", "C1"
}),
ValueSwitch = ParameterSwitchKind.MANUAL
};
parameter.ValueSet.Add(parameterValueSet);
this.satellite.Parameter.Add(parameter);
var nestedElementTreeGenerator = new NestedElementTreeGenerator();
var nestedElements = nestedElementTreeGenerator.Generate(this.option, this.systemEngineering);
var rootnode = nestedElements.Single(ne => ne.ShortName == "SAT");
var nestedparameter_1 = rootnode.NestedParameter.Single(x => x.Component == component_1);
var excelRow_1 = new NestedParameterExcelRow(nestedparameter_1);
Assert.AreEqual("=SAT.coord.x", excelRow_1.ActualValue);
Assert.AreEqual("SAT\\coord.x\\option1\\", excelRow_1.ModelCode);
Assert.AreEqual("coordinate", excelRow_1.Name);
Assert.AreEqual("SYS", excelRow_1.Owner);
Assert.AreEqual("coord.x [m]", excelRow_1.ParameterTypeShortName);
Assert.AreEqual("NP", excelRow_1.Type);
var nestedparameter_2 = rootnode.NestedParameter.Single(x => x.Component == component_2);
var excelRow_2 = new NestedParameterExcelRow(nestedparameter_2);
Assert.AreEqual("=SAT.coord.txt", excelRow_2.ActualValue);
Assert.AreEqual("SAT\\coord.txt\\option1\\", excelRow_2.ModelCode);
Assert.AreEqual("coordinate", excelRow_2.Name);
Assert.AreEqual("SYS", excelRow_2.Owner);
Assert.AreEqual("coord.txt", excelRow_2.ParameterTypeShortName);
Assert.AreEqual("NP", excelRow_2.Type);
}
/// <summary>
/// A must override method that returns the actual data object.
/// A data object could be anything, except a dynamic/ExpandoObject type.
/// </summary>
/// <returns>
/// The data as an object.
/// </returns>
public override object CreateDataObject()
{
// Select an Option from the current Iteration.
// this.SelectOption is a method of the OptionDependentDataCollector class
// After selection the SelectedOption property will be set.
this.SelectOption();
var option = this.SelectedOption;
// Get the tree of NestedElements for the selected Option.
var nestedElementTree = new NestedElementTreeGenerator().Generate(option).ToList();
// Create a CategoryDecompositionHierarchy instance that reads all elements in the ProductTree that
// comply to the Hierarchy of categories defined here:
//
// - Missions
// | Segments
// | Systems [1..5 nesting levels]
// | Subsystems
//
// In case there are multiple nested Equipment levels in the model, the deepest level is selected
// as the source for the parameter values.
// The fieldnames in the result DataSource are set explicitly (second parameter of AddLevel method).
var functionHierarchy = new CategoryDecompositionHierarchy
.Builder(this.Iteration)
.AddLevel("Missions")
.AddLevel("Segments")
.AddLevel("Systems", "SystemName", 5)
.AddLevel("Subsystems", "SubsystemName")
.Build();
// Create a CategoryDecompositionHierarchy instance that reads all elements in the ProductTree that
// comply to the Hierarchy of categories defined here:
//
// - Missions
// | Segments
// | Systems [1..5 nesting levels]
// | Subsystems
//
// In case there are multiple nested Elements levels in the model, the deepest level is selected
// as the source for the parameter values.
// The fieldnames in the result DataSource are set explicitly (second parameter of AddLevel method).
var productHierarchy = new CategoryDecompositionHierarchy
.Builder(this.Iteration)
.AddLevel("Missions")
.AddLevel("Segments")
.AddLevel("Elements", "SystemName", 5)
.AddLevel("Equipment", "SubsystemName")
.Build();
// Build a DataTable for the productHierarchy level (Product level)
// The third parameter in the GetTable method indicates that elements that do not contain
// any wanted parameters will not be shown in the result table.
var resultDataSource =
new DataCollectorNodesCreator <RowRepresentation>()
.GetTable(productHierarchy, nestedElementTree, true);
// Build a DataTable for the functionHierarchy level (Function level)
// The third parameter in the GetTable method indicates that elements that do not contain
// any wanted parameters will not be shown in the result table.
var secondDataSource =
new DataCollectorNodesCreator <RowRepresentation>()
.GetTable(functionHierarchy, nestedElementTree, true);
// Merge the two datatables
resultDataSource.Merge(secondDataSource);
var newView = new DataView(resultDataSource);
newView.RowFilter = "Segments = '" + Variables.SpaceSegmentName + "' And (P_on <> 0 Or P_stby <> 0)";
resultDataSource = newView.ToTable();
resultDataSource.TableName = "MainData";
//Build dynamic tables
var systemModeList = this.Iteration.ActualFiniteStateList.FirstOrDefault(x => x.ShortName == Variables.SystemModesShortName);
if (systemModeList == null)
{
System.Windows.MessageBox.Show("Please set the correct ShortName of the System Mode ActualFiniteStateList in the Variables section of this report's code file.");
}
var stateList = systemModeList.ActualState.ToList().Select(x => x.ShortName);
foreach (var state in stateList)
{
this.DynamicTableCellsCollector.AddValueTableCell("dynamicDutyCycleHeaderTable", state);
this.DynamicTableCellsCollector.AddFieldTableCell("dynamicDutyCycleTable", "P_duty_cyc" + state);
}
return(resultDataSource);
}
/// <summary>
/// A must override method that returns the actual data object.
/// A data object could be anything, except a dynamic/ExpandoObject type.
/// </summary>
/// <returns>
/// The data as an object.
/// </returns>
public override object CreateDataObject()
{
// Select an Option from the current Iteration.
// this.SelectOption is a method of the OptionDependentDataCollector class
// After selection the SelectedOption property will be set.
this.SelectOption();
var option = this.SelectedOption;
// Get the tree of NestedElements for the selected Option.
var nestedElementTree = new NestedElementTreeGenerator().Generate(option).ToList();
// Create a CategoryDecompositionHierarchy instance that reads all elements in the ProductTree that
// comply to the Hierarchy of categories defined here:
//
// - Missions
// | Segments
// | Systems [1..5 nesting levels]
// | Subsystems
//
// In case there are multiple nested Equipment levels in the model, the deepest level is selected
// as the source for the parameter values.
// The fieldnames in the result DataSource are set explicitly (second parameter of AddLevel method).
var functionHierarchy = new CategoryDecompositionHierarchy
.Builder(this.Iteration)
.AddLevel("Missions")
.AddLevel("Segments")
.AddLevel("Systems", "SystemName", 5)
.AddLevel("Subsystems", "SubsystemName")
.Build();
// Create a CategoryDecompositionHierarchy instance that reads all elements in the ProductTree that
// comply to the Hierarchy of categories defined here:
//
// - Missions
// | Segments
// | Systems [1..5 nesting levels]
// | Subsystems
//
// In case there are multiple nested Elements levels in the model, the deepest level is selected
// as the source for the parameter values.
// The fieldnames in the result DataSource are set explicitly (second parameter of AddLevel method).
var productHierarchy = new CategoryDecompositionHierarchy
.Builder(this.Iteration)
.AddLevel("Missions")
.AddLevel("Segments")
.AddLevel("Elements", "SystemName", 5)
.AddLevel("Equipment", "SubsystemName")
.Build();
// Build a DataTable for the productHierarchy level (Product level)
// The third parameter in the GetTable method indicates that elements that do not contain
// any wanted parameters will not be shown in the result table.
var resultDataSource =
new DataCollectorNodesCreator <RowRepresentation>()
.GetTable(productHierarchy, nestedElementTree, true);
// Build a DataTable for the functionHierarchy level (Function level)
// The third parameter in the GetTable method indicates that elements that do not contain
// any wanted parameters will not be shown in the result table.
var secondDataSource =
new DataCollectorNodesCreator <RowRepresentation>()
.GetTable(functionHierarchy, nestedElementTree, true);
// Merge the two datatables
resultDataSource.Merge(secondDataSource);
var newView = new DataView(resultDataSource);
newView.RowFilter = "Segments = '" + Variables.SpaceSegmentName + "' And (P_on <> 0 Or P_stby <> 0)";
resultDataSource = newView.ToTable();
resultDataSource.TableName = "MainData";
//---------------------------------------------------
// Create distinct rows for all ED's and summarize the NumberOfItems
//---------------------------------------------------
var resultColumnArray = resultDataSource.Columns.Cast <DataColumn>()
.Select(x => x.ColumnName)
.Except(new[] { "NumberOfItems", "n_items", "SubsystemName", "SystemName_3", "SystemName_4", "SystemName_5" })
.ToArray();
var distinctResultDataSource = new DataView(resultDataSource).ToTable(true, resultColumnArray);
distinctResultDataSource.Columns.Add("NumberOfItems", typeof(double));
// Summarize the relevant data and write to the merged DataRow
foreach (DataRow distinctRow in distinctResultDataSource.Rows)
{
distinctRow["NumberOfItems"] = 0D;
foreach (DataRow row in resultDataSource.Rows)
{
var write = true;
foreach (var columnName in resultColumnArray)
{
if (!row[columnName].Equals(distinctRow[columnName]))
{
write = false;
break;
}
}
if (write)
{
distinctRow["NumberOfItems"] = ((double)distinctRow["NumberOfItems"]) + ((double)row["NumberOfItems"]);
}
}
}
resultDataSource = distinctResultDataSource;
//---------------------------------------------------
//Build dynamic tables
var systemModeList = this.Iteration.ActualFiniteStateList.FirstOrDefault(x => x.ShortName == Variables.SystemModesShortName);
if (systemModeList == null)
{
System.Windows.MessageBox.Show("Please set the correct ShortName of the System Mode ActualFiniteStateList in the Variables section of this report's code file.");
}
var stateList = systemModeList.ActualState.ToList().Select(x => x.ShortName);
foreach (var state in stateList)
{
var newMeanColumn = new DataColumn("P_mean" + state, typeof(double));
newMeanColumn.DefaultValue = 0D;
resultDataSource.Columns.Add(newMeanColumn);
var newMaxColumn = new DataColumn("P_max" + state, typeof(double));
newMaxColumn.DefaultValue = 0D;
resultDataSource.Columns.Add(newMaxColumn);
this.DynamicTableCellsCollector.AddValueTableCell("dynamicDutyCycleHeaderTable", state);
this.DynamicTableCellsCollector.AddValueTableCell("dynamicP_meanHeaderTable", state);
this.DynamicTableCellsCollector.AddValueTableCell("dynamicP_maxHeaderTable", state);
this.DynamicTableCellsCollector.AddFieldTableCell("dynamicDutyCycleTable", "P_duty_cyc" + state);
this.DynamicTableCellsCollector.AddFieldTableCell("dynamicP_meanTable", "P_mean" + state);
this.DynamicTableCellsCollector.AddFieldTableCell("dynamicP_maxTable", "P_max" + state);
this.DynamicTableCellsCollector.AddExpressionTableCell("dynamicP_meanOwnerTotalsTable", "sumSum([P_mean" + state + "])");
this.DynamicTableCellsCollector.AddExpressionTableCell("dynamicP_meanSystemTotalsTable", "sumSum([P_mean" + state + "])");
this.DynamicTableCellsCollector.AddExpressionTableCell("dynamicP_meanTotalsTable", "sumSum([P_mean" + state + "])");
this.DynamicTableCellsCollector.AddExpressionTableCell("dynamicP_meanTotalsInclMarginTable", "sumSum([P_mean" + state + "] * (1 + ?SystemMargin / 100))");
this.DynamicTableCellsCollector.AddExpressionTableCell("dynamicP_maxOwnerTotalsTable", "sumSum([P_max" + state + "])");
this.DynamicTableCellsCollector.AddExpressionTableCell("dynamicP_maxSystemTotalsTable", "sumSum([P_max" + state + "])");
this.DynamicTableCellsCollector.AddExpressionTableCell("dynamicP_maxTotalsTable", "sumSum([P_max" + state + "])");
this.DynamicTableCellsCollector.AddExpressionTableCell("dynamicP_maxTotalsInclMarginTable", "sumSum([P_max" + state + "] * (1 + (?SystemMargin / 100)))");
foreach (DataRow row in resultDataSource.Rows)
{
var emptyValues = new [] { "", "-" }.ToList();
var P_duty_cyc = emptyValues.Contains(row["P_duty_cyc" + state].ToString()) ? -1D : double.Parse(row["P_duty_cyc" + state].ToString());
var redundancy_type = row["redundancy_type"].ToString();
var redundancy_scheme = row["redundancy_scheme"].ToString();
var redundancy_k = emptyValues.Contains(row["redundancy_k"].ToString()) ? 0D : double.Parse(row["redundancy_k"].ToString());
var redundancy_n = emptyValues.Contains(row["redundancy_n"].ToString()) ? 0D : double.Parse(row["redundancy_n"].ToString());
var P_on = emptyValues.Contains(row["P_on"].ToString()) ? 0D : double.Parse(row["P_on"].ToString());
var P_stby = emptyValues.Contains(row["P_stby"].ToString()) ? 0D : double.Parse(row["P_stby"].ToString());
var NumberOfItems = emptyValues.Contains(row["NumberOfItems"].ToString()) ? 0D : double.Parse(row["NumberOfItems"].ToString());
var maturity_margin = emptyValues.Contains(row["maturity_margin"].ToString()) ? 0D : double.Parse(row["maturity_margin"].ToString());
// --------------------------------------------------------
// Calculate P_mean
// --------------------------------------------------------
var P_mean = 0D;
if (P_duty_cyc != -1)
{
P_mean = double.NaN;
if (redundancy_type == "External")
{
if (redundancy_scheme == "Cold")
{
P_mean = (redundancy_k / redundancy_n) * NumberOfItems * ((P_on * P_duty_cyc) + (P_stby * (1 - P_duty_cyc))) * (1 + maturity_margin / 100);
}
else if (redundancy_scheme == "Standby")
{
P_mean = ((redundancy_k / redundancy_n) * NumberOfItems * ((P_on * P_duty_cyc) + (P_stby * (1 - P_duty_cyc)))) + (((redundancy_n - redundancy_k) / redundancy_n) * NumberOfItems * P_stby) * (1 + maturity_margin / 100);
}
}
if (Double.IsNaN(P_mean))
{
P_mean = NumberOfItems * ((P_on * P_duty_cyc) + (P_stby * (1 - P_duty_cyc))) * (1 + maturity_margin / 100);
}
}
row["P_mean" + state] = P_mean;
// --------------------------------------------------------
// Calculate P_max
// --------------------------------------------------------
var P_max = 0D;
if (P_duty_cyc != -1)
{
P_max = double.NaN;
if (P_duty_cyc == 0)
{
if (redundancy_type == "External")
{
if (redundancy_scheme == "Cold")
{
P_max = (redundancy_k / redundancy_n) * NumberOfItems * P_stby * (1 + maturity_margin / 100);
}
}
if (Double.IsNaN(P_max))
{
P_max = NumberOfItems * P_stby * (1 + maturity_margin / 100);
}
}
else
{
if (redundancy_type == "External")
{
if (redundancy_scheme == "Cold")
{
P_max = (redundancy_k / redundancy_n) * NumberOfItems * P_on * (1 + maturity_margin / 100);
}
else if (redundancy_scheme == "Standby")
{
P_max = ((redundancy_k / redundancy_n) * NumberOfItems * P_on) + (((redundancy_n - redundancy_k) / redundancy_n) * NumberOfItems * P_stby) * (1 + maturity_margin / 100);
}
}
if (Double.IsNaN(P_max))
{
P_max = NumberOfItems * P_on * (1 + maturity_margin / 100);
}
}
}
row["P_max" + state] = P_max;
}
}
return(resultDataSource);
}
public void VerifyThatNestedParameterExcelRowPropertiesAreSetForParameterOverride()
{
var parameter = new Parameter(Guid.NewGuid(), this.cache, this.uri)
{
ParameterType = this.length,
Scale = this.meter,
Owner = this.powerEngineering
};
var parameterValueSet = new ParameterValueSet(Guid.NewGuid(), this.cache, this.uri)
{
Manual = new ValueArray <string>(new List <string> {
"A"
}),
Computed = new ValueArray <string>(new List <string> {
"B"
}),
Formula = new ValueArray <string>(new List <string> {
"C"
}),
ValueSwitch = ParameterSwitchKind.MANUAL,
};
parameter.ValueSet.Add(parameterValueSet);
this.battery.Parameter.Add(parameter);
var parameterOverride = new ParameterOverride(Guid.NewGuid(), this.cache, this.uri);
parameterOverride.Owner = this.powerEngineering;
var paameterOverrideValueSet = new ParameterOverrideValueSet(Guid.NewGuid(), this.cache, this.uri)
{
Manual = new ValueArray <string>(new List <string> {
"A"
}),
Computed = new ValueArray <string>(new List <string> {
"B"
}),
Formula = new ValueArray <string>(new List <string> {
"C"
}),
ValueSwitch = ParameterSwitchKind.MANUAL,
ParameterValueSet = parameterValueSet
};
parameterOverride.ValueSet.Add(paameterOverrideValueSet);
parameterOverride.Parameter = parameter;
this.batteryUsage.ParameterOverride.Add(parameterOverride);
var nestedElementTreeGenerator = new NestedElementTreeGenerator();
var nestedElements = nestedElementTreeGenerator.Generate(this.option, this.powerEngineering);
foreach (var nestedElement in nestedElements)
{
Console.WriteLine(nestedElement.ShortName);
}
var batteryNode = nestedElements.Single(ne => ne.ShortName == "SAT.batt");
var nestedparameter = batteryNode.NestedParameter.Single();
var excelRow = new NestedParameterExcelRow(nestedparameter);
Assert.AreEqual("=BAT.l", excelRow.ActualValue);
Assert.AreEqual("SAT.batt\\l\\option1\\", excelRow.ModelCode);
Assert.AreEqual("Length", excelRow.Name);
Assert.AreEqual("PWR", excelRow.Owner);
Assert.AreEqual("l [m]", excelRow.ParameterTypeShortName);
Assert.AreEqual("NP", excelRow.Type);
}
/// <summary>
/// Finds and returns <see cref="NestedParameter"/>s by their <see cref="NestedParameter.Path"/>s in the <see cref="Option"/>'s <see cref="NestedParameter"/>
/// </summary>
/// <param name="path">The path to search for in all this <see cref="Option"/>'s <see cref="NestedParameter.Path"/> properties.</param>
/// <returns>An <see cref="IEnumerable{NestedParameter}"/> containing all found <see cref="NestedParameter"/>s. </returns>
public IEnumerable <NestedParameter> GetNestedParameterValueSetsByPath(string path)
{
var allParameters = new NestedElementTreeGenerator().GetNestedParameters(this);
return(this.GetNestedParameterValueSetsByPath(path, allParameters).ToList());
}
/// <summary>
/// A must override method that returns the actual data object.
/// A data object could be anything, except a dynamic/ExpandoObject type.
/// </summary>
/// <returns>
/// The data as an object.
/// </returns>
public override object CreateDataObject()
{
// Select an Option from the current Iteration.
// this.SelectOption is a method of the OptionDependentDataCollector class
// After selection the SelectedOption property will be set.
this.SelectOption();
var option = this.SelectedOption;
// Get the tree of NestedElements for the selected Option.
var nestedElementTree = new NestedElementTreeGenerator().Generate(option).ToList();
// Create a CategoryDecompositionHierarchy instance that reads all elements in the ProductTree that
// comply to the Hierarchy of categories defined here.
// The Category hierarchy of elements in the product tree should be like:
//
// Missions
// | Segments
// | Elements [1..5 nesting levels]
// | Equipment
//
// In case there are multiple nested Equipment levels in the model, the deepest level is selected
// as the source for the parameter values.
var productHierarchy = new CategoryDecompositionHierarchy
.Builder(this.Iteration)
.AddLevel("Missions")
.AddLevel("Segments")
.AddLevel("Elements", 5)
.AddLevel("Equipment")
.Build();
// Build a DataTable for the productHierarchy level (Product level)
var resultDataSource =
new DataCollectorNodesCreator<MainDataRow>()
.GetTable(productHierarchy, nestedElementTree);
//---------------------------------------------------
// Create distinct rows for all elements and summarize the NoOfItems
//---------------------------------------------------
var resultColumnArray = resultDataSource.Columns.Cast<DataColumn>()
.Select(x => x.ColumnName)
.Except(new [] {"NumberOfItems", "n_items", "Equipment"})
.ToArray();
var distinctResultDataSource = new DataView(resultDataSource).ToTable(true, resultColumnArray);
distinctResultDataSource.Columns.Add("NumberOfItems", typeof(double));
distinctResultDataSource.Columns.Add("Equipment", typeof(string));
foreach (DataRow distinctRow in distinctResultDataSource.Rows)
{
distinctRow["NumberOfItems"] = 0D;
var writeElementDefinitionName = false;
foreach (DataRow row in resultDataSource.Rows)
{
var write = true;
foreach (var columnName in resultColumnArray)
{
if (!row[columnName].Equals(distinctRow[columnName]))
{
write = false;
break;
}
}
if (write)
{
distinctRow["NumberOfItems"] = ((double)distinctRow["NumberOfItems"]) + ((double)row["NumberOfItems"]);
if (writeElementDefinitionName)
{
distinctRow["Equipment"] = (string)row["ElementDefinitionName"];
}
else
{
distinctRow["Equipment"] = (string)row["Equipment"];
}
writeElementDefinitionName = true;
}
}
}
resultDataSource = distinctResultDataSource;
//---------------------------------------------------
// Create a DataView that contains all Distinct values in the resultDataSource's Segments column,
var segmentsTable = new DataView(resultDataSource).ToTable(true, "Segments");
// Create the DataSet that will be returned by this CreateDataObject method.
var dataSet = new DataSet();
// Find the data rows that contain a Segments name that is equal to the SpaceSegmentName set in the top of this file
// and add that table to the DataSet.
foreach (DataRow dataRow in segmentsTable.Rows)
{
var segment = dataRow["Segments"].ToString();
if ((segment) == Variables.SpaceSegmentName)
{
var newView = new DataView(resultDataSource);
newView.RowFilter = "Segments = '" + segment + "'";
var newTable = newView.ToTable();
newTable.TableName = "MainData";
dataSet.Tables.Add(newTable);
}
}
return dataSet;
}
