Ejemplo n.º 1
0
        public override IEnumerable <PropertyInfo> GetPropertyInfos()
        {
            yield return(new PropertyInfo <HydraulicLoadsStateFailureMechanismContext, HydraulicLoadsStateFailureMechanismProperties>
            {
                CreateInstance = context => new HydraulicLoadsStateFailureMechanismProperties(context.WrappedData)
            });

            yield return(new PropertyInfo <RegistrationStateFailureMechanismContext, RegistrationStateFailureMechanismProperties>
            {
                CreateInstance = context => new RegistrationStateFailureMechanismProperties(context.WrappedData)
            });

            yield return(new PropertyInfo <StabilityStoneCoverWaveConditionsOutputContext, StabilityStoneCoverWaveConditionsOutputProperties>
            {
                CreateInstance = context => new StabilityStoneCoverWaveConditionsOutputProperties(context.WrappedData, context.Input)
            });

            yield return(new PropertyInfo <StabilityStoneCoverWaveConditionsInputContext, StabilityStoneCoverWaveConditionsInputContextProperties>
            {
                CreateInstance = context => new StabilityStoneCoverWaveConditionsInputContextProperties(
                    context,
                    () => WaveConditionsInputHelper.GetAssessmentLevel(context.WrappedData, context.AssessmentSection),
                    new ObservablePropertyChangeHandler(context.Calculation, context.WrappedData))
            });
        }
        public void GetAssessmentLevel_ValidInputWithHydraulicBoundaryLocation_ReturnsExpectedValue(
            WaveConditionsInputWaterLevelType waterLevelType,
            Func <WaveConditionsInput, IAssessmentSection, double> getExpectedAssessmentLevel)
        {
            // Setup
            var assessmentSection         = new AssessmentSectionStub();
            var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();

            assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
            {
                hydraulicBoundaryLocation
            }, true);

            var input = new WaveConditionsInput
            {
                HydraulicBoundaryLocation     = hydraulicBoundaryLocation,
                WaterLevelType                = waterLevelType,
                CalculationsTargetProbability = assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.First()
            };

            // Call
            double assessmentLevel = WaveConditionsInputHelper.GetAssessmentLevel(input, assessmentSection);

            // Assert
            Assert.AreEqual(getExpectedAssessmentLevel(input, assessmentSection), assessmentLevel);
        }
Ejemplo n.º 3
0
        private void SetConfigurationTargetProbabilityProperty(WaveConditionsCalculationConfiguration configuration, WaveConditionsInput input)
        {
            if (input.WaterLevelType == WaveConditionsInputWaterLevelType.None)
            {
                return;
            }

            configuration.TargetProbability = WaveConditionsInputHelper.GetTargetProbability(input, assessmentSection);
        }
Ejemplo n.º 4
0
        private static void Validate(WaveImpactAsphaltCoverWaveConditionsCalculationContext context)
        {
            IAssessmentSection assessmentSection = context.AssessmentSection;
            WaveImpactAsphaltCoverWaveConditionsCalculation calculation = context.WrappedData;

            WaveConditionsCalculationServiceBase.Validate(calculation.InputParameters,
                                                          WaveConditionsInputHelper.GetAssessmentLevel(calculation.InputParameters, context.AssessmentSection),
                                                          assessmentSection.HydraulicBoundaryDatabase);
        }
