Index: Riskeer/Integration/src/Riskeer.Integration.Service/RiskeerDataSynchronizationService.cs
===================================================================
diff -u -r008f330233a663eff7365bd639b4a0096242b6ca -r096183e77e31be862775750ba697922a6e6d6dd8
--- Riskeer/Integration/src/Riskeer.Integration.Service/RiskeerDataSynchronizationService.cs	(.../RiskeerDataSynchronizationService.cs)	(revision 008f330233a663eff7365bd639b4a0096242b6ca)
+++ Riskeer/Integration/src/Riskeer.Integration.Service/RiskeerDataSynchronizationService.cs	(.../RiskeerDataSynchronizationService.cs)	(revision 096183e77e31be862775750ba697922a6e6d6dd8)
@@ -90,7 +90,8 @@
                 switch (failureMechanism)
                 {
                     case PipingFailureMechanism pipingFailureMechanism:
-                        changedObservables.AddRange(PipingDataSynchronizationService.ClearAllCalculationOutputAndHydraulicBoundaryLocations(pipingFailureMechanism));
+                        changedObservables.AddRange(PipingDataSynchronizationService.ClearAllCalculationOutputAndHydraulicBoundaryLocations(
+                                                        pipingFailureMechanism, hydraulicBoundaryLocations));
                         break;
                     case GrassCoverErosionInwardsFailureMechanism grassCoverErosionInwardsFailureMechanism:
                         changedObservables.AddRange(GrassCoverErosionInwardsDataSynchronizationService.ClearAllCalculationOutputAndHydraulicBoundaryLocations(grassCoverErosionInwardsFailureMechanism));
Index: Riskeer/Piping/src/Riskeer.Piping.Service/PipingDataSynchronizationService.cs
===================================================================
diff -u -r9e9976818f1b446948c3bf815cafe2e023f98ac1 -r096183e77e31be862775750ba697922a6e6d6dd8
--- Riskeer/Piping/src/Riskeer.Piping.Service/PipingDataSynchronizationService.cs	(.../PipingDataSynchronizationService.cs)	(revision 9e9976818f1b446948c3bf815cafe2e023f98ac1)
+++ Riskeer/Piping/src/Riskeer.Piping.Service/PipingDataSynchronizationService.cs	(.../PipingDataSynchronizationService.cs)	(revision 096183e77e31be862775750ba697922a6e6d6dd8)
@@ -85,27 +85,42 @@
         /// <summary>
         /// Clears:
         /// <list type="bullet">
-        /// <item>The <see cref="HydraulicBoundaryLocation"/> for all the calculations in the <see cref="PipingFailureMechanism"/>;</item>
-        /// <item>The output for all the calculations in the <see cref="PipingFailureMechanism"/>,
+        /// <item>The <see cref="HydraulicBoundaryLocation"/> for all the calculations in the <see cref="PipingFailureMechanism"/>
+        /// that uses an <see cref="HydraulicBoundaryLocation"/> from <paramref name="hydraulicBoundaryLocations"/>;</item>
+        /// <item>The output for all these calculations in the <see cref="PipingFailureMechanism"/>,
         /// except for the <see cref="SemiProbabilisticPipingCalculationScenario"/> where
         /// <see cref="SemiProbabilisticPipingInput.UseAssessmentLevelManualInput"/> is <c>true</c>.</item>
         /// </list>
         /// </summary>
         /// <param name="failureMechanism">The <see cref="PipingFailureMechanism"/> which contains the calculations.</param>
+        /// <param name="hydraulicBoundaryLocations">The hydraulic boundary locations to clear for.</param>
         /// <returns>An <see cref="IEnumerable{T}"/> of objects which are affected by removing data.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/> is <c>null</c>.</exception>
-        public static IEnumerable<IObservable> ClearAllCalculationOutputAndHydraulicBoundaryLocations(PipingFailureMechanism failureMechanism)
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
+        public static IEnumerable<IObservable> ClearAllCalculationOutputAndHydraulicBoundaryLocations(PipingFailureMechanism failureMechanism,
+                                                                                                      IEnumerable<HydraulicBoundaryLocation> hydraulicBoundaryLocations)
         {
             if (failureMechanism == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanism));
             }
 
