Index: dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCalc2Dll.cs
===================================================================
diff -u -r371 -r375
--- dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCalc2Dll.cs	(.../PipingCalc2Dll.cs)	(revision 371)
+++ dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCalc2Dll.cs	(.../PipingCalc2Dll.cs)	(revision 375)
@@ -19,6 +19,9 @@
     public delegate string PC2_Model2GetCalculationMessages(IntPtr CalcHandle);
     public delegate void PC2_Model2DestroyHandle(IntPtr CalcHandle);
 
+    /// <summary>
+    /// Wrapper for MPipingCalc2.dll
+    /// </summary>
     public class PipingCalc2Dll
     {
 
Index: dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingModel2Data.cs
===================================================================
diff -u -r371 -r375
--- dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingModel2Data.cs	(.../PipingModel2Data.cs)	(revision 371)
+++ dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingModel2Data.cs	(.../PipingModel2Data.cs)	(revision 375)
@@ -2,6 +2,9 @@
 {
     using System.Collections.Generic;
 
+    /// <summary>
+    /// Data for Piping calculation with PipingCalc2Dll
+    /// </summary>
     public class PipingModelModel2Data
     {
         private double fHeight1 = 0.0;
@@ -27,6 +30,9 @@
 
         private bool fIsHeadDropCalculation = true;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PipingModelModel2Data"/> class.
+        /// </summary>
         public PipingModelModel2Data()
         {
             fPipingCommonData = new PipingCommonData();
@@ -60,12 +66,20 @@
             fRowHeaderTextList.Add("Calculate"); // moved to end
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PipingModelModel2Data"/> class.
+        /// </summary>
+        /// <param name="aPipingCommonData">a piping common data.</param>
         public PipingModelModel2Data(ref PipingCommonData aPipingCommonData)
         {
             InitializeDefaults();
             fPipingCommonData = aPipingCommonData;
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PipingModelModel2Data"/> class.
+        /// </summary>
+        /// <param name="aModel2CalculationData">a model2 calculation data.</param>
         public PipingModelModel2Data(PipingModelModel2Data aModel2CalculationData)
         {
             fSeepageLength = aModel2CalculationData.SeepageLength;
@@ -90,6 +104,9 @@
             fPipingCommonData = new PipingCommonData(aModel2CalculationData.PipingCommonData);
         }
 
+        /// <summary>
+        /// Initializes the defaults.
+        /// </summary>
         public void InitializeDefaults()
         {
 
@@ -121,29 +138,118 @@
             fIsHeadDropCalculation = true;
         }
 
+        /// <summary>
+        /// Gets or sets the piping common data.
+        /// </summary>
+        /// <value>
+        /// The piping common data.
+        /// </value>
         public PipingCommonData PipingCommonData { set { fPipingCommonData = value; } get { return fPipingCommonData; } }
 
         // Model2 data as properties (VNK)
+
+        /// <summary>
+        /// Gets or sets the length of the seepage.
+        /// </summary>
+        /// <value>
+        /// The length of the seepage.
+        /// </value>
         public double SeepageLength { set { fSeepageLength = value; } get { return fSeepageLength; } }
 
+        /// <summary>
+        /// Gets or sets the length of the crack.
+        /// </summary>
+        /// <value>
+        /// The length of the crack.
+        /// </value>
         public double CrackLength { set { fCrackLength = value; } get { return fCrackLength; } }
 
+        /// <summary>
+        /// Gets or sets the particle diameter.
+        /// </summary>
+        /// <value>
+        /// The particle diameter.
+        /// </value>
         public double ParticleDiameter { set { fParticleDiameter = value; } get { return fParticleDiameter; } }
 
+        /// <summary>
+        /// Gets or sets the height1.
+        /// </summary>
+        /// <value>
+        /// The height1.
+        /// </value>
         public double Height1 { set { fHeight1 = value; } get { return fHeight1; } }
+
+        /// <summary>
+        /// Gets or sets the height2.
+        /// </summary>
+        /// <value>
+        /// The height2.
+        /// </value>
         public double Height2 { set { fHeight2 = value; } get { return fHeight2; } }
 
+        /// <summary>
+        /// Gets or sets the permeability1.
+        /// </summary>
+        /// <value>
+        /// The permeability1.
+        /// </value>
         public double Permeability1 { set { fPermeability1 = value; } get { return fPermeability1; } }
+
+        /// <summary>
+        /// Gets or sets the permeability2.
+        /// </summary>
+        /// <value>
+        /// The permeability2.
+        /// </value>
         public double Permeability2 { set { fPermeability2 = value; } get { return fPermeability2; } }
+
+        /// <summary>
+        /// Gets or sets the permeability3.
+        /// </summary>
+        /// <value>
+        /// The permeability3.
+        /// </value>
         public double Permeability3 { set { fPermeability3 = value; } get { return fPermeability3; } }
 
+        /// <summary>
+        /// Gets or sets the head drop.
+        /// </summary>
+        /// <value>
+        /// The head drop.
+        /// </value>
         public double HeadDrop { get { return fHeadDrop; } set { fHeadDrop = value; } }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is head drop calculation.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if this instance is head drop calculation; otherwise, <c>false</c>.
+        /// </value>
         public bool IsHeadDropCalculation { get { return fIsHeadDropCalculation; } set { fIsHeadDropCalculation = value; } }
 
+        /// <summary>
+        /// Gets or sets the messages.
+        /// </summary>
+        /// <value>
+        /// The messages.
+        /// </value>
         public string Messages { get { return fMessages; } set { fMessages = value; } }
+
+        /// <summary>
+        /// Gets or sets the warning message.
+        /// </summary>
+        /// <value>
+        /// The warning message.
+        /// </value>
         public string WarningMessage { get { return fWarningMessage; } set { fWarningMessage = value; } }
 
+        /// <summary>
+        /// Gets the row header text list.
+        /// </summary>
+        /// <value>
+        /// The row header text list.
+        /// </value>
         public static List<string> RowHeaderTextList { get { return fRowHeaderTextList; } }
 
     }
Index: dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCommonData.cs
===================================================================
diff -u -r371 -r375
--- dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCommonData.cs	(.../PipingCommonData.cs)	(revision 371)
+++ dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCommonData.cs	(.../PipingCommonData.cs)	(revision 375)
@@ -2,18 +2,24 @@
 
 namespace Deltares.DamPiping.SellmeijerVNKCalculator
 {
+    /// <summary>
+    /// Common Data for Piping calculation with PipingCalc2Dll
+    /// </summary>
     public class PipingCommonData
     {
-        // soil properties
-
-        // calc params
-
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PipingCommonData"/> class.
+        /// </summary>
         public PipingCommonData()
         {
             IsAdjustHeadDrop = true;
             InitializeDefaults();
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PipingCommonData"/> class.
+        /// </summary>
+        /// <param name="pipingCommonData">The piping common data.</param>
         public PipingCommonData(PipingCommonData pipingCommonData)
         {
             WaterViscosity = pipingCommonData.WaterViscosity;
@@ -28,15 +34,73 @@
             FluidisationGradient = pipingCommonData.FluidisationGradient;
         }
 
+        /// <summary>
+        /// Gets or sets the water viscosity.
+        /// </summary>
+        /// <value>
+        /// The water viscosity.
+        /// </value>
         public double WaterViscosity { get; set; }
+
+        /// <summary>
+        /// Gets or sets the water unit weight.
+        /// </summary>
+        /// <value>
+        /// The water unit weight.
+        /// </value>
         public double WaterUnitWeight { get; set; }
+
+        /// <summary>
+        /// Gets or sets the particle unit weight.
+        /// </summary>
+        /// <value>
+        /// The particle unit weight.
+        /// </value>
         public double ParticleUnitWeight { get; set; }
+
+        /// <summary>
+        /// Gets or sets the whites constant.
+        /// </summary>
+        /// <value>
+        /// The whites constant.
+        /// </value>
         public double WhitesConstant { get; set; }
+
+        /// <summary>
+        /// Gets or sets the bedding angle.
+        /// </summary>
+        /// <value>
+        /// The bedding angle.
+        /// </value>
         public double BeddingAngle { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is adjust head drop.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if this instance is adjust head drop; otherwise, <c>false</c>.
+        /// </value>
         public bool IsAdjustHeadDrop { get; set; }
+
+        /// <summary>
+        /// Gets or sets the safety factor.
+        /// </summary>
+        /// <value>
+        /// The safety factor.
+        /// </value>
         public double SafetyFactor { get; set; }
+
+        /// <summary>
+        /// Gets or sets the fluidisation gradient.
+        /// </summary>
+        /// <value>
+        /// The fluidisation gradient.
+        /// </value>
         public double FluidisationGradient { get; set; }
 
+        /// <summary>
+        /// Initializes the defaults.
+        /// </summary>
         public void InitializeDefaults()
         {
             WaterViscosity = Physics.WaterViscosity;
Index: dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingModel2Calculation.cs
===================================================================
diff -u -r371 -r375
--- dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingModel2Calculation.cs	(.../PipingModel2Calculation.cs)	(revision 371)
+++ dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingModel2Calculation.cs	(.../PipingModel2Calculation.cs)	(revision 375)
@@ -1,32 +1,13 @@
 namespace Deltares.DamPiping.SellmeijerVNKCalculator
 {
     using System;
-    using System.Text;
-    using System.IO;
     using System.Runtime.InteropServices;
-    using System.Globalization;
-    using System.Collections.Generic;
 
-    [StructLayout(LayoutKind.Sequential)]
-    public struct RingDataStruct
-    {
-        public double WaterUnitWeight; //1
-        public double WaterViscosity; //2
-        public double ParticleUnitWeight; //3
-        public double ParticleDiameter; //4
-        public double Model2Layer1Thickness; //5
-        public double Model2Layer2Thickness; //6
-        public double Model2Soil1Permeability; //7
-        public double Model2Soil2Permeability; //8
-        public double Model2Soil3Permeability; //9
-        public double VerticalSeepageLength; //10
-        public double SeepageLength; //11
-        public double BeddingAngle; //12
-        public double WhitesConstant; //13
-        public double SafetyFactor; //14
-        public double FluidisationGradient; //15
-    } ;
+    #region Structs
 
+    /// <summary>
+    /// Struct for Soil Poperties
+    /// </summary>
     [StructLayout(LayoutKind.Sequential)]
     public struct SoilPropertiesStruct
     {
@@ -36,13 +17,19 @@
         public double WhitesConstant; //4
     } ;
 
+    /// <summary>
+    /// Struct for Water Poperties
+    /// </summary>
     [StructLayout(LayoutKind.Sequential)]
     public struct WaterPropertiesStruct
     {
         public double UnitWeight;
         public double Viscosity;
     } ;
 
+    /// <summary>
+    /// Struct for Calculation Parameters
+    /// </summary>
     [StructLayout(LayoutKind.Sequential)]
     public struct CalculationParametersStruct
     {
@@ -53,114 +40,206 @@
         public double FluidisationGradient; //4
     }
 
+    #endregion Strucs
+
+    /// <summary>
+    /// Runs the PipingCalc2Dll
+    /// </summary>
     public class PipingModel2Calculation
     {
-        private const string sPipingParametersSectionId = "[PipingParameters]";
-        private const int cTotalParameterCount = 15;
-        private const string sDebugFile = "VNK-Debug.log";
-        private const int cMaxPath = 256;
-
         private PipingModelModel2Data fCurrentCalculationData = null;
 
         private string fHomeDir = "";
 
         private string fSessionId = "";
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PipingModel2Calculation"/> class.
+        /// </summary>
         public PipingModel2Calculation()
         {
             fCurrentCalculationData = new PipingModelModel2Data();            
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PipingModel2Calculation"/> class.
+        /// </summary>
+        /// <param name="aPipingCommonData">a piping common data.</param>
         public PipingModel2Calculation(ref PipingCommonData aPipingCommonData)
         {
             fCurrentCalculationData = new PipingModelModel2Data(ref aPipingCommonData);            
         }
 
-        // wrap the Model2 data as properties here again (VNK)
+        /// <summary>
+        /// Gets or sets the piping common data.
+        /// wrap the Model2 data as properties here again (VNK)
+        /// </summary>
         public PipingCommonData PipingCommonData
         {
             set { fCurrentCalculationData.PipingCommonData = value; }
             get { return fCurrentCalculationData.PipingCommonData; }
         }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is head drop calculation.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if this instance is head drop calculation; otherwise, <c>false</c>.
+        /// </value>
         public bool IsHeadDropCalculation
         {
             set { fCurrentCalculationData.IsHeadDropCalculation = value; }
             get { return fCurrentCalculationData.IsHeadDropCalculation; }
         }
 
+        /// <summary>
+        /// Gets or sets the length of the seepage.
+        /// </summary>
+        /// <value>
+        /// The length of the seepage.
+        /// </value>
         public double SeepageLength
         {
             set { fCurrentCalculationData.SeepageLength = value; }
             get { return fCurrentCalculationData.SeepageLength; }
         }
 
+        /// <summary>
+        /// Gets or sets the length of the crack.
+        /// </summary>
+        /// <value>
+        /// The length of the crack.
+        /// </value>
         public double CrackLength
         {
             set { fCurrentCalculationData.CrackLength = value; }
             get { return fCurrentCalculationData.CrackLength; }
         }
 
+        /// <summary>
+        /// Gets or sets the particle diameter.
+        /// </summary>
+        /// <value>
+        /// The particle diameter.
+        /// </value>
         public double ParticleDiameter
         {
             set { fCurrentCalculationData.ParticleDiameter = value; }
             get { return fCurrentCalculationData.ParticleDiameter; }
         }
 
+        /// <summary>
+        /// Gets or sets the height1.
+        /// </summary>
+        /// <value>
+        /// The height1.
+        /// </value>
         public double Height1
         {
             set { fCurrentCalculationData.Height1 = value; }
             get { return fCurrentCalculationData.Height1; }
         }
 
+        /// <summary>
+        /// Gets or sets the height2.
+        /// </summary>
+        /// <value>
+        /// The height2.
+        /// </value>
         public double Height2
         {
             set { fCurrentCalculationData.Height2 = value; }
             get { return fCurrentCalculationData.Height2; }
         }
 
+        /// <summary>
+        /// Gets or sets the permeability1.
+        /// </summary>
+        /// <value>
+        /// The permeability1.
+        /// </value>
         public double Permeability1
         {
             set { fCurrentCalculationData.Permeability1 = value; }
             get { return fCurrentCalculationData.Permeability1; }
         }
 
+        /// <summary>
+        /// Gets or sets the permeability2.
+        /// </summary>
+        /// <value>
+        /// The permeability2.
+        /// </value>
         public double Permeability2
         {
             set { fCurrentCalculationData.Permeability2 = value; }
             get { return fCurrentCalculationData.Permeability2; }
         }
 
+        /// <summary>
+        /// Gets or sets the permeability3.
+        /// </summary>
+        /// <value>
+        /// The permeability3.
+        /// </value>
         public double Permeability3
         {
             set { fCurrentCalculationData.Permeability3 = value; }
             get { return fCurrentCalculationData.Permeability3; }
         }
 
+        /// <summary>
+        /// Gets or sets the head drop.
+        /// </summary>
+        /// <value>
+        /// The head drop.
+        /// </value>
         public double HeadDrop
         {
             get { return fCurrentCalculationData.HeadDrop; }
             set { fCurrentCalculationData.HeadDrop = value; }
         }
 
+        /// <summary>
+        /// Gets or sets the messages.
+        /// </summary>
+        /// <value>
+        /// The messages.
+        /// </value>
         public string Messages
         {
             get { return fCurrentCalculationData.Messages; }
             set { fCurrentCalculationData.Messages = value; }
         }
 
+        /// <summary>
+        /// Gets or sets the home dir.
+        /// </summary>
+        /// <value>
+        /// The home dir.
+        /// </value>
         public string HomeDir
         {
             get { return fHomeDir; }
             set { fHomeDir = value; }
         }
 
+        /// <summary>
+        /// Gets or sets the session identifier.
+        /// </summary>
+        /// <value>
+        /// The session identifier.
+        /// </value>
         public string SessionId
         {
             get { return fSessionId; }
             set { fSessionId = value; }
         }
 
+        /// <summary>
+        /// Calculates the head drop pc2.
+        /// </summary>
+        /// <exception cref="PipingCalculationException">Error in Piping DLL</exception>
         public void CalculateHeadDropPC2()
         {
             const string cMessageError = "Error";
@@ -248,275 +327,5 @@
             }
         }
 
-//        /// <summary>
-//        /// Throw helper
-//        /// </summary>
-//        /// <param name="currentObject"></param>
-//        public void ThrowIfNotAssigned(Object currentObject, string objectName)
-//        {
-//            if (currentObject == null)
-//            {
-//                throw new PipingCalculationException(string.Format("Missing input {0}", objectName));
-//            }
-//        }
-//
-//
-//
-//        /// <summary>
-//        /// Read debug log from file
-//        /// </summary>
-//        /// <param name="APath"></param>
-//        /// <returns></returns>
-//        private string ReadDebugLog(string APath)
-//        {
-//            try
-//            {
-//                StreamReader stream = File.OpenText(APath);
-//                stream.ReadLine(); // first line
-//
-//                string LLine2 = stream.ReadToEnd();
-//                stream.Close();
-//                File.Delete(APath);
-//
-//                return LLine2;
-//            }
-//            catch
-//            {
-//                return null;
-//            }
-//        }
-//
-//        // TEMP... this has to be done more generically
-//        private void SetCurrentValueFromString(string aField, string aValue)
-//        {
-//            double doubleValue = 0.0;
-//            bool boolValue = true;
-//
-//            switch (aField)
-//            {
-//                case "gamma_w":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
-//                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
-//                            fCurrentCalculationData.PipingCommonData.WaterUnitWeight = doubleValue;
-//                        break;
-//                    }
-//                case "mu":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CMinWaterViscosity,
-//                                                            PipingConstants.CMaxWaterViscosity, ref doubleValue))
-//                            fCurrentCalculationData.PipingCommonData.WaterViscosity = doubleValue;
-//                        break;
-//                    }
-//                case "gamma_p":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
-//                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
-//                            fCurrentCalculationData.PipingCommonData.ParticleUnitWeight = doubleValue;
-//                        break;
-//                    }
-//                case "eta":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CMinWhitesConstant,
-//                                                            PipingConstants.CMaxWhitesConstant, ref doubleValue))
-//                            fCurrentCalculationData.PipingCommonData.WhitesConstant = doubleValue;
-//                        break;
-//                    }
-//                case "theta":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CMinBeddingAngle,
-//                                                            PipingConstants.CMaxBeddingAngle, ref doubleValue))
-//                            fCurrentCalculationData.PipingCommonData.BeddingAngle = doubleValue;
-//                        break;
-//                    }
-//                case "Adapt":
-//                    {
-//                        if (GetBoolValueFromString(aValue, ref boolValue))
-//                            fCurrentCalculationData.PipingCommonData.IsAdjustHeadDrop = boolValue;
-//                        break;
-//                    }
-//                case "F":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CMinSafetyFactor,
-//                                                            PipingConstants.CMaxSafetyFactor, ref doubleValue))
-//                            fCurrentCalculationData.PipingCommonData.SafetyFactor = doubleValue;
-//                        break;
-//                    }
-//                case "i":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CMinFluidisationGradient,
-//                                                            PipingConstants.CMaxFluidisationGradient, ref doubleValue))
-//                            fCurrentCalculationData.PipingCommonData.FluidisationGradient = doubleValue;
-//                        break;
-//                    }
-//                case "D1":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
-//                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
-//                            fCurrentCalculationData.Height1 = doubleValue;
-//                        break;
-//                    }
-//                case "D2":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
-//                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
-//                            fCurrentCalculationData.Height2 = doubleValue;
-//                        break;
-//                    }
-//                case "K1":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
-//                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
-//                            fCurrentCalculationData.Permeability1 = doubleValue;
-//                        break;
-//                    }
-//                case "K2":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
-//                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
-//                            fCurrentCalculationData.Permeability2 = doubleValue;
-//                        break;
-//                    }
-//                case "K3":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
-//                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
-//                            fCurrentCalculationData.Permeability3 = doubleValue;
-//                        break;
-//                    }
-//                case "Do":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, 0.0, PipingConstants.CDelphiMaxDouble,
-//                                                            ref doubleValue))
-//                            fCurrentCalculationData.CrackLength = doubleValue;
-//                        break;
-//                    }
-//                case "d70":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
-//                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
-//                            fCurrentCalculationData.ParticleDiameter = doubleValue;
-//                        break;
-//                    }
-//                case "L":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
-//                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
-//                            fCurrentCalculationData.SeepageLength = doubleValue;
-//                        break;
-//                    }
-//                case "dH":
-//                    {
-//                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
-//                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
-//                            fCurrentCalculationData.HeadDrop = doubleValue;
-//                        break;
-//                    }
-//                case "Calculate":
-//                    {
-//                        if (aValue == PipingModelModel2Data.RowHeaderTextList[15])
-//                            fCurrentCalculationData.IsHeadDropCalculation = false;
-//                        else
-//                            fCurrentCalculationData.IsHeadDropCalculation = true;
-//                        break;
-//                    }
-//                default:
-//                    break;
-//            }
-//        }
-//
-//        // TEMP... this has to be done more generically
-//        private bool ValidateDoubleToRangeFromString(string aStringValue, double aMin, double aMax, ref double aValue)
-//        {
-//            double doubleValue = 0.0;
-//
-//            // the CSV read would have changed all decimal separators to '.'
-//            // specify this to the double parsing, else we'd get wrong values
-//            // if the current thread has a diff decimal separator
-//            NumberFormatInfo ni = new NumberFormatInfo();
-//            ni.CurrencyDecimalSeparator = ".";
-//            ni.NumberDecimalSeparator = ".";
-//
-//            try
-//            {
-//                doubleValue = Double.Parse(aStringValue, ni);
-//            }
-//            catch
-//            {
-//                return false;
-//            }
-//
-//            if (doubleValue < aMin)
-//                doubleValue = aMin;
-//            else if (doubleValue > aMax)
-//                doubleValue = aMax;
-//
-//            aValue = doubleValue;
-//            return true;
-//        }
-//
-//        private bool GetBoolValueFromString(string aStringValue, ref bool aValue)
-//        {
-//            bool boolValue = true;
-//
-//            try
-//            {
-//                boolValue = bool.Parse(aStringValue);
-//            }
-//            catch
-//            {
-//                return false;
-//            }
-//
-//            aValue = boolValue;
-//            return true;
-//        }
-//
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <returns></returns>
-        public List<string> ParametersToStrings()
-        {
-            List<string> parameterStrings = new List<string>();
-
-            // soil properties
-            parameterStrings.Add(sPipingParametersSectionId);
-            parameterStrings.Add(String.Format("BeddingAngle={0}", fCurrentCalculationData.PipingCommonData.BeddingAngle));
-            parameterStrings.Add(String.Format("ParticleDiameter={0}", fCurrentCalculationData.ParticleDiameter));
-            parameterStrings.Add(String.Format("ParticleUnitWeight={0:0.00}",
-                                               fCurrentCalculationData.PipingCommonData.ParticleUnitWeight));
-            parameterStrings.Add(String.Format("WhitesConstant={0}",
-                                               fCurrentCalculationData.PipingCommonData.WhitesConstant));
-            //// water properties
-            parameterStrings.Add(String.Format("WaterUnitWeight={0:0.00}",
-                                               fCurrentCalculationData.PipingCommonData.WaterUnitWeight));
-            parameterStrings.Add(String.Format("WaterViscosity={0:E4}",
-                                               fCurrentCalculationData.PipingCommonData.WaterViscosity));
-
-            parameterStrings.Add(String.Format("CrackLength={0:0.00}", fCurrentCalculationData.CrackLength));
-            parameterStrings.Add(String.Format("HeadDrop={0:0.00}", fCurrentCalculationData.HeadDrop));
-            parameterStrings.Add(String.Format("SeepageLength={0:0.00}", fCurrentCalculationData.SeepageLength));
-
-            //// heights
-            parameterStrings.Add(String.Format("Height1={0:0.00}", fCurrentCalculationData.Height1));
-            parameterStrings.Add(String.Format("Height2={0:0.00}", fCurrentCalculationData.Height2));
-            //// permeabilities
-            parameterStrings.Add(String.Format("Permeability1={0:E5}", fCurrentCalculationData.Permeability1));
-            parameterStrings.Add(String.Format("Permeability2={0:E5}", fCurrentCalculationData.Permeability2));
-            parameterStrings.Add(String.Format("Permeability3={0:E5}", fCurrentCalculationData.Permeability3));
-
-            parameterStrings.Add(String.Format("IsHeadDropCalculation={0}",
-                                               fCurrentCalculationData.IsHeadDropCalculation));
-            parameterStrings.Add(String.Format("IsAdjustHeadDrop={0}",
-                                               fCurrentCalculationData.PipingCommonData.IsAdjustHeadDrop));
-            parameterStrings.Add(String.Format("SafetyFactor={0:0.00}",
-                                               fCurrentCalculationData.PipingCommonData.SafetyFactor));
-            parameterStrings.Add(String.Format("FluidisationGradient={0:0.00}",
-                                               fCurrentCalculationData.PipingCommonData.FluidisationGradient));
-
-            return parameterStrings;
-        }
-
     }
 }
\ No newline at end of file
Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.SellmeijerVNKCalculatorTests/PipingModel2CalculationTest.cs
===================================================================
diff -u
--- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.SellmeijerVNKCalculatorTests/PipingModel2CalculationTest.cs	(revision 0)
+++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.SellmeijerVNKCalculatorTests/PipingModel2CalculationTest.cs	(revision 375)
@@ -0,0 +1,124 @@
+using Deltares.DamPiping.SellmeijerVNKCalculator;
+using Deltares.DamPiping.SellmeijerVNKCalculator.Geo;
+
+namespace Deltares.DamPiping.SellmeijerVNKCalculatorTests
+{
+    using NUnit.Framework;
+
+    [TestFixture]
+    public class TestPipingModel2Calculation
+    {
+        private const double cToleranceHeadDrop = 0.005;
+
+        [Test]
+        public void IsHeadDropCalculatedCorrectly()
+        {
+            PipingModel2Calculation pipingModel2Calculation = new PipingModel2Calculation();
+            pipingModel2Calculation.Height1 = 10.0;
+            pipingModel2Calculation.CalculateHeadDropPC2();
+            Assert.AreEqual(3.46, pipingModel2Calculation.HeadDrop, cToleranceHeadDrop);
+            pipingModel2Calculation.Height1 = 11.0;
+            pipingModel2Calculation.CalculateHeadDropPC2();
+            Assert.AreEqual(3.42, pipingModel2Calculation.HeadDrop, cToleranceHeadDrop);
+            pipingModel2Calculation.Height1 = 11.0;
+            pipingModel2Calculation.Permeability3 = 0.002;
+            pipingModel2Calculation.CalculateHeadDropPC2();
+            Assert.AreEqual(3.06, pipingModel2Calculation.HeadDrop, cToleranceHeadDrop);
+        }
+
+        [Test]
+        public void IsSeepageLengthCalculatedCorrectly()
+        {
+            PipingModel2Calculation pipingModel2Calculation = new PipingModel2Calculation();
+            pipingModel2Calculation.PipingCommonData.BeddingAngle = 20.0;
+            pipingModel2Calculation.PipingCommonData.FluidisationGradient = 0.3;
+            pipingModel2Calculation.PipingCommonData.ParticleUnitWeight = 26.5;
+            pipingModel2Calculation.PipingCommonData.SafetyFactor = 1.2;
+            pipingModel2Calculation.PipingCommonData.IsAdjustHeadDrop = false;
+            pipingModel2Calculation.PipingCommonData.WaterUnitWeight = Physics.UnitWeightOfwater;
+            pipingModel2Calculation.PipingCommonData.WaterViscosity = 1.33E-06;
+            pipingModel2Calculation.PipingCommonData.WhitesConstant = 0.4;
+            pipingModel2Calculation.Height1 = 4.0;
+            pipingModel2Calculation.Height2 = 42.0;
+            pipingModel2Calculation.Permeability1 = 0.0005;
+            pipingModel2Calculation.Permeability2 = 0.0005;
+            pipingModel2Calculation.Permeability3 = 0.0005;
+            pipingModel2Calculation.ParticleDiameter = 350.0;
+            pipingModel2Calculation.CrackLength = 1.1;
+            pipingModel2Calculation.HeadDrop = 18.757;
+            pipingModel2Calculation.HeadDrop = 5.0;
+            pipingModel2Calculation.SeepageLength = 50.0;
+            pipingModel2Calculation.IsHeadDropCalculation = false;
+            pipingModel2Calculation.CalculateHeadDropPC2();
+            Assert.AreEqual(101.5, pipingModel2Calculation.SeepageLength, cToleranceHeadDrop);
+        }
+
+        [Test]
+        [ExpectedException(typeof(PipingCalculationException))]
+        public void IsExceptionFromDllHandledCorrectly()
+        {
+            PipingModel2Calculation pipingModel2Calculation = new PipingModel2Calculation();
+            pipingModel2Calculation.PipingCommonData.BeddingAngle = 20.0;
+            pipingModel2Calculation.PipingCommonData.FluidisationGradient = 0.3;
+            pipingModel2Calculation.PipingCommonData.ParticleUnitWeight = 26.5;
+            pipingModel2Calculation.PipingCommonData.SafetyFactor = 1.2;
+            pipingModel2Calculation.PipingCommonData.IsAdjustHeadDrop = false;
+            pipingModel2Calculation.PipingCommonData.WaterUnitWeight = Physics.UnitWeightOfwater;
+            pipingModel2Calculation.PipingCommonData.WaterViscosity = 1.33E-06;
+            pipingModel2Calculation.PipingCommonData.WhitesConstant = 0.4;
+            pipingModel2Calculation.Height1 = 4.0;
+            pipingModel2Calculation.Height2 = 42.0;
+            pipingModel2Calculation.Permeability1 = 0.0005;
+            pipingModel2Calculation.Permeability2 = 0.0005;
+            pipingModel2Calculation.Permeability3 = 0.0005;
+            pipingModel2Calculation.ParticleDiameter = 350.0;
+            pipingModel2Calculation.CrackLength = 1.1;
+            pipingModel2Calculation.HeadDrop = 18.757;
+            pipingModel2Calculation.SeepageLength = -50.0;
+            pipingModel2Calculation.IsHeadDropCalculation = true;
+            // negative seepagelength will throw an ecxeption
+            pipingModel2Calculation.CalculateHeadDropPC2();
+        }
+
+        private PipingModel2Calculation CreateAndFillPipingModel2CalculationForTestcase01()
+        {
+            var pipingModel2Calculation = new PipingModel2Calculation();
+            pipingModel2Calculation.HeadDrop = 0.0;// Not used, to be calculated
+            pipingModel2Calculation.PipingCommonData.BeddingAngle = 20.0;
+            pipingModel2Calculation.PipingCommonData.FluidisationGradient = 0.3;
+            pipingModel2Calculation.PipingCommonData.WaterUnitWeight = Physics.UnitWeightOfwater;
+            pipingModel2Calculation.PipingCommonData.WaterViscosity = 1.33000E-06;
+            pipingModel2Calculation.PipingCommonData.WhitesConstant = 0.4;
+            pipingModel2Calculation.PipingCommonData.SafetyFactor = 1.20;
+            pipingModel2Calculation.PipingCommonData.IsAdjustHeadDrop = false;
+
+            // Soil parameters
+            pipingModel2Calculation.PipingCommonData.ParticleUnitWeight = 26.50;
+            pipingModel2Calculation.Permeability1 = 0.0001;
+            pipingModel2Calculation.Permeability2 = 0.0005;
+            pipingModel2Calculation.Permeability3 = 0.0001;
+            pipingModel2Calculation.ParticleDiameter = 250.0;
+
+            // Geometry parameters
+            pipingModel2Calculation.Height1 = 5.5;
+            pipingModel2Calculation.Height2 = 45.0;
+            return pipingModel2Calculation;
+        }
+
+        [Test]
+        public void CanCalculateTestCase01()
+        {
+            // MPipingCalc2.dll 1.2.3.1 fails on this 
+            var pipingModel2Calculation = CreateAndFillPipingModel2CalculationForTestcase01();
+            pipingModel2Calculation.IsHeadDropCalculation = false; // Constant
+
+            pipingModel2Calculation.HeadDrop = 1.773; // L will be Calculated
+            pipingModel2Calculation.CrackLength = 0.1; // Distance upper sandlayer to surfaceline, "Do" in DGSWebPiping
+
+            pipingModel2Calculation.CalculateHeadDropPC2();
+
+            Assert.AreEqual(23.304, pipingModel2Calculation.SeepageLength, cToleranceHeadDrop);
+        }
+
+    }
+}
Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.SellmeijerVNKCalculatorTests/Deltares.DamPiping.SellmeijerVNKCalculatorTests.csproj
===================================================================
diff -u -r366 -r375
--- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.SellmeijerVNKCalculatorTests/Deltares.DamPiping.SellmeijerVNKCalculatorTests.csproj	(.../Deltares.DamPiping.SellmeijerVNKCalculatorTests.csproj)	(revision 366)
+++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.SellmeijerVNKCalculatorTests/Deltares.DamPiping.SellmeijerVNKCalculatorTests.csproj	(.../Deltares.DamPiping.SellmeijerVNKCalculatorTests.csproj)	(revision 375)
@@ -46,6 +46,7 @@
   <ItemGroup>
     <Compile Include="PipingCalculatorSellmeijerVNKTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="PipingModel2CalculationTest.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\Deltares.DamPiping.SellmeijerVNKCalculator\Deltares.DamPiping.SellmeijerVNKCalculator.csproj">
Index: dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.Sellmeijer4ForcesCalculator/PipingCalculatorSellmeijer4Forces.cs
===================================================================
diff -u -r374 -r375
--- dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.Sellmeijer4ForcesCalculator/PipingCalculatorSellmeijer4Forces.cs	(.../PipingCalculatorSellmeijer4Forces.cs)	(revision 374)
+++ dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.Sellmeijer4ForcesCalculator/PipingCalculatorSellmeijer4Forces.cs	(.../PipingCalculatorSellmeijer4Forces.cs)	(revision 375)
@@ -5,7 +5,9 @@
 
 namespace Deltares.DamPiping.Sellmeijer4ForcesCalculator
 {
-
+    /// <summary>
+    /// Calculates piping according to Sellmeijer 4 Forces
+    /// </summary>
     public class PipingCalculatorSellmeijer4Forces
     {
 
Index: dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCalculationException.cs
===================================================================
diff -u -r371 -r375
--- dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCalculationException.cs	(.../PipingCalculationException.cs)	(revision 371)
+++ dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCalculationException.cs	(.../PipingCalculationException.cs)	(revision 375)
@@ -3,23 +3,44 @@
     using System;
     using System.Runtime.Serialization;
 
+    /// <summary>
+    /// Exception class for Piping Calculation
+    /// </summary>
+    /// <seealso cref="System.Exception" />
     [Serializable]
     public class PipingCalculationException : Exception
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PipingCalculationException"/> class.
+        /// </summary>
         public PipingCalculationException()
         {
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PipingCalculationException"/> class.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
         public PipingCalculationException(string message)
             : base(message)
         {
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PipingCalculationException"/> class.
+        /// </summary>
+        /// <param name="message">The message.</param>
+        /// <param name="inner">The inner.</param>
         public PipingCalculationException(string message, Exception inner)
             : base(message, inner)
         {
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PipingCalculationException"/> class.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> that contains contextual information about the source or destination.</param>
         protected PipingCalculationException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         {
Index: dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCalculatorSellmeijerVNK.cs
===================================================================
diff -u -r374 -r375
--- dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCalculatorSellmeijerVNK.cs	(.../PipingCalculatorSellmeijerVNK.cs)	(revision 374)
+++ dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCalculatorSellmeijerVNK.cs	(.../PipingCalculatorSellmeijerVNK.cs)	(revision 375)
@@ -5,6 +5,9 @@
 
 namespace Deltares.DamPiping.SellmeijerVNKCalculator
 {
+    /// <summary>
+    /// Calculates piping according to Sellmeijer VNK
+    /// </summary>
     public class PipingCalculatorSellmeijerVNK
     {
 
@@ -123,18 +126,9 @@
             foSp = DetermineFactorOfSafety(hc, reducedFall);
         }
 
-        private PipingModel2Calculation SetData()
-        {
-            var pipingModel2Calculation = CreateAndFillPipingModel2Calculation();
-            pipingModel2Calculation.IsHeadDropCalculation = true; // Constant
-            pipingModel2Calculation.SeepageLength = SeepageLength;
-            pipingModel2Calculation.CrackLength = DTotal;
-            return pipingModel2Calculation;
-        }
-
         internal double CalculateHCritical()
         {
-            PipingModel2Calculation pipingModel2Calculation = SetData();
+            PipingModel2Calculation pipingModel2Calculation = CreateAndFillPipingModel2Calculation();
             // Reference level is highest value of surfaceLevel or PolderLevel
             // Uit TR Zandmeevoerende wellen (1999): "Het verval dH is gelijk aan het verschil tussen buitenwaterstand (het ontwerppeil(OP)) 
             // bij zeedijken en de maatgevende hoogwaterstand (MHW bij rivierdijken) en de waterstand binnendijks ter plaatse van het uittredepunt, 
@@ -180,6 +174,10 @@
         {
             var pipingModel2Calculation = new PipingModel2Calculation();
 
+            pipingModel2Calculation.IsHeadDropCalculation = true; // Constant
+            pipingModel2Calculation.SeepageLength = SeepageLength;
+            pipingModel2Calculation.CrackLength = DTotal;
+
             pipingModel2Calculation.HeadDrop = 0.0;// Not used, to be calculated
             pipingModel2Calculation.PipingCommonData.BeddingAngle = BeddingAngle; // From soilmaterials of upper sandlayer
             pipingModel2Calculation.PipingCommonData.FluidisationGradient = Rc; //Constant