Index: DamClients/DamUI/trunk/src/Dam/Deltares.Dam.Tests/WaterBoardImporterTests.cs
===================================================================
diff -u -r4070 -r4174
--- DamClients/DamUI/trunk/src/Dam/Deltares.Dam.Tests/WaterBoardImporterTests.cs	(.../WaterBoardImporterTests.cs)	(revision 4070)
+++ DamClients/DamUI/trunk/src/Dam/Deltares.Dam.Tests/WaterBoardImporterTests.cs	(.../WaterBoardImporterTests.cs)	(revision 4174)
@@ -28,326 +28,315 @@
 using Deltares.Geometry;
 using Deltares.Geotechnics.Soils;
 using Deltares.Geotechnics.SurfaceLines;
+using Deltares.Standard.Logging;
 using NUnit.Framework;
 
-namespace Deltares.Dam.Tests
+namespace Deltares.Dam.Tests;
+
+[TestFixture]
+public class WaterBoardImporterTests
 {
-    [TestFixture]
-    public class WaterBoardImporterTests
+    private const string DirectoryWithCsvFiles = @"..\..\..\..\..\data\Dam\Waterboards\Groot Salland\Binnenwaarts";
+    private List<DataSource> srcDataSources;
+    private DataPluginImporter dataPluginImporter;
+    private DataSourceContainer dataSourceContainer;
+
+    [Test]
+    [Category("Slow")]
+    public void WaterBoardImportedWithCsvFilesHasValidData()
     {
-        private const string DirectoryWithCsvFiles = @"..\..\..\..\..\data\Dam\Waterboards\Groot Salland\Binnenwaarts";
-        private List<DataSource> srcDataSources;
-        private DataPluginImporter dataPluginImporter;
-        private DataSourceContainer dataSourceContainer;
+        const string soilKleiDuin = "klei duin";
+        const string soilProfileId = "10Z_275_STBI_p";
+        const string segmentId = "segment_dijkring10_dwp02_4";
+        const string surfacelineId = "dijkring10_dwp40_0";
+        const string locationId = "dwp04_1";
+        const double cTolerance = 0.00001;
+        const double cToleranceCoordinate = 0.00001;
+        SetupForCsvFilesImport();
+        using WaterBoard waterBoard = WaterBoardImporter.ImportAllData("", dataSourceContainer,
+                                                                       DamProjectType.Calamity, null, out List<LogMessage> _);
+        // Check Dike
+        Assert.AreEqual(1, waterBoard.Dikes.Count);
+        Dike dike = waterBoard.Dikes[0];
 
-        [Test]
-        [Category("Slow")]
-        public void WaterBoardImportedWithCsvFilesHasValidData()
-        {
-            const string soilKleiDuin = "klei duin";
-            const string soilProfileId = "10Z_275_STBI_p";
-            const string segmentId = "segment_dijkring10_dwp02_4";
-            const string surfacelineId = "dijkring10_dwp40_0";
-            const string locationId = "dwp04_1";
-            const double cTolerance = 0.00001;
-            const double cToleranceCoordinate = 0.00001;
-            SetupForCsvFilesImport();
-            using (WaterBoard waterBoard =
-                   WaterBoardImporter.ImportAllData("", dataSourceContainer, DamProjectType.Calamity, null))
-            {
-                // Check Dike
-                Assert.AreEqual(1, waterBoard.Dikes.Count);
-                Dike dike = waterBoard.Dikes[0];
+        //Check Soils
+        Assert.AreEqual(47, dike.SoilList.Soils.Count);
+        Soil soil = dike.SoilList.Soils[dike.SoilList.GetSoilIndexByName(soilKleiDuin)];
+        Assert.AreEqual(15.7, soil.AbovePhreaticLevel, cTolerance);
 
-                //Check Soils
-                Assert.AreEqual(47, dike.SoilList.Soils.Count);
-                Soil soil = dike.SoilList.Soils[dike.SoilList.GetSoilIndexByName(soilKleiDuin)];
-                Assert.AreEqual(15.7, soil.AbovePhreaticLevel, cTolerance);
+        // Check Soilprofiles
+        Assert.AreEqual(26, dike.SoilProfiles.Count);
+        SoilProfile1D soilProfile = dike.SoilProfiles.First(x => x.Name.Equals(soilProfileId));
+        Assert.AreEqual(soilKleiDuin, soilProfile.Layers[0].Soil.Name);
 
-                // Check Soilprofiles
-                Assert.AreEqual(26, dike.SoilProfiles.Count);
-                SoilProfile1D soilProfile = dike.SoilProfiles.First(x => x.Name.Equals(soilProfileId));
-                Assert.AreEqual(soilKleiDuin, soilProfile.Layers[0].Soil.Name);
+        // Check Segments
+        Assert.AreEqual(24, waterBoard.Segments.Count);
+        Segment segment = waterBoard.Segments.First(x => x.Name.Equals(segmentId));
+        Assert.AreEqual("10Y_024_STBI.sti", segment.SoilProfileProbabilities[0].SoilGeometryName);
+        Assert.AreEqual(100.0, segment.SoilProfileProbabilities[0].Probability, cTolerance);
+        Assert.IsTrue(segment.SoilProfileProbabilities[0].SegmentFailureMechanismType
+                             .Equals(FailureMechanismSystemType.StabilityInside));
+        // Check segment with stability and piping
+        segment = waterBoard.Segments.Where(x => x.Name.Equals("segment_dijkring10_dwp02_4")).FirstOrDefault();
+        Assert.AreEqual("10Y_024_STBI.sti", segment.SoilProfileProbabilities[0].SoilGeometryName);
+        Assert.AreEqual(100.0, segment.SoilProfileProbabilities[0].Probability, cTolerance);
+        Assert.IsTrue(segment.SoilProfileProbabilities[0].SegmentFailureMechanismType
+                             .Equals(FailureMechanismSystemType.StabilityInside));
+        Assert.AreEqual("10Y_024_STBI.sti", segment.SoilProfileProbabilities[1].SoilGeometryName);
+        Assert.AreEqual(100.0, segment.SoilProfileProbabilities[1].Probability, cTolerance);
+        Assert.IsTrue(segment.SoilProfileProbabilities[1].SegmentFailureMechanismType
+                             .Equals(FailureMechanismSystemType.Piping));
 
-                // Check Segments
-                Assert.AreEqual(24, waterBoard.Segments.Count);
-                Segment segment = waterBoard.Segments.First(x => x.Name.Equals(segmentId));
-                Assert.AreEqual("10Y_024_STBI.sti", segment.SoilProfileProbabilities[0].SoilGeometryName);
-                Assert.AreEqual(100.0, segment.SoilProfileProbabilities[0].Probability, cTolerance);
-                Assert.IsTrue(segment.SoilProfileProbabilities[0].SegmentFailureMechanismType
-                                     .Equals(FailureMechanismSystemType.StabilityInside));
-                // Check segment with stability and piping
-                segment = waterBoard.Segments.Where(x => x.Name.Equals("segment_dijkring10_dwp02_4")).FirstOrDefault();
-                Assert.AreEqual("10Y_024_STBI.sti", segment.SoilProfileProbabilities[0].SoilGeometryName);
-                Assert.AreEqual(100.0, segment.SoilProfileProbabilities[0].Probability, cTolerance);
-                Assert.IsTrue(segment.SoilProfileProbabilities[0].SegmentFailureMechanismType
-                                     .Equals(FailureMechanismSystemType.StabilityInside));
-                Assert.AreEqual("10Y_024_STBI.sti", segment.SoilProfileProbabilities[1].SoilGeometryName);
-                Assert.AreEqual(100.0, segment.SoilProfileProbabilities[1].Probability, cTolerance);
-                Assert.IsTrue(segment.SoilProfileProbabilities[1].SegmentFailureMechanismType
-                                     .Equals(FailureMechanismSystemType.Piping));
+        // Check surfacelines 
+        Assert.AreEqual(13, dike.SurfaceLines2.Count);
+        SurfaceLine2 surfaceline = dike.SurfaceLines2.First(x => x.Name.Equals(surfacelineId));
+        Assert.IsTrue(surfaceline.Geometry.Points.Any());
+        Assert.AreEqual(0.0, surfaceline.Geometry.Points[0].X, cToleranceCoordinate);
+        Assert.AreEqual(0.0, surfaceline.Geometry.Points[0].Y, cToleranceCoordinate);
+        Assert.AreEqual(-0.48, surfaceline.Geometry.Points[0].Z, cToleranceCoordinate);
+        int lastPointIndex = surfaceline.Geometry.Count - 1;
+        Assert.AreEqual(71.25, surfaceline.Geometry.Points[lastPointIndex].X, cToleranceCoordinate);
+        Assert.AreEqual(0.0, surfaceline.Geometry.Points[lastPointIndex].Y, cToleranceCoordinate);
+        Assert.AreEqual(-0.36, surfaceline.Geometry.Points[lastPointIndex].Z, cToleranceCoordinate);
 
-                // Check surfacelines 
-                Assert.AreEqual(13, dike.SurfaceLines2.Count);
-                SurfaceLine2 surfaceline = dike.SurfaceLines2.First(x => x.Name.Equals(surfacelineId));
-                Assert.IsTrue(surfaceline.Geometry.Points.Any());
-                Assert.AreEqual(0.0, surfaceline.Geometry.Points[0].X, cToleranceCoordinate);
-                Assert.AreEqual(0.0, surfaceline.Geometry.Points[0].Y, cToleranceCoordinate);
-                Assert.AreEqual(-0.48, surfaceline.Geometry.Points[0].Z, cToleranceCoordinate);
-                int lastPointIndex = surfaceline.Geometry.Count - 1;
-                Assert.AreEqual(71.25, surfaceline.Geometry.Points[lastPointIndex].X, cToleranceCoordinate);
-                Assert.AreEqual(0.0, surfaceline.Geometry.Points[lastPointIndex].Y, cToleranceCoordinate);
-                Assert.AreEqual(-0.36, surfaceline.Geometry.Points[lastPointIndex].Z, cToleranceCoordinate);
+        GeometryPoint point = surfaceline.CharacteristicPoints.GetGeometryPoint(
+            CharacteristicPointType.SurfaceLevelInside);
+        Assert.AreEqual(71.25, point.X, cToleranceCoordinate);
+        Assert.AreEqual(0.0, point.Y, cToleranceCoordinate);
+        Assert.AreEqual(-0.36, point.Z, cToleranceCoordinate);
 
-                GeometryPoint point = surfaceline.CharacteristicPoints.GetGeometryPoint(
-                    CharacteristicPointType.SurfaceLevelInside);
-                Assert.AreEqual(71.25, point.X, cToleranceCoordinate);
-                Assert.AreEqual(0.0, point.Y, cToleranceCoordinate);
-                Assert.AreEqual(-0.36, point.Z, cToleranceCoordinate);
-
-                // Check locations
-                Assert.AreEqual(13, dike.Locations.Count);
-                Location location = dike.Locations.First(x => x.Name.Equals(locationId));
+        // Check locations
+        Assert.AreEqual(13, dike.Locations.Count);
+        Location location = dike.Locations.First(x => x.Name.Equals(locationId));
 //                Assert.AreEqual(0.25, location.MinimalCircleDepth, cTolerance); // is default from modelparameters
 
-                Assert.AreEqual("segment_dijkring10_dwp04_1", location.Segment.Name);
-                Assert.AreEqual("dijkring10_dwp04_1", location.SurfaceLine2.Name);
+        Assert.AreEqual("segment_dijkring10_dwp04_1", location.Segment.Name);
+        Assert.AreEqual("dijkring10_dwp04_1", location.SurfaceLine2.Name);
 
-                dike.Validate();
-            }
-        }
+        dike.Validate();
+    }
 
-        [Test]
-        [Category("Slow")]
-        public void ImportWaterBoardOnlyCsvFiles1D()
-        {
-            const double cTolerance = 0.0001;
-            const string definitionFilename = @".\TestData\CSVData\Full1DProject\Import.defx";
+    [Test]
+    [Category("Slow")]
+    public void ImportWaterBoardOnlyCsvFiles1D()
+    {
+        const double cTolerance = 0.0001;
+        const string definitionFilename = @".\TestData\CSVData\Full1DProject\Import.defx";
 
-            dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
-            string damImportFolder = Path.GetDirectoryName(definitionFilename);
-            IList<string> dikeList =
-                WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, DamProjectType.Calamity,
-                                                     out _).ToList();
-            using (WaterBoard waterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, dataSourceContainer,
-                                                                                     dikeList, DamProjectType.Calamity, null))
-            {
-                //WaterBoard waterBoard = WaterBoardImporter.ImportAllData(damImportFolder, dataSourceContainer, null);
+        dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
+        string damImportFolder = Path.GetDirectoryName(definitionFilename);
+        IList<string> dikeList = WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, 
+                                                                      DamProjectType.Calamity, out _).ToList();
+        using WaterBoard waterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, 
+                                                                                dataSourceContainer, dikeList, 
+                                                                                DamProjectType.Calamity, null, 
+                                                                                out List<LogMessage> _);
 
