Index: Ringtoets/DuneErosion/src/Ringtoets.DuneErosion.Forms/GuiServices/DuneLocationCalculationGuiService.cs
===================================================================
diff -u -r16ff9b6edce7916571518d621021b2995c1c01aa -r63a5a07d2178d1a83e2439cb40bcfd8cae317455
--- Ringtoets/DuneErosion/src/Ringtoets.DuneErosion.Forms/GuiServices/DuneLocationCalculationGuiService.cs	(.../DuneLocationCalculationGuiService.cs)	(revision 16ff9b6edce7916571518d621021b2995c1c01aa)
+++ Ringtoets/DuneErosion/src/Ringtoets.DuneErosion.Forms/GuiServices/DuneLocationCalculationGuiService.cs	(.../DuneLocationCalculationGuiService.cs)	(revision 63a5a07d2178d1a83e2439cb40bcfd8cae317455)
@@ -97,6 +97,7 @@
             ActivityProgressDialogRunner.Run(
                 viewParent,
                 locations.Select(l => new DuneErosionBoundaryCalculationActivity(l,
+                                                                                 getCalculationFunc(l),
                                                                                  hydraulicBoundaryDatabaseFilePath,
                                                                                  preprocessorDirectory,
                                                                                  norm)).ToArray());
Index: Ringtoets/DuneErosion/src/Ringtoets.DuneErosion.Service/DuneErosionBoundaryCalculationActivity.cs
===================================================================
diff -u -r397eafbec8987f6aa2e31318745c4e07ed575981 -r63a5a07d2178d1a83e2439cb40bcfd8cae317455
--- Ringtoets/DuneErosion/src/Ringtoets.DuneErosion.Service/DuneErosionBoundaryCalculationActivity.cs	(.../DuneErosionBoundaryCalculationActivity.cs)	(revision 397eafbec8987f6aa2e31318745c4e07ed575981)
+++ Ringtoets/DuneErosion/src/Ringtoets.DuneErosion.Service/DuneErosionBoundaryCalculationActivity.cs	(.../DuneErosionBoundaryCalculationActivity.cs)	(revision 63a5a07d2178d1a83e2439cb40bcfd8cae317455)
@@ -33,6 +33,7 @@
     public class DuneErosionBoundaryCalculationActivity : HydraRingActivityBase
     {
         private readonly DuneLocation duneLocation;
+        private readonly DuneLocationCalculation duneLocationCalculation;
         private readonly string hydraulicBoundaryDatabaseFilePath;
         private readonly string preprocessorDirectory;
         private readonly double norm;
@@ -42,16 +43,17 @@
         /// Creates a new instance of <see cref="DuneErosionBoundaryCalculationActivity"/>.
         /// </summary>
         /// <param name="duneLocation">The <see cref="DuneLocation"/> to perform the calculation for.</param>
+        /// <param name="duneLocationCalculation">The <see cref="DuneLocationCalculation"/> to perform.</param>
         /// <param name="hydraulicBoundaryDatabaseFilePath">The hydraulic boundary database file that 
         /// should be used for performing the calculation.</param>
         /// <param name="preprocessorDirectory">The preprocessor directory.</param>
         /// <param name="norm">The norm to use during the calculation.</param>
         /// <remarks>Preprocessing is disabled when <paramref name="preprocessorDirectory"/>
         /// equals <see cref="string.Empty"/>.</remarks>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="duneLocation"/>,
-        /// <paramref name="hydraulicBoundaryDatabaseFilePath"/> or <paramref name="preprocessorDirectory"/>
-        ///  is <c>null</c>.</exception>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="duneLocation"/> or
+        /// <paramref name="duneLocationCalculation"/> is <c>null</c>.</exception>
         public DuneErosionBoundaryCalculationActivity(DuneLocation duneLocation,
+                                                      DuneLocationCalculation duneLocationCalculation,
                                                       string hydraulicBoundaryDatabaseFilePath,
                                                       string preprocessorDirectory,
                                                       double norm)
@@ -61,7 +63,13 @@
                 throw new ArgumentNullException(nameof(duneLocation));
             }
 
+            if (duneLocationCalculation == null)
+            {
+                throw new ArgumentNullException(nameof(duneLocationCalculation));
+            }
+
             this.duneLocation = duneLocation;
