Index: Riskeer/Integration/src/Riskeer.Integration.Service/RiskeerDataSynchronizationService.cs
===================================================================
diff -u -r9a931d552787ccfbee3455713a17d46e616ebdb2 -r2c97f863718888be8f3b35f4934c0119869b9187
--- Riskeer/Integration/src/Riskeer.Integration.Service/RiskeerDataSynchronizationService.cs	(.../RiskeerDataSynchronizationService.cs)	(revision 9a931d552787ccfbee3455713a17d46e616ebdb2)
+++ Riskeer/Integration/src/Riskeer.Integration.Service/RiskeerDataSynchronizationService.cs	(.../RiskeerDataSynchronizationService.cs)	(revision 2c97f863718888be8f3b35f4934c0119869b9187)
@@ -230,6 +230,31 @@
         }
 
         /// <summary>
+        /// Clears the output of all semi probabilistic calculations in the <see cref="IAssessmentSection"/>.
+        /// </summary>
+        /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> which contains the calculations.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> of calculations which are affected by clearing the output.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/> is <c>null</c>.</exception>
+        public static IEnumerable<IObservable> ClearAllSemiProbabilisticCalculationOutput(IAssessmentSection assessmentSection)
+        {
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
+            IEnumerable<IFailureMechanism> failureMechanisms = assessmentSection.GetFailureMechanisms();
+            
+            var changedObservables = new List<IObservable>();
+            changedObservables.AddRange(PipingDataSynchronizationService.ClearAllSemiProbabilisticCalculationOutputWithoutManualAssessmentLevel(
+                                            failureMechanisms.OfType<PipingFailureMechanism>()
+                                                             .Single()));
+            changedObservables.AddRange(MacroStabilityInwardsDataSynchronizationService.ClearAllCalculationOutputWithoutManualAssessmentLevel(
+                                            failureMechanisms.OfType<MacroStabilityInwardsFailureMechanism>()
+                                                             .Single()));
+            return changedObservables;
+        }
+
+        /// <summary>
         /// Clears the hydraulic boundary location calculation output belonging to the
         /// <see cref="FailureMechanismContribution.NormativeNorm"/>.
         /// </summary>
Index: Riskeer/Integration/test/Riskeer.Integration.Service.Test/RiskeerDataSynchronizationServiceTest.cs
===================================================================
diff -u -r9a931d552787ccfbee3455713a17d46e616ebdb2 -r2c97f863718888be8f3b35f4934c0119869b9187
--- Riskeer/Integration/test/Riskeer.Integration.Service.Test/RiskeerDataSynchronizationServiceTest.cs	(.../RiskeerDataSynchronizationServiceTest.cs)	(revision 9a931d552787ccfbee3455713a17d46e616ebdb2)
+++ Riskeer/Integration/test/Riskeer.Integration.Service.Test/RiskeerDataSynchronizationServiceTest.cs	(.../RiskeerDataSynchronizationServiceTest.cs)	(revision 2c97f863718888be8f3b35f4934c0119869b9187)
@@ -46,9 +46,13 @@
 using Riskeer.Integration.TestUtil;
 using Riskeer.MacroStabilityInwards.Data;
 using Riskeer.MacroStabilityInwards.Data.SoilProfile;
+using Riskeer.MacroStabilityInwards.Data.TestUtil;
 using Riskeer.MacroStabilityInwards.Primitives;
 using Riskeer.Piping.Data;
+using Riskeer.Piping.Data.Probabilistic;
+using Riskeer.Piping.Data.SemiProbabilistic;
 using Riskeer.Piping.Data.SoilProfile;
+using Riskeer.Piping.Data.TestUtil;
 using Riskeer.Piping.Primitives;
 using Riskeer.StabilityPointStructures.Data;
 using Riskeer.StabilityStoneCover.Data;
@@ -130,6 +134,104 @@
         }
 
         [Test]
