Index: Riskeer/Piping/src/Riskeer.Piping.Service/PipingDataSynchronizationService.cs
===================================================================
diff -u -r356b1bc9480c286a82e259868d21e93fb0bc8390 -r5592d157be0bb64ab16660411dadc652df2daed1
--- Riskeer/Piping/src/Riskeer.Piping.Service/PipingDataSynchronizationService.cs	(.../PipingDataSynchronizationService.cs)	(revision 356b1bc9480c286a82e259868d21e93fb0bc8390)
+++ Riskeer/Piping/src/Riskeer.Piping.Service/PipingDataSynchronizationService.cs	(.../PipingDataSynchronizationService.cs)	(revision 5592d157be0bb64ab16660411dadc652df2daed1)
@@ -25,6 +25,7 @@
 using System.Linq;
 using Core.Common.Base;
 using Riskeer.Common.Data.Calculation;
+using Riskeer.Common.Data.FailureMechanism;
 using Riskeer.Common.Data.Hydraulics;
 using Riskeer.Common.IO.SoilProfile;
 using Riskeer.Common.Service;
@@ -97,7 +98,7 @@
             }
 
             var affectedItems = new List<IObservable>();
-            foreach (PipingCalculation<PipingInput, PipingOutput> calculation in failureMechanism.Calculations.Cast<PipingCalculation<PipingInput, PipingOutput>>())
+            foreach (IPipingCalculation<PipingInput, PipingOutput> calculation in failureMechanism.Calculations.Cast<IPipingCalculation<PipingInput, PipingOutput>>())
             {
                 affectedItems.AddRange(ClearCalculationOutput(calculation)
                                            .Concat(ClearHydraulicBoundaryLocation(calculation.InputParameters)));
@@ -166,9 +167,9 @@
                 throw new ArgumentNullException(nameof(surfaceLine));
             }
 
-            IEnumerable<PipingCalculation<PipingInput, PipingOutput>> pipingCalculationScenarios =
+            IEnumerable<IPipingCalculation<PipingInput, PipingOutput>> pipingCalculationScenarios =
                 failureMechanism.Calculations
-                                .Cast<PipingCalculation<PipingInput, PipingOutput>>()
+                                .Cast<IPipingCalculation<PipingInput, PipingOutput>>()
                                 .Where(pcs => ReferenceEquals(pcs.InputParameters.SurfaceLine, surfaceLine));
 
             List<IObservable> changedObservables = RemoveSurfaceLineDependentData(pipingCalculationScenarios).ToList();
@@ -194,9 +195,9 @@
                 throw new ArgumentNullException(nameof(failureMechanism));
             }
 
-            IEnumerable<PipingCalculation<PipingInput, PipingOutput>> affectedCalculationScenarios =
+            IEnumerable<IPipingCalculation<PipingInput, PipingOutput>> affectedCalculationScenarios =
                 failureMechanism.Calculations
-                                .Cast<PipingCalculation<PipingInput, PipingOutput>>()
+                                .Cast<IPipingCalculation<PipingInput, PipingOutput>>()
                                 .Where(calc => calc.InputParameters.SurfaceLine != null).ToArray();
 
             List<IObservable> affectedObjects = RemoveSurfaceLineDependentData(affectedCalculationScenarios).ToList();
@@ -231,12 +232,12 @@
 
             var changedObservables = new List<IObservable>();
 
-            IEnumerable<PipingCalculation<PipingInput, PipingOutput>> pipingCalculationScenarios =
+            IEnumerable<IPipingCalculation<PipingInput, PipingOutput>> pipingCalculationScenarios =
                 failureMechanism.Calculations
-                                .Cast<PipingCalculation<PipingInput, PipingOutput>>()
+                                .Cast<IPipingCalculation<PipingInput, PipingOutput>>()
                                 .Where(pcs => ReferenceEquals(pcs.InputParameters.StochasticSoilModel, soilModel));
 
