Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SoilProfile1D.cs
===================================================================
diff -u -r4000 -r4052
--- DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SoilProfile1D.cs	(.../SoilProfile1D.cs)	(revision 4000)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SoilProfile1D.cs	(.../SoilProfile1D.cs)	(revision 4052)
@@ -27,655 +27,654 @@
 using Deltares.DamEngine.Data.Standard.Language;
 using Deltares.DamEngine.Data.Standard.Validation;
 
-namespace Deltares.DamEngine.Data.Geotechnics
+namespace Deltares.DamEngine.Data.Geotechnics;
+
+/// <summary>
+/// Interface for providing the 1D Soil Profile
+/// </summary>
+public interface ISoilProfileProvider
 {
     /// <summary>
-    /// Interface for providing the 1D Soil Profile
+    /// Gets the soil profile.
     /// </summary>
-    public interface ISoilProfileProvider
+    /// <value>
+    /// The soil profile.
+    /// </value>
+    SoilProfile1D SoilProfile { get; }
+}
+
+/// <summary>
+/// 1D Soil Profile Object
+/// </summary>
+public class SoilProfile1D : SoilProfile
+{
+    private const double DefaultBottomLayerHeight = 20.0;
+
+    private readonly DelegatedList<SoilLayer1D> layers = new DelegatedList<SoilLayer1D>();
+    private double bottomLevel = double.NaN;
+
+    /// <summary>
+    /// Default constructor
+    /// </summary>
+    public SoilProfile1D()
     {
-        /// <summary>
-        /// Gets the soil profile.
-        /// </summary>
-        /// <value>
-        /// The soil profile.
-        /// </value>
-        SoilProfile1D SoilProfile { get; }
+        base.Name = LocalizationManager.GetTranslatedText(this, "DefaultNameSoilProfile1D");
+        layers.AddMethod = AddLayer;
     }
 
     /// <summary>
-    /// 1D Soil Profile Object
+    /// Constructor to construct simple soilprofile
     /// </summary>
-    public class SoilProfile1D : SoilProfile
+    /// <param name="topLevel"></param>
+    /// <param name="bottomLevel"></param>
+    /// <param name="soil"></param>
+    public SoilProfile1D(double topLevel, double bottomLevel, Soil soil)
+        : this()
     {
-        private const double DefaultBottomLayerHeight = 20.0;
+        this.bottomLevel = bottomLevel;
+        layers.Add(new SoilLayer1D(soil, topLevel));
+    }
 
-        private readonly DelegatedList<SoilLayer1D> layers = new DelegatedList<SoilLayer1D>();
-        private double bottomLevel = double.NaN;
-
-        /// <summary>
-        /// Default constructor
-        /// </summary>
-        public SoilProfile1D()
+    /// <summary>
+    /// Gets the soil layer collection for this profile
+    /// </summary>
+    public IList<SoilLayer1D> Layers
+    {
+        get
         {
-            base.Name = LocalizationManager.GetTranslatedText(this, "DefaultNameSoilProfile1D");
-            layers.AddMethod = AddLayer;
+            return layers;
         }
+    }
 
-        /// <summary>
-        /// Constructor to construct simple soilprofile
-        /// </summary>
-        /// <param name="topLevel"></param>
-        /// <param name="bottomLevel"></param>
-        /// <param name="soil"></param>
-        public SoilProfile1D(double topLevel, double bottomLevel, Soil soil)
-            : this()
+    /// <summary>
+    /// Gets the number of layers.
+    /// </summary>
+    /// <value>
+    /// The layer count.
+    /// </value>
+    public int LayerCount
+    {
+        get
         {
-            this.bottomLevel = bottomLevel;
-            layers.Add(new SoilLayer1D(soil, topLevel));
+            return layers.Count;
         }
+    }
 
-        /// <summary>
-        /// Gets the soil layer collection for this profile
-        /// </summary>
-        public IList<SoilLayer1D> Layers
+    /// <summary>
+    /// Gets or sets the bottom level.
+    /// </summary>
+    /// <value>
+    /// The bottom level.
+    /// </value>
+    public double BottomLevel
+    {
+        get
         {
-            get
+            if (double.IsNaN(bottomLevel) && layers.Count > 0)
             {
-                return layers;
+                bottomLevel = Layers.Last().TopLevel - DefaultBottomLayerHeight;
             }
-        }
 
-        /// <summary>
-        /// Gets the number of layers.
-        /// </summary>
-        /// <value>
-        /// The layer count.
-        /// </value>
-        public int LayerCount
-        {
-            get
-            {
-                return layers.Count;
-            }
+            return bottomLevel;
         }
-
-        /// <summary>
-        /// Gets or sets the bottom level.
-        /// </summary>
-        /// <value>
-        /// The bottom level.
-        /// </value>
-        public double BottomLevel
+        set
         {
-            get
+            if (double.IsNaN(bottomLevel) || (Math.Abs(value - bottomLevel) > GeometryConstants.Accuracy))
             {
-                if (double.IsNaN(bottomLevel) && layers.Count > 0)
-                {
-                    bottomLevel = Layers.Last().TopLevel - DefaultBottomLayerHeight;
-                }
-
-                return bottomLevel;
+                bottomLevel = value;
             }
-            set
-            {
-                if (double.IsNaN(bottomLevel) || (Math.Abs(value - bottomLevel) > GeometryConstants.Accuracy))
-                {
-                    bottomLevel = value;
-                }
-            }
         }
+    }
 
-        /// <summary>
-        /// Gets or sets the top level.
-        /// </summary>
-        /// <value>
-        /// The top level.
-        /// </value>
-        public double TopLevel
+    /// <summary>
+    /// Gets or sets the top level.
+    /// </summary>
+    /// <value>
+    /// The top level.
+    /// </value>
+    public double TopLevel
+    {
+        get
         {
-            get
-            {
-                return layers.Any() ? layers.First().TopLevel : BottomLevel;
-            }
+            return layers.Any() ? layers.First().TopLevel : BottomLevel;
         }
+    }
 
-        /// <summary>
-        /// Gets the infiltration layer.
-        /// </summary>
-        /// <value>
-        /// The infiltration layer.
-        /// </value>
-        public SoilLayer1D InfiltrationLayer { get; private set; }
+    /// <summary>
+    /// Gets the infiltration layer.
+    /// </summary>
+    /// <value>
+    /// The infiltration layer.
+    /// </value>
+    public SoilLayer1D InfiltrationLayer { get; private set; }
 
-        /// <summary>
-        /// Gets the toppest aquifer layer of the deepest cluster of aquifers 
-        /// </summary>
-        /// <value>
-        /// The toppest aquifer layer in the deepest cluster of aquifers
-        /// </value>
-        public SoilLayer1D BottomAquiferLayer
+    /// <summary>
+    /// Gets the toppest aquifer layer of the deepest cluster of aquifers 
+    /// </summary>
+    /// <value>
+    /// The toppest aquifer layer in the deepest cluster of aquifers
+    /// </value>
+    public SoilLayer1D BottomAquiferLayer
+    {
+        get
         {
-            get
+            IList<SoilLayer1D> sortedLayers = Layers.OrderBy(l => l.TopLevel).ToList();
+            SoilLayer1D aquiferLayer = null;
+            int aquiferIndex = -1;
+
+            // Search deepest aquifer layer
+            for (var layerIndex = 0; layerIndex < sortedLayers.Count; layerIndex++)
             {
-                IList<SoilLayer1D> sortedLayers = Layers.OrderBy(l => l.TopLevel).ToList();
-                SoilLayer1D aquiferLayer = null;
-                int aquiferIndex = -1;
+                SoilLayer1D layer = sortedLayers[layerIndex];
+                if (IsAquiferLayer(layer))
+                {
+                    aquiferIndex = layerIndex;
+                    aquiferLayer = layer;
+                    break;
+                }
+            }
 
-                // Search deepest aquifer layer
-                for (var layerIndex = 0; layerIndex < sortedLayers.Count; layerIndex++)
+            // aquifer may consists of more then 1 connected (aquifer) layers 
+            // Search all layers above the first found aquifer to find top aquifer layer
+            if (aquiferIndex >= 0)
+            {
+                for (int layerIndex = aquiferIndex + 1; layerIndex < sortedLayers.Count; layerIndex++)
                 {
                     SoilLayer1D layer = sortedLayers[layerIndex];
                     if (IsAquiferLayer(layer))
                     {
-                        aquiferIndex = layerIndex;
                         aquiferLayer = layer;
-                        break;
                     }
-                }
-
-                // aquifer may consists of more then 1 connected (aquifer) layers 
-                // Search all layers above the first found aquifer to find top aquifer layer
-                if (aquiferIndex >= 0)
-                {
-                    for (int layerIndex = aquiferIndex + 1; layerIndex < sortedLayers.Count; layerIndex++)
+                    else
                     {
-                        SoilLayer1D layer = sortedLayers[layerIndex];
-                        if (IsAquiferLayer(layer))
-                        {
-                            aquiferLayer = layer;
-                        }
-                        else
-                        {
-                            break;
-                        }
+                        break;
                     }
                 }
-
-                return aquiferLayer;
             }
+
+            return aquiferLayer;
         }
+    }
 
-        /// <summary>
-        /// Gets the highest aquifer in the highest cluster of in-between aquifers.
-        /// The top layer of a cluster of in-between aquifer can't be the highest layer of the soil profile.
-        /// </summary>
-        /// <value>
-        /// The highest aquifer in the highest in-between cluster of aquifers
-        /// </value>
-        public SoilLayer1D InBetweenAquiferLayer
+    /// <summary>
+    /// Gets the highest aquifer in the highest cluster of in-between aquifers.
+    /// The top layer of a cluster of in-between aquifer can't be the highest layer of the soil profile.
+    /// </summary>
+    /// <value>
+    /// The highest aquifer in the highest in-between cluster of aquifers
+    /// </value>
+    public SoilLayer1D InBetweenAquiferLayer
+    {
+        get
         {
-            get
-            {
-                IList<SoilLayer1D> sortedLayers = Layers.OrderByDescending(l => l.TopLevel).ToList();
-                SoilLayer1D aquiferLayer = null;
+            IList<SoilLayer1D> sortedLayers = Layers.OrderByDescending(l => l.TopLevel).ToList();
+            SoilLayer1D aquiferLayer = null;
 
-                // Search the highest aquifer layer with an aquitard above
-                for (var layerIndex = 1; layerIndex < sortedLayers.Count; layerIndex++)
+            // Search the highest aquifer layer with an aquitard above
+            for (var layerIndex = 1; layerIndex < sortedLayers.Count; layerIndex++)
+            {
+                SoilLayer1D previousLayer = sortedLayers[layerIndex - 1];
+                SoilLayer1D layer = sortedLayers[layerIndex];
+                if (IsAquiferLayer(layer) && !IsAquiferLayer(previousLayer))
                 {
-                    SoilLayer1D previousLayer = sortedLayers[layerIndex - 1];
-                    SoilLayer1D layer = sortedLayers[layerIndex];
-                    if (IsAquiferLayer(layer) && !IsAquiferLayer(previousLayer))
-                    {
-                        aquiferLayer = layer;
-                        break;
-                    }
+                    aquiferLayer = layer;
+                    break;
                 }
-
-                // If highest aquifer layer is bottom aquifer layer, there is no in between aquiferlayer
-                if (aquiferLayer == BottomAquiferLayer)
-                {
-                    aquiferLayer = null;
-                }
-
-                return aquiferLayer;
             }
-        }
 
-        /// <summary>
-        /// Assigns the specified profile.
-        /// </summary>
-        /// <param name="profile">The profile.</param>
-        public void Assign(SoilProfile1D profile)
-        {
-            Assign((SoilProfile) profile);
-            Layers.Clear();
-            foreach (SoilLayer1D layer in profile.Layers)
+            // If highest aquifer layer is bottom aquifer layer, there is no in between aquiferlayer
+            if (aquiferLayer == BottomAquiferLayer)
             {
-                Layers.Add((SoilLayer1D) layer.Clone());
+                aquiferLayer = null;
             }
 
-            BottomLevel = profile.BottomLevel;
+            return aquiferLayer;
         }
+    }
 
-        /// <summary>
-        /// Creates a new object that is a copy of the current instance.
-        /// </summary>
-        /// <returns>
-        /// A new object that is a copy of this instance.
-        /// </returns>
-        public object Clone()
+    /// <summary>
+    /// Assigns the specified profile.
+    /// </summary>
+    /// <param name="profile">The profile.</param>
+    public void Assign(SoilProfile1D profile)
+    {
+        Assign((SoilProfile) profile);
+        Layers.Clear();
+        foreach (SoilLayer1D layer in profile.Layers)
         {
-            var cloneSoilProfile = new SoilProfile1D();
-            cloneSoilProfile.Assign(this);
-            return cloneSoilProfile;
+            Layers.Add((SoilLayer1D) layer.Clone());
         }
 
-        /// <summary>
-        /// Gets layer with the specified name.
-        /// </summary>
-        /// <param name="name">The name.</param>
-        /// <returns></returns>
-        public SoilLayer1D GetLayerWithName(string name)
+        BottomLevel = profile.BottomLevel;
+    }
+
+    /// <summary>
+    /// Creates a new object that is a copy of the current instance.
+    /// </summary>
+    /// <returns>
+    /// A new object that is a copy of this instance.
+    /// </returns>
+    public object Clone()
+    {
+        var cloneSoilProfile = new SoilProfile1D();
+        cloneSoilProfile.Assign(this);
+        return cloneSoilProfile;
+    }
+
+    /// <summary>
+    /// Gets layer with the specified name.
+    /// </summary>
+    /// <param name="name">The name.</param>
+    /// <returns></returns>
+    public SoilLayer1D GetLayerWithName(string name)
+    {
+        return layers.FirstOrDefault(layer =>
         {
-            return layers.FirstOrDefault(layer =>
+            if (layer.Name != null)
             {
-                if (layer.Name != null)
-                {
-                    return layer.Name.Equals(name);
-                }
+                return layer.Name.Equals(name);
+            }
 
-                return false;
-            });
-        }
+            return false;
+        });
+    }
 