-                // Check Dike
-                Assert.AreEqual(1, waterBoard.Dikes.Count);
-                Dike dike = waterBoard.Dikes[0];
+        // Check Dike
+        Assert.AreEqual(1, waterBoard.Dikes.Count);
+        Dike dike = waterBoard.Dikes[0];
 
-                //Check locations
-                Assert.AreEqual(2, dike.Locations.Count);
+        //Check locations
+        Assert.AreEqual(2, dike.Locations.Count);
 
-                // Check Soilprofiles
-                Assert.AreEqual(23, dike.SoilProfiles.Count);
-                SoilProfile1D soilProfile = dike.SoilProfiles.First(x => x.Name.Equals("25_2_1_bz_4"));
-                Assert.AreEqual("kade", soilProfile.Layers[0].Soil.Name);
+        // Check Soilprofiles
+        Assert.AreEqual(23, dike.SoilProfiles.Count);
+        SoilProfile1D soilProfile = dike.SoilProfiles.First(x => x.Name.Equals("25_2_1_bz_4"));
+        Assert.AreEqual("kade", soilProfile.Layers[0].Soil.Name);
 
-                //Check Soils
-                Assert.AreEqual(51, dike.SoilList.Soils.Count);
-                Soil soil = dike.SoilList.Soils[dike.SoilList.GetSoilIndexByName("kade")];
-                Assert.AreEqual(17.0, soil.AbovePhreaticLevel, cTolerance);
+        //Check Soils
+        Assert.AreEqual(51, dike.SoilList.Soils.Count);
+        Soil soil = dike.SoilList.Soils[dike.SoilList.GetSoilIndexByName("kade")];
+        Assert.AreEqual(17.0, soil.AbovePhreaticLevel, cTolerance);
 
