Index: Riskeer/Piping/src/Riskeer.Piping.Service/PipingDataSynchronizationService.cs
===================================================================
diff -u -rf3889f7c9d59a70d2da5be02cdb3858435dad29f -rde851b1488ab6396c74afda4993973752252f0cc
--- Riskeer/Piping/src/Riskeer.Piping.Service/PipingDataSynchronizationService.cs	(.../PipingDataSynchronizationService.cs)	(revision f3889f7c9d59a70d2da5be02cdb3858435dad29f)
+++ Riskeer/Piping/src/Riskeer.Piping.Service/PipingDataSynchronizationService.cs	(.../PipingDataSynchronizationService.cs)	(revision de851b1488ab6396c74afda4993973752252f0cc)
@@ -87,25 +87,23 @@
         }
 
         /// <summary>
-        /// Clears the output for all calculations in the <see cref="PipingFailureMechanism"/>,
+        /// Clears the output for all <see cref="SemiProbabilisticPipingCalculationScenario"/> in the <see cref="PipingFailureMechanism"/>,
         /// except for the <see cref="SemiProbabilisticPipingCalculationScenario"/> where
         /// <see cref="SemiProbabilisticPipingInput.UseAssessmentLevelManualInput"/> is <c>true</c>.
         /// </summary>
         /// <param name="failureMechanism">The <see cref="PipingFailureMechanism"/> 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="failureMechanism"/> is <c>null</c>.</exception>
-        public static IEnumerable<IObservable> ClearAllCalculationOutputWithoutManualAssessmentLevel(PipingFailureMechanism failureMechanism)
+        public static IEnumerable<IObservable> ClearAllSemiProbabilisticCalculationOutputWithoutManualAssessmentLevel(PipingFailureMechanism failureMechanism)
         {
             if (failureMechanism == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanism));
             }
 
             return failureMechanism.Calculations
-                                   .OfType<IPipingCalculationScenario<PipingInput>>()
-                                   .Except(failureMechanism.Calculations
-                                                           .OfType<SemiProbabilisticPipingCalculationScenario>()
-                                                           .Where(c => c.InputParameters.UseAssessmentLevelManualInput))
+                                   .OfType<SemiProbabilisticPipingCalculationScenario>()
+                                   .Where(c => !c.InputParameters.UseAssessmentLevelManualInput)
                                    .SelectMany(ClearCalculationOutput)
                                    .ToArray();
         }
Index: Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingDataSynchronizationServiceTest.cs
===================================================================
diff -u -rf3889f7c9d59a70d2da5be02cdb3858435dad29f -rde851b1488ab6396c74afda4993973752252f0cc
--- Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingDataSynchronizationServiceTest.cs	(.../PipingDataSynchronizationServiceTest.cs)	(revision f3889f7c9d59a70d2da5be02cdb3858435dad29f)
+++ Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingDataSynchronizationServiceTest.cs	(.../PipingDataSynchronizationServiceTest.cs)	(revision de851b1488ab6396c74afda4993973752252f0cc)
@@ -115,18 +115,18 @@
         }
 
         [Test]
-        public void ClearAllCalculationOutputWithoutManualAssessmentLevel_FailureMechanismNull_ThrowsArgumentNullException()
+        public void ClearAllSemiProbabilisticCalculationOutputWithoutManualAssessmentLevel_FailureMechanismNull_ThrowsArgumentNullException()
         {
             // Call
-            void Call() => PipingDataSynchronizationService.ClearAllCalculationOutputWithoutManualAssessmentLevel(null);
+            void Call() => PipingDataSynchronizationService.ClearAllSemiProbabilisticCalculationOutputWithoutManualAssessmentLevel(null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("failureMechanism", exception.ParamName);
         }
 
         [Test]
-        public void ClearAllCalculationOutputWithoutManualAssessmentLevel_WithVariousCalculations_ClearsCalculationsOutputAndReturnsAffectedCalculations()
+        public void ClearAllSemiProbabilisticCalculationOutputWithoutManualAssessmentLevel_WithVariousCalculations_ClearsCalculationsOutputAndReturnsAffectedCalculations()
         {
             // Setup
             PipingFailureMechanism failureMechanism = PipingTestDataGenerator.GetPipingFailureMechanismWithAllCalculationConfigurations();
@@ -156,26 +156,21 @@
                 }
             });
 
-            SemiProbabilisticPipingCalculationScenario[] exceptCalculations = failureMechanism.Calculations
-                                                                                              .OfType<SemiProbabilisticPipingCalculationScenario>()
-                                                                                              .Where(c => c.InputParameters.UseAssessmentLevelManualInput)
-                                                                                              .ToArray();
+            SemiProbabilisticPipingCalculationScenario[] expectedAffectedCalculations = failureMechanism.Calculations
+                                                                                                        .OfType<SemiProbabilisticPipingCalculationScenario>()
+                                                                                                        .Where(c => !c.InputParameters.UseAssessmentLevelManualInput && c.HasOutput)
+                                                                                                        .ToArray();
 
-            IPipingCalculationScenario<PipingInput>[] expectedAffectedCalculations = failureMechanism.Calculations
-                                                                                                     .OfType<IPipingCalculationScenario<PipingInput>>()
-                                                                                                     .Except(exceptCalculations)
-                                                                                                     .Where(c => c.HasOutput)
-                                                                                                     .ToArray();
-
             // Call
-            IEnumerable<IObservable> affectedItems = PipingDataSynchronizationService.ClearAllCalculationOutputWithoutManualAssessmentLevel(failureMechanism);
+            IEnumerable<IObservable> affectedItems = PipingDataSynchronizationService.ClearAllSemiProbabilisticCalculationOutputWithoutManualAssessmentLevel(failureMechanism);
 
             // 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(failureMechanism.Calculations
                                           .OfType<IPipingCalculationScenario<PipingInput>>()
-                                          .Except(exceptCalculations)
+                                          .OfType<SemiProbabilisticPipingCalculationScenario>()
+                                          .Where(c => !c.InputParameters.UseAssessmentLevelManualInput)
                                           .All(c => !c.HasOutput));
 
             CollectionAssert.AreEquivalent(expectedAffectedCalculations, affectedItems);