public void AssembleCombinedFailureMechanismSections_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator()
        {
            // Setup
            var random = new Random(39);

            using (new AssemblyToolKernelFactoryConfig())
            {
                var factory    = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
                var calculator = new AssessmentSectionAssemblyCalculator(factory);

                // Call
                CombinedFailureMechanismSectionAssemblyResultWrapper output = calculator.AssembleCombinedFailureMechanismSections(new[]
                {
                    new[]
                    {
                        new CombinedAssemblyFailureMechanismSection(0, 1, random.NextEnumValue <FailureMechanismSectionAssemblyGroup>())
                    }
                }, random.NextDouble());

                // Assert
                CombinedFailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedCombinedFailureMechanismSectionAssemblyKernel;
                CombinedFailureMechanismSectionAssemblyAssert.AssertAssembly(new[]
                {
                    kernel.FailureMechanismResult
                }, kernel.CombinedSectionResults, output.AssemblyResults);
                Assert.AreEqual(AssemblyMethod.BOI3A1, output.CommonSectionAssemblyMethod);
                Assert.AreEqual(AssemblyMethod.BOI3B1, output.FailureMechanismResultsAssemblyMethod);
                Assert.AreEqual(AssemblyMethod.BOI3C1, output.CombinedSectionResultAssemblyMethod);
            }
        }
        public CombinedFailureMechanismSectionAssemblyResultWrapper AssembleCombinedFailureMechanismSections(
            IEnumerable <IEnumerable <CombinedAssemblyFailureMechanismSection> > input, double assessmentSectionLength)
        {
            if (ThrowExceptionOnCalculate)
            {
                throw new AssessmentSectionAssemblyCalculatorException("Message", new Exception());
            }

            CombinedFailureMechanismSectionsInput = input;
            AssessmentSectionLength = assessmentSectionLength;

            return(CombinedFailureMechanismSectionAssemblyOutput ?? (CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
                                                                         new[]
            {
                new CombinedFailureMechanismSectionAssembly(
                    new CombinedAssemblyFailureMechanismSection(
                        0, 1, FailureMechanismSectionAssemblyGroup.Zero),
                    input.Select(failureMechanism => FailureMechanismSectionAssemblyGroup.Dominant).ToArray())
            }, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1)));
        }
Exemplo n.º 3
0
        /// <summary>
        /// Assembles the combined failure mechanism sections.
        /// </summary>
        /// <param name="assessmentSection">The assessment section that contains all
        /// the failure mechanism sections to assemble.</param>
        /// <returns>A collection of <see cref="CombinedFailureMechanismSectionAssemblyResult"/>.</returns>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/>
        /// is <c>null</c>.</exception>
        /// <exception cref="AssemblyException">Thrown when a <see cref="CombinedFailureMechanismSectionAssemblyResult"/>
        /// cannot be created.</exception>
        public static IEnumerable <CombinedFailureMechanismSectionAssemblyResult> AssembleCombinedPerFailureMechanismSection(
            AssessmentSection assessmentSection)
        {
            if (assessmentSection == null)
            {
                throw new ArgumentNullException(nameof(assessmentSection));
            }

            try
            {
                IAssemblyToolCalculatorFactory       calculatorFactory = AssemblyToolCalculatorFactory.Instance;
                IAssessmentSectionAssemblyCalculator calculator        = calculatorFactory.CreateAssessmentSectionAssemblyCalculator(
                    AssemblyToolKernelFactory.Instance);

                Dictionary <IFailureMechanism, int> failureMechanismsToAssemble = assessmentSection.GetFailureMechanisms()
                                                                                  .Concat(assessmentSection.SpecificFailureMechanisms)
                                                                                  .Where(fm => fm.InAssembly)
                                                                                  .Select((fm, i) => new
                {
                    FailureMechanism = fm,
                    Index            = i
                })
                                                                                  .ToDictionary(x => x.FailureMechanism, x => x.Index);

                CombinedFailureMechanismSectionAssemblyResultWrapper output = calculator.AssembleCombinedFailureMechanismSections(
                    CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, failureMechanismsToAssemble.Keys),
                    assessmentSection.ReferenceLine.Length);

                return(CombinedFailureMechanismSectionAssemblyResultFactory.Create(output, failureMechanismsToAssemble, assessmentSection));
            }
            catch (AssessmentSectionAssemblyCalculatorException e)
            {
                throw new AssemblyException(e.Message, e);
            }
            catch (AssemblyException e)
            {
                throw new AssemblyException(Resources.AssessmentSectionAssemblyFactory_Error_while_assembling_failureMechanisms, e);
            }
        }
Exemplo n.º 4
0
        public void Constructor_ExpectedValues()
        {
            // Setup
            var random          = new Random(21);
            var assemblyResults = new[]
            {
                new CombinedFailureMechanismSectionAssembly(
                    new CombinedAssemblyFailureMechanismSection(0, 1, random.NextEnumValue <FailureMechanismSectionAssemblyGroup>()),
                    Array.Empty <FailureMechanismSectionAssemblyGroup>())
            };
            var commonSectionAssemblyMethod           = random.NextEnumValue <AssemblyMethod>();
            var failureMechanismResultsAssemblyMethod = random.NextEnumValue <AssemblyMethod>();
            var combinedSectionResultAssemblyMethod   = random.NextEnumValue <AssemblyMethod>();

            // Call
            var wrapper = new CombinedFailureMechanismSectionAssemblyResultWrapper(
                assemblyResults, commonSectionAssemblyMethod, failureMechanismResultsAssemblyMethod, combinedSectionResultAssemblyMethod);

            // Assert
            Assert.AreSame(assemblyResults, wrapper.AssemblyResults);
            Assert.AreEqual(commonSectionAssemblyMethod, wrapper.CommonSectionAssemblyMethod);
            Assert.AreEqual(failureMechanismResultsAssemblyMethod, wrapper.FailureMechanismResultsAssemblyMethod);
            Assert.AreEqual(combinedSectionResultAssemblyMethod, wrapper.CombinedSectionResultAssemblyMethod);
        }
Exemplo n.º 5
0
        public void Create_WithAllFailureMechanisms_ReturnsCombinedFailureMechanismSectionAssemblyResults()
        {
            // Setup
            var random            = new Random(21);
            var assessmentSection = new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>());

            assessmentSection.SpecificFailureMechanisms.Add(new SpecificFailureMechanism());
            Dictionary <IFailureMechanism, int> failureMechanisms = assessmentSection.GetFailureMechanisms()
                                                                    .Concat(assessmentSection.SpecificFailureMechanisms)
                                                                    .Where(fm => fm.InAssembly)
                                                                    .Select((fm, i) => new
            {
                FailureMechanism = fm,
                Index            = i
            })
                                                                    .ToDictionary(x => x.FailureMechanism, x => x.Index);

            var section1 = new CombinedAssemblyFailureMechanismSection(0, 5, random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
            var section2 = new CombinedAssemblyFailureMechanismSection(5, 11, random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
            var output   = new CombinedFailureMechanismSectionAssemblyResultWrapper(
                new[]
            {
                new CombinedFailureMechanismSectionAssembly(section1, GetFailureMechanismsOutput(failureMechanisms.Keys, random)),
                new CombinedFailureMechanismSectionAssembly(section2, GetFailureMechanismsOutput(failureMechanisms.Keys, random))
            }, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);

            // Call
            CombinedFailureMechanismSectionAssemblyResult[] results = CombinedFailureMechanismSectionAssemblyResultFactory.Create(output, failureMechanisms, assessmentSection).ToArray();

            // Assert
            Assert.AreEqual(output.AssemblyResults.Count(), results.Length);
            for (var i = 0; i < output.AssemblyResults.Count(); i++)
            {
                CombinedFailureMechanismSectionAssembly assemblyResult = output.AssemblyResults.ElementAt(i);
                Assert.AreEqual(assemblyResult.Section.SectionStart, results[i].SectionStart);
                Assert.AreEqual(assemblyResult.Section.SectionEnd, results[i].SectionEnd);
                Assert.AreEqual(assemblyResult.Section.FailureMechanismSectionAssemblyGroup, results[i].TotalResult);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.Piping]), results[i].Piping);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverErosionInwards]), results[i].GrassCoverErosionInwards);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.MacroStabilityInwards]), results[i].MacroStabilityInwards);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.Microstability]), results[i].Microstability);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.StabilityStoneCover]), results[i].StabilityStoneCover);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.WaveImpactAsphaltCover]), results[i].WaveImpactAsphaltCover);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.WaterPressureAsphaltCover]), results[i].WaterPressureAsphaltCover);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverErosionOutwards]), results[i].GrassCoverErosionOutwards);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverSlipOffOutwards]), results[i].GrassCoverSlipOffOutwards);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverSlipOffInwards]), results[i].GrassCoverSlipOffInwards);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.HeightStructures]), results[i].HeightStructures);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.ClosingStructures]), results[i].ClosingStructures);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.PipingStructure]), results[i].PipingStructure);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.StabilityPointStructures]), results[i].StabilityPointStructures);
                Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.DuneErosion]), results[i].DuneErosion);
                Assert.AreEqual(assessmentSection.SpecificFailureMechanisms.Count, results[i].SpecificFailureMechanisms.Length);
                foreach (SpecificFailureMechanism specificFailureMechanism in assessmentSection.SpecificFailureMechanisms)
                {
                    Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[specificFailureMechanism]), results[i].SpecificFailureMechanisms.Single());
                }

                Assert.AreEqual(output.CommonSectionAssemblyMethod, results[i].CommonSectionAssemblyMethod);
                Assert.AreEqual(output.FailureMechanismResultsAssemblyMethod, results[i].FailureMechanismResultsAssemblyMethod);
                Assert.AreEqual(output.CombinedSectionResultAssemblyMethod, results[i].CombinedSectionResultAssemblyMethod);
            }
        }
        /// <summary>
        /// Creates a collection of <see cref="CombinedFailureMechanismSectionAssemblyResult"/> based
        /// on the given <paramref name="output"/> and <paramref name="failureMechanisms"/>.
        /// </summary>
        /// <param name="output">The output to create the results for.</param>
        /// <param name="failureMechanisms">The failure mechanisms to create the results for.</param>
        /// <param name="assessmentSection">The assessment section to use while creating the results.</param>
        /// <returns>A collection of <see cref="CombinedFailureMechanismSectionAssemblyResult"/>.</returns>
        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
        public static IEnumerable <CombinedFailureMechanismSectionAssemblyResult> Create(CombinedFailureMechanismSectionAssemblyResultWrapper output,
                                                                                         IDictionary <IFailureMechanism, int> failureMechanisms,
                                                                                         AssessmentSection assessmentSection)
        {
            if (output == null)
            {
                throw new ArgumentNullException(nameof(output));
            }

            if (failureMechanisms == null)
            {
                throw new ArgumentNullException(nameof(failureMechanisms));
            }

            if (assessmentSection == null)
            {
                throw new ArgumentNullException(nameof(assessmentSection));
            }

            return(output.AssemblyResults.Select(assembly => new CombinedFailureMechanismSectionAssemblyResult(
                                                     assembly.Section.SectionStart,
                                                     assembly.Section.SectionEnd,
                                                     assembly.Section.FailureMechanismSectionAssemblyGroup,
                                                     output.CommonSectionAssemblyMethod,
                                                     output.FailureMechanismResultsAssemblyMethod,
                                                     output.CombinedSectionResultAssemblyMethod,
                                                     CreateFailureMechanismResults(assembly.FailureMechanismSectionAssemblyGroupResults,
                                                                                   failureMechanisms, assessmentSection)))
                   .ToArray());
        }