Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Plugin/GrassCoverErosionInwardsGuiPlugin.cs
===================================================================
diff -u -r55e027f1f3573d97603297411504f2714e9819b1 -rb0341753cd4f8a71d8254bdd00e0555e957879c7
--- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Plugin/GrassCoverErosionInwardsGuiPlugin.cs	(.../GrassCoverErosionInwardsGuiPlugin.cs)	(revision 55e027f1f3573d97603297411504f2714e9819b1)
+++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Plugin/GrassCoverErosionInwardsGuiPlugin.cs	(.../GrassCoverErosionInwardsGuiPlugin.cs)	(revision b0341753cd4f8a71d8254bdd00e0555e957879c7)
@@ -151,7 +151,7 @@
         private static ExceedanceProbabilityCalculationActivity CreateHydraRingTargetProbabilityCalculationActivity(FailureMechanismSection failureMechanismSection,
                                                                                                                     string hlcdDirectory,
                                                                                                                     GrassCoverErosionInwardsCalculation calculation,
-                                                                                                                    double norm)
+                                                                                                                    double norm, double contribution)
         {
             var hydraulicBoundaryLocationId = (int) calculation.InputParameters.HydraulicBoundaryLocation.Id;
             var sectionLength = failureMechanismSection.GetSectionLength();
@@ -178,7 +178,7 @@
                                                 ParseBreakWater(inwardsInput)
                     ),
                 calculation.ClearOutput,
-                output => { ParseHydraRingOutput(calculation, norm, output); });
+                output => { ParseHydraRingOutput(calculation, norm, contribution, output); });
         }
 
         private static HydraRingBreakWater ParseBreakWater(GrassCoverErosionInwardsInput input)
@@ -219,11 +219,11 @@
             }
         }
 
-        private static void ParseHydraRingOutput(GrassCoverErosionInwardsCalculation calculation, double norm, ExceedanceProbabilityCalculationOutput output)
+        private static void ParseHydraRingOutput(GrassCoverErosionInwardsCalculation calculation, double norm, double contribution, ExceedanceProbabilityCalculationOutput output)
         {
             if (output != null)
             {
-                GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, norm, output.Beta);
+                GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, norm, contribution, output.Beta);
                 calculation.NotifyObservers();
             }
             else
@@ -240,7 +240,9 @@
                                                                              failureMechanism.Sections.First(), // TODO: Pass dike section based on cross section of calculation with reference line
                                                                              Path.GetDirectoryName(assessmentSection.HydraulicBoundaryDatabase.FilePath),
                                                                              calc,
-                                                                             assessmentSection.FailureMechanismContribution.Norm)).ToList());
+                                                                             assessmentSection.FailureMechanismContribution.Norm,
+                                                                             failureMechanism.Contribution
+                                                                                             )).ToList());
         }
 
         private static string AllDataAvailable(IAssessmentSection assessmentSection, GrassCoverErosionInwardsFailureMechanism failureMechanism)
@@ -284,7 +286,7 @@
             {
                 failureMechanism = failureMechanismContext.WrappedData;
             }
-            return failureMechanism != null && ReferenceEquals(view.Data, ((GrassCoverErosionInwardsFailureMechanism)failureMechanism).SectionResults);
+            return failureMechanism != null && ReferenceEquals(view.Data, ((GrassCoverErosionInwardsFailureMechanism) failureMechanism).SectionResults);
         }
 
         #endregion
@@ -537,7 +539,8 @@
                 context.FailureMechanism.Sections.First(), // TODO: Pass dike section based on cross section of calculation with reference line
                 Path.GetDirectoryName(context.AssessmentSection.HydraulicBoundaryDatabase.FilePath),
                 calculation,
