private void ReadFailureMechanismSections(ExpectedFailureMechanismResult expectedFailureMechanismResult)
        {
            var sections      = new List <IExpectedFailureMechanismSection>();
            var startRow      = GetRowId("Vaknaam") + 1;
            var sectionReader = sectionReaderFactory.CreateReader(expectedFailureMechanismResult.HasLengthEffect);

            var iRow = startRow;

            while (iRow <= MaxRow)
            {
                var startMeters = GetCellValueAsDouble("C", iRow) * 1000.0;
                var endMeters   = GetCellValueAsDouble("D", iRow) * 1000.0;

                if (double.IsNaN(startMeters) || double.IsNaN(endMeters))
                {
                    break;
                }

                sections.Add(sectionReader.ReadSection(iRow, startMeters, endMeters));

                iRow++;
            }

            expectedFailureMechanismResult.Sections = sections;
        }
        public void ReaderReadsFailureMechanismWithoutLengthEffectInformationCorrectly()
        {
            var testFile = Path.Combine(GetTestDir(), "Benchmarktool assemblage - Failure mechanism without length-effect.xlsx");

            using (SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Open(testFile, false))
            {
                WorkbookPart workbookPart   = spreadsheetDocument.WorkbookPart;
                var          workSheetParts = ReadWorkSheetParts(workbookPart);
                var          workSheetPart  = workSheetParts["Sheet1"];

                var reader = new FailureMechanismsReader(workSheetPart, workbookPart);

                var result = new BenchmarkTestInput();

                reader.Read(result, "GEKB");

                Assert.AreEqual(1, result.ExpectedFailureMechanismsResults.Count);
                ExpectedFailureMechanismResult expectedFailureMechanismResult =
                    result.ExpectedFailureMechanismsResults.First();
                Assert.AreEqual(false, expectedFailureMechanismResult.HasLengthEffect);
                Assert.AreEqual("GEKB", expectedFailureMechanismResult.MechanismId);
                Assert.AreEqual(4.46E-06, expectedFailureMechanismResult.ExpectedCombinedProbability, 1E-4);
                Assert.AreEqual(4.46E-06, expectedFailureMechanismResult.ExpectedCombinedProbabilityTemporal, 1E-4);
            }
        }
 private void ReadGeneralInformation(ExpectedFailureMechanismResult expectedFailureMechanismResult)
 {
     expectedFailureMechanismResult.ExpectedCombinedProbabilityTemporal  = new Probability(GetCellValueAsDouble("C", "Faalkans tussentijds"));
     expectedFailureMechanismResult.ExpectedIsSectionsCorrelatedTemporal = ToCorrelation(GetCellValueAsString("C", "Vakken gecorreleerd?") == "Ja");
     expectedFailureMechanismResult.ExpectedCombinedProbability          = new Probability(GetCellValueAsDouble("C", "Faalkans"));
     expectedFailureMechanismResult.ExpectedIsSectionsCorrelated         = ToCorrelation(double.IsNaN(expectedFailureMechanismResult.ExpectedCombinedProbability) || expectedFailureMechanismResult.ExpectedIsSectionsCorrelatedTemporal == EFailureMechanismAssemblyMethod.Correlated);
     expectedFailureMechanismResult.LengthEffectFactor = GetCellValueAsDouble("C", "Ntraject");
 }
        /// <summary>
        /// Reads all relevant input and expected output for a specific failure mechanism.
        /// </summary>
        /// <param name="benchmarkTestInput">The test input.</param>
        /// <param name="mechanismId">String used to identify the failure mechanism.</param>
        public void Read(BenchmarkTestInput benchmarkTestInput, string mechanismId)
        {
            bool hasLengthEffect = GetCellValueAsString("C", "Lengte-effect") == "Ja";
            ExpectedFailureMechanismResult expectedFailureMechanismResult =
                new ExpectedFailureMechanismResult(GetCellValueAsString("C", "Faalpad"), mechanismId, hasLengthEffect);

            ReadGeneralInformation(expectedFailureMechanismResult);
            ReadFailureMechanismSections(expectedFailureMechanismResult);

            benchmarkTestInput.ExpectedFailureMechanismsResults.Add(expectedFailureMechanismResult);
        }
 /// <summary>
 /// Creates a new instance of <see cref="FailureMechanismResultTesterBase{TFailureMechanismResult}"/>.
 /// </summary>
 /// <param name="methodResults">The method results.</param>
 /// <param name="expectedFailureMechanismResult">The expected failure mechanism results.</param>
 /// <param name="interpretationCategories"></param>
 protected FailureMechanismResultTesterBase(MethodResultsListing methodResults,
                                            ExpectedFailureMechanismResult expectedFailureMechanismResult,
                                            CategoriesList <InterpretationCategory> interpretationCategories)
 {
     ExpectedFailureMechanismResult = expectedFailureMechanismResult;
     MethodResults            = methodResults;
     InterpretationCategories = interpretationCategories;
     if (ExpectedFailureMechanismResult == null || InterpretationCategories == null)
     {
         throw new ArgumentException();
     }
 }
        /// <summary>
        /// Test the failure mechanism assembly.
        /// </summary>
        /// <param name="expectedFailureMechanismResult">The expected failure mechanism result.</param>
        /// <param name="testResult">The test result.</param>
        /// <param name="interpretationCategories">The interpretation categories needed to translate a probability to an interpretation category.</param>
        public static void TestFailureMechanismAssembly(ExpectedFailureMechanismResult expectedFailureMechanismResult,
                                                        BenchmarkTestResult testResult, CategoriesList <InterpretationCategory> interpretationCategories)
        {
            var failureMechanismTestResult =
                GetBenchmarkTestFailureMechanismResult(testResult, expectedFailureMechanismResult.Name, expectedFailureMechanismResult.MechanismId, expectedFailureMechanismResult.HasLengthEffect);

            var failureMechanismTester =
                expectedFailureMechanismResult.HasLengthEffect
                    ? new FailureMechanismWithLengthEffectResultTester(testResult.MethodResults, expectedFailureMechanismResult, interpretationCategories) as IFailureMechanismResultTester
                    : new FailureMechanismResultTester(testResult.MethodResults, expectedFailureMechanismResult, interpretationCategories);

            failureMechanismTestResult.AreEqualCombinedAssessmentResultsPerSection =
                failureMechanismTester.TestCombinedAssessment();
            failureMechanismTestResult.AreEqualAssessmentResultPerAssessmentSection =
                failureMechanismTester.TestAssessmentSectionResult();
            failureMechanismTestResult.AreEqualAssessmentResultPerAssessmentSectionTemporal =
                failureMechanismTester.TestAssessmentSectionResultTemporal();
        }
 public FailureMechanismResultTester(MethodResultsListing methodResults,
                                     ExpectedFailureMechanismResult expectedFailureMechanismResult,
                                     CategoriesList <InterpretationCategory> interpretationCategories) : base(methodResults, expectedFailureMechanismResult, interpretationCategories)
 {
 }