Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Plugin/GrassCoverErosionInwardsGuiPlugin.cs
===================================================================
diff -u -ra053684de9667dfb70aa8cf669e22843c2bd39ed -r1f2fbaa211ff678a1171a5c0a67e9a94c350eab5
--- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Plugin/GrassCoverErosionInwardsGuiPlugin.cs	(.../GrassCoverErosionInwardsGuiPlugin.cs)	(revision a053684de9667dfb70aa8cf669e22843c2bd39ed)
+++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Plugin/GrassCoverErosionInwardsGuiPlugin.cs	(.../GrassCoverErosionInwardsGuiPlugin.cs)	(revision 1f2fbaa211ff678a1171a5c0a67e9a94c350eab5)
@@ -207,11 +207,11 @@
             }
         }
 
-        private static void ParseHydraRingOutput(GrassCoverErosionInwardsCalculation calculation, double contribution, ExceedanceProbabilityCalculationOutput output)
+        private static void ParseHydraRingOutput(GrassCoverErosionInwardsCalculation calculation, double norm, ExceedanceProbabilityCalculationOutput output)
         {
             if (output != null)
             {
-                GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, contribution, output.Beta);
+                GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, norm, output.Beta);
             }
             else
             {
Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsOutputCalculationService.cs
===================================================================
diff -u -ra053684de9667dfb70aa8cf669e22843c2bd39ed -r1f2fbaa211ff678a1171a5c0a67e9a94c350eab5
--- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsOutputCalculationService.cs	(.../GrassCoverErosionInwardsOutputCalculationService.cs)	(revision a053684de9667dfb70aa8cf669e22843c2bd39ed)
+++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsOutputCalculationService.cs	(.../GrassCoverErosionInwardsOutputCalculationService.cs)	(revision 1f2fbaa211ff678a1171a5c0a67e9a94c350eab5)
@@ -19,6 +19,7 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
+using System;
 using MathNet.Numerics.Distributions;
 using Ringtoets.GrassCoverErosionInwards.Data;
 
@@ -35,9 +36,9 @@
         private readonly double probability;
 
         // Results
-        private double betaTrajectNorm;
+        private double requiredProbability;
         private double pTCrossAllowed;
-        private double pTCrossGEKB;
+        private double pTCrossGrassCoverErosionInwards;
         private double requiredReliability;
         private double reliability;
         private double factorOfSafety;
@@ -50,18 +51,23 @@
         }
 
         /// <summary>
-        /// Calculates 
+        /// Calculates the <see cref="GrassCoverErosionInwardsOutput"/> given the <paramref name="calculation"/>, <paramref name="norm"/>, and <paramref name="probability"/>.
         /// </summary>
