private void AssertResultsIsAsExpected(double start, double end, EInterpretationCategory category,
FailureMechanismSectionWithCategory section)
{
Assert.AreEqual(start, section.SectionStart, 1e-8);
Assert.AreEqual(end, section.SectionEnd, 1e-8);
Assert.AreEqual(category, section.Category);
}
/// <summary>
/// Creates a collection of <see cref="CombinedFailureMechanismSectionAssembly"/>
/// based on the <paramref name="resultsPerFailureMechanism"/> and <paramref name="combinedSectionResults"/>.
/// </summary>
/// <param name="resultsPerFailureMechanism">The results per failure mechanism.</param>
/// <param name="combinedSectionResults">The combined section results.</param>
/// <returns>A collection of <see cref="CombinedFailureMechanismSectionAssembly"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static IEnumerable <CombinedFailureMechanismSectionAssembly> Create(IEnumerable <FailureMechanismSectionList> resultsPerFailureMechanism,
IEnumerable <FailureMechanismSectionWithCategory> combinedSectionResults)
{
if (resultsPerFailureMechanism == null)
{
throw new ArgumentNullException(nameof(resultsPerFailureMechanism));
}
if (combinedSectionResults == null)
{
throw new ArgumentNullException(nameof(combinedSectionResults));
}
var sectionAssemblies = new List <CombinedFailureMechanismSectionAssembly>();
for (var i = 0; i < combinedSectionResults.Count(); i++)
{
FailureMechanismSectionWithCategory section = combinedSectionResults.ElementAt(i);
sectionAssemblies.Add(new CombinedFailureMechanismSectionAssembly(
CreateSection(section),
resultsPerFailureMechanism
.Select(failureMechanismSectionList => failureMechanismSectionList.Sections.ElementAt(i))
.Cast <FailureMechanismSectionWithCategory>()
.Select(element => FailureMechanismSectionAssemblyGroupConverter.ConvertTo(element.Category))
.ToArray()));
}
return(sectionAssemblies);
}
/// <summary>
/// Asserts whether <paramref name="actual"/> is equal to
/// <paramref name="failureMechanismResults"/> and <paramref name="combinedResults"/>.
/// </summary>
/// <param name="failureMechanismResults">The original <see cref="IEnumerable{T}"/> of <see cref="FailureMechanismSectionList"/>.</param>
/// <param name="combinedResults">The original <see cref="IEnumerable{T}"/> of <see cref="FailureMechanismSectionWithCategory"/>.</param>
/// <param name="actual">The actual collection of <see cref="CombinedFailureMechanismSectionAssembly"/>.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="actual"/> is not equal to
/// <paramref name="failureMechanismResults"/> and <paramref name="combinedResults"/>.</exception>
public static void AssertAssembly(IEnumerable <FailureMechanismSectionList> failureMechanismResults,
IEnumerable <FailureMechanismSectionWithCategory> combinedResults,
IEnumerable <CombinedFailureMechanismSectionAssembly> actual)
{
Assert.AreEqual(combinedResults.Count(), actual.Count());
for (var i = 0; i < combinedResults.Count(); i++)
{
FailureMechanismSectionWithCategory combinedResult = combinedResults.ElementAt(i);
CombinedFailureMechanismSectionAssembly actualCombinedFailureMechanismSectionAssembly = actual.ElementAt(i);
Assert.AreEqual(combinedResult.Start, actualCombinedFailureMechanismSectionAssembly.Section.SectionStart);
Assert.AreEqual(combinedResult.End, actualCombinedFailureMechanismSectionAssembly.Section.SectionEnd);
Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(combinedResult.Category),
actualCombinedFailureMechanismSectionAssembly.Section.FailureMechanismSectionAssemblyGroup);
Assert.AreEqual(failureMechanismResults.Count(), actualCombinedFailureMechanismSectionAssembly.FailureMechanismSectionAssemblyGroupResults.Count());
for (var j = 0; j < failureMechanismResults.Count(); j++)
{
FailureMechanismSectionAssemblyGroup expectedGroup = FailureMechanismSectionAssemblyGroupConverter.ConvertTo(
((FailureMechanismSectionWithCategory)failureMechanismResults.ElementAt(j).Sections.ElementAt(i)).Category);
Assert.AreEqual(expectedGroup, actualCombinedFailureMechanismSectionAssembly.FailureMechanismSectionAssemblyGroupResults.ElementAt(j));
}
}
}
public void ConstructorPassesInput()
{
var sectionStart = 0.10;
var sectionEnd = 5189.015;
var section = new FailureMechanismSectionWithCategory(sectionStart, sectionEnd, EInterpretationCategory.II);
Assert.AreEqual(sectionStart, section.SectionStart);
Assert.AreEqual(sectionEnd, section.SectionEnd);
Assert.AreEqual(EInterpretationCategory.II, section.Category);
}
/// <inheritdoc />
public IEnumerable <FailureMechanismSectionWithCategory> DetermineCombinedResultPerCommonSectionWbi3C1(
IEnumerable <FailureMechanismSectionList> failureMechanismResults, bool partialAssembly)
{
FailureMechanismSectionWithCategory[][] failureMechanismSectionLists = CheckInputWbi3C1(failureMechanismResults);
FailureMechanismSectionWithCategory[] firstSectionsList = failureMechanismSectionLists.First();
var combinedSectionResults = new List <FailureMechanismSectionWithCategory>();
for (var iSection = 0; iSection < firstSectionsList.Length; iSection++)
{
var newCombinedSection = new FailureMechanismSectionWithCategory(firstSectionsList[iSection].SectionStart,
firstSectionsList[iSection].SectionEnd,
EInterpretationCategory.NotRelevant);
foreach (var failureMechanismSectionList in failureMechanismSectionLists)
{
var section = failureMechanismSectionList[iSection];
if (!AreEqualSections(section, newCombinedSection))
{
throw new AssemblyException("FailureMechanismSectionList",
EAssemblyErrors.CommonFailureMechanismSectionsInvalid);
}
newCombinedSection.Category = DetermineCombinedCategory(newCombinedSection.Category,
section.Category, partialAssembly);
if (newCombinedSection.Category == EInterpretationCategory.Gr)
{
break;
}
}
combinedSectionResults.Add(newCombinedSection);
}
return(combinedSectionResults);
}
private static CombinedAssemblyFailureMechanismSection CreateSection(FailureMechanismSectionWithCategory section)
{
return(new CombinedAssemblyFailureMechanismSection(
section.Start, section.End,
FailureMechanismSectionAssemblyGroupConverter.ConvertTo(section.Category)));
}