-                // Check Segments
-                Assert.AreEqual(2, waterBoard.Segments.Count);
-                Segment segment = waterBoard.Segments.First(x => x.Name.Equals("106"));
-                Assert.AreEqual("25_2_1_bz_1", segment.SoilProfileProbabilities[0].SoilGeometryName);
-                Assert.AreEqual(35.0, segment.SoilProfileProbabilities[0].Probability, cTolerance);
-                Assert.IsTrue(segment.SoilProfileProbabilities[0].SegmentFailureMechanismType
-                                     .Equals(FailureMechanismSystemType.StabilityInside));
-            }
-        }
+        // Check Segments
+        Assert.AreEqual(2, waterBoard.Segments.Count);
+        Segment segment = waterBoard.Segments.First(x => x.Name.Equals("106"));
+        Assert.AreEqual("25_2_1_bz_1", segment.SoilProfileProbabilities[0].SoilGeometryName);
+        Assert.AreEqual(35.0, segment.SoilProfileProbabilities[0].Probability, cTolerance);
+        Assert.IsTrue(segment.SoilProfileProbabilities[0].SegmentFailureMechanismType
+                             .Equals(FailureMechanismSystemType.StabilityInside));
+    }
 
-        [Test]
-        [Category("Slow")]
-        public void ImportWaterBoardOnlyCsvFiles2D()
+    [Test]
+    [Category("Slow")]
+    public void ImportWaterBoardOnlyCsvFiles2D()
+    {
+        const string definitionFilename = @".\TestData\CSVData\Full2DProject\Import.defx";
+        const string projectFilename = @".\TestData\TestWithGeometries2D.damx";
+        using (var damProject = new DamProject())
         {
-            //const double cTolerance = 0.0001;
-            const string definitionFilename = @".\TestData\CSVData\Full2DProject\Import.defx";
-            const string projectFilename = @".\TestData\TestWithGeometries2D.damx";
-            using (var damProject = new DamProject())
-            {
-                dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
-                string damImportFolder = Path.GetDirectoryName(definitionFilename);
-                IList<string> dikeList = WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer,
-                                                                              DamProjectType.Calamity, out _).ToList();
-                damProject.DamProjectData.WaterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder,
-                                                                                                 dataSourceContainer,
-                                                                                                 dikeList, DamProjectType.Calamity, null);
-                damProject.AssignGeometry2DMapnameIfNotAssigned(Path.Combine(damImportFolder,
-                                                                             dataSourceContainer.MapSoilProfile2D));
+            dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
+            string damImportFolder = Path.GetDirectoryName(definitionFilename);
+            IList<string> dikeList = WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer,
+                                                                          DamProjectType.Calamity, out _).ToList();
+            damProject.DamProjectData.WaterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder,
+                                                                                             dataSourceContainer,
+                                                                                             dikeList, DamProjectType.Calamity, null, out List<LogMessage> _);
+            damProject.AssignGeometry2DMapnameIfNotAssigned(Path.Combine(damImportFolder, dataSourceContainer.MapSoilProfile2D));
 
