/// <summary> /// Asserts whether the <see cref="PersistableDataModel"/> contains the data /// that is representative for the <paramref name="calculation"/> /// and the <paramref name="filePath"/>. /// </summary> /// <param name="calculation">The calculation that contains the original data.</param> /// <param name="filePath">The file path that is used.</param> /// <param name="persistableDataModel">The <see cref="PersistableDataModel"/> that needs to be asserted.</param> /// <exception cref="AssertionException">Thrown when the data in <paramref name="persistableDataModel"/> /// is not correct.</exception> public static void AssertPersistableDataModel(MacroStabilityInwardsCalculation calculation, string filePath, PersistableDataModel persistableDataModel) { AssertProjectInfo(calculation, filePath, persistableDataModel.Info); AssertCalculationSettings(calculation.Output.SlidingCurve, persistableDataModel.CalculationSettings); IEnumerable <MacroStabilityInwardsSoilLayer2D> layers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(calculation.InputParameters.SoilProfileUnderSurfaceLine.Layers); AssertPersistableSoils(layers, persistableDataModel.Soils.Soils); AssertPersistableGeometry(layers, persistableDataModel.Geometry); AssertPersistableSoilLayers(layers, persistableDataModel.SoilLayers, persistableDataModel.Soils.Soils, persistableDataModel.Geometry); AssertWaternets(new[] { DerivedMacroStabilityInwardsInput.GetWaternetDaily(calculation.InputParameters, new GeneralMacroStabilityInwardsInput()), DerivedMacroStabilityInwardsInput.GetWaternetExtreme(calculation.InputParameters, new GeneralMacroStabilityInwardsInput(), RoundedDouble.NaN) }, persistableDataModel.Waternets); AssertWaternetCreatorSettings(calculation.InputParameters, persistableDataModel.WaternetCreatorSettings, AssessmentSectionTestHelper.GetTestAssessmentLevel(), new[] { MacroStabilityInwardsExportStageType.Daily, MacroStabilityInwardsExportStageType.Extreme }); AssertStates(calculation.InputParameters.SoilProfileUnderSurfaceLine, persistableDataModel.States); Assert.IsNull(persistableDataModel.AssessmentResults); Assert.IsNull(persistableDataModel.Decorations); Assert.IsNull(persistableDataModel.Loads); Assert.IsNull(persistableDataModel.NailPropertiesForSoils); Assert.IsNull(persistableDataModel.Reinforcements); Assert.IsNull(persistableDataModel.SoilCorrelations); Assert.IsNull(persistableDataModel.SoilVisualizations); Assert.IsNull(persistableDataModel.StateCorrelations); AssertStages(persistableDataModel.Stages, persistableDataModel.CalculationSettings, persistableDataModel.Geometry, persistableDataModel.SoilLayers, persistableDataModel.Waternets, persistableDataModel.WaternetCreatorSettings, persistableDataModel.States); }
public void Create_WithSoilProfile_ReturnsPersistableSoilCollection(MacroStabilityInwardsShearStrengthModel shearStrengthModel) { // Setup var soilProfile = new MacroStabilityInwardsSoilProfileUnderSurfaceLine( new[] { MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D(new[] { MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D() }) }, Enumerable.Empty <IMacroStabilityInwardsPreconsolidationStress>()); var registry = new MacroStabilityInwardsExportRegistry(); IEnumerable <MacroStabilityInwardsSoilLayer2D> originalLayers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(soilProfile.Layers); originalLayers.ForEachElementDo(layer => layer.Data.ShearStrengthModel = shearStrengthModel); // Call PersistableSoilCollection soilCollection = PersistableSoilCollectionFactory.Create(soilProfile, new IdFactory(), registry); // Assert IEnumerable <PersistableSoil> actualSoils = soilCollection.Soils; PersistableDataModelTestHelper.AssertPersistableSoils(originalLayers, actualSoils); Assert.AreEqual(actualSoils.Count(), registry.Soils.Count); for (var i = 0; i < originalLayers.Count(); i++) { KeyValuePair <MacroStabilityInwardsSoilLayer2D, string> registrySoil = registry.Soils.ElementAt(i); Assert.AreSame(originalLayers.ElementAt(i), registrySoil.Key); Assert.AreEqual(actualSoils.ElementAt(i).Id, registrySoil.Value); } }
/// <summary> /// Creates a new instance of <see cref="PersistableSoilCollection"/>. /// </summary> /// <param name="soilProfile">The soil profile to use.</param> /// <param name="idFactory">The factory for creating IDs.</param> /// <param name="registry">The persistence registry.</param> /// <returns>The created <see cref="PersistableSoilCollection"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception> /// <exception cref="InvalidEnumArgumentException">Thrown when /// <see cref="MacroStabilityInwardsShearStrengthModel"/> has an invalid value.</exception> /// <exception cref="NotSupportedException">Thrown when <see cref="MacroStabilityInwardsShearStrengthModel"/> /// has a valid value but is not supported.</exception> public static PersistableSoilCollection Create(IMacroStabilityInwardsSoilProfileUnderSurfaceLine soilProfile, IdFactory idFactory, MacroStabilityInwardsExportRegistry registry) { if (soilProfile == null) { throw new ArgumentNullException(nameof(soilProfile)); } if (idFactory == null) { throw new ArgumentNullException(nameof(idFactory)); } if (registry == null) { throw new ArgumentNullException(nameof(registry)); } return(new PersistableSoilCollection { Soils = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(soilProfile.Layers) .Select(l => Create(l, idFactory, registry)) .ToArray() }); }
public void GetLayersRecursively_LayersNull_ReturnsEmptyCollection() { // Call IEnumerable <MacroStabilityInwardsSoilLayer2D> layers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(null); // Assert CollectionAssert.IsEmpty(layers); }
private static PersistableGeometry CreateGeometry(IMacroStabilityInwardsSoilProfileUnderSurfaceLine soilProfile, MacroStabilityInwardsExportStageType stageType, IdFactory idFactory, MacroStabilityInwardsExportRegistry registry) { var geometry = new PersistableGeometry { Id = idFactory.Create(), Layers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(soilProfile.Layers) .Select(l => CreateLayer(l, stageType, idFactory, registry)) .ToArray() }; registry.AddGeometry(stageType, geometry.Id); return(geometry); }
private static PersistableSoilLayerCollection CreateSoilLayerCollection(IMacroStabilityInwardsSoilProfileUnderSurfaceLine soilProfile, MacroStabilityInwardsExportStageType stageType, IdFactory idFactory, MacroStabilityInwardsExportRegistry registry) { var soilLayerCollection = new PersistableSoilLayerCollection { Id = idFactory.Create(), SoilLayers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(soilProfile.Layers) .Select(l => Create(l, stageType, registry)) .ToArray() }; registry.AddSoilLayer(stageType, soilLayerCollection.Id); return(soilLayerCollection); }
/// <summary> /// Asserts whether the <see cref="PersistableState"/> contains the data /// that is representative for the <paramref name="soilProfile"/>. /// </summary> /// <param name="soilProfile">The input that contains the original data.</param> /// <param name="states">The <see cref="PersistableState"/> /// that needs to be asserted.</param> /// <exception cref="AssertionException">Thrown when the data in <paramref name="states"/> /// is not correct.</exception> public static void AssertStates(IMacroStabilityInwardsSoilProfileUnderSurfaceLine soilProfile, IEnumerable <PersistableState> states) { Assert.AreEqual(1, states.Count()); IEnumerable <MacroStabilityInwardsSoilLayer2D> layers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(soilProfile.Layers); for (var i = 0; i < states.Count(); i++) { PersistableState state = states.ElementAt(i); Assert.IsNotNull(state.Id); CollectionAssert.IsEmpty(state.StateLines); AssertPopStatePoints(layers, state.StatePoints.Where(sp => sp.Stress.StateType == PersistableStateType.Pop)); AssertYieldStressStatePoints(layers, soilProfile.PreconsolidationStresses, state.StatePoints.Where(sp => sp.Stress.StateType == PersistableStateType.YieldStress)); } }
/// <summary> /// Indicator whether a <paramref name="soilProfile"/> has valid state points. /// </summary> /// <param name="soilProfile">The <see cref="IMacroStabilityInwardsSoilProfileUnderSurfaceLine"/> to get the state points from.</param> /// <returns><c>true</c> when every layer in <paramref name="soilProfile"/> has max. 1 state point; <c>false</c> otherwise.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="soilProfile"/> is <c>null</c>.</exception> public static bool HasValidStatePoints(IMacroStabilityInwardsSoilProfileUnderSurfaceLine soilProfile) { if (soilProfile == null) { throw new ArgumentNullException(nameof(soilProfile)); } MacroStabilityInwardsSoilLayer2D[] layers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(soilProfile.Layers).ToArray(); Dictionary <IMacroStabilityInwardsPreconsolidationStress, MacroStabilityInwardsSoilLayer2D> stressesWithLayers = soilProfile.PreconsolidationStresses.ToDictionary(pcs => pcs, pcs => GetLayerForPreconsolidationStress(layers, pcs)); IEnumerable <IGrouping <MacroStabilityInwardsSoilLayer2D, IMacroStabilityInwardsPreconsolidationStress> > duplicateLayers = stressesWithLayers.ToLookup(pair => pair.Value, pair => pair.Key).Where(x => x.Count() > 1); return(!duplicateLayers.Any() && stressesWithLayers.All(pair => pair.Value != null) && !stressesWithLayers.Any(stressWithLayer => stressWithLayer.Value.Data.UsePop && HasValidPop(stressWithLayer.Value.Data.Pop))); }
private void ValidateData() { if (Math.Abs(calculation.InputParameters.MaximumSliceWidth - 1) > 1e-3) { LogWarning(string.Format(Resources.MacroStabilityInwardsCalculationExporter_ValidateData_DGeoSuite_only_supports_MaximumSliceWidth_one_but_calculation_has_MaximumSliceWidth_0, calculation.InputParameters.MaximumSliceWidth.ToString(null, CultureInfo.CurrentCulture))); } MacroStabilityInwardsSoilLayer2D[] layers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(calculation.InputParameters.SoilProfileUnderSurfaceLine.Layers).ToArray(); if (layers.Count(l => l.Data.IsAquifer) > 1) { LogWarning(Resources.MacroStabilityInwardsCalculationExporter_ValidateData_Multiple_aquifer_layers_not_supported_no_aquifer_layer_exported); } if (!PersistableStateHelper.HasValidStatePoints(calculation.InputParameters.SoilProfileUnderSurfaceLine)) { LogWarning(Resources.MacroStabilityInwardsCalculationExporter_ValidateData_Multiple_stress_points_not_supported_no_stress_points_exported); } }
public void Create_WithValidData_ReturnsNull() { // Setup var soilProfile = new MacroStabilityInwardsSoilProfileUnderSurfaceLine(new[] { MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D(new[] { MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D() }) }, Enumerable.Empty <IMacroStabilityInwardsPreconsolidationStress>()); var registry = new MacroStabilityInwardsExportRegistry(); // Call IEnumerable <PersistableGeometry> geometries = PersistableGeometryFactory.Create(soilProfile, new IdFactory(), registry); // Assert IEnumerable <MacroStabilityInwardsSoilLayer2D> layersRecursively = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(soilProfile.Layers); PersistableDataModelTestHelper.AssertPersistableGeometry(layersRecursively, geometries); AssertRegistry(registry, geometries, layersRecursively); }
private static PersistableState Create(IMacroStabilityInwardsSoilProfileUnderSurfaceLine soilProfile, MacroStabilityInwardsExportStageType stageType, IdFactory idFactory, MacroStabilityInwardsExportRegistry registry) { MacroStabilityInwardsSoilLayer2D[] layers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(soilProfile.Layers).ToArray(); var statePoints = new List <PersistableStatePoint>(); if (PersistableStateHelper.HasValidStatePoints(soilProfile)) { statePoints.AddRange(layers.Where(l => l.Data.UsePop && PersistableStateHelper.HasValidPop(l.Data.Pop)) .Select(l => CreatePOPStatePoint(l, stageType, idFactory, registry)) .ToArray()); var preconsolidationStressPoints = new List <PersistableStatePoint>(); foreach (IMacroStabilityInwardsPreconsolidationStress preconsolidationStress in soilProfile.PreconsolidationStresses) { MacroStabilityInwardsSoilLayer2D layer = PersistableStateHelper.GetLayerForPreconsolidationStress(layers, preconsolidationStress); if (layer != null) { preconsolidationStressPoints.Add( CreateYieldStressStatePoint(layer, preconsolidationStress, stageType, idFactory, registry)); } } statePoints.AddRange(preconsolidationStressPoints); } var state = new PersistableState { Id = idFactory.Create(), StateLines = Enumerable.Empty <PersistableStateLine>(), StatePoints = statePoints }; registry.AddState(stageType, state.Id); return(state); }
/// <summary> /// Creates a new <see cref="PersistableWaternetCreatorSettings"/>. /// </summary> /// <param name="input">The input to use.</param> /// <param name="idFactory">The factory for creating IDs.</param> /// <param name="registry">The persistence registry.</param> /// <param name="stageType">The stage type.</param> /// <returns>The created <see cref="PersistableWaternetCreatorSettings"/>.</returns> /// <exception cref="InvalidEnumArgumentException">Thrown when <see cref="IMacroStabilityInwardsWaternetInput.DikeSoilScenario"/> /// has an invalid value for <see cref="MacroStabilityInwardsDikeSoilScenario"/>.</exception> /// <exception cref="NotSupportedException">Thrown when <see cref="IMacroStabilityInwardsWaternetInput.DikeSoilScenario"/> /// is not supported.</exception> private static PersistableWaternetCreatorSettings Create(IMacroStabilityInwardsWaternetInput input, IdFactory idFactory, MacroStabilityInwardsExportRegistry registry, MacroStabilityInwardsExportStageType stageType) { bool isDitchPresent = IsDitchPresent(input.SurfaceLine); var waternetCreatorSettings = new PersistableWaternetCreatorSettings { Id = idFactory.Create(), InitialLevelEmbankmentTopWaterSide = input.MinimumLevelPhreaticLineAtDikeTopRiver, InitialLevelEmbankmentTopLandSide = input.MinimumLevelPhreaticLineAtDikeTopPolder, AdjustForUplift = input.AdjustPhreaticLine3And4ForUplift, PleistoceneLeakageLengthOutwards = input.LeakageLengthOutwardsPhreaticLine3, PleistoceneLeakageLengthInwards = input.LeakageLengthInwardsPhreaticLine3, AquiferLayerInsideAquitardLeakageLengthOutwards = input.LeakageLengthOutwardsPhreaticLine4, AquiferLayerInsideAquitardLeakageLengthInwards = input.LeakageLengthInwardsPhreaticLine4, AquitardHeadWaterSide = input.PiezometricHeadPhreaticLine2Outwards, AquitardHeadLandSide = input.PiezometricHeadPhreaticLine2Inwards, MeanWaterLevel = input.WaterLevelRiverAverage, IsDrainageConstructionPresent = input.DrainageConstructionPresent, DrainageConstruction = new PersistablePoint(input.XCoordinateDrainageConstruction, input.ZCoordinateDrainageConstruction), IsDitchPresent = isDitchPresent, DitchCharacteristics = CreateDitchCharacteristics(input.SurfaceLine, isDitchPresent), EmbankmentCharacteristics = CreateEmbankmentCharacteristics(input.SurfaceLine), EmbankmentSoilScenario = CreateEmbankmentSoilScenario(input.DikeSoilScenario), IsAquiferLayerInsideAquitard = false }; IEnumerable <MacroStabilityInwardsSoilLayer2D> aquiferLayers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(input.SoilProfileUnderSurfaceLine.Layers) .Where(l => l.Data.IsAquifer); if (aquiferLayers.Count() == 1) { waternetCreatorSettings.AquiferLayerId = registry.GeometryLayers[stageType][aquiferLayers.Single()]; } registry.AddWaternetCreatorSettings(stageType, waternetCreatorSettings.Id); return(waternetCreatorSettings); }
/// <summary> /// Asserts whether <paramref name="actual"/> corresponds to <paramref name="soilProfileUnderSurface"/>, /// <paramref name="expectedName"/> and <paramref name="mapDataShouldContainAreas"/>. /// </summary> /// <param name="soilProfileUnderSurface">The <see cref="IMacroStabilityInwardsSoilProfileUnderSurfaceLine"/> /// that should be represented as series in <paramref name="actual"/>.</param> /// <param name="expectedName">The expected name of <paramref name="actual"/>.</param> /// <param name="mapDataShouldContainAreas">Indicator whether areas should be present.</param> /// <param name="actual">The actual <see cref="ChartData"/>.</param> /// <exception cref="AssertionException">Thrown when <paramref name="actual"/> does not correspond /// to <paramref name="soilProfileUnderSurface"/>, <paramref name="expectedName"/> or /// <paramref name="mapDataShouldContainAreas"/>.</exception> public static void AssertSoilProfileChartData(IMacroStabilityInwardsSoilProfileUnderSurfaceLine soilProfileUnderSurface, string expectedName, bool mapDataShouldContainAreas, ChartData actual) { Assert.IsInstanceOf <ChartDataCollection>(actual); var soilProfileChartData = (ChartDataCollection)actual; MacroStabilityInwardsSoilLayer2D[] layers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(soilProfileUnderSurface?.Layers).ToArray(); int expectedLayerCount = layers.Length; Assert.AreEqual(expectedLayerCount, soilProfileChartData.Collection.Count()); Assert.AreEqual(expectedName, soilProfileChartData.Name); for (var i = 0; i < expectedLayerCount; i++) { var chartMultipleAreaData = soilProfileChartData.Collection.ElementAt(i) as ChartMultipleAreaData; Assert.IsNotNull(chartMultipleAreaData); Assert.AreEqual(layers.ElementAt(i).Data.MaterialName, chartMultipleAreaData.Name); Assert.AreEqual(mapDataShouldContainAreas, chartMultipleAreaData.Areas.Any()); } }
/// <summary> /// Asserts whether the <see cref="PersistableSoilLayerCollection"/> contains the data /// that is representative for the <paramref name="layers"/>. /// </summary> /// <param name="layers">The layers that contain the original data.</param> /// <param name="soilLayerCollections">The <see cref="PersistableSoilLayerCollection"/> /// that needs to be asserted.</param> /// <param name="soils">The soils that are used.</param> /// <param name="geometries">The geometries that are used.</param> /// <exception cref="AssertionException">Thrown when the data in <paramref name="soilLayerCollections"/> /// is not correct.</exception> public static void AssertPersistableSoilLayers(IEnumerable <MacroStabilityInwardsSoilLayer2D> layers, IEnumerable <PersistableSoilLayerCollection> soilLayerCollections, IEnumerable <PersistableSoil> soils, IEnumerable <PersistableGeometry> geometries) { Assert.AreEqual(2, soilLayerCollections.Count()); IEnumerable <MacroStabilityInwardsSoilLayer2D> originalLayers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(layers); for (var i = 0; i < soilLayerCollections.Count(); i++) { PersistableSoilLayerCollection soilLayerCollection = soilLayerCollections.ElementAt(i); Assert.IsNotNull(soilLayerCollection.Id); Assert.AreEqual(originalLayers.Count(), soilLayerCollection.SoilLayers.Count()); for (var j = 0; j < originalLayers.Count(); j++) { PersistableSoilLayer persistableSoilLayer = soilLayerCollection.SoilLayers.ElementAt(j); Assert.AreEqual(soils.ElementAt(j).Id, persistableSoilLayer.SoilId); Assert.AreEqual(geometries.ElementAt(i).Layers.ElementAt(j).Id, persistableSoilLayer.LayerId); } } }
private IEnumerable <MacroStabilityInwardsSoilLayer2D> GetSoilLayers() { return(MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(data.InputParameters.SoilProfileUnderSurfaceLine?.Layers)); }
public void GetLayersRecursively_WithNestedLayers_ReturnsAllTopLevelAndNestedLayers() { // Setup var nestedLayer1 = new MacroStabilityInwardsSoilLayer2D( new Ring(new List <Point2D> { new Point2D(4.0, 2.0), new Point2D(0.0, 2.5) })); var topLevelLayer1 = new MacroStabilityInwardsSoilLayer2D( new Ring(new List <Point2D> { new Point2D(0.0, 1.0), new Point2D(2.0, 4.0) }), new MacroStabilityInwardsSoilLayerData(), new[] { nestedLayer1 }); var doubleNestedLayer = new MacroStabilityInwardsSoilLayer2D( new Ring(new List <Point2D> { new Point2D(4.0, 2.0), new Point2D(0.0, 2.5) })); var nestedLayer2 = new MacroStabilityInwardsSoilLayer2D( new Ring(new List <Point2D> { new Point2D(4.0, 2.0), new Point2D(0.0, 2.5) }), new MacroStabilityInwardsSoilLayerData(), new[] { doubleNestedLayer }); var topLevelLayer2 = new MacroStabilityInwardsSoilLayer2D( new Ring(new List <Point2D> { new Point2D(3.0, 1.0), new Point2D(8.0, 3.0) }), new MacroStabilityInwardsSoilLayerData(), new[] { nestedLayer2 }); MacroStabilityInwardsSoilLayer2D[] layers = { topLevelLayer1, topLevelLayer2 }; // Call IEnumerable <MacroStabilityInwardsSoilLayer2D> flatLayers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(layers); // Assert CollectionAssert.AreEqual(new[] { topLevelLayer1, nestedLayer1, topLevelLayer2, nestedLayer2, doubleNestedLayer }, flatLayers); }