Index: Ringtoets/Common/src/Ringtoets.Common.Data/FailureMechanism/ICalculationItem.cs
===================================================================
diff -u -rfa424689d48793c024e73bfcee1c202559eea3e0 -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Common/src/Ringtoets.Common.Data/FailureMechanism/ICalculationItem.cs	(.../ICalculationItem.cs)	(revision fa424689d48793c024e73bfcee1c202559eea3e0)
+++ Ringtoets/Common/src/Ringtoets.Common.Data/FailureMechanism/ICalculationItem.cs	(.../ICalculationItem.cs)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -19,15 +19,14 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
-using Core.Common.Base;
 using Ringtoets.HydraRing.Data;
 
 namespace Ringtoets.Common.Data.FailureMechanism
 {
     /// <summary>
     /// A calculation related object.
     /// </summary>
-    public interface ICalculationItem : ICommentable, IObservable
+    public interface ICalculationItem : ICalculation, ICommentable
     {
         /// <summary>
         /// Clears the calculated output.
@@ -39,4 +38,4 @@
         /// </summary>
         void ClearHydraulicBoundaryLocation();
     }
-}
+}
\ No newline at end of file
Index: Ringtoets/Common/src/Ringtoets.Common.Data/ICalculation.cs
===================================================================
diff -u
--- Ringtoets/Common/src/Ringtoets.Common.Data/ICalculation.cs	(revision 0)
+++ Ringtoets/Common/src/Ringtoets.Common.Data/ICalculation.cs	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -0,0 +1,41 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using Core.Common.Base;
+
+namespace Ringtoets.Common.Data
+{
+    /// <summary>
+    /// A calculation related object.
+    /// </summary>
+    public interface ICalculation : IObservable
+    {
+        /// <summary>
+        /// Gets the name of this calculation object.
+        /// </summary>
+        string Name { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether or not  this calculation item contains calculation outputs.
+        /// </summary>
+        bool HasOutput { get; }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Common/src/Ringtoets.Common.Data/Ringtoets.Common.Data.csproj
===================================================================
diff -u -r1e4d77c17c6eac78bfd705efdff9e52b4fca2c7e -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Common/src/Ringtoets.Common.Data/Ringtoets.Common.Data.csproj	(.../Ringtoets.Common.Data.csproj)	(revision 1e4d77c17c6eac78bfd705efdff9e52b4fca2c7e)
+++ Ringtoets/Common/src/Ringtoets.Common.Data/Ringtoets.Common.Data.csproj	(.../Ringtoets.Common.Data.csproj)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -52,6 +52,7 @@
     <Compile Include="FailureMechanism\ICalculationScenario.cs" />
     <Compile Include="FailureMechanism\IFailureMechanism.cs" />
     <Compile Include="ICommentable.cs" />
+    <Compile Include="ICalculation.cs" />
     <Compile Include="Probabilistics\DesignVariable.cs" />
     <Compile Include="Probabilistics\IDistribution.cs" />
     <Compile Include="Probabilistics\LognormalDistribution.cs" />
Fisheye: Tag 314545f25db70366badcc527aeca68d241bfdcdc refers to a dead (removed) revision in file `Ringtoets/Piping/src/Ringtoets.Piping.Data/IPipingCalculationItem.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/IPipingCalculationItemExtensions.cs
===================================================================
diff -u -r0b081b2391e73b7e3ff04ef31fafd2df1b1571e3 -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Piping/src/Ringtoets.Piping.Data/IPipingCalculationItemExtensions.cs	(.../IPipingCalculationItemExtensions.cs)	(revision 0b081b2391e73b7e3ff04ef31fafd2df1b1571e3)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Data/IPipingCalculationItemExtensions.cs	(.../IPipingCalculationItemExtensions.cs)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -23,28 +23,29 @@
 using System.Collections.Generic;
 using System.Linq;
 using Core.Common.Base.Geometry;
+using Ringtoets.Common.Data;
 
 namespace Ringtoets.Piping.Data
 {
     /// <summary>
-    /// Defines extension methods dealing with <see cref="IPipingCalculationItem"/> instances.
+    /// Defines extension methods dealing with <see cref="ICalculation"/> instances.
     /// </summary>
     public static class IPipingCalculationItemExtensions
     {
         /// <summary>
         /// Recursively enumerates across over the contents of the piping calculation item, 
         /// yielding the piping calculations found within the calculation item.
         /// </summary>
-        /// <param name="pipingCalculationItem">The calculation item to be evaluated.</param>
+        /// <param name="calculation">The calculation item to be evaluated.</param>
         /// <returns>Returns all contained piping calculations as an enumerable result.</returns>
-        public static IEnumerable<PipingCalculationScenario> GetPipingCalculations(this IPipingCalculationItem pipingCalculationItem)
+        public static IEnumerable<PipingCalculationScenario> GetPipingCalculations(this ICalculation calculation)
         {
-            var calculation = pipingCalculationItem as PipingCalculationScenario;
-            if (calculation != null)
+            var calculationScenario = calculation as PipingCalculationScenario;
+            if (calculationScenario != null)
             {
-                yield return calculation;
+                yield return calculationScenario;
             }
-            var group = pipingCalculationItem as PipingCalculationGroup;
+            var group = calculation as PipingCalculationGroup;
             if (group != null)
             {
                 foreach (PipingCalculationScenario calculationInGroup in group.Children.GetPipingCalculations())
@@ -60,21 +61,21 @@
         /// </summary>
         /// <param name="pipingCalculationItems">The calculation items to be evaluated.</param>
         /// <returns>Returns all contained piping calculations as an enumerable result.</returns>
-        public static IEnumerable<PipingCalculationScenario> GetPipingCalculations(this IEnumerable<IPipingCalculationItem> pipingCalculationItems)
+        public static IEnumerable<PipingCalculationScenario> GetPipingCalculations(this IEnumerable<ICalculation> pipingCalculationItems)
         {
             return pipingCalculationItems.SelectMany(GetPipingCalculations);
         }
 
         /// <summary>
         /// Determines if the surfaceline of a calculation is intersecting with the section reference line.
         /// </summary>
-        /// <param name="pipingCalculationItem">The calculation containing the surface line.</param>
+        /// <param name="calculation">The calculation containing the surface line.</param>
         /// <param name="lineSegments">The line segments that defines the reference line.</param>
         /// <returns><c>true</c> when intersecting. <c>false</c> otherwise.</returns>
         /// <exception cref="InvalidOperationException">Thrown when <paramref name="lineSegments"/> contains no elements.</exception>
-        public static bool IsSurfaceLineIntersectionWithReferenceLineInSection(this IPipingCalculationItem pipingCalculationItem, IEnumerable<Segment2D> lineSegments)
+        public static bool IsSurfaceLineIntersectionWithReferenceLineInSection(this ICalculation calculation, IEnumerable<Segment2D> lineSegments)
         {
-            var pipingCalculation = pipingCalculationItem as PipingCalculationScenario;
+            var pipingCalculation = calculation as PipingCalculationScenario;
 
             if (pipingCalculation == null)
             {
Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingCalculation.cs
===================================================================
diff -u -rd320e912103d060e7a359846539a67dc54c616a4 -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingCalculation.cs	(.../PipingCalculation.cs)	(revision d320e912103d060e7a359846539a67dc54c616a4)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingCalculation.cs	(.../PipingCalculation.cs)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -21,6 +21,7 @@
 
 using System;
 using Core.Common.Base;
+using Ringtoets.Common.Data;
 using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Piping.Data.Properties;
 
@@ -29,7 +30,7 @@
     /// <summary>
     /// This class holds the information which can be made visible in the graphical interface of the application.
     /// </summary>
-    public class PipingCalculation : Observable, ICalculationItem, IPipingCalculationItem
+    public class PipingCalculation : Observable, ICalculationItem, ICalculation
     {
         /// <summary>
         /// Constructs a new instance of <see cref="PipingCalculation"/> with default values set for some of the parameters.
@@ -56,8 +57,6 @@
             SemiProbabilisticParameters = semiProbabilisticInputParameters;
         }
 
-        public string Comments { get; set; }
-
         /// <summary>
         /// Gets the parameters required to perform a semi-probabilistic assessment.
         /// </summary>
@@ -94,6 +93,8 @@
             }
         }
 
+        public string Comments { get; set; }
+
         public void ClearOutput()
         {
             Output = null;
Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingCalculationGroup.cs
===================================================================
diff -u -rb743d495d10779d51c8f75b7cb04b5babb4b226f -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingCalculationGroup.cs	(.../PipingCalculationGroup.cs)	(revision b743d495d10779d51c8f75b7cb04b5babb4b226f)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingCalculationGroup.cs	(.../PipingCalculationGroup.cs)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -23,14 +23,15 @@
 using System.Collections.Generic;
 using System.Linq;
 using Core.Common.Base;
+using Ringtoets.Common.Data;
 using Ringtoets.Piping.Data.Properties;
 
 namespace Ringtoets.Piping.Data
 {
     /// <summary>
     /// Class to allow grouping one or multiple <see cref="PipingCalculation"/> instances.
     /// </summary>
-    public class PipingCalculationGroup : Observable, IPipingCalculationItem
+    public class PipingCalculationGroup : Observable, ICalculation
     {
         private string name;
 
@@ -49,13 +50,13 @@
         {
             name = newName;
             IsNameEditable = canEditName;
-            Children = new List<IPipingCalculationItem>();
+            Children = new List<ICalculation>();
         }
 
         /// <summary>
         /// Gets the children that define this group.
         /// </summary>
-        public IList<IPipingCalculationItem> Children { get; private set; }
+        public IList<ICalculation> Children { get; private set; }
 
         /// <summary>
         /// Gets a value indicating whether or not <see cref="Name"/> is editable.
Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/Ringtoets.Piping.Data.csproj
===================================================================
diff -u -r1e4d77c17c6eac78bfd705efdff9e52b4fca2c7e -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Piping/src/Ringtoets.Piping.Data/Ringtoets.Piping.Data.csproj	(.../Ringtoets.Piping.Data.csproj)	(revision 1e4d77c17c6eac78bfd705efdff9e52b4fca2c7e)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Data/Ringtoets.Piping.Data.csproj	(.../Ringtoets.Piping.Data.csproj)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -51,7 +51,6 @@
     </Compile>
     <Compile Include="DerivedPipingInput.cs" />
     <Compile Include="GeneralPipingInput.cs" />
-    <Compile Include="IPipingCalculationItem.cs" />
     <Compile Include="IPipingCalculationItemExtensions.cs" />
     <Compile Include="PipingCalculation.cs" />
     <Compile Include="PipingCalculationGroup.cs" />
Index: Ringtoets/Piping/src/Ringtoets.Piping.Forms/PipingCalculationConfigurationHelper.cs
===================================================================
diff -u -r8323c6cbe3f292646a254938161e17c42d13d10c -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Piping/src/Ringtoets.Piping.Forms/PipingCalculationConfigurationHelper.cs	(.../PipingCalculationConfigurationHelper.cs)	(revision 8323c6cbe3f292646a254938161e17c42d13d10c)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Forms/PipingCalculationConfigurationHelper.cs	(.../PipingCalculationConfigurationHelper.cs)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -25,6 +25,7 @@
 using Core.Common.Base.Data;
 using Core.Common.Base.Geometry;
 using log4net;
+using Ringtoets.Common.Data;
 using Ringtoets.Common.Forms.Helpers;
 using Ringtoets.Piping.Data;
 using Ringtoets.Piping.Forms.Properties;
@@ -48,7 +49,7 @@
         /// <param name="soilModels">The soil models from which profiles are taken to configure <see cref="PipingCalculation"/> with.</param>
         /// <param name="generalInput">General input to assign to each generated piping calculation.</param>
         /// <param name="semiProbabilisticInput">Semi probabilistic input to assign to each generated piping calculation.</param>
-        /// <returns>A structure or <see cref="IPipingCalculationItem"/> matching combinations of <paramref name="surfaceLines"/> and
+        /// <returns>A structure or <see cref="ICalculation"/> matching combinations of <paramref name="surfaceLines"/> and
         /// profiles of intersecting <paramref name="soilModels"/>.</returns>
         /// <exception cref="ArgumentNullException">Throw when either:
         /// <list type="bullet">
@@ -57,7 +58,7 @@
         /// <item><paramref name="generalInput"/> is <c>null</c></item>
         /// <item><paramref name="semiProbabilisticInput"/> is <c>null</c></item>
         /// </list></exception>
-        public static IEnumerable<IPipingCalculationItem> GenerateCalculationsStructure(IEnumerable<RingtoetsPipingSurfaceLine> surfaceLines, IEnumerable<StochasticSoilModel> soilModels, GeneralPipingInput generalInput, SemiProbabilisticPipingInput semiProbabilisticInput)
+        public static IEnumerable<ICalculation> GenerateCalculationsStructure(IEnumerable<RingtoetsPipingSurfaceLine> surfaceLines, IEnumerable<StochasticSoilModel> soilModels, GeneralPipingInput generalInput, SemiProbabilisticPipingInput semiProbabilisticInput)
         {
             if (surfaceLines == null)
             {
@@ -76,7 +77,7 @@
                 throw new ArgumentNullException("semiProbabilisticInput");
             }
 
-            List<IPipingCalculationItem> groups = new List<IPipingCalculationItem>();
+            List<ICalculation> groups = new List<ICalculation>();
             foreach (var surfaceLine in surfaceLines)
             {
                 var group = CreateCalculationGroup(surfaceLine, soilModels, generalInput, semiProbabilisticInput);
@@ -122,7 +123,7 @@
             return soilModelObjectsForCalculation;
         }
 
-        private static IPipingCalculationItem CreateCalculationGroup(RingtoetsPipingSurfaceLine surfaceLine, IEnumerable<StochasticSoilModel> soilModels, GeneralPipingInput generalInput, SemiProbabilisticPipingInput semiProbabilisticInput)
+        private static ICalculation CreateCalculationGroup(RingtoetsPipingSurfaceLine surfaceLine, IEnumerable<StochasticSoilModel> soilModels, GeneralPipingInput generalInput, SemiProbabilisticPipingInput semiProbabilisticInput)
         {
             var pipingCalculationGroup = new PipingCalculationGroup(surfaceLine.Name, true);
             var stochasticSoilModels = GetStochasticSoilModelsForSurfaceLine(surfaceLine, soilModels);
@@ -137,7 +138,7 @@
             return pipingCalculationGroup;
         }
 
-        private static IPipingCalculationItem CreatePipingCalculation(RingtoetsPipingSurfaceLine surfaceLine, StochasticSoilModel stochasticSoilModel, StochasticSoilProfile stochasticSoilProfile, IEnumerable<IPipingCalculationItem> calculations, GeneralPipingInput generalInput, SemiProbabilisticPipingInput semiProbabilisticInput)
+        private static ICalculation CreatePipingCalculation(RingtoetsPipingSurfaceLine surfaceLine, StochasticSoilModel stochasticSoilModel, StochasticSoilProfile stochasticSoilProfile, IEnumerable<ICalculation> calculations, GeneralPipingInput generalInput, SemiProbabilisticPipingInput semiProbabilisticInput)
         {
             var nameBase = string.Format("{0} {1}", surfaceLine.Name, stochasticSoilProfile);
             var name = NamingHelper.GetUniqueName(calculations, nameBase, c => c.Name);
Index: Ringtoets/Piping/src/Ringtoets.Piping.Forms/PresentationObjects/PipingInputContext.cs
===================================================================
diff -u -r52fb2dd367bdca54564201857ed6e0b3cc244693 -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Piping/src/Ringtoets.Piping.Forms/PresentationObjects/PipingInputContext.cs	(.../PipingInputContext.cs)	(revision 52fb2dd367bdca54564201857ed6e0b3cc244693)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Forms/PresentationObjects/PipingInputContext.cs	(.../PipingInputContext.cs)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -40,26 +40,26 @@
         /// Creates a new instance of <see cref="PipingInputContext"/>
         /// </summary>
         /// <param name="pipingInput">The piping input instance wrapped by this context object.</param>
-        /// <param name="pipingCalculationItem">The piping calculation item the <paramref name="pipingInput"/> belongs to.</param>
+        /// <param name="calculationItem">The calculation item the <paramref name="pipingInput"/> belongs to.</param>
         /// <param name="surfaceLines">The surface lines available within the piping context.</param>
         /// <param name="stochasticSoilModels">The stochastic soil models available within the piping context.</param>
         /// <param name="pipingFailureMechanism">The failure mechanism which the piping context belongs to.</param>
         /// <param name="assessmentSection">The assessment section which the piping context belongs to.</param>
         /// <exception cref="ArgumentNullException">When any input parameter is null.</exception>
         public PipingInputContext(PipingInput pipingInput,
-                                  IPipingCalculationItem pipingCalculationItem,
+                                  ICalculationItem calculationItem,
                                   IEnumerable<RingtoetsPipingSurfaceLine> surfaceLines,
                                   IEnumerable<StochasticSoilModel> stochasticSoilModels,
                                   PipingFailureMechanism pipingFailureMechanism,
                                   IAssessmentSection assessmentSection)
             : base(pipingInput, surfaceLines, stochasticSoilModels, assessmentSection)
         {
-            if (pipingCalculationItem == null)
+            if (calculationItem == null)
             {
                 var message = String.Format(Resources.PipingContext_AssertInputsAreNotNull_DataDescription_0_cannot_be_null,
                                             Resources.PipingContext_DataDescription_PipingCalculationItem);
 
-                throw new ArgumentNullException("pipingCalculationItem", message);
+                throw new ArgumentNullException("calculationItem", message);
             }
             if (pipingFailureMechanism == null)
             {
@@ -69,14 +69,14 @@
                 throw new ArgumentNullException("pipingFailureMechanism", message);
             }
 
-            PipingCalculationItem = pipingCalculationItem;
+            PipingCalculationItem = calculationItem;
             PipingFailureMechanism = pipingFailureMechanism;
         }
 
         /// <summary>
         /// Gets the calculation item which the piping context belongs to.
         /// </summary>
-        public IPipingCalculationItem PipingCalculationItem { get; private set; }
+        public ICalculationItem PipingCalculationItem { get; private set; }
 
         /// <summary>
         /// Gets the failure mechanism which the piping context belongs to.
Index: Ringtoets/Piping/src/Ringtoets.Piping.Plugin/PipingGuiPlugin.cs
===================================================================
diff -u -r684b8c0ca681ea2da3cc988bd60e9223037e5a16 -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Piping/src/Ringtoets.Piping.Plugin/PipingGuiPlugin.cs	(.../PipingGuiPlugin.cs)	(revision 684b8c0ca681ea2da3cc988bd60e9223037e5a16)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Plugin/PipingGuiPlugin.cs	(.../PipingGuiPlugin.cs)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -566,7 +566,7 @@
         {
             var childNodeObjects = new List<object>();
 
-            foreach (IPipingCalculationItem item in nodeData.WrappedData.Children)
+            foreach (ICalculation item in nodeData.WrappedData.Children)
             {
                 var calculation = item as PipingCalculation;
                 var group = item as PipingCalculationGroup;
@@ -832,10 +832,10 @@
 
         private bool PipingCalculationGroupContextCanDropOrCanInsert(object draggedData, object targetData)
         {
-            return GetAsIPipingCalculationItem(draggedData) != null && NodesHaveSameParentFailureMechanism(draggedData, targetData);
+            return GetAsICalculation(draggedData) != null && NodesHaveSameParentFailureMechanism(draggedData, targetData);
         }
 
-        private static IPipingCalculationItem GetAsIPipingCalculationItem(object item)
+        private static ICalculation GetAsICalculation(object item)
         {
             var calculationContext = item as PipingCalculationContext;
             if (calculationContext != null)
@@ -879,16 +879,16 @@
 
         private void PipingCalculationGroupContextOnDrop(object droppedData, object newParentData, object oldParentData, int position, TreeViewControl treeViewControl)
         {
-            IPipingCalculationItem pipingCalculationItem = GetAsIPipingCalculationItem(droppedData);
+            ICalculation calculation = GetAsICalculation(droppedData);
             var originalOwnerContext = oldParentData as PipingCalculationGroupContext;
             var target = newParentData as PipingCalculationGroupContext;
 
-            if (pipingCalculationItem != null && originalOwnerContext != null && target != null)
+            if (calculation != null && originalOwnerContext != null && target != null)
             {
                 var isMoveWithinSameContainer = ReferenceEquals(originalOwnerContext, target);
 
                 DroppingPipingCalculationInContainerStrategy dropHandler = GetDragDropStrategy(isMoveWithinSameContainer, originalOwnerContext, target);
-                dropHandler.Execute(droppedData, pipingCalculationItem, position, treeViewControl);
+                dropHandler.Execute(droppedData, calculation, position, treeViewControl);
             }
         }
 
@@ -904,7 +904,7 @@
         #region Nested Types: DroppingPipingCalculationInContainerStrategy and implementations
 
         /// <summary>
-        /// Strategy pattern implementation for dealing with drag & dropping a <see cref="IPipingCalculationItem"/>
+        /// Strategy pattern implementation for dealing with drag & dropping a <see cref="ICalculation"/>
         /// onto <see cref="PipingCalculationGroup"/> data.
         /// </summary>
         private abstract class DroppingPipingCalculationInContainerStrategy
@@ -922,26 +922,26 @@
             /// Perform the drag & drop operation.
             /// </summary>
             /// <param name="draggedData">The dragged data.</param>
-            /// <param name="pipingCalculationItem">The piping calculation item wrapped by <see cref="draggedData"/>.</param>
+            /// <param name="calculation">The calculation wrapped by <see cref="draggedData"/>.</param>
             /// <param name="newPosition">The index of the new position within the new owner's collection.</param>
             /// <param name="treeViewControl">The tree view control which is at stake.</param>
-            public virtual void Execute(object draggedData, IPipingCalculationItem pipingCalculationItem, int newPosition, TreeViewControl treeViewControl)
+            public virtual void Execute(object draggedData, ICalculation calculation, int newPosition, TreeViewControl treeViewControl)
             {
-                MoveCalculationItemToNewOwner(pipingCalculationItem, newPosition);
+                MoveCalculationItemToNewOwner(calculation, newPosition);
 
                 NotifyObservers();
             }
 
             /// <summary>
-            /// Moves the <see cref="IPipingCalculationItem"/> instance to its new location.
+            /// Moves the <see cref="ICalculation"/> instance to its new location.
             /// </summary>
-            /// <param name="pipingCalculationItem">The instance to be relocated.</param>
+            /// <param name="calculation">The instance to be relocated.</param>
             /// <param name="position">The index in the new <see cref="PipingCalculationGroup"/>
             /// owner within its <see cref="PipingCalculationGroup.Children"/>.</param>
-            protected void MoveCalculationItemToNewOwner(IPipingCalculationItem pipingCalculationItem, int position)
+            protected void MoveCalculationItemToNewOwner(ICalculation calculation, int position)
             {
-                originalOwnerContext.WrappedData.Children.Remove(pipingCalculationItem);
-                target.WrappedData.Children.Insert(position, pipingCalculationItem);
+                originalOwnerContext.WrappedData.Children.Remove(calculation);
+                target.WrappedData.Children.Insert(position, calculation);
             }
 
             /// <summary>
@@ -954,7 +954,7 @@
         }
 
         /// <summary>
-        /// Strategy implementation for rearranging the order of an <see cref="IPipingCalculationItem"/>
+        /// Strategy implementation for rearranging the order of an <see cref="ICalculation"/>
         /// within a <see cref="PipingCalculationGroup"/> through a drag & drop action.
         /// </summary>
         private class DroppingPipingCalculationWithinSameContainer : DroppingPipingCalculationInContainerStrategy
@@ -971,7 +971,7 @@
         }
 
         /// <summary>
-        /// Strategy implementation for moving an <see cref="IPipingCalculationItem"/> from
+        /// Strategy implementation for moving an <see cref="ICalculation"/> from
         /// one <see cref="PipingCalculationGroup"/> to another using a drag & drop action.
         /// </summary>
         private class DroppingPipingCalculationToNewContainer : DroppingPipingCalculationInContainerStrategy
@@ -986,17 +986,17 @@
             public DroppingPipingCalculationToNewContainer(PipingCalculationGroupContext originalOwnerContext, PipingCalculationGroupContext target) :
                 base(originalOwnerContext, target) {}
 
-            public override void Execute(object draggedData, IPipingCalculationItem pipingCalculationItem, int newPosition, TreeViewControl treeViewControl)
+            public override void Execute(object draggedData, ICalculation calculation, int newPosition, TreeViewControl treeViewControl)
             {
-                MoveCalculationItemToNewOwner(pipingCalculationItem, newPosition);
+                MoveCalculationItemToNewOwner(calculation, newPosition);
 
                 NotifyObservers();
 
                 // Try to start a name edit action when an item with the same name was already present
                 if (target.WrappedData.Children.Except(new[]
                 {
-                    pipingCalculationItem
-                }).Any(c => c.Name.Equals(pipingCalculationItem.Name)))
+                    calculation
+                }).Any(c => c.Name.Equals(calculation.Name)))
                 {
                     treeViewControl.TryRenameNodeForData(draggedData);
                 }
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/IPipingCalculationItemExtensionsTest.cs
===================================================================
diff -u -r1279dcba187f56c0ba96dfdb962067304e333475 -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/IPipingCalculationItemExtensionsTest.cs	(.../IPipingCalculationItemExtensionsTest.cs)	(revision 1279dcba187f56c0ba96dfdb962067304e333475)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/IPipingCalculationItemExtensionsTest.cs	(.../IPipingCalculationItemExtensionsTest.cs)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -24,6 +24,7 @@
 using System.Linq;
 using Core.Common.Base.Geometry;
 using NUnit.Framework;
+using Ringtoets.Common.Data;
 using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Piping.Primitives;
 
@@ -36,20 +37,23 @@
         public void GetPipingCalculations_FromPipingCalculation_ReturnThatCalculationInstance()
         {
             // Setup
-            IPipingCalculationItem calculation = new PipingCalculationScenario(new GeneralPipingInput(), new SemiProbabilisticPipingInput());
+            ICalculation calculation = new PipingCalculationScenario(new GeneralPipingInput(), new SemiProbabilisticPipingInput());
 
             // Call
             IEnumerable<PipingCalculationScenario> result = calculation.GetPipingCalculations();
 
             // Assert
-            CollectionAssert.AreEqual(new[]{calculation}, result);
+            CollectionAssert.AreEqual(new[]
+            {
+                calculation
+            }, result);
         }
 
         [Test]
         public void GetPipingCalculations_FromPipingCalculationGroupWithoutChildren_ReturnEmpty()
         {
             // Setup
-            IPipingCalculationItem groupWithoutChildren = new PipingCalculationGroup();
+            ICalculation groupWithoutChildren = new PipingCalculationGroup();
 
             // Call
             IEnumerable<PipingCalculation> result = groupWithoutChildren.GetPipingCalculations();
@@ -67,7 +71,7 @@
             rootGroup.Children.Add(new PipingCalculationGroup());
             rootGroup.Children.Add(new PipingCalculationGroup());
 
-            IPipingCalculationItem groupsWithoutChildren = rootGroup;
+            ICalculation groupsWithoutChildren = rootGroup;
 
             // Call
             IEnumerable<PipingCalculationScenario> result = groupsWithoutChildren.GetPipingCalculations();
@@ -102,7 +106,7 @@
             rootGroup.Children.Add(calculation1);
             rootGroup.Children.Add(subgroup2);
 
-            IPipingCalculationItem groupWithoutChildren = rootGroup;
+            ICalculation groupWithoutChildren = rootGroup;
 
             // Call
             IEnumerable<PipingCalculationScenario> result = groupWithoutChildren.GetPipingCalculations();
@@ -122,7 +126,7 @@
         public void GetPipingCalculations_FromEmptyEnummerable_ReturnEmpty()
         {
             // Setup
-            IEnumerable<IPipingCalculationItem> emptyEnumerable = Enumerable.Empty<IPipingCalculationItem>();
+            IEnumerable<ICalculation> emptyEnumerable = Enumerable.Empty<ICalculation>();
 
             // Call
             IEnumerable<PipingCalculationScenario> result = emptyEnumerable.GetPipingCalculations();
@@ -139,7 +143,11 @@
             var semiProbabilisticInput = new SemiProbabilisticPipingInput();
             var calculation1 = new PipingCalculationScenario(generalInputParameters, semiProbabilisticInput);
             var calculation2 = new PipingCalculationScenario(generalInputParameters, semiProbabilisticInput);
-            IEnumerable<IPipingCalculationItem> calculationArray = new[] { calculation1, calculation2 };
+            IEnumerable<ICalculation> calculationArray = new[]
+            {
+                calculation1,
+                calculation2
+            };
 
             // Call
             IEnumerable<PipingCalculationScenario> result = calculationArray.GetPipingCalculations();
@@ -154,7 +162,11 @@
             // Setup
             var emptyGroup1 = new PipingCalculationGroup();
             var emptyGroup2 = new PipingCalculationGroup();
-            IEnumerable<IPipingCalculationItem> emptyEnumerable = new[] { emptyGroup1, emptyGroup2 };
+            IEnumerable<ICalculation> emptyEnumerable = new[]
+            {
+                emptyGroup1,
+                emptyGroup2
+            };
 
             // Call
             IEnumerable<PipingCalculationScenario> result = emptyEnumerable.GetPipingCalculations();
@@ -192,7 +204,12 @@
 
             var emptyRootGroup = new PipingCalculationGroup();
 
-            IEnumerable<IPipingCalculationItem> mixedArray = new IPipingCalculationItem[] { emptyRootGroup, rootGroup, rootcalculation };
+            IEnumerable<ICalculation> mixedArray = new ICalculation[]
+            {
+                emptyRootGroup,
+                rootGroup,
+                rootcalculation
+            };
 
             // Call
             IEnumerable<PipingCalculationScenario> result = mixedArray.GetPipingCalculations();
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingCalculationGroupTest.cs
===================================================================
diff -u -rc7c07db38829afdc5965c331844e1d39123944ff -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingCalculationGroupTest.cs	(.../PipingCalculationGroupTest.cs)	(revision c7c07db38829afdc5965c331844e1d39123944ff)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingCalculationGroupTest.cs	(.../PipingCalculationGroupTest.cs)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -20,12 +20,10 @@
 // All rights reserved.
 
 using System;
-
 using Core.Common.Base;
-
 using NUnit.Framework;
-
 using Rhino.Mocks;
+using Ringtoets.Common.Data;
 
 namespace Ringtoets.Piping.Data.Test
 {
@@ -39,7 +37,7 @@
             var group = new PipingCalculationGroup();
 
             // Assert
-            Assert.IsInstanceOf<IPipingCalculationItem>(group);
+            Assert.IsInstanceOf<ICalculation>(group);
             Assert.IsInstanceOf<Observable>(group);
             Assert.IsTrue(group.IsNameEditable);
             Assert.AreEqual("Nieuwe map", group.Name);
@@ -59,7 +57,7 @@
             var group = new PipingCalculationGroup(newName, isNameEditable);
 
             // Assert
-            Assert.IsInstanceOf<IPipingCalculationItem>(group);
+            Assert.IsInstanceOf<ICalculation>(group);
             Assert.IsInstanceOf<Observable>(group);
             Assert.AreEqual(isNameEditable, group.IsNameEditable);
             Assert.AreEqual(newName, group.Name);
@@ -157,8 +155,12 @@
             // Assert
             Assert.AreEqual(2, group.Children.Count);
             Assert.AreSame(calculationToInsert, group.Children[index]);
-            CollectionAssert.AreEquivalent(new[]{calculationToInsert,calculation}, group.Children,
-                "Already existing items should have remained in collection and new item should be added.");
+            CollectionAssert.AreEquivalent(new[]
+            {
+                calculationToInsert,
+                calculation
+            }, group.Children,
+                                           "Already existing items should have remained in collection and new item should be added.");
         }
 
         [Test]
@@ -210,8 +212,12 @@
             // Assert
             Assert.AreEqual(2, group.Children.Count);
             Assert.AreSame(groupToInsert, group.Children[index]);
-            CollectionAssert.AreEquivalent(new[] { groupToInsert, existingGroup }, group.Children,
-                "Already existing items should have remained in collection and new item should be added.");
+            CollectionAssert.AreEquivalent(new[]
+            {
+                groupToInsert,
+                existingGroup
+            }, group.Children,
+                                           "Already existing items should have remained in collection and new item should be added.");
         }
 
         [Test]
@@ -235,10 +241,10 @@
         {
             // Setup
             var mocks = new MockRepository();
-            var childWithoutOutput = mocks.Stub<IPipingCalculationItem>();
+            var childWithoutOutput = mocks.Stub<ICalculation>();
             childWithoutOutput.Stub(c => c.HasOutput).Return(false);
 
-            var childWithOutput = mocks.Stub<IPipingCalculationItem>();
+            var childWithOutput = mocks.Stub<ICalculation>();
             childWithOutput.Stub(c => c.HasOutput).Return(true);
             mocks.ReplayAll();
 
@@ -259,10 +265,10 @@
         {
             // Setup
             var mocks = new MockRepository();
-            var child1WithoutOutput = mocks.Stub<IPipingCalculationItem>();
+            var child1WithoutOutput = mocks.Stub<ICalculation>();
             child1WithoutOutput.Stub(c => c.HasOutput).Return(false);
 
-            var child2WithoutOutput = mocks.Stub<IPipingCalculationItem>();
+            var child2WithoutOutput = mocks.Stub<ICalculation>();
             child2WithoutOutput.Stub(c => c.HasOutput).Return(false);
             mocks.ReplayAll();
 
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingCalculationTest.cs
===================================================================
diff -u -rc7c07db38829afdc5965c331844e1d39123944ff -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingCalculationTest.cs	(.../PipingCalculationTest.cs)	(revision c7c07db38829afdc5965c331844e1d39123944ff)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingCalculationTest.cs	(.../PipingCalculationTest.cs)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -52,7 +52,7 @@
             var calculation = new PipingCalculation(generalInputParameters, semiProbabilisticInputParameters);
 
             // Assert
-            Assert.IsInstanceOf<IPipingCalculationItem>(calculation);
+            Assert.IsInstanceOf<ICalculation>(calculation);
             Assert.IsInstanceOf<ICommentable>(calculation);
 
             Assert.AreEqual("Nieuwe berekening", calculation.Name);
Index: Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PipingCalculationConfigurationHelperTest.cs
===================================================================
diff -u -r8323c6cbe3f292646a254938161e17c42d13d10c -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PipingCalculationConfigurationHelperTest.cs	(.../PipingCalculationConfigurationHelperTest.cs)	(revision 8323c6cbe3f292646a254938161e17c42d13d10c)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PipingCalculationConfigurationHelperTest.cs	(.../PipingCalculationConfigurationHelperTest.cs)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -26,6 +26,7 @@
 using Core.Common.Base.Geometry;
 using Core.Common.TestUtil;
 using NUnit.Framework;
+using Ringtoets.Common.Data;
 using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Piping.Data;
 using Ringtoets.Piping.Primitives;
@@ -433,7 +434,7 @@
                     Name = testName4
                 }
             };
-            IEnumerable<IPipingCalculationItem> result = null;
+            IEnumerable<ICalculation> result = null;
 
             // Call
             Action call = () =>
@@ -511,7 +512,7 @@
             };
 
             // Call
-            IEnumerable<IPipingCalculationItem> result = PipingCalculationConfigurationHelper.GenerateCalculationsStructure(
+            IEnumerable<ICalculation> result = PipingCalculationConfigurationHelper.GenerateCalculationsStructure(
                 surfaceLines,
                 availableSoilModels,
                 new GeneralPipingInput(),
@@ -573,7 +574,7 @@
                 surfaceLine
             };
 
-            IEnumerable<IPipingCalculationItem> result = null;
+            IEnumerable<ICalculation> result = null;
             // Call
             Action call = () =>
             {
@@ -649,7 +650,7 @@
                 surfaceLine
             };
 
-            IEnumerable<IPipingCalculationItem> result = null; 
+            IEnumerable<ICalculation> result = null; 
 
             // Call
             Action call = () =>
@@ -736,7 +737,7 @@
             };
 
             // Call
-            IEnumerable<IPipingCalculationItem> result = PipingCalculationConfigurationHelper.GenerateCalculationsStructure(
+            IEnumerable<ICalculation> result = PipingCalculationConfigurationHelper.GenerateCalculationsStructure(
                 surfaceLines, 
                 availableSoilModels, 
                 new GeneralPipingInput(), 
@@ -845,7 +846,7 @@
             };
 
             // Call
-            IEnumerable<IPipingCalculationItem> result = PipingCalculationConfigurationHelper.GenerateCalculationsStructure(
+            IEnumerable<ICalculation> result = PipingCalculationConfigurationHelper.GenerateCalculationsStructure(
                 surfaceLines, 
                 availableSoilModels, 
                 new GeneralPipingInput(), 
@@ -966,7 +967,7 @@
                 surfaceLine2
             };
 
-            IEnumerable<IPipingCalculationItem> result = null;
+            IEnumerable<ICalculation> result = null;
 
             // Call
             Action call = () =>
@@ -1065,7 +1066,7 @@
             SemiProbabilisticPipingInput semiProbabilisticInput = new SemiProbabilisticPipingInput();
 
             // Call
-            IEnumerable<IPipingCalculationItem> result = PipingCalculationConfigurationHelper.GenerateCalculationsStructure(
+            IEnumerable<ICalculation> result = PipingCalculationConfigurationHelper.GenerateCalculationsStructure(
                 surfaceLines,
                 availableSoilModels,
                 generalInput,
@@ -1154,7 +1155,7 @@
             };
 
             // Call
-            IEnumerable<IPipingCalculationItem> result = PipingCalculationConfigurationHelper.GenerateCalculationsStructure(
+            IEnumerable<ICalculation> result = PipingCalculationConfigurationHelper.GenerateCalculationsStructure(
                 surfaceLines,
                 availableSoilModels,
                 new GeneralPipingInput(),
Index: Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/TreeNodeInfos/PipingCalculationGroupContextTreeNodeInfoTest.cs
===================================================================
diff -u -r0b081b2391e73b7e3ff04ef31fafd2df1b1571e3 -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/TreeNodeInfos/PipingCalculationGroupContextTreeNodeInfoTest.cs	(.../PipingCalculationGroupContextTreeNodeInfoTest.cs)	(revision 0b081b2391e73b7e3ff04ef31fafd2df1b1571e3)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/TreeNodeInfos/PipingCalculationGroupContextTreeNodeInfoTest.cs	(.../PipingCalculationGroupContextTreeNodeInfoTest.cs)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -35,6 +35,7 @@
 using NUnit.Extensions.Forms;
 using NUnit.Framework;
 using Rhino.Mocks;
+using Ringtoets.Common.Data;
 using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Piping.Data;
@@ -164,7 +165,7 @@
         public void ChildNodeObjects_GroupWithMixedContents_ReturnChildren()
         {
             // Setup
-            var calculationItem = mocks.StrictMock<IPipingCalculationItem>();
+            var calculationItem = mocks.StrictMock<ICalculation>();
 
             var childCalculation = new PipingCalculation(new GeneralPipingInput(), new SemiProbabilisticPipingInput());
 
@@ -706,7 +707,7 @@
                                                              pipingFailureMechanismMock,
                                                              assessmentSectionMock);
 
-            var calculationItem = mocks.Stub<IPipingCalculationItem>();
+            var calculationItem = mocks.Stub<ICalculation>();
             calculationItem.Expect(ci => ci.Name).Return("Nieuwe map");
 
             var observer = mocks.StrictMock<IObserver>();
@@ -757,7 +758,7 @@
                                                              pipingFailureMechanismMock,
                                                              assessmentSectionMock);
 
-            var calculationItem = mocks.Stub<IPipingCalculationItem>();
+            var calculationItem = mocks.Stub<ICalculation>();
             calculationItem.Expect(ci => ci.Name).Return("Nieuwe berekening");
 
             var observer = mocks.StrictMock<IObserver>();
@@ -1525,18 +1526,18 @@
         [Combinatorial]
         public void CanDropOrCanInsert_DraggingPipingCalculationItemContextOntoGroupNotContainingItem_ReturnTrue(
             [Values(DragDropTestMethod.CanDrop, DragDropTestMethod.CanInsert)] DragDropTestMethod methodToTest,
-            [Values(PipingCalculationItemType.Calculation, PipingCalculationItemType.Group)] PipingCalculationItemType draggedItemType)
+            [Values(PipingCalculationType.Calculation, PipingCalculationType.Group)] PipingCalculationType draggedItemType)
         {
             // Setup
-            IPipingCalculationItem draggedItem;
+            ICalculation draggedItem;
             object draggedItemContext;
 
             var failureMechanism = new PipingFailureMechanism();
             var assessmentSection = mocks.StrictMock<IAssessmentSection>();
 
             mocks.ReplayAll();
 
-            CreatePipingCalculationItemAndContext(draggedItemType, out draggedItem, out draggedItemContext, failureMechanism, assessmentSection);
+            CreatePipingCalculationAndContext(draggedItemType, out draggedItem, out draggedItemContext, failureMechanism, assessmentSection);
 
             PipingCalculationGroup targetGroup;
             PipingCalculationGroupContext targetGroupContext;
@@ -1572,18 +1573,18 @@
         [Combinatorial]
         public void CanDropOrInsert_DraggingCalculationItemContextOntoGroupNotContainingItemOtherFailureMechanism_ReturnFalse(
             [Values(DragDropTestMethod.CanDrop, DragDropTestMethod.CanInsert)] DragDropTestMethod methodToTest,
-            [Values(PipingCalculationItemType.Calculation, PipingCalculationItemType.Group)] PipingCalculationItemType draggedItemType)
+            [Values(PipingCalculationType.Calculation, PipingCalculationType.Group)] PipingCalculationType draggedItemType)
         {
             // Setup
-            IPipingCalculationItem draggedItem;
+            ICalculation draggedItem;
             object draggedItemContext;
 
             var targetFailureMechanism = new PipingFailureMechanism();
             var assessmentSection = mocks.StrictMock<IAssessmentSection>();
 
             mocks.ReplayAll();
 
-            CreatePipingCalculationItemAndContext(draggedItemType, out draggedItem, out draggedItemContext, targetFailureMechanism, assessmentSection);
+            CreatePipingCalculationAndContext(draggedItemType, out draggedItem, out draggedItemContext, targetFailureMechanism, assessmentSection);
 
             var sourceFailureMechanism = new PipingFailureMechanism();
             sourceFailureMechanism.CalculationsGroup.Children.Add(draggedItem);
@@ -1620,16 +1621,16 @@
         [Test]
         [Combinatorial]
         public void OnDrop_DraggingPipingCalculationItemContextOntoGroupEnd_MoveCalculationItemInstanceToNewGroup(
-            [Values(PipingCalculationItemType.Calculation, PipingCalculationItemType.Group)] PipingCalculationItemType draggedItemType)
+            [Values(PipingCalculationType.Calculation, PipingCalculationType.Group)] PipingCalculationType draggedItemType)
         {
             // Setup
             var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
             var pipingFailureMechanismMock = mocks.StrictMock<PipingFailureMechanism>();
             var assessmentSection = mocks.StrictMock<IAssessmentSection>();
 
-            IPipingCalculationItem draggedItem;
+            ICalculation draggedItem;
             object draggedItemContext;
-            CreatePipingCalculationItemAndContext(draggedItemType, out draggedItem, out draggedItemContext, pipingFailureMechanismMock, assessmentSection);
+            CreatePipingCalculationAndContext(draggedItemType, out draggedItem, out draggedItemContext, pipingFailureMechanismMock, assessmentSection);
 
             PipingCalculationGroup originalOwnerGroup;
             PipingCalculationGroupContext originalOwnerGroupContext;
@@ -1670,7 +1671,7 @@
         [Test]
         [Combinatorial]
         public void OnDrop_InsertingPipingCalculationItemContextAtDifferentLocationWithinSameGroup_ChangeItemIndexOfCalculationItem(
-            [Values(PipingCalculationItemType.Calculation, PipingCalculationItemType.Group)] PipingCalculationItemType draggedItemType,
+            [Values(PipingCalculationType.Calculation, PipingCalculationType.Group)] PipingCalculationType draggedItemType,
             [Values(0, 2)] int newIndex)
         {
             // Setup
@@ -1679,11 +1680,11 @@
             var assessmentSection = mocks.StrictMock<IAssessmentSection>();
 
             const string name = "Very cool name";
-            IPipingCalculationItem draggedItem;
+            ICalculation draggedItem;
             object draggedItemContext;
-            CreatePipingCalculationItemAndContext(draggedItemType, out draggedItem, out draggedItemContext, pipingFailureMechanismMock, assessmentSection, name);
+            CreatePipingCalculationAndContext(draggedItemType, out draggedItem, out draggedItemContext, pipingFailureMechanismMock, assessmentSection, name);
 
-            var existingItemStub = mocks.Stub<IPipingCalculationItem>();
+            var existingItemStub = mocks.Stub<ICalculation>();
             existingItemStub.Stub(i => i.Name).Return("");
 
             PipingCalculationGroup originalOwnerGroup;
@@ -1721,16 +1722,16 @@
         [Test]
         [Combinatorial]
         public void OnDrop_DraggingPipingCalculationItemContextOntoGroupWithSameNamedItem_MoveCalculationItemInstanceToNewGroupAndRename(
-            [Values(PipingCalculationItemType.Calculation, PipingCalculationItemType.Group)] PipingCalculationItemType draggedItemType)
+            [Values(PipingCalculationType.Calculation, PipingCalculationType.Group)] PipingCalculationType draggedItemType)
         {
             // Setup
             var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
             var pipingFailureMechanismMock = mocks.StrictMock<PipingFailureMechanism>();
             var assessmentSection = mocks.StrictMock<IAssessmentSection>();
 
-            IPipingCalculationItem draggedItem;
+            ICalculation draggedItem;
             object draggedItemContext;
-            CreatePipingCalculationItemAndContext(draggedItemType, out draggedItem, out draggedItemContext, pipingFailureMechanismMock, assessmentSection);
+            CreatePipingCalculationAndContext(draggedItemType, out draggedItem, out draggedItemContext, pipingFailureMechanismMock, assessmentSection);
 
             PipingCalculationGroup originalOwnerGroup;
             PipingCalculationGroupContext originalOwnerGroupContext;
@@ -1741,7 +1742,7 @@
             PipingCalculationGroupContext newOwnerGroupContext;
             CreatePipingCalculationGroupAndContext(out newOwnerGroup, out newOwnerGroupContext, pipingFailureMechanismMock, assessmentSection);
 
-            var sameNamedItem = mocks.Stub<IPipingCalculationItem>();
+            var sameNamedItem = mocks.Stub<ICalculation>();
             sameNamedItem.Stub(i => i.Name).Return(draggedItem.Name);
 
             var originalOwnerObserver = mocks.StrictMock<IObserver>();
@@ -1775,10 +1776,10 @@
                            "Dragging to insert node at start of newOwnerGroup should place the node at the start of the list.");
             switch (draggedItemType)
             {
-                case PipingCalculationItemType.Calculation:
+                case PipingCalculationType.Calculation:
                     Assert.AreEqual("Nieuwe berekening", draggedItem.Name);
                     break;
-                case PipingCalculationItemType.Group:
+                case PipingCalculationType.Group:
                     Assert.AreEqual("Nieuwe map", draggedItem.Name);
                     break;
             }
@@ -1813,20 +1814,20 @@
         }
 
         /// <summary>
-        /// Creates an instance of <see cref="IPipingCalculationItem"/> and the corresponding context.
+        /// Creates an instance of <see cref="ICalculation"/> and the corresponding context.
         /// </summary>
-        /// <param name="type">Defines the implementation of <see cref="IPipingCalculationItem"/> to be constructed.</param>
+        /// <param name="type">Defines the implementation of <see cref="ICalculation"/> to be constructed.</param>
         /// <param name="data">Output: The concrete create class based on <paramref name="type"/>.</param>
         /// <param name="dataContext">Output: The <see cref="PipingContext{T}"/> corresponding with <paramref name="data"/>.</param>
         /// <param name="pipingFailureMechanism">The piping failure mechanism the item and context belong to.</param>
         /// <param name="assessmentSection">The assessment section the item and context belong to.</param>
         /// <param name="initialName">Optional: The name of <paramref name="data"/>.</param>
         /// <exception cref="System.NotSupportedException"></exception>
-        private void CreatePipingCalculationItemAndContext(PipingCalculationItemType type, out IPipingCalculationItem data, out object dataContext, PipingFailureMechanism pipingFailureMechanism, IAssessmentSection assessmentSection, string initialName = null)
+        private static void CreatePipingCalculationAndContext(PipingCalculationType type, out ICalculation data, out object dataContext, PipingFailureMechanism pipingFailureMechanism, IAssessmentSection assessmentSection, string initialName = null)
         {
             switch (type)
             {
-                case PipingCalculationItemType.Calculation:
+                case PipingCalculationType.Calculation:
                     var calculation = new PipingCalculation(new GeneralPipingInput(), new SemiProbabilisticPipingInput());
                     if (initialName != null)
                     {
@@ -1839,7 +1840,7 @@
                                                                pipingFailureMechanism,
                                                                assessmentSection);
                     break;
-                case PipingCalculationItemType.Group:
+                case PipingCalculationType.Group:
                     var group = new PipingCalculationGroup();
                     if (initialName != null)
                     {
@@ -1874,9 +1875,9 @@
         }
 
         /// <summary>
-        /// Type indicator for implementations of <see cref="IPipingCalculationItem"/> to be created in a test.
+        /// Type indicator for implementations of <see cref="ICalculation"/> to be created in a test.
         /// </summary>
-        public enum PipingCalculationItemType
+        public enum PipingCalculationType
         {
             /// <summary>
             /// Indicates <see cref="PipingCalculation"/>.
Index: Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/TreeNodeInfos/PipingFailureMechanismTreeNodeInfoTest.cs
===================================================================
diff -u -r684b8c0ca681ea2da3cc988bd60e9223037e5a16 -r314545f25db70366badcc527aeca68d241bfdcdc
--- Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/TreeNodeInfos/PipingFailureMechanismTreeNodeInfoTest.cs	(.../PipingFailureMechanismTreeNodeInfoTest.cs)	(revision 684b8c0ca681ea2da3cc988bd60e9223037e5a16)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/TreeNodeInfos/PipingFailureMechanismTreeNodeInfoTest.cs	(.../PipingFailureMechanismTreeNodeInfoTest.cs)	(revision 314545f25db70366badcc527aeca68d241bfdcdc)
@@ -495,7 +495,7 @@
 
             // Assert
             Assert.AreEqual(2, failureMechanism.CalculationsGroup.Children.Count);
-            IPipingCalculationItem addedItem = failureMechanism.CalculationsGroup.Children.ElementAt(1);
+            ICalculation addedItem = failureMechanism.CalculationsGroup.Children.ElementAt(1);
             Assert.AreEqual("Nieuwe berekening (1)", addedItem.Name,
                             "Because there is already an item with the same default name, '(1)' should be appended.");
             Assert.IsInstanceOf<PipingCalculationScenario>(addedItem);
@@ -540,7 +540,7 @@
 
             // Assert
             Assert.AreEqual(2, failureMechanism.CalculationsGroup.Children.Count);
-            IPipingCalculationItem addedItem = failureMechanism.CalculationsGroup.Children.ElementAt(1);
+            ICalculation addedItem = failureMechanism.CalculationsGroup.Children.ElementAt(1);
             Assert.AreEqual("Nieuwe map (1)", addedItem.Name,
                             "Because there is already an item with the same default name, '(1)' should be appended.");
             Assert.IsInstanceOf<PipingCalculationGroup>(addedItem);