+        public void ClearAllSemiProbabilisticCalculationOutput_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            void Call() => RiskeerDataSynchronizationService.ClearAllSemiProbabilisticCalculationOutput(null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
+        public void ClearAllSemiProbabilisticCalculationOutput_VariousCalculations_ClearsCalculationsOutputAndReturnsAffectedObjects()
+        {
+            // Setup
+            var pipingFailureMechanism = new PipingFailureMechanism();
+            pipingFailureMechanism.CalculationsGroup.Children.AddRange(new IPipingCalculationScenario<PipingInput>[]
+            {
+                new SemiProbabilisticPipingCalculationScenario
+                {
+                    Output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput()
+                },
+                new SemiProbabilisticPipingCalculationScenario
+                {
+                    InputParameters =
+                    {
+                        UseAssessmentLevelManualInput = true
+                    },
+                    Output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput()
+                },
+                new SemiProbabilisticPipingCalculationScenario(),
+                new ProbabilisticPipingCalculationScenario(),
+                new ProbabilisticPipingCalculationScenario
+                {
+                    Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints()
+                },
+                new ProbabilisticPipingCalculationScenario
+                {
+                    Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithoutIllustrationPoints()
+                }
+            });
+
+            var macroStabilityInwardsFailureMechanism = new MacroStabilityInwardsFailureMechanism();
+            macroStabilityInwardsFailureMechanism.CalculationsGroup.Children.AddRange(new[]
+            {
+                new MacroStabilityInwardsCalculationScenario(),
+                new MacroStabilityInwardsCalculationScenario
+                {
+                    InputParameters =
+                    {
+                        UseAssessmentLevelManualInput = true
+                    },
+                    Output = MacroStabilityInwardsOutputTestFactory.CreateOutput()
+                },
+                new MacroStabilityInwardsCalculationScenario
+                {
+                    Output = MacroStabilityInwardsOutputTestFactory.CreateOutput()
+                }
+            });
+
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            assessmentSection.Stub(section => section.GetFailureMechanisms()).Return(new IFailureMechanism[]
+            {
+                pipingFailureMechanism,
+                macroStabilityInwardsFailureMechanism
+            });
+            mocks.ReplayAll();
+
+            MacroStabilityInwardsCalculationScenario[] expectedAffectedMacroStabilityInwardsCalculations = macroStabilityInwardsFailureMechanism.Calculations
+                                                                                                                                                .OfType<MacroStabilityInwardsCalculationScenario>()
+                                                                                                                                                .Where(c => !c.InputParameters.UseAssessmentLevelManualInput && c.HasOutput)
+                                                                                                                                                .ToArray();
+            SemiProbabilisticPipingCalculationScenario[] expectedAffectedPipingCalculations = pipingFailureMechanism.Calculations
+                                                                                                                    .OfType<SemiProbabilisticPipingCalculationScenario>()
+                                                                                                                    .Where(c => !c.InputParameters.UseAssessmentLevelManualInput && c.HasOutput)
+                                                                                                                    .ToArray();
+
+            // Call
+            IEnumerable<IObservable> affectedItems = RiskeerDataSynchronizationService.ClearAllSemiProbabilisticCalculationOutput(assessmentSection);
+
+            // 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(macroStabilityInwardsFailureMechanism.Calculations
+                                                               .OfType<MacroStabilityInwardsCalculationScenario>()
+                                                               .Where(c => !c.InputParameters.UseAssessmentLevelManualInput)
+                                                               .All(c => !c.HasOutput));
+            Assert.IsTrue(pipingFailureMechanism.Calculations
+                                                .OfType<SemiProbabilisticPipingCalculationScenario>()
+                                                .Where(c => !c.InputParameters.UseAssessmentLevelManualInput)
+                                                .All(c => !c.HasOutput));
+
+            CollectionAssert.AreEquivalent(expectedAffectedPipingCalculations.Concat<ICalculationScenario>(expectedAffectedMacroStabilityInwardsCalculations),
+                                           affectedItems);
+            mocks.VerifyAll();
+        }
+
+        [Test]
         public void ClearAllCalculationOutputAndHydraulicBoundaryLocations_AssessmentSectionNull_ThrowsArgumentNullException()
         {
             // Call
Index: Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingDataSynchronizationServiceTest.cs
===================================================================
diff -u -rde851b1488ab6396c74afda4993973752252f0cc -r2c97f863718888be8f3b35f4934c0119869b9187
--- Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingDataSynchronizationServiceTest.cs	(.../PipingDataSynchronizationServiceTest.cs)	(revision de851b1488ab6396c74afda4993973752252f0cc)
+++ Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingDataSynchronizationServiceTest.cs	(.../PipingDataSynchronizationServiceTest.cs)	(revision 2c97f863718888be8f3b35f4934c0119869b9187)
@@ -168,7 +168,6 @@
             // 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(failureMechanism.Calculations
-                                          .OfType<IPipingCalculationScenario<PipingInput>>()
                                           .OfType<SemiProbabilisticPipingCalculationScenario>()
                                           .Where(c => !c.InputParameters.UseAssessmentLevelManualInput)
                                           .All(c => !c.HasOutput));