public void TranslateFailureMechanismResultsToCommonSectionsWbi3B1ThrowsOnIncorrectListType()
{
var resultSectionsList = new FailureMechanismSectionList(new[]
{
new FailureMechanismSection(0.0, 5.0),
new FailureMechanismSection(5.0, 10.0)
});
var commonSectionsList = new FailureMechanismSectionList(new[]
{
new FailureMechanismSection(0.0, 2.5),
new FailureMechanismSection(2.5, 5.0),
new FailureMechanismSection(5.0, 7.5),
new FailureMechanismSection(7.5, 10.0)
});
try
{
var commonSectionsWithResults =
assembler.TranslateFailureMechanismResultsToCommonSectionsWbi3B1(resultSectionsList,
commonSectionsList);
}
catch (AssemblyException exception)
{
Assert.IsNotNull(exception.Errors);
Assert.AreEqual(1, exception.Errors.Count());
Assert.AreEqual(EAssemblyErrors.SectionsWithoutCategory, exception.Errors.First().ErrorCode);
Assert.Pass();
}
Assert.Fail("Expected exception did not occur");
}
public void TranslateFailureMechanismResultsToCommonSectionsWbi3B1ThrowsOnInvalidSectionLengthsEmpty()
{
var list = new FailureMechanismSectionList(new[]
{
new FailureMechanismSectionWithCategory(0.0, 2.85, EInterpretationCategory.III)
});
var longList = new FailureMechanismSectionList(new FailureMechanismSection[]
{
new FailureMechanismSectionWithCategory(0.0, 10.0, EInterpretationCategory.III)
});
try
{
var commonSectionsWithResults =
assembler.TranslateFailureMechanismResultsToCommonSectionsWbi3B1(longList, list);
}
catch (AssemblyException exception)
{
Assert.IsNotNull(exception.Errors);
Assert.AreEqual(1, exception.Errors.Count());
Assert.AreEqual(EAssemblyErrors.CommonFailureMechanismSectionsInvalid,
exception.Errors.First().ErrorCode);
Assert.Pass();
}
Assert.Fail("Expected exception did not occur");
}
public void FindGreatestCommonDenominatorSectionsWbi3A1ThrowsOnInvalidAssessmentLength(double assessmentLength,
EAssemblyErrors expectedError)
{
var list1 = new FailureMechanismSectionList(new[]
{
new FailureMechanismSection(0.0, 10.0),
new FailureMechanismSection(10.0, 20.0),
new FailureMechanismSection(20.0, 30.0)
});
try
{
var commonSections =
assembler.FindGreatestCommonDenominatorSectionsWbi3A1(new[]
{
list1
},
assessmentLength);
}
catch (AssemblyException exception)
{
Assert.IsNotNull(exception.Errors);
Assert.AreEqual(1, exception.Errors.Count());
Assert.AreEqual(expectedError, exception.Errors.First().ErrorCode);
Assert.Pass();
}
Assert.Fail("Expected exception did not occur");
}
public void DetermineCombinedResultPerCommonSectionThrowsOnInvalidSections1()
{
var sectionsList1 = new FailureMechanismSectionList(new[]
{
new FailureMechanismSectionWithCategory(0.0, 1.0, EInterpretationCategory.III),
new FailureMechanismSectionWithCategory(1.0, 2.0, EInterpretationCategory.III)
});
var sectionsList2 = new FailureMechanismSectionList(new[]
{
new FailureMechanismSectionWithCategory(0.0, 1.0, EInterpretationCategory.III)
});
try
{
var commonSectionsWithResults =
assembler.DetermineCombinedResultPerCommonSectionWbi3C1(new[]
{
sectionsList1,
sectionsList2
}, false);
}
catch (AssemblyException exception)
{
Assert.IsNotNull(exception.Errors);
Assert.AreEqual(1, exception.Errors.Count());
Assert.AreEqual(EAssemblyErrors.CommonFailureMechanismSectionsInvalid,
exception.Errors.First().ErrorCode);
Assert.Pass();
}
Assert.Fail("Expected exception did not occur");
}
/// <inheritdoc />
public AssemblyResult AssembleCommonFailureMechanismSections(
IEnumerable <FailureMechanismSectionList> failureMechanismSectionLists, double assessmentSectionLength,
bool partialAssembly)
{
FailureMechanismSectionList[] failureMechanismSections = failureMechanismSectionLists.ToArray();
// step 1: create greatest common denominator list of the failure mechanism sections in the list.
FailureMechanismSectionList commonSections =
FindGreatestCommonDenominatorSectionsWbi3A1(failureMechanismSections, assessmentSectionLength);
// step 2: determine assessment results per section for each failure mechanism.
var failureMechanismResults = new List <FailureMechanismSectionList>();
foreach (FailureMechanismSectionList failureMechanismSectionList in failureMechanismSections)
{
failureMechanismResults.Add(
TranslateFailureMechanismResultsToCommonSectionsWbi3B1(failureMechanismSectionList,
commonSections));
}
// step 3: determine combined result per common section
var combinedSectionResult =
DetermineCombinedResultPerCommonSectionWbi3C1(failureMechanismResults, partialAssembly);
return(new AssemblyResult(failureMechanismResults, combinedSectionResult));
}
/// <inheritdoc />
public FailureMechanismSectionList TranslateFailureMechanismResultsToCommonSectionsWbi3B1(
FailureMechanismSectionList failureMechanismSectionList,
FailureMechanismSectionList commonSections)
{
CheckResultsToCommonSectionsInput(commonSections, failureMechanismSectionList);
var commonSectionsArray = commonSections.Sections as FailureMechanismSection[] ??
commonSections.Sections.ToArray();
var resultsToCommonSections = new List <FailureMechanismSection>();
foreach (var commonSection in commonSectionsArray)
{
var section = failureMechanismSectionList.GetSectionAtPoint(
commonSection.SectionEnd - (commonSection.SectionEnd - commonSection.SectionStart) / 2.0);
var sectionWithCategory = section as FailureMechanismSectionWithCategory;
if (sectionWithCategory != null)
{
resultsToCommonSections.Add(new FailureMechanismSectionWithCategory(
commonSection.SectionStart,
commonSection.SectionEnd,
sectionWithCategory.Category));
}
}
return(new FailureMechanismSectionList(resultsToCommonSections));
}
public void TranslateFailureMechanismResultsToCommonSectionsWbi3B1WithRoundingTranslatesCorrectly()
{
var resultSectionsList = new FailureMechanismSectionList(new[]
{
new FailureMechanismSectionWithCategory(0.0, 5.0, EInterpretationCategory.III),
new FailureMechanismSectionWithCategory(5.0, 10.0, EInterpretationCategory.I)
});
var commonSectionsList = new FailureMechanismSectionList(new[]
{
new FailureMechanismSection(0.0, 2.5),
new FailureMechanismSection(2.5, 5.0),
new FailureMechanismSection(5.0, 7.5),
new FailureMechanismSection(7.5, 10.000000001)
});
var commonSectionsWithResults =
assembler.TranslateFailureMechanismResultsToCommonSectionsWbi3B1(resultSectionsList,
commonSectionsList);
Assert.IsNotNull(commonSectionsWithResults.Sections);
Assert.AreEqual(4, commonSectionsWithResults.Sections.Count());
Assert.AreEqual(EInterpretationCategory.III,
((FailureMechanismSectionWithCategory)commonSectionsWithResults.Sections.ElementAt(0)).Category);
Assert.AreEqual(EInterpretationCategory.III,
((FailureMechanismSectionWithCategory)commonSectionsWithResults.Sections.ElementAt(1)).Category);
Assert.AreEqual(EInterpretationCategory.I,
((FailureMechanismSectionWithCategory)commonSectionsWithResults.Sections.ElementAt(2)).Category);
Assert.AreEqual(EInterpretationCategory.I,
((FailureMechanismSectionWithCategory)commonSectionsWithResults.Sections.ElementAt(3)).Category);
}
public void FindGreatestCommonDenominatorSectionsWbi3A1IgnoresSmallSectionBoundaryDifferences()
{
var delta = 1e-6;
var assessmentSectionLength = 30.0;
var list1 = new FailureMechanismSectionList(new[]
{
new FailureMechanismSection(0.0, 10.0),
new FailureMechanismSection(10.001, 20.0),
new FailureMechanismSection(20.0, assessmentSectionLength + delta)
});
var list2 = new FailureMechanismSectionList(new[]
{
new FailureMechanismSection(0.0, 5.0),
new FailureMechanismSection(5.0, 25.0),
new FailureMechanismSection(25.0, assessmentSectionLength)
});
var list3 = new FailureMechanismSectionList(new[]
{
new FailureMechanismSection(0.0, 5.001),
new FailureMechanismSection(5.001, 15.0),
new FailureMechanismSection(15.0, 28.0),
new FailureMechanismSection(28.0, assessmentSectionLength)
});
var commonSections =
assembler.FindGreatestCommonDenominatorSectionsWbi3A1(new[]
{
list1,
list2,
list3
},
assessmentSectionLength);
var expectedSectionLimits = new[]
{
0.0,
5.0,
5.001,
10.0,
15.0,
20.0,
25.0,
28.0,
assessmentSectionLength
};
var calculatedCommonSections = commonSections.Sections.ToArray();
Assert.AreEqual(expectedSectionLimits.Length - 1, calculatedCommonSections.Length);
for (int i = 0; i < calculatedCommonSections.Length; i++)
{
Assert.AreEqual(expectedSectionLimits[i], calculatedCommonSections[i].SectionStart);
Assert.AreEqual(expectedSectionLimits[i + 1], calculatedCommonSections[i].SectionEnd);
}
}
/// <summary>
/// Asserts whether <paramref name="actual"/> is equal to <paramref name="original"/>.
/// </summary>
/// <param name="original">The original collection of <see cref="CombinedAssemblyFailureMechanismSection"/>
/// collections.</param>
/// <param name="actual">The actual collection of <see cref="FailureMechanismSectionList"/>.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="actual"/>
/// is not equal to <paramref name="original"/>.</exception>
public static void AssertCombinedFailureMechanismInput(IEnumerable <CombinedAssemblyFailureMechanismSection[]> original, IEnumerable <FailureMechanismSectionList> actual)
{
Assert.AreEqual(original.Count(), actual.Count());
for (var i = 0; i < original.Count(); i++)
{
CombinedAssemblyFailureMechanismSection[] sections = original.ElementAt(i);
FailureMechanismSectionList sectionList = actual.ElementAt(i);
AssertSections(sections, sectionList.Sections);
}
}
private static FailureMechanismSectionList CreateFailureMechanismSectionListForStep3(
List <FailureMechanismSection> failureMechanismSectionResults)
{
var failureMechanismSectionList = new FailureMechanismSectionList(failureMechanismSectionResults.Select(failureMechanismSection =>
new FailureMechanismSectionWithCategory(
failureMechanismSection.SectionStart,
failureMechanismSection.SectionEnd,
failureMechanismSection.Result.InterpretationCategory)));
return(failureMechanismSectionList);
}
public void DetermineCombinedResultPerCommonSectionReturnsCorrectResults()
{
var sectionsList1 = new FailureMechanismSectionList(new[]
{
new FailureMechanismSectionWithCategory(0.0, 0.5, EInterpretationCategory.NotRelevant),
new FailureMechanismSectionWithCategory(0.5, 1.0, EInterpretationCategory.III),
new FailureMechanismSectionWithCategory(1.0, 1.5, EInterpretationCategory.Zero),
new FailureMechanismSectionWithCategory(1.5, 2.0, EInterpretationCategory.Gr),
new FailureMechanismSectionWithCategory(2.0, 2.5, EInterpretationCategory.NotDominant),
new FailureMechanismSectionWithCategory(2.5, 3.0, EInterpretationCategory.III)
});
var sectionsList2 = new FailureMechanismSectionList(new[]
{
new FailureMechanismSectionWithCategory(0.0, 0.5, EInterpretationCategory.NotRelevant),
new FailureMechanismSectionWithCategory(0.5, 1.0, EInterpretationCategory.Zero),
new FailureMechanismSectionWithCategory(1.0, 1.5, EInterpretationCategory.IMin),
new FailureMechanismSectionWithCategory(1.5, 2.0, EInterpretationCategory.IIIMin),
new FailureMechanismSectionWithCategory(2.0, 2.5, EInterpretationCategory.NotRelevant),
new FailureMechanismSectionWithCategory(2.5, 3.0, EInterpretationCategory.II)
});
var sectionsList3 = new FailureMechanismSectionList(new[]
{
new FailureMechanismSectionWithCategory(0.0, 0.5, EInterpretationCategory.NotRelevant),
new FailureMechanismSectionWithCategory(0.5, 1.0, EInterpretationCategory.IIIMin),
new FailureMechanismSectionWithCategory(1.0, 1.5, EInterpretationCategory.Zero),
new FailureMechanismSectionWithCategory(1.5, 2.0, EInterpretationCategory.IIIMin),
new FailureMechanismSectionWithCategory(2.0, 2.5, EInterpretationCategory.NotDominant),
new FailureMechanismSectionWithCategory(2.5, 3.0, EInterpretationCategory.I)
});
var commonSectionsWithResults =
assembler.DetermineCombinedResultPerCommonSectionWbi3C1(new[]
{
sectionsList1,
sectionsList2,
sectionsList3
}, false);
var expectedResults = new List <FailureMechanismSectionWithCategory>
{
new FailureMechanismSectionWithCategory(0.0, 0.5, EInterpretationCategory.NotRelevant),
new FailureMechanismSectionWithCategory(0.5, 1.0, EInterpretationCategory.IIIMin),
new FailureMechanismSectionWithCategory(1.0, 1.5, EInterpretationCategory.IMin),
new FailureMechanismSectionWithCategory(1.5, 2.0, EInterpretationCategory.Gr),
new FailureMechanismSectionWithCategory(2.0, 2.5, EInterpretationCategory.NotDominant),
new FailureMechanismSectionWithCategory(2.5, 3.0, EInterpretationCategory.I)
};
AssertCombinedResultsList(expectedResults, commonSectionsWithResults);
}
public void FindGreatestCommonDenominatorSectionsWbi3A1ReturnsCorrectSections()
{
const double assessmentSectionLength = 30.0;
var list1 = new FailureMechanismSectionList(new[]
{
new FailureMechanismSection(0.0, 10.0),
new FailureMechanismSection(10.0, 20.0),
new FailureMechanismSection(20.0, assessmentSectionLength)
});
var list2 = new FailureMechanismSectionList(new[]
{
new FailureMechanismSection(0.0, 5.0),
new FailureMechanismSection(5.0, 25.0),
new FailureMechanismSection(25.0, assessmentSectionLength)
});
var list3 = new FailureMechanismSectionList(new[]
{
new FailureMechanismSection(0.0, 15.0),
new FailureMechanismSection(15.0, 28.0),
new FailureMechanismSection(28.0, assessmentSectionLength)
});
var commonSections =
assembler.FindGreatestCommonDenominatorSectionsWbi3A1(new[]
{
list1,
list2,
list3
},
assessmentSectionLength);
var expectedSectionLimits = new[]
{
0.0
}
.Concat(list1.Sections.Select(r => r.SectionEnd).ToArray())
.Concat(list2.Sections.Select(r => r.SectionEnd).ToArray())
.Concat(list3.Sections.Select(r => r.SectionEnd).ToArray())
.Distinct().OrderBy(v => v).ToArray();
var calculatedCommonSections = commonSections.Sections.ToArray();
Assert.AreEqual(expectedSectionLimits.Length - 1, calculatedCommonSections.Length);
for (int i = 0; i < calculatedCommonSections.Length; i++)
{
Assert.AreEqual(expectedSectionLimits[i], calculatedCommonSections[i].SectionStart);
Assert.AreEqual(expectedSectionLimits[i + 1], calculatedCommonSections[i].SectionEnd);
}
}
public FailureMechanismSectionList TranslateFailureMechanismResultsToCommonSectionsBoi3B1(
FailureMechanismSectionList failureMechanismSectionList, FailureMechanismSectionList commonSections)
{
ThrowException();
FailureMechanismSectionList = failureMechanismSectionList;
CommonSectionsInput = commonSections;
CalculatedCommonSectionResults = true;
return(FailureMechanismResult ?? (FailureMechanismResult = new FailureMechanismSectionList(new[]
{
new FailureMechanismSectionWithCategory(0, 1, EInterpretationCategory.II)
})));
}
public FailureMechanismSectionList FindGreatestCommonDenominatorSectionsBoi3A1(
IEnumerable <FailureMechanismSectionList> failureMechanismSectionLists, double assessmentSectionLength)
{
ThrowException();
FailureMechanismSectionLists = failureMechanismSectionLists;
AssessmentSectionLength = assessmentSectionLength;
CalculatedCommonSections = true;
return(CommonSections ?? (CommonSections = new FailureMechanismSectionList(new[]
{
new FailureMechanismSectionWithCategory(0, 1, EInterpretationCategory.I)
})));
}
public void GetCategoryOfSectionReturnsCategory()
{
var failureMechanismSectionList = new FailureMechanismSectionList(
new List <FailureMechanismSection>
{
new FailureMechanismSectionWithCategory(0, 10, EInterpretationCategory.I),
new FailureMechanismSectionWithCategory(10, 20, EInterpretationCategory.II)
});
var s = failureMechanismSectionList.GetSectionAtPoint(15.0);
Assert.AreEqual(10, s.SectionStart);
Assert.AreEqual(20, s.SectionEnd);
var sectionWithCategory = s as FailureMechanismSectionWithCategory;
Assert.IsNotNull(sectionWithCategory);
Assert.AreEqual(EInterpretationCategory.II, sectionWithCategory.Category);
}
public void GetCategoryOfSectionOutsideOfRange()
{
try
{
var failureMechanismSectionList = new FailureMechanismSectionList(
new List <FailureMechanismSection>
{
new FailureMechanismSectionWithCategory(0, 10, EInterpretationCategory.I),
new FailureMechanismSectionWithCategory(10, 20, EInterpretationCategory.I)
});
failureMechanismSectionList.GetSectionAtPoint(25.0);
}
catch (AssemblyException e)
{
CheckException(e, EAssemblyErrors.RequestedPointOutOfRange);
}
Assert.Fail("Expected exception was not thrown");
}
private static void TestCombinedSectionsFailureMechanismResults(BenchmarkTestInput input,
BenchmarkTestResult result, string mechanismName, string mechanismId, bool hasLengthEffect)
{
var assembler = new CommonFailureMechanismSectionAssembler();
var combinedSections = new FailureMechanismSectionList(input.ExpectedCombinedSectionResult);
var failureMechanismSectionList = new FailureMechanismSectionList(
input.ExpectedFailureMechanismsResults.First(fm => fm.MechanismId == mechanismId).Sections
.OfType <ExpectedFailureMechanismSection>()
.Select(CreateExpectedFailureMechanismSectionWithResult));
var calculatedSectionResults = assembler.TranslateFailureMechanismResultsToCommonSectionsWbi3B1(
failureMechanismSectionList,
combinedSections);
var calculatedSections = calculatedSectionResults.Sections.OfType <FailureMechanismSectionWithCategory>().ToArray();
var expectedSections = input.ExpectedCombinedSectionResultPerFailureMechanism.First(l => l.FailureMechanismId == mechanismId).Sections
.OfType <FailureMechanismSectionWithCategory>().ToArray();
var failureMechanismResult = GetBenchmarkTestFailureMechanismResult(result, mechanismName, mechanismId, hasLengthEffect);
try
{
Assert.AreEqual(expectedSections.Length, calculatedSections.Length);
for (int i = 0; i < expectedSections.Length; i++)
{
Assert.AreEqual(expectedSections[i].SectionStart, calculatedSections[i].SectionStart, 0.01);
Assert.AreEqual(expectedSections[i].SectionEnd, calculatedSections[i].SectionEnd, 0.01);
Assert.AreEqual(expectedSections[i].Category, calculatedSections[i].Category);
}
failureMechanismResult.AreEqualCombinedResultsCombinedSections = true;
result.MethodResults.Wbi3B1 = BenchmarkTestHelper.GetUpdatedMethodResult(result.MethodResults.Wbi3B1, true);
}
catch (AssertionException e)
{
Console.WriteLine("Error matching combined sections for {0}: {1}", failureMechanismResult.Name, e.Message);
failureMechanismResult.AreEqualCombinedResultsCombinedSections = false;
result.MethodResults.Wbi3B1 = false;
}
}
public void TranslateFailureMechanismResultsToCommonSectionsWbi3B1ThrowsOnNullLists2()
{
var list = new FailureMechanismSectionList(new[]
{
new FailureMechanismSection(0.0, 2.5)
});
try
{
var commonSectionsWithResults =
assembler.TranslateFailureMechanismResultsToCommonSectionsWbi3B1(list, null);
}
catch (AssemblyException exception)
{
Assert.IsNotNull(exception.Errors);
Assert.AreEqual(1, exception.Errors.Count());
Assert.AreEqual(EAssemblyErrors.ValueMayNotBeNull, exception.Errors.First().ErrorCode);
Assert.Pass();
}
Assert.Fail("Expected exception did not occur");
}
public void FindGreatestCommonDenominatorSectionsWbi3A1ThrowsOnInvalidSectionList()
{
var assessmentSectionLength = 30.0;
var list1 = new FailureMechanismSectionList(new[]
{
new FailureMechanismSection(0.0, 10.0),
new FailureMechanismSection(10.001, 20.0),
new FailureMechanismSection(20.0, assessmentSectionLength)
});
var list2 = new FailureMechanismSectionList(new[]
{
new FailureMechanismSection(0.0, 5.0),
new FailureMechanismSection(5.0, 25.0),
new FailureMechanismSection(25.0, assessmentSectionLength - 1.0)
});
try
{
var commonSections =
assembler.FindGreatestCommonDenominatorSectionsWbi3A1(new[]
{
list1,
list2
},
assessmentSectionLength);
}
catch (AssemblyException exception)
{
Assert.IsNotNull(exception.Errors);
Assert.AreEqual(1, exception.Errors.Count());
Assert.AreEqual(EAssemblyErrors.FailureMechanismSectionLengthInvalid, exception.Errors.First().ErrorCode);
Assert.Pass();
}
Assert.Fail("Expected exception did not occur");
}
public CombinedFailureMechanismSectionAssemblyResultWrapper AssembleCombinedFailureMechanismSections(
IEnumerable <IEnumerable <CombinedAssemblyFailureMechanismSection> > input, double assessmentSectionLength)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
try
{
ICommonFailureMechanismSectionAssembler kernel = factory.CreateCombinedFailureMechanismSectionAssemblyKernel();
IEnumerable <FailureMechanismSectionList> failureMechanismSections = FailureMechanismSectionListCreator.Create(input);
FailureMechanismSectionList commonSections = kernel.FindGreatestCommonDenominatorSectionsBoi3A1(
failureMechanismSections, assessmentSectionLength);
FailureMechanismSectionList[] failureMechanismResults = failureMechanismSections.Select(fmsl => kernel.TranslateFailureMechanismResultsToCommonSectionsBoi3B1(
fmsl, commonSections))
.ToArray();
IEnumerable <FailureMechanismSectionWithCategory> combinedSectionResults =
kernel.DetermineCombinedResultPerCommonSectionBoi3C1(failureMechanismResults, false);
return(new CombinedFailureMechanismSectionAssemblyResultWrapper(
CombinedFailureMechanismSectionAssemblyCreator.Create(failureMechanismResults, combinedSectionResults),
AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1));
}
catch (AssemblyException e)
{
throw new AssessmentSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateErrorMessage(e.Errors), e);
}
catch (Exception e)
{
throw new AssessmentSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), e);
}
}
private static void CheckResultsToCommonSectionsInput(FailureMechanismSectionList commonSections,
FailureMechanismSectionList failureMechanismSectionList)
{
if (commonSections == null || failureMechanismSectionList == null)
{
throw new AssemblyException("FailureMechanismSectionList",
EAssemblyErrors.ValueMayNotBeNull);
}
if (Math.Abs(commonSections.Sections.Last().SectionEnd -
failureMechanismSectionList.Sections.Last().SectionEnd) > 1e-8)
{
throw new AssemblyException("FailureMechanismSectionList",
EAssemblyErrors.CommonFailureMechanismSectionsInvalid);
}
var firstResult = failureMechanismSectionList.Sections.First();
if (!(firstResult is FailureMechanismSectionWithCategory))
{
throw new AssemblyException("FailureMechanismSectionList",
EAssemblyErrors.SectionsWithoutCategory);
}
}