-                context.AssessmentSection.FailureMechanismContribution.Norm);
+                context.AssessmentSection.FailureMechanismContribution.Norm,
+                context.FailureMechanism.Contribution);
 
             ActivityProgressDialogRunner.Run(Gui.MainWindow, activity);
         }
Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsOutputCalculationService.cs
===================================================================
diff -u -r1f2fbaa211ff678a1171a5c0a67e9a94c350eab5 -rb0341753cd4f8a71d8254bdd00e0555e957879c7
--- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsOutputCalculationService.cs	(.../GrassCoverErosionInwardsOutputCalculationService.cs)	(revision 1f2fbaa211ff678a1171a5c0a67e9a94c350eab5)
+++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsOutputCalculationService.cs	(.../GrassCoverErosionInwardsOutputCalculationService.cs)	(revision b0341753cd4f8a71d8254bdd00e0555e957879c7)
@@ -21,7 +21,9 @@
 
 using System;
 using MathNet.Numerics.Distributions;
+using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.GrassCoverErosionInwards.Data;
+using Ringtoets.Integration.Data;
 
 namespace Ringtoets.GrassCoverErosionInwards.Service
 {
@@ -32,20 +34,22 @@
     {
         // Inputs
         private readonly double norm;
+        private readonly double contribution;
         private readonly int lengthEffectN;
         private readonly double probability;
 
         // Results
         private double requiredProbability;
-        private double pTCrossAllowed;
-        private double pTCrossGrassCoverErosionInwards;
+        private double allowedCrossSectionProbability;
+        private double grassCoverErosionInwardsCrossSectionProbability;
         private double requiredReliability;
         private double reliability;
         private double factorOfSafety;
 
-        private GrassCoverErosionInwardsOutputCalculationService(double norm, int lengthEffectN, double probability)
+        private GrassCoverErosionInwardsOutputCalculationService(double norm, double contribution, int lengthEffectN, double probability)
         {
             this.norm = norm;
+            this.contribution = contribution/100;
             this.lengthEffectN = lengthEffectN;
             this.probability = probability;
         }
@@ -54,16 +58,17 @@
         /// Calculates the <see cref="GrassCoverErosionInwardsOutput"/> given the <paramref name="calculation"/>, <paramref name="norm"/>, and <paramref name="probability"/>.
         /// </summary>
         /// <param name="calculation">The calculation which is used.</param>
-        /// <param name="norm">The norm which has been defined on the assessment section.</param>
+        /// <param name="contribution">The amount of contribution as a percentage [0-100] for the <see cref="IFailureMechanism"/> as part of the overall verdict. </param>
+        /// <param name="norm">The norm which has been defined on the <see cref="AssessmentSection"/>.</param>
         /// <param name="probability">The probability result.</param>
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/> is <c>null</c>.</exception>
-        public static void Calculate(GrassCoverErosionInwardsCalculation calculation, double norm, double probability)
+        public static void Calculate(GrassCoverErosionInwardsCalculation calculation, double norm, double contribution, double probability)
         {
             if (calculation == null)
             {
                 throw new ArgumentNullException("calculation");
             }
-            var calculator = new GrassCoverErosionInwardsOutputCalculationService(norm, calculation.NormProbabilityInput.N, probability);
+            var calculator = new GrassCoverErosionInwardsOutputCalculationService(norm, contribution, calculation.NormProbabilityInput.N, probability);
 
             calculator.Calculate();
 
@@ -86,48 +91,38 @@
         private void CalculateReliability()
         {
             requiredProbability = RequiredProbability(norm);
-            pTCrossAllowed = PtCrossAllowed(probability, norm, lengthEffectN);
-            pTCrossGrassCoverErosionInwards = PtCrossGrassCoverErosionInwards();
+            allowedCrossSectionProbability = AllowedCrossSectionProbability(contribution, norm, lengthEffectN);
+            grassCoverErosionInwardsCrossSectionProbability = probability;
         }
 
         private void CalculateRequiredReliability()
         {
-            requiredReliability = RequiredReliability(pTCrossAllowed);
-            reliability = Reliability(pTCrossGrassCoverErosionInwards);
+            requiredReliability = RequiredReliability(allowedCrossSectionProbability);
+            reliability = grassCoverErosionInwardsCrossSectionProbability;
         }
 
         #region Sub calculations
 
-        private static double RequiredProbability(double contribution)
+        private static double RequiredProbability(double norm)
         {
-            return new Normal().InverseCumulativeDistribution(1 - 1.0/contribution);
+            return new Normal().InverseCumulativeDistribution(1 - 1.0/norm);
         }
 
-        private static double PtCrossAllowed(double probability, double contribution, double n)
+        private static double AllowedCrossSectionProbability(double probability, double contribution, double factorN)
         {
-            return probability*(1.0/contribution)/n;
+            return probability*(1.0/contribution)/factorN;
         }
 
-        private static double PtCrossGrassCoverErosionInwards()
+        private static double RequiredReliability(double allowedCrossSectionProbability)
         {
-            return 1.0/50000;
+            return new Normal().InverseCumulativeDistribution(1 - allowedCrossSectionProbability);
         }
 
-        private static double RequiredReliability(double pTCrossAllowed)
+        private static double FactorOfSafety(double reliability, double requiredReliability)
         {
-            return new Normal().InverseCumulativeDistribution(1 - pTCrossAllowed);
+            return reliability/requiredReliability;
         }
 
-        private static double Reliability(double pTCross)
-        {
-            return new Normal().InverseCumulativeDistribution(1 - pTCross);
-        }
-
-        private static double FactorOfSafety(double betaCrossGekb, double betaCrossAllowed)
-        {
-            return betaCrossGekb/betaCrossAllowed;
-        }
-
         #endregion
     }
 }
\ No newline at end of file
Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/Ringtoets.GrassCoverErosionInwards.Service.csproj
===================================================================
diff -u -ra053684de9667dfb70aa8cf669e22843c2bd39ed -rb0341753cd4f8a71d8254bdd00e0555e957879c7
--- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/Ringtoets.GrassCoverErosionInwards.Service.csproj	(.../Ringtoets.GrassCoverErosionInwards.Service.csproj)	(revision a053684de9667dfb70aa8cf669e22843c2bd39ed)
+++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/Ringtoets.GrassCoverErosionInwards.Service.csproj	(.../Ringtoets.GrassCoverErosionInwards.Service.csproj)	(revision b0341753cd4f8a71d8254bdd00e0555e957879c7)
@@ -73,6 +73,11 @@
       <Name>Ringtoets.Common.Data</Name>
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\Integration\src\Ringtoets.Integration.Data\Ringtoets.Integration.Data.csproj">
+      <Project>{11F1F874-45AF-43E4-8AE5-15A5C9593E28}</Project>
+      <Name>Ringtoets.Integration.Data</Name>
+      <Private>False</Private>
+    </ProjectReference>
     <ProjectReference Include="..\Ringtoets.GrassCoverErosionInwards.Data\Ringtoets.GrassCoverErosionInwards.Data.csproj">
       <Project>{90DE728E-48EF-4665-AB38-3D88E41D9F4D}</Project>
       <Name>Ringtoets.GrassCoverErosionInwards.Data</Name>
Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsOutputCalculationServiceTest.cs
===================================================================
diff -u -r1f2fbaa211ff678a1171a5c0a67e9a94c350eab5 -rb0341753cd4f8a71d8254bdd00e0555e957879c7
--- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsOutputCalculationServiceTest.cs	(.../GrassCoverErosionInwardsOutputCalculationServiceTest.cs)	(revision 1f2fbaa211ff678a1171a5c0a67e9a94c350eab5)
+++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsOutputCalculationServiceTest.cs	(.../GrassCoverErosionInwardsOutputCalculationServiceTest.cs)	(revision b0341753cd4f8a71d8254bdd00e0555e957879c7)
@@ -35,7 +35,7 @@
         public void Calculate_NullCalculation_ThrowsArgumentNullException()
         {
             // Setup & Call
-            TestDelegate test = () => GrassCoverErosionInwardsOutputCalculationService.Calculate(null, 0, 1);
+            TestDelegate test = () => GrassCoverErosionInwardsOutputCalculationService.Calculate(null, double.NaN, double.NaN, double.NaN);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(test);
@@ -52,62 +52,85 @@
                                                                       new GeneralNormProbabilityInput());
 
             // Call
-            GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, norm, double.NaN);
+            GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, norm, double.NaN, double.NaN);
 
             // Assert
             RoundedDouble output = calculation.Output.RequiredProbability;
             Assert.AreEqual(expectedResult, output, output.GetAccuracy());
         }
 
         [Test]