-            var affectedItems = new List<IObservable>();
-            affectedItems.AddRange(ClearAllSemiProbabilisticCalculationOutputWithoutManualAssessmentLevel(failureMechanism));
-            affectedItems.AddRange(ClearAllProbabilisticCalculationOutput(failureMechanism));
+            if (hydraulicBoundaryLocations == null)
+            {
+                throw new ArgumentNullException(nameof(hydraulicBoundaryLocations));
+            }
 
-            foreach (IPipingCalculationScenario<PipingInput> calculation in failureMechanism.Calculations.Cast<IPipingCalculationScenario<PipingInput>>())
+            List<IObservable> affectedItems = failureMechanism.Calculations
+                                                              .OfType<SemiProbabilisticPipingCalculationScenario>()
+                                                              .Where(c => !c.InputParameters.UseAssessmentLevelManualInput)
+                                                              .Cast<ICalculation<PipingInput>>()
+                                                              .Concat(failureMechanism.Calculations.OfType<ProbabilisticPipingCalculationScenario>())
+                                                              .Where(c => hydraulicBoundaryLocations.Contains(c.InputParameters.HydraulicBoundaryLocation))
+                                                              .SelectMany(RiskeerCommonDataSynchronizationService.ClearCalculationOutput)
+                                                              .ToList();
+
+            foreach (IPipingCalculationScenario<PipingInput> calculation in failureMechanism.Calculations.Cast<IPipingCalculationScenario<PipingInput>>()
+                                                                                            .Where(c => hydraulicBoundaryLocations.Contains(
+                                                                                                       c.InputParameters.HydraulicBoundaryLocation)))
             {
                 affectedItems.AddRange(RiskeerCommonDataSynchronizationService.ClearHydraulicBoundaryLocation(calculation.InputParameters));
             }
Index: Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingDataSynchronizationServiceTest.cs
===================================================================
diff -u -r9e9976818f1b446948c3bf815cafe2e023f98ac1 -r096183e77e31be862775750ba697922a6e6d6dd8
--- Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingDataSynchronizationServiceTest.cs	(.../PipingDataSynchronizationServiceTest.cs)	(revision 9e9976818f1b446948c3bf815cafe2e023f98ac1)
+++ Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingDataSynchronizationServiceTest.cs	(.../PipingDataSynchronizationServiceTest.cs)	(revision 096183e77e31be862775750ba697922a6e6d6dd8)
@@ -25,6 +25,9 @@
 using Core.Common.Base;
 using NUnit.Framework;
 using Riskeer.Common.Data.Calculation;
+using Riskeer.Common.Data.Hydraulics;
+using Riskeer.Common.Data.TestUtil;
+using Riskeer.Common.Data.TestUtil.IllustrationPoints;
 using Riskeer.Common.Service;
 using Riskeer.Piping.Data;
 using Riskeer.Piping.Data.Probabilistic;
@@ -151,42 +154,85 @@
         public void ClearAllCalculationOutputAndHydraulicBoundaryLocations_FailureMechanismNull_ThrowsArgumentNullException()
         {
             // Call
-            void Call() => PipingDataSynchronizationService.ClearAllCalculationOutputAndHydraulicBoundaryLocations(null);
+            void Call() => PipingDataSynchronizationService.ClearAllCalculationOutputAndHydraulicBoundaryLocations(null, Enumerable.Empty<HydraulicBoundaryLocation>());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("failureMechanism", exception.ParamName);
         }
 
         [Test]
