public static void CalculatePiezometricHeadAtExit_CompleteInput_InputSetOnSubCalculator()
        {
            // Setup
            RoundedDouble assessmentLevel        = new Random(21).NextRoundedDouble();
            var           validPipingCalculation =
                SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>(
                    new TestHydraulicBoundaryLocation());
            PipingInput input = validPipingCalculation.InputParameters;

            using (new PipingSubCalculatorFactoryConfig())
            {
                // Call
                InputParameterCalculationService.CalculatePiezometricHeadAtExit(
                    assessmentLevel,
                    SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(),
                    PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue());

                // Assert
                var testFactory = (TestPipingSubCalculatorFactory)PipingSubCalculatorFactory.Instance;
                PiezoHeadCalculatorStub piezometricHeadAtExitCalculator = testFactory.LastCreatedPiezometricHeadAtExitCalculator;

                Assert.AreEqual(assessmentLevel.Value, piezometricHeadAtExitCalculator.HRiver);
                Assert.AreEqual(PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(),
                                piezometricHeadAtExitCalculator.PhiPolder,
                                input.PhreaticLevelExit.GetAccuracy());
                Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(),
                                piezometricHeadAtExitCalculator.RExit,
                                input.DampingFactorExit.GetAccuracy());
            }
        }
Example #2
0
        public void GetPiezometricHeadExit_ValidInput_SetsParametersForCalculatorAndReturnsNotNaN()
        {
            // Setup
            var input = new TestPipingInput();

            using (new PipingSubCalculatorFactoryConfig())
            {
                // Setup
                var assessmentLevel = (RoundedDouble)1.1;

                // Call
                RoundedDouble piezometricHead = DerivedSemiProbabilisticPipingInput.GetPiezometricHeadExit(input, assessmentLevel);

                // Assert
                Assert.AreEqual(2, piezometricHead.NumberOfDecimalPlaces);
                Assert.IsFalse(double.IsNaN(piezometricHead));

                var factory = (TestPipingSubCalculatorFactory)PipingSubCalculatorFactory.Instance;
                PiezoHeadCalculatorStub piezometricHeadAtExitCalculator = factory.LastCreatedPiezometricHeadAtExitCalculator;

                Assert.AreEqual(assessmentLevel, piezometricHeadAtExitCalculator.HRiver, assessmentLevel.GetAccuracy());
                Assert.AreEqual(PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.PhiPolder,
                                input.PhreaticLevelExit.GetAccuracy());
                Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.RExit,
                                input.DampingFactorExit.GetAccuracy());
            }
        }
        public void GetDampingFactorExit_PipingInputNull_ThrowsArgumentNullException()
        {
            // Call
            void Call() => SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(null);

            // Assert
            var exception = Assert.Throws <ArgumentNullException>(Call);

            Assert.AreEqual("pipingInput", exception.ParamName);
        }
        public void GetDampingFactorExit_ValidPipingInput_CreateDesignVariableForDampingFactorExit()
        {
            // Setup
            var pipingInput = new TestPipingInput();

            // Call
            DesignVariable <LogNormalDistribution> dampingFactorExit =
                SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(pipingInput);

            // Assert
            Assert.AreSame(pipingInput.DampingFactorExit, dampingFactorExit.Distribution);
            AssertPercentile(0.95, dampingFactorExit);
        }
        public static void CalculatePiezometricHeadAtExit_Always_ReturnsResult()
        {
            // Setup
            var input = new TestPipingInput();

            // Call
            double result = InputParameterCalculationService.CalculatePiezometricHeadAtExit(
                (RoundedDouble)0.0,
                SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(),
                PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue());

            // Assert
            Assert.IsFalse(double.IsNaN(result));
        }
        private static PipingCalculatorInput CreateInputFromData(SemiProbabilisticPipingInput input,
                                                                 GeneralPipingInput generalPipingInput,
                                                                 RoundedDouble normativeAssessmentLevel)
        {
            RoundedDouble effectiveAssessmentLevel = GetEffectiveAssessmentLevel(input, normativeAssessmentLevel);

            return(new PipingCalculatorInput(
                       new PipingCalculatorInput.ConstructionProperties
            {
                WaterVolumetricWeight = generalPipingInput.WaterVolumetricWeight,
                SaturatedVolumicWeightOfCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetSaturatedVolumicWeightOfCoverageLayer(input).GetDesignValue(),
                UpliftModelFactor = SemiProbabilisticPipingDesignVariableFactory.GetUpliftModelFactorDesignVariable(generalPipingInput).GetDesignValue(),
                AssessmentLevel = effectiveAssessmentLevel,
                PiezometricHeadExit = DerivedSemiProbabilisticPipingInput.GetPiezometricHeadExit(input, effectiveAssessmentLevel),
                DampingFactorExit = SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(),
                PhreaticLevelExit = PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(),
                CriticalHeaveGradient = SemiProbabilisticPipingDesignVariableFactory.GetCriticalHeaveGradientDesignVariable(generalPipingInput).GetDesignValue(),
                ThicknessCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetThicknessCoverageLayer(input).GetDesignValue(),
                EffectiveThicknessCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetEffectiveThicknessCoverageLayer(input, generalPipingInput).GetDesignValue(),
                SellmeijerModelFactor = SemiProbabilisticPipingDesignVariableFactory.GetSellmeijerModelFactorDesignVariable(generalPipingInput).GetDesignValue(),
                SellmeijerReductionFactor = generalPipingInput.SellmeijerReductionFactor,
                SeepageLength = SemiProbabilisticPipingDesignVariableFactory.GetSeepageLength(input).GetDesignValue(),
                SandParticlesVolumicWeight = generalPipingInput.SandParticlesVolumicWeight,
                WhitesDragCoefficient = generalPipingInput.WhitesDragCoefficient,
                Diameter70 = SemiProbabilisticPipingDesignVariableFactory.GetDiameter70(input).GetDesignValue(),
                DarcyPermeability = SemiProbabilisticPipingDesignVariableFactory.GetDarcyPermeability(input).GetDesignValue(),
                WaterKinematicViscosity = generalPipingInput.WaterKinematicViscosity,
                Gravity = generalPipingInput.Gravity,
                ThicknessAquiferLayer = SemiProbabilisticPipingDesignVariableFactory.GetThicknessAquiferLayer(input).GetDesignValue(),
                MeanDiameter70 = generalPipingInput.MeanDiameter70,
                BeddingAngle = generalPipingInput.BeddingAngle,
                ExitPointXCoordinate = input.ExitPointL,
                SurfaceLine = input.SurfaceLine,
                SoilProfile = input.StochasticSoilProfile?.SoilProfile
            }));
        }