Index: Riskeer/Piping/src/Riskeer.Piping.Service/Probabilistic/ProbabilisticPipingCalculationService.cs
===================================================================
diff -u -rcf29688172754dfc3c2ff94c4ac05fc2f6f17963 -r1d1743fbce08093c724d0d180e41943e93633a8f
--- Riskeer/Piping/src/Riskeer.Piping.Service/Probabilistic/ProbabilisticPipingCalculationService.cs	(.../ProbabilisticPipingCalculationService.cs)	(revision cf29688172754dfc3c2ff94c4ac05fc2f6f17963)
+++ Riskeer/Piping/src/Riskeer.Piping.Service/Probabilistic/ProbabilisticPipingCalculationService.cs	(.../ProbabilisticPipingCalculationService.cs)	(revision 1d1743fbce08093c724d0d180e41943e93633a8f)
@@ -19,13 +19,74 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
+using System.Collections.Generic;
+using System.Linq;
+using Riskeer.Common.Data.AssessmentSection;
+using Riskeer.Common.Data.Hydraulics;
+using Riskeer.Common.IO.HydraRing;
+using Riskeer.Common.Service;
+using Riskeer.Piping.Data.Probabilistic;
+using RiskeerCommonServiceResources = Riskeer.Common.Service.Properties.Resources;
+
 namespace Riskeer.Piping.Service.Probabilistic
 {
     /// <summary>
     /// Service that provides methods for performing Hydra-ring calculations for piping probabilistic.
     /// </summary>
     public class ProbabilisticPipingCalculationService
     {
+        /// <summary>
+        /// Performs validation over the values on the given <paramref name="calculation"/>. Error and status information is logged during
+        /// the execution of the operation.
+        /// </summary>
+        /// <param name="calculation">The <see cref="ProbabilisticPipingCalculation"/> for which to validate the values.</param>
+        /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> for which to validate the values.</param>
+        /// <returns><c>true</c> if <paramref name="calculation"/> has no validation errors; <c>false</c> otherwise.</returns>
+        public static bool Validate(ProbabilisticPipingCalculation calculation, IAssessmentSection assessmentSection)
+        {
+            CalculationServiceHelper.LogValidationBegin();
+            
+            string[] hydraulicBoundaryDatabaseMessages = ValidateHydraulicBoundaryDatabase(assessmentSection).ToArray();
+            CalculationServiceHelper.LogMessagesAsError(hydraulicBoundaryDatabaseMessages);
+            if (hydraulicBoundaryDatabaseMessages.Any())
+            {
+                CalculationServiceHelper.LogValidationEnd();
+                return false;
+            }
+
+            string[] messages = ValidateInput(calculation.InputParameters).ToArray();
+            CalculationServiceHelper.LogMessagesAsError(messages);
+            
+            CalculationServiceHelper.LogValidationEnd();
+            return !messages.Any();
+        }
+
+        private static IEnumerable<string> ValidateHydraulicBoundaryDatabase(IAssessmentSection assessmentSection)
+        {
+            string preprocessorDirectory = assessmentSection.HydraulicBoundaryDatabase.EffectivePreprocessorDirectory();
+            string databaseValidationProblem = HydraulicBoundaryDatabaseConnectionValidator.Validate(assessmentSection.HydraulicBoundaryDatabase);
+            if (!string.IsNullOrEmpty(databaseValidationProblem))
+            {
+                yield return databaseValidationProblem;
+            }
+
+            string preprocessorDirectoryValidationProblem = HydraulicBoundaryDatabaseHelper.ValidatePreprocessorDirectory(preprocessorDirectory);
+            if (!string.IsNullOrEmpty(preprocessorDirectoryValidationProblem))
+            {
+                yield return preprocessorDirectoryValidationProblem;
+            }
+        }
         
+        private static IEnumerable<string> ValidateInput(ProbabilisticPipingInput input)
+        {
+            var validationResults = new List<string>();
+
+            if (input.HydraulicBoundaryLocation == null)
+            {
+                validationResults.Add(RiskeerCommonServiceResources.CalculationService_ValidateInput_No_hydraulic_boundary_location_selected);
+            }
+
+            return validationResults;
+        }
     }
 }
