public void CreateForResultWithProfileAndSectionProbabilities_WithValidResult_ReturnsExpectedFailureMechanismSectionAssembly()
{
// Setup
var random = new Random(21);
double profileProbability = random.NextDouble(0.0001, 0.001);
double sectionProbability = random.NextDouble(0.0, 0.01);
EInterpretationCategory category = random.NextEnumValue(new[]
{
EInterpretationCategory.III,
EInterpretationCategory.II,
EInterpretationCategory.I,
EInterpretationCategory.Zero,
EInterpretationCategory.IMin,
EInterpretationCategory.IIMin,
EInterpretationCategory.IIIMin
});
var result = new ResultWithProfileAndSectionProbabilities(
new Probability(profileProbability), new Probability(sectionProbability));
// Call
FailureMechanismSectionAssemblyResult createdAssemblyResult = FailureMechanismSectionAssemblyResultCreator.Create(result, category);
// Assert
Assert.AreEqual(profileProbability, createdAssemblyResult.ProfileProbability);
Assert.AreEqual(sectionProbability, createdAssemblyResult.SectionProbability);
Assert.AreEqual(result.LengthEffectFactor, createdAssemblyResult.N);
Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(category),
createdAssemblyResult.FailureMechanismSectionAssemblyGroup);
}
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);
}
public void Wbi0A2RefinedProbabilityEstimationNoLengthEffectTest(double probabilitySectionValue, double refinedProbabilitySectionValue,
EInterpretationCategory expectedCategory, double expectedProbabilityValue)
{
var categories = new CategoriesList <InterpretationCategory>(
new[]
{
new InterpretationCategory(EInterpretationCategory.III, (Probability)0, (Probability)0.02),
new InterpretationCategory(EInterpretationCategory.II, (Probability)0.02, (Probability)0.04),
new InterpretationCategory(EInterpretationCategory.I, (Probability)0.04, (Probability)1.0)
});
Probability probabilityInitialMechanismSection = new Probability(probabilitySectionValue);
Probability refinedProbabilitySection = new Probability(refinedProbabilitySectionValue);
var result = translator.TranslateAssessmentResultWbi0A2(
ESectionInitialMechanismProbabilitySpecification.RelevantWithProbabilitySpecification,
probabilityInitialMechanismSection,
ERefinementStatus.Performed,
refinedProbabilitySection,
categories);
Assert.IsNotNull(result);
Assert.AreEqual(expectedCategory, result.InterpretationCategory);
Assert.AreEqual(expectedProbabilityValue, result.ProbabilityProfile);
Assert.AreEqual(expectedProbabilityValue, result.ProbabilitySection);
Assert.AreEqual(1.0, result.NSection);
}
public FailureMechanismSectionAssemblyResultWrapper AssembleFailureMechanismSection(FailureMechanismSectionAssemblyInput input)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
try
{
IAssessmentResultsTranslator kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
if (!IsProbabilityDefined(input))
{
return(AssembleWithUndefinedProbabilities(input, kernel));
}
Probability sectionProbability = kernel.DetermineRepresentativeProbabilityBoi0A1(
input.FurtherAnalysisType != FailureMechanismSectionResultFurtherAnalysisType.NotNecessary,
AssemblyCalculatorInputCreator.CreateProbability(input.InitialSectionProbability),
AssemblyCalculatorInputCreator.CreateProbability(input.RefinedSectionProbability));
EInterpretationCategory interpretationCategory = AssembleInterpretationCategory(input, kernel, sectionProbability);
return(new FailureMechanismSectionAssemblyResultWrapper(
FailureMechanismSectionAssemblyResultCreator.Create(sectionProbability, interpretationCategory),
AssemblyMethod.BOI0A1, AssemblyMethod.BOI0B1));
}
catch (AssemblyException e)
{
throw new FailureMechanismSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateErrorMessage(e.Errors), e);
}
catch (Exception e)
{
throw new FailureMechanismSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), e);
}
}
private void AssertAreEqualInterpretationCategories(EInterpretationCategory expectedCategory, double expectedLowerLimit,
double expectedUpperLimit, InterpretationCategory interpretationCategory)
{
Assert.AreEqual(expectedCategory, interpretationCategory.Category);
Assert.AreEqual(expectedLowerLimit, interpretationCategory.LowerLimit, 1e-15);
Assert.AreEqual(expectedUpperLimit, interpretationCategory.UpperLimit, 1e-15);
}
/// <summary>
/// Read the section on a specific row.
/// </summary>
/// <param name="iRow">Row index of the row in Excel that must be read.</param>
/// <param name="startMeters">Already read start of the section in meters along the assessment section.</param>
/// <param name="endMeters">Already read end of the section in meters along the assessment section.</param>
/// <returns></returns>
public ExpectedFailureMechanismSectionWithLengthEffect ReadSection(int iRow, double startMeters, double endMeters)
{
string sectionName = GetCellValueAsString("B", iRow);
bool isRelevant = GetCellValueAsString("E", iRow) == "Ja";
Probability probabilityInitialMechanismProfile = new Probability(GetCellValueAsDouble("G", iRow));
Probability probabilityInitialMechanismSection = new Probability(GetCellValueAsDouble("H", iRow));
bool refinedAnalysisNecessary = GetCellValueAsString("I", iRow) == "Ja";
Probability refinedProbabilityProfile = new Probability(GetCellValueAsDouble("J", iRow));
Probability refinedProbabilitySection = new Probability(GetCellValueAsDouble("K", iRow));
Probability expectedCombinedProbabilityProfile = new Probability(GetCellValueAsDouble("L", iRow));
Probability expectedCombinedProbabilitySection = new Probability(GetCellValueAsDouble("M", iRow));
EInterpretationCategory expectedInterpretationCategory = GetCellValueAsString("O", iRow).ToInterpretationCategory();
var eRefinementStatus = !refinedAnalysisNecessary ? ERefinementStatus.NotNecessary :
double.IsNaN(refinedProbabilityProfile) ? ERefinementStatus.Necessary : ERefinementStatus.Performed;
return(new ExpectedFailureMechanismSectionWithLengthEffect(sectionName,
startMeters,
endMeters,
isRelevant,
probabilityInitialMechanismProfile,
probabilityInitialMechanismSection,
eRefinementStatus,
refinedProbabilityProfile,
refinedProbabilitySection,
expectedCombinedProbabilityProfile,
expectedCombinedProbabilitySection,
expectedInterpretationCategory));
}
public void ConvertTo_ValidInterpretationCategory_ReturnsExpectedValue(EInterpretationCategory interpretationCategory, FailureMechanismSectionAssemblyGroup expectedAssemblyGroup)
{
// Call
FailureMechanismSectionAssemblyGroup convertedAssemblyGroup = FailureMechanismSectionAssemblyGroupConverter.ConvertTo(interpretationCategory);
// Assert
Assert.AreEqual(expectedAssemblyGroup, convertedAssemblyGroup);
}
public void ConvertFrom_ValidAssemblyGroup_ReturnsExpectedValue(FailureMechanismSectionAssemblyGroup assemblyGroup, EInterpretationCategory expectedInterpretationCategory)
{
// Call
EInterpretationCategory convertedInterpretationCategory = FailureMechanismSectionAssemblyGroupConverter.ConvertFrom(assemblyGroup);
// Assert
Assert.AreEqual(expectedInterpretationCategory, convertedInterpretationCategory);
}
private static FailureMechanismSectionAssemblyResultWrapper AssembleWithUndefinedProbabilities(FailureMechanismSectionAssemblyInput input, IAssessmentResultsTranslator kernel)
{
EInterpretationCategory interpretationCategory = kernel.DetermineInterpretationCategoryWithoutProbabilityEstimationBoi0C1(GetAnalysisStatus(input));
Probability sectionProbability = kernel.TranslateInterpretationCategoryToProbabilityBoi0C2(interpretationCategory);
return(new FailureMechanismSectionAssemblyResultWrapper(
FailureMechanismSectionAssemblyResultCreator.Create(sectionProbability, interpretationCategory),
AssemblyMethod.BOI0C2, AssemblyMethod.BOI0C1));
}
public Probability TranslateInterpretationCategoryToProbabilityBoi0C2(EInterpretationCategory category)
{
ThrowException();
Calculated = true;
CategoryInput = category;
return(SectionProbability);
}
private static EInterpretationCategory DetermineCombinedCategory(EInterpretationCategory combinedCategory,
EInterpretationCategory currentCategory,
bool partialAssembly)
{
if (partialAssembly && (currentCategory == EInterpretationCategory.Dominant || currentCategory == EInterpretationCategory.Gr))
{
return(combinedCategory);
}
return(currentCategory > combinedCategory ? currentCategory : combinedCategory);
}
public ExpectedFailureMechanismSection(string sectionName, double start, double end, bool isRelevant, Probability initialMechanismProbabilitySection, ERefinementStatus refinementStatus, Probability refinedProbabilitySection, Probability expectedCombinedProbabilitySection, EInterpretationCategory expectedInterpretationCategory)
{
SectionName = sectionName;
Start = start;
End = end;
IsRelevant = isRelevant;
InitialMechanismProbabilitySection = initialMechanismProbabilitySection;
RefinementStatus = refinementStatus;
RefinedProbabilitySection = refinedProbabilitySection;
ExpectedCombinedProbabilitySection = expectedCombinedProbabilitySection;
ExpectedInterpretationCategory = expectedInterpretationCategory;
}
/// <summary>
/// Converts a <see cref="ResultWithProfileAndSectionProbabilities"/> combined with a <see cref="EInterpretationCategory"/>
/// into a <see cref="FailureMechanismSectionAssemblyResult"/>.
/// </summary>
/// <param name="result">The <see cref="ResultWithProfileAndSectionProbabilities"/> to convert.</param>
/// <param name="category">The <see cref="EInterpretationCategory"/> to convert.</param>
/// <returns>A <see cref="FailureMechanismSectionAssemblyResult"/> based on <paramref name="result"/>
/// and <paramref name="category"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="result"/> is <c>null</c>.</exception>
/// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="category"/>
/// is an invalid value.</exception>
/// <exception cref="NotSupportedException">Thrown when <paramref name="category"/>
/// is a valid value, but unsupported.</exception>
public static FailureMechanismSectionAssemblyResult Create(ResultWithProfileAndSectionProbabilities result,
EInterpretationCategory category)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
return(new FailureMechanismSectionAssemblyResult(
result.ProbabilityProfile, result.ProbabilitySection, result.LengthEffectFactor,
FailureMechanismSectionAssemblyGroupConverter.ConvertTo(category)));
}
public void ConvertTo_InvalidInterpretationCategory_ThrowsInvalidEnumArgumentException()
{
// Setup
const EInterpretationCategory interpretationCategory = (EInterpretationCategory)99;
// Call
void Call() => FailureMechanismSectionAssemblyGroupConverter.ConvertTo(interpretationCategory);
// Assert
var expectedMessage = $"The value of argument 'interpretationCategory' ({interpretationCategory}) is invalid for Enum type '{nameof(EInterpretationCategory)}'.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(Call, expectedMessage);
}
/// <summary>
/// Constructor for the FailureMechanismSectionAssemblyResult class
/// </summary>
/// <param name="probabilityProfile">Estimated probability of failure for a representative profile in the section</param>
/// <param name="probabilitySection">Estimated probability of failure of the section</param>
/// <param name="category">The resulting interpretation category</param>
/// <exception cref="AssemblyException">In case probabilityProfile or probabilitySection is not within the range 0.0 - 1.0 (or exactly 0.0 or 1.0)</exception>
public FailureMechanismSectionAssemblyResult(Probability probabilityProfile, Probability probabilitySection,
EInterpretationCategory category)
{
switch (category)
{
case EInterpretationCategory.NotRelevant:
if (Math.Abs(probabilityProfile - 0.0) > 1E-8 || Math.Abs(probabilitySection - 0.0) > 1E-8)
{
throw new AssemblyException("FailureMechanismSectionAssemblyResult", EAssemblyErrors.NonMatchingProbabilityValues);
}
break;
case EInterpretationCategory.Dominant:
case EInterpretationCategory.NotDominant:
case EInterpretationCategory.Gr:
if (!double.IsNaN(probabilityProfile) || !double.IsNaN(probabilitySection))
{
throw new AssemblyException("FailureMechanismSectionAssemblyResult", EAssemblyErrors.NonMatchingProbabilityValues);
}
break;
case EInterpretationCategory.III:
case EInterpretationCategory.II:
case EInterpretationCategory.I:
case EInterpretationCategory.Zero:
case EInterpretationCategory.IMin:
case EInterpretationCategory.IIMin:
case EInterpretationCategory.IIIMin:
if (double.IsNaN(probabilitySection.Value) || double.IsNaN(probabilityProfile.Value))
{
throw new AssemblyException("FailureMechanismSectionAssemblyResult", EAssemblyErrors.ValueMayNotBeNaN);
}
if (probabilitySection < probabilityProfile)
{
throw new AssemblyException("FailureMechanismSectionAssemblyResult", EAssemblyErrors.ProfileProbabilityGreaterThanSectionProbability);
}
break;
default:
throw new AssemblyException("FailureMechanismSectionAssemblyResult", EAssemblyErrors.InvalidCategoryValue);
}
InterpretationCategory = category;
ProbabilityProfile = probabilityProfile;
ProbabilitySection = probabilitySection;
NSection = double.IsNaN(probabilitySection.Value) || double.IsNaN(probabilityProfile.Value) || probabilitySection == probabilityProfile
? 1.0
: probabilitySection.Value / probabilityProfile.Value;
}
/// <summary>
/// Converts an <see cref="EInterpretationCategory"/> into a <see cref="FailureMechanismSectionAssemblyGroup"/>.
/// </summary>
/// <param name="interpretationCategory">The <see cref="EInterpretationCategory"/> to convert.</param>
/// <returns>A <see cref="FailureMechanismSectionAssemblyGroup"/> based on <paramref name="interpretationCategory"/>.</returns>
/// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="interpretationCategory"/>
/// is an invalid value.</exception>
/// <exception cref="NotSupportedException">Thrown when <paramref name="interpretationCategory"/>
/// is a valid value, but unsupported.</exception>
public static FailureMechanismSectionAssemblyGroup ConvertTo(EInterpretationCategory interpretationCategory)
{
if (!Enum.IsDefined(typeof(EInterpretationCategory), interpretationCategory))
{
throw new InvalidEnumArgumentException(nameof(interpretationCategory),
(int)interpretationCategory,
typeof(EInterpretationCategory));
}
switch (interpretationCategory)
{
case EInterpretationCategory.NotDominant:
return(FailureMechanismSectionAssemblyGroup.NotDominant);
case EInterpretationCategory.III:
return(FailureMechanismSectionAssemblyGroup.III);
case EInterpretationCategory.II:
return(FailureMechanismSectionAssemblyGroup.II);
case EInterpretationCategory.I:
return(FailureMechanismSectionAssemblyGroup.I);
case EInterpretationCategory.Zero:
return(FailureMechanismSectionAssemblyGroup.Zero);
case EInterpretationCategory.IMin:
return(FailureMechanismSectionAssemblyGroup.IMin);
case EInterpretationCategory.IIMin:
return(FailureMechanismSectionAssemblyGroup.IIMin);
case EInterpretationCategory.IIIMin:
return(FailureMechanismSectionAssemblyGroup.IIIMin);
case EInterpretationCategory.Dominant:
return(FailureMechanismSectionAssemblyGroup.Dominant);
case EInterpretationCategory.NoResult:
return(FailureMechanismSectionAssemblyGroup.NoResult);
case EInterpretationCategory.NotRelevant:
return(FailureMechanismSectionAssemblyGroup.NotRelevant);
default:
throw new NotSupportedException();
}
}
/// <summary>
/// Constructor for the <seealso cref="ExpectedFailureMechanismSectionWithLengthEffect"/>.
/// </summary>
/// <param name="sectionName">Custom of the section.</param>
/// <param name="start">Start of the section in meters along the assessment section.</param>
/// <param name="end">End of the section in meters along the assessment section.</param>
/// <param name="isRelevant">Relevance of the section for a specific failure mechanism.</param>
/// <param name="initialMechanismProbabilityProfile">Probability estimation for the initial mechanism for a single profile.</param>
/// <param name="initialMechanismProbabilitySection">Probability estimation for the initial mechanism for the complete section.</param>
/// <param name="refinementStatus">Refinement status of the probability estimation.</param>
/// <param name="refinedProbabilityProfile">Refined probability estimation for a single profile.</param>
/// <param name="refinedProbabilitySection">Refined probability estimation for the complete section.</param>
/// <param name="expectedCombinedProbabilityProfile">The expected combined probability for a single profile.</param>
/// <param name="expectedCombinedProbabilitySection">The expected combined probability for the complete section.</param>
/// <param name="expectedInterpretationCategory">The expected interpretation category for the section.</param>
public ExpectedFailureMechanismSectionWithLengthEffect(string sectionName,
double start,
double end,
bool isRelevant,
Probability initialMechanismProbabilityProfile,
Probability initialMechanismProbabilitySection,
ERefinementStatus refinementStatus,
Probability refinedProbabilityProfile,
Probability refinedProbabilitySection,
Probability expectedCombinedProbabilityProfile,
Probability expectedCombinedProbabilitySection,
EInterpretationCategory expectedInterpretationCategory)
: base(sectionName, start, end, isRelevant, initialMechanismProbabilitySection, refinementStatus, refinedProbabilitySection, expectedCombinedProbabilitySection, expectedInterpretationCategory)
{
InitialMechanismProbabilityProfile = initialMechanismProbabilityProfile;
RefinedProbabilityProfile = refinedProbabilityProfile;
ExpectedCombinedProbabilityProfile = expectedCombinedProbabilityProfile;
}
/// <summary>
/// Converts a <see cref="Probability"/> combined with a <see cref="EInterpretationCategory"/>
/// into a <see cref="FailureMechanismSectionAssemblyResult"/>.
/// </summary>
/// <param name="sectionProbability">The <see cref="Probability"/> to convert.</param>
/// <param name="category">The <see cref="EInterpretationCategory"/> to convert.</param>
/// <returns>A <see cref="FailureMechanismSectionAssemblyResult"/> based on <paramref name="sectionProbability"/>
/// and <paramref name="category"/>.</returns>
/// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="category"/>
/// is an invalid value.</exception>
/// <exception cref="NotSupportedException">Thrown when <paramref name="category"/>
/// is a valid value, but unsupported.</exception>
public static FailureMechanismSectionAssemblyResult Create(Probability sectionProbability, EInterpretationCategory category)
{
return(new FailureMechanismSectionAssemblyResult(
sectionProbability, sectionProbability, 1.0,
FailureMechanismSectionAssemblyGroupConverter.ConvertTo(category)));
}
/// <summary>
/// Failure mechanism with category
/// </summary>
/// <param name="sectionStart">The start of the section in meters from the beginning of the assessment section.
/// Must be greater than 0</param>
/// <param name="sectionEnd">The end of the section in meters from the beginning of the assessment section.
/// Must be greater than 0 and greater than the start of the section</param>
/// <param name="category">The assessment result of the failure mechanism section</param>
public FailureMechanismSectionWithCategory(double sectionStart, double sectionEnd,
EInterpretationCategory category) :
base(sectionStart, sectionEnd)
{
Category = category;
}
public void ConstructorChecksInputForInconsistentProbabilitiesNotRelevantCategory(double profileProbability, double sectionProbability, EInterpretationCategory interpretationCategory)
{
try
{
var result = new FailureMechanismSectionAssemblyResult((Probability)profileProbability, (Probability)sectionProbability, interpretationCategory);
}
catch (AssemblyException e)
{
Assert.AreEqual(1, e.Errors.Count());
Assert.AreEqual(EAssemblyErrors.NonMatchingProbabilityValues, e.Errors.First().ErrorCode);
Assert.Pass();
}
Assert.Fail("Expected error was not thrown");
}
public void ConstructorChecksInputForNotNaNValuesWithCorrespondingCategories(double profileValue, double sectionValue, EInterpretationCategory category)
{
try
{
var result = new FailureMechanismSectionAssemblyResult((Probability)profileValue, (Probability)sectionValue, category);
}
catch (AssemblyException e)
{
Assert.AreEqual(1, e.Errors.Count());
Assert.AreEqual(EAssemblyErrors.ValueMayNotBeNaN, e.Errors.First().ErrorCode);
Assert.Pass();
}
Assert.Fail("Expected error was not thrown");
}
public void Wbi0A2InitialMechanismPrevailsNoLengthEffectTest(double probabilitySectionValue, EInterpretationCategory expectedCategory, double expectedProbabilityValues)
{
var random = new Random(10);
var categories = new CategoriesList <InterpretationCategory>(
new[]
{
new InterpretationCategory(EInterpretationCategory.III, (Probability)0, (Probability)0.02),
new InterpretationCategory(EInterpretationCategory.II, (Probability)0.02, (Probability)0.04),
new InterpretationCategory(EInterpretationCategory.I, (Probability)0.04, (Probability)1.0)
});
Probability probabilitySection = new Probability(probabilitySectionValue);
var result = translator.TranslateAssessmentResultWbi0A2(
ESectionInitialMechanismProbabilitySpecification.RelevantWithProbabilitySpecification,
probabilitySection,
ERefinementStatus.NotNecessary,
(Probability)random.NextDouble(),
categories);
Assert.IsNotNull(result);
Assert.AreEqual(expectedCategory, result.InterpretationCategory);
Assert.AreEqual(expectedProbabilityValues, result.ProbabilityProfile);
Assert.AreEqual(expectedProbabilityValues, result.ProbabilitySection);
Assert.AreEqual(1.0, result.NSection);
}
private static FailureMechanismSectionAssemblyGroup GetFailureMechanismSectionAssemblyGroup(EInterpretationCategory category)
{
switch (category)
{
case EInterpretationCategory.NotDominant:
return(FailureMechanismSectionAssemblyGroup.NotDominant);
case EInterpretationCategory.III:
return(FailureMechanismSectionAssemblyGroup.III);
case EInterpretationCategory.II:
return(FailureMechanismSectionAssemblyGroup.II);
case EInterpretationCategory.I:
return(FailureMechanismSectionAssemblyGroup.I);
case EInterpretationCategory.Zero:
return(FailureMechanismSectionAssemblyGroup.Zero);
case EInterpretationCategory.IMin:
return(FailureMechanismSectionAssemblyGroup.IMin);
case EInterpretationCategory.IIMin:
return(FailureMechanismSectionAssemblyGroup.IIMin);
case EInterpretationCategory.IIIMin:
return(FailureMechanismSectionAssemblyGroup.IIIMin);
case EInterpretationCategory.Dominant:
return(FailureMechanismSectionAssemblyGroup.Dominant);
case EInterpretationCategory.NoResult:
return(FailureMechanismSectionAssemblyGroup.NoResult);
case EInterpretationCategory.NotRelevant:
return(FailureMechanismSectionAssemblyGroup.NotRelevant);
default:
throw new NotSupportedException();
}
}
public void FailureMechanismSectionAssemblyResultConstructorChecksValidProbabilities(double probabilityProfile, double probabilitySection, EInterpretationCategory interpretationCategory, double expectedNValue)
{
var result = new FailureMechanismSectionAssemblyResult((Probability)probabilityProfile, (Probability)probabilitySection, interpretationCategory);
Assert.AreEqual(expectedNValue, result.NSection);
Assert.AreEqual(probabilityProfile, result.ProbabilityProfile.Value);
Assert.AreEqual(probabilitySection, result.ProbabilitySection.Value);
Assert.AreEqual(interpretationCategory, result.InterpretationCategory);
}