-            foreach (PipingCalculation<PipingInput, PipingOutput> pipingCalculationScenario in pipingCalculationScenarios)
+            foreach (IPipingCalculation<PipingInput, PipingOutput> pipingCalculationScenario in pipingCalculationScenarios)
             {
                 changedObservables.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(pipingCalculationScenario));
                 changedObservables.AddRange(ClearStochasticSoilModel(pipingCalculationScenario.InputParameters));
@@ -263,13 +264,13 @@
                 throw new ArgumentNullException(nameof(failureMechanism));
             }
 
-            IEnumerable<PipingCalculation<PipingInput, PipingOutput>> affectedCalculationScenarios =
+            IEnumerable<IPipingCalculation<PipingInput, PipingOutput>> affectedCalculationScenarios =
                 failureMechanism.Calculations
-                                .Cast<PipingCalculation<PipingInput, PipingOutput>>()
+                                .Cast<IPipingCalculation<PipingInput, PipingOutput>>()
                                 .Where(calc => calc.InputParameters.StochasticSoilModel != null).ToArray();
 
             var affectedObjects = new List<IObservable>();
-            foreach (PipingCalculation<PipingInput, PipingOutput> calculation in affectedCalculationScenarios)
+            foreach (IPipingCalculation<PipingInput, PipingOutput> calculation in affectedCalculationScenarios)
             {
                 affectedObjects.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation));
                 affectedObjects.AddRange(ClearStochasticSoilModel(calculation.InputParameters));
@@ -305,7 +306,7 @@
 
             var changedObservables = new List<IObservable>();
 
-            foreach (PipingCalculation<PipingInput, PipingOutput> pipingCalculationScenario in GetCalculationsWithSoilProfileAssigned(failureMechanism, soilProfile))
+            foreach (IPipingCalculation<PipingInput, PipingOutput> pipingCalculationScenario in GetCalculationsWithSoilProfileAssigned(failureMechanism, soilProfile))
             {
                 changedObservables.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(pipingCalculationScenario));
                 changedObservables.AddRange(ClearStochasticSoilProfile(pipingCalculationScenario.InputParameters));
@@ -339,7 +340,7 @@
 
             var changedObservables = new List<IObservable>();
 
-            foreach (PipingCalculation<PipingInput, PipingOutput> calculation in GetCalculationsWithSoilProfileAssigned(failureMechanism, soilProfile))
+            foreach (IPipingCalculation<PipingInput, PipingOutput> calculation in GetCalculationsWithSoilProfileAssigned(failureMechanism, soilProfile))
             {
                 changedObservables.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation));
                 changedObservables.Add(calculation.InputParameters);
@@ -348,10 +349,10 @@
             return changedObservables;
         }
 
-        private static IEnumerable<IObservable> RemoveSurfaceLineDependentData(IEnumerable<PipingCalculation<PipingInput, PipingOutput>> pipingCalculationScenarios)
+        private static IEnumerable<IObservable> RemoveSurfaceLineDependentData(IEnumerable<IPipingCalculation<PipingInput, PipingOutput>> pipingCalculationScenarios)
         {
             var changedObservables = new List<IObservable>();
-            foreach (PipingCalculation<PipingInput, PipingOutput> pipingCalculationScenario in pipingCalculationScenarios)
+            foreach (IPipingCalculation<PipingInput, PipingOutput> pipingCalculationScenario in pipingCalculationScenarios)
             {
                 changedObservables.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(pipingCalculationScenario));
                 changedObservables.AddRange(ClearSurfaceLine(pipingCalculationScenario.InputParameters));
@@ -360,14 +361,12 @@
             return changedObservables;
         }
 