+        public void ClearAllCalculationOutputAndHydraulicBoundaryLocations_HydraulicBoundaryLocationsNull_ThrowsArgumentNullException()
+        {
+            // Call
+            void Call() => PipingDataSynchronizationService.ClearAllCalculationOutputAndHydraulicBoundaryLocations(new PipingFailureMechanism(), null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("hydraulicBoundaryLocations", exception.ParamName);
+        }
+
+        [Test]
         public void ClearAllCalculationOutputAndHydraulicBoundaryLocations_WithVariousCalculations_ClearsHydraulicBoundaryLocationAndCalculationsAndReturnsAffectedObjects()
         {
             // Setup
-            PipingFailureMechanism failureMechanism = PipingTestDataGenerator.GetPipingFailureMechanismWithAllCalculationConfigurations();
+            var failureMechanism = new PipingFailureMechanism();
+            var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
+            PipingTestDataGenerator.ConfigureFailureMechanismWithAllCalculationConfigurations(failureMechanism, hydraulicBoundaryLocation);
+            failureMechanism.CalculationsGroup.Children.AddRange(new IPipingCalculationScenario<PipingInput>[]
+            {
+                new SemiProbabilisticPipingCalculationScenario
+                {
+                    InputParameters =
+                    {
+                        UseAssessmentLevelManualInput = false,
+                        HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation()
+                    },
+                    Output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties())
+                },
+                new ProbabilisticPipingCalculationScenario
+                {
+                    InputParameters =
+                    {
+                        HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation()
+                    },
+                    Output = new ProbabilisticPipingOutput(new TestPartialProbabilisticPipingOutput(0, new TestGeneralResult<TestTopLevelIllustrationPoint>()),
+                                                           new TestPartialProbabilisticPipingOutput(0, new TestGeneralResult<TestTopLevelIllustrationPoint>()))
+                },
+                new TestPipingCalculationScenario(new TestPipingInput
+                {
+                    HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation()
+                })
+            });
+
             IPipingCalculationScenario<PipingInput>[] calculations = failureMechanism.Calculations.Cast<IPipingCalculationScenario<PipingInput>>()
                                                                                      .ToArray();
 
-            var expectedAffectedItems = new List<IObservable>();
-            expectedAffectedItems.AddRange(calculations.OfType<SemiProbabilisticPipingCalculationScenario>()
-                                                       .Where(c => !c.InputParameters.UseAssessmentLevelManualInput
-                                                                   && c.HasOutput));
-            expectedAffectedItems.AddRange(calculations.OfType<ProbabilisticPipingCalculationScenario>()
-                                                       .Where(c => c.HasOutput));
+            var expectedAffectedCalculations = new List<IPipingCalculationScenario<PipingInput>>();
+            expectedAffectedCalculations.AddRange(calculations.OfType<SemiProbabilisticPipingCalculationScenario>()
+                                                              .Where(c => !c.InputParameters.UseAssessmentLevelManualInput
+                                                                          && c.InputParameters.HydraulicBoundaryLocation == hydraulicBoundaryLocation
+                                                                          && c.HasOutput));
+            expectedAffectedCalculations.AddRange(calculations.OfType<ProbabilisticPipingCalculationScenario>()
+                                                              .Where(c => c.InputParameters.HydraulicBoundaryLocation == hydraulicBoundaryLocation
+                                                                          && c.HasOutput));
+
+            var expectedAffectedItems = new List<IObservable>(expectedAffectedCalculations);
             expectedAffectedItems.AddRange(calculations.Select(c => c.InputParameters)
-                                                       .Where(i => i.HydraulicBoundaryLocation != null));
+                                                       .Where(i => i.HydraulicBoundaryLocation == hydraulicBoundaryLocation));
 
             // Call
-            IEnumerable<IObservable> affectedItems = PipingDataSynchronizationService.ClearAllCalculationOutputAndHydraulicBoundaryLocations(failureMechanism);
+            IEnumerable<IObservable> affectedItems = PipingDataSynchronizationService.ClearAllCalculationOutputAndHydraulicBoundaryLocations(
+                failureMechanism, new[]
+                {
+                    hydraulicBoundaryLocation
+                });
 
             // Assert
             // Note: To make sure the clear is performed regardless of what is done with
             // the return result, no ToArray() should be called before these assertions:
-            Assert.IsTrue(calculations.OfType<SemiProbabilisticPipingCalculationScenario>()
-                                      .Where(c => !c.InputParameters.UseAssessmentLevelManualInput)
-                                      .All(c => !c.HasOutput));
-            Assert.IsTrue(calculations.OfType<ProbabilisticPipingCalculationScenario>()
-                                      .All(c => !c.HasOutput));
-            Assert.IsTrue(calculations.All(c => c.InputParameters.HydraulicBoundaryLocation == null));
+            Assert.IsTrue(expectedAffectedCalculations.All(c => !c.HasOutput));
+            Assert.IsTrue(calculations.All(c => c.InputParameters.HydraulicBoundaryLocation != hydraulicBoundaryLocation));
 
             CollectionAssert.AreEquivalent(expectedAffectedItems, affectedItems);
         }