Index: dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.Sellmeijer4ForcesCalculator/PipingCalculatorSellmeijer4Forces.cs =================================================================== diff -u -r363 -r374 --- dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.Sellmeijer4ForcesCalculator/PipingCalculatorSellmeijer4Forces.cs (.../PipingCalculatorSellmeijer4Forces.cs) (revision 363) +++ dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.Sellmeijer4ForcesCalculator/PipingCalculatorSellmeijer4Forces.cs (.../PipingCalculatorSellmeijer4Forces.cs) (revision 374) @@ -10,7 +10,6 @@ { public const double RcDefault = 0.3; - public const double Epsilon = 1e-8; protected const double DegreeToRadian = Math.PI / 180.0; protected static double GammaPDividedByGammaW = 16.5 / Physics.UnitWeightOfwater; // Gamma korrel is now assumed 16.5 kN/m3 @@ -104,23 +103,27 @@ { hc = CalculateHCritical(); reducedFall = GetReducedFall(); - DetermineFactorOfSafety(); + foSp = DetermineFactorOfSafety(hc, reducedFall); } - private void DetermineFactorOfSafety() + internal static double DetermineFactorOfSafety(double hCritical, double headDrop) { const double cDefaultMaxReturnValue = 90.0; const double cDefaultMinReturnValue = 0.0; + const double cEpsilon = 1e-8; - foSp = cDefaultMinReturnValue; - if (Math.Abs(hc) > Epsilon) + double factor = cDefaultMinReturnValue; + if (Math.Abs(hCritical) > cEpsilon) { - if (reducedFall <= 0) + factor = cDefaultMaxReturnValue; + // If actual headdrop is almost zero or smaller than zero then piping will be no problem + // The pipingfactor will be set to cDefaultMaxReturnValue + if (headDrop > 0 + cEpsilon) { - foSp = cDefaultMaxReturnValue; + factor = hCritical / headDrop; } - foSp = hc / reducedFall; } + return factor; } /// @@ -136,7 +139,7 @@ return result; } - private double GetReducedFall() + internal double GetReducedFall() { return HRiver - HExit - (Rc * DTotal); } Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.BlighCalculatorTests/PipingCalculatorBlighTests.cs =================================================================== diff -u -r373 -r374 --- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.BlighCalculatorTests/PipingCalculatorBlighTests.cs (.../PipingCalculatorBlighTests.cs) (revision 373) +++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.BlighCalculatorTests/PipingCalculatorBlighTests.cs (.../PipingCalculatorBlighTests.cs) (revision 374) @@ -63,6 +63,58 @@ } [Test] + public void TestGetReducedFall() + { + // reduced fall = HRiver - HExit - (Rc * DTotal) + const double cTolerance = 0.01; + var calculator = new PipingCalculatorBligh + { + HRiver = 1.0, + HExit = 0.0, + Rc = 0.3, + DTotal = 2.0, + }; + var reducedFall = calculator.GetReducedFall(); + Assert.AreEqual(0.40, reducedFall, cTolerance); + + calculator.HRiver = 0.0; + calculator.HExit = -2.0; + calculator.Rc = 0.2; + calculator.DTotal = 6.0; + reducedFall = calculator.GetReducedFall(); + Assert.AreEqual(0.80, reducedFall, cTolerance); + } + + [Test] + public void TestDetermineFactorOfSafety() + { + // foSp = hc / reducedFall + const double cTolerance = 0.01; + + var hCritical = 3.65; + var reducedFall = 1.00; + var safetyFactor = PipingCalculatorBligh.DetermineFactorOfSafety(hCritical, reducedFall); + Assert.AreEqual(3.65, safetyFactor, cTolerance); + + hCritical = 3.65; + reducedFall = 2.00; + safetyFactor = PipingCalculatorBligh.DetermineFactorOfSafety(hCritical, reducedFall); + Assert.AreEqual(1.825, safetyFactor, cTolerance); + + // reducedFall <= 0 result is cDefaultMaxReturnValue = 90.0; + hCritical = 3.65; + reducedFall = 0.00; + safetyFactor = PipingCalculatorBligh.DetermineFactorOfSafety(hCritical, reducedFall); + Assert.AreEqual(90.0, safetyFactor, cTolerance); + + // hCritical = 0 result is cDefaultMinReturnValue = 0.0; + hCritical = 0.00; + reducedFall = 1.00; + safetyFactor = PipingCalculatorBligh.DetermineFactorOfSafety(hCritical, reducedFall); + Assert.AreEqual(0.0, safetyFactor, cTolerance); + } + + [Test] public void TestValidateNaNParameter() { var calculator = new PipingCalculatorBligh Index: dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCalculatorSellmeijerVNK.cs =================================================================== diff -u -r371 -r374 --- dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCalculatorSellmeijerVNK.cs (.../PipingCalculatorSellmeijerVNK.cs) (revision 371) +++ dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/PipingCalculatorSellmeijerVNK.cs (.../PipingCalculatorSellmeijerVNK.cs) (revision 374) @@ -9,19 +9,11 @@ { public const double RcDefault = 0.3; - // public const double Epsilon = 1e-8; - // protected const double DegreeToRadian = Math.PI / 180.0; - // protected static double GammaPDividedByGammaW = 16.5 / Physics.UnitWeightOfwater; // Gamma korrel is now assumed 16.5 kN/m3 - public const string PipingFilenameExtension = ".txt"; - public const string DamParametersSectionId = "[DamParameters]"; - public const string ResultsSectionId = "[Results]"; - protected const double CToleranceHead = 0.00000001; private double foSp; private double hc; private double rc = RcDefault; private double reducedFall; - private string fileName = ""; /// /// River level as input @@ -121,17 +113,14 @@ } } - public string FilenameCalculation { get; set; } - /// /// Start the calculation of all output parameters. /// public void Calculate() { - PipingModel2Calculation pipingModel2Calculation = SetData(); - hc = CalculateHCritical(pipingModel2Calculation); + hc = CalculateHCritical(); reducedFall = GetReducedFall(); - DetermineFactorOfSafety(); + foSp = DetermineFactorOfSafety(hc, reducedFall); } private PipingModel2Calculation SetData() @@ -143,74 +132,39 @@ return pipingModel2Calculation; } - private double CalculateHCritical(PipingModel2Calculation pipingModel2Calculation) + internal double CalculateHCritical() { + PipingModel2Calculation pipingModel2Calculation = SetData(); // 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, // rekening houdend met zeespiegelrijzing etc.(zie paragraaf 3.7.2). In dien ter plaatse van het uittreepunt of de opbarstlocatie // geen vrije waterstand heerst kan gerekend worden met het maaiveldniveau, rekening houdend met eventuele maaiveld daling (zie paragraaf 3.7.2)." - - // Ouput piping parameters and dam parameters to project file - if (FilenameCalculation != null) - { - if (FilenameCalculation != "") - { - string directoryName = Path.GetDirectoryName(FilenameCalculation); - if (!String.IsNullOrEmpty(directoryName) && !Directory.Exists(directoryName)) - { - Directory.CreateDirectory(directoryName); - - } - fileName = String.Format("{0}{1}", FilenameCalculation, PipingFilenameExtension); - Console.WriteLine(fileName); - File.WriteAllLines(fileName, pipingModel2Calculation.ParametersToStrings().ToArray()); - - // Write Dam parameters to calculation file - var damParameterStrings = new List - { - DamParametersSectionId, - String.Format("PolderLevel={0}", PolderLevel), - String.Format("SurfaceTopLevel={0}", SurfaceLevel), - String.Format("ReferenceLevel={0}", HExit), - String.Format("WaterLevel={0}", HRiver), - "" - }; - File.AppendAllText(fileName, string.Join(Environment.NewLine, damParameterStrings.ToArray())); - } - } pipingModel2Calculation.CalculateHeadDropPC2(); - return pipingModel2Calculation.HeadDrop; } - private void DetermineFactorOfSafety() + internal static double DetermineFactorOfSafety(double hCritical, double headDrop) { const double cDefaultMaxReturnValue = 90.0; - foSp = cDefaultMaxReturnValue; - // If actual headdrop is almost zero or smaller than zero then piping will be no problem - // The pipingfactor will be set to cDefaultMaxReturnValue - if (reducedFall > CToleranceHead) + const double cDefaultMinReturnValue = 0.0; + const double cEpsilon = 1e-8; + + double factor = cDefaultMinReturnValue; + if (Math.Abs(hCritical) > cEpsilon) { - foSp = hc / reducedFall; + factor = cDefaultMaxReturnValue; + // If actual headdrop is almost zero or smaller than zero then piping will be no problem + // The pipingfactor will be set to cDefaultMaxReturnValue + if (headDrop > 0 + cEpsilon) + { + factor = hCritical / headDrop; + } } - - // Write results to calculation file - if (fileName != "") - { - var resultStrings = new List - { - ResultsSectionId, - String.Format("HCritical={0}", hc), - String.Format("HActual={0}", reducedFall), - String.Format("PipingFactor={0}", foSp), - "" - }; - File.AppendAllText(fileName, string.Join(Environment.NewLine, resultStrings.ToArray())); - } + return factor; } - private double GetReducedFall() + internal double GetReducedFall() { // The Leidraad says that 0.3 * d can be substracted from hActual // In the piping Sellmeijer model (PipingModel2 for VNK) 0.3 * d is added to the hCritical Index: dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.BlighCalculator/PipingCalculatorBligh.cs =================================================================== diff -u -r352 -r374 --- dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.BlighCalculator/PipingCalculatorBligh.cs (.../PipingCalculatorBligh.cs) (revision 352) +++ dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.BlighCalculator/PipingCalculatorBligh.cs (.../PipingCalculatorBligh.cs) (revision 374) @@ -10,7 +10,6 @@ public class PipingCalculatorBligh { public const double RcDefault = 0.3; - public const double Epsilon = 1e-8; public const double D50DividedByD70 = 0.81; private double foSp; @@ -78,23 +77,27 @@ { hc = GetHc(); reducedFall = GetReducedFall(); - DetermineFactorOfSafety(); + foSp = DetermineFactorOfSafety(hc, reducedFall); } - private void DetermineFactorOfSafety() + internal static double DetermineFactorOfSafety(double hCritical, double headDrop) { const double cDefaultMaxReturnValue = 90.0; const double cDefaultMinReturnValue = 0.0; + const double cEpsilon = 1e-8; - foSp = cDefaultMinReturnValue; - if (Math.Abs(hc) > Epsilon) + double factor = cDefaultMinReturnValue; + if (Math.Abs(hCritical) > cEpsilon) { - if (reducedFall <= 0) + factor = cDefaultMaxReturnValue; + // If actual headdrop is almost zero or smaller than zero then piping will be no problem + // The pipingfactor will be set to cDefaultMaxReturnValue + if (headDrop > 0 + cEpsilon) { - foSp = cDefaultMaxReturnValue; + factor = hCritical / headDrop; } - foSp = hc / reducedFall; } + return factor; } /// @@ -142,7 +145,7 @@ } } - private double GetReducedFall() + internal double GetReducedFall() { return HRiver - HExit - (Rc * DTotal); } Index: dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/Deltares.DamPiping.SellmeijerVNKCalculator.csproj =================================================================== diff -u -r371 -r374 --- dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/Deltares.DamPiping.SellmeijerVNKCalculator.csproj (.../Deltares.DamPiping.SellmeijerVNKCalculator.csproj) (revision 371) +++ dam failuremechanisms/damPiping/trunk/src/Deltares.DamPiping.SellmeijerVNKCalculator/Deltares.DamPiping.SellmeijerVNKCalculator.csproj (.../Deltares.DamPiping.SellmeijerVNKCalculator.csproj) (revision 374) @@ -44,6 +44,7 @@ Properties\GlobalAssemblyInfo.cs + Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.Sellmeijer4ForcesCalculatorTests/PipingCalculatorSellmeijer4ForcesTest.cs =================================================================== diff -u -r373 -r374 --- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.Sellmeijer4ForcesCalculatorTests/PipingCalculatorSellmeijer4ForcesTest.cs (.../PipingCalculatorSellmeijer4ForcesTest.cs) (revision 373) +++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.Sellmeijer4ForcesCalculatorTests/PipingCalculatorSellmeijer4ForcesTest.cs (.../PipingCalculatorSellmeijer4ForcesTest.cs) (revision 374) @@ -48,7 +48,6 @@ Assert.AreEqual(4.7596469835953883, calculator.Hc, diff); } - [Test] public void TestCanCalculateHCritical() { @@ -94,6 +93,58 @@ } [Test] + public void TestGetReducedFall() + { + // reduced fall = HRiver - HExit - (Rc * DTotal) + const double cTolerance = 0.01; + var calculator = new PipingCalculatorSellmeijer4Forces + { + HRiver = 1.0, + HExit = 0.0, + Rc = 0.3, + DTotal = 2.0, + }; + var reducedFall = calculator.GetReducedFall(); + Assert.AreEqual(0.40, reducedFall, cTolerance); + + calculator.HRiver = 0.0; + calculator.HExit = -2.0; + calculator.Rc = 0.2; + calculator.DTotal = 6.0; + reducedFall = calculator.GetReducedFall(); + Assert.AreEqual(0.80, reducedFall, cTolerance); + } + + [Test] + public void TestDetermineFactorOfSafety() + { + // foSp = hc / reducedFall + const double cTolerance = 0.01; + + var hCritical = 3.65; + var reducedFall = 1.00; + var safetyFactor = PipingCalculatorSellmeijer4Forces.DetermineFactorOfSafety(hCritical, reducedFall); + Assert.AreEqual(3.65, safetyFactor, cTolerance); + + hCritical = 3.65; + reducedFall = 2.00; + safetyFactor = PipingCalculatorSellmeijer4Forces.DetermineFactorOfSafety(hCritical, reducedFall); + Assert.AreEqual(1.825, safetyFactor, cTolerance); + + // reducedFall <= 0 result is cDefaultMaxReturnValue = 90.0; + hCritical = 3.65; + reducedFall = 0.00; + safetyFactor = PipingCalculatorSellmeijer4Forces.DetermineFactorOfSafety(hCritical, reducedFall); + Assert.AreEqual(90.0, safetyFactor, cTolerance); + + // hCritical = 0 result is cDefaultMinReturnValue = 0.0; + hCritical = 0.00; + reducedFall = 1.00; + safetyFactor = PipingCalculatorSellmeijer4Forces.DetermineFactorOfSafety(hCritical, reducedFall); + Assert.AreEqual(0.0, safetyFactor, cTolerance); + } + + [Test] public void TestTermAlpha() { var term = PipingCalculatorSellmeijer4Forces.TermAlpha(15.00, 3.0); @@ -227,7 +278,6 @@ CollectionAssert.AreEqual(new[] { expectedMessageEN }, errors); } - } } Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.SellmeijerVNKCalculatorTests/PipingCalculatorSellmeijerVNKTest.cs =================================================================== diff -u -r372 -r374 --- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.SellmeijerVNKCalculatorTests/PipingCalculatorSellmeijerVNKTest.cs (.../PipingCalculatorSellmeijerVNKTest.cs) (revision 372) +++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.SellmeijerVNKCalculatorTests/PipingCalculatorSellmeijerVNKTest.cs (.../PipingCalculatorSellmeijerVNKTest.cs) (revision 374) @@ -32,9 +32,9 @@ // reducedFall = HRiver - HExit = 1.0 - 0.0 = 1.0 // FoSp = Hc / reducedFall = 3.65 / 1.0 = 3.65 - // For calculation of Hc see TestCanCalculateHCritical - const double diff = 0.01; - var bc = new PipingCalculatorSellmeijerVNK + // Hc is calculated with external dll + const double cTolerance = 0.01; + var calculator = new PipingCalculatorSellmeijerVNK { HRiver = 1.0, HExit = 0.0, @@ -52,9 +52,9 @@ BeddingAngle = 37.0, WaterViscosity = 1.33E-06, }; - bc.Calculate(); - Assert.AreEqual(3.65, bc.FoSp, diff); - Assert.AreEqual(3.65, bc.Hc, diff); + calculator.Calculate(); + Assert.AreEqual(3.65, calculator.FoSp, cTolerance); + Assert.AreEqual(3.65, calculator.Hc, cTolerance); } [Test] @@ -83,9 +83,9 @@ // reducedFall = HRiver - HExit = 1.0 - 0.0 = 1.0 // FoSp = Hc / reducedFall = 4.13581 / 1.0 = 4.13581 - // For calculation of Hc see TestCanCalculateHCritical - const double diff = 0.00001; - var bc = new PipingCalculatorSellmeijerVNK + // Hc is calculated with external dll + const double cTolerance = 0.00001; + var calculator = new PipingCalculatorSellmeijerVNK { HRiver = 1.0, HExit = 0.0, @@ -103,9 +103,88 @@ BeddingAngle = 37.0, WaterViscosity = 1.33E-06, }; - bc.Calculate(); - Assert.AreEqual(4.13581, bc.FoSp, diff); - Assert.AreEqual(4.13581, bc.Hc, diff); + calculator.Calculate(); + Assert.AreEqual(4.13581, calculator.FoSp, cTolerance); + Assert.AreEqual(4.13581, calculator.Hc, cTolerance); } + + [Test] + public void TestCanCalculateHCritical() + { + // Hc is calculated with external dll + var calculator = new PipingCalculatorSellmeijerVNK + { + HRiver = 1.0, + HExit = 0.0, + PolderLevel = 0.0, + SurfaceLevel = 0.0, + Rc = 0.3, + DTotal = 2.0, + DInBetweenAquiferlayer = 2.0, + DBottomAquiferlayer = 6.0, + PermeabilityInBetweenAquiferlayer = 0.0001, + PermeabilityBottomAquiferlayer = 0.0002, + SeepageLength = 40.5, + D70 = 200.0, + WhitesConstant = 0.25, + BeddingAngle = 37.0, + WaterViscosity = 1.33E-06, + }; + var hCritical = calculator.CalculateHCritical(); + Assert.AreEqual(3.65, hCritical, 0.01); + + calculator.DInBetweenAquiferlayer = 4.0; + calculator.DBottomAquiferlayer = 4.0; + calculator.PermeabilityBottomAquiferlayer = 0.0001; + hCritical = calculator.CalculateHCritical(); + Assert.AreEqual(4.13581, hCritical, 0.00001); + } + + [Test] + public void TestGetReducedFall() + { + // reduced fall = HRiver - HExit + const double cTolerance = 0.01; + var calculator = new PipingCalculatorSellmeijerVNK + { + HRiver = 1.0, + HExit = 0.0, + }; + var reducedFall = calculator.GetReducedFall(); + Assert.AreEqual(1.00, reducedFall, cTolerance); + + calculator.HRiver = 0.0; + calculator.HExit = -2.0; + reducedFall = calculator.GetReducedFall(); + Assert.AreEqual(2.00, reducedFall, cTolerance); + } + public void TestDetermineFactorOfSafety() + { + // foSp = hc / reducedFall + const double cTolerance = 0.01; + + var hCritical = 3.65; + var reducedFall = 1.00; + var safetyFactor = PipingCalculatorSellmeijerVNK.DetermineFactorOfSafety(hCritical, reducedFall); + Assert.AreEqual(3.65, safetyFactor, cTolerance); + + hCritical = 3.65; + reducedFall = 2.00; + safetyFactor = PipingCalculatorSellmeijerVNK.DetermineFactorOfSafety(hCritical, reducedFall); + Assert.AreEqual(1.825, safetyFactor, cTolerance); + + // reducedFall <= 0 result is cDefaultMaxReturnValue = 90.0; + hCritical = 3.65; + reducedFall = 0.00; + safetyFactor = PipingCalculatorSellmeijerVNK.DetermineFactorOfSafety(hCritical, reducedFall); + Assert.AreEqual(90.0, safetyFactor, cTolerance); + + // hCritical = 0 result is cDefaultMinReturnValue = 0.0; + hCritical = 0.00; + reducedFall = 1.00; + safetyFactor = PipingCalculatorSellmeijerVNK.DetermineFactorOfSafety(hCritical, reducedFall); + Assert.AreEqual(0.0, safetyFactor, cTolerance); + } + } }