-        private static IEnumerable<PipingCalculation<PipingInput, PipingOutput>> GetCalculationsWithSoilProfileAssigned(PipingFailureMechanism failureMechanism,
-                                                                                                                        PipingStochasticSoilProfile soilProfile)
+        private static IEnumerable<IPipingCalculation<PipingInput, PipingOutput>> GetCalculationsWithSoilProfileAssigned(IFailureMechanism failureMechanism,
+                                                                                                                         PipingStochasticSoilProfile soilProfile)
         {
-            IEnumerable<PipingCalculation<PipingInput, PipingOutput>> pipingCalculationScenarios =
-                failureMechanism.Calculations
-                                .Cast<PipingCalculation<PipingInput, PipingOutput>>()
-                                .Where(pcs => ReferenceEquals(pcs.InputParameters.StochasticSoilProfile, soilProfile));
-            return pipingCalculationScenarios;
+            return failureMechanism.Calculations
+                                   .Cast<IPipingCalculation<PipingInput, PipingOutput>>()
+                                   .Where(pcs => ReferenceEquals(pcs.InputParameters.StochasticSoilProfile, soilProfile));
         }
 
         private static IEnumerable<IObservable> ClearSurfaceLine(PipingInput input)
Index: Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingDataSynchronizationServiceTest.cs
===================================================================
diff -u -r3a17278b768b9fad2ea946607126a15b8854f02a -r5592d157be0bb64ab16660411dadc652df2daed1
--- Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingDataSynchronizationServiceTest.cs	(.../PipingDataSynchronizationServiceTest.cs)	(revision 3a17278b768b9fad2ea946607126a15b8854f02a)
+++ Riskeer/Piping/test/Riskeer.Piping.Service.Test/PipingDataSynchronizationServiceTest.cs	(.../PipingDataSynchronizationServiceTest.cs)	(revision 5592d157be0bb64ab16660411dadc652df2daed1)
@@ -134,7 +134,7 @@
         {
             // Setup
             PipingFailureMechanism failureMechanism = PipingTestDataGenerator.GetPipingFailureMechanismWithAllCalculationConfigurations();
-            PipingCalculation<PipingInput, PipingOutput>[] calculations = failureMechanism.Calculations.Cast<PipingCalculation<PipingInput, PipingOutput>>().ToArray();
+            IPipingCalculation<PipingInput, PipingOutput>[] calculations = failureMechanism.Calculations.Cast<IPipingCalculation<PipingInput, PipingOutput>>().ToArray();
             IObservable[] expectedAffectedCalculations = calculations.Where(c => c.HasOutput)
                                                                      .Cast<IObservable>()
                                                                      .ToArray();
@@ -150,7 +150,7 @@
             // 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
-                                          .Cast<PipingCalculation<PipingInput, PipingOutput>>()
+                                          .Cast<IPipingCalculation<PipingInput, PipingOutput>>()
                                           .All(c => c.InputParameters.HydraulicBoundaryLocation == null &&
                                                     !c.HasOutput));
 
@@ -239,12 +239,12 @@
             // Setup
             PipingFailureMechanism failureMechanism = PipingTestDataGenerator.GetPipingFailureMechanismWithAllCalculationConfigurations();
             PipingSurfaceLine surfaceLine = failureMechanism.SurfaceLines[0];
-            PipingCalculation<PipingInput, PipingOutput>[] calculationsWithSurfaceLine = failureMechanism.Calculations
-                                                                                                         .Cast<PipingCalculation<PipingInput, PipingOutput>>()
-                                                                                                         .Where(c => ReferenceEquals(c.InputParameters.SurfaceLine, surfaceLine))
-                                                                                                         .ToArray();
-            PipingCalculation<PipingInput, PipingOutput>[] calculationsWithOutput = calculationsWithSurfaceLine.Where(c => c.HasOutput)
-                                                                                                               .ToArray();
+            IPipingCalculation<PipingInput, PipingOutput>[] calculationsWithSurfaceLine = failureMechanism.Calculations
+                                                                                                          .Cast<IPipingCalculation<PipingInput, PipingOutput>>()
+                                                                                                          .Where(c => ReferenceEquals(c.InputParameters.SurfaceLine, surfaceLine))
+                                                                                                          .ToArray();
+            IPipingCalculation<PipingInput, PipingOutput>[] calculationsWithOutput = calculationsWithSurfaceLine.Where(c => c.HasOutput)
+                                                                                                                .ToArray();
 
             // Precondition
             CollectionAssert.IsNotEmpty(calculationsWithSurfaceLine);