-        /// <summary>
-        /// Checks weather all layer names are unique.
-        /// </summary>
-        /// <value>
-        ///   <c>true</c> if all layer names are unique; otherwise, <c>false</c>.
-        /// </value>
-        public bool AreAllLayerNamesUnique()
+    /// <summary>
+    /// Checks weather all layer names are unique.
+    /// </summary>
+    /// <value>
+    ///   <c>true</c> if all layer names are unique; otherwise, <c>false</c>.
+    /// </value>
+    public bool AreAllLayerNamesUnique()
+    {
+        int layersSize = Layers.Count;
+        for (var i = 0; i < layersSize; ++i)
         {
-            int layersSize = Layers.Count;
-            for (var i = 0; i < layersSize; ++i)
+            string id1 = layers[i].Name;
+            if (id1 == null)
             {
-                string id1 = layers[i].Name;
-                if (id1 == null)
+                return false;
+            }
+
+            for (int j = i + 1; j < layersSize; ++j)
+            {
+                if (id1.Equals(Layers[j].Name))
                 {
                     return false;
                 }
-
-                for (int j = i + 1; j < layersSize; ++j)
-                {
-                    if (id1.Equals(Layers[j].Name))
-                    {
-                        return false;
-                    }
-                }
             }
-
-            return true;
         }
 
-        /// <summary>
-        /// Gets the first unused unique layer name.
-        /// </summary>
-        /// <returns>new unique layer name</returns>
-        public string GetNewUniqueLayerName()
+        return true;
+    }
+
+    /// <summary>
+    /// Gets the first unused unique layer name.
+    /// </summary>
+    /// <returns>new unique layer name</returns>
+    public string GetNewUniqueLayerName()
+    {
+        string newName;
+        var i = 0;
+        SoilLayer1D soilLayer;
+        do
         {
-            string newName;
-            var i = 0;
-            SoilLayer1D soilLayer;
-            do
-            {
-                newName = "L" + i++;
-                soilLayer = GetLayerWithName(newName);
-            } while (soilLayer != null);
+            newName = "L" + i++;
+            soilLayer = GetLayerWithName(newName);
+        } while (soilLayer != null);
 
-            return newName;
-        }
+        return newName;
+    }
 
-        /// <summary>
-        /// Gets (calculates) the height for a given layer in the profile
-        /// </summary>
-        /// <param name="soilLayer">The layer to process</param>
-        /// <returns>The height</returns>
-        public double GetLayerHeight(SoilLayer1D soilLayer)
-        {
-            int layerIndex = layers.IndexOf(soilLayer);
-            SoilLayer1D soilLayerBelow = (layerIndex < layers.Count - 1) ? layers[layerIndex + 1] : null;
-            double levelBelow = (soilLayerBelow != null) ? soilLayerBelow.TopLevel : BottomLevel;
-            return soilLayer.TopLevel - levelBelow;
-        }
+    /// <summary>
+    /// Gets (calculates) the height for a given layer in the profile
+    /// </summary>
+    /// <param name="soilLayer">The layer to process</param>
+    /// <returns>The height</returns>
+    public double GetLayerHeight(SoilLayer1D soilLayer)
+    {
+        int layerIndex = layers.IndexOf(soilLayer);
+        SoilLayer1D soilLayerBelow = (layerIndex < layers.Count - 1) ? layers[layerIndex + 1] : null;
+        double levelBelow = (soilLayerBelow != null) ? soilLayerBelow.TopLevel : BottomLevel;
+        return soilLayer.TopLevel - levelBelow;
+    }
 
-        /// <summary>
-        /// Make sure the last layer has a height
-        /// </summary>
-        public void EnsureLastLayerHasHeight()
+    /// <summary>
+    /// Make sure the last layer has a height
+    /// </summary>
+    public void EnsureLastLayerHasHeight()
+    {
+        SoilLayer1D bottomLayer = Layers.Last();
+        if (bottomLayer.Height.IsZero())
         {
-            SoilLayer1D bottomLayer = Layers.Last();
-            if (bottomLayer.Height.IsZero())
-            {
-                BottomLevel -= DefaultBottomLayerHeight;
-            }
+            BottomLevel -= DefaultBottomLayerHeight;
         }
+    }
 
-        /// <summary>
-        /// Determines the infiltration layer.
-        /// </summary>
-        /// <param name="penetrationLength">Length of the penetration.</param>
-        public void DetermineInfiltrationLayer(double penetrationLength)
-        {
-            InfiltrationLayer = null;
+    /// <summary>
+    /// Determines the infiltration layer.
+    /// </summary>
+    /// <param name="penetrationLength">Length of the penetration.</param>
+    public void DetermineInfiltrationLayer(double penetrationLength)
+    {
+        InfiltrationLayer = null;
 
-            SoilLayer1D bottomAquiferLayer = BottomAquiferLayer;
+        SoilLayer1D bottomAquiferLayer = BottomAquiferLayer;
 
-            if (penetrationLength > 0 && bottomAquiferLayer != null)
-            {
-                SoilLayer1D inBetweenAquiferLayer = InBetweenAquiferLayer;
+        if (penetrationLength > 0 && bottomAquiferLayer != null)
+        {
+            SoilLayer1D inBetweenAquiferLayer = InBetweenAquiferLayer;
 
-                double aquiferBottom = inBetweenAquiferLayer == null ? Double.PositiveInfinity : inBetweenAquiferLayer.BottomLevel;
+            double aquiferBottom = inBetweenAquiferLayer == null ? Double.PositiveInfinity : inBetweenAquiferLayer.BottomLevel;
 
-                IList<SoilLayer1D> infiltrationLayers =
-                    layers.Where(l => l.TopLevel <= aquiferBottom && l.TopLevel > bottomAquiferLayer.TopLevel)
-                          .ToList();
+            IList<SoilLayer1D> infiltrationLayers =
+                layers.Where(l => l.TopLevel <= aquiferBottom && l.TopLevel > bottomAquiferLayer.TopLevel)
+                      .ToList();
 
-                if (infiltrationLayers.Count > 0)
-                {
-                    double separationLevel = bottomAquiferLayer.TopLevel + penetrationLength;
+            if (infiltrationLayers.Count > 0)
+            {
+                double separationLevel = bottomAquiferLayer.TopLevel + penetrationLength;
 
-                    if (separationLevel <= infiltrationLayers.First().TopLevel)
-                    {
-                        InfiltrationLayer = layers.Last(l => l.TopLevel >= separationLevel);
-                    }
+                if (separationLevel <= infiltrationLayers.First().TopLevel)
+                {
+                    InfiltrationLayer = layers.Last(l => l.TopLevel >= separationLevel);
                 }
             }
         }
+    }
 
-        /// <summary>
-        /// Validates this instance (using validator mechanism).
-        /// </summary>
-        /// <returns></returns>
-        [Validate]
-        public ValidationResult[] Validate()
-        {
-            SoilLayer1D erroneousLayer;
+    /// <summary>
+    /// Validates this instance (using validator mechanism).
+    /// </summary>
+    /// <returns></returns>
+    [Validate]
+    public ValidationResult[] Validate()
+    {
+        SoilLayer1D erroneousLayer;
 
-            if (LayerCount == 0)
+        if (LayerCount == 0)
+        {
+            string error = String.Format(LocalizationManager.GetTranslatedText(this, "SoilProfileWithoutLayers"), Name);
+            return new[]
             {
-                string error = String.Format(LocalizationManager.GetTranslatedText(this, "SoilProfileWithoutLayers"), Name);
-                return new[]
-                {
-                    new ValidationResult(ValidationResultType.Error,
-                                         error, "", this)
-                };
-            }
+                new ValidationResult(ValidationResultType.Error,
+                                     error, "", this)
+            };
+        }
 
-            if (!IsStrictlyDescending(out erroneousLayer))
+        if (!IsStrictlyDescending(out erroneousLayer))
+        {
+            string error = String.Format(LocalizationManager.GetTranslatedText(this, "SoilProfileLayersNotDescending"),
+                                         Name, erroneousLayer.Name);
+            return new[]
             {
-                string error = String.Format(LocalizationManager.GetTranslatedText(this, "SoilProfileLayersNotDescending"),
-                                             Name, erroneousLayer.Name);
-                return new[]
-                {
-                    new ValidationResult(ValidationResultType.Error,
-                                         error, "", this)
-                };
-            }
+                new ValidationResult(ValidationResultType.Error,
+                                     error, "", this)
+            };
+        }
 
-            if (HasInvalidThicknessLayers(out erroneousLayer))
+        if (HasInvalidThicknessLayers(out erroneousLayer))
+        {
+            string error = String.Format(LocalizationManager.GetTranslatedText(this, "SoilProfileInvalidLayerThickness"),
+                                         Name, erroneousLayer.Name);
+            return new[]
             {
-                string error = String.Format(LocalizationManager.GetTranslatedText(this, "SoilProfileInvalidLayerThickness"),
-                                             Name, erroneousLayer.Name);
-                return new[]
-                {
-                    new ValidationResult(ValidationResultType.Error,
-                                         error, "", this)
-                };
-            }
-
-            if (HasLayersWithoutSoil(out erroneousLayer))
-            {
-                string error = String.Format(LocalizationManager.GetTranslatedText(this, "SoilProfileLayerWithoutSoil"),
-                                             Name, erroneousLayer.Name);
-                return new[]
-                {
-                    new ValidationResult(ValidationResultType.Error,
-                                         error, "", this)
-                };
-            }
-
-            return new ValidationResult[0];
+                new ValidationResult(ValidationResultType.Error,
+                                     error, "", this)
+            };
         }
 
-        /// <summary>
-        /// Gets the aquifer layers.
-        /// </summary>
-        /// <returns>list of Aquifer layers</returns>
-        public IList<SoilLayer1D> GetAquiferLayers()
+        if (HasLayersWithoutSoil(out erroneousLayer))
         {
-            return Layers.Where(IsAquiferLayer).OrderBy(l => l.TopLevel).ToList();
+            string error = String.Format(LocalizationManager.GetTranslatedText(this, "SoilProfileLayerWithoutSoil"),
+                                         Name, erroneousLayer.Name);
+            return new[]
+            {
+                new ValidationResult(ValidationResultType.Error,
+                                     error, "", this)
+            };
         }
 
-        /// <summary>
-        /// Gets the bottom level.
-        /// </summary>
-        /// <param name="soilLayer">The soil layer.</param>
-        /// <returns>Bottom level</returns>
-        public double GetBottomLevel(SoilLayer1D soilLayer)
-        {
-            SoilLayer1D layerBelow = GetLayerBelow(soilLayer);
+        return new ValidationResult[0];
+    }
 
-            return layerBelow != null ? layerBelow.TopLevel : BottomLevel;
-        }
+    /// <summary>
+    /// Gets the aquifer layers.
+    /// </summary>
+    /// <returns>list of Aquifer layers</returns>
+    public IList<SoilLayer1D> GetAquiferLayers()
+    {
+        return Layers.Where(IsAquiferLayer).OrderBy(l => l.TopLevel).ToList();
+    }
 
-        /// <summary>
-        /// Gets the layer at a given z coordinate.
-        /// </summary>
-        /// <param name="z">The z.</param>
-        /// <returns>the found layer</returns>
-        public SoilLayer1D GetLayerAt(double z)
-        {
-            return Layers.FirstOrDefault(soilLayer => soilLayer.BottomLevel < z && soilLayer.TopLevel >= z);
-        }
+    /// <summary>
+    /// Gets the bottom level.
+    /// </summary>
+    /// <param name="soilLayer">The soil layer.</param>
+    /// <returns>Bottom level</returns>
+    public double GetBottomLevel(SoilLayer1D soilLayer)
+    {
+        SoilLayer1D layerBelow = GetLayerBelow(soilLayer);
 
-        /// <summary>
-        /// Gets the layer below the given layer.
-        /// </summary>
-        /// <param name="layer">The given layer.</param>
-        /// <returns>The found layer</returns>
-        public SoilLayer1D GetLayerBelow(SoilLayer1D layer)
-        {
-            return GetLayerByInsetOffset(layer, 1);
-        }
+        return layerBelow != null ? layerBelow.TopLevel : BottomLevel;
+    }
 
-        /// <summary>
-        /// Gets the layer index of the given layer.
-        /// </summary>
-        /// <param name="layer">The layer.</param>
-        /// <returns>The index, -1 if not found</returns>
-        public int GetLayerIndexAt(SoilLayer1D layer)
-        {
-            if (layer == null)
-            {
-                return -1;
-            }
+    /// <summary>
+    /// Gets the layer at a given z coordinate.
+    /// </summary>
+    /// <param name="z">The z.</param>
+    /// <returns>the found layer</returns>
+    public SoilLayer1D GetLayerAt(double z)
+    {
+        return Layers.FirstOrDefault(soilLayer => soilLayer.BottomLevel < z && soilLayer.TopLevel >= z);
+    }
 
-            for (var i = 0; i < layers.Count; ++i)
-            {
-                if (layers[i] == layer)
-                {
-                    return i;
-                }
-            }
+    /// <summary>
+    /// Gets the layer below the given layer.
+    /// </summary>
+    /// <param name="layer">The given layer.</param>
+    /// <returns>The found layer</returns>
+    public SoilLayer1D GetLayerBelow(SoilLayer1D layer)
+    {
+        return GetLayerByInsetOffset(layer, 1);
+    }
 
+    /// <summary>
+    /// Gets the layer index of the given layer.
+    /// </summary>
+    /// <param name="layer">The layer.</param>
+    /// <returns>The index, -1 if not found</returns>
+    public int GetLayerIndexAt(SoilLayer1D layer)
+    {
+        if (layer == null)
+        {
             return -1;
         }
 
-        /// <summary>
-        /// Gets the top level of highest aquifer.
-        /// </summary>
-        /// <returns></returns>
-        public double GetTopLevelOfHighestAquifer()
+        for (var i = 0; i < layers.Count; ++i)
         {
-            double topLevel;
-            if (InBetweenAquiferLayer != null)
+            if (layers[i] == layer)
             {
-                topLevel = InBetweenAquiferLayer.TopLevel;
+                return i;
             }
-            else
-            {
-                topLevel = BottomAquiferLayer.TopLevel;
-            }
-
-            return topLevel;
         }
 
-        /// <summary>
-        /// Returns a <see cref="System.String" /> that represents this instance.
-        /// </summary>
-        /// <returns>
-        /// A <see cref="System.String" /> that represents this instance.
-        /// </returns>
-        public override string ToString()
+        return -1;
+    }
+
+    /// <summary>
+    /// Gets the top level of highest aquifer.
+    /// </summary>
+    /// <returns></returns>
+    public double GetTopLevelOfHighestAquifer()
+    {
+        double topLevel;
+        if (InBetweenAquiferLayer != null)
         {
-            return Name;
+            topLevel = InBetweenAquiferLayer.TopLevel;
         }
-
-        /// <summary>
-        /// Ares the layers ordered descending.
-        /// </summary>
-        /// <value>
-        ///   <c>true</c> if all layers are ordered descending; otherwise, <c>false</c>.
-        /// </value>
-        private bool AreLayersOrderedByDescending()
+        else
         {
-            // check for empty list
-            if (Layers.Count <= 1)
-            {
-                return true;
-            }
+            topLevel = BottomAquiferLayer.TopLevel;
+        }
 
-            SoilLayer1D current = Layers[0];
-            for (var i = 1; i < Layers.Count; ++i)
-            {
-                SoilLayer1D previous = current;
-                current = Layers[i];
+        return topLevel;
+    }
 
-                if (current.TopLevel > previous.TopLevel)
-                {
-                    return false;
-                }
-            }
+    /// <summary>
+    /// Returns a <see cref="System.String" /> that represents this instance.
+    /// </summary>
+    /// <returns>
+    /// A <see cref="System.String" /> that represents this instance.
+    /// </returns>
+    public override string ToString()
+    {
+        return Name;
+    }
 
+    /// <summary>
+    /// Ares the layers ordered descending.
+    /// </summary>
+    /// <value>
+    ///   <c>true</c> if all layers are ordered descending; otherwise, <c>false</c>.
+    /// </value>
+    private bool AreLayersOrderedByDescending()
+    {
+        // check for empty list
+        if (Layers.Count <= 1)
+        {
             return true;
         }
 
-        /// <summary>
-        /// Determines whether the layers are strictly ordered in descending order.
-        /// If erroneous layer is found, <c>false</c> is returned and the layer 
-        /// is stored in the parameter
-        /// </summary>
-        /// <param name="erroneousLayer">The erroneous layer.</param>
-        /// <returns> <c>true</c> if the layers are strictly ordered in descending order; otherwise, <c>false</c>. </returns>
-        private bool IsStrictlyDescending(out SoilLayer1D erroneousLayer)
+        SoilLayer1D current = Layers[0];
+        for (var i = 1; i < Layers.Count; ++i)
         {
-            for (var i = 1; i < layers.Count; i++)
+            SoilLayer1D previous = current;
+            current = Layers[i];
+
+            if (current.TopLevel > previous.TopLevel)
             {
-                if (layers[i].TopLevel > layers[i - 1].TopLevel)
-                {
-                    erroneousLayer = layers[i];
-                    return false;
-                }
+                return false;
             }
-
-            erroneousLayer = null;
-            return true;
         }
 
-        /// <summary>
-        /// Determines whether there are layers with invalid thickness.
-        /// </summary>
-        /// <param name="erroneousLayer">The erroneous layer.</param>
-        /// <returns>True when a layer with invalid thickness exists</returns>
-        private bool HasInvalidThicknessLayers(out SoilLayer1D erroneousLayer)
+        return true;
+    }
+
+    /// <summary>
+    /// Determines whether the layers are strictly ordered in descending order.
+    /// If erroneous layer is found, <c>false</c> is returned and the layer 
+    /// is stored in the parameter
+    /// </summary>
+    /// <param name="erroneousLayer">The erroneous layer.</param>
+    /// <returns> <c>true</c> if the layers are strictly ordered in descending order; otherwise, <c>false</c>. </returns>
+    private bool IsStrictlyDescending(out SoilLayer1D erroneousLayer)
+    {
+        for (var i = 1; i < layers.Count; i++)
         {
-            for (var i = 1; i < layers.Count; i++)
+            if (layers[i].TopLevel > layers[i - 1].TopLevel)
             {
-                if (layers[i].TopLevel >= layers[i - 1].TopLevel)
-                {
-                    erroneousLayer = layers[i];
-                    return true;
-                }
+                erroneousLayer = layers[i];
+                return false;
             }
+        }
 
-            // check bottom layer using bottom of profile
-            if (layers.Count > 0 && layers[layers.Count - 1].TopLevel <= BottomLevel)
+        erroneousLayer = null;
+        return true;
+    }
+
+    /// <summary>
+    /// Determines whether there are layers with invalid thickness.
+    /// </summary>
+    /// <param name="erroneousLayer">The erroneous layer.</param>
+    /// <returns>True when a layer with invalid thickness exists</returns>
+    private bool HasInvalidThicknessLayers(out SoilLayer1D erroneousLayer)
+    {
+        for (var i = 1; i < layers.Count; i++)
+        {
+            if (layers[i].TopLevel >= layers[i - 1].TopLevel)
             {
-                erroneousLayer = layers[layers.Count - 1];
+                erroneousLayer = layers[i];
                 return true;
             }
-
-            erroneousLayer = null;
-            return false;
         }
 
-        /// <summary>
-        /// Determines whether there are layers without soil.
-        /// </summary>
-        /// <param name="erroneousLayer">The erroneous layer.</param>
-        /// <returns>true when a layer without soil is found</returns>
-        private bool HasLayersWithoutSoil(out SoilLayer1D erroneousLayer)
+        // check bottom layer using bottom of profile
+        if (layers.Count > 0 && layers[layers.Count - 1].TopLevel <= BottomLevel)
         {
-            for (var i = 0; i < layers.Count; i++)
-            {
-                if (layers[i].Soil == null)
-                {
-                    erroneousLayer = layers[i];
-                    return true;
-                }
-            }
-
-            erroneousLayer = null;
-            return false;
+            erroneousLayer = layers[layers.Count - 1];
+            return true;
         }
 
-        /// <summary>
-        /// Gets the layer by inset offset, seen from the given layer plus the given offset.
-        /// </summary>
-        /// <param name="layer">The layer.</param>
-        /// <param name="offset">The offset.</param>
-        /// <returns>the found layer, if no layer found, null</returns>
-        private SoilLayer1D GetLayerByInsetOffset(SoilLayer1D layer, int offset)
+        erroneousLayer = null;
+        return false;
+    }
+
+    /// <summary>
+    /// Determines whether there are layers without soil.
+    /// </summary>
+    /// <param name="erroneousLayer">The erroneous layer.</param>
+    /// <returns>true when a layer without soil is found</returns>
+    private bool HasLayersWithoutSoil(out SoilLayer1D erroneousLayer)
+    {
+        for (var i = 0; i < layers.Count; i++)
         {
-            // only works if list is sorted
-            if (!AreLayersOrderedByDescending())
+            if (layers[i].Soil == null)
             {
-                layers.Sort();
+                erroneousLayer = layers[i];
+                return true;
             }
+        }
 
-            int index = GetLayerIndexAt(layer);
+        erroneousLayer = null;
+        return false;
+    }
 
-            // was the layer found?
-            if (index < 0 || index >= layers.Count)
-            {
-                return null;
-            }
-
-            // is there a layer at the specified offset?
-            int requestedIndex = index + offset;
-            if (requestedIndex < 0 || requestedIndex >= layers.Count)
-            {
-                return null;
-            }
-
-            // return the valid layer
-            return layers[requestedIndex];
+    /// <summary>
+    /// Gets the layer by inset offset, seen from the given layer plus the given offset.
+    /// </summary>
+    /// <param name="layer">The layer.</param>
+    /// <param name="offset">The offset.</param>
+    /// <returns>the found layer, if no layer found, null</returns>
+    private SoilLayer1D GetLayerByInsetOffset(SoilLayer1D layer, int offset)
+    {
+        // only works if list is sorted
+        if (!AreLayersOrderedByDescending())
+        {
+            layers.Sort();
         }
 
-        private void AddLayer(SoilLayer1D layer)
+        int index = GetLayerIndexAt(layer);
+
+        // was the layer found?
+        if (index < 0 || index >= layers.Count)
         {
-            layer.SoilProfile = this;
+            return null;
         }
 
-        /// <summary>
-        /// Determines whether the specified layer is an aquifer layer.
-        /// </summary>
-        /// <param name="layer">The layer.</param>
-        /// <returns><c>true</c> if layer is aquifer layer; otherwise, <c>false</c>.</returns>
-        private static bool IsAquiferLayer(SoilLayer1D layer)
+        // is there a layer at the specified offset?
+        int requestedIndex = index + offset;
+        if (requestedIndex < 0 || requestedIndex >= layers.Count)
         {
-            return (layer.IsAquifer);
+            return null;
         }
+
+        // return the valid layer
+        return layers[requestedIndex];
     }
+
+    private void AddLayer(SoilLayer1D layer)
+    {
+        layer.SoilProfile = this;
+    }
+
+    /// <summary>
+    /// Determines whether the specified layer is an aquifer layer.
+    /// </summary>
+    /// <param name="layer">The layer.</param>
+    /// <returns><c>true</c> if layer is aquifer layer; otherwise, <c>false</c>.</returns>
+    private static bool IsAquiferLayer(SoilLayer1D layer)
+    {
+        return (layer.IsAquifer);
+    }
 }
\ No newline at end of file