Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.Sellmeijer4ForcesCalculatorTests/PipingCalculatorSellmeijer4ForcesTest.cs
===================================================================
diff -u -r363 -r373
--- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.Sellmeijer4ForcesCalculatorTests/PipingCalculatorSellmeijer4ForcesTest.cs	(.../PipingCalculatorSellmeijer4ForcesTest.cs)	(revision 363)
+++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.Sellmeijer4ForcesCalculatorTests/PipingCalculatorSellmeijer4ForcesTest.cs	(.../PipingCalculatorSellmeijer4ForcesTest.cs)	(revision 373)
@@ -12,13 +12,13 @@
         [Test]
         public void TestCalculationDefault()
         {
-            var bc = new PipingCalculatorSellmeijer4Forces
+            var calculator = new PipingCalculatorSellmeijer4Forces
             {
                 HRiver = 1
             };
-            bc.Calculate();
-            Assert.AreEqual(0, bc.FoSp);
-            Assert.AreEqual(double.NaN, bc.Hc);
+            calculator.Calculate();
+            Assert.AreEqual(0, calculator.FoSp);
+            Assert.AreEqual(double.NaN, calculator.Hc);
         }
 
         [Test]
@@ -29,7 +29,7 @@
             // For calculation of Hc see TestCanCalculateHCritical
             // See also "..\..\doc\Evaluation Piping\Nieuwe rekenregel bligh Sellmeijeruli.xls"
             const double diff = 0.0001;
-            var bc = new PipingCalculatorSellmeijer4Forces
+            var calculator = new PipingCalculatorSellmeijer4Forces
             {
                 HRiver = 1.0,
                 HExit = 0.0,
@@ -43,9 +43,9 @@
                 WaterViscosity = 1.33E-06,
                 PermeabilityKx = 0.0001
             };
-            bc.Calculate();
-            Assert.AreEqual(11.899117458988471, bc.FoSp, diff);
-            Assert.AreEqual(4.7596469835953883, bc.Hc, diff);
+            calculator.Calculate();
+            Assert.AreEqual(11.899117458988471, calculator.FoSp, diff);
+            Assert.AreEqual(4.7596469835953883, calculator.Hc, diff);
         }
 
 
@@ -54,42 +54,42 @@
         {
             const double cwhitesConstant = 0.25;
             const double cbeddingAngle = 41.0;
-            var pc = new PipingCalculatorSellmeijer4Forces
+            var calculator = new PipingCalculatorSellmeijer4Forces
             {
                 WhitesConstant = cwhitesConstant,
                 BeddingAngle = cbeddingAngle,
                 AquiferHeight = 3.0,
                 WaterViscosity = 1.33E-06
             };
 
-            pc.D70 = 180.0;
-            pc.SeepageLength = 15.00;
-            pc.PermeabilityKx = 7.00e-05;
-            var hCritical = pc.CalculateHCritical();
+            calculator.D70 = 180.0;
+            calculator.SeepageLength = 15.00;
+            calculator.PermeabilityKx = 7.00e-05;
+            var hCritical = calculator.CalculateHCritical();
             Assert.AreEqual(2.757966400, hCritical, CTolerance);
 
-            pc.D70 = 260.0;
-            pc.SeepageLength = 15.00;
-            pc.PermeabilityKx = 1.30e-04;
-            hCritical = pc.CalculateHCritical();
+            calculator.D70 = 260.0;
+            calculator.SeepageLength = 15.00;
+            calculator.PermeabilityKx = 1.30e-04;
+            hCritical = calculator.CalculateHCritical();
             Assert.AreEqual(3.184432652, hCritical, CTolerance);
 
-            pc.D70 = 180.0;
-            pc.SeepageLength = 20.00;
-            pc.PermeabilityKx = 7.00e-05;
-            hCritical = pc.CalculateHCritical();
+            calculator.D70 = 180.0;
+            calculator.SeepageLength = 20.00;
+            calculator.PermeabilityKx = 7.00e-05;
+            hCritical = calculator.CalculateHCritical();
             Assert.AreEqual(3.650076587, hCritical, CTolerance);
 
-            pc.D70 = 260.0;
-            pc.SeepageLength = 20.00;
-            pc.PermeabilityKx = 1.30e-04;
-            hCritical = pc.CalculateHCritical();
+            calculator.D70 = 260.0;
+            calculator.SeepageLength = 20.00;
+            calculator.PermeabilityKx = 1.30e-04;
+            hCritical = calculator.CalculateHCritical();
             Assert.AreEqual(4.215258070, hCritical, CTolerance);
 
-            pc.D70 = 180.0;
-            pc.SeepageLength = 60.00;
-            pc.PermeabilityKx = 7.00e-05;
-            hCritical = pc.CalculateHCritical();
+            calculator.D70 = 180.0;
+            calculator.SeepageLength = 60.00;
+            calculator.PermeabilityKx = 7.00e-05;
+            hCritical = calculator.CalculateHCritical();
             Assert.AreEqual(10.705479854, hCritical, CTolerance);
         }
 
@@ -124,7 +124,7 @@
         [Test]
         public void TestValidateNaNParameter()
         {
-            var bc = new PipingCalculatorSellmeijer4Forces
+            var calculator = new PipingCalculatorSellmeijer4Forces
             {
                 HRiver = 1.0,
                 HExit = 0.0,
@@ -138,20 +138,20 @@
                 WaterViscosity = 1.33E-06,
                 PermeabilityKx = 0.0001
             };
-            var originalErrors = bc.Validate();
+            var originalErrors = calculator.Validate();
 
-            bc.HRiver = double.NaN;
-            bc.HExit = double.NaN;
-            bc.Rc = double.NaN;
-            bc.DTotal = double.NaN;
-            bc.AquiferHeight = double.NaN;
-            bc.SeepageLength = double.NaN;
-            bc.D70 = double.NaN;
-            bc.WhitesConstant = double.NaN;
-            bc.BeddingAngle = double.NaN;
-            bc.WaterViscosity = double.NaN;
-            bc.PermeabilityKx = double.NaN;
-            var nanErrors = bc.Validate();
+            calculator.HRiver = double.NaN;
+            calculator.HExit = double.NaN;
+            calculator.Rc = double.NaN;
+            calculator.DTotal = double.NaN;
+            calculator.AquiferHeight = double.NaN;
+            calculator.SeepageLength = double.NaN;
+            calculator.D70 = double.NaN;
+            calculator.WhitesConstant = double.NaN;
+            calculator.BeddingAngle = double.NaN;
+            calculator.WaterViscosity = double.NaN;
+            calculator.PermeabilityKx = double.NaN;
+            var nanErrors = calculator.Validate();
             Assert.AreEqual(originalErrors.Count + 11, nanErrors.Count);
         }
 
Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.BlighCalculatorTests/PipingCalculatorBlighTests.cs
===================================================================
diff -u -r358 -r373
--- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.BlighCalculatorTests/PipingCalculatorBlighTests.cs	(.../PipingCalculatorBlighTests.cs)	(revision 358)
+++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.BlighCalculatorTests/PipingCalculatorBlighTests.cs	(.../PipingCalculatorBlighTests.cs)	(revision 373)
@@ -10,13 +10,13 @@
         [Test]
         public void TestCalculationDefault()
         {
-            var bc = new PipingCalculatorBligh
+            var calculator = new PipingCalculatorBligh
             {
                 HRiver = 1
             };
-            bc.Calculate();
-            Assert.AreEqual(0, bc.FoSp);
-            Assert.AreEqual(0, bc.Hc);
+            calculator.Calculate();
+            Assert.AreEqual(0, calculator.FoSp);
+            Assert.AreEqual(0, calculator.Hc);
         }
 
         [Test]
@@ -27,7 +27,7 @@
             // reducedFall = HRiver - HExit - (Rc * DTotal) = 2.0 - 0.0 - (0.3 * 5.0) = 0.5
             // FoSp = Hc / reducedFall = 2.25 / 0.5
             const double diff = 0.0001;
-            var bc = new PipingCalculatorBligh
+            var calculator = new PipingCalculatorBligh
             {
                 HRiver = 2.0,
                 HExit = 0.0,
@@ -36,36 +36,36 @@
                 SeepageLength = 40.5,
                 D70 = 180.0 
             };
-            bc.Calculate();
-            Assert.AreEqual(4.5, bc.FoSp, diff);
-            Assert.AreEqual(2.25, bc.Hc, diff);
+            calculator.Calculate();
+            Assert.AreEqual(4.5, calculator.FoSp, diff);
+            Assert.AreEqual(2.25, calculator.Hc, diff);
         }
 
         [Test]
         public void TestCreepFactor()
         {
-            var bc = new PipingCalculatorBligh();
-            bc.D70 = 180.0; // d50 < 150 
-            var factor = bc.CreepFactor();
+            var calculator = new PipingCalculatorBligh();
+            calculator.D70 = 180.0; // d50 < 150 
+            var factor = calculator.CreepFactor();
             Assert.AreEqual(18.0, factor);
 
-            bc.D70 = 200; // 150 < d50 < 300 
-            factor = bc.CreepFactor();
+            calculator.D70 = 200; // 150 < d50 < 300 
+            factor = calculator.CreepFactor();
             Assert.AreEqual(15.0, factor);
 
-            bc.D70 = 400; // 300 > d50 
-            factor = bc.CreepFactor();
+            calculator.D70 = 400; // 300 > d50 
+            factor = calculator.CreepFactor();
             Assert.AreEqual(12.0, factor);
 
-            bc.D70 = null; // d70 not specified
-            factor = bc.CreepFactor();
+            calculator.D70 = null; // d70 not specified
+            factor = calculator.CreepFactor();
             Assert.AreEqual(18.0, factor);
         }
 
         [Test]
         public void TestValidateNaNParameter()
         {
-            var bc = new PipingCalculatorBligh
+            var calculator = new PipingCalculatorBligh
             {
                 HRiver = 2.0,
                 HExit = 0.0,
@@ -74,20 +74,20 @@
                 SeepageLength = 40.5,
                 D70 = 180.0
             };
-            var originalErrors = bc.Validate();
+            var originalErrors = calculator.Validate();
 
-            bc.HRiver = double.NaN;
-            bc.HExit = double.NaN;
-            bc.Rc = double.NaN;
-            bc.DTotal = double.NaN;
-            bc.SeepageLength = double.NaN;
-            bc.D70 = double.NaN;
-            var nanErrors = bc.Validate();
+            calculator.HRiver = double.NaN;
+            calculator.HExit = double.NaN;
+            calculator.Rc = double.NaN;
+            calculator.DTotal = double.NaN;
+            calculator.SeepageLength = double.NaN;
+            calculator.D70 = double.NaN;
+            var nanErrors = calculator.Validate();
             Assert.AreEqual(originalErrors.Count + 6, nanErrors.Count);
 
             //  D70 is allowed to be null
-            bc.D70 = null;
-            nanErrors = bc.Validate();
+            calculator.D70 = null;
+            nanErrors = calculator.Validate();
             Assert.AreEqual(originalErrors.Count + 5, nanErrors.Count);
         }