\ No newline at end of file
Index: Riskeer/Piping/test/Riskeer.Piping.Service.Test/Probabilistic/ProbabilisticPipingCalculationServiceTest.cs
===================================================================
diff -u -rcf29688172754dfc3c2ff94c4ac05fc2f6f17963 -r1d1743fbce08093c724d0d180e41943e93633a8f
--- Riskeer/Piping/test/Riskeer.Piping.Service.Test/Probabilistic/ProbabilisticPipingCalculationServiceTest.cs	(.../ProbabilisticPipingCalculationServiceTest.cs)	(revision cf29688172754dfc3c2ff94c4ac05fc2f6f17963)
+++ Riskeer/Piping/test/Riskeer.Piping.Service.Test/Probabilistic/ProbabilisticPipingCalculationServiceTest.cs	(.../ProbabilisticPipingCalculationServiceTest.cs)	(revision 1d1743fbce08093c724d0d180e41943e93633a8f)
@@ -19,13 +19,216 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
+using System.IO;
+using System.Linq;
+using Core.Common.TestUtil;
 using NUnit.Framework;
+using Rhino.Mocks;
+using Riskeer.Common.Data.AssessmentSection;
+using Riskeer.Common.Data.Hydraulics;
+using Riskeer.Common.Data.TestUtil;
+using Riskeer.Common.Service.TestUtil;
+using Riskeer.Piping.Data;
+using Riskeer.Piping.Data.TestUtil;
+using Riskeer.Piping.Service.Probabilistic;
 
 namespace Riskeer.Piping.Service.Test.Probabilistic
 {
     [TestFixture]
     public class ProbabilisticPipingCalculationServiceTest
     {
+        private static readonly string testDataPath = TestHelper.GetTestDataPath(TestDataPath.Riskeer.Integration.Service, "HydraRingCalculation");
+        private static readonly string validFilePath = Path.Combine(testDataPath, "HRD dutch coast south.sqlite");
         
+        [Test]
+        public void Validate_NoHydraulicBoundaryLocation_LogsMessageAndReturnFalse()
+        {
+            // Setup
+            var failureMechanism = new PipingFailureMechanism();
+
+            var mockRepository = new MockRepository();
+            IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(
+                failureMechanism, mockRepository, validFilePath);
+            mockRepository.ReplayAll();
+
+            var calculation = new TestProbabilisticPipingCalculation();
+
+            // Call
+            var isValid = false;
+            void Call() => isValid = ProbabilisticPipingCalculationService.Validate(calculation, assessmentSection);
+
+            // Assert
+            TestHelper.AssertLogMessages(Call, messages =>
+            {
+                string[] msgs = messages.ToArray();
+                Assert.AreEqual(3, msgs.Length);
+                CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
+                StringAssert.StartsWith("Er is geen hydraulische belastingenlocatie geselecteerd.", msgs[1]);
+                CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
+            });
+            Assert.IsFalse(isValid);
+
+            mockRepository.VerifyAll();
+        }
+
+        [Test]
+        public void Validate_InvalidHydraulicBoundaryDatabase_LogsMessageAndReturnFalse()
+        {
+            // Setup
+            var failureMechanism = new PipingFailureMechanism();
+
+            string invalidFilePath = Path.Combine(testDataPath, "notexisting.sqlite");
+
+            var mockRepository = new MockRepository();
+            IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
+                                                                                                           mockRepository,
+                                                                                                           invalidFilePath);
+            mockRepository.ReplayAll();
+
+            var calculation = new TestProbabilisticPipingCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 2, 2),
+                }
+            };
+
+            // Call
+            var isValid = true;
+            void Call() => isValid = ProbabilisticPipingCalculationService.Validate(calculation, assessmentSection);
+
+            // Assert
+            TestHelper.AssertLogMessages(Call, messages =>
+            {
+                string[] msgs = messages.ToArray();
+                Assert.AreEqual(3, msgs.Length);
+                CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
+                StringAssert.StartsWith("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt. Fout bij het lezen van bestand", msgs[1]);
+                CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
+            });
+            Assert.IsFalse(isValid);
+
+            mockRepository.VerifyAll();
+        }
+
+        [Test]
+        public void Validate_InvalidPreprocessorDirectory_LogsMessageAndReturnFalse()
+        {
+            // Setup
+            var failureMechanism = new PipingFailureMechanism();
+
+            var mockRepository = new MockRepository();
+            IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
+                                                                                                           mockRepository,
+                                                                                                           validFilePath);
+
+            assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.CanUsePreprocessor = true;
+            assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.UsePreprocessor = true;
+            assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.PreprocessorDirectory = "NonExistingPreprocessorDirectory";
+
+            mockRepository.ReplayAll();
+
+            var calculation = new TestProbabilisticPipingCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 2, 2),
+                }
+            };
+
+            // Call
+            var isValid = true;
+            void Call() => isValid = ProbabilisticPipingCalculationService.Validate(calculation, assessmentSection);
+
+            // Assert
+            TestHelper.AssertLogMessages(Call, messages =>
+            {
+                string[] msgs = messages.ToArray();
+                Assert.AreEqual(3, msgs.Length);
+                CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
+                Assert.AreEqual("De bestandsmap waar de preprocessor bestanden opslaat is ongeldig. De bestandsmap bestaat niet.", msgs[1]);
+                CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
+            });
+            Assert.IsFalse(isValid);
+
+            mockRepository.VerifyAll();
+        }
+
+        [Test]
+        public void Validate_ValidHydraulicBoundaryDatabaseWithoutSettings_LogsMessageAndReturnFalse()
+        {
+            // Setup
+            var failureMechanism = new PipingFailureMechanism();
+
+            string invalidFilePath = Path.Combine(testDataPath, "HRD nosettings.sqlite");
+
+            var mockRepository = new MockRepository();
+            IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
+                                                                                                           mockRepository,
+                                                                                                           invalidFilePath);
+            mockRepository.ReplayAll();
+
+            var calculation = new TestProbabilisticPipingCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 2, 2),
+                }
+            };
+
+            // Call
+            var isValid = false;
+            void Call() => isValid = ProbabilisticPipingCalculationService.Validate(calculation, assessmentSection);
+
+            // Assert
+            TestHelper.AssertLogMessages(Call, messages =>
+            {
+                string[] msgs = messages.ToArray();
+                Assert.AreEqual(3, msgs.Length);
+                CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
+                StringAssert.StartsWith("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt. Fout bij het lezen van bestand", msgs[1]);
+                CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
+            });
+            Assert.IsFalse(isValid);
+
+            mockRepository.VerifyAll();
+        }
+
+        [Test]
+        public void Validate_WithoutImportedHydraulicBoundaryDatabase_LogsMessageAndReturnFalse()
+        {
+            // Setup
+            var failureMechanism = new PipingFailureMechanism();
+
+            var mockRepository = new MockRepository();
+            IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
+                                                                                                           mockRepository);
+            mockRepository.ReplayAll();
+
+            var calculation = new TestProbabilisticPipingCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 2, 2),
+                }
+            };
+
+            // Call
+            var isValid = false;
+            void Call() => isValid = ProbabilisticPipingCalculationService.Validate(calculation, assessmentSection);
+
+            // Assert
+            TestHelper.AssertLogMessages(Call, messages =>
+            {
+                string[] msgs = messages.ToArray();
+                Assert.AreEqual(3, msgs.Length);
+                CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
+                Assert.AreEqual("Er is geen hydraulische belastingendatabase geïmporteerd.", msgs[1]);
+                CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
+            });
+            Assert.IsFalse(isValid);
+
+            mockRepository.VerifyAll();
+        }
     }
 }
\ No newline at end of file