Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingSemiProbabilisticOutput.cs
===================================================================
diff -u -r746902d8ff996441c8d885dbea8bc605fcee8239 -r37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b
--- Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingSemiProbabilisticOutput.cs	(.../PipingSemiProbabilisticOutput.cs)	(revision 746902d8ff996441c8d885dbea8bc605fcee8239)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingSemiProbabilisticOutput.cs	(.../PipingSemiProbabilisticOutput.cs)	(revision 37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b)
@@ -9,36 +9,107 @@
         /// <summary>
         /// Creates a new instance of <see cref="PipingSemiProbabilisticOutput"/>.
         /// </summary>
-        /// <param name="upliftFactorOfSafety">The factor of safety for the uplift sub calculation.</param>
-        /// <param name="heaveFactorOfSafety">The factor of safety for the heave sub calculation.</param>
-        /// <param name="sellmeijerFactorOfSafety">The factor of safety for the Sellmeijer sub calculation.</param>
+        /// <param name="upliftFactorOfSafety">The factor of safety for the uplift sub-mechanism.</param>
+        /// <param name="upliftReliability">The reliability of uplift the sub-mechanism.</param>
+        /// <param name="upliftProbability">The probability of failure due to the uplift sub-mechanism.</param>
+        /// <param name="heaveFactorOfSafety">The factor of safety for the heave sub-mechanism.</param>
+        /// <param name="heaveReliability">The reliability of the heave sub-mechanism.</param>
+        /// <param name="heaveProbability">The probability of failure due to the heave sub-mechanism.</param>
+        /// <param name="sellmeijerFactorOfSafety">The factor of safety for the Sellmeijer sub-mechanism.</param>
+        /// <param name="sellmeijerReliability">The reliability of the Sellmeijer sub-mechanism.</param>
+        /// <param name="sellmeijerProbability">The probability of failure due to the Sellmeijer sub-mechanism.</param>
+        /// <param name="requiredProbability">The required (maximum allowed) probability of failure due to piping.</param>
+        /// <param name="requiredReliability">The required (maximum allowed) reliabiality of the piping failure mechanism</param>
+        /// <param name="pipingProbability">The calculated probability of failing due to piping.</param>
+        /// <param name="pipingReliability">The calculated reliability of the piping failure mechanism.</param>
         /// <param name="pipingFactorOfSafety">The factor of safety for the piping failure mechanims.</param>
-        public PipingSemiProbabilisticOutput(double upliftFactorOfSafety, double heaveFactorOfSafety, double sellmeijerFactorOfSafety, double pipingFactorOfSafety)
+        public PipingSemiProbabilisticOutput(double upliftFactorOfSafety, double upliftReliability, double upliftProbability, double heaveFactorOfSafety, double heaveReliability, double heaveProbability, double sellmeijerFactorOfSafety, double sellmeijerReliability, double sellmeijerProbability, double requiredProbability, double requiredReliability, double pipingProbability, double pipingReliability, double pipingFactorOfSafety)
         {
             UpliftFactorOfSafety = upliftFactorOfSafety;
+            UpliftReliability = upliftReliability;
+            UpliftProbability = upliftProbability;
             HeaveFactorOfSafety = heaveFactorOfSafety;
+            HeaveReliability = heaveReliability;
+            HeaveProbability = heaveProbability;
             SellmeijerFactorOfSafety = sellmeijerFactorOfSafety;
+            SellmeijerReliability = sellmeijerReliability;
+            SellmeijerProbability = sellmeijerProbability;
+
+            RequiredProbability = requiredProbability;
+            RequiredReliability = requiredReliability;
+            PipingProbability = pipingProbability;
+            PipingReliability = pipingReliability;
             PipingFactorOfSafety = pipingFactorOfSafety;
         }
 
         /// <summary>
-        /// Gets or sets the factor of safety of the piping failure mechanism.
+        /// Gets the required probability of the piping failure mechanism.
         /// </summary>
+        public double RequiredProbability { get; private set; }
+
+        /// <summary>
+        /// Get the required reliability of the piping failure mechanism.
+        /// </summary>
+        public double RequiredReliability { get; private set; }
+
+        /// <summary>
+        /// Gets the factor of safety of the piping failure mechanism.
+        /// </summary>
         public double PipingFactorOfSafety { get; private set; }
 
         /// <summary>
-        /// The factor of safety for the uplift sub calculation.
+        /// Gets the reliability of the piping failure mechanism.
         /// </summary>
+        public double PipingReliability { get; private set; }
+
+        /// <summary>
+        /// Gets the probability of failing due to the piping failure mechanism.
+        /// </summary>
+        public double PipingProbability { get; private set; }
+
+        /// <summary>
+        /// Gets the factor of safety for the uplift sub-mechanism.
+        /// </summary>
         public double UpliftFactorOfSafety { get; private set; }
 
         /// <summary>
-        /// The factor of safety for the heave sub calculation.
+        /// Gets the reliability for the uplift sub-mechanism.
         /// </summary>
+        public double UpliftReliability{ get; private set; }
+
+        /// <summary>
+        /// Gets the probability of failing due to the uplift failure sub-mechanism.
+        /// </summary>
+        public double UpliftProbability{ get; private set; }
+
+        /// <summary>
+        /// Gets the factor of safety for the heave sub-mechanism.
+        /// </summary>
         public double HeaveFactorOfSafety { get; private set; }
 
         /// <summary>
-        /// The factor of safety for the Sellmeijer sub calculation.
+        /// Gets the reliability for the heave sub-mechanism.
         /// </summary>
+        public double HeaveReliability { get; private set; }
+
+        /// <summary>
+        /// Gets the probability of failing due to the heave failure sub-mechanism.
+        /// </summary>
+        public double HeaveProbability { get; private set; }
+
+        /// <summary>
+        /// Gets the factor of safety for the Sellmeijer sub-mechanism.
+        /// </summary>
         public double SellmeijerFactorOfSafety { get; private set; }
+
+        /// <summary>
+        /// Gets the reliability for the Sellmeijer sub-mechanism.
+        /// </summary>
+        public double SellmeijerReliability { get; private set; }
+
+        /// <summary>
+        /// Gets the probability of failing due to the Sellmeijer failure sub-mechanism.
+        /// </summary>
+        public double SellmeijerProbability { get; private set; }
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/src/Ringtoets.Piping.Forms/Properties/Resources.Designer.cs
===================================================================
diff -u -r746902d8ff996441c8d885dbea8bc605fcee8239 -r37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b
--- Ringtoets/Piping/src/Ringtoets.Piping.Forms/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision 746902d8ff996441c8d885dbea8bc605fcee8239)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Forms/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision 37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b)
@@ -1130,151 +1130,304 @@
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Veiligheidsfactor heave..
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
-        public static string PipingOutput_HeaveFactorOfSafety_Description {
+        public static System.Drawing.Bitmap PipingOutputIcon {
             get {
-                return ResourceManager.GetString("PipingOutput_HeaveFactorOfSafety_Description", resourceCulture);
+                object obj = ResourceManager.GetObject("PipingOutputIcon", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Veiligheidsfactor heave.
+        ///   Looks up a localized string similar to Heave.
         /// </summary>
-        public static string PipingOutput_HeaveFactorOfSafety_DisplayName {
+        public static string PipingSemiProbabilisticOutput_Categories_Heave {
             get {
-                return ResourceManager.GetString("PipingOutput_HeaveFactorOfSafety_DisplayName", resourceCulture);
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_Categories_Heave", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Z-waarde heave..
+        ///   Looks up a localized string similar to Piping.
         /// </summary>
-        public static string PipingOutput_HeaveZValue_Description {
+        public static string PipingSemiProbabilisticOutput_Categories_Piping {
             get {
-                return ResourceManager.GetString("PipingOutput_HeaveZValue_Description", resourceCulture);
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_Categories_Piping", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Z-waarde heave.
+        ///   Looks up a localized string similar to Interne erosie (Sellmeijer).
         /// </summary>
-        public static string PipingOutput_HeaveZValue_DisplayName {
+        public static string PipingSemiProbabilisticOutput_Categories_Sellmeijer {
             get {
-                return ResourceManager.GetString("PipingOutput_HeaveZValue_DisplayName", resourceCulture);
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_Categories_Sellmeijer", resourceCulture);
             }
         }
         
         /// <summary>
+        ///   Looks up a localized string similar to Opbarsten.
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_Categories_Uplift {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_Categories_Uplift", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to De veiligheidsfactor voor het heave faalmechanisme..
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_HeaveFactorOfSafety_Description {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_HeaveFactorOfSafety_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Veiligheidsfactor [-].
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_HeaveFactorOfSafety_DisplayName {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_HeaveFactorOfSafety_DisplayName", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to De kans dat het faalmechanisme heave optreedt..
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_HeaveProbability_Description {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_HeaveProbability_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Kans van voorkomen [1/jaar].
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_HeaveProbability_DisplayName {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_HeaveProbability_DisplayName", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to De betrouwbaarheidsindex van het heave faalmechanisme..
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_HeaveReliability_Description {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_HeaveReliability_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Betrouwbaarheidsindex [-].
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_HeaveReliability_DisplayName {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_HeaveReliability_DisplayName", resourceCulture);
+            }
+        }
+        
+        /// <summary>
         ///   Looks up a localized string similar to De veiligheidsfactor voor het piping faalmechanisme..
         /// </summary>
-        public static string PipingOutput_PipingFactorOfSafety_Description {
+        public static string PipingSemiProbabilisticOutput_PipingFactorOfSafety_Description {
             get {
-                return ResourceManager.GetString("PipingOutput_PipingFactorOfSafety_Description", resourceCulture);
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_PipingFactorOfSafety_Description", resourceCulture);
             }
         }
         
         /// <summary>
         ///   Looks up a localized string similar to Veiligheidsfactor [-].
         /// </summary>
-        public static string PipingOutput_PipingFactorOfSafety_DisplayName {
+        public static string PipingSemiProbabilisticOutput_PipingFactorOfSafety_DisplayName {
             get {
-                return ResourceManager.GetString("PipingOutput_PipingFactorOfSafety_DisplayName", resourceCulture);
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_PipingFactorOfSafety_DisplayName", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Piping resultaten.
+        ///   Looks up a localized string similar to De kans dat het faalmechanisme piping optreedt..
         /// </summary>
-        public static string PipingOutput_Properties_DisplayName {
+        public static string PipingSemiProbabilisticOutput_PipingProbability_Description {
             get {
-                return ResourceManager.GetString("PipingOutput_Properties_DisplayName", resourceCulture);
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_PipingProbability_Description", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Veiligheidsfactor Sellmeijer..
+        ///   Looks up a localized string similar to Faalkans [1/jaar].
         /// </summary>
-        public static string PipingOutput_SellmeijerFactorOfSafety_Description {
+        public static string PipingSemiProbabilisticOutput_PipingProbability_DisplayName {
             get {
-                return ResourceManager.GetString("PipingOutput_SellmeijerFactorOfSafety_Description", resourceCulture);
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_PipingProbability_DisplayName", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Veiligheidsfactor Sellmeijer.
+        ///   Looks up a localized string similar to De betrouwbaarheidsindex van het piping faalmechanisme..
         /// </summary>
-        public static string PipingOutput_SellmeijerFactorOfSafety_DisplayName {
+        public static string PipingSemiProbabilisticOutput_PipingReliability_Description {
             get {
-                return ResourceManager.GetString("PipingOutput_SellmeijerFactorOfSafety_DisplayName", resourceCulture);
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_PipingReliability_Description", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Z-waarde Sellmeijer..
+        ///   Looks up a localized string similar to Betrouwbaarheidsindex [-].
         /// </summary>
-        public static string PipingOutput_SellmeijerZValue_Description {
+        public static string PipingSemiProbabilisticOutput_PipingReliability_DisplayName {
             get {
-                return ResourceManager.GetString("PipingOutput_SellmeijerZValue_Description", resourceCulture);
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_PipingReliability_DisplayName", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Z-waarde Sellmeijer.
+        ///   Looks up a localized string similar to De maximaal toegestane betrouwbaarheidsindex voor het faalmechanisme piping..
         /// </summary>
-        public static string PipingOutput_SellmeijerZValue_DisplayName {
+        public static string PipingSemiProbabilisticOutput_RequiredProbability_Description {
             get {
-                return ResourceManager.GetString("PipingOutput_SellmeijerZValue_DisplayName", resourceCulture);
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_RequiredProbability_Description", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Veiligheidsfactor opbarsten.
+        ///   Looks up a localized string similar to Betrouwbaarheidsindex faalkanseis [-].
         /// </summary>
-        public static string PipingOutput_UpliftFactorOfSafety_Description {
+        public static string PipingSemiProbabilisticOutput_RequiredProbability_DisplayName {
             get {
-                return ResourceManager.GetString("PipingOutput_UpliftFactorOfSafety_Description", resourceCulture);
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_RequiredProbability_DisplayName", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Veiligheidsfactor opbarsten.
+        ///   Looks up a localized string similar to De maximaal toegestane kans dat het faalmechanisme piping optreedt..
         /// </summary>
-        public static string PipingOutput_UpliftFactorOfSafety_DisplayName {
+        public static string PipingSemiProbabilisticOutput_RequiredReliability_Description {
             get {
-                return ResourceManager.GetString("PipingOutput_UpliftFactorOfSafety_DisplayName", resourceCulture);
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_RequiredReliability_Description", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Z-waarde opbarsten..
+        ///   Looks up a localized string similar to Faalkanseis [1/jaar].
         /// </summary>
-        public static string PipingOutput_UpliftZValue_Description {
+        public static string PipingSemiProbabilisticOutput_RequiredReliability_DisplayName {
             get {
-                return ResourceManager.GetString("PipingOutput_UpliftZValue_Description", resourceCulture);
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_RequiredReliability_DisplayName", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Z-waarde opbarsten.
+        ///   Looks up a localized string similar to De veiligheidsfactor voor het Sellmeijer faalmechanisme..
         /// </summary>
-        public static string PipingOutput_UpliftZValue_DisplayName {
+        public static string PipingSemiProbabilisticOutput_SellmeijerFactorOfSafety_Description {
             get {
-                return ResourceManager.GetString("PipingOutput_UpliftZValue_DisplayName", resourceCulture);
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_SellmeijerFactorOfSafety_Description", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        ///   Looks up a localized string similar to Veiligheidsfactor [-].
         /// </summary>
-        public static System.Drawing.Bitmap PipingOutputIcon {
+        public static string PipingSemiProbabilisticOutput_SellmeijerFactorOfSafety_DisplayName {
             get {
-                object obj = ResourceManager.GetObject("PipingOutputIcon", resourceCulture);
-                return ((System.Drawing.Bitmap)(obj));
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_SellmeijerFactorOfSafety_DisplayName", resourceCulture);
             }
         }
         
         /// <summary>
+        ///   Looks up a localized string similar to De kans dat het faalmechanisme Sellmeijer optreedt..
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_SellmeijerProbability_Description {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_SellmeijerProbability_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Kans van voorkomen [1/jaar].
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_SellmeijerProbability_DisplayName {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_SellmeijerProbability_DisplayName", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to De betrouwbaarheidsindex van het Sellmeijer faalmechanisme..
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_SellmeijerReliability_Description {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_SellmeijerReliability_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Betrouwbaarheidsindex [-].
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_SellmeijerReliability_DisplayName {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_SellmeijerReliability_DisplayName", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to De veiligheidsfactor voor het opbarsten faalmechanisme..
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_UpliftFactorOfSafety_Description {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_UpliftFactorOfSafety_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Veiligheidsfactor [-].
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_UpliftFactorOfSafety_DisplayName {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_UpliftFactorOfSafety_DisplayName", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to De kans dat het faalmechanisme opbarsten optreedt..
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_UpliftProbability_Description {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_UpliftProbability_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Kans van voorkomen [1/jaar].
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_UpliftProbability_DisplayName {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_UpliftProbability_DisplayName", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to De betrouwbaarheidsindex van het opbarsten faalmechanisme..
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_UpliftReliability_Description {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_UpliftReliability_Description", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Betrouwbaarheidsindex [-].
+        /// </summary>
+        public static string PipingSemiProbabilisticOutput_UpliftReliability_DisplayName {
+            get {
+                return ResourceManager.GetString("PipingSemiProbabilisticOutput_UpliftReliability_DisplayName", resourceCulture);
+            }
+        }
+        
+        /// <summary>
         ///   Looks up a localized string similar to Het niveau van de onderkant van dit profiel..
         /// </summary>
         public static string PipingSoilProfile_Bottom_Description {
Index: Ringtoets/Piping/src/Ringtoets.Piping.Forms/Properties/Resources.resx
===================================================================
diff -u -r746902d8ff996441c8d885dbea8bc605fcee8239 -r37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b
--- Ringtoets/Piping/src/Ringtoets.Piping.Forms/Properties/Resources.resx	(.../Resources.resx)	(revision 746902d8ff996441c8d885dbea8bc605fcee8239)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Forms/Properties/Resources.resx	(.../Resources.resx)	(revision 37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b)
@@ -253,45 +253,24 @@
   <data name="PipingOutput_DisplayName" xml:space="preserve">
     <value>Piping resultaat</value>
   </data>
-  <data name="PipingOutput_HeaveFactorOfSafety_Description" xml:space="preserve">
-    <value>Veiligheidsfactor heave.</value>
+  <data name="PipingSemiProbabilisticOutput_HeaveFactorOfSafety_Description" xml:space="preserve">
+    <value>De veiligheidsfactor voor het heave faalmechanisme.</value>
   </data>
-  <data name="PipingOutput_HeaveFactorOfSafety_DisplayName" xml:space="preserve">
-    <value>Veiligheidsfactor heave</value>
+  <data name="PipingSemiProbabilisticOutput_HeaveFactorOfSafety_DisplayName" xml:space="preserve">
+    <value>Veiligheidsfactor [-]</value>
   </data>
-  <data name="PipingOutput_HeaveZValue_Description" xml:space="preserve">
-    <value>Z-waarde heave.</value>
+  <data name="PipingSemiProbabilisticOutput_SellmeijerFactorOfSafety_Description" xml:space="preserve">
+    <value>De veiligheidsfactor voor het Sellmeijer faalmechanisme.</value>
   </data>
-  <data name="PipingOutput_HeaveZValue_DisplayName" xml:space="preserve">
-    <value>Z-waarde heave</value>
+  <data name="PipingSemiProbabilisticOutput_SellmeijerFactorOfSafety_DisplayName" xml:space="preserve">
+    <value>Veiligheidsfactor [-]</value>
   </data>
-  <data name="PipingOutput_Properties_DisplayName" xml:space="preserve">
-    <value>Piping resultaten</value>
+  <data name="PipingSemiProbabilisticOutput_UpliftFactorOfSafety_Description" xml:space="preserve">
+    <value>De veiligheidsfactor voor het opbarsten faalmechanisme.</value>
   </data>
-  <data name="PipingOutput_SellmeijerFactorOfSafety_Description" xml:space="preserve">
-    <value>Veiligheidsfactor Sellmeijer.</value>
+  <data name="PipingSemiProbabilisticOutput_UpliftFactorOfSafety_DisplayName" xml:space="preserve">
+    <value>Veiligheidsfactor [-]</value>
   </data>
-  <data name="PipingOutput_SellmeijerFactorOfSafety_DisplayName" xml:space="preserve">
-    <value>Veiligheidsfactor Sellmeijer</value>
-  </data>
-  <data name="PipingOutput_SellmeijerZValue_Description" xml:space="preserve">
-    <value>Z-waarde Sellmeijer.</value>
-  </data>
-  <data name="PipingOutput_SellmeijerZValue_DisplayName" xml:space="preserve">
-    <value>Z-waarde Sellmeijer</value>
-  </data>
-  <data name="PipingOutput_UpliftFactorOfSafety_Description" xml:space="preserve">
-    <value>Veiligheidsfactor opbarsten</value>
-  </data>
-  <data name="PipingOutput_UpliftFactorOfSafety_DisplayName" xml:space="preserve">
-    <value>Veiligheidsfactor opbarsten</value>
-  </data>
-  <data name="PipingOutput_UpliftZValue_Description" xml:space="preserve">
-    <value>Z-waarde opbarsten.</value>
-  </data>
-  <data name="PipingOutput_UpliftZValue_DisplayName" xml:space="preserve">
-    <value>Z-waarde opbarsten</value>
-  </data>
   <data name="PipingSurfaceLinesCollection_DisplayName" xml:space="preserve">
     <value>Profielmetingen</value>
   </data>
@@ -604,10 +583,82 @@
   <data name="Categories_SoilProperties" xml:space="preserve">
     <value>Grondeigenschappen</value>
   </data>
-  <data name="PipingOutput_PipingFactorOfSafety_Description" xml:space="preserve">
+  <data name="PipingSemiProbabilisticOutput_PipingFactorOfSafety_Description" xml:space="preserve">
     <value>De veiligheidsfactor voor het piping faalmechanisme.</value>
   </data>
-  <data name="PipingOutput_PipingFactorOfSafety_DisplayName" xml:space="preserve">
+  <data name="PipingSemiProbabilisticOutput_PipingFactorOfSafety_DisplayName" xml:space="preserve">
     <value>Veiligheidsfactor [-]</value>
   </data>
+  <data name="PipingSemiProbabilisticOutput_HeaveProbability_Description" xml:space="preserve">
+    <value>De kans dat het faalmechanisme heave optreedt.</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_HeaveProbability_DisplayName" xml:space="preserve">
+    <value>Kans van voorkomen [1/jaar]</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_HeaveReliability_Description" xml:space="preserve">
+    <value>De betrouwbaarheidsindex van het heave faalmechanisme.</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_HeaveReliability_DisplayName" xml:space="preserve">
+    <value>Betrouwbaarheidsindex [-]</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_PipingProbability_Description" xml:space="preserve">
+    <value>De kans dat het faalmechanisme piping optreedt.</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_PipingProbability_DisplayName" xml:space="preserve">
+    <value>Faalkans [1/jaar]</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_PipingReliability_Description" xml:space="preserve">
+    <value>De betrouwbaarheidsindex van het piping faalmechanisme.</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_PipingReliability_DisplayName" xml:space="preserve">
+    <value>Betrouwbaarheidsindex [-]</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_RequiredProbability_Description" xml:space="preserve">
+    <value>De maximaal toegestane betrouwbaarheidsindex voor het faalmechanisme piping.</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_RequiredProbability_DisplayName" xml:space="preserve">
+    <value>Betrouwbaarheidsindex faalkanseis [-]</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_RequiredReliability_Description" xml:space="preserve">
+    <value>De maximaal toegestane kans dat het faalmechanisme piping optreedt.</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_RequiredReliability_DisplayName" xml:space="preserve">
+    <value>Faalkanseis [1/jaar]</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_SellmeijerProbability_Description" xml:space="preserve">
+    <value>De kans dat het faalmechanisme Sellmeijer optreedt.</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_SellmeijerProbability_DisplayName" xml:space="preserve">
+    <value>Kans van voorkomen [1/jaar]</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_SellmeijerReliability_Description" xml:space="preserve">
+    <value>De betrouwbaarheidsindex van het Sellmeijer faalmechanisme.</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_SellmeijerReliability_DisplayName" xml:space="preserve">
+    <value>Betrouwbaarheidsindex [-]</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_UpliftProbability_Description" xml:space="preserve">
+    <value>De kans dat het faalmechanisme opbarsten optreedt.</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_UpliftProbability_DisplayName" xml:space="preserve">
+    <value>Kans van voorkomen [1/jaar]</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_UpliftReliability_Description" xml:space="preserve">
+    <value>De betrouwbaarheidsindex van het opbarsten faalmechanisme.</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_UpliftReliability_DisplayName" xml:space="preserve">
+    <value>Betrouwbaarheidsindex [-]</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_Categories_Heave" xml:space="preserve">
+    <value>Heave</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_Categories_Piping" xml:space="preserve">
+    <value>Piping</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_Categories_Sellmeijer" xml:space="preserve">
+    <value>Interne erosie (Sellmeijer)</value>
+  </data>
+  <data name="PipingSemiProbabilisticOutput_Categories_Uplift" xml:space="preserve">
+    <value>Opbarsten</value>
+  </data>
 </root>
\ No newline at end of file
Index: Ringtoets/Piping/src/Ringtoets.Piping.Forms/PropertyClasses/PipingSemiProbabilisticOutputProperties.cs
===================================================================
diff -u -r746902d8ff996441c8d885dbea8bc605fcee8239 -r37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b
--- Ringtoets/Piping/src/Ringtoets.Piping.Forms/PropertyClasses/PipingSemiProbabilisticOutputProperties.cs	(.../PipingSemiProbabilisticOutputProperties.cs)	(revision 746902d8ff996441c8d885dbea8bc605fcee8239)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Forms/PropertyClasses/PipingSemiProbabilisticOutputProperties.cs	(.../PipingSemiProbabilisticOutputProperties.cs)	(revision 37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b)
@@ -7,9 +7,42 @@
 {
     public class PipingSemiProbabilisticOutputProperties : ObjectProperties<PipingSemiProbabilisticOutput>
     {
-        [ResourcesCategory(typeof(Resources), "Categories_General")]
-        [ResourcesDisplayName(typeof(Resources), "PipingOutput_HeaveFactorOfSafety_DisplayName")]
-        [ResourcesDescription(typeof(Resources), "PipingOutput_HeaveFactorOfSafety_Description")]
+        [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Uplift")]
+        [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_UpliftFactorOfSafety_DisplayName")]
+        [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_UpliftFactorOfSafety_Description")]
+        public double UpliftFactorOfSafety
+        {
+            get
+            {
+                return data.UpliftFactorOfSafety;
+            }
+        }
+
+        [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Uplift")]
+        [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_UpliftReliability_DisplayName")]
+        [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_UpliftReliability_Description")]
+        public double UpliftReliability
+        {
+            get
+            {
+                return data.UpliftReliability;
+            }
+        }
+
+        [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Uplift")]
+        [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_UpliftProbability_DisplayName")]
+        [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_UpliftProbability_Description")]
+        public double UpliftProbability
+        {
+            get
+            {
+                return data.UpliftProbability;
+            }
+        }
+
+        [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Heave")]
+        [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_HeaveFactorOfSafety_DisplayName")]
+        [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_HeaveFactorOfSafety_Description")]
         public double HeaveFactorOfSafety
         {
             get
@@ -18,20 +51,31 @@
             }
         }
 
-        [ResourcesCategory(typeof(Resources), "Categories_General")]
-        [ResourcesDisplayName(typeof(Resources), "PipingOutput_UpliftFactorOfSafety_DisplayName")]
-        [ResourcesDescription(typeof(Resources), "PipingOutput_UpliftFactorOfSafety_Description")]
-        public double UpliftFactorOfSafety
+        [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Heave")]
+        [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_HeaveReliability_DisplayName")]
+        [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_HeaveReliability_Description")]
+        public double HeaveReliability
         {
             get
             {
-                return data.UpliftFactorOfSafety;
+                return data.HeaveReliability;
             }
         }
 
-        [ResourcesCategory(typeof(Resources), "Categories_General")]
-        [ResourcesDisplayName(typeof(Resources), "PipingOutput_SellmeijerFactorOfSafety_DisplayName")]
-        [ResourcesDescription(typeof(Resources), "PipingOutput_SellmeijerFactorOfSafety_Description")]
+        [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Heave")]
+        [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_HeaveProbability_DisplayName")]
+        [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_HeaveProbability_Description")]
+        public double HeaveProbability
+        {
+            get
+            {
+                return data.HeaveProbability;
+            }
+        }
+
+        [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Sellmeijer")]
+        [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_SellmeijerFactorOfSafety_DisplayName")]
+        [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_SellmeijerFactorOfSafety_Description")]
         public double SellmeijerFactorOfSafety
         {
             get
@@ -40,9 +84,75 @@
             }
         }
 
-        [ResourcesCategory(typeof(Resources), "Categories_General")]
-        [ResourcesDisplayName(typeof(Resources), "PipingOutput_PipingFactorOfSafety_DisplayName")]
-        [ResourcesDescription(typeof(Resources), "PipingOutput_PipingFactorOfSafety_Description")]
+        [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Sellmeijer")]
+        [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_SellmeijerReliability_DisplayName")]
+        [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_SellmeijerReliability_Description")]
+        public double SellmeijerReliability
+        {
+            get
+            {
+                return data.SellmeijerReliability;
+            }
+        }
+
+        [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Sellmeijer")]
+        [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_SellmeijerProbability_DisplayName")]
+        [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_SellmeijerProbability_Description")]
+        public double SellmeijerProbability
+        {
+            get
+            {
+                return data.SellmeijerProbability;
+            }
+        }
+
+        [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Piping")]
+        [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_RequiredProbability_DisplayName")]
+        [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_RequiredProbability_Description")]
+        public double RequiredProbability
+        {
+            get
+            {
+                return data.RequiredProbability;
+            }
+        }
+
+        [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Piping")]
+        [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_RequiredReliability_DisplayName")]
+        [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_RequiredReliability_Description")]
+        public double RequiredReliability
+        {
+            get
+            {
+                return data.RequiredReliability;
+            }
+        }
+
+        [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Piping")]
+        [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_PipingProbability_DisplayName")]
+        [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_PipingProbability_Description")]
+        public double PipingProbability
+        {
+            get
+            {
+                return data.PipingProbability;
+            }
+        }
+
+        [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Piping")]
+        [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_PipingReliability_DisplayName")]
+        [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_PipingReliability_Description")]
+        public double PipingReliability
+        {
+            get
+            {
+                return data.PipingReliability;
+            }
+        }
+
+        [ResourcesCategory(typeof(Resources), "PipingSemiProbabilisticOutput_Categories_Piping")]
+        [ResourcesDisplayName(typeof(Resources), "PipingSemiProbabilisticOutput_PipingFactorOfSafety_DisplayName")]
+        [ResourcesDescription(typeof(Resources), "PipingSemiProbabilisticOutput_PipingFactorOfSafety_Description")]
         public double PipingFactorOfSafety
         {
             get
Index: Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingSemiProbabilisticCalculationService.cs
===================================================================
diff -u -r746902d8ff996441c8d885dbea8bc605fcee8239 -r37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b
--- Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingSemiProbabilisticCalculationService.cs	(.../PipingSemiProbabilisticCalculationService.cs)	(revision 746902d8ff996441c8d885dbea8bc605fcee8239)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingSemiProbabilisticCalculationService.cs	(.../PipingSemiProbabilisticCalculationService.cs)	(revision 37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b)
@@ -9,8 +9,9 @@
     /// </summary>
     public class PipingSemiProbabilisticCalculationService
     {
-        private readonly double heaveFactorOfSafety;
+        // Inputs
         private readonly double upliftFactorOfSafety;
+        private readonly double heaveFactorOfSafety;
         private readonly double sellmeijerFactorOfSafety;
 
         private readonly int returnPeriod;
@@ -19,44 +20,22 @@
         private readonly double assessmentSectionLength;
         private readonly double contribution;
 
-        /// <summary>
-        /// Calculates the semi-probabilistic results given a <see cref="PipingCalculation"/> with <see cref="PipingOutput"/>.
-        /// </summary>
-        /// <param name="calculation">The calculation which is used as input for the semi-probabilistic assessment. If the semi-
-        /// probabilistic calculation is successful, <see cref="PipingCalculation.SemiProbabilisticOutput"/> is set.</param>
-        /// <exception cref="ArgumentNullException">Thrown when calculation has no output from a piping calculation.</exception>
-        public static void Calculate(PipingCalculation calculation)
-        {
-            ValidateOutputOnCalculation(calculation);
+        // Intermediate results
+        private double heaveReliability;
+        private double upliftReliability;
+        private double sellmeijerReliability;
 
-            SemiProbabilisticPipingInput semiProbabilisticParameters = calculation.SemiProbabilisticParameters;
-            var pipingOutput = calculation.Output;
+        private double heaveProbability;
+        private double upliftProbability;
+        private double sellmeijerProbability;
 
-            var calculator = new PipingSemiProbabilisticCalculationService(
-				pipingOutput.UpliftFactorOfSafety,
-                pipingOutput.HeaveFactorOfSafety,
-                pipingOutput.SellmeijerFactorOfSafety,
-                semiProbabilisticParameters.Norm,
-                semiProbabilisticParameters.A,
-                semiProbabilisticParameters.B,
-                semiProbabilisticParameters.SectionLength,
-                semiProbabilisticParameters.Contribution/100);
+        private double pipingProbability;
+        private double pipingReliability;
 
-            calculation.SemiProbabilisticOutput = new PipingSemiProbabilisticOutput(
-                pipingOutput.UpliftFactorOfSafety,
-                pipingOutput.HeaveFactorOfSafety,
-                pipingOutput.SellmeijerFactorOfSafety,
-                calculator.FactorOfSafety()
-            );
-        }
+        private double requiredProbability;
+        private double requiredReliability;
 
-        private static void ValidateOutputOnCalculation(PipingCalculation calculation)
-        {
-            if (!calculation.HasOutput)
-            {
-                throw new ArgumentNullException("calculation", "Cannot perform a semi-probabilistic calculation without output form the piping kernel.");
-            }
-        }
+        private double pipingFactorOfSafety;
 
         /// <summary>
         /// Creates a new instance of <see cref="PipingSemiProbabilisticCalculationService"/>.
@@ -82,12 +61,66 @@
         }
 
         /// <summary>
+        /// Calculates the semi-probabilistic results given a <see cref="PipingCalculation"/> with <see cref="PipingOutput"/>.
+        /// </summary>
+        /// <param name="calculation">The calculation which is used as input for the semi-probabilistic assessment. If the semi-
+        /// probabilistic calculation is successful, <see cref="PipingCalculation.SemiProbabilisticOutput"/> is set.</param>
+        /// <exception cref="ArgumentNullException">Thrown when calculation has no output from a piping calculation.</exception>
+        public static void Calculate(PipingCalculation calculation)
+        {
+            ValidateOutputOnCalculation(calculation);
+
+            SemiProbabilisticPipingInput semiProbabilisticParameters = calculation.SemiProbabilisticParameters;
+            var pipingOutput = calculation.Output;
+
+            var calculator = new PipingSemiProbabilisticCalculationService(
+                pipingOutput.UpliftFactorOfSafety,
+                pipingOutput.HeaveFactorOfSafety,
+                pipingOutput.SellmeijerFactorOfSafety,
+                semiProbabilisticParameters.Norm,
+                semiProbabilisticParameters.A,
+                semiProbabilisticParameters.B,
+                semiProbabilisticParameters.SectionLength,
+                semiProbabilisticParameters.Contribution / 100);
+            calculator.Calculate();
+
+            calculation.SemiProbabilisticOutput = new PipingSemiProbabilisticOutput(
+                calculator.upliftFactorOfSafety,
+                calculator.upliftReliability,
+                calculator.upliftProbability,
+                calculator.heaveFactorOfSafety,
+                calculator.heaveReliability,
+                calculator.heaveProbability,
+                calculator.sellmeijerFactorOfSafety,
+                calculator.sellmeijerReliability,
+                calculator.sellmeijerProbability,
+                calculator.requiredProbability,
+                calculator.requiredReliability,
+                calculator.pipingProbability,
+                calculator.pipingReliability,
+                calculator.pipingFactorOfSafety
+                );
+        }
+
+        private void Calculate()
+        {
+            FailureProbabilityUplift();
+            FailureProbabilityHeave();
+            FailureProbabilitySellmeijer();
+            BetaCrossPiping();
+            BetaCrossRequired();
+            FactorOfSafety();
+        }
+
+        /// <summary>
         /// Returns the failure probability of the uplift sub mechanism.
         /// </summary>
         /// <returns>A value represening failure probability.</returns>
         public double FailureProbabilityUplift()
         {
-            return FailureProbability(upliftFactorOfSafety, upliftFactors);
+            upliftReliability = SubMechanismReliability(upliftFactorOfSafety, upliftFactors);
+            upliftProbability = ReliabilityToProbability(upliftReliability);
+            return upliftProbability;
         }
 
         /// <summary>
@@ -96,7 +129,9 @@
         /// <returns>A value represening failure probability.</returns>
         public double FailureProbabilityHeave()
         {
-            return FailureProbability(heaveFactorOfSafety, heaveFactors);
+            heaveReliability = SubMechanismReliability(heaveFactorOfSafety, heaveFactors);
+            heaveProbability = ReliabilityToProbability(heaveReliability);
+            return heaveProbability;
         }
 
         /// <summary>
@@ -105,7 +140,9 @@
         /// <returns>A value represening failure probability.</returns>
         public double FailureProbabilitySellmeijer()
         {
-            return FailureProbability(sellmeijerFactorOfSafety, sellmeijerFactors);
+            sellmeijerReliability = SubMechanismReliability(sellmeijerFactorOfSafety, sellmeijerFactors);
+            sellmeijerProbability = ReliabilityToProbability(sellmeijerReliability);
+            return sellmeijerProbability;
         }
 
         /// <summary>
@@ -114,18 +151,20 @@
         /// <returns>A value representing the reliability.</returns>
         public double BetaCrossPiping()
         {
-            var minFailureProbability = Math.Min(Math.Min(FailureProbabilityHeave(), FailureProbabilityUplift()), FailureProbabilitySellmeijer());
-            return Normal.InvCDF(0.0, 1.0, 1 - minFailureProbability);
+            pipingProbability = Math.Min(Math.Min(heaveProbability, upliftProbability), sellmeijerProbability);
+            pipingReliability = ProbabilityToReliability(pipingProbability);
+            return pipingReliability;
         }
 
         /// <summary>
-        /// Returns the allowed reliability of the piping failure mechanism for the complete assessment section.
+        /// Returns the required reliability of the piping failure mechanism for the complete assessment section.
         /// </summary>
-        /// <returns>A value representing the allowed reliability.</returns>
-        public double BetaCrossAllowed()
+        /// <returns>A value representing the required reliability.</returns>
+        public double BetaCrossRequired()
         {
-            var normCross = (contribution/returnPeriod)/(1 + (constantA*assessmentSectionLength)/constantB);
-            return Normal.InvCDF(0, 1, 1 - normCross);
+            requiredProbability = (contribution/returnPeriod)/(1 + (constantA*assessmentSectionLength)/constantB);
+            requiredReliability = ProbabilityToReliability(requiredProbability);
+            return requiredReliability;
         }
 
         /// <summary>
@@ -135,19 +174,36 @@
         /// <returns>A factor of safety value.</returns>
         public double FactorOfSafety()
         {
-            return BetaCrossAllowed()/BetaCrossPiping();
+            pipingFactorOfSafety = requiredReliability/pipingReliability;
+            return pipingFactorOfSafety;
         }
 
-        private double FailureProbability(double factorOfSafety, SubCalculationFactors factors)
+        private static void ValidateOutputOnCalculation(PipingCalculation calculation)
         {
+            if (!calculation.HasOutput)
+            {
+                throw new ArgumentNullException("calculation", "Cannot perform a semi-probabilistic calculation without output form the piping kernel.");
+            }
+        }
+
+        private double SubMechanismReliability(double factorOfSafety, SubCalculationFactors factors)
+        {
             var norm = (1.0/returnPeriod);
-            var bNorm = Normal.InvCDF(0, 1, 1 - norm);
+            var bNorm = ProbabilityToReliability(norm);
 
-            var betaCross = (1/factors.A)*(Math.Log(factorOfSafety/factors.B) + (factors.C*bNorm));
+            return (1/factors.A)*(Math.Log(factorOfSafety/factors.B) + (factors.C*bNorm));
+        }
 
-            return Normal.CDF(0, 1, -betaCross);
+        private double ReliabilityToProbability(double reliability)
+        {
+            return Normal.CDF(0, 1, -reliability);
         }
 
+        private double ProbabilityToReliability(double probability)
+        {
+            return Normal.InvCDF(0, 1, 1 - probability);
+        }
+
         #region sub-calculation constants
 
         private struct SubCalculationFactors
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticOutputTest.cs
===================================================================
diff -u -r746902d8ff996441c8d885dbea8bc605fcee8239 -r37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticOutputTest.cs	(.../PipingSemiProbabilisticOutputTest.cs)	(revision 746902d8ff996441c8d885dbea8bc605fcee8239)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSemiProbabilisticOutputTest.cs	(.../PipingSemiProbabilisticOutputTest.cs)	(revision 37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b)
@@ -11,17 +11,51 @@
             // Setup
             var random = new Random(21);
             double upliftFactorOfSafety = random.NextDouble();
+            double upliftReliability = random.NextDouble();
+            double upliftProbability = random.NextDouble();
             double heaveFactorOfSafety = random.NextDouble();
+            double heaveReliability = random.NextDouble();
+            double heaveProbability = random.NextDouble();
             double sellmeijerFactorOfSafety = random.NextDouble();
+            double sellmeijerReliability = random.NextDouble();
+            double sellmeijerProbability = random.NextDouble();
+            double requiredProbability = random.NextDouble();
+            double requiredReliability = random.NextDouble();
+            double pipingProbability = random.NextDouble();
+            double pipingReliability = random.NextDouble();
             double pipingFactorOfSafety = random.NextDouble();
 
             // Call
-            var output = new PipingSemiProbabilisticOutput(upliftFactorOfSafety, heaveFactorOfSafety, sellmeijerFactorOfSafety, pipingFactorOfSafety);
+            var output = new PipingSemiProbabilisticOutput(
+                upliftFactorOfSafety, 
+                upliftReliability,
+                upliftProbability,
+                heaveFactorOfSafety, 
+                heaveReliability,
+                heaveProbability,
+                sellmeijerFactorOfSafety, 
+                sellmeijerReliability,
+                sellmeijerProbability,
+                requiredProbability,
+                requiredReliability,
+                pipingProbability,
+                pipingReliability,
+                pipingFactorOfSafety);
 
             // Assert
             Assert.AreEqual(upliftFactorOfSafety, output.UpliftFactorOfSafety);
+            Assert.AreEqual(upliftReliability, output.UpliftReliability);
+            Assert.AreEqual(upliftProbability, output.UpliftProbability);
             Assert.AreEqual(heaveFactorOfSafety, output.HeaveFactorOfSafety);
+            Assert.AreEqual(heaveReliability, output.HeaveReliability);
+            Assert.AreEqual(heaveProbability, output.HeaveProbability);
             Assert.AreEqual(sellmeijerFactorOfSafety, output.SellmeijerFactorOfSafety);
+            Assert.AreEqual(sellmeijerReliability, output.SellmeijerReliability);
+            Assert.AreEqual(sellmeijerProbability, output.SellmeijerProbability);
+            Assert.AreEqual(requiredProbability, output.RequiredProbability);
+            Assert.AreEqual(requiredReliability, output.RequiredReliability);
+            Assert.AreEqual(pipingProbability, output.PipingProbability);
+            Assert.AreEqual(pipingReliability, output.PipingReliability);
             Assert.AreEqual(pipingFactorOfSafety, output.PipingFactorOfSafety);
         } 
     }
Index: Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingSemiProbabilisticOutputPropertiesTest.cs
===================================================================
diff -u -r746902d8ff996441c8d885dbea8bc605fcee8239 -r37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b
--- Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingSemiProbabilisticOutputPropertiesTest.cs	(.../PipingSemiProbabilisticOutputPropertiesTest.cs)	(revision 746902d8ff996441c8d885dbea8bc605fcee8239)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingSemiProbabilisticOutputPropertiesTest.cs	(.../PipingSemiProbabilisticOutputPropertiesTest.cs)	(revision 37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b)
@@ -25,16 +25,36 @@
         {
             // Setup
             var random = new Random(22);
-
             double upliftFactorOfSafety = random.NextDouble();
+            double upliftReliability = random.NextDouble();
+            double upliftProbability = random.NextDouble();
             double heaveFactorOfSafety = random.NextDouble();
+            double heaveReliability = random.NextDouble();
+            double heaveProbability = random.NextDouble();
             double sellmeijerFactorOfSafety = random.NextDouble();
+            double sellmeijerReliability = random.NextDouble();
+            double sellmeijerProbability = random.NextDouble();
+            double requiredProbability = random.NextDouble();
+            double requiredReliability = random.NextDouble();
+            double pipingProbability = random.NextDouble();
+            double pipingReliability = random.NextDouble();
             double pipingFactorOfSafety = random.NextDouble();
 
+            // Call
             var semiProbabilisticOutput = new PipingSemiProbabilisticOutput(
-                upliftFactorOfSafety,
-                heaveFactorOfSafety,
-                sellmeijerFactorOfSafety,
+                upliftFactorOfSafety, 
+                upliftReliability,
+                upliftProbability,
+                heaveFactorOfSafety, 
+                heaveReliability,
+                heaveProbability,
+                sellmeijerFactorOfSafety, 
+                sellmeijerReliability,
+                sellmeijerProbability,
+                requiredProbability,
+                requiredReliability,
+                pipingProbability,
+                pipingReliability,
                 pipingFactorOfSafety);
 
             var properties = new PipingSemiProbabilisticOutputProperties
@@ -44,8 +64,18 @@
 
             // Call & Assert
             Assert.AreEqual(upliftFactorOfSafety, properties.UpliftFactorOfSafety);
+            Assert.AreEqual(upliftReliability, properties.UpliftReliability);
+            Assert.AreEqual(upliftProbability, properties.UpliftProbability);
             Assert.AreEqual(heaveFactorOfSafety, properties.HeaveFactorOfSafety);
+            Assert.AreEqual(heaveReliability, properties.HeaveReliability);
+            Assert.AreEqual(heaveProbability, properties.HeaveProbability);
             Assert.AreEqual(sellmeijerFactorOfSafety, properties.SellmeijerFactorOfSafety);
+            Assert.AreEqual(sellmeijerReliability, properties.SellmeijerReliability);
+            Assert.AreEqual(sellmeijerProbability, properties.SellmeijerProbability);
+            Assert.AreEqual(requiredProbability, properties.RequiredProbability);
+            Assert.AreEqual(requiredReliability, properties.RequiredReliability);
+            Assert.AreEqual(pipingProbability, properties.PipingProbability);
+            Assert.AreEqual(pipingReliability, properties.PipingReliability);
             Assert.AreEqual(pipingFactorOfSafety, properties.PipingFactorOfSafety);
         }
     }
Index: Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/TreeNodeInfos/PipingSemiProbabilisticOutputTreeNodeInfoTest.cs
===================================================================
diff -u -r746902d8ff996441c8d885dbea8bc605fcee8239 -r37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b
--- Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/TreeNodeInfos/PipingSemiProbabilisticOutputTreeNodeInfoTest.cs	(.../PipingSemiProbabilisticOutputTreeNodeInfoTest.cs)	(revision 746902d8ff996441c8d885dbea8bc605fcee8239)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/TreeNodeInfos/PipingSemiProbabilisticOutputTreeNodeInfoTest.cs	(.../PipingSemiProbabilisticOutputTreeNodeInfoTest.cs)	(revision 37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b)
@@ -51,7 +51,7 @@
         public void Text_Always_ReturnsTextFromResource()
         {
             // Setup
-            var pipingOutput = mocks.StrictMock<PipingSemiProbabilisticOutput>(0, 0, 0, 0);
+            var pipingOutput = mocks.StrictMock<PipingSemiProbabilisticOutput>(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 
             mocks.ReplayAll();
 
@@ -68,7 +68,7 @@
         public void Image_Always_ReturnsSetImage()
         {
             // Setup
-            var pipingOutput = mocks.StrictMock<PipingSemiProbabilisticOutput>(0, 0, 0, 0);
+            var pipingOutput = mocks.StrictMock<PipingSemiProbabilisticOutput>(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 
             mocks.ReplayAll();
 
Index: Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingSemiProbabilisticCalculationServiceTest.cs
===================================================================
diff -u -r746902d8ff996441c8d885dbea8bc605fcee8239 -r37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b
--- Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingSemiProbabilisticCalculationServiceTest.cs	(.../PipingSemiProbabilisticCalculationServiceTest.cs)	(revision 746902d8ff996441c8d885dbea8bc605fcee8239)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingSemiProbabilisticCalculationServiceTest.cs	(.../PipingSemiProbabilisticCalculationServiceTest.cs)	(revision 37e31f1893a9cfe14e9f05779eb6a0e12f6d7b6b)
@@ -16,14 +16,21 @@
         public void FailureProbabilityUplift_DifferentInputs_ReturnsExpectedValue(int norm, double factorOfSafety, double expectedResult)
         {
             // Setup
+            var pipingInput = new SemiProbabilisticPipingInput
+            {
+                Norm = norm
+            };
             var calculatorResult = new PipingOutput(double.NaN, factorOfSafety, double.NaN, double.NaN, double.NaN, double.NaN);
-            var transformer = new PipingSemiProbabilisticCalculationService(calculatorResult.UpliftFactorOfSafety, calculatorResult.HeaveFactorOfSafety, calculatorResult.SellmeijerFactorOfSafety, norm, double.NaN, double.NaN, double.NaN, double.NaN);
 
+            var calculation = AsPipingCalculation(calculatorResult, pipingInput);
+
+            PipingSemiProbabilisticCalculationService.Calculate(calculation);
+
             // Call
-            double result = transformer.FailureProbabilityUplift();
+            double result = calculation.SemiProbabilisticOutput.UpliftProbability;
 
             // Assert
-            Assert.AreEqual(expectedResult, result, 1e-6);
+            Assert.AreEqual(expectedResult, result, 1e-8);
         }
 
         [Test]
@@ -34,14 +41,21 @@
         public void FailureProbabilityHeave_DifferentInputs_ReturnsExpectedValue(int norm, double factorOfSafety, double expectedResult)
         {
             // Setup
+            var pipingInput = new SemiProbabilisticPipingInput
+            {
+                Norm = norm
+            };
             var calculatorResult = new PipingOutput(double.NaN, double.NaN, double.NaN, factorOfSafety, double.NaN, double.NaN);
-            var transformer = new PipingSemiProbabilisticCalculationService(calculatorResult.UpliftFactorOfSafety, calculatorResult.HeaveFactorOfSafety, calculatorResult.SellmeijerFactorOfSafety, norm, double.NaN, double.NaN, double.NaN, double.NaN);
 
+            var calculation = AsPipingCalculation(calculatorResult, pipingInput);
+
+            PipingSemiProbabilisticCalculationService.Calculate(calculation);
+
             // Call
-            double result = transformer.FailureProbabilityHeave();
+            double result = calculation.SemiProbabilisticOutput.HeaveProbability;
 
             // Assert
-            Assert.AreEqual(expectedResult, result, 1e-6);
+            Assert.AreEqual(expectedResult, result, 1e-8);
         }
 
         [Test]
@@ -52,11 +66,18 @@
         public void FailureProbabilitySellmeijer_DifferentInputs_ReturnsExpectedValue(int norm, double factorOfSafety, double expectedResult)
         {
             // Setup
+            var pipingInput = new SemiProbabilisticPipingInput
+            {
+                Norm = norm
+            };
             var calculatorResult = new PipingOutput(double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, factorOfSafety);
-            var transformer = new PipingSemiProbabilisticCalculationService(calculatorResult.UpliftFactorOfSafety, calculatorResult.HeaveFactorOfSafety, calculatorResult.SellmeijerFactorOfSafety, norm, double.NaN, double.NaN, double.NaN, double.NaN);
 
+            var calculation = AsPipingCalculation(calculatorResult, pipingInput);
+
+            PipingSemiProbabilisticCalculationService.Calculate(calculation);
+
             // Call
-            double result = transformer.FailureProbabilitySellmeijer();
+            double result = calculation.SemiProbabilisticOutput.SellmeijerProbability;
 
             // Assert
             Assert.AreEqual(expectedResult, result, 1e-8);
@@ -73,29 +94,43 @@
         {
             // Setup
             var calculatorResult = new PipingOutput(double.NaN, fosUplift, double.NaN, fosHeave, double.NaN, fosSellmeijer);
-            var transformer = new PipingSemiProbabilisticCalculationService(calculatorResult.UpliftFactorOfSafety, calculatorResult.HeaveFactorOfSafety, calculatorResult.SellmeijerFactorOfSafety, norm, double.NaN, double.NaN, double.NaN, double.NaN);
+            var pipingInput = new SemiProbabilisticPipingInput
+            {
+                Norm = norm
+            };
 
+            var calculation = AsPipingCalculation(calculatorResult, pipingInput);
+
+            PipingSemiProbabilisticCalculationService.Calculate(calculation);
+
             // Call
-            double result = transformer.BetaCrossPiping();
+            double result = calculation.SemiProbabilisticOutput.PipingReliability;
 
             // Assert
             Assert.AreEqual(expectedResult, result, 1e-8);
         }
 
         [Test]
-        [TestCase(30000, 1, 350, 6000, 0.24, 4.916313847)]
-        [TestCase(20000, 1, 350, 6000, 0.12, 4.972362935)]
-        [TestCase(20000, 14, 350, 6000, 0.24, 5.327479413)]
-        [TestCase(20000, 1, 112, 6000, 0.24, 5.050875101)]
-        [TestCase(20000, 1, 350, 8000, 0.24, 4.890463519)]
-        public void BetaCrossAllowed_DifferentInputs_ReturnsExpectedValue(int norm, double a, double b, double assessmentSectionLength, double contribution, double expectedResult)
+        [TestCase(30000, 6000, 24, 4.916313847)]
+        [TestCase(20000, 6000, 12, 4.972362935)]
+        [TestCase(20000, 8000, 24, 4.890463519)]
+        public void BetaCrossAllowed_DifferentInputs_ReturnsExpectedValue(int norm, double assessmentSectionLength, double contribution, double expectedResult)
         {
             // Setup
             var calculatorResult = new PipingOutput(double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, double.NaN);
-            var transformer = new PipingSemiProbabilisticCalculationService(calculatorResult.UpliftFactorOfSafety, calculatorResult.HeaveFactorOfSafety, calculatorResult.SellmeijerFactorOfSafety, norm, a, b, assessmentSectionLength, contribution);
+            var pipingInput = new SemiProbabilisticPipingInput
+            {
+                Norm = norm,
+                SectionLength = assessmentSectionLength,
+                Contribution = contribution
+            };
 
+            var calculation = AsPipingCalculation(calculatorResult, pipingInput);
+
+            PipingSemiProbabilisticCalculationService.Calculate(calculation);
+
             // Call
-            double result = transformer.BetaCrossAllowed();
+            double result = calculation.SemiProbabilisticOutput.RequiredReliability;
 
             // Assert
             Assert.AreEqual(expectedResult, result, 1e-8);
@@ -106,20 +141,27 @@
         {
             // Setup
             int norm = 30000;
-            double a = 1;
-            double b = 350;
             double assessmentSectionLength = 6000;
-            double contribution = 0.24;
+            double contribution = 24;
             double fosUplift = 1.2;
             double fosHeave = 0.6;
             double fosSellmeijer = 0.9;
             double expectedResult = 1.134713444;
 
             var calculatorResult = new PipingOutput(double.NaN, fosUplift, double.NaN, fosHeave, double.NaN, fosSellmeijer);
-            var transformer = new PipingSemiProbabilisticCalculationService(calculatorResult.UpliftFactorOfSafety, calculatorResult.HeaveFactorOfSafety, calculatorResult.SellmeijerFactorOfSafety, norm, a, b, assessmentSectionLength, contribution);
+            var pipingInput = new SemiProbabilisticPipingInput
+            {
+                Norm = norm,
+                SectionLength = assessmentSectionLength,
+                Contribution = contribution
+            };
 
+            var calculation = AsPipingCalculation(calculatorResult, pipingInput);
+
+            PipingSemiProbabilisticCalculationService.Calculate(calculation); 
+
             // Call
-            double result = transformer.FactorOfSafety();
+            double result = calculation.SemiProbabilisticOutput.PipingFactorOfSafety;
 
             // Assert
             Assert.AreEqual(expectedResult, result, 1e-8);
@@ -129,26 +171,30 @@
         [Combinatorial]
         public void FactorOfSafety_DifferentInputs_ReturnsExpectedValue(
             [Values(20000, 30000)] int norm,
-            [Values(1, 14)] double a,
-            [Values(112, 350)] double b,
             [Values(6000, 8000)] double assessmentSectionLength,
-            [Values(0.12, 0.24)] double contribution,
+            [Values(12, 24)] double contribution,
             [Values(1.2, 1.0)] double fosUplift,
             [Values(1.4, 0.6)] double fosHeave,
             [Values(0.9, 1.1)] double fosSellmeijer)
         {
             // Setup
             var calculatorResult = new PipingOutput(double.NaN, fosUplift, double.NaN, fosHeave, double.NaN, fosSellmeijer);
-            var transformer = new PipingSemiProbabilisticCalculationService(calculatorResult.UpliftFactorOfSafety, calculatorResult.HeaveFactorOfSafety, calculatorResult.SellmeijerFactorOfSafety, norm, a, b, assessmentSectionLength, contribution);
+            var pipingInput = new SemiProbabilisticPipingInput
+            {
+                Norm = norm,
+                SectionLength = assessmentSectionLength,
+                Contribution = contribution
+            };
 
-            var betaAllowed = transformer.BetaCrossAllowed();
-            var betaPiping = transformer.BetaCrossPiping();
+            var calculation = AsPipingCalculation(calculatorResult, pipingInput);
 
+            PipingSemiProbabilisticCalculationService.Calculate(calculation); 
+
             // Call
-            double result = transformer.FactorOfSafety();
+            double result = calculation.SemiProbabilisticOutput.PipingFactorOfSafety;
 
             // Assert
-            Assert.AreEqual(betaAllowed/betaPiping, result, 1e-8);
+            Assert.AreEqual(calculation.SemiProbabilisticOutput.RequiredReliability / calculation.SemiProbabilisticOutput.PipingReliability, result, 1e-8);
         }
 
         [Test]
@@ -188,5 +234,13 @@
             // Assert
             TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, "Cannot perform a semi-probabilistic calculation without output form the piping kernel.");
         }
+
+        private PipingCalculation AsPipingCalculation(PipingOutput pipingOutput, SemiProbabilisticPipingInput semiProbabilisticPipingInput)
+        {
+            return new PipingCalculation(new GeneralPipingInput(), semiProbabilisticPipingInput)
+            {
+                Output = pipingOutput
+            };
+        }
     }
 }
\ No newline at end of file