Ejemplo n.º 5
0
 private static void ValidateAllInCalculationGroup(WaveImpactAsphaltCoverCalculationGroupContext context)
 {
     foreach (WaveImpactAsphaltCoverWaveConditionsCalculation calculation in context.WrappedData.GetCalculations().OfType <WaveImpactAsphaltCoverWaveConditionsCalculation>())
     {
         WaveConditionsCalculationServiceBase.Validate(calculation.InputParameters,
                                                       WaveConditionsInputHelper.GetAssessmentLevel(calculation.InputParameters, context.AssessmentSection),
                                                       context.AssessmentSection.HydraulicBoundaryDatabase);
     }
 }
        public void GetTargetProbability_InputNull_ThrowsArgumentNullException()
        {
            // Call
            void Call() => WaveConditionsInputHelper.GetTargetProbability(null, new AssessmentSectionStub());

            // Assert
            var exception = Assert.Throws <ArgumentNullException>(Call);

            Assert.AreEqual("input", exception.ParamName);
        }
        public void GetUpperBoundaryAssessmentLevel_DifferentAssessmentLevels_ReturnsExpectedUpperBoundary(double assessmentLevel,
                                                                                                           double expectedUpperBoundary)
        {
            // Call
            RoundedDouble upperBoundary = WaveConditionsInputHelper.GetUpperBoundaryAssessmentLevel((RoundedDouble)assessmentLevel);

            // Assert
            Assert.AreEqual(2, upperBoundary.NumberOfDecimalPlaces);
            Assert.AreEqual(expectedUpperBoundary, upperBoundary);
        }
        public void GetAssessmentLevel_AssessmentSectionNull_ThrowsArgumentNullException()
        {
            // Call
            void Call() => WaveConditionsInputHelper.GetAssessmentLevel(new WaveConditionsInput(), null);

            // Assert
            var exception = Assert.Throws <ArgumentNullException>(Call);

            Assert.AreEqual("assessmentSection", exception.ParamName);
        }
        public void GetHydraulicBoundaryLocationCalculation_AssessmentSectionNull_ThrowsArgumentNullException()
        {
            // Call
            void Call() => WaveConditionsInputHelper.GetHydraulicBoundaryLocationCalculation(new WaveConditionsInput(), null);

            // Assert
            var exception = Assert.Throws <ArgumentNullException>(Call);

            Assert.AreEqual("assessmentSection", exception.ParamName);
        }
Ejemplo n.º 10
0
        private static void ValidateAllInCalculationGroup(GrassCoverErosionOutwardsCalculationGroupContext context)
        {
            CalculationGroup calculationGroup = context.WrappedData;

            foreach (GrassCoverErosionOutwardsWaveConditionsCalculation calculation in calculationGroup.GetCalculations().OfType <GrassCoverErosionOutwardsWaveConditionsCalculation>())
            {
                WaveConditionsCalculationServiceBase.Validate(
                    calculation.InputParameters,
                    WaveConditionsInputHelper.GetAssessmentLevel(calculation.InputParameters, context.AssessmentSection),
                    context.AssessmentSection.HydraulicBoundaryDatabase);
            }
        }
        public void SetWaterLevelType_WaveConditionsInputNull_ThrowsArgumentNullException()
        {
            // Setup
            var random = new Random(21);

            // Call
            void Call() => WaveConditionsInputHelper.SetWaterLevelType(null, random.NextEnumValue <NormativeProbabilityType>());

            // Assert
            var exception = Assert.Throws <ArgumentNullException>(Call);

            Assert.AreEqual("waveConditionsInput", exception.ParamName);
        }
        public void SetWaterLevelType_WithWaveConditionsInputAndVariousNormativeProbabilityTypes_SetsWaterLevelType(
            NormativeProbabilityType normativeProbabilityType,
            WaveConditionsInputWaterLevelType expectedWaveConditionsInputWaterLevelType)
        {
            // Setup
            var waveConditionsInput = new WaveConditionsInput();

            // Call
            WaveConditionsInputHelper.SetWaterLevelType(waveConditionsInput, normativeProbabilityType);

            // Assert
            Assert.AreEqual(expectedWaveConditionsInputWaterLevelType, waveConditionsInput.WaterLevelType);
        }
