Index: Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy.cs =================================================================== diff -u --- Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy.cs (revision 0) +++ Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy.cs (revision ed6da521af434bc10b0645b455744a7ab642c9f9) @@ -0,0 +1,79 @@ +// Copyright (C) Stichting Deltares 2021. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using System.Collections.Generic; +using Riskeer.Common.Data.FailureMechanism; + +namespace Riskeer.GrassCoverErosionInwards.Data +{ + /// + /// Strategy to calculate probabilities for . + /// + public class GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy : IFailureMechanismSectionResultCalculateProbabilityStrategy + { + private readonly AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult; + private readonly IEnumerable calculationScenarios; + private readonly GrassCoverErosionInwardsFailureMechanism failureMechanism; + + /// + /// Creates a new instance of . + /// + /// The to get the probabilities for. + /// All the of the failure mechanism. + /// The failure mechanism the calculation scenarios belong to. + /// Thrown when any parameter is null. + public GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy( + AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult, + IEnumerable calculationScenarios, + GrassCoverErosionInwardsFailureMechanism failureMechanism) + { + if (sectionResult == null) + { + throw new ArgumentNullException(nameof(sectionResult)); + } + + if (calculationScenarios == null) + { + throw new ArgumentNullException(nameof(calculationScenarios)); + } + + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + this.sectionResult = sectionResult; + this.calculationScenarios = calculationScenarios; + this.failureMechanism = failureMechanism; + } + + public double CalculateProfileProbability() + { + return sectionResult.GetInitialFailureMechanismResultProbability(calculationScenarios); + } + + public double CalculateSectionProbability() + { + return CalculateProfileProbability() * failureMechanism.GeneralInput.N; + } + } +} \ No newline at end of file Index: Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Data.Test/GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs =================================================================== diff -u --- Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Data.Test/GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs (revision 0) +++ Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Data.Test/GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs (revision ed6da521af434bc10b0645b455744a7ab642c9f9) @@ -0,0 +1,205 @@ +// Copyright (C) Stichting Deltares 2021. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using System.Linq; +using Core.Common.Base.Data; +using NUnit.Framework; +using Riskeer.Common.Data.FailureMechanism; +using Riskeer.Common.Data.TestUtil; +using Riskeer.GrassCoverErosionInwards.Data.TestUtil; + +namespace Riskeer.GrassCoverErosionInwards.Data.Test +{ + [TestFixture] + public class GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategyTest + { + [Test] + public void Constructor_SectionResultNull_ThrowsArgumentNullException() + { + // Call + void Call() => new GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy( + null, Enumerable.Empty(), new GrassCoverErosionInwardsFailureMechanism()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("sectionResult", exception.ParamName); + } + + [Test] + public void Constructor_CalculationScenariosNull_ThrowsArgumentNullException() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + + // Call + void Call() => new GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy( + new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section), null, new GrassCoverErosionInwardsFailureMechanism()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("calculationScenarios", exception.ParamName); + } + + [Test] + public void Constructor_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + + // Call + void Call() => new GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy( + new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section), + Enumerable.Empty(), null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanism", exception.ParamName); + } + + [Test] + public void Constructor_ExpectedValues() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + + // Call + var strategy = new GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy( + new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section), Enumerable.Empty(), + new GrassCoverErosionInwardsFailureMechanism()); + + // Assert + Assert.IsInstanceOf(strategy); + } + + [Test] + public void CalculateProfileProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section); + + GrassCoverErosionInwardsCalculationScenario calculationScenario1 = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateGrassCoverErosionInwardsCalculationScenario(section); + GrassCoverErosionInwardsCalculationScenario calculationScenario2 = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateGrassCoverErosionInwardsCalculationScenario(section); + GrassCoverErosionInwardsCalculationScenario calculationScenario3 = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateGrassCoverErosionInwardsCalculationScenario(section); + + calculationScenario1.IsRelevant = true; + calculationScenario1.Contribution = (RoundedDouble) 0.2111; + calculationScenario1.Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(1.1), null, null); + + calculationScenario2.IsRelevant = true; + calculationScenario2.Contribution = (RoundedDouble) 0.7889; + calculationScenario1.Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(2.2), null, null); + + calculationScenario3.IsRelevant = false; + + GrassCoverErosionInwardsCalculationScenario[] calculationScenarios = + { + calculationScenario1, + calculationScenario2, + calculationScenario3 + }; + + var strategy = new GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy( + sectionResult, calculationScenarios, new GrassCoverErosionInwardsFailureMechanism()); + + // Call + double profileProbability = strategy.CalculateProfileProbability(); + + // Assert + Assert.AreEqual(0.3973850177700996, profileProbability); + } + + [Test] + public void CalculateProfileProbability_NoScenarios_ReturnsNaN() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section); + + var strategy = new GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy( + sectionResult, Enumerable.Empty(), + new GrassCoverErosionInwardsFailureMechanism()); + + // Call + double profileProbability = strategy.CalculateProfileProbability(); + + // Assert + Assert.IsNaN(profileProbability); + } + + [Test] + public void CalculateSectionProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section); + + GrassCoverErosionInwardsCalculationScenario calculationScenario1 = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateGrassCoverErosionInwardsCalculationScenario(section); + GrassCoverErosionInwardsCalculationScenario calculationScenario2 = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateGrassCoverErosionInwardsCalculationScenario(section); + GrassCoverErosionInwardsCalculationScenario calculationScenario3 = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateGrassCoverErosionInwardsCalculationScenario(section); + + calculationScenario1.IsRelevant = true; + calculationScenario1.Contribution = (RoundedDouble) 0.2111; + calculationScenario1.Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(1.1), null, null); + + calculationScenario2.IsRelevant = true; + calculationScenario2.Contribution = (RoundedDouble) 0.7889; + calculationScenario1.Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(2.2), null, null); + + calculationScenario3.IsRelevant = false; + + GrassCoverErosionInwardsCalculationScenario[] calculationScenarios = + { + calculationScenario1, + calculationScenario2, + calculationScenario3 + }; + + var strategy = new GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy( + sectionResult, calculationScenarios, new GrassCoverErosionInwardsFailureMechanism()); + + // Call + double sectionProbability = strategy.CalculateSectionProbability(); + + // Assert + Assert.AreEqual(0.79, sectionProbability); + } + + [Test] + public void CalculateSectionProbability_NoScenarios_ReturnsNaN() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section); + + var strategy = new GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy( + sectionResult, Enumerable.Empty(), + new GrassCoverErosionInwardsFailureMechanism()); + + // Call + double sectionProbability = strategy.CalculateSectionProbability(); + + // Assert + Assert.IsNaN(sectionProbability); + } + } +} \ No newline at end of file Index: Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.Data.Test/MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs =================================================================== diff -u -r4c5b838896048250be3167fdf0fe6ed8b89c328e -red6da521af434bc10b0645b455744a7ab642c9f9 --- Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.Data.Test/MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs (.../MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs) (revision 4c5b838896048250be3167fdf0fe6ed8b89c328e) +++ Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.Data.Test/MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs (.../MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategyTest.cs) (revision ed6da521af434bc10b0645b455744a7ab642c9f9) @@ -176,10 +176,10 @@ sectionResult, calculations, new MacroStabilityInwardsFailureMechanism()); // Call - double profileProbability = strategy.CalculateSectionProbability(); + double sectionProbability = strategy.CalculateSectionProbability(); // Assert - Assert.AreEqual(0.99078184, profileProbability, 1e-8); + Assert.AreEqual(0.99078184, sectionProbability, 1e-8); } [Test]