@@ -256,7 +256,7 @@
             // 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:
             CollectionAssert.DoesNotContain(failureMechanism.SurfaceLines, surfaceLine);
-            foreach (PipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithSurfaceLine)
+            foreach (IPipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithSurfaceLine)
             {
                 Assert.IsNull(calculation.InputParameters.SurfaceLine);
             }
@@ -265,7 +265,7 @@
             int expectedAffectedObjectCount = 1 + calculationsWithOutput.Length + calculationsWithSurfaceLine.Length;
             Assert.AreEqual(expectedAffectedObjectCount, affectedObjectsArray.Length);
 
-            foreach (PipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithOutput)
+            foreach (IPipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithOutput)
             {
                 Assert.IsFalse(calculation.HasOutput);
             }
@@ -297,12 +297,12 @@
         {
             // Setup
             PipingFailureMechanism failureMechanism = PipingTestDataGenerator.GetPipingFailureMechanismWithAllCalculationConfigurations();
-            PipingCalculation<PipingInput, PipingOutput>[] calculationsWithSurfaceLine = failureMechanism.Calculations
-                                                                                                         .Cast<PipingCalculation<PipingInput, PipingOutput>>()
-                                                                                                         .Where(calc => calc.InputParameters.SurfaceLine != null)
-                                                                                                         .ToArray();
-            PipingCalculation<PipingInput, PipingOutput>[] calculationsWithOutput = calculationsWithSurfaceLine.Where(c => c.HasOutput)
-                                                                                                               .ToArray();
+            IPipingCalculation<PipingInput, PipingOutput>[] calculationsWithSurfaceLine = failureMechanism.Calculations
+                                                                                                          .Cast<IPipingCalculation<PipingInput, PipingOutput>>()
+                                                                                                          .Where(calc => calc.InputParameters.SurfaceLine != null)
+                                                                                                          .ToArray();
+            IPipingCalculation<PipingInput, PipingOutput>[] calculationsWithOutput = calculationsWithSurfaceLine.Where(c => c.HasOutput)
+                                                                                                                .ToArray();
 
             // Precondition
             CollectionAssert.IsNotEmpty(calculationsWithSurfaceLine);
@@ -314,7 +314,7 @@
             // 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:
             CollectionAssert.IsEmpty(failureMechanism.SurfaceLines);
-            foreach (PipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithSurfaceLine)
+            foreach (IPipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithSurfaceLine)
             {
                 Assert.IsNull(calculation.InputParameters.SurfaceLine);
             }
@@ -323,7 +323,7 @@
             int expectedAffectedObjectCount = 1 + calculationsWithOutput.Length + calculationsWithSurfaceLine.Length;
             Assert.AreEqual(expectedAffectedObjectCount, affectedObjectsArray.Length);
 
-            foreach (PipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithOutput)
+            foreach (IPipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithOutput)
             {
                 Assert.IsFalse(calculation.HasOutput);
             }
@@ -373,12 +373,12 @@
             // Setup
             PipingFailureMechanism failureMechanism = PipingTestDataGenerator.GetPipingFailureMechanismWithAllCalculationConfigurations();
             PipingStochasticSoilModel soilModel = failureMechanism.StochasticSoilModels[1];
-            PipingCalculation<PipingInput, PipingOutput>[] calculationsWithSoilModel = failureMechanism.Calculations
-                                                                                                       .Cast<PipingCalculation<PipingInput, PipingOutput>>()
-                                                                                                       .Where(c => ReferenceEquals(c.InputParameters.StochasticSoilModel, soilModel))
-                                                                                                       .ToArray();
-            PipingCalculation<PipingInput, PipingOutput>[] calculationsWithOutput = calculationsWithSoilModel.Where(c => c.HasOutput)
-                                                                                                             .ToArray();
+            IPipingCalculation<PipingInput, PipingOutput>[] calculationsWithSoilModel = failureMechanism.Calculations
+                                                                                                        .Cast<IPipingCalculation<PipingInput, PipingOutput>>()
+                                                                                                        .Where(c => ReferenceEquals(c.InputParameters.StochasticSoilModel, soilModel))
+                                                                                                        .ToArray();
+            IPipingCalculation<PipingInput, PipingOutput>[] calculationsWithOutput = calculationsWithSoilModel.Where(c => c.HasOutput)
+                                                                                                              .ToArray();
 
             // Precondition
             CollectionAssert.IsNotEmpty(calculationsWithSoilModel);
@@ -390,7 +390,7 @@
             // 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:
             CollectionAssert.DoesNotContain(failureMechanism.StochasticSoilModels, soilModel);
-            foreach (PipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithSoilModel)
+            foreach (IPipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithSoilModel)
             {
                 Assert.IsNull(calculation.InputParameters.StochasticSoilModel);
             }
@@ -399,7 +399,7 @@
             int expectedAffectedObjectCount = 1 + calculationsWithOutput.Length + calculationsWithSoilModel.Length;
             Assert.AreEqual(expectedAffectedObjectCount, affectedObjectsArray.Length);
 
-            foreach (PipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithOutput)
+            foreach (IPipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithOutput)
             {
                 Assert.IsFalse(calculation.HasOutput);
             }
@@ -431,12 +431,12 @@
         {
             // Setup
             PipingFailureMechanism failureMechanism = PipingTestDataGenerator.GetPipingFailureMechanismWithAllCalculationConfigurations();
-            PipingCalculation<PipingInput, PipingOutput>[] calculationsWithStochasticSoilModel = failureMechanism.Calculations
-                                                                                                                 .Cast<PipingCalculation<PipingInput, PipingOutput>>()
-                                                                                                                 .Where(calc => calc.InputParameters.StochasticSoilModel != null)
-                                                                                                                 .ToArray();
-            PipingCalculation<PipingInput, PipingOutput>[] calculationsWithOutput = calculationsWithStochasticSoilModel.Where(c => c.HasOutput)
-                                                                                                                       .ToArray();
+            IPipingCalculation<PipingInput, PipingOutput>[] calculationsWithStochasticSoilModel = failureMechanism.Calculations
+                                                                                                                  .Cast<IPipingCalculation<PipingInput, PipingOutput>>()
+                                                                                                                  .Where(calc => calc.InputParameters.StochasticSoilModel != null)
+                                                                                                                  .ToArray();
+            IPipingCalculation<PipingInput, PipingOutput>[] calculationsWithOutput = calculationsWithStochasticSoilModel.Where(c => c.HasOutput)
+                                                                                                                        .ToArray();
 
             // Precondition
             CollectionAssert.IsNotEmpty(calculationsWithStochasticSoilModel);
@@ -448,7 +448,7 @@
             // 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:
             CollectionAssert.IsEmpty(failureMechanism.StochasticSoilModels);
-            foreach (PipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithStochasticSoilModel)
+            foreach (IPipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithStochasticSoilModel)
             {
                 Assert.IsNull(calculation.InputParameters.StochasticSoilModel);
             }
@@ -457,7 +457,7 @@
             int expectedAffectedObjectCount = 1 + calculationsWithOutput.Length + calculationsWithStochasticSoilModel.Length;
             Assert.AreEqual(expectedAffectedObjectCount, affectedObjectsArray.Length);
 
-            foreach (PipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithOutput)
+            foreach (IPipingCalculation<PipingInput, PipingOutput> calculation in calculationsWithOutput)
             {
                 Assert.IsFalse(calculation.HasOutput);
             }