Index: DamClients/DamUI/trunk/src/Dam/Deltares.Dam.TestHelper/ComputeHelper.cs
===================================================================
diff -u -r6793 -r6798
--- DamClients/DamUI/trunk/src/Dam/Deltares.Dam.TestHelper/ComputeHelper.cs	(.../ComputeHelper.cs)	(revision 6793)
+++ DamClients/DamUI/trunk/src/Dam/Deltares.Dam.TestHelper/ComputeHelper.cs	(.../ComputeHelper.cs)	(revision 6798)
@@ -27,36 +27,49 @@
 using Deltares.DamEngine.Io.XmlInput;
 using Deltares.DamEngine.Io.XmlOutput;
 using Deltares.Standard.Logging;
+using DGeoSuite.Common;
 using NUnit.Framework;
 
 namespace Deltares.Dam.TestHelper
 {
+    /// <summary>
+    /// Input parameters for computing a stability project
+    /// </summary>
+    public class ComputeStabilityProjectParameters
+    {
+        public List<string> LocationNames { get; set; } = null;
+        public StabilityModelType ModelType { get; set; } = StabilityModelType.Bishop;
+        public bool IsStabilityInside { get; set; } = true;
+        public int ExpectedLocations { get; set; } = 1;
+        public int MaxCores { get; set; } = 1;
+    }
+
+    /// <summary>
+    /// Helper class to compute stability projects
+    /// </summary>
     public class ComputeHelper
     {
         /// <summary>
         /// Compute stability project
         /// </summary>
-        /// <param name="projectFilename"></param>
-        /// <param name="modelType"></param>
-        /// <param name="isStabilityInside"></param>
-        /// <param name="expectedLocations"></param>
-        /// <param name="logMessages"></param>
-        /// <param name="maxCores"></param>
+        /// <param name="projectFilename">The filename of the project to compute</param>
+        /// <param name="computeStabilityProjectParameters">Parameteres to compute a stability project</param>
+        /// <param name="logMessages">The log messages of the computation</param>
         /// <returns></returns>
-        public static List<CsvExportData> ComputeStabilityProject(string projectFilename, StabilityModelType modelType, bool isStabilityInside,
-                                                                  int expectedLocations, int maxCores, out List<LogMessage> logMessages)
+        public static List<CsvExportData> ComputeStabilityProject(string projectFilename, ComputeStabilityProjectParameters computeStabilityProjectParameters,
+                                                                  out List<LogMessage> logMessages)
         {
             using DamProjectData damProjectData = ProjectLoader.LoadProjectData(projectFilename);
             Assert.That(damProjectData.WaterBoard.Dikes.Count, Is.EqualTo(1));
             Dike dike = damProjectData.WaterBoard.Dikes[0];
-            Assert.That(dike.Locations.Count, Is.EqualTo(expectedLocations));
+            Assert.That(dike.Locations.Count, Is.EqualTo(computeStabilityProjectParameters.ExpectedLocations));
 
             // Specify calculation
-            damProjectData.MaxCalculationCores = maxCores;
-            damProjectData.DamProjectCalculationSpecification.CurrentSpecification.StabilityModelType = modelType;
+            damProjectData.MaxCalculationCores = computeStabilityProjectParameters.MaxCores;
+            damProjectData.DamProjectCalculationSpecification.CurrentSpecification.StabilityModelType = computeStabilityProjectParameters.ModelType;
             damProjectData.DamProjectCalculationSpecification.CurrentSpecification.FailureMechanismeParamatersMStab
                           .MStabParameters.SearchMethod = StabilitySearchMethod.Grid;
-            if (isStabilityInside)
+            if (computeStabilityProjectParameters.IsStabilityInside)
             {
                 damProjectData.DamProjectCalculationSpecification.CurrentSpecification.FailureMechanismSystemType = FailureMechanismSystemType.StabilityInside;
             }
@@ -65,10 +78,21 @@
                 damProjectData.DamProjectCalculationSpecification.CurrentSpecification.FailureMechanismSystemType = FailureMechanismSystemType.StabilityOutside;
             }
 
-            foreach (var locationJob in damProjectData.LocationJobs)
+            // Determine locations to calculate
+            foreach (LocationJob locationJob in damProjectData.LocationJobs)
             {
-                locationJob.Run = true;
+                if (computeStabilityProjectParameters.LocationNames.IsNullOrEmpty())
+                {
+                    // If no location names specified, run all locations
+                    locationJob.Run = true;
+                }
+                else
+                {
+                    // Only run specified locations
+                    locationJob.Run = computeStabilityProjectParameters.LocationNames.Contains(locationJob.Location.Name);
+                }
             }
+
             DamProjectCalculationSpecification.SelectedAnalysisType = AnalysisType.NoAdaption;
 
             Input input = FillXmlInputFromDamUi.CreateInput(damProjectData);
Index: DamClients/DamUI/trunk/src/Dam/Deltares.Dam.IntegrationTests/FailureMechanismTests.cs
===================================================================
diff -u -r6788 -r6798
--- DamClients/DamUI/trunk/src/Dam/Deltares.Dam.IntegrationTests/FailureMechanismTests.cs	(.../FailureMechanismTests.cs)	(revision 6788)
+++ DamClients/DamUI/trunk/src/Dam/Deltares.Dam.IntegrationTests/FailureMechanismTests.cs	(.../FailureMechanismTests.cs)	(revision 6798)
@@ -40,7 +40,7 @@
         public void TestStabilityOutsideWith2DStixFiles()
         {
             string projectFilename = Path.Combine(Directory.GetCurrentDirectory(), @"TestData\StabilityOutside2DFromStixTest\BishopOutside.damx");
-            List<CsvExportData> allCalculationResults = ComputeStabilityOutsideProject(projectFilename, 1);
+            List<CsvExportData> allCalculationResults = ComputeStabilityOutsideProject(projectFilename, new List<string>(), 1);
 
             Assert.That(allCalculationResults, Has.Count.EqualTo(1));
             Assert.Multiple(() =>
@@ -100,23 +100,29 @@
         [Test]
         public void TestStabilityOutsideWith1DProfiles()
         {
+            const string locationToCalculate = "RK212-50";
             string projectFilename = Path.Combine(Directory.GetCurrentDirectory(), @"TestData\StabilityOutside1DProfileTest\Actualisatie.damx");
-            List<CsvExportData> allCalculationResults = ComputeStabilityOutsideProject(projectFilename, 59);
+            var locationsToCalculate = new List<string>
+            {
+                locationToCalculate
+            };
+            List<CsvExportData> allCalculationResults = ComputeStabilityOutsideProject(projectFilename, locationsToCalculate, 59);
 
-            Assert.That(allCalculationResults, Has.Count.EqualTo(100));
+            // Only 1 location (locationToCalculate) is calculated and it has 36 profiles
+            Assert.That(allCalculationResults, Has.Count.EqualTo(36));
             Assert.Multiple(() =>
             {
-                Assert.That(allCalculationResults[1].LocationName, Is.EqualTo("RK210-560"));
+                Assert.That(allCalculationResults[1].LocationName, Is.EqualTo(locationToCalculate));
                 Assert.That(allCalculationResults[1].CalculationResult, Is.EqualTo(CalculationResult.Succeeded));
-                Assert.That(allCalculationResults[1].X, Is.EqualTo(88218.047).Within(tolerance3Decimals));
-                Assert.That(allCalculationResults[1].Y, Is.EqualTo(448871.233).Within(tolerance3Decimals));
+                Assert.That(allCalculationResults[1].X, Is.EqualTo(88157.270).Within(tolerance3Decimals));
+                Assert.That(allCalculationResults[1].Y, Is.EqualTo(448925.910).Within(tolerance3Decimals));
                 Assert.That(allCalculationResults[1].AnalysisType, Is.EqualTo(AnalysisType.NoAdaption));
                 Assert.That(allCalculationResults[1].IsUplift, Is.EqualTo(false));
                 Assert.That(allCalculationResults[1].ProfileName, Is.EqualTo("Segment_1_1D2"));
                 Assert.That(allCalculationResults[1].ProfileProbability, Is.EqualTo(2.43));
                 Assert.That(allCalculationResults[1].StabilityModel, Is.EqualTo(StabilityModelType.Bishop));
                 // In version 19.2.1, the safety factor was 1.079
-                Assert.That(allCalculationResults[1].SafetyFactor, Is.EqualTo(1.129).Within(tolerance3Decimals));
+                Assert.That(allCalculationResults[1].SafetyFactor, Is.EqualTo(1.142).Within(tolerance3Decimals));
                 Assert.That(allCalculationResults[1].ShoulderHeight, Is.EqualTo(null));
                 Assert.That(allCalculationResults[1].ToeAtPolderX, Is.EqualTo(null));
                 Assert.That(allCalculationResults[1].ToeAtPolderZ, Is.EqualTo(null));
@@ -125,7 +131,7 @@
                 Assert.That(allCalculationResults[1].RiverLevelLow, Is.EqualTo(-2.520));
                 Assert.That(allCalculationResults[1].DikeTableHeight, Is.EqualTo(-2.000).Within(tolerance3Decimals));
                 Assert.That(allCalculationResults[1].SlopeDampingPiezometricHeightPolderSide, Is.EqualTo(0.000));
-                Assert.That(allCalculationResults[1].DikeLength, Is.EqualTo(14.12).Within(tolerance3Decimals * 10));
+                Assert.That(allCalculationResults[1].DikeLength, Is.EqualTo(10.73).Within(tolerance3Decimals * 10));
 
                 Assert.That(allCalculationResults[1].Pl3MinUplift, Is.EqualTo(null));
                 Assert.That(allCalculationResults[1].Pl3HeadAdjusted, Is.EqualTo(null));
@@ -138,9 +144,9 @@
                 Assert.That(allCalculationResults[1].Pl4LocationXMinUplift, Is.EqualTo(null));
                 Assert.That(allCalculationResults[1].Pl4LocationYMinUplift, Is.EqualTo(null));
 
-                Assert.That(allCalculationResults[1].LocalPipingEntryPointX, Is.EqualTo(9.798).Within(tolerance3Decimals));
-                Assert.That(allCalculationResults[1].PipingEntryPointX, Is.EqualTo(88216.844).Within(tolerance3Decimals));
-                Assert.That(allCalculationResults[1].PipingEntryPointY, Is.EqualTo(448870.287).Within(tolerance3Decimals));
+                Assert.That(allCalculationResults[1].LocalPipingEntryPointX, Is.EqualTo(9.581).Within(tolerance3Decimals));
+                Assert.That(allCalculationResults[1].PipingEntryPointX, Is.EqualTo(88158.879).Within(tolerance3Decimals));
+                Assert.That(allCalculationResults[1].PipingEntryPointY, Is.EqualTo(448927.141).Within(tolerance3Decimals));
                 Assert.That(allCalculationResults[1].LocalPipingExitPointX, Is.EqualTo(null));
                 Assert.That(allCalculationResults[1].PipingExitPointX, Is.EqualTo(null));
                 Assert.That(allCalculationResults[1].PipingExitPointY, Is.EqualTo(null));
@@ -155,15 +161,15 @@
                 // Check safety factors of few other soil profiles
                 // In version 19.2.1, safety factors were: [4]=1.079, [8]=0.967, [10]=1.046, [11]=1.225 [12]=1.046
                 Assert.That(allCalculationResults[4].ProfileName, Is.EqualTo("Segment_1_1D5"));
-                Assert.That(allCalculationResults[4].SafetyFactor, Is.EqualTo(1.129).Within(tolerance3Decimals));
+                Assert.That(allCalculationResults[4].SafetyFactor, Is.EqualTo(1.142).Within(tolerance3Decimals));
                 Assert.That(allCalculationResults[8].ProfileName, Is.EqualTo("Segment_1_1D9"));
-                Assert.That(allCalculationResults[8].SafetyFactor, Is.EqualTo(1.049).Within(tolerance3Decimals));
+                Assert.That(allCalculationResults[8].SafetyFactor, Is.EqualTo(0.838).Within(tolerance3Decimals));
                 Assert.That(allCalculationResults[10].ProfileName, Is.EqualTo("Segment_1_1D11"));
-                Assert.That(allCalculationResults[10].SafetyFactor, Is.EqualTo(1.111).Within(tolerance3Decimals));
+                Assert.That(allCalculationResults[10].SafetyFactor, Is.EqualTo(1.000).Within(tolerance3Decimals));
                 Assert.That(allCalculationResults[11].ProfileName, Is.EqualTo("Segment_1_1D12"));
-                Assert.That(allCalculationResults[11].SafetyFactor, Is.EqualTo(1.253).Within(tolerance3Decimals));
+                Assert.That(allCalculationResults[11].SafetyFactor, Is.EqualTo(0.873).Within(tolerance3Decimals));
                 Assert.That(allCalculationResults[12].ProfileName, Is.EqualTo("Segment_1_1D13"));
-                Assert.That(allCalculationResults[12].SafetyFactor, Is.EqualTo(1.111).Within(tolerance3Decimals));
+                Assert.That(allCalculationResults[12].SafetyFactor, Is.EqualTo(1.000).Within(tolerance3Decimals));
             });
         }
 
@@ -173,9 +179,18 @@
         /// <param name="projectFilename"></param>
         /// <param name="expectedLocations"></param>
         /// <returns></returns>
-        private static List<CsvExportData> ComputeStabilityOutsideProject(string projectFilename, int expectedLocations)
+        private static List<CsvExportData> ComputeStabilityOutsideProject(string projectFilename, List<string> locationsToCalculate,
+                                                                          int expectedLocations)
         {
-            return ComputeHelper.ComputeStabilityProject(projectFilename, StabilityModelType.Bishop, false, expectedLocations, 1, out List<LogMessage> _);
+            var computeStabilityProjectParameters = new ComputeStabilityProjectParameters
+            {
+                LocationNames = locationsToCalculate,
+                ModelType = StabilityModelType.Bishop,
+                IsStabilityInside = false,
+                ExpectedLocations = expectedLocations,
+                MaxCores = 1
+            };
+            return ComputeHelper.ComputeStabilityProject(projectFilename, computeStabilityProjectParameters, out List<LogMessage> _);
         }
     }
 }
\ No newline at end of file