Index: Ringtoets/Common/test/Ringtoets.Common.Service.Test/WaveHeightCalculationServiceTest.cs
===================================================================
diff -u -rf27e8e2e7c8d056c76f2f883ae6bdf03edb740fc -r639ed2d13b89000c99295422e20162320a1456cb
--- Ringtoets/Common/test/Ringtoets.Common.Service.Test/WaveHeightCalculationServiceTest.cs	(.../WaveHeightCalculationServiceTest.cs)	(revision f27e8e2e7c8d056c76f2f883ae6bdf03edb740fc)
+++ Ringtoets/Common/test/Ringtoets.Common.Service.Test/WaveHeightCalculationServiceTest.cs	(.../WaveHeightCalculationServiceTest.cs)	(revision 639ed2d13b89000c99295422e20162320a1456cb)
@@ -134,7 +134,7 @@
         }
 
         [Test]
-        public void Calculate_WaveHeightCalculationNull_ThrowArgumentNullException()
+        public void Calculate_CalculationWrapperNull_ThrowArgumentNullException()
         {
             // Setup
             var mockRepository = new MockRepository();
@@ -146,7 +146,7 @@
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(test);
-            Assert.AreEqual("waveHeightCalculation", exception.ParamName);
+            Assert.AreEqual("calculationWrapper", exception.ParamName);
         }
 
         [Test]
@@ -167,17 +167,21 @@
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
             calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, validPreprocessorDirectory)).Return(calculator);
 
-            var calculation = mockRepository.Stub<IHydraulicBoundaryCalculationWrapper>();
-            calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-            calculation.Expect(c => c.CalculateIllustrationPoints).Return(readIllustrationPoints);
-
             var calculationMessageProvider = mockRepository.StrictMock<ICalculationMessageProvider>();
             mockRepository.ReplayAll();
 
+            var location = new HydraulicBoundaryLocation(100, "punt_flw_ 1", 0.0, 0.0);
+            var calculation = new HydraulicBoundaryLocationCalculation
+            {
+                InputParameters =
+                {
+                    ShouldIllustrationPointsBeCalculated = readIllustrationPoints
+                }
+            };
+
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
-                Action call = () => new WaveHeightCalculationService().Calculate(calculation,
+                Action call = () => new WaveHeightCalculationService().Calculate(new HydraulicBoundaryCalculationWrapper(location, calculation),
                                                                                  validFilePath,
                                                                                  validPreprocessorDirectory,
                                                                                  norm,
@@ -200,6 +204,7 @@
                 Assert.IsNotNull(calculation.Output);
                 Assert.AreEqual(readIllustrationPoints, calculation.Output.HasGeneralResult);
             }
+
             mockRepository.VerifyAll();
         }
 
@@ -223,18 +228,16 @@
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
             calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, preprocessorDirectory)).Return(calculator);
 
-            var calculation = mockRepository.Stub<IHydraulicBoundaryCalculationWrapper>();
-            calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-            calculation.Expect(c => c.CalculateIllustrationPoints).Return(false);
-
             var calculationMessageProvider = mockRepository.StrictMock<ICalculationMessageProvider>();
             mockRepository.ReplayAll();
 
+            var location = new HydraulicBoundaryLocation(100, "punt_flw_ 1", 0.0, 0.0);
+            var calculation = new HydraulicBoundaryLocationCalculation();
+
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 // Call
-                new WaveHeightCalculationService().Calculate(calculation,
+                new WaveHeightCalculationService().Calculate(new HydraulicBoundaryCalculationWrapper(location, calculation),
                                                              validFilePath,
                                                              preprocessorDirectory,
                                                              1.0 / 30,
@@ -243,13 +246,14 @@
                 // Assert
                 Assert.AreEqual(usePreprocessor, calculator.ReceivedInputs.Single().PreprocessorSetting.RunPreprocessor);
             }
+
             mockRepository.VerifyAll();
         }
 
         [Test]
         [TestCase(true)]
         [TestCase(false)]
-        public void Calculate_ValidWaveHeightCalculationAndDoesNotConverge_SetsOutputAndLogs(bool calculateIllustrationPoints)
+        public void Calculate_ValidWaveHeightCalculationAndDoesNotConverge_SetsOutputAndLogs(bool readIllustrationPoints)
         {
             // Setup
             var calculator = new TestWaveHeightCalculator
@@ -262,19 +266,23 @@
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
             calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, validPreprocessorDirectory)).Return(calculator);
 
-            var calculation = mockRepository.Stub<IHydraulicBoundaryCalculationWrapper>();
-            calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-            calculation.Expect(c => c.CalculateIllustrationPoints).Return(calculateIllustrationPoints);
-
             var calculationMessageProvider = mockRepository.StrictMock<ICalculationMessageProvider>();
             const string failedConvergenceMessage = "Did not converge";
             calculationMessageProvider.Expect(mp => mp.GetCalculatedNotConvergedMessage("punt_flw_ 1")).Return(failedConvergenceMessage);
             mockRepository.ReplayAll();
 
+            var location = new HydraulicBoundaryLocation(100, "punt_flw_ 1", 0.0, 0.0);
+            var calculation = new HydraulicBoundaryLocationCalculation
+            {
+                InputParameters =
+                {
+                    ShouldIllustrationPointsBeCalculated = readIllustrationPoints
+                }
+            };
+
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
-                Action call = () => new WaveHeightCalculationService().Calculate(calculation,
+                Action call = () => new WaveHeightCalculationService().Calculate(new HydraulicBoundaryCalculationWrapper(location, calculation),
                                                                                  validFilePath,
                                                                                  validPreprocessorDirectory,
                                                                                  1.0 / 30,
@@ -293,8 +301,9 @@
                 });
                 Assert.IsFalse(calculator.IsCanceled);
                 Assert.IsNotNull(calculation.Output);
-                Assert.AreEqual(calculateIllustrationPoints, calculation.Output.HasGeneralResult);
+                Assert.AreEqual(readIllustrationPoints, calculation.Output.HasGeneralResult);
             }
+
             mockRepository.VerifyAll();
         }
 
@@ -312,18 +321,22 @@
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
             calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, validPreprocessorDirectory)).Return(calculator);
 
-            var calculation = mockRepository.Stub<IHydraulicBoundaryCalculationWrapper>();
-            calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-            calculation.Expect(c => c.CalculateIllustrationPoints).Return(true);
-
             var calculationMessageProvider = mockRepository.StrictMock<ICalculationMessageProvider>();
             mockRepository.ReplayAll();
 
+            var location = new HydraulicBoundaryLocation(100, "punt_flw_ 1", 0.0, 0.0);
+            var calculation = new HydraulicBoundaryLocationCalculation
+            {
+                InputParameters =
+                {
+                    ShouldIllustrationPointsBeCalculated = true
+                }
+            };
+
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 // Call
-                Action call = () => new WaveHeightCalculationService().Calculate(calculation,
+                Action call = () => new WaveHeightCalculationService().Calculate(new HydraulicBoundaryCalculationWrapper(location, calculation),
                                                                                  validFilePath,
                                                                                  validPreprocessorDirectory,
                                                                                  1.0 / 30,
@@ -348,6 +361,7 @@
                 Assert.IsNotNull(calculation.Output);
                 Assert.IsFalse(calculation.Output.HasGeneralResult);
             }
+
             mockRepository.VerifyAll();
         }
 
@@ -365,18 +379,22 @@
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
             calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, validPreprocessorDirectory)).Return(calculator);
 
-            var calculation = mockRepository.Stub<IHydraulicBoundaryCalculationWrapper>();
-            calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Stub(c => c.Id).Return(100);
-            calculation.Stub(c => c.CalculateIllustrationPoints).Return(true);
-
             var calculationMessageProvider = mockRepository.StrictMock<ICalculationMessageProvider>();
             mockRepository.ReplayAll();
 
+            var location = new HydraulicBoundaryLocation(100, "punt_flw_ 1", 0.0, 0.0);
+            var calculation = new HydraulicBoundaryLocationCalculation
+            {
+                InputParameters =
+                {
+                    ShouldIllustrationPointsBeCalculated = true
+                }
+            };
+
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 // Call
-                Action call = () => new WaveHeightCalculationService().Calculate(calculation,
+                Action call = () => new WaveHeightCalculationService().Calculate(new HydraulicBoundaryCalculationWrapper(location, calculation),
                                                                                  validFilePath,
                                                                                  validPreprocessorDirectory,
                                                                                  1.0 / 30,
@@ -401,6 +419,7 @@
                 Assert.IsNotNull(calculation.Output);
                 Assert.IsFalse(calculation.Output.HasGeneralResult);
             }
+
             mockRepository.VerifyAll();
         }
 
@@ -420,19 +439,18 @@
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
             calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, validPreprocessorDirectory)).Return(calculator);
 
-            var calculation = mockRepository.Stub<IHydraulicBoundaryCalculationWrapper>();
-            calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-
             var calculationMessageProvider = mockRepository.Stub<ICalculationMessageProvider>();
             calculationMessageProvider.Stub(mp => mp.GetCalculatedNotConvergedMessage("punt_flw_ 1")).Return(string.Empty);
             mockRepository.ReplayAll();
 
+            var location = new HydraulicBoundaryLocation(100, "punt_flw_ 1", 0.0, 0.0);
+            var calculation = new HydraulicBoundaryLocationCalculation();
+
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 // Call
                 TestDelegate call = () => new WaveHeightCalculationService()
-                    .Calculate(calculation,
+                    .Calculate(new HydraulicBoundaryCalculationWrapper(location, calculation),
                                validFilePath,
                                validPreprocessorDirectory,
                                1.0 / 30,
@@ -442,6 +460,7 @@
                 var thrownException = Assert.Throws<HydraRingFileParserException>(call);
                 Assert.AreSame(expectedException, thrownException);
             }
+
             mockRepository.VerifyAll();
         }
 
@@ -460,19 +479,23 @@
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
             calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, validPreprocessorDirectory)).Return(calculator);
 
-            var calculation = mockRepository.Stub<IHydraulicBoundaryCalculationWrapper>();
-            calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-            calculation.Expect(c => c.CalculateIllustrationPoints).Return(true);
-
             var calculationMessageProvider = mockRepository.Stub<ICalculationMessageProvider>();
             mockRepository.ReplayAll();
 
+            var location = new HydraulicBoundaryLocation(100, "punt_flw_ 1", 0.0, 0.0);
+            var calculation = new HydraulicBoundaryLocationCalculation
+            {
+                InputParameters =
+                {
+                    ShouldIllustrationPointsBeCalculated = true
+                }
+            };
+
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 // Call
                 Action call = () => new WaveHeightCalculationService()
-                    .Calculate(calculation,
+                    .Calculate(new HydraulicBoundaryCalculationWrapper(location, calculation),
                                validFilePath,
                                validPreprocessorDirectory,
                                1.0 / 30,
@@ -491,6 +514,7 @@
                 });
                 Assert.IsFalse(calculation.Output.HasGeneralResult);
             }
+
             mockRepository.VerifyAll();
         }
 
@@ -508,19 +532,17 @@
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
             calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, validPreprocessorDirectory)).Return(calculator);
 
-            var calculation = mockRepository.Stub<IHydraulicBoundaryCalculationWrapper>();
-            calculation.Stub(c => c.Name).Return("punt_flw_ 1");
-            calculation.Expect(c => c.Id).Return(100);
-            calculation.Expect(c => c.CalculateIllustrationPoints).Return(false);
-
             var calculationMessageProvider = mockRepository.Stub<ICalculationMessageProvider>();
             mockRepository.ReplayAll();
 
+            var location = new HydraulicBoundaryLocation(100, "punt_flw_ 1", 0.0, 0.0);
+            var calculation = new HydraulicBoundaryLocationCalculation();
+
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 // Call
                 Action call = () => new WaveHeightCalculationService()
-                    .Calculate(calculation,
+                    .Calculate(new HydraulicBoundaryCalculationWrapper(location, calculation),
                                validFilePath,
                                validPreprocessorDirectory,
                                1.0 / 30,
@@ -537,6 +559,7 @@
                     CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[2]);
                 });
             }
+
             mockRepository.VerifyAll();
         }
 
@@ -550,13 +573,12 @@
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
             calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, validPreprocessorDirectory)).Return(calculator);
 
-            var calculation = mockRepository.Stub<IHydraulicBoundaryCalculationWrapper>();
-            calculation.Stub(c => c.Name).Return("name");
-            calculation.Expect(c => c.Id).Return(0);
-
             var calculationMessageProvider = mockRepository.Stub<ICalculationMessageProvider>();
             mockRepository.ReplayAll();
 
+            var location = new HydraulicBoundaryLocation(100, "punt_flw_ 1", 0.0, 0.0);
+            var calculation = new HydraulicBoundaryLocationCalculation();
+
             const double norm = 1.0 / 30;
 
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
@@ -565,7 +587,7 @@
                 calculator.CalculationFinishedHandler += (s, e) => service.Cancel();
 
                 // Call
-                service.Calculate(calculation,
+                service.Calculate(new HydraulicBoundaryCalculationWrapper(location, calculation),
                                   validFilePath,
                                   validPreprocessorDirectory,
                                   norm,
@@ -574,6 +596,7 @@
                 // Assert
                 Assert.IsTrue(calculator.IsCanceled);
             }
+
             mockRepository.VerifyAll();
         }
 
@@ -599,10 +622,6 @@
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
             calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, validPreprocessorDirectory)).Return(calculator);
 
-            var calculation = mockRepository.Stub<IHydraulicBoundaryCalculationWrapper>();
-            calculation.Stub(c => c.Name).Return(locationName);
-            calculation.Expect(c => c.Id).Return(0);
-
             var calculationMessageProvider = mockRepository.Stub<ICalculationMessageProvider>();
             if (endInFailure && string.IsNullOrEmpty(lastErrorFileContent))
             {
@@ -616,8 +635,12 @@
                                                                                                           : lastErrorFileContent
                                                   )).Return(calculationFailedMessage);
             }
+
             mockRepository.ReplayAll();
 
+            var location = new HydraulicBoundaryLocation(100, locationName, 0.0, 0.0);
+            var calculation = new HydraulicBoundaryLocationCalculation();
+
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 HydraRingCalculationException exception = null;
@@ -627,7 +650,7 @@
                 {
                     try
                     {
-                        new WaveHeightCalculationService().Calculate(calculation,
+                        new WaveHeightCalculationService().Calculate(new HydraulicBoundaryCalculationWrapper(location, calculation),
                                                                      validFilePath,
                                                                      validPreprocessorDirectory,
                                                                      norm,
@@ -653,6 +676,7 @@
 
                 Assert.IsInstanceOf<HydraRingCalculationException>(exception);
             }
+
             mockRepository.VerifyAll();
         }