-        /// <param name="calculation"></param>
-        /// <param name="norm"></param>
-        /// <param name="probability"></param>
+        /// <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="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)
         {
+            if (calculation == null)
+            {
+                throw new ArgumentNullException("calculation");
+            }
             var calculator = new GrassCoverErosionInwardsOutputCalculationService(norm, calculation.NormProbabilityInput.N, probability);
 
             calculator.Calculate();
 
-            calculation.Output = new GrassCoverErosionInwardsOutput(calculator.betaTrajectNorm,
+            calculation.Output = new GrassCoverErosionInwardsOutput(calculator.requiredProbability,
                                                                     calculator.requiredReliability,
                                                                     calculator.probability,
                                                                     calculator.reliability,
@@ -79,42 +85,42 @@
 
         private void CalculateReliability()
         {
-            betaTrajectNorm = BetaTrajectNorm(norm);
-            pTCrossAllowed = PTCrossAllowed(probability, norm, lengthEffectN);
-            pTCrossGEKB = PTCrossGEKB();
+            requiredProbability = RequiredProbability(norm);
+            pTCrossAllowed = PtCrossAllowed(probability, norm, lengthEffectN);
+            pTCrossGrassCoverErosionInwards = PtCrossGrassCoverErosionInwards();
         }
 
         private void CalculateRequiredReliability()
         {
-            requiredReliability = BetaCrossAllowed(pTCrossAllowed);
-            reliability = BetaCrossGEKB(pTCrossGEKB);
+            requiredReliability = RequiredReliability(pTCrossAllowed);
+            reliability = Reliability(pTCrossGrassCoverErosionInwards);
         }
 
         #region Sub calculations
 
-        private static double BetaTrajectNorm(double contribution)
+        private static double RequiredProbability(double contribution)
         {
             return new Normal().InverseCumulativeDistribution(1 - 1.0/contribution);
         }
 
-        private static double PTCrossAllowed(double probability, double contribution, double n)
+        private static double PtCrossAllowed(double probability, double contribution, double n)
         {
             return probability*(1.0/contribution)/n;
         }
 
-        private static double PTCrossGEKB()
+        private static double PtCrossGrassCoverErosionInwards()
         {
             return 1.0/50000;
         }
 
-        private static double BetaCrossAllowed(double pTCrossAllowed)
+        private static double RequiredReliability(double pTCrossAllowed)
         {
             return new Normal().InverseCumulativeDistribution(1 - pTCrossAllowed);
         }
 
-        private static double BetaCrossGEKB(double pTCrossGEKB)
+        private static double Reliability(double pTCross)
         {
-            return new Normal().InverseCumulativeDistribution(1 - pTCrossGEKB);
+            return new Normal().InverseCumulativeDistribution(1 - pTCross);
         }
 
         private static double FactorOfSafety(double betaCrossGekb, double betaCrossAllowed)
Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsOutputCalculationServiceTest.cs
===================================================================
diff -u -rc196992ccccf32ce0fd55b83a17e3f3574467a1e -r1f2fbaa211ff678a1171a5c0a67e9a94c350eab5
--- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsOutputCalculationServiceTest.cs	(.../GrassCoverErosionInwardsOutputCalculationServiceTest.cs)	(revision c196992ccccf32ce0fd55b83a17e3f3574467a1e)
+++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsOutputCalculationServiceTest.cs	(.../GrassCoverErosionInwardsOutputCalculationServiceTest.cs)	(revision 1f2fbaa211ff678a1171a5c0a67e9a94c350eab5)
@@ -19,6 +19,8 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
+using System;
+using Core.Common.Base.Data;
 using NUnit.Framework;
 using Ringtoets.Common.Data.Calculation;
 using Ringtoets.Common.Data.TestUtil;
@@ -30,24 +32,84 @@
     public class GrassCoverErosionInwardsOutputCalculationServiceTest
     {
         [Test]
-        public void Calculate_CompleteInput_ReturnsGrassCoverErosionInwardsOutputWithValues()
+        public void Calculate_NullCalculation_ThrowsArgumentNullException()
         {
+            // Setup & Call
+            TestDelegate test = () => GrassCoverErosionInwardsOutputCalculationService.Calculate(null, 0, 1);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(test);
+            Assert.AreEqual("calculation", exception.ParamName);
+        }
+
+        [Test]
+        [TestCase(30000, 3.98787893661)]
+        [TestCase(20000, 3.89059188641)]
+        public void RequiredProbability_DifferentInputs_ReturnsExpectedValue(int norm, double expectedResult)
+        {
             // Setup
-            const int norm = 30000;
-            const double probability = 0.24;
             var calculation = new GrassCoverErosionInwardsCalculation(new GeneralGrassCoverErosionInwardsInput(),
                                                                       new GeneralNormProbabilityInput());
 
             // Call
+            GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, norm, 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)
+        {
+            // Setup
+            var calculation = new GrassCoverErosionInwardsCalculation(new GeneralGrassCoverErosionInwardsInput(),
+                                                                      new GeneralNormProbabilityInput());
+
+            // Call
             GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, norm, probability);
 
             // Assert
-            GrassCoverErosionInwardsOutput output = calculation.Output;
-            Assert.AreEqual(0.9199, output.FactorOfSafety, output.FactorOfSafety.GetAccuracy());
-            Assert.AreEqual(probability, output.Probability, output.Probability.GetAccuracy());
-            Assert.AreEqual(4.107, output.Reliability, output.Reliability.GetAccuracy());
-            Assert.AreEqual(3.99, output.RequiredProbability, output.RequiredProbability.GetAccuracy());
-            Assert.AreEqual(4.465, output.RequiredReliability, output.RequiredReliability.GetAccuracy());
+            RoundedDouble output = calculation.Output.RequiredReliability;
+            Assert.AreEqual(expectedResult, output, output.GetAccuracy());
         }
+
+        [Test]
+        public void Reliability_DifferentInputs_ReturnsExpectedValue()
+        {
+            // Setup
+            var calculation = new GrassCoverErosionInwardsCalculation(new GeneralGrassCoverErosionInwardsInput(),
+                                                                      new GeneralNormProbabilityInput());
+
+            // Call
+            GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, double.NaN, double.NaN);
+
+            // Assert
+            RoundedDouble output = calculation.Output.Reliability;
+            Assert.AreEqual(4.107479655, 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)
+        {
+            // Setup
+            var calculation = new GrassCoverErosionInwardsCalculation(new GeneralGrassCoverErosionInwardsInput(),
+                                                                      new GeneralNormProbabilityInput());
+
+            // Call
+            GrassCoverErosionInwardsOutputCalculationService.Calculate(calculation, norm, probability);
+
+            // Assert
+            RoundedDouble output = calculation.Output.FactorOfSafety;
+            Assert.AreEqual(expectedResult, output, output.GetAccuracy());
+        }
     }
 }
\ No newline at end of file