Exemplo n.º 1
0
        private static void SetInputParametersToEntity(SemiProbabilisticPipingCalculationEntity entity,
                                                       SemiProbabilisticPipingInput inputParameters,
                                                       PersistenceRegistry registry)
        {
            if (inputParameters.SurfaceLine != null)
            {
                entity.SurfaceLineEntity = registry.Get(inputParameters.SurfaceLine);
            }

            SetHydraulicBoundaryLocationInputToEntity(entity, inputParameters, registry);

            if (inputParameters.StochasticSoilProfile != null)
            {
                entity.PipingStochasticSoilProfileEntity = registry.Get(inputParameters.StochasticSoilProfile);
            }

            entity.ExitPointL  = inputParameters.ExitPointL.Value.ToNaNAsNull();
            entity.EntryPointL = inputParameters.EntryPointL.Value.ToNaNAsNull();

            entity.PhreaticLevelExitMean = inputParameters.PhreaticLevelExit.Mean.ToNaNAsNull();
            entity.PhreaticLevelExitStandardDeviation = inputParameters.PhreaticLevelExit.StandardDeviation.ToNaNAsNull();

            entity.DampingFactorExitMean = inputParameters.DampingFactorExit.Mean.ToNaNAsNull();
            entity.DampingFactorExitStandardDeviation = inputParameters.DampingFactorExit.StandardDeviation.ToNaNAsNull();
        }
Exemplo n.º 2
0
        private static void ReadInputParameters(SemiProbabilisticPipingInput inputParameters, SemiProbabilisticPipingCalculationEntity entity,
                                                ReadConversionCollector collector)
        {
            if (entity.SurfaceLineEntity != null)
            {
                inputParameters.SurfaceLine = entity.SurfaceLineEntity.ReadAsPipingSurfaceLine(collector);
            }

            inputParameters.UseAssessmentLevelManualInput = Convert.ToBoolean(entity.UseAssessmentLevelManualInput);
            inputParameters.AssessmentLevel = (RoundedDouble)entity.AssessmentLevel.ToNullAsNaN();

            if (entity.HydraulicLocationEntity != null)
            {
                inputParameters.HydraulicBoundaryLocation = entity.HydraulicLocationEntity.Read(collector);
            }

            if (entity.PipingStochasticSoilProfileEntity != null)
            {
                inputParameters.StochasticSoilModel   = entity.PipingStochasticSoilProfileEntity.StochasticSoilModelEntity.ReadAsPipingStochasticSoilModel(collector);
                inputParameters.StochasticSoilProfile = entity.PipingStochasticSoilProfileEntity.Read(collector);
            }

            inputParameters.EntryPointL            = (RoundedDouble)entity.EntryPointL.ToNullAsNaN();
            inputParameters.ExitPointL             = (RoundedDouble)entity.ExitPointL.ToNullAsNaN();
            inputParameters.PhreaticLevelExit.Mean = (RoundedDouble)entity.PhreaticLevelExitMean.ToNullAsNaN();
            inputParameters.PhreaticLevelExit.StandardDeviation = (RoundedDouble)entity.PhreaticLevelExitStandardDeviation.ToNullAsNaN();
            inputParameters.DampingFactorExit.Mean = (RoundedDouble)entity.DampingFactorExitMean.ToNullAsNaN();
            inputParameters.DampingFactorExit.StandardDeviation = (RoundedDouble)entity.DampingFactorExitStandardDeviation.ToNullAsNaN();
        }
        public void ParameteredConstructor_CalculationNull_ThrowsArgumentNullException()
        {
            // Setup
            var mocks             = new MockRepository();
            var assessmentSection = mocks.Stub <IAssessmentSection>();

            mocks.ReplayAll();

            var calculationInput = new SemiProbabilisticPipingInput();
            var surfaceLines     = new[]
            {
                new PipingSurfaceLine(string.Empty)
            };

            PipingStochasticSoilModel[] stochasticSoilModels =
            {
                PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel()
            };
            var failureMechanism = new PipingFailureMechanism();

            // Call
            TestDelegate call = () => new SemiProbabilisticPipingInputContext(calculationInput, null, surfaceLines, stochasticSoilModels, failureMechanism, assessmentSection);

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

            Assert.AreEqual("calculation", exception.ParamName);
            mocks.VerifyAll();
        }
Exemplo n.º 4
0
        /// <summary>
        /// This method sets random data values to all properties of <paramref name="input"/>.
        /// </summary>
        /// <param name="input">The input to set the random data values to.</param>
        public static void SetRandomDataToPipingInput(SemiProbabilisticPipingInput input)
        {
            SetRandomDataToPipingInput((PipingInput)input);

            var random = new Random(21);

            input.UseAssessmentLevelManualInput = random.NextBoolean();
            input.AssessmentLevel = random.NextRoundedDouble();
        }
        public void Constructor_ExpectedValues()
        {
            // Call
            var inputParameters = new SemiProbabilisticPipingInput();

            // Assert
            Assert.IsInstanceOf <PipingInput>(inputParameters);

            Assert.IsNaN(inputParameters.AssessmentLevel);
            Assert.AreEqual(2, inputParameters.AssessmentLevel.NumberOfDecimalPlaces);
            Assert.IsFalse(inputParameters.UseAssessmentLevelManualInput);
        }
Exemplo n.º 6
0
        private static void SetHydraulicBoundaryLocationInputToEntity(SemiProbabilisticPipingCalculationEntity entity,
                                                                      SemiProbabilisticPipingInput inputParameters,
                                                                      PersistenceRegistry registry)
        {
            entity.UseAssessmentLevelManualInput = Convert.ToByte(inputParameters.UseAssessmentLevelManualInput);
            entity.AssessmentLevel = inputParameters.AssessmentLevel.ToNaNAsNull();

            if (inputParameters.HydraulicBoundaryLocation != null)
            {
                entity.HydraulicLocationEntity = registry.Get(inputParameters.HydraulicBoundaryLocation);
            }
        }
 private static void ToSemiProbabilisticConfiguration(PipingCalculationConfiguration calculationConfiguration,
                                                      SemiProbabilisticPipingInput input)
 {
     if (input.UseAssessmentLevelManualInput)
     {
         calculationConfiguration.AssessmentLevel = input.AssessmentLevel;
     }
     else if (input.HydraulicBoundaryLocation != null)
     {
         calculationConfiguration.HydraulicBoundaryLocationName = input.HydraulicBoundaryLocation.Name;
     }
 }
        public void Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues()
        {
            // Setup
            var original = new SemiProbabilisticPipingInput();

            PipingTestDataGenerator.SetRandomDataToPipingInput(original);

            // Call
            object clone = original.Clone();

            // Assert
            CoreCloneAssert.AreObjectClones(original, clone, PipingCloneAssert.AreClones);
        }
        private static List <string> ValidateInput(SemiProbabilisticPipingInput input, GeneralPipingInput generalInput, RoundedDouble normativeAssessmentLevel)
        {
            var validationResults = new List <string>();

            validationResults.AddRange(ValidateHydraulics(input, normativeAssessmentLevel));
            validationResults.AddRange(PipingCalculationValidationHelper.GetValidationErrors(input));

            if (!validationResults.Any())
            {
                validationResults.AddRange(ValidateCoverageLayers(input, generalInput));
            }

            return(validationResults);
        }
        public void AssessmentLevel_SetToNew_ValueIsRounded()
        {
            // Setup
            const double assessmentLevel = 1.111111;
            var          input           = new SemiProbabilisticPipingInput();

            int originalNumberOfDecimalPlaces = input.AssessmentLevel.NumberOfDecimalPlaces;

            // Call
            input.AssessmentLevel = (RoundedDouble)assessmentLevel;

            // Assert
            Assert.AreEqual(originalNumberOfDecimalPlaces, input.AssessmentLevel.NumberOfDecimalPlaces);
            Assert.AreEqual(assessmentLevel, input.AssessmentLevel, input.AssessmentLevel.GetAccuracy());
        }
        private static IEnumerable <string> ValidateAssessmentLevel(SemiProbabilisticPipingInput input, RoundedDouble normativeAssessmentLevel)
        {
            var validationResult = new List <string>();

            if (input.UseAssessmentLevelManualInput)
            {
                validationResult.AddRange(new NumericInputRule(input.AssessmentLevel, ParameterNameExtractor.GetFromDisplayName(RiskeerCommonFormsResources.WaterLevel_DisplayName)).Validate());
            }
            else
            {
                if (double.IsNaN(normativeAssessmentLevel))
                {
                    validationResult.Add(RiskeerCommonServiceResources.CalculationService_ValidateInput_Cannot_determine_AssessmentLevel);
                }
            }

            return(validationResult);
        }
            protected override void AssertPipingCalculationScenario(SemiProbabilisticPipingCalculationScenario expectedCalculation,
                                                                    SemiProbabilisticPipingCalculationScenario actualCalculation)
            {
                AssertPipingCalculationScenarioGenericProperties(expectedCalculation, actualCalculation);

                SemiProbabilisticPipingInput expectedInput = expectedCalculation.InputParameters;
                SemiProbabilisticPipingInput actualInput   = actualCalculation.InputParameters;

                Assert.AreEqual(expectedInput.UseAssessmentLevelManualInput, actualInput.UseAssessmentLevelManualInput);
                if (expectedInput.UseAssessmentLevelManualInput)
                {
                    Assert.AreEqual(expectedInput.AssessmentLevel, actualInput.AssessmentLevel);
                }
                else
                {
                    Assert.AreSame(expectedInput.HydraulicBoundaryLocation, actualInput.HydraulicBoundaryLocation);
                }
            }
        public void Clone_NotAllPropertiesSet_ReturnNewInstanceWithCopiedValues()
        {
            // Setup
            var original = new SemiProbabilisticPipingInput();

            PipingTestDataGenerator.SetRandomDataToPipingInput(original);

            original.SurfaceLine               = null;
            original.StochasticSoilModel       = null;
            original.StochasticSoilProfile     = null;
            original.HydraulicBoundaryLocation = null;

            // Call
            object clone = original.Clone();

            // Assert
            CoreCloneAssert.AreObjectClones(original, clone, PipingCloneAssert.AreClones);
        }
        private static IEnumerable <string> ValidateHydraulics(SemiProbabilisticPipingInput input, RoundedDouble normativeAssessmentLevel)
        {
            var validationResults = new List <string>();

            if (!input.UseAssessmentLevelManualInput && input.HydraulicBoundaryLocation == null)
            {
                validationResults.Add(RiskeerCommonServiceResources.CalculationService_ValidateInput_No_hydraulic_boundary_location_selected);
            }
            else
            {
                validationResults.AddRange(ValidateAssessmentLevel(input, normativeAssessmentLevel));

                RoundedDouble piezometricHeadExit = DerivedSemiProbabilisticPipingInput.GetPiezometricHeadExit(input, GetEffectiveAssessmentLevel(input, normativeAssessmentLevel));
                if (double.IsNaN(piezometricHeadExit) || double.IsInfinity(piezometricHeadExit))
                {
                    validationResults.Add(Resources.SemiProbabilisticPipingCalculationService_ValidateInput_Cannot_determine_PiezometricHeadExit);
                }
            }

            return(validationResults);
        }
Exemplo n.º 15
0
        public void GetViewData_WithContext_ReturnsWrappedCalculation()
        {
            // Setup
            var assessmentSection = mocks.Stub <IAssessmentSection>();

            mocks.ReplayAll();

            var pipingInput = new SemiProbabilisticPipingInput();

            var calculation             = new SemiProbabilisticPipingCalculationScenario();
            var calculationInputContext = new SemiProbabilisticPipingInputContext(pipingInput, calculation, Enumerable.Empty <PipingSurfaceLine>(),
                                                                                  Enumerable.Empty <PipingStochasticSoilModel>(),
                                                                                  new PipingFailureMechanism(),
                                                                                  assessmentSection);

            // Call
            object viewData = info.GetViewData(calculationInputContext);

            // Assert
            Assert.AreSame(calculation, viewData);
            mocks.VerifyAll();
        }
        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
            }));
        }
 private static RoundedDouble GetEffectiveAssessmentLevel(SemiProbabilisticPipingInput input, RoundedDouble normativeAssessmentLevel)
 {
     return(input.UseAssessmentLevelManualInput
                ? input.AssessmentLevel
                : normativeAssessmentLevel);
 }
Exemplo n.º 18
0
        public void Create_SemiProbabilisticPipingCalculationScenarioWithPropertiesSet_ReturnSemiProbabilisticPipingCalculationEntity(
            bool isRelevant, bool useAssessmentLevelManualInput, double contribution, string name, string comments,
            double exitPoint, double entryPoint, double assessmentLevel, int order, int randomSeed)
        {
            // Setup
            var random = new Random(randomSeed);

            var calculation = new SemiProbabilisticPipingCalculationScenario
            {
                IsRelevant   = isRelevant,
                Contribution = (RoundedDouble)contribution,
                Name         = name,
                Comments     =
                {
                    Body = comments
                },
                InputParameters =
                {
                    ExitPointL        = (RoundedDouble)exitPoint,
                    EntryPointL       = (RoundedDouble)entryPoint,
                    PhreaticLevelExit =
                    {
                        Mean                      = random.NextRoundedDouble(-9999.9999, 9999.9999),
                        StandardDeviation         = random.NextRoundedDouble(1e-6,             9999.9999)
                    },
                    DampingFactorExit             =
                    {
                        Mean                      = random.NextRoundedDouble(1e-6,       9999.9999),
                        StandardDeviation         = random.NextRoundedDouble(1e-6, 9999.9999)
                    },
                    UseAssessmentLevelManualInput = useAssessmentLevelManualInput,
                    AssessmentLevel               = (RoundedDouble)assessmentLevel
                }
            };

            var registry = new PersistenceRegistry();

            // Call
            SemiProbabilisticPipingCalculationEntity entity = calculation.Create(registry, order);

            // Assert
            Assert.AreEqual(Convert.ToByte(isRelevant), entity.RelevantForScenario);
            Assert.AreEqual(calculation.Contribution, entity.ScenarioContribution);
            Assert.AreEqual(name, entity.Name);
            Assert.AreEqual(comments, entity.Comments);

            Assert.AreEqual(exitPoint.ToNaNAsNull(), entity.ExitPointL);
            Assert.AreEqual(entryPoint.ToNaNAsNull(), entity.EntryPointL);

            SemiProbabilisticPipingInput input = calculation.InputParameters;

            Assert.AreEqual(input.PhreaticLevelExit.Mean.Value, entity.PhreaticLevelExitMean);
            Assert.AreEqual(input.PhreaticLevelExit.StandardDeviation.Value, entity.PhreaticLevelExitStandardDeviation);
            Assert.AreEqual(input.DampingFactorExit.Mean.Value, entity.DampingFactorExitMean);
            Assert.AreEqual(input.DampingFactorExit.StandardDeviation.Value, entity.DampingFactorExitStandardDeviation);

            Assert.AreEqual(Convert.ToByte(input.UseAssessmentLevelManualInput), entity.UseAssessmentLevelManualInput);
            Assert.AreEqual(input.AssessmentLevel.ToNaNAsNull(), entity.AssessmentLevel);

            Assert.AreEqual(order, entity.Order);
            Assert.AreEqual(0, entity.SemiProbabilisticPipingCalculationEntityId);
            Assert.IsNull(entity.CalculationGroupEntity);

            Assert.IsNull(entity.SurfaceLineEntity);
            Assert.IsNull(entity.PipingStochasticSoilProfileEntity);
            Assert.IsNull(entity.HydraulicLocationEntity);
            CollectionAssert.IsEmpty(entity.SemiProbabilisticPipingCalculationOutputEntities);
        }
Exemplo n.º 19
0
 /// <summary>
 /// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
 /// are clones.
 /// </summary>
 /// <param name="original">The original object.</param>
 /// <param name="clone">The cloned object.</param>
 /// <exception cref="AssertionException">Thrown when <paramref name="original"/> and
 /// <paramref name="clone"/> are not clones.</exception>
 public static void AreClones(SemiProbabilisticPipingInput original, SemiProbabilisticPipingInput clone)
 {
     AreClones((PipingInput)original, clone);
     Assert.AreEqual(original.AssessmentLevel, clone.AssessmentLevel);
     Assert.AreEqual(original.UseAssessmentLevelManualInput, clone.UseAssessmentLevelManualInput);
 }