Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Create/CalculationGroupCreateExtensions.cs =================================================================== diff -u -rbce62ec6102f15b0dbb1328fd9d14063fd21c978 -r3e7db9d95e07d438ec99f8488ec184848655b98c --- Application/Ringtoets/src/Application.Ringtoets.Storage/Create/CalculationGroupCreateExtensions.cs (.../CalculationGroupCreateExtensions.cs) (revision bce62ec6102f15b0dbb1328fd9d14063fd21c978) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Create/CalculationGroupCreateExtensions.cs (.../CalculationGroupCreateExtensions.cs) (revision 3e7db9d95e07d438ec99f8488ec184848655b98c) @@ -20,10 +20,8 @@ // All rights reserved. using System; -using Application.Ringtoets.Storage.Create.ClosingStructures; using Application.Ringtoets.Storage.Create.GrassCoverErosionInwards; using Application.Ringtoets.Storage.Create.GrassCoverErosionOutwards; -using Application.Ringtoets.Storage.Create.HeightStructures; using Application.Ringtoets.Storage.Create.Piping; using Application.Ringtoets.Storage.Create.StabilityStoneCover; using Application.Ringtoets.Storage.Create.WaveImpactAsphaltCover; @@ -36,6 +34,7 @@ using Ringtoets.GrassCoverErosionOutwards.Data; using Ringtoets.HeightStructures.Data; using Ringtoets.Piping.Data; +using Ringtoets.StabilityPointStructures.Data; using Ringtoets.StabilityStoneCover.Data; using Ringtoets.WaveImpactAsphaltCover.Data; @@ -107,6 +106,11 @@ { entity.ClosingStructuresCalculationEntities.Add(childClosingStructuresCalculation.CreateForClosingStructures(registry, i)); } + var childStabilityPointStructuresCalculation = calculationBase as StructuresCalculation; + if (childStabilityPointStructuresCalculation != null) + { + entity.StabilityPointStructuresCalculationEntities.Add(childStabilityPointStructuresCalculation.CreateForStabilityPointStructures(registry, i)); + } var stabilityStoneCoverWaveConditionsCalculation = calculationBase as StabilityStoneCoverWaveConditionsCalculation; if (stabilityStoneCoverWaveConditionsCalculation != null) { Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Create/StabilityPointStructures/StabilityPointStructuresFailureMechanismCreateExtensions.cs =================================================================== diff -u -r0bc3d23ba7c6e8521df5786cc2680911e5865259 -r3e7db9d95e07d438ec99f8488ec184848655b98c --- Application/Ringtoets/src/Application.Ringtoets.Storage/Create/StabilityPointStructures/StabilityPointStructuresFailureMechanismCreateExtensions.cs (.../StabilityPointStructuresFailureMechanismCreateExtensions.cs) (revision 0bc3d23ba7c6e8521df5786cc2680911e5865259) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Create/StabilityPointStructures/StabilityPointStructuresFailureMechanismCreateExtensions.cs (.../StabilityPointStructuresFailureMechanismCreateExtensions.cs) (revision 3e7db9d95e07d438ec99f8488ec184848655b98c) @@ -42,10 +42,11 @@ internal static FailureMechanismEntity Create(this StabilityPointStructuresFailureMechanism mechanism, PersistenceRegistry registry) { FailureMechanismEntity entity = mechanism.Create(FailureMechanismType.StabilityPointStructures, registry); - AddEntitiesForSectionResults(mechanism.SectionResults, registry); AddEntitiesForForeshoreProfiles(mechanism.ForeshoreProfiles, entity, registry); AddEntitiesForStabilityPointStructures(mechanism.StabilityPointStructures, entity, registry); AddEntitiesForFailureMechanismMeta(mechanism.GeneralInput, entity); + entity.CalculationGroupEntity = mechanism.CalculationsGroup.Create(registry, 0); + AddEntitiesForSectionResults(mechanism.SectionResults, registry); return entity; } Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Read/CalculationGroupEntityReadExtentions.cs =================================================================== diff -u -r811967790aed0c6617f36c2135016a5bc4aa8fcc -r3e7db9d95e07d438ec99f8488ec184848655b98c --- Application/Ringtoets/src/Application.Ringtoets.Storage/Read/CalculationGroupEntityReadExtentions.cs (.../CalculationGroupEntityReadExtentions.cs) (revision 811967790aed0c6617f36c2135016a5bc4aa8fcc) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Read/CalculationGroupEntityReadExtentions.cs (.../CalculationGroupEntityReadExtentions.cs) (revision 3e7db9d95e07d438ec99f8488ec184848655b98c) @@ -28,6 +28,7 @@ using Application.Ringtoets.Storage.Read.HeightStructures; using Application.Ringtoets.Storage.Read.Piping; using Application.Ringtoets.Storage.Read.StabilityStoneCover; +using Application.Ringtoets.Storage.Read.StabilityPointStructures; using Application.Ringtoets.Storage.Read.WaveImpactAsphaltCover; using Ringtoets.Common.Data.Calculation; using Ringtoets.Piping.Data; @@ -235,6 +236,42 @@ /// The object keeping track of read operations. /// A new . /// Thrown when is null. + internal static CalculationGroup ReadAsStabilityPointStructuresCalculationGroup(this CalculationGroupEntity entity, + ReadConversionCollector collector) + { + if (collector == null) + { + throw new ArgumentNullException("collector"); + } + + var group = new CalculationGroup(entity.Name, true); + + foreach (object childEntity in GetChildEntitiesInOrder(entity)) + { + var childCalculationGroupEntity = childEntity as CalculationGroupEntity; + if (childCalculationGroupEntity != null) + { + group.Children.Add(childCalculationGroupEntity.ReadAsStabilityPointStructuresCalculationGroup(collector)); + } + var childCalculationEntity = childEntity as StabilityPointStructuresCalculationEntity; + if (childCalculationEntity != null) + { + group.Children.Add(childCalculationEntity.Read(collector)); + } + } + + return group; + } + + /// + /// Read the and use the information to construct + /// a . + /// + /// The to create + /// for. + /// The object keeping track of read operations. + /// A new . + /// Thrown when is null. internal static CalculationGroup ReadAsStabilityStoneCoverWaveConditionsCalculationGroup(this CalculationGroupEntity entity, ReadConversionCollector collector) { @@ -325,6 +362,10 @@ { sortedList.Add(calculationEntity.Order, calculationEntity); } + foreach (StabilityPointStructuresCalculationEntity calculationEntity in entity.StabilityPointStructuresCalculationEntities) + { + sortedList.Add(calculationEntity.Order, calculationEntity); + } foreach (StabilityStoneCoverWaveConditionsCalculationEntity calculationEntity in entity.StabilityStoneCoverWaveConditionsCalculationEntities) { sortedList.Add(calculationEntity.Order, calculationEntity); Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Read/FailureMechanismEntityReadExtensions.cs =================================================================== diff -u -ree999e492a57d9bbb3777754651e9f4722611075 -r3e7db9d95e07d438ec99f8488ec184848655b98c --- Application/Ringtoets/src/Application.Ringtoets.Storage/Read/FailureMechanismEntityReadExtensions.cs (.../FailureMechanismEntityReadExtensions.cs) (revision ee999e492a57d9bbb3777754651e9f4722611075) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Read/FailureMechanismEntityReadExtensions.cs (.../FailureMechanismEntityReadExtensions.cs) (revision 3e7db9d95e07d438ec99f8488ec184848655b98c) @@ -385,8 +385,8 @@ } private static void ReadClosingStructuresRootCalculationGroup(CalculationGroupEntity rootCalculationGroupEntity, - CalculationGroup targetRootCalculationGroup, - ReadConversionCollector collector) + CalculationGroup targetRootCalculationGroup, + ReadConversionCollector collector) { CalculationGroup rootCalculationGroup = rootCalculationGroupEntity.ReadAsClosingStructuresCalculationGroup(collector); foreach (ICalculationBase calculationBase in rootCalculationGroup.Children) @@ -743,6 +743,7 @@ entity.ReadForeshoreProfiles(failureMechanism.ForeshoreProfiles, collector); entity.ReadStabilityPointStructures(failureMechanism.StabilityPointStructures, collector); entity.ReadGeneralInput(failureMechanism.GeneralInput); + ReadStabilityPointStructuresRootCalculationGroup(entity.CalculationGroupEntity, failureMechanism.CalculationsGroup, collector); } private static void ReadStabilityPointStructuresMechanismSectionResults(this FailureMechanismEntity entity, StabilityPointStructuresFailureMechanism failureMechanism, ReadConversionCollector collector) @@ -769,6 +770,17 @@ generalInput.N = generalStabilityPointStructuresInput.N; } + private static void ReadStabilityPointStructuresRootCalculationGroup(CalculationGroupEntity rootCalculationGroupEntity, + CalculationGroup targetRootCalculationGroup, + ReadConversionCollector collector) + { + CalculationGroup rootCalculationGroup = rootCalculationGroupEntity.ReadAsStabilityPointStructuresCalculationGroup(collector); + foreach (ICalculationBase calculationBase in rootCalculationGroup.Children) + { + targetRootCalculationGroup.Children.Add(calculationBase); + } + } + #endregion } } \ No newline at end of file Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/CalculationGroupCreateExtensionsTest.cs =================================================================== diff -u -r811967790aed0c6617f36c2135016a5bc4aa8fcc -r3e7db9d95e07d438ec99f8488ec184848655b98c --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/CalculationGroupCreateExtensionsTest.cs (.../CalculationGroupCreateExtensionsTest.cs) (revision 811967790aed0c6617f36c2135016a5bc4aa8fcc) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/CalculationGroupCreateExtensionsTest.cs (.../CalculationGroupCreateExtensionsTest.cs) (revision 3e7db9d95e07d438ec99f8488ec184848655b98c) @@ -31,6 +31,7 @@ using Ringtoets.GrassCoverErosionOutwards.Data; using Ringtoets.HeightStructures.Data; using Ringtoets.Piping.Data; +using Ringtoets.StabilityPointStructures.Data; using Ringtoets.StabilityStoneCover.Data; using Ringtoets.WaveImpactAsphaltCover.Data; @@ -754,5 +755,92 @@ Assert.AreEqual("D", childEntity4.Name); Assert.AreEqual(3, childEntity4.Order); } + + [Test] + public void Create_GroupWithChildStabilityPointStructuresCalculations_CreateEntities() + { + // Setup + var group = new CalculationGroup("root", true) + { + Children = + { + new StructuresCalculation + { + Name = "A" + }, + new StructuresCalculation + { + Name = "B" + } + } + }; + + var registry = new PersistenceRegistry(); + + // Call + CalculationGroupEntity entity = group.Create(registry, 0); + + // Assert + StabilityPointStructuresCalculationEntity[] childCalculationEntities = entity.StabilityPointStructuresCalculationEntities.ToArray(); + Assert.AreEqual(2, childCalculationEntities.Length); + + StabilityPointStructuresCalculationEntity childEntity1 = childCalculationEntities[0]; + Assert.AreEqual("A", childEntity1.Name); + Assert.AreEqual(0, childEntity1.Order); + StabilityPointStructuresCalculationEntity childEntity2 = childCalculationEntities[1]; + Assert.AreEqual("B", childEntity2.Name); + Assert.AreEqual(1, childEntity2.Order); + } + + [Test] + public void Create_GroupWithChildStabilityPointStructuresCalculationsAndChildCalculationGroups_CreateEntities() + { + // Setup + var group = new CalculationGroup("root", true) + { + Children = + { + new CalculationGroup("A", true), + new StructuresCalculation + { + Name = "B" + }, + new CalculationGroup("C", true), + new StructuresCalculation + { + Name = "D" + } + } + }; + + var registry = new PersistenceRegistry(); + + // Call + CalculationGroupEntity entity = group.Create(registry, 0); + + // Assert + CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity1.ToArray(); + StabilityPointStructuresCalculationEntity[] childCalculationEntities = entity.StabilityPointStructuresCalculationEntities.ToArray(); + Assert.AreEqual(2, childGroupEntities.Length); + Assert.AreEqual(2, childCalculationEntities.Length); + + CalculationGroupEntity childEntity1 = childGroupEntities[0]; + Assert.AreEqual("A", childEntity1.Name); + Assert.AreEqual(0, childEntity1.Order); + CollectionAssert.IsEmpty(childEntity1.CalculationGroupEntity1); + + StabilityPointStructuresCalculationEntity childEntity2 = childCalculationEntities[0]; + Assert.AreEqual("B", childEntity2.Name); + Assert.AreEqual(1, childEntity2.Order); + + CalculationGroupEntity childEntity3 = childGroupEntities[1]; + Assert.AreEqual("C", childEntity3.Name); + Assert.AreEqual(2, childEntity3.Order); + CollectionAssert.IsEmpty(childEntity3.CalculationGroupEntity1); + + StabilityPointStructuresCalculationEntity childEntity4 = childCalculationEntities[1]; + Assert.AreEqual("D", childEntity4.Name); + Assert.AreEqual(3, childEntity4.Order); + } } } \ No newline at end of file Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/StabilityPointStructures/StabilityPointStructuresFailureMechanismCreateExtensionsTest.cs =================================================================== diff -u -r0bc3d23ba7c6e8521df5786cc2680911e5865259 -r3e7db9d95e07d438ec99f8488ec184848655b98c --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/StabilityPointStructures/StabilityPointStructuresFailureMechanismCreateExtensionsTest.cs (.../StabilityPointStructuresFailureMechanismCreateExtensionsTest.cs) (revision 0bc3d23ba7c6e8521df5786cc2680911e5865259) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/StabilityPointStructures/StabilityPointStructuresFailureMechanismCreateExtensionsTest.cs (.../StabilityPointStructuresFailureMechanismCreateExtensionsTest.cs) (revision 3e7db9d95e07d438ec99f8488ec184848655b98c) @@ -26,6 +26,8 @@ using Application.Ringtoets.Storage.DbContext; using Application.Ringtoets.Storage.TestUtil; using NUnit.Framework; +using Ringtoets.Common.Data.Calculation; +using Ringtoets.Common.Data.Structures; using Ringtoets.StabilityPointStructures.Data; using Ringtoets.StabilityPointStructures.Data.TestUtil; @@ -163,5 +165,43 @@ Assert.AreEqual(1, entity.StabilityPointStructureEntities.Count); Assert.IsTrue(persistenceRegistry.Contains(structure)); } + + [Test] + public void Create_WithCalculationGroup_ReturnFailureMechanismEntityWithCalculationGroupEntities() + { + // Setup + StructuresCalculation calculation = new TestStabilityPointStructuresCalculation(); + calculation.InputParameters.Structure = null; + calculation.InputParameters.HydraulicBoundaryLocation = null; + + var failureMechanism = new StabilityPointStructuresFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup("A", true)); + failureMechanism.CalculationsGroup.Children.Add(calculation); + + var registry = new PersistenceRegistry(); + + // Call + FailureMechanismEntity entity = failureMechanism.Create(registry); + + // Assert + Assert.IsNotNull(entity); + Assert.AreEqual(failureMechanism.CalculationsGroup.Name, entity.CalculationGroupEntity.Name); + Assert.AreEqual(0, entity.CalculationGroupEntity.Order); + + CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity.CalculationGroupEntity1 + .OrderBy(cge => cge.Order) + .ToArray(); + Assert.AreEqual(1, childGroupEntities.Length); + CalculationGroupEntity childGroupEntity = childGroupEntities[0]; + Assert.AreEqual("A", childGroupEntity.Name); + Assert.AreEqual(0, childGroupEntity.Order); + + StabilityPointStructuresCalculationEntity[] calculationEntities = entity.CalculationGroupEntity.StabilityPointStructuresCalculationEntities + .OrderBy(ce => ce.Order) + .ToArray(); + StabilityPointStructuresCalculationEntity calculationEntity = calculationEntities[0]; + Assert.AreEqual("Nieuwe berekening", calculationEntity.Name); + Assert.AreEqual(1, calculationEntity.Order); + } } } \ No newline at end of file Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/IntegrationTests/StorageSqLiteIntegrationTest.cs =================================================================== diff -u -r6bd97cb84b2c0b7c06298d9d42171ed0678e872c -r3e7db9d95e07d438ec99f8488ec184848655b98c --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/IntegrationTests/StorageSqLiteIntegrationTest.cs (.../StorageSqLiteIntegrationTest.cs) (revision 6bd97cb84b2c0b7c06298d9d42171ed0678e872c) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/IntegrationTests/StorageSqLiteIntegrationTest.cs (.../StorageSqLiteIntegrationTest.cs) (revision 3e7db9d95e07d438ec99f8488ec184848655b98c) @@ -729,6 +729,11 @@ { AssertStructuresCalculation(expectedClosingStructuresCalculation, (StructuresCalculation) actualChild); } + var expectedStabilityPointStructuresCalculation = expectedChild as StructuresCalculation; + if (expectedStabilityPointStructuresCalculation != null) + { + AssertStructuresCalculation(expectedStabilityPointStructuresCalculation, (StructuresCalculation)actualChild); + } var expectedStabilityStoneCoverWaveConditionsCalculation = expectedChild as StabilityStoneCoverWaveConditionsCalculation; if (expectedStabilityStoneCoverWaveConditionsCalculation != null) { @@ -921,6 +926,7 @@ AssertForeshoreProfiles(expectedFailureMechanism.ForeshoreProfiles, actualFailureMechanism.ForeshoreProfiles); AssertStabilityPointStructures(expectedFailureMechanism.StabilityPointStructures, actualFailureMechanism.StabilityPointStructures); + AssertCalculationGroup(expectedFailureMechanism.CalculationsGroup, actualFailureMechanism.CalculationsGroup); } private static void AssertStabilityPointStructures(ObservableList expectedStabilityPointStructures, @@ -967,6 +973,63 @@ Assert.AreEqual(expectedStabilityPointStructure.InflowModelType, actualStabilityPointStructure.InflowModelType); } + private static void AssertStructuresCalculation(StructuresCalculation expectedCalculation, + StructuresCalculation actualCalculation) + { + Assert.AreEqual(expectedCalculation.Name, actualCalculation.Name); + Assert.AreEqual(expectedCalculation.Comments, actualCalculation.Comments); + + AssertStabilityPointStructuresInput(expectedCalculation.InputParameters, actualCalculation.InputParameters); + + if (expectedCalculation.HasOutput) + { + AssertProbabilityAssessmentOutput(expectedCalculation.Output, actualCalculation.Output); + } + else + { + Assert.IsFalse(actualCalculation.HasOutput); + } + } + + private static void AssertStabilityPointStructuresInput(StabilityPointStructuresInput expectedInput, StabilityPointStructuresInput actualInput) + { + AssertStructureInputBase(expectedInput, actualInput); + + if (expectedInput.Structure == null) + { + Assert.IsNull(actualInput.Structure); + } + else + { + AssertStabilityPointStructure(expectedInput.Structure, actualInput.Structure); + } + + DistributionAssert.AreEqual(expectedInput.InsideWaterLevel, actualInput.InsideWaterLevel); + DistributionAssert.AreEqual(expectedInput.ThresholdHeightOpenWeir, actualInput.ThresholdHeightOpenWeir); + DistributionAssert.AreEqual(expectedInput.ConstructiveStrengthLinearLoadModel, actualInput.ConstructiveStrengthLinearLoadModel); + DistributionAssert.AreEqual(expectedInput.ConstructiveStrengthQuadraticLoadModel, actualInput.ConstructiveStrengthQuadraticLoadModel); + DistributionAssert.AreEqual(expectedInput.BankWidth, actualInput.BankWidth); + DistributionAssert.AreEqual(expectedInput.InsideWaterLevelFailureConstruction, actualInput.InsideWaterLevelFailureConstruction); + Assert.AreEqual(expectedInput.EvaluationLevel, actualInput.EvaluationLevel); + DistributionAssert.AreEqual(expectedInput.LevelCrestStructure, actualInput.LevelCrestStructure); + Assert.AreEqual(expectedInput.VerticalDistance, actualInput.VerticalDistance); + Assert.AreEqual(expectedInput.FailureProbabilityRepairClosure, actualInput.FailureProbabilityRepairClosure); + DistributionAssert.AreEqual(expectedInput.FailureCollisionEnergy, actualInput.FailureCollisionEnergy); + DistributionAssert.AreEqual(expectedInput.ShipMass, actualInput.ShipMass); + DistributionAssert.AreEqual(expectedInput.ShipVelocity, actualInput.ShipVelocity); + Assert.AreEqual(expectedInput.LevellingCount, actualInput.LevellingCount); + Assert.AreEqual(expectedInput.ProbabilityCollisionSecondaryStructure, actualInput.ProbabilityCollisionSecondaryStructure); + DistributionAssert.AreEqual(expectedInput.FlowVelocityStructureClosable, actualInput.FlowVelocityStructureClosable); + DistributionAssert.AreEqual(expectedInput.StabilityLinearLoadModel, actualInput.StabilityLinearLoadModel); + DistributionAssert.AreEqual(expectedInput.StabilityQuadraticLoadModel, actualInput.StabilityQuadraticLoadModel); + DistributionAssert.AreEqual(expectedInput.AreaFlowApertures, actualInput.AreaFlowApertures); + Assert.AreEqual(expectedInput.InflowModelType, actualInput.InflowModelType); + Assert.AreEqual(expectedInput.LoadSchematizationType, actualInput.LoadSchematizationType); + Assert.AreEqual(expectedInput.VolumicWeightWater, actualInput.VolumicWeightWater); + Assert.AreEqual(expectedInput.FactorStormDurationOpenStructure, actualInput.FactorStormDurationOpenStructure); + DistributionAssert.AreEqual(expectedInput.DrainCoefficient, actualInput.DrainCoefficient); + } + #endregion #region ClosingStructures FailureMechanism @@ -978,6 +1041,7 @@ AssertForeshoreProfiles(expectedFailureMechanism.ForeshoreProfiles, actualFailureMechanism.ForeshoreProfiles); AssertClosingStructures(expectedFailureMechanism.ClosingStructures, actualFailureMechanism.ClosingStructures); + AssertCalculationGroup(expectedFailureMechanism.CalculationsGroup, actualFailureMechanism.CalculationsGroup); } private static void AssertClosingStructures(ObservableList expectedClosingStructures, ObservableList actualClosingStructures) Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/CalculationGroupEntityReadExtentionsTest.cs =================================================================== diff -u -r811967790aed0c6617f36c2135016a5bc4aa8fcc -r3e7db9d95e07d438ec99f8488ec184848655b98c --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/CalculationGroupEntityReadExtentionsTest.cs (.../CalculationGroupEntityReadExtentionsTest.cs) (revision 811967790aed0c6617f36c2135016a5bc4aa8fcc) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/CalculationGroupEntityReadExtentionsTest.cs (.../CalculationGroupEntityReadExtentionsTest.cs) (revision 3e7db9d95e07d438ec99f8488ec184848655b98c) @@ -31,6 +31,7 @@ using Ringtoets.GrassCoverErosionOutwards.Data; using Ringtoets.HeightStructures.Data; using Ringtoets.Piping.Data; +using Ringtoets.StabilityPointStructures.Data; using Ringtoets.StabilityStoneCover.Data; using Ringtoets.WaveImpactAsphaltCover.Data; @@ -1033,6 +1034,199 @@ #endregion + #region StabilityPointStructures + + [Test] + public void ReadAsStabilityPointStructuresCalculationGroup_CollectorIsNull_ThrowArgumentNullException() + { + // Setup + var entity = new CalculationGroupEntity(); + + // Call + TestDelegate call = () => entity.ReadAsStabilityPointStructuresCalculationGroup(null); + + // Assert + string paramName = Assert.Throws(call).ParamName; + Assert.AreEqual("collector", paramName); + } + + [Test] + [TestCase("HAbba")] + [TestCase("Dooeis")] + public void ReadAsStabilityPointStructuresCalculationGroup_EntityWithoutChildren_CreateCalculationGroupWithoutChildren(string name) + { + // Setup + var entity = new CalculationGroupEntity + { + Name = name, + }; + + var collector = new ReadConversionCollector(); + + // Call + CalculationGroup group = entity.ReadAsStabilityPointStructuresCalculationGroup(collector); + + // Assert + Assert.AreEqual(name, group.Name); + CollectionAssert.IsEmpty(group.Children); + } + + [Test] + public void ReadAsStabilityPointStructuresCalculationGroup_EntityWithChildGroups_CreateCalculationGroupWithChildGroups() + { + // Setup + var rootGroupEntity = new CalculationGroupEntity + { + Name = "A", + CalculationGroupEntity1 = + { + new CalculationGroupEntity + { + Name = "AB", + CalculationGroupEntity1 = + { + new CalculationGroupEntity + { + Name = "ABA", + Order = 0 + }, + new CalculationGroupEntity + { + Name = "ABB", + Order = 1 + } + }, + Order = 1 + }, + new CalculationGroupEntity + { + Name = "AA", + Order = 0 + } + } + }; + + var collector = new ReadConversionCollector(); + + // Call + var rootGroup = rootGroupEntity.ReadAsStabilityPointStructuresCalculationGroup(collector); + + // Assert + Assert.AreEqual("A", rootGroup.Name); + + ICalculationBase[] rootChildren = rootGroup.Children.ToArray(); + var rootChildGroup1 = (CalculationGroup)rootChildren[0]; + Assert.AreEqual("AA", rootChildGroup1.Name); + CollectionAssert.IsEmpty(rootChildGroup1.Children); + var rootChildGroup2 = (CalculationGroup)rootChildren[1]; + Assert.AreEqual("AB", rootChildGroup2.Name); + + ICalculationBase[] rootChildGroup2Children = rootChildGroup2.Children.ToArray(); + var rootChildGroup1Child1 = (CalculationGroup)rootChildGroup2Children[0]; + Assert.AreEqual("ABA", rootChildGroup1Child1.Name); + CollectionAssert.IsEmpty(rootChildGroup1Child1.Children); + var rootChildGroup1Child2 = (CalculationGroup)rootChildGroup2Children[1]; + Assert.AreEqual("ABB", rootChildGroup1Child2.Name); + CollectionAssert.IsEmpty(rootChildGroup1Child2.Children); + } + + [Test] + public void ReadAsStabilityPointStructuresCalculationGroup_EntityWithChildStabilityPointStructuresCalculations_CreateCalculationGroupWithChildCalculations() + { + // Setup + var rootGroupEntity = new CalculationGroupEntity + { + Name = "A", + StabilityPointStructuresCalculationEntities = + { + new StabilityPointStructuresCalculationEntity + { + Order = 0, + Name = "1" + }, + new StabilityPointStructuresCalculationEntity + { + Order = 1, + Name = "2" + } + } + }; + + var collector = new ReadConversionCollector(); + + // Call + var rootGroup = rootGroupEntity.ReadAsStabilityPointStructuresCalculationGroup(collector); + + // Assert + ICalculationBase[] rootChildren = rootGroup.Children.ToArray(); + Assert.AreEqual(2, rootChildren.Length); + + var rootChildCalculation1 = (StructuresCalculation)rootChildren[0]; + Assert.AreEqual("1", rootChildCalculation1.Name); + + var rootChildCalculation2 = (StructuresCalculation)rootChildren[1]; + Assert.AreEqual("2", rootChildCalculation2.Name); + } + + [Test] + public void ReadAsStabilityPointStructuresCalculationGroup_EntityWithChildStabilityPointStructuresCalculationAndGroups_CreateCalculationGroupWithChildCalculationsAndGroups() + { + // Setup + var rootGroupEntity = new CalculationGroupEntity + { + Name = "A", + StabilityPointStructuresCalculationEntities = + { + new StabilityPointStructuresCalculationEntity + { + Order = 0, + Name = "calculation1" + }, + new StabilityPointStructuresCalculationEntity + { + Order = 2, + Name = "calculation2" + } + }, + CalculationGroupEntity1 = + { + new CalculationGroupEntity + { + Order = 1, + Name = "group1" + }, + new CalculationGroupEntity + { + Order = 3, + Name = "group2" + } + } + }; + + var collector = new ReadConversionCollector(); + + // Call + var rootGroup = rootGroupEntity.ReadAsStabilityPointStructuresCalculationGroup(collector); + + // Assert + ICalculationBase[] rootChildren = rootGroup.Children.ToArray(); + Assert.AreEqual(4, rootChildren.Length); + + var rootChildCalculation1 = (StructuresCalculation)rootChildren[0]; + Assert.AreEqual("calculation1", rootChildCalculation1.Name); + + var rootChildGroup1 = (CalculationGroup)rootChildren[1]; + Assert.AreEqual("group1", rootChildGroup1.Name); + + var rootChildCalculation2 = (StructuresCalculation)rootChildren[2]; + Assert.AreEqual("calculation2", rootChildCalculation2.Name); + + var rootChildGroup2 = (CalculationGroup)rootChildren[3]; + Assert.AreEqual("group2", rootChildGroup2.Name); + } + + #endregion + #region Stability Stone Cover [Test] Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/FailureMechanismEntityReadExtensionsTest.cs =================================================================== diff -u -r811967790aed0c6617f36c2135016a5bc4aa8fcc -r3e7db9d95e07d438ec99f8488ec184848655b98c --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/FailureMechanismEntityReadExtensionsTest.cs (.../FailureMechanismEntityReadExtensionsTest.cs) (revision 811967790aed0c6617f36c2135016a5bc4aa8fcc) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/FailureMechanismEntityReadExtensionsTest.cs (.../FailureMechanismEntityReadExtensionsTest.cs) (revision 3e7db9d95e07d438ec99f8488ec184848655b98c) @@ -972,7 +972,7 @@ var entity = new FailureMechanismEntity { CalculationGroupEntity = new CalculationGroupEntity(), - ClosingStructureEntities = + ClosingStructureEntities = { new ClosingStructureEntity { @@ -987,7 +987,7 @@ Id = "b" } }, - ClosingStructureFailureMechanismMetaEntities = + ClosingStructureFailureMechanismMetaEntities = { new ClosingStructureFailureMechanismMetaEntity() } @@ -1026,14 +1026,14 @@ }, ClosingStructuresCalculationEntities = { - new ClosingStructuresCalculationEntity + new ClosingStructuresCalculationEntity { Name = "B", Order = 0 } } }, - ClosingStructureFailureMechanismMetaEntities = + ClosingStructureFailureMechanismMetaEntities = { new ClosingStructureFailureMechanismMetaEntity() } @@ -1156,6 +1156,57 @@ Assert.AreEqual("Child1", child2.Name); } + [Test] + public void ReadAsStabilityPointStructuresFailureMechanism_WithCalculationsAndGroups_ReturnFailureMechanismWithCalculationsAndGroups() + { + // Setup + var entity = new FailureMechanismEntity + { + CalculationGroupEntity = new CalculationGroupEntity + { + CalculationGroupEntity1 = + { + new CalculationGroupEntity + { + Name = "A", + Order = 1 + } + }, + StabilityPointStructuresCalculationEntities = + { + new StabilityPointStructuresCalculationEntity + { + Name = "B", + Order = 0 + } + } + }, + StabilityPointStructuresFailureMechanismMetaEntities = + { + new StabilityPointStructuresFailureMechanismMetaEntity + { + N = 2 + } + } + }; + var collector = new ReadConversionCollector(); + var failureMechanism = new StabilityPointStructuresFailureMechanism(); + + // Call + entity.ReadAsStabilityPointStructuresFailureMechanism(failureMechanism, collector); + + // Assert + Assert.AreEqual(2, failureMechanism.CalculationsGroup.Children.Count); + + ICalculationBase expectedCalculation = failureMechanism.CalculationsGroup.Children[0]; + Assert.AreEqual("B", expectedCalculation.Name); + Assert.IsInstanceOf>(expectedCalculation); + + ICalculationBase expectedCalculationGroup = failureMechanism.CalculationsGroup.Children[1]; + Assert.AreEqual("A", expectedCalculationGroup.Name); + Assert.IsInstanceOf(expectedCalculationGroup); + } + #endregion } } \ No newline at end of file Index: Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil.Test/RingtoetsProjectTestHelperTest.cs =================================================================== diff -u -r481507356af9b0ed7ed0de2493275a6f8c2f47ea -r3e7db9d95e07d438ec99f8488ec184848655b98c --- Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil.Test/RingtoetsProjectTestHelperTest.cs (.../RingtoetsProjectTestHelperTest.cs) (revision 481507356af9b0ed7ed0de2493275a6f8c2f47ea) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil.Test/RingtoetsProjectTestHelperTest.cs (.../RingtoetsProjectTestHelperTest.cs) (revision 3e7db9d95e07d438ec99f8488ec184848655b98c) @@ -297,6 +297,19 @@ StabilityPointStructuresFailureMechanism failureMechanism = assessmentSection.StabilityPointStructures; Assert.AreEqual(2, failureMechanism.ForeshoreProfiles.Count); Assert.AreEqual(2, failureMechanism.StabilityPointStructures.Count); + + Assert.NotNull(failureMechanism.CalculationsGroup); + Assert.AreEqual(3, failureMechanism.CalculationsGroup.Children.Count); + + var firstCalculationGroup = (CalculationGroup)failureMechanism.CalculationsGroup.Children[0]; + Assert.AreEqual(1, firstCalculationGroup.Children.Count); + + var calculation = (StructuresCalculation)firstCalculationGroup.Children[0]; + Assert.AreEqual("Calculation 1", calculation.Name); + + var secondCalculationGroup = (CalculationGroup)failureMechanism.CalculationsGroup.Children[1]; + Assert.AreEqual(0, secondCalculationGroup.Children.Count); + Assert.IsInstanceOf>(failureMechanism.CalculationsGroup.Children[2]); } } } \ No newline at end of file Index: Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectTestHelper.cs =================================================================== diff -u -r481507356af9b0ed7ed0de2493275a6f8c2f47ea -r3e7db9d95e07d438ec99f8488ec184848655b98c --- Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectTestHelper.cs (.../RingtoetsProjectTestHelper.cs) (revision 481507356af9b0ed7ed0de2493275a6f8c2f47ea) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectTestHelper.cs (.../RingtoetsProjectTestHelper.cs) (revision 3e7db9d95e07d438ec99f8488ec184848655b98c) @@ -111,11 +111,12 @@ ConfigureClosingStructuresFailureMechanism(closingStructuresFailureMechanism, assessmentSection); AddSections(closingStructuresFailureMechanism); SetSectionResults(closingStructuresFailureMechanism.SectionResults, - (StructuresCalculation)closingStructuresFailureMechanism.Calculations.First()); + (StructuresCalculation) closingStructuresFailureMechanism.Calculations.First()); StabilityPointStructuresFailureMechanism stabilityPointStructuresFailureMechanism = assessmentSection.StabilityPointStructures; AddForeshoreProfiles(stabilityPointStructuresFailureMechanism.ForeshoreProfiles); - ConfigureStabilityPointStructuresFailureMechanism(stabilityPointStructuresFailureMechanism); + ConfigureStabilityPointStructuresFailureMechanism(stabilityPointStructuresFailureMechanism, + assessmentSection); AddSections(stabilityPointStructuresFailureMechanism); SetSectionResults(stabilityPointStructuresFailureMechanism.SectionResults); @@ -350,11 +351,164 @@ #region StabilityPointStructures FailureMechanism - private static void ConfigureStabilityPointStructuresFailureMechanism(StabilityPointStructuresFailureMechanism failureMechanism) + private static void ConfigureStabilityPointStructuresFailureMechanism(StabilityPointStructuresFailureMechanism failureMechanism, + IAssessmentSection assessmentSection) { failureMechanism.GeneralInput.N = 8; failureMechanism.StabilityPointStructures.Add(new TestStabilityPointStructure()); failureMechanism.StabilityPointStructures.Add(new TestStabilityPointStructure()); + + var random = new Random(56); + + ForeshoreProfile foreshoreProfile = failureMechanism.ForeshoreProfiles[0]; + HydraulicBoundaryLocation hydroLocation = assessmentSection.HydraulicBoundaryDatabase.Locations[0]; + failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup + { + Name = "StabilityPoint Structure A", + Children = + { + new StructuresCalculation + { + Name = "Calculation 1", + Comments = "Fully configured for greatness!", + InputParameters = + { + StormDuration = + { + Mean = (RoundedDouble) random.NextDouble(), + }, + StructureNormalOrientation = (RoundedDouble) random.NextDouble(), + FailureProbabilityStructureWithErosion = random.NextDouble(), + UseForeshore = random.NextBoolean(), + UseBreakWater = random.NextBoolean(), + BreakWater = + { + Type = BreakWaterType.Dam, + Height = (RoundedDouble) random.NextDouble() + }, + AllowedLevelIncreaseStorage = + { + Mean = (RoundedDouble) random.NextDouble(), + StandardDeviation = (RoundedDouble) random.NextDouble() + }, + StorageStructureArea = + { + Mean = (RoundedDouble) random.NextDouble(), + CoefficientOfVariation = (RoundedDouble) random.NextDouble() + }, + FlowWidthAtBottomProtection = + { + Mean = (RoundedDouble) random.NextDouble(), + StandardDeviation = (RoundedDouble) random.NextDouble() + }, + CriticalOvertoppingDischarge = + { + Mean = (RoundedDouble) random.NextDouble(), + CoefficientOfVariation = (RoundedDouble) random.NextDouble() + }, + ModelFactorSuperCriticalFlow = + { + Mean = (RoundedDouble) random.NextDouble() + }, + WidthFlowApertures = + { + Mean = (RoundedDouble) random.NextDouble(), + CoefficientOfVariation = (RoundedDouble) random.NextDouble() + }, + InsideWaterLevel = + { + Mean = (RoundedDouble) random.NextDouble(), + StandardDeviation = (RoundedDouble) random.NextDouble() + }, + ThresholdHeightOpenWeir = + { + Mean = (RoundedDouble) random.NextDouble(), + StandardDeviation = (RoundedDouble) random.NextDouble() + }, + ConstructiveStrengthLinearLoadModel = + { + Mean = (RoundedDouble) random.NextDouble(), + CoefficientOfVariation = (RoundedDouble) random.NextDouble() + }, + ConstructiveStrengthQuadraticLoadModel = + { + Mean = (RoundedDouble) random.NextDouble(), + CoefficientOfVariation = (RoundedDouble) random.NextDouble() + }, + BankWidth = + { + Mean = (RoundedDouble) random.NextDouble(), + StandardDeviation = (RoundedDouble) random.NextDouble() + }, + InsideWaterLevelFailureConstruction = + { + Mean = (RoundedDouble) random.NextDouble(), + StandardDeviation = (RoundedDouble) random.NextDouble() + }, + EvaluationLevel = (RoundedDouble) random.NextDouble(), + LevelCrestStructure = + { + Mean = (RoundedDouble) random.NextDouble(), + StandardDeviation = (RoundedDouble) random.NextDouble() + }, + VerticalDistance = (RoundedDouble) random.NextDouble(), + FailureProbabilityRepairClosure = random.NextDouble(), + FailureCollisionEnergy = + { + Mean = (RoundedDouble) random.NextDouble(), + CoefficientOfVariation = (RoundedDouble) random.NextDouble() + }, + ShipMass = + { + Mean = (RoundedDouble) random.NextDouble(), + CoefficientOfVariation = (RoundedDouble) random.NextDouble() + }, + ShipVelocity = + { + Mean = (RoundedDouble) random.NextDouble(), + CoefficientOfVariation = (RoundedDouble) random.NextDouble() + }, + LevellingCount = random.Next(), + ProbabilityCollisionSecondaryStructure = random.NextDouble(), + FlowVelocityStructureClosable = + { + Mean = (RoundedDouble) random.NextDouble(), + StandardDeviation = (RoundedDouble) random.NextDouble() + }, + StabilityLinearLoadModel = + { + Mean = (RoundedDouble) random.NextDouble(), + CoefficientOfVariation = (RoundedDouble) random.NextDouble() + }, + StabilityQuadraticLoadModel = + { + Mean = (RoundedDouble) random.NextDouble(), + CoefficientOfVariation = (RoundedDouble) random.NextDouble() + }, + AreaFlowApertures = + { + Mean = (RoundedDouble) random.NextDouble(), + StandardDeviation = (RoundedDouble) random.NextDouble() + }, + InflowModelType = StabilityPointStructureInflowModelType.LowSill, + LoadSchematizationType = LoadSchematizationType.Quadratic, + VolumicWeightWater = (RoundedDouble) random.NextDouble(), + FactorStormDurationOpenStructure = (RoundedDouble) random.NextDouble(), + DrainCoefficient = + { + Mean = (RoundedDouble) random.NextDouble() + }, + ForeshoreProfile = foreshoreProfile, + HydraulicBoundaryLocation = hydroLocation + } + } + } + }); + failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup + { + Name = "StabilityPoint Structure B" + }); + failureMechanism.CalculationsGroup.Children.Add(new StructuresCalculation()); } #endregion @@ -466,15 +620,15 @@ failureMechanism.CalculationsGroup.Children.Add(new StructuresCalculation()); } - private static void SetSectionResults(IEnumerable sectionResults, - StructuresCalculation calculation) + private static void SetSectionResults(IEnumerable sectionResults, + StructuresCalculation calculation) { var random = new Random(21); var firstSectionResultHasCalculation = false; foreach (var sectionResult in sectionResults) { sectionResult.AssessmentLayerOne = random.NextBoolean(); - sectionResult.AssessmentLayerThree = (RoundedDouble)random.NextDouble(); + sectionResult.AssessmentLayerThree = (RoundedDouble) random.NextDouble(); if (!firstSectionResultHasCalculation) { sectionResult.Calculation = calculation;