-        [TestCase(30000, 1, 4.149409984)]
-        [TestCase(30000, 0.24, 4.465183916)]
-        [TestCase(20000, 1, 4.055626981)]
-        [TestCase(20000, 0.24, 4.377587847)]
-        public void RequiredReliability_DifferentInputs_ReturnsExpectedValue(int norm, double probability, double expectedResult)
+        [TestCase(30000, 100, 4.149409984)]
+        [TestCase(30000, 24, 4.465183916)]
+        [TestCase(20000, 100, 4.055626981)]
+        [TestCase(20000, 24, 4.377587847)]
+        public void RequiredReliability_DifferentInputs_ReturnsExpectedValue(int norm, double contribution, double expectedResult)
         {
             // Setup
             var calculation = new GrassCoverErosionInwardsCalculation(new GeneralGrassCoverErosionInwardsInput(),
                                                                       new GeneralNormProbabilityInput());
 
             // Call
-            GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, norm, probability);
+            GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, norm, contribution, double.NaN);
 
             // Assert
             RoundedDouble output = calculation.Output.RequiredReliability;
             Assert.AreEqual(expectedResult, output, output.GetAccuracy());
         }
 
         [Test]
-        public void Reliability_DifferentInputs_ReturnsExpectedValue()
+        [TestCase(1.23456, 1.23456)]
+        [TestCase(789.123, 789.123)]
+        public void Reliability_DifferentInputs_ReturnsExpectedValue(double probability, double expectedResult)
         {
             // Setup
             var calculation = new GrassCoverErosionInwardsCalculation(new GeneralGrassCoverErosionInwardsInput(),
                                                                       new GeneralNormProbabilityInput());
 
             // Call
-            GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, double.NaN, double.NaN);
+            GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, double.NaN, double.NaN, probability);
 
             // Assert
             RoundedDouble output = calculation.Output.Reliability;
-            Assert.AreEqual(4.107479655, output, output.GetAccuracy());
+            Assert.AreEqual(expectedResult, output, output.GetAccuracy());
         }
 
         [Test]
-        [TestCase(30000, 1, 0.989894869)]
-        [TestCase(30000, 0.24, 0.919890363)]
-        [TestCase(20000, 1, 1.012785366)]
-        [TestCase(20000, 0.24, 0.938297482)]
-        public void FactorOfSafety_DifferentInputs_ReturnsExpectedValue(int norm, double probability, double expectedResult)
+        [TestCase(1, 1)]
+        [TestCase(60000, 60000)]
+        public void Probability_Always_ReturnsExpectedValue(double probability, double expectedResult)
         {
             // Setup
             var calculation = new GrassCoverErosionInwardsCalculation(new GeneralGrassCoverErosionInwardsInput(),
                                                                       new GeneralNormProbabilityInput());
 
             // Call
-            GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, norm, probability);
+            GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, double.NaN, double.NaN, probability);
 
             // Assert
+            RoundedDouble output = calculation.Output.Probability;
+            Assert.AreEqual(expectedResult, output, output.GetAccuracy());
+        }
+
+        [Test]
+        [TestCase(30000, 100, 4.107479655, 0.989894869)]
+        [TestCase(30000, 100, 4.149409984, 1)]
+        [TestCase(30000, 24, 4.107479655, 0.919890363)]
+        [TestCase(30000, 24, 4.149409984, 0.929280868)]
+        [TestCase(20000, 100, 4.107479655, 1.012785366)]
+        [TestCase(20000, 100, 4.149409984, 1.023124169)]
+        [TestCase(20000, 24, 4.107479655, 0.938297482)]
+        [TestCase(20000, 24, 4.149409984, 0.947875892)]
+        public void FactorOfSafety_DifferentInputs_ReturnsExpectedValue(int norm, double contribution, double probability, double expectedResult)
+        {
+            // Setup
+            var calculation = new GrassCoverErosionInwardsCalculation(new GeneralGrassCoverErosionInwardsInput(),
+                                                                      new GeneralNormProbabilityInput());
+
+            // Call
+            GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, norm, contribution, probability);
+
+            // Assert
             RoundedDouble output = calculation.Output.FactorOfSafety;
             Assert.AreEqual(expectedResult, output, output.GetAccuracy());
         }