+            this.duneLocationCalculation = duneLocationCalculation;
             this.hydraulicBoundaryDatabaseFilePath = hydraulicBoundaryDatabaseFilePath;
             this.preprocessorDirectory = preprocessorDirectory;
             this.norm = norm;
@@ -108,7 +116,7 @@
         {
             get
             {
-                return duneLocation.Calculation.Output != null;
+                return duneLocationCalculation.Output != null;
             }
         }
     }
Index: Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Integration.Test/DuneErosionBoundaryCalculationActivityIntegrationTest.cs
===================================================================
diff -u -rb0e228408016f88b94ac63d6896e5bc7668a75c1 -r63a5a07d2178d1a83e2439cb40bcfd8cae317455
--- Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Integration.Test/DuneErosionBoundaryCalculationActivityIntegrationTest.cs	(.../DuneErosionBoundaryCalculationActivityIntegrationTest.cs)	(revision b0e228408016f88b94ac63d6896e5bc7668a75c1)
+++ Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Integration.Test/DuneErosionBoundaryCalculationActivityIntegrationTest.cs	(.../DuneErosionBoundaryCalculationActivityIntegrationTest.cs)	(revision 63a5a07d2178d1a83e2439cb40bcfd8cae317455)
@@ -61,7 +61,9 @@
                                                     Orientation = 0,
                                                     D50 = 0.000007
                                                 });
+            var duneLocationCalculation = new DuneLocationCalculation();
             var activity = new DuneErosionBoundaryCalculationActivity(duneLocation,
+                                                                      duneLocationCalculation,
                                                                       validFilePath,
                                                                       validPreprocessorDirectory,
                                                                       1.0 / 30000);
@@ -121,7 +123,9 @@
                                                     Orientation = 0,
                                                     D50 = 0.000007
                                                 });
+            var duneLocationCalculation = new DuneLocationCalculation();
             var activity = new DuneErosionBoundaryCalculationActivity(duneLocation,
+                                                                      duneLocationCalculation,
                                                                       validFilePath,
                                                                       validPreprocessorDirectory,
                                                                       1.0 / 30000);
@@ -147,14 +151,13 @@
             mockRepository.ReplayAll();
 
             var initialOutput = new TestDuneLocationOutput();
-            var duneLocation = new TestDuneLocation
+            var duneLocation = new TestDuneLocation();
+            var duneLocationCalculation = new DuneLocationCalculation
             {
-                Calculation =
-                {
-                    Output = initialOutput
-                }
+                Output = initialOutput
             };
             var activity = new DuneErosionBoundaryCalculationActivity(duneLocation,
+                                                                      duneLocationCalculation,
                                                                       validFilePath,
                                                                       validPreprocessorDirectory,
                                                                       1.0 / 30000);
@@ -166,7 +169,7 @@
 
                 // Assert
                 Assert.AreEqual(ActivityState.Skipped, activity.State);
-                Assert.AreSame(initialOutput, duneLocation.Calculation.Output);
+                Assert.AreSame(initialOutput, duneLocationCalculation.Output);
             }
 
             mockRepository.VerifyAll();
Index: Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/DuneErosionBoundaryCalculationActivityTest.cs
===================================================================
diff -u -rb0e228408016f88b94ac63d6896e5bc7668a75c1 -r63a5a07d2178d1a83e2439cb40bcfd8cae317455
--- Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/DuneErosionBoundaryCalculationActivityTest.cs	(.../DuneErosionBoundaryCalculationActivityTest.cs)	(revision b0e228408016f88b94ac63d6896e5bc7668a75c1)
+++ Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/DuneErosionBoundaryCalculationActivityTest.cs	(.../DuneErosionBoundaryCalculationActivityTest.cs)	(revision 63a5a07d2178d1a83e2439cb40bcfd8cae317455)
@@ -59,9 +59,11 @@
         {
             // Setup
             var duneLocation = new TestDuneLocation();
+            var duneLocationCalculation = new DuneLocationCalculation();
 
             // Call
             var activity = new DuneErosionBoundaryCalculationActivity(duneLocation,
+                                                                      duneLocationCalculation,
                                                                       validFilePath,
                                                                       validPreprocessorDirectory,
                                                                       1.0 / 30000);
@@ -78,6 +80,7 @@
         {
             // Call
             TestDelegate test = () => new DuneErosionBoundaryCalculationActivity(null,
+                                                                                 new DuneLocationCalculation(),
                                                                                  validFilePath,
                                                                                  validPreprocessorDirectory,
                                                                                  1.0 / 30000);
@@ -88,15 +91,32 @@
         }
 
         [Test]
+        public void Constructor_DuneLocationCalculationNull_ThrowArgumentNullException()
+        {
+            // Call
+            TestDelegate test = () => new DuneErosionBoundaryCalculationActivity(new TestDuneLocation(),
+                                                                                 null,
+                                                                                 validFilePath,
+                                                                                 validPreprocessorDirectory,
+                                                                                 1.0 / 30000);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(test);
+            Assert.AreEqual("duneLocationCalculation", exception.ParamName);
+        }
+
+        [Test]
         public void Run_InvalidHydraulicBoundaryDatabase_PerformValidationAndLogStartAndEndAndError()
         {
             // Setup
             string invalidFilePath = Path.Combine(testDataPath, "notexisting.sqlite");
 
             const string locationName = "testLocation";
             var duneLocation = new TestDuneLocation(locationName);
+            var duneLocationCalculation = new DuneLocationCalculation();
 
             var activity = new DuneErosionBoundaryCalculationActivity(duneLocation,
+                                                                      duneLocationCalculation,
                                                                       invalidFilePath,
                                                                       validPreprocessorDirectory,
                                                                       0.5);
@@ -125,8 +145,10 @@
             const string invalidPreprocessorDirectory = "NonExistingPreprocessorDirectory";
             const string locationName = "testLocation";
             var duneLocation = new TestDuneLocation(locationName);
+            var duneLocationCalculation = new DuneLocationCalculation();
 
             var activity = new DuneErosionBoundaryCalculationActivity(duneLocation,
+                                                                      duneLocationCalculation,
                                                                       validFilePath,
                                                                       invalidPreprocessorDirectory,
                                                                       0.5);
@@ -156,6 +178,7 @@
 
             const string locationName = "some name";
             var duneLocation = new TestDuneLocation(locationName);
+            var duneLocationCalculation = new DuneLocationCalculation();
             var calculator = new TestDunesBoundaryConditionsCalculator
             {
                 Converged = true
@@ -166,6 +189,7 @@
             mockRepository.ReplayAll();
 
             var activity = new DuneErosionBoundaryCalculationActivity(duneLocation,
+                                                                      duneLocationCalculation,
                                                                       validFilePath,
                                                                       validPreprocessorDirectory,
                                                                       norm);
@@ -193,6 +217,7 @@
                 Assert.AreEqual(duneLocation.Id, calculationInput.HydraulicBoundaryLocationId);
                 Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(norm), calculationInput.Beta);
             }
+
             Assert.AreEqual(ActivityState.Executed, activity.State);
             mockRepository.VerifyAll();
         }
@@ -201,15 +226,14 @@
         public void Run_DuneLocationOutputSet_ValidationAndCalculationNotPerformedAndStateSkipped()
         {
             // Setup
-            var duneLocation = new TestDuneLocation("locationName")
+            var duneLocation = new TestDuneLocation("locationName");
+            var duneLocationCalculation = new DuneLocationCalculation
             {
-                Calculation =
-                {
-                    Output = new DuneLocationOutput(CalculationConvergence.CalculatedConverged, new DuneLocationOutput.ConstructionProperties())
-                }
+                Output = new DuneLocationOutput(CalculationConvergence.CalculatedConverged, new DuneLocationOutput.ConstructionProperties())
             };
 
             var activity = new DuneErosionBoundaryCalculationActivity(duneLocation,
+                                                                      duneLocationCalculation,
                                                                       validFilePath,
                                                                       validPreprocessorDirectory,
                                                                       0.5);
@@ -233,6 +257,7 @@
             double expectedReliabilityIndex = random.NextDouble();
 
             var duneLocation = new TestDuneLocation();
+            var duneLocationCalculation = new DuneLocationCalculation();
             var calculator = new TestDunesBoundaryConditionsCalculator
             {
                 WaterLevel = expectedWaterLevel,
@@ -247,6 +272,7 @@
             mockRepository.ReplayAll();
 
             var activity = new DuneErosionBoundaryCalculationActivity(duneLocation,
+                                                                      duneLocationCalculation,
                                                                       validFilePath,
                                                                       validPreprocessorDirectory,
                                                                       norm);
@@ -258,7 +284,7 @@
             }
 
             // Assert
-            DuneLocationOutput duneLocationOutput = duneLocation.Calculation.Output;
+            DuneLocationOutput duneLocationOutput = duneLocationCalculation.Output;
             Assert.IsNotNull(duneLocationOutput);
             Assert.AreEqual(expectedWaterLevel, duneLocationOutput.WaterLevel, duneLocationOutput.WaterLevel.GetAccuracy());
             Assert.AreEqual(expectedWaveHeight, duneLocationOutput.WaveHeight, duneLocationOutput.WaveHeight.GetAccuracy());
@@ -287,8 +313,10 @@
             mockRepository.ReplayAll();
 
             var duneLocation = new TestDuneLocation("dune location");
+            var duneLocationCalculation = new DuneLocationCalculation();
 
             var activity = new DuneErosionBoundaryCalculationActivity(duneLocation,
+                                                                      duneLocationCalculation,
                                                                       validFilePath,
                                                                       validPreprocessorDirectory,
                                                                       0.5);
@@ -302,6 +330,7 @@
                 string calculationfailedMessage = $"Hydraulische randvoorwaarden berekening voor locatie '{duneLocation.Name}' is mislukt. {detailedReport}";
                 TestHelper.AssertLogMessageIsGenerated(call, calculationfailedMessage, 7);
             }
+
             mockRepository.VerifyAll();
         }
 
@@ -320,8 +349,10 @@
 
             const string locationName = "some name";
             var duneLocation = new TestDuneLocation(locationName);
+            var duneLocationCalculation = new DuneLocationCalculation();
 
             var activity = new DuneErosionBoundaryCalculationActivity(duneLocation,
+                                                                      duneLocationCalculation,
                                                                       validFilePath,
                                                                       validPreprocessorDirectory,
                                                                       0.5);
@@ -347,6 +378,7 @@
 
                 Assert.AreEqual(CalculationConvergence.CalculatedNotConverged, duneLocation.Calculation.Output.CalculationConvergence);
             }
+
             mockRepository.VerifyAll();
         }
 
@@ -359,6 +391,7 @@
         {
             // Setup
             var duneLocation = new TestDuneLocation();
+            var duneLocationCalculation = new DuneLocationCalculation();
 
             var calculator = new TestDunesBoundaryConditionsCalculator
             {
@@ -371,6 +404,7 @@
             mockRepository.ReplayAll();
 
             var activity = new DuneErosionBoundaryCalculationActivity(duneLocation,
+                                                                      duneLocationCalculation,
                                                                       validFilePath,
                                                                       validPreprocessorDirectory,
                                                                       0.5);
@@ -383,6 +417,7 @@
                 // Assert
                 Assert.AreEqual(ActivityState.Failed, activity.State);
             }
+
             mockRepository.VerifyAll();
         }
 
@@ -395,13 +430,15 @@
         {
             // Setup
             var duneLocation = new TestDuneLocation();
+            var duneLocationCalculation = new DuneLocationCalculation();
 
             var observer = mockRepository.StrictMock<IObserver>();
             observer.Expect(o => o.UpdateObserver());
             duneLocation.Attach(observer);
             mockRepository.ReplayAll();
 
             var activity = new DuneErosionBoundaryCalculationActivityWithState(duneLocation,
+                                                                               duneLocationCalculation,
                                                                                validFilePath,
                                                                                validPreprocessorDirectory,
                                                                                1.0,
@@ -417,11 +454,13 @@
         private class DuneErosionBoundaryCalculationActivityWithState : DuneErosionBoundaryCalculationActivity
         {
             public DuneErosionBoundaryCalculationActivityWithState(DuneLocation duneLocation,
+                                                                   DuneLocationCalculation duneLocationCalculation,
                                                                    string hydraulicBoundaryDatabaseFilePath,
                                                                    string preprocessorDirectory,
                                                                    double norm,
                                                                    ActivityState state)
                 : base(duneLocation,
+                       duneLocationCalculation,
                        hydraulicBoundaryDatabaseFilePath,
                        preprocessorDirectory,
                        norm)