Ejemplo n.º 13
0
        public override IEnumerable <ViewInfo> GetViewInfos()
        {
            yield return(new RiskeerViewInfo <HydraulicLoadsStateFailureMechanismContext, HydraulicLoadsStateFailureMechanismView>(() => Gui)
            {
                GetViewName = (view, context) => context.WrappedData.Name,
                CreateInstance = context => new HydraulicLoadsStateFailureMechanismView(context.WrappedData, context.Parent)
            });

            yield return(new RiskeerViewInfo <RegistrationStateFailureMechanismContext, RegistrationStateFailureMechanismView>(() => Gui)
            {
                GetViewName = (view, context) => context.WrappedData.Name,
                AdditionalDataCheck = context => context.WrappedData.InAssembly,
                CreateInstance = context => new RegistrationStateFailureMechanismView(context.WrappedData, context.Parent),
                CloseForData = CloseFailureMechanismViewForData
            });

            yield return(new RiskeerViewInfo <
                             WaveImpactAsphaltCoverFailureMechanismSectionResultContext,
                             IObservableEnumerable <NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>,
                             NonAdoptableWithProfileProbabilityFailureMechanismResultView <WaveImpactAsphaltCoverFailureMechanism> >(() => Gui)
            {
                GetViewName = (view, context) => RiskeerCommonFormsResources.FailureMechanism_AssessmentResult_DisplayName,
                CloseForData = CloseFailureMechanismResultViewForData,
                GetViewData = context => context.WrappedData,
                CreateInstance = context =>
                {
                    var failureMechanism = (WaveImpactAsphaltCoverFailureMechanism)context.FailureMechanism;
                    IAssessmentSection assessmentSection = context.AssessmentSection;

                    return new NonAdoptableWithProfileProbabilityFailureMechanismResultView <WaveImpactAsphaltCoverFailureMechanism>(
                        context.WrappedData,
                        failureMechanism,
                        assessmentSection,
                        WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism,
                        fm => fm.GeneralWaveImpactAsphaltCoverInput.ApplyLengthEffectInSection,
                        sr => WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleSection(sr, failureMechanism, assessmentSection));
                }
            });

            yield return(new RiskeerViewInfo <WaveImpactAsphaltCoverWaveConditionsInputContext,
                                              ICalculation <WaveConditionsInput>,
                                              WaveConditionsInputView>(() => Gui)
            {
                GetViewName = (view, context) => RiskeerCommonFormsResources.Calculation_Input,
                CloseForData = RiskeerPluginHelper.ShouldCloseViewWithCalculationData,
                CreateInstance = context => new WaveConditionsInputView(
                    context.Calculation,
                    () => WaveConditionsInputHelper.GetHydraulicBoundaryLocationCalculation(context.WrappedData, context.AssessmentSection),
                    new WaveImpactAsphaltCoverWaveConditionsInputViewStyle())
            });
        }
        public void SetWaterLevelType_InvalidNormativeProbabilityType_ThrowsInvalidEnumArgumentException()
        {
            // Setup
            const NormativeProbabilityType normativeProbabilityType = (NormativeProbabilityType)99;

            // Call
            void Call() => WaveConditionsInputHelper.SetWaterLevelType(new WaveConditionsInput(), normativeProbabilityType);

            // Assert
            var expectedMessage = $"The value of argument 'normativeProbabilityType' ({normativeProbabilityType}) is invalid for Enum type '{nameof(NormativeProbabilityType)}'.";
            var exception       = TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(Call, expectedMessage);

            Assert.AreEqual("normativeProbabilityType", exception.ParamName);
        }
Ejemplo n.º 15
0
        private static void AddWaveConditionsCalculation(WaveImpactAsphaltCoverCalculationGroupContext nodeData)
        {
            var calculation = new WaveImpactAsphaltCoverWaveConditionsCalculation
            {
                Name = NamingHelper.GetUniqueName(nodeData.WrappedData.Children,
                                                  RiskeerCommonDataResources.Calculation_DefaultName,
                                                  c => c.Name)
            };

            WaveConditionsInputHelper.SetWaterLevelType(calculation.InputParameters,
                                                        nodeData.AssessmentSection.FailureMechanismContribution.NormativeProbabilityType);
            nodeData.WrappedData.Children.Add(calculation);
            nodeData.WrappedData.NotifyObservers();
        }
        /// <summary>
        /// Performs a wave conditions calculation for the wave impact on asphalt failure mechanism based on the supplied
        /// <see cref="WaveImpactAsphaltCoverWaveConditionsCalculation"/>  and sets
        /// <see cref="WaveImpactAsphaltCoverWaveConditionsCalculation.Output"/> if the calculation was successful.
        /// Error and status information is logged during the execution of the operation.
        /// </summary>
        /// <param name="calculation">The <see cref="WaveImpactAsphaltCoverWaveConditionsCalculation"/> that holds all the information required to perform the calculation.</param>
        /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> that holds information about the target probability used in the calculation.</param>
        /// <param name="generalWaveConditionsInput">Calculation input parameters that apply to all <see cref="WaveImpactAsphaltCoverWaveConditionsCalculation"/> instances.</param>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/>, <paramref name="assessmentSection"/>
        /// or <paramref name="generalWaveConditionsInput"/> is <c>null</c>.</exception>
        /// <exception cref="ArgumentException">Thrown when the hydraulic boundary database file path contains invalid characters.</exception>
        /// <exception cref="CriticalFileReadException">Thrown when:
        /// <list type="bullet">
        /// <item>No settings database file could be found at the location of hydraulic boundary database file path
        /// with the same name.</item>
        /// <item>Unable to open settings database file.</item>
        /// <item>Unable to read required data from database file.</item>
        /// </list>
        /// </exception>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when the target probability or
        /// calculated probability falls outside the [0.0, 1.0] range and is not <see cref="double.NaN"/>.</exception>
        /// <exception cref="HydraRingFileParserException">Thrown when an error occurs during parsing of the Hydra-Ring output.</exception>
        /// <exception cref="HydraRingCalculationException">Thrown when an error occurs during the calculation.</exception>
        public void Calculate(WaveImpactAsphaltCoverWaveConditionsCalculation calculation,
                              IAssessmentSection assessmentSection,
                              GeneralWaveConditionsInput generalWaveConditionsInput)
        {
            if (calculation == null)
            {
                throw new ArgumentNullException(nameof(calculation));
            }

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

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

            CalculationServiceHelper.LogCalculationBegin();

            RoundedDouble a = generalWaveConditionsInput.A;
            RoundedDouble b = generalWaveConditionsInput.B;
            RoundedDouble c = generalWaveConditionsInput.C;

            double targetProbability = WaveConditionsInputHelper.GetTargetProbability(calculation.InputParameters, assessmentSection);

            RoundedDouble assessmentLevel = WaveConditionsInputHelper.GetAssessmentLevel(calculation.InputParameters, assessmentSection);

            CurrentCalculationType      = Resources.WaveImpactAsphaltCover_DisplayName;
            TotalWaterLevelCalculations = calculation.InputParameters.GetWaterLevels(assessmentLevel).Count();

            try
            {
                IEnumerable <WaveConditionsOutput> outputs = CalculateWaveConditions(calculation.InputParameters,
                                                                                     assessmentLevel,
                                                                                     a, b, c, targetProbability,
                                                                                     assessmentSection.HydraulicBoundaryDatabase);

                if (!Canceled)
                {
                    calculation.Output = new WaveImpactAsphaltCoverWaveConditionsOutput(outputs);
                }
            }
            finally
            {
                CalculationServiceHelper.LogCalculationEnd();
            }
        }
Ejemplo n.º 17
0
        public override IEnumerable <ExportInfo> GetExportInfos()
        {
            yield return(new ExportInfo <WaveImpactAsphaltCoverCalculationGroupContext>
            {
                Name = context => RiskeerCommonFormsResources.WaveConditionsExporter_DisplayName,
                Extension = RiskeerCommonFormsResources.DataTypeDisplayName_csv_file_filter_Extension,
                CreateFileExporter = (context, filePath) =>
                {
                    IEnumerable <WaveImpactAsphaltCoverWaveConditionsCalculation> calculations = context.WrappedData.GetCalculations().Cast <WaveImpactAsphaltCoverWaveConditionsCalculation>();
                    return new WaveImpactAsphaltCoverWaveConditionsExporter(calculations, filePath, input =>
                                                                            WaveConditionsInputHelper.GetTargetProbability(input, context.AssessmentSection)
                                                                            .ToString(CultureInfo.InvariantCulture));
                },
                IsEnabled = context => context.WrappedData.GetCalculations().Cast <WaveImpactAsphaltCoverWaveConditionsCalculation>().Any(c => c.HasOutput),
                GetExportPath = () => ExportHelper.GetFilePath(GetInquiryHelper(), GetWaveConditionsFileFilterGenerator())
            });

            yield return(new ExportInfo <WaveImpactAsphaltCoverWaveConditionsCalculationContext>
            {
                Name = context => RiskeerCommonFormsResources.WaveConditionsExporter_DisplayName,
                Extension = RiskeerCommonFormsResources.DataTypeDisplayName_csv_file_filter_Extension,
                CreateFileExporter = (context, filePath) => new WaveImpactAsphaltCoverWaveConditionsExporter(new[]
                {
                    context.WrappedData
                }, filePath,
                                                                                                             input =>
                                                                                                             WaveConditionsInputHelper.GetTargetProbability(input, context.AssessmentSection)
                                                                                                             .ToString(CultureInfo.InvariantCulture)),
                IsEnabled = context => context.WrappedData.HasOutput,
                GetExportPath = () => ExportHelper.GetFilePath(GetInquiryHelper(), GetWaveConditionsFileFilterGenerator())
            });

            yield return(RiskeerExportInfoFactory.CreateCalculationGroupConfigurationExportInfo <WaveImpactAsphaltCoverCalculationGroupContext>(
                             (context, filePath) => new WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationExporter(
                                 context.WrappedData.Children, filePath, context.AssessmentSection),
                             context => context.WrappedData.Children.Any(),
                             GetInquiryHelper()));

            yield return(RiskeerExportInfoFactory.CreateCalculationConfigurationExportInfo <WaveImpactAsphaltCoverWaveConditionsCalculationContext>(
                             (context, filePath) => new WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationExporter(
                                 new[]
            {
                context.WrappedData
            }, filePath, context.AssessmentSection),
                             GetInquiryHelper()));
        }
Ejemplo n.º 18
0
        /// <summary>
        /// Creates a calculation and sets the <paramref name="hydraulicBoundaryLocation"/>
        /// and the water level type on its input.
        /// </summary>
        /// <param name="hydraulicBoundaryLocation">The <see cref="HydraulicBoundaryLocation"/> to set.</param>
        /// <param name="calculations">The list of calculations to base the calculation name from.</param>
        /// <param name="normativeProbabilityType">The <see cref="NormativeProbabilityType"/> to base the water level type input on.</param>
        /// <returns>An <see cref="ICalculationBase"/> representing a stability stone cover calculation.</returns>
        /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="normativeProbabilityType"/> is an invalid value.</exception>
        /// <exception cref="NotSupportedException">Thrown when <paramref name="normativeProbabilityType"/> is a valid value,
        /// but unsupported.</exception>
        private static ICalculationBase CreateStabilityStoneCoverWaveConditionsCalculation(
            HydraulicBoundaryLocation hydraulicBoundaryLocation,
            IEnumerable <ICalculationBase> calculations,
            NormativeProbabilityType normativeProbabilityType)
        {
            string nameBase    = hydraulicBoundaryLocation.Name;
            var    calculation = new StabilityStoneCoverWaveConditionsCalculation
            {
                Name            = NamingHelper.GetUniqueName(calculations, nameBase, c => c.Name),
                InputParameters =
                {
                    HydraulicBoundaryLocation = hydraulicBoundaryLocation
                }
            };

            WaveConditionsInputHelper.SetWaterLevelType(calculation.InputParameters, normativeProbabilityType);
            return(calculation);
        }
        public void GetAssessmentLevel_InputWithInvalidWaterLevelType_ThrowsInvalidEnumArgumentException()
        {
            // Setup
            const WaveConditionsInputWaterLevelType waterLevelType = (WaveConditionsInputWaterLevelType)99;
            var waveConditionsInput = new WaveConditionsInput
            {
                WaterLevelType = waterLevelType
            };

            // Call
            void Call() => WaveConditionsInputHelper.GetAssessmentLevel(waveConditionsInput, new AssessmentSectionStub());

            // Assert
            var expectedMessage = $"The value of argument 'WaterLevelType' ({waterLevelType}) is invalid for Enum type '{nameof(WaveConditionsInputWaterLevelType)}'.";
            var exception       = TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(Call, expectedMessage);

            Assert.AreEqual("WaterLevelType", exception.ParamName);
        }
        public void GetTargetProbability_ValidInput_ReturnsExpectedValue(
            WaveConditionsInputWaterLevelType waterLevelType,
            Func <WaveConditionsInput, IAssessmentSection, double> getExpectedTargetProbability)
        {
            // Setup
            var assessmentSection = new AssessmentSectionStub();

            var input = new WaveConditionsInput
            {
                WaterLevelType = waterLevelType,
                CalculationsTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.01)
            };

            // Call
            double targetProbability = WaveConditionsInputHelper.GetTargetProbability(input, assessmentSection);

            // Assert
            Assert.AreEqual(getExpectedTargetProbability(input, assessmentSection), targetProbability);
        }
        public void GetAssessmentLevel_ValidInputWithoutHydraulicBoundaryLocation_ReturnsNaN(WaveConditionsInputWaterLevelType waterLevelType)
        {
            // Setup
            var assessmentSection = new AssessmentSectionStub();

            assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
            {
                new TestHydraulicBoundaryLocation()
            }, true);

            var input = new WaveConditionsInput
            {
                WaterLevelType = waterLevelType,
                CalculationsTargetProbability = assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.First()
            };

            // Call
            double assessmentLevel = WaveConditionsInputHelper.GetAssessmentLevel(input, assessmentSection);

            // Assert
            Assert.IsNaN(assessmentLevel);
        }
Ejemplo n.º 22
0
        /// <summary>
        /// Performs a wave conditions calculation for the stability of stone revetment failure mechanism based on the supplied
        /// <see cref="StabilityStoneCoverWaveConditionsCalculation"/>  and sets
        /// <see cref="StabilityStoneCoverWaveConditionsCalculation.Output"/> if the calculation was successful.
        /// Error and status information is logged during the execution of the operation.
        /// </summary>
        /// <param name="calculation">The <see cref="StabilityStoneCoverWaveConditionsCalculation"/> that holds all the information required to perform the calculation.</param>
        /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> that holds information about the target probability used in the calculation.</param>
        /// <param name="generalWaveConditionsInput">Calculation input parameters that apply to all <see cref="StabilityStoneCoverWaveConditionsCalculation"/> instances.</param>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/>, <paramref name="assessmentSection"/>
        /// or <paramref name="generalWaveConditionsInput"/> is <c>null</c>.</exception>
        /// <exception cref="ArgumentException">Thrown when the hydraulic boundary database file path contains invalid characters.</exception>
        /// <exception cref="CriticalFileReadException">Thrown when:
        /// <list type="bullet">
        /// <item>No settings database file could be found at the location of the hydraulic boundary database file path
        /// with the same name.</item>
        /// <item>Unable to open settings database file.</item>
        /// <item>Unable to read required data from database file.</item>
        /// </list>
        /// </exception>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when the target probability or
        /// calculated probability falls outside the [0.0, 1.0] range and is not <see cref="double.NaN"/>.</exception>
        /// <exception cref="HydraRingFileParserException">Thrown when an error occurs during parsing of the Hydra-Ring output.</exception>
        /// <exception cref="HydraRingCalculationException">Thrown when an error occurs during the calculation.</exception>
        public void Calculate(StabilityStoneCoverWaveConditionsCalculation calculation,
                              IAssessmentSection assessmentSection,
                              GeneralStabilityStoneCoverWaveConditionsInput generalWaveConditionsInput)
        {
            if (calculation == null)
            {
                throw new ArgumentNullException(nameof(calculation));
            }

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

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

            StabilityStoneCoverWaveConditionsInput           calculationInput = calculation.InputParameters;
            StabilityStoneCoverWaveConditionsCalculationType calculationType  = calculationInput.CalculationType;

            if (!Enum.IsDefined(typeof(StabilityStoneCoverWaveConditionsCalculationType), calculationType))
            {
                throw new InvalidEnumArgumentException(nameof(calculationType), (int)calculationType,
                                                       typeof(StabilityStoneCoverWaveConditionsCalculationType));
            }

            CalculationServiceHelper.LogCalculationBegin();

            double targetProbability = WaveConditionsInputHelper.GetTargetProbability(calculationInput, assessmentSection);

            RoundedDouble assessmentLevel = WaveConditionsInputHelper.GetAssessmentLevel(calculationInput, assessmentSection);

            int waterLevelCount = calculationInput.GetWaterLevels(assessmentLevel).Count();

            TotalWaterLevelCalculations = calculationType == StabilityStoneCoverWaveConditionsCalculationType.Both
                                              ? waterLevelCount * 2
                                              : waterLevelCount;

            try
            {
                IEnumerable <WaveConditionsOutput> blocksOutputs = null;
                if (calculationType == StabilityStoneCoverWaveConditionsCalculationType.Both ||
                    calculationType == StabilityStoneCoverWaveConditionsCalculationType.Blocks)
                {
                    CurrentCalculationType = Resources.StabilityStoneCoverWaveConditions_Blocks_DisplayName;
                    blocksOutputs          = CalculateBlocks(calculation, assessmentSection, assessmentLevel,
                                                             generalWaveConditionsInput.GeneralBlocksWaveConditionsInput, targetProbability);
                }

                if (Canceled)
                {
                    return;
                }

                IEnumerable <WaveConditionsOutput> columnsOutputs = null;
                if (calculationType == StabilityStoneCoverWaveConditionsCalculationType.Both ||
                    calculationType == StabilityStoneCoverWaveConditionsCalculationType.Columns)
                {
                    CurrentCalculationType = Resources.StabilityStoneCoverWaveConditions_Columns_DisplayName;
                    columnsOutputs         = CalculateColumns(calculation, assessmentSection, assessmentLevel,
                                                              generalWaveConditionsInput.GeneralColumnsWaveConditionsInput, targetProbability);
                }

                if (!Canceled)
                {
                    calculation.Output = CreateOutput(calculationType, blocksOutputs, columnsOutputs);
                }
            }
            finally
            {
                CalculationServiceHelper.LogCalculationEnd();
            }
        }
Ejemplo n.º 23
0
 protected override bool Validate()
 {
     return(WaveConditionsCalculationServiceBase.Validate(calculation.InputParameters,
                                                          WaveConditionsInputHelper.GetAssessmentLevel(calculation.InputParameters, assessmentSection),
                                                          assessmentSection.HydraulicBoundaryDatabase));
 }
Ejemplo n.º 24
0
        /// <summary>
        /// Performs a wave conditions calculation for the grass cover erosion outwards failure mechanism based on the supplied
        /// <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation"/> and sets
        /// <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation.Output"/> if the calculation was successful.
        /// Error and status information is logged during the execution of the operation.
        /// </summary>
        /// <param name="calculation">The <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation"/> that holds all the information required to perform the calculation.</param>
        /// <param name="failureMechanism">The grass cover erosion outwards failure mechanism, which contains general parameters that apply to all
        /// <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation"/> instances.</param>
        /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> that holds information about the target probability used in the calculation.</param>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/>, <paramref name="failureMechanism"/>
        /// or <paramref name="assessmentSection"/> is <c>null</c>.</exception>
        /// <exception cref="ArgumentException">Thrown when:
        /// <list type="bullet">
        /// <item>the hydraulic boundary database file path contains invalid characters.</item>
        /// <item><paramref name="failureMechanism"/> has no (0) contribution.</item>
        /// </list></exception>
        /// <exception cref="InvalidEnumArgumentException">Thrown when an unexpected
        /// enum value is encountered.</exception>
        /// <exception cref="CriticalFileReadException">Thrown when:
        /// <list type="bullet">
        /// <item>No settings database file could be found at the location of the hydraulic boundary database file path
        /// with the same name.</item>
        /// <item>Unable to open settings database file.</item>
        /// <item>Unable to read required data from database file.</item>
        /// </list>
        /// </exception>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when the target probability or
        /// calculated probability falls outside the [0.0, 1.0] range and is not <see cref="double.NaN"/>.</exception>
        /// <exception cref="HydraRingFileParserException">Thrown when an error occurs during parsing of the Hydra-Ring output.</exception>
        /// <exception cref="HydraRingCalculationException">Thrown when an error occurs during the calculation.</exception>
        /// <exception cref="NotSupportedException">Thrown when <see cref="GrassCoverErosionOutwardsWaveConditionsCalculationType"/>
        /// is a valid value, but unsupported.</exception>
        public void Calculate(GrassCoverErosionOutwardsWaveConditionsCalculation calculation,
                              GrassCoverErosionOutwardsFailureMechanism failureMechanism,
                              IAssessmentSection assessmentSection)
        {
            if (calculation == null)
            {
                throw new ArgumentNullException(nameof(calculation));
            }

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

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

            GrassCoverErosionOutwardsWaveConditionsInput           calculationInput = calculation.InputParameters;
            GrassCoverErosionOutwardsWaveConditionsCalculationType calculationType  = calculationInput.CalculationType;

            if (!Enum.IsDefined(typeof(GrassCoverErosionOutwardsWaveConditionsCalculationType), calculationType))
            {
                throw new InvalidEnumArgumentException(nameof(calculationType), (int)calculationType,
                                                       typeof(GrassCoverErosionOutwardsWaveConditionsCalculationType));
            }

            CalculationServiceHelper.LogCalculationBegin();

            RoundedDouble assessmentLevel = WaveConditionsInputHelper.GetAssessmentLevel(calculationInput, assessmentSection);

            double targetProbability = WaveConditionsInputHelper.GetTargetProbability(calculationInput, assessmentSection);

            HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;

            DetermineTotalWaterLevelCalculations(calculationInput, assessmentLevel);

            try
            {
                IEnumerable <WaveConditionsOutput> waveRunUpOutput = null;
                if (ShouldCalculateWaveRunUp(calculationType))
                {
                    CurrentCalculationType = Resources.GrassCoverErosionOutwardsWaveConditions_WaveRunUp_DisplayName;
                    waveRunUpOutput        = CalculateWaveRunUp(calculation, failureMechanism, hydraulicBoundaryDatabase, assessmentLevel, targetProbability);
                }

                if (Canceled)
                {
                    return;
                }

                IEnumerable <WaveConditionsOutput> waveImpactOutput = null;
                if (ShouldCalculateWaveImpact(calculationType))
                {
                    CurrentCalculationType = Resources.GrassCoverErosionOutwardsWaveConditions_WaveImpact_DisplayName;
                    waveImpactOutput       = CalculateWaveImpact(calculation, failureMechanism, hydraulicBoundaryDatabase, assessmentLevel, targetProbability);
                }

                IEnumerable <WaveConditionsOutput> waveImpactWithWaveDirectionOutput = null;
                if (ShouldCalculateWaveImpactWithWaveDirection(calculationType))
                {
                    CurrentCalculationType            = Resources.GrassCoverErosionOutwardsWaveConditions_WaveImpactWithWaveDirection_DisplayName;
                    waveImpactWithWaveDirectionOutput = CalculateWaveImpactWithWaveDirection(calculation, failureMechanism, hydraulicBoundaryDatabase, assessmentLevel, targetProbability);
                }

                if (!Canceled)
                {
                    calculation.Output = CreateOutput(calculationType, waveRunUpOutput, waveImpactOutput, waveImpactWithWaveDirectionOutput);
                }
            }
            finally
            {
                CalculationServiceHelper.LogCalculationEnd();
            }
        }
Ejemplo n.º 25
0
 private static IEnumerable <RoundedDouble> GetWaterLevels(StabilityStoneCoverWaveConditionsCalculation calculation, IAssessmentSection assessmentSection)
 {
     return(calculation.InputParameters.GetWaterLevels(WaveConditionsInputHelper.GetAssessmentLevel(calculation.InputParameters, assessmentSection)));
 }
 private static IEnumerable <RoundedDouble> GetWaterLevels(GrassCoverErosionOutwardsWaveConditionsCalculation calculation,
                                                           IAssessmentSection assessmentSection)
 {
     return(calculation.InputParameters.GetWaterLevels(WaveConditionsInputHelper.GetAssessmentLevel(calculation.InputParameters, assessmentSection)));
 }