Beispiel #1
0
        /// <summary>
        /// Assembles the section based on the input arguments.
        /// </summary>
        /// <param name="sectionResult">The section result to assemble.</param>
        /// <param name="failureMechanism">The <see cref="PipingFailureMechanism"/> the section result belongs to.</param>
        /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> the section belongs to.</param>
        /// <returns>A <see cref="FailureMechanismSectionAssemblyResultWrapper"/>.</returns>
        /// <exception cref="ArgumentNullException">Thrown when any argument is <c>null</c>.</exception>
        /// <exception cref="AssemblyException">Thrown when the section could not be assembled.</exception>
        public static FailureMechanismSectionAssemblyResultWrapper AssembleSection(
            AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult,
            PipingFailureMechanism failureMechanism,
            IAssessmentSection assessmentSection)
        {
            if (sectionResult == null)
            {
                throw new ArgumentNullException(nameof(sectionResult));
            }

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

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

            IFailureMechanismSectionResultCalculateProbabilityStrategy calculateProbabilityStrategy =
                PipingFailureMechanismSectionResultCalculateProbabilityStrategyFactory.CreateCalculateStrategy(sectionResult, failureMechanism, assessmentSection);

            return(FailureMechanismSectionAssemblyResultFactory.AssembleSection(
                       sectionResult, assessmentSection, calculateProbabilityStrategy,
                       failureMechanism.GeneralInput.ApplyLengthEffectInSection,
                       failureMechanism.PipingProbabilityAssessmentInput.GetN(sectionResult.Section.Length)));
        }
        public void CreateCalculateStrategy_WithProbabilisticConfigurations_ReturnsExpectedStrategy(
            PipingFailureMechanism failureMechanism, PipingScenarioConfigurationPerFailureMechanismSectionType configurationType)
        {
            // Setup
            var mocks             = new MockRepository();
            var assessmentSection = mocks.Stub <IAssessmentSection>();

            mocks.ReplayAll();

            FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();

            failureMechanism.SetSections(new[]
            {
                section
            }, "APath");

            PipingScenarioConfigurationPerFailureMechanismSection scenarioConfigurationPerFailureMechanismSection =
                failureMechanism.ScenarioConfigurationsPerFailureMechanismSection.Single();

            scenarioConfigurationPerFailureMechanismSection.ScenarioConfigurationType = configurationType;

            // Call
            IFailureMechanismSectionResultCalculateProbabilityStrategy strategy =
                PipingFailureMechanismSectionResultCalculateProbabilityStrategyFactory.CreateCalculateStrategy(
                    failureMechanism.SectionResults.Single(), failureMechanism, assessmentSection);

            // Assert
            Assert.IsInstanceOf <ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy>(strategy);
        }
        /// <summary>
        /// Creates a new instance of <see cref="AdoptableWithProfileProbabilityFailureMechanismSectionResultRow"/>.
        /// </summary>
        /// <param name="sectionResult">The <see cref="AdoptableWithProfileProbabilityFailureMechanismSectionResult"/> that is
        /// the source of this row.</param>
        /// <param name="calculateProbabilityStrategy">The strategy used to calculate probabilities.</param>
        /// <param name="failureMechanismSectionResultRowErrorProvider">The error provider to use for
        /// the failure mechanism section result row.</param>
        /// <param name="performAssemblyFunc">Function to perform the assembly.</param>
        /// <param name="getApplyLengthEffectInSectionFunc">Function to get the apply length effect in section indicator.</param>
        /// <param name="constructionProperties">The property values required to create an instance of
        /// <see cref="AdoptableWithProfileProbabilityFailureMechanismSectionResultRow"/>.</param>
        /// <exception cref="ArgumentNullException">Throw when any parameter is <c>null</c>.</exception>
        public AdoptableWithProfileProbabilityFailureMechanismSectionResultRow(AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult,
                                                                               IFailureMechanismSectionResultCalculateProbabilityStrategy calculateProbabilityStrategy,
                                                                               IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider failureMechanismSectionResultRowErrorProvider,
                                                                               Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc,
                                                                               Func <bool> getApplyLengthEffectInSectionFunc,
                                                                               ConstructionProperties constructionProperties)
            : base(sectionResult)
        {
            if (calculateProbabilityStrategy == null)
            {
                throw new ArgumentNullException(nameof(calculateProbabilityStrategy));
            }

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

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

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

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

            this.calculateProbabilityStrategy = calculateProbabilityStrategy;
            this.failureMechanismSectionResultRowErrorProvider = failureMechanismSectionResultRowErrorProvider;
            this.performAssemblyFunc = performAssemblyFunc;
            this.getApplyLengthEffectInSectionFunc = getApplyLengthEffectInSectionFunc;

            initialFailureMechanismResultTypeIndex = constructionProperties.InitialFailureMechanismResultTypeIndex;
            initialFailureMechanismResultProfileProbabilityIndex = constructionProperties.InitialFailureMechanismResultProfileProbabilityIndex;
            initialFailureMechanismResultSectionProbabilityIndex = constructionProperties.InitialFailureMechanismResultSectionProbabilityIndex;
            furtherAnalysisTypeIndex       = constructionProperties.FurtherAnalysisTypeIndex;
            probabilityRefinementTypeIndex = constructionProperties.ProbabilityRefinementTypeIndex;
            refinedProfileProbabilityIndex = constructionProperties.RefinedProfileProbabilityIndex;
            refinedSectionProbabilityIndex = constructionProperties.RefinedSectionProbabilityIndex;
            profileProbabilityIndex        = constructionProperties.ProfileProbabilityIndex;
            sectionProbabilityIndex        = constructionProperties.SectionProbabilityIndex;
            sectionNIndex      = constructionProperties.SectionNIndex;
            assemblyGroupIndex = constructionProperties.AssemblyGroupIndex;

            CreateColumnStateDefinitions();

            Update();
        }
        /// <summary>
        /// Assembles a failure mechanism section result based on the input arguments.
        /// </summary>
        /// <param name="sectionResult">The section result to assemble for.</param>
        /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> to assemble with.</param>
        /// <param name="calculateProbabilityStrategy">The <see cref="IFailureMechanismSectionResultCalculateProbabilityStrategy"/>
        /// to assemble with.</param>
        /// <param name="useLengthEffect">Indicator whether to use the length effect or not.</param>
        /// <param name="sectionN">The N value for the section.</param>
        /// <returns>A <see cref="FailureMechanismSectionAssemblyResultWrapper"/>.</returns>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="sectionResult"/>,
        /// <paramref name="assessmentSection"/> or <paramref name="calculateProbabilityStrategy"/> is <c>null</c>.</exception>
        /// <exception cref="AssemblyException">Thrown when the section could not be successfully assembled.</exception>
        public static FailureMechanismSectionAssemblyResultWrapper AssembleSection(
            AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult, IAssessmentSection assessmentSection,
            IFailureMechanismSectionResultCalculateProbabilityStrategy calculateProbabilityStrategy,
            bool useLengthEffect, double sectionN)
        {
            if (sectionResult == null)
            {
                throw new ArgumentNullException(nameof(sectionResult));
            }

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

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

            bool   isInitialFailureMechanismResultTypeAdopt        = sectionResult.InitialFailureMechanismResultType == AdoptableInitialFailureMechanismResultType.Adopt;
            double initialFailureMechanismResultSectionProbability =
                isInitialFailureMechanismResultTypeAdopt
                    ? calculateProbabilityStrategy.CalculateSectionProbability()
                    : sectionResult.ManualInitialFailureMechanismResultSectionProbability;

            FailureMechanismSectionAssemblyInput input;

            if (useLengthEffect)
            {
                double initialFailureMechanismResultProfileProbability =
                    isInitialFailureMechanismResultTypeAdopt
                        ? calculateProbabilityStrategy.CalculateProfileProbability()
                        : sectionResult.ManualInitialFailureMechanismResultProfileProbability;

                input = CreateInput(
                    assessmentSection, sectionResult.IsRelevant, sectionResult.InitialFailureMechanismResultType,
                    initialFailureMechanismResultProfileProbability, initialFailureMechanismResultSectionProbability, sectionResult.FurtherAnalysisType,
                    sectionResult.RefinedProfileProbability, sectionResult.RefinedSectionProbability, sectionResult.ProbabilityRefinementType, sectionN);
            }
            else
            {
                bool hasProbabilitySpecified = sectionResult.InitialFailureMechanismResultType != AdoptableInitialFailureMechanismResultType.NoFailureProbability;

                input = CreateInput(
                    assessmentSection, sectionResult.IsRelevant, initialFailureMechanismResultSectionProbability,
                    sectionResult.FurtherAnalysisType, sectionResult.RefinedSectionProbability, hasProbabilitySpecified);
            }

            return(PerformAssembly(input));
        }