-                // Save the data
-                damProject.SaveXMLProject(projectFilename, damProject);
+            // Save the data
+            damProject.SaveXMLProject(projectFilename, damProject);
 
-                // Check Dike
-                Assert.AreEqual(1, damProject.DamProjectData.WaterBoard.Dikes.Count);
-                Dike dike = damProject.DamProjectData.WaterBoard.Dikes[0];
+            // Check Dike
+            Assert.AreEqual(1, damProject.DamProjectData.WaterBoard.Dikes.Count);
+            Dike dike = damProject.DamProjectData.WaterBoard.Dikes[0];
 
-                //Check locations
-                Assert.AreEqual(17, dike.Locations.Count);
-            }
+            //Check locations
+            Assert.AreEqual(17, dike.Locations.Count);
         }
+    }
 
-        [Test]
-        [Category("Slow")]
-        public void ImportWaterBoardOnlyWithoutPl3AndPl4CsvFiles()
-        {
-            const string definitionFilename = @".\TestData\CSVData\DataWithoutPl3AndPl4\Import.defx";
+    [Test]
+    [Category("Slow")]
+    public void ImportWaterBoardOnlyWithoutPl3AndPl4CsvFiles()
+    {
+        const string definitionFilename = @".\TestData\CSVData\DataWithoutPl3AndPl4\Import.defx";
 
-            dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
-            string damImportFolder = Path.GetDirectoryName(definitionFilename);
-            IList<string> dikeList =
-                WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, DamProjectType.Calamity,
-                                                     out _).ToList();
-            using (WaterBoard waterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, dataSourceContainer,
-                                                                                     dikeList, DamProjectType.Calamity, null))
-            {
-                //WaterBoard waterBoard = WaterBoardImporter.ImportAllData(damImportFolder, dataSourceContainer, null);
+        dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
+        string damImportFolder = Path.GetDirectoryName(definitionFilename);
+        IList<string> dikeList = WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, 
+                                                                      DamProjectType.Calamity, out _).ToList();
+        using WaterBoard waterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, 
+                                                                                dataSourceContainer, dikeList, 
+                                                                                DamProjectType.Calamity, null, out List<LogMessage> _);
 
-                // Check Dike
-                Assert.AreEqual(1, waterBoard.Dikes.Count);
-                Dike dike = waterBoard.Dikes[0];
+        // Check Dike
+        Assert.AreEqual(1, waterBoard.Dikes.Count);
+        Dike dike = waterBoard.Dikes[0];
 
-                //Check locations
-                Assert.AreEqual(2, dike.Locations.Count);
-            }
-        }
+        //Check locations
+        Assert.AreEqual(2, dike.Locations.Count);
+    }
 
-        [Test]
-        [Category("Slow")]
-        public void ImportWaterBoardOnlyCsvFiles1DRelativeSoilProfiles()
-        {
-            const double cTolerance = 0.0001;
-            const string definitionFilename = @".\TestData\CSVData\Full1DProject\Import relative soilprofiles.defx";
+    [Test]
+    [Category("Slow")]
+    public void ImportWaterBoardOnlyCsvFiles1DRelativeSoilProfiles()
+    {
+        const double cTolerance = 0.0001;
+        const string definitionFilename = @".\TestData\CSVData\Full1DProject\Import relative soilprofiles.defx";
 
-            dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
-            string damImportFolder = Path.GetDirectoryName(definitionFilename);
-            IList<string> dikeList =
-                WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, DamProjectType.Calamity,
-                                                     out _).ToList();
-            using (WaterBoard waterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, dataSourceContainer,
-                                                                                     dikeList, DamProjectType.Calamity, null))
-            using (WaterBoard referenceWaterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder,
-                                                                                              dataSourceContainer,
-                                                                                              dikeList, DamProjectType.Calamity, null))
+        dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
+        string damImportFolder = Path.GetDirectoryName(definitionFilename);
+        IList<string> dikeList = WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, DamProjectType.Calamity,
+                                                                      out _).ToList();
+        using (WaterBoard waterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, dataSourceContainer,
+                                                                                 dikeList, DamProjectType.Calamity, null, out List<LogMessage> _))
+        using (WaterBoard referenceWaterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder,
+                                                                                          dataSourceContainer,
+                                                                                          dikeList, DamProjectType.Calamity, null, out List<LogMessage> _))
+        {
+            // If profiles are defined as relative profiles, new absolute profiles will be generated for each location
+            if (dataSourceContainer.IsImportAsRelativeProfiles)
             {
-                // If profiles are defined as relative profiles, new absolute profiles will be generated for each location
-                if (dataSourceContainer.IsImportAsRelativeProfiles)
-                {
-                    WaterBoardPostProcessRelativeProfiles.CreateAbsoluteProfiles(waterBoard,
-                                                                                 dataSourceContainer.SoilProfileCharacteristicPointReference);
-                }
+                WaterBoardPostProcessRelativeProfiles.CreateAbsoluteProfiles(waterBoard,
+                                                                             dataSourceContainer.SoilProfileCharacteristicPointReference);
+            }
 
-                // Check Dike
-                Assert.AreEqual(1, waterBoard.Dikes.Count);
-                Dike dike = waterBoard.Dikes[0];
+            // Check Dike
+            Assert.AreEqual(1, waterBoard.Dikes.Count);
+            Dike dike = waterBoard.Dikes[0];
 
-                //Check locations
-                Assert.AreEqual(2, dike.Locations.Count);
+            //Check locations
+            Assert.AreEqual(2, dike.Locations.Count);
 
-                // Check Soilprofiles
-                // Count is 43: 23 (imported) + 7 (generated for first location) + 13 (generated for second location) 
-                Assert.AreEqual(43, dike.SoilProfiles.Count);
-                SoilProfile1D soilProfile = dike.SoilProfiles.First(x => x.Name.Equals("25_2_1_bz_4"));
-                Assert.AreEqual("kade", soilProfile.Layers[0].Soil.Name);
-                Assert.AreEqual(60.0, soilProfile.TopLevel);
+            // Check Soilprofiles
+            // Count is 43: 23 (imported) + 7 (generated for first location) + 13 (generated for second location) 
+            Assert.AreEqual(43, dike.SoilProfiles.Count);
+            SoilProfile1D soilProfile = dike.SoilProfiles.First(x => x.Name.Equals("25_2_1_bz_4"));
+            Assert.AreEqual("kade", soilProfile.Layers[0].Soil.Name);
+            Assert.AreEqual(60.0, soilProfile.TopLevel);
 
-                // Check if all profiles are made absolute from relative
-                foreach (Location location in waterBoard.Locations)
-                foreach (SoilGeometryProbability soilProfileProbability in location.Segment.SoilProfileProbabilities)
-                {
-                    GeometryPoint dikeToeAtPolder =
-                        location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType
-                                                                                        .DikeToeAtPolder);
-                    Assert.AreEqual(soilProfileProbability.SoilProfile.Layers[1].TopLevel, dikeToeAtPolder.Z, cTolerance);
-                }
+            // Check if all profiles are made absolute from relative
+            foreach (Location location in waterBoard.Locations)
+            foreach (SoilGeometryProbability soilProfileProbability in location.Segment.SoilProfileProbabilities)
+            {
+                GeometryPoint dikeToeAtPolder = location.SurfaceLine2.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType
+                                                                                                                .DikeToeAtPolder);
+                Assert.AreEqual(soilProfileProbability.SoilProfile.Layers[1].TopLevel, dikeToeAtPolder.Z, cTolerance);
+            }
 
-                // Compare reference waterboard to converted waterboard
-                foreach (Location location in waterBoard.Locations)
+            // Compare reference waterboard to converted waterboard
+            foreach (Location location in waterBoard.Locations)
+            {
+                Location referenceLocation = referenceWaterBoard.Locations.Find(l => l.Name.Equals(location.Name));
+                var soilProbabilityIndex = 0;
+                foreach (SoilGeometryProbability referenceSoilProfileProbability in referenceLocation.Segment.SoilProfileProbabilities)
                 {
-                    Location referenceLocation = referenceWaterBoard.Locations.Find(l => l.Name.Equals(location.Name));
-                    var soilProbabilityIndex = 0;
-                    foreach (SoilGeometryProbability referenceSoilProfileProbability in referenceLocation.Segment.SoilProfileProbabilities)
+                    soilProbabilityIndex++;
+                    SoilGeometryProbability soilProfileProbability =
+                        location.Segment.SoilProfileProbabilities.Find(
+                            s => s.SoilProfile.Name.Equals(string.Format("{0}-{1}-{2}",
+                                                                         referenceSoilProfileProbability.SoilProfile.Name, location.Name, soilProbabilityIndex)));
+                    for (var layerIndex = 0;
+                         layerIndex < soilProfileProbability.SoilProfile.LayerCount;
+                         layerIndex++)
                     {
-                        soilProbabilityIndex++;
-                        SoilGeometryProbability soilProfileProbability =
-                            location.Segment.SoilProfileProbabilities.Find(
-                                s => s.SoilProfile.Name.Equals(string.Format("{0}-{1}-{2}",
-                                                                             referenceSoilProfileProbability.SoilProfile.Name, location.Name, soilProbabilityIndex)));
-                        for (var layerIndex = 0;
-                             layerIndex < soilProfileProbability.SoilProfile.LayerCount;
-                             layerIndex++)
+                        // As the moved profile has a new top layer, make sure to compare the proper layers 
+                        if (layerIndex > 0)
                         {
-                            // As the moved profile has a new top layer, make sure to compare the proper layers 
-                            if (layerIndex > 0)
-                            {
-                                Assert.AreEqual(
-                                    referenceSoilProfileProbability.SoilProfile.Layers[layerIndex - 1].Height,
-                                    soilProfileProbability.SoilProfile.Layers[layerIndex].Height, cTolerance,
-                                    string.Format(
-                                        "Location {0} Segment {1} soilProfile {2} Layer {3} ({4}/{5}), Org ({6}/{7})",
-                                        location.Name, location.Segment.Name, soilProfileProbability.SoilProfile.Name,
-                                        soilProfileProbability.SoilProfile.Layers[layerIndex],
-                                        soilProfileProbability.SoilProfile.Layers[layerIndex].TopLevel,
-                                        soilProfileProbability.SoilProfile.Layers[layerIndex].BottomLevel,
-                                        referenceSoilProfileProbability.SoilProfile.Layers[layerIndex - 1].TopLevel,
-                                        referenceSoilProfileProbability.SoilProfile.Layers[layerIndex - 1]
-                                                                       .BottomLevel));
-                            }
+                            Assert.AreEqual(
+                                referenceSoilProfileProbability.SoilProfile.Layers[layerIndex - 1].Height,
+                                soilProfileProbability.SoilProfile.Layers[layerIndex].Height, cTolerance,
+                                string.Format(
+                                    "Location {0} Segment {1} soilProfile {2} Layer {3} ({4}/{5}), Org ({6}/{7})",
+                                    location.Name, location.Segment.Name, soilProfileProbability.SoilProfile.Name,
+                                    soilProfileProbability.SoilProfile.Layers[layerIndex],
+                                    soilProfileProbability.SoilProfile.Layers[layerIndex].TopLevel,
+                                    soilProfileProbability.SoilProfile.Layers[layerIndex].BottomLevel,
+                                    referenceSoilProfileProbability.SoilProfile.Layers[layerIndex - 1].TopLevel,
+                                    referenceSoilProfileProbability.SoilProfile.Layers[layerIndex - 1]
+                                                                   .BottomLevel));
                         }
                     }
                 }
             }
         }
+    }
 
-        [Test]
-        [Category("Slow")]
-        public void IsZoneDataReadCorrectlyFromCsvFiles()
+    [Test]
+    [Category("Slow")]
+    public void IsZoneDataReadCorrectlyFromCsvFiles()
+    {
+        const double cTolerance = 0.0001;
+        const string definitionFilename = @".\TestData\CSVData\ProjectZoneType\Import.defx";
+
+        dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
+        string damImportFolder = Path.GetDirectoryName(definitionFilename);
+        IList<string> dikeList =
+            WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, DamProjectType.Calamity,
+                                                 out _).ToList();
+        using (WaterBoard waterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, dataSourceContainer,
+                                                                                 dikeList, DamProjectType.Calamity, null, out List<LogMessage> _))
         {
-            const double cTolerance = 0.0001;
-            const string definitionFilename = @".\TestData\CSVData\ProjectZoneType\Import.defx";
+            // Check Dike
+            Assert.AreEqual(1, waterBoard.Dikes.Count);
+            Dike dike = waterBoard.Dikes[0];
 
-            dataSourceContainer = DataSourceContainer.Deserialize(definitionFilename);
-            string damImportFolder = Path.GetDirectoryName(definitionFilename);
-            IList<string> dikeList =
-                WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, DamProjectType.Calamity,
-                                                     out _).ToList();
-            using (WaterBoard waterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, dataSourceContainer,
-                                                                                     dikeList, DamProjectType.Calamity, null))
-            {
-                // Check Dike
-                Assert.AreEqual(1, waterBoard.Dikes.Count);
-                Dike dike = waterBoard.Dikes[0];
-
-                //Check locations
-                Assert.AreEqual(2, dike.Locations.Count);
-                Assert.AreEqual(MStabZonesType.NoZones, dike.Locations[0].StabilityZoneType);
-                Assert.AreEqual(0.5, dike.Locations[0].ForbiddenZoneFactor, cTolerance);
-                Assert.AreEqual(MStabZonesType.ForbiddenZone, dike.Locations[1].StabilityZoneType);
-                Assert.AreEqual(0.9, dike.Locations[1].ForbiddenZoneFactor, cTolerance);
-            }
+            //Check locations
+            Assert.AreEqual(2, dike.Locations.Count);
+            Assert.AreEqual(MStabZonesType.NoZones, dike.Locations[0].StabilityZoneType);
+            Assert.AreEqual(0.5, dike.Locations[0].ForbiddenZoneFactor, cTolerance);
+            Assert.AreEqual(MStabZonesType.ForbiddenZone, dike.Locations[1].StabilityZoneType);
+            Assert.AreEqual(0.9, dike.Locations[1].ForbiddenZoneFactor, cTolerance);
         }
+    }
 
-        public void SetupForCsvFilesImport()
+    public void SetupForCsvFilesImport()
+    {
+        srcDataSources = new List<DataSource>
         {
-            srcDataSources = new List<DataSource>
+            new()
             {
-                new DataSource
-                {
-                    DataSourceType = DataSourceType.CsvFiles,
-                    DataLocation = DirectoryWithCsvFiles
-                }
-            };
-            dataPluginImporter = new DataPluginImporter();
-            dataPluginImporter.SetDataSources("", srcDataSources);
-            dataSourceContainer = new DataSourceContainer
-            {
-                DataSourceList = srcDataSources
-            };
-        }
+                DataSourceType = DataSourceType.CsvFiles,
+                DataLocation = DirectoryWithCsvFiles
+            }
+        };
+        dataPluginImporter = new DataPluginImporter();
+        dataPluginImporter.SetDataSources("", srcDataSources);
+        dataSourceContainer = new DataSourceContainer
+        {
+            DataSourceList = srcDataSources
+        };
     }
 }
\ No newline at end of file
Index: DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/WaterBoardImporter.cs
===================================================================
diff -u -r4169 -r4174
--- DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/WaterBoardImporter.cs	(.../WaterBoardImporter.cs)	(revision 4169)
+++ DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.Data/WaterBoardImporter.cs	(.../WaterBoardImporter.cs)	(revision 4174)
@@ -126,21 +126,6 @@
     }
 
     /// <summary>
-    /// Imports all data.
-    /// </summary>
-    /// <param name="dataFolder">The data folder.</param>
-    /// <param name="dataSourceContainer">The data source container.</param>
-    /// <param name="damProjectType">Type of the dam project.</param>
-    /// <param name="progress">The progress.</param>
-    /// <returns></returns>
-    public static WaterBoard ImportAllData(string dataFolder,
-                                           DataSourceContainer dataSourceContainer, DamProjectType damProjectType, ProgressDelegate progress)
-    {
-        List<LogMessage> dummy;
-        return ImportAllData(dataFolder, dataSourceContainer, damProjectType, progress, out dummy);
-    }
-
-    /// <summary>
     /// Imports the data for dike rings.
     /// </summary>
     /// <param name="damProjectFolder">The dam project folder.</param>
@@ -149,25 +134,6 @@
     /// <param name="dikeRingIds">The dike ring ids.</param>
     /// <param name="damProjectType">Type of the dam project.</param>
     /// <param name="progress">The progress.</param>
-    /// <returns></returns>
-    public static WaterBoard ImportDataForDikeRings(string damProjectFolder, string dataFolder,
-                                                    DataSourceContainer dataSourceContainer, IEnumerable<string> dikeRingIds,
-                                                    DamProjectType damProjectType, ProgressDelegate progress)
-    {
-        List<LogMessage> dummy;
-        return ImportDataForDikeRings(damProjectFolder, dataFolder, dataSourceContainer,
-                                      dikeRingIds, damProjectType, progress, out dummy);
-    }
-
-    /// <summary>
-    /// Imports the data for dike rings.
-    /// </summary>
-    /// <param name="damProjectFolder">The dam project folder.</param>
-    /// <param name="dataFolder">The data folder.</param>
-    /// <param name="dataSourceContainer">The data source container.</param>
-    /// <param name="dikeRingIds">The dike ring ids.</param>
-    /// <param name="damProjectType">Type of the dam project.</param>
-    /// <param name="progress">The progress.</param>
     /// <param name="logMessages">The log messages.</param>
     /// <returns></returns>
     public static WaterBoard ImportDataForDikeRings(string damProjectFolder, string dataFolder,
@@ -332,16 +298,6 @@
     }
 
     /// <summary>
-    /// Creates the soil base for dike.
-    /// </summary>
-    /// <param name="dike">The dike.</param>
-    private void CreateSoilBaseForDike(Dike dike)
-    {
-        // TODO: soildatabase should be created. Now we make a direct link
-        // must be based on dike.SoilDatabaseName
-    }
-
-    /// <summary>
     /// Imports the soils.
     /// </summary>
     /// <param name="dikeRingID">The dike ring identifier.</param>
@@ -447,8 +403,6 @@
 
         ImportCsvLogMessages.AddRange(dike.MakeDataConsistent());
 
-        CreateSoilBaseForDike(dike);
-
         DisposeImportedItem(dikeRingId);
 
         return dike;
Index: DamClients/DamUI/trunk/src/Dam/Deltares.Dam.Tests/Sensors/SensorImportFromExcelSheetTest.cs
===================================================================
diff -u -r4070 -r4174
--- DamClients/DamUI/trunk/src/Dam/Deltares.Dam.Tests/Sensors/SensorImportFromExcelSheetTest.cs	(.../SensorImportFromExcelSheetTest.cs)	(revision 4070)
+++ DamClients/DamUI/trunk/src/Dam/Deltares.Dam.Tests/Sensors/SensorImportFromExcelSheetTest.cs	(.../SensorImportFromExcelSheetTest.cs)	(revision 4174)
@@ -71,7 +71,7 @@
                 List<LogMessage> importLogMessages;
                 IList<string> dikeList = WaterBoardImporter.ImportDikeRingIds(damImportFolder, dataSourceContainer, DamProjectType.Calamity, out importLogMessages).ToList();
                 damProject.DamProjectData.WaterBoard = WaterBoardImporter.ImportDataForDikeRings("", damImportFolder, dataSourceContainer,
-                                                                                                 dikeList, DamProjectType.Calamity, null);
+                                                                                                 dikeList, DamProjectType.Calamity, null, out List<LogMessage> _);
                 damProject.AssignGeometry2DMapnameIfNotAssigned(Path.Combine(damImportFolder, dataSourceContainer.MapSoilProfile2D));
 
                 Dike dike = damProject.DamProjectData.WaterBoard.Dikes.First();