Index: src/Plugins/Wti/Wti.Calculation/Piping/PipingCalculation.cs
===================================================================
diff -u -re4bd298c3f3762925531b11517a0f57b7005e5ad -r56799a04d6d49cdcb6706d8ada0f1d1e5d7d08dc
--- src/Plugins/Wti/Wti.Calculation/Piping/PipingCalculation.cs	(.../PipingCalculation.cs)	(revision e4bd298c3f3762925531b11517a0f57b7005e5ad)
+++ src/Plugins/Wti/Wti.Calculation/Piping/PipingCalculation.cs	(.../PipingCalculation.cs)	(revision 56799a04d6d49cdcb6706d8ada0f1d1e5d7d08dc)
@@ -1,4 +1,7 @@
-using Deltares.WTIPiping;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using Deltares.WTIPiping;
 
 namespace Wti.Calculation.Piping
 {
@@ -29,44 +32,90 @@
         /// <exception cref="PipingCalculationException">Thrown when any of the invocations of the sub-calculations from the kernel throws an Exception.</exception>
         public PipingCalculationResult Calculate()
         {
+            var upliftResult = CalculateUplift();
+            var heaveResult = CalculateHeave();
+            var sellmeijerResult = CalculateSellmeijer();
+
+            return new PipingCalculationResult(
+                upliftResult.Zu,
+                upliftResult.FoSu,
+                heaveResult.Zh,
+                heaveResult.FoSh,
+                sellmeijerResult.Zp,
+                sellmeijerResult.FoSp
+            );
+        }
+
+        /// <summary>
+        /// Returns a list of validation messages. The validation messages are based on the values of the <see cref="PipingCalculationInput"/>
+        /// which was provided to this <see cref="PipingCalculation"/> and are determined by the Piping kernel.
+        /// </summary>
+        public List<string> Validate()
+        {
+            List<string> upliftCalculatorValidationResults = CreateUpliftCalculator().Validate();
+            List<string> heaveCalculatorValidationResults = CreateHeaveCalculator().Validate();
+            List<string> sellmeijerCalculatorValidationResults = CreateSellmeijerCalculator().Validate();
+
+            return upliftCalculatorValidationResults.Concat(heaveCalculatorValidationResults).Concat(sellmeijerCalculatorValidationResults).ToList();
+        }
+
+        private Sellmeijer2011Calculator CalculateSellmeijer()
+        {
+            Sellmeijer2011Calculator sellmeijerCalculator = CreateSellmeijerCalculator();
+
             try
             {
-                var upliftResultContainer = CalculateUplift();
-                var heaveResultContainer = CalulateHeave();
-                var sellmejerResultContainer = CalulateSellmeijer();
-
-                return new PipingCalculationResult(
-                    upliftResultContainer.Zu,
-                    upliftResultContainer.FoSu,
-                    heaveResultContainer.Zh,
-                    heaveResultContainer.FoSh,
-                    sellmejerResultContainer.Zp,
-                    sellmejerResultContainer.FoSp
-                    );
+                sellmeijerCalculator.Calculate();
             }
-            catch (WTIUpliftCalculatorException e)
+            catch (PipingException<Sellmeijer2011Calculator> e)
             {
                 throw new PipingCalculationException(e.Message);
             }
-            catch (PipingException<HeaveCalculator> e)
+            catch (PipingException<SellmeijerBaseCalculator> e)
             {
                 throw new PipingCalculationException(e.Message);
             }
-            catch (PipingException<EffectiveThicknessCalculator> e)
+
+            return sellmeijerCalculator;
+        }
+
+        private HeaveCalculator CalculateHeave()
+        {
+            var heaveCalculator = CreateHeaveCalculator();
+
+            try
             {
+                heaveCalculator.Calculate();
+            }
+            catch (PipingException<HeaveCalculator> e)
+            {
                 throw new PipingCalculationException(e.Message);
             }
-            catch (PipingException<Sellmeijer2011Calculator> e)
+
+            return heaveCalculator;
+        }
+
+        private WTIUpliftCalculator CalculateUplift()
+        {
+            WTIUpliftCalculator upliftCalculator = CreateUpliftCalculator();
+            
+            try
             {
+                upliftCalculator.Calculate();
+            }
+            catch (WTIUpliftCalculatorException e)
+            {
                 throw new PipingCalculationException(e.Message);
             }
-            catch (PipingException<SellmeijerBaseCalculator> e)
+            catch (PipingException<EffectiveThicknessCalculator> e)
             {
                 throw new PipingCalculationException(e.Message);
             }
+
+            return upliftCalculator;
         }
 
-        private HeaveCalculator CalulateHeave()
+        private HeaveCalculator CreateHeaveCalculator()
         {
             var calculator = new HeaveCalculator
             {
@@ -77,11 +126,10 @@
                 RExit = input.DampingFactorExit,
                 HExit = input.PhreaticLevelExit
             };
-            calculator.Calculate();
             return calculator;
         }
 
-        private WTIUpliftCalculator CalculateUplift()
+        private WTIUpliftCalculator CreateUpliftCalculator()
         {
             var effectiveStressResult = CalculateEffectiveThickness();
 
@@ -96,11 +144,10 @@
                 HExit = input.PhreaticLevelExit,
                 PhiPolder = input.PiezometricHeadPolder
             };
-            calculator.Calculate();
             return calculator;
         }
 
-        private Sellmeijer2011Calculator CalulateSellmeijer()
+        private Sellmeijer2011Calculator CreateSellmeijerCalculator()
         {
             var calculator = new Sellmeijer2011Calculator
             {
@@ -121,7 +168,6 @@
                 D70Mean = input.MeanDiameter70,
                 BeddingAngle = input.BeddingAngle
             };
-            calculator.Calculate();
             return calculator;
         }
 
Index: test/Plugins/Wti/Wti.Calculation.Test/Piping/PipingCalculationTest.cs
===================================================================
diff -u -re4bd298c3f3762925531b11517a0f57b7005e5ad -r56799a04d6d49cdcb6706d8ada0f1d1e5d7d08dc
--- test/Plugins/Wti/Wti.Calculation.Test/Piping/PipingCalculationTest.cs	(.../PipingCalculationTest.cs)	(revision e4bd298c3f3762925531b11517a0f57b7005e5ad)
+++ test/Plugins/Wti/Wti.Calculation.Test/Piping/PipingCalculationTest.cs	(.../PipingCalculationTest.cs)	(revision 56799a04d6d49cdcb6706d8ada0f1d1e5d7d08dc)
@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using Wti.Calculation.Piping;
 
@@ -9,30 +11,7 @@
         [Test]
         public void GivenACompleteInput_WhenCalculationPerformed_ThenResultContainsNoNaN()
         {
-            Random random = new Random(22);
-            PipingCalculationInput input = new PipingCalculationInput(
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble(),
-                random.NextDouble());
+            PipingCalculationInput input = new TestPipingInput().AsRealInput();
 
             PipingCalculationResult actual = new PipingCalculation(input).Calculate();
 
@@ -44,5 +23,189 @@
             Assert.IsFalse(double.IsNaN(actual.SellmeijerZValue));
             Assert.IsFalse(double.IsNaN(actual.SellmeijerFactorOfSafety));
         }
+
+        [Test]
+        [TestCase(0)]
+        [TestCase(-1e-6)]
+        [TestCase(-100)]
+        public void Validate_ZeroOrNegativeSeepageLength_ValidationMessageForPipingLength(double seepageLength)
+        {
+            // Setup
+            PipingCalculationInput input = new TestPipingInput
+            {
+                SeepageLength = seepageLength
+            }.AsRealInput();
+
+            var calculation = new PipingCalculation(input);
+
+            // Call
+            List<string> validationMessages = calculation.Validate();
+
+            // Assert
+            Assert.AreEqual(1, validationMessages.Count);
+            Assert.IsTrue(validationMessages.Any(message => message.Contains("Piping length")));
+        }
+
+        [Test]
+        [TestCase(0)]
+        [TestCase(-1e-6)]
+        [TestCase(-100)]
+        public void Validate_ZeroOrNegativeAquiferThickness_ValidationMessageForDAquifer(double aquiferThickness)
+        {
+            // Setup
+            PipingCalculationInput input = new TestPipingInput
+            {
+                ThicknessAquiferLayer = aquiferThickness
+            }.AsRealInput();
+
+            var calculation = new PipingCalculation(input);
+
+            // Call
+            List<string> validationMessages = calculation.Validate();
+
+            // Assert
+            Assert.AreEqual(1, validationMessages.Count);
+            Assert.IsTrue(validationMessages.Any(message => message.Contains("DAquifer")));
+        }
+
+        [Test]
+        [TestCase(-1e-6)]
+        [TestCase(-100)]
+        public void Validate_NegativeBeddingAngle_ValidationMessageForBeddingAngle(double beddingAngle)
+        {
+            // Setup
+            PipingCalculationInput input = new TestPipingInput
+            {
+                BeddingAngle = beddingAngle
+            }.AsRealInput();
+
+            var calculation = new PipingCalculation(input);
+
+            // Call
+            List<string> validationMessages = calculation.Validate();
+
+            // Assert
+            Assert.AreEqual(1, validationMessages.Count);
+            Assert.IsTrue(validationMessages.Any(message => message.Contains("Bedding angle")));
+        }
+
+        [Test]
+        [TestCase(-1e-6)]
+        [TestCase(-100)]
+        public void Validate_PiezometricHeadExitSameAsPhreaticLevelExit_ValidationMessageForPhiExitAndHExit(double level)
+        {
+            // Setup
+            PipingCalculationInput input = new TestPipingInput
+            {
+                PiezometricHeadExit = level,
+                PhreaticLevelExit = level
+            }.AsRealInput();
+
+            var calculation = new PipingCalculation(input);
+
+            // Call
+            List<string> validationMessages = calculation.Validate();
+
+            // Assert
+            Assert.AreEqual(2, validationMessages.Count);
+            Assert.IsTrue(validationMessages.Any(message => message.Contains("PhiExit -  HExit")));
+            Assert.IsTrue(validationMessages.Any(message => message.Contains("phiExit - hExit")));
+        }
+
+        class TestPipingInput
+        {
+            public double WaterVolumetricWeight;
+            public double UpliftModelFactor;
+            public double AssessmentLevel;
+            public double PiezometricHeadExit;
+            public double DampingFactorExit;
+            public double PhreaticLevelExit;
+            public double PiezometricHeadPolder;
+            public double CriticalHeaveGradient;
+            public double ThicknessCoverageLayer;
+            public double SellmeijerModelFactor;
+            public double SellmeijerReductionFactor;
+            public double SeepageLength;
+            public double SandParticlesVolumicWeight;
+            public double WhitesDragCoefficient;
+            public double Diameter70;
+            public double DarcyPermeability;
+            public double WaterKinematicViscosity;
+            public double Gravity;
+            public double ExitPointXCoordinate;
+            public double BeddingAngle;
+            public double MeanDiameter70;
+            public double ThicknessAquiferLayer;
+
+            private readonly Random random = new Random(22);
+            private double last;
+
+            public TestPipingInput()
+            {
+                WaterVolumetricWeight = NextDouble();
+                UpliftModelFactor = NextDouble();
+                AssessmentLevel = NextDouble();
+                PiezometricHeadExit = NextDouble();
+                PhreaticLevelExit = NextDouble();
+                DampingFactorExit = NextDouble();
+                PiezometricHeadPolder = NextDouble();
+                CriticalHeaveGradient = NextDouble();
+                ThicknessCoverageLayer = NextDouble();
+                SellmeijerModelFactor = NextDouble();
+                SellmeijerReductionFactor = NextDouble();
+                SeepageLength = NextDouble();
+                SandParticlesVolumicWeight = NextDouble();
+                WhitesDragCoefficient = NextDouble();
+                Diameter70 = NextDouble();
+                DarcyPermeability = NextDouble();
+                WaterKinematicViscosity = NextDouble();
+                Gravity = NextDouble();
+                ExitPointXCoordinate = NextDouble();
+                BeddingAngle = NextDouble();
+                MeanDiameter70 = NextDouble();
+                ThicknessAquiferLayer = NextDouble();
+            }
+
+            /// <summary>
+            /// The returned double is sure to be different from the last time it was called.
+            /// </summary>
+            /// <returns></returns>
+            private double NextDouble()
+            {
+                return last += random.NextDouble() + 1e-6;
+            }
+
+            /// <summary>
+            /// Returns the current set value as a <see cref="PipingCalculationInput"/>
+            /// </summary>
+            /// <returns></returns>
+            public PipingCalculationInput AsRealInput()
+            {
+                return new PipingCalculationInput(
+                    WaterVolumetricWeight,
+                    UpliftModelFactor,
+                    AssessmentLevel,
+                    PiezometricHeadExit,
+                    DampingFactorExit,
+                    PhreaticLevelExit,
+                    PiezometricHeadPolder,
+                    CriticalHeaveGradient,
+                    ThicknessCoverageLayer,
+                    SellmeijerModelFactor,
+                    SellmeijerReductionFactor,
+                    SeepageLength,
+                    SandParticlesVolumicWeight,
+                    WhitesDragCoefficient,
+                    Diameter70,
+                    DarcyPermeability,
+                    WaterKinematicViscosity,
+                    Gravity,
+                    ThicknessAquiferLayer,
+                    MeanDiameter70,
+                    BeddingAngle,
+                    ExitPointXCoordinate
+                );
+            }
+        }
     }
 }
\ No newline at end of file
Index: test/Plugins/Wti/Wti.Forms.Test/Helper/PipingOutputCreator.cs
===================================================================
diff -u -r0a2e4c7ac0cdcaf0038721c74ed9c823f1e14f91 -r56799a04d6d49cdcb6706d8ada0f1d1e5d7d08dc
--- test/Plugins/Wti/Wti.Forms.Test/Helper/PipingOutputCreator.cs	(.../PipingOutputCreator.cs)	(revision 0a2e4c7ac0cdcaf0038721c74ed9c823f1e14f91)
+++ test/Plugins/Wti/Wti.Forms.Test/Helper/PipingOutputCreator.cs	(.../PipingOutputCreator.cs)	(revision 56799a04d6d49cdcb6706d8ada0f1d1e5d7d08dc)
@@ -4,7 +4,7 @@
 namespace Wti.Forms.Test.Helper
 {
     /// <summary>
-    /// Helper class to create simple PipingOutput.
+    /// Helper class to create simple <see cref="PipingOutput"/>.
     /// </summary>
     public static class PipingOutputCreator
     {