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); }