Index: Riskeer/Piping/src/Riskeer.Piping.Forms/Factories/PipingMapDataFeaturesFactory.cs =================================================================== diff -u -r1250f75d43f878e4ad35f226cea3c68f556964c2 -rd2db1044e78377af2673cbdd7d2f60bc20b1c066 --- Riskeer/Piping/src/Riskeer.Piping.Forms/Factories/PipingMapDataFeaturesFactory.cs (.../PipingMapDataFeaturesFactory.cs) (revision 1250f75d43f878e4ad35f226cea3c68f556964c2) +++ Riskeer/Piping/src/Riskeer.Piping.Forms/Factories/PipingMapDataFeaturesFactory.cs (.../PipingMapDataFeaturesFactory.cs) (revision d2db1044e78377af2673cbdd7d2f60bc20b1c066) @@ -26,6 +26,7 @@ using Core.Components.Gis.Features; using Riskeer.Common.Forms.Factories; using Riskeer.Common.Forms.PresentationObjects; +using Riskeer.Piping.Data.Probabilistic; using Riskeer.Piping.Data.SemiProbabilistic; using Riskeer.Piping.Data.SoilProfile; using Riskeer.Piping.Primitives; @@ -100,7 +101,7 @@ /// A collection of features or an empty collection when is null or empty. public static IEnumerable CreateCalculationFeatures(IEnumerable calculations) { - bool hasCalculations = calculations != null && calculations.Any(); + bool hasCalculations = calculations != null && calculations.OfType().Any(); if (!hasCalculations) { @@ -121,6 +122,34 @@ return RiskeerMapDataFeaturesFactory.CreateCalculationFeatures(calculationData); } + /// + /// Create calculation features based on the provided . + /// + /// The collection of to create the calculation features for. + /// A collection of features or an empty collection when is null or empty. + public static IEnumerable CreateCalculationFeatures(IEnumerable calculations) + { + bool hasCalculations = calculations != null && calculations.OfType().Any(); + + if (!hasCalculations) + { + return new MapFeature[0]; + } + + IEnumerable calculationsWithLocationAndHydraulicBoundaryLocation = calculations.Where( + c => c.InputParameters.SurfaceLine != null + && c.InputParameters.HydraulicBoundaryLocation != null); + + MapCalculationData[] calculationData = + calculationsWithLocationAndHydraulicBoundaryLocation.Select( + calculation => new MapCalculationData( + calculation.Name, + calculation.InputParameters.SurfaceLine.ReferenceLineIntersectionWorldPoint, + calculation.InputParameters.HydraulicBoundaryLocation)).ToArray(); + + return RiskeerMapDataFeaturesFactory.CreateCalculationFeatures(calculationData); + } + private static IEnumerable GetWorldPoints(PipingSurfaceLine surfaceLine) { return surfaceLine.Points.Select(p => new Point2D(p.X, p.Y)).ToArray(); Index: Riskeer/Piping/src/Riskeer.Piping.Forms/Views/PipingFailureMechanismView.cs =================================================================== diff -u -rd9610fdd57cae01feec12d69ea4413d202d131f4 -rd2db1044e78377af2673cbdd7d2f60bc20b1c066 --- Riskeer/Piping/src/Riskeer.Piping.Forms/Views/PipingFailureMechanismView.cs (.../PipingFailureMechanismView.cs) (revision d9610fdd57cae01feec12d69ea4413d202d131f4) +++ Riskeer/Piping/src/Riskeer.Piping.Forms/Views/PipingFailureMechanismView.cs (.../PipingFailureMechanismView.cs) (revision d2db1044e78377af2673cbdd7d2f60bc20b1c066) @@ -21,6 +21,7 @@ using System; using System.Collections.Generic; +using System.Drawing; using System.Linq; using System.Windows.Forms; using Core.Common.Base; @@ -33,6 +34,7 @@ using Riskeer.Common.Forms.Factories; using Riskeer.Common.Forms.Helpers; using Riskeer.Piping.Data; +using Riskeer.Piping.Data.Probabilistic; using Riskeer.Piping.Data.SemiProbabilistic; using Riskeer.Piping.Data.SoilProfile; using Riskeer.Piping.Forms.Factories; @@ -52,6 +54,7 @@ private MapLineData surfaceLinesMapData; private MapPointData hydraulicBoundaryLocationsMapData; private MapLineData semiProbabilisticCalculationsMapData; + private MapLineData probabilisticCalculationsMapData; private MapLineData sectionsMapData; private MapPointData sectionsStartPointMapData; @@ -77,9 +80,11 @@ private RecursiveObserver, HydraulicBoundaryLocationCalculation> waveHeightCalculationsForSignalingNormObserver; private RecursiveObserver, HydraulicBoundaryLocationCalculation> waveHeightCalculationsForLowerLimitNormObserver; private RecursiveObserver, HydraulicBoundaryLocationCalculation> waveHeightCalculationsForFactorizedLowerLimitNormObserver; - private RecursiveObserver semiProbabilisticCalculationInputObserver; + private RecursiveObserver semiProbabilisticCalculationInputObserver; + private RecursiveObserver probabilisticCalculationInputObserver; private RecursiveObserver calculationGroupObserver; private RecursiveObserver semiProbabilisticCalculationObserver; + private RecursiveObserver probabilisticCalculationObserver; private RecursiveObserver surfaceLineObserver; private RecursiveObserver, PipingFailureMechanismSectionResult> sectionResultObserver; @@ -149,8 +154,10 @@ hydraulicBoundaryLocationsObserver.Dispose(); stochasticSoilModelsObserver.Dispose(); semiProbabilisticCalculationInputObserver.Dispose(); + probabilisticCalculationInputObserver.Dispose(); calculationGroupObserver.Dispose(); semiProbabilisticCalculationObserver.Dispose(); + probabilisticCalculationObserver.Dispose(); surfaceLinesObserver.Dispose(); surfaceLineObserver.Dispose(); sectionResultObserver.Dispose(); @@ -170,7 +177,8 @@ hydraulicBoundaryLocationsMapData = RiskeerMapDataFactory.CreateHydraulicBoundaryLocationsMapData(); stochasticSoilModelsMapData = RiskeerMapDataFactory.CreateStochasticSoilModelsMapData(); surfaceLinesMapData = RiskeerMapDataFactory.CreateSurfaceLinesMapData(); - semiProbabilisticCalculationsMapData = RiskeerMapDataFactory.CreateCalculationsMapData(); + semiProbabilisticCalculationsMapData = RiskeerMapDataFactory.CreateCalculationsMapData("Semi-probabilistische berekeningen", Color.MediumPurple); + probabilisticCalculationsMapData = RiskeerMapDataFactory.CreateCalculationsMapData("Probabilistische berekeningen", Color.Pink); MapDataCollection sectionsMapDataCollection = RiskeerMapDataFactory.CreateSectionsMapDataCollection(); sectionsMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsMapData(); @@ -200,6 +208,7 @@ mapDataCollection.Add(hydraulicBoundaryLocationsMapData); mapDataCollection.Add(semiProbabilisticCalculationsMapData); + mapDataCollection.Add(probabilisticCalculationsMapData); } private void CreateObservers() @@ -246,11 +255,16 @@ waveHeightCalculationsForFactorizedLowerLimitNormObserver = ObserverHelper.CreateHydraulicBoundaryLocationCalculationsObserver( AssessmentSection.WaveHeightCalculationsForFactorizedLowerLimitNorm, UpdateHydraulicBoundaryLocationsMapData); - semiProbabilisticCalculationInputObserver = new RecursiveObserver( + semiProbabilisticCalculationInputObserver = new RecursiveObserver( UpdateSemiProbabilisticCalculationsMapData, pcg => pcg.Children.Concat(pcg.Children.OfType().Select(pc => pc.InputParameters))) { Observable = FailureMechanism.CalculationsGroup }; + probabilisticCalculationInputObserver = new RecursiveObserver( + UpdateProbabilisticCalculationsMapData, pcg => pcg.Children.Concat(pcg.Children.OfType().Select(pc => pc.InputParameters))) + { + Observable = FailureMechanism.CalculationsGroup + }; calculationGroupObserver = new RecursiveObserver(UpdateSemiProbabilisticCalculationsMapData, pcg => pcg.Children) { Observable = FailureMechanism.CalculationsGroup @@ -259,7 +273,10 @@ { Observable = FailureMechanism.CalculationsGroup }; - + probabilisticCalculationObserver = new RecursiveObserver(UpdateProbabilisticCalculationsMapData, pcg => pcg.Children) + { + Observable = FailureMechanism.CalculationsGroup + }; surfaceLineObserver = new RecursiveObserver(UpdateSurfaceLinesMapData, rpslc => rpslc) { Observable = FailureMechanism.SurfaceLines @@ -318,10 +335,25 @@ private void SetSemiProbabilisticCalculationsMapData() { IEnumerable calculations = - FailureMechanism.CalculationsGroup.GetCalculations().Cast(); + FailureMechanism.CalculationsGroup.GetCalculations().OfType(); semiProbabilisticCalculationsMapData.Features = PipingMapDataFeaturesFactory.CreateCalculationFeatures(calculations); } + private void UpdateProbabilisticCalculationsMapData() + { + SetProbabilisticCalculationsMapData(); + probabilisticCalculationsMapData.NotifyObservers(); + + UpdateAssemblyMapData(); + } + + private void SetProbabilisticCalculationsMapData() + { + IEnumerable calculations = + FailureMechanism.CalculationsGroup.GetCalculations().OfType(); + probabilisticCalculationsMapData.Features = PipingMapDataFeaturesFactory.CreateCalculationFeatures(calculations); + } + #endregion #region HydraulicBoundaryLocations MapData Index: Riskeer/Piping/test/Riskeer.Piping.Forms.Test/Factories/PipingMapDataFeaturesFactoryTest.cs =================================================================== diff -u -r4235d3b1ed09e2c2848795625a50fc745d8fcce9 -rd2db1044e78377af2673cbdd7d2f60bc20b1c066 --- Riskeer/Piping/test/Riskeer.Piping.Forms.Test/Factories/PipingMapDataFeaturesFactoryTest.cs (.../PipingMapDataFeaturesFactoryTest.cs) (revision 4235d3b1ed09e2c2848795625a50fc745d8fcce9) +++ Riskeer/Piping/test/Riskeer.Piping.Forms.Test/Factories/PipingMapDataFeaturesFactoryTest.cs (.../PipingMapDataFeaturesFactoryTest.cs) (revision d2db1044e78377af2673cbdd7d2f60bc20b1c066) @@ -154,7 +154,7 @@ public void CreateCalculationFeatures_CalculationsNull_ReturnsEmptyFeaturesCollection() { // Call - IEnumerable features = PipingMapDataFeaturesFactory.CreateCalculationFeatures(null); + IEnumerable features = PipingMapDataFeaturesFactory.CreateCalculationFeatures((IEnumerable) null); // Assert CollectionAssert.IsEmpty(features); Index: Riskeer/Piping/test/Riskeer.Piping.Forms.Test/Views/PipingFailureMechanismViewTest.cs =================================================================== diff -u -r9e06f96692c7981718519db5cbb8f2e8e9b02c46 -rd2db1044e78377af2673cbdd7d2f60bc20b1c066 --- Riskeer/Piping/test/Riskeer.Piping.Forms.Test/Views/PipingFailureMechanismViewTest.cs (.../PipingFailureMechanismViewTest.cs) (revision 9e06f96692c7981718519db5cbb8f2e8e9b02c46) +++ Riskeer/Piping/test/Riskeer.Piping.Forms.Test/Views/PipingFailureMechanismViewTest.cs (.../PipingFailureMechanismViewTest.cs) (revision d2db1044e78377af2673cbdd7d2f60bc20b1c066) @@ -44,9 +44,11 @@ using Riskeer.Common.Forms.TestUtil; using Riskeer.Common.Forms.Views; using Riskeer.Piping.Data; +using Riskeer.Piping.Data.Probabilistic; using Riskeer.Piping.Data.SemiProbabilistic; using Riskeer.Piping.Data.SoilProfile; using Riskeer.Piping.Data.TestUtil; +using Riskeer.Piping.Data.TestUtil.Probabilistic; using Riskeer.Piping.Data.TestUtil.SemiProbabilistic; using Riskeer.Piping.Forms.Views; using Riskeer.Piping.Primitives; @@ -62,7 +64,8 @@ private const int sectionsCollectionIndex = 3; private const int assemblyResultsIndex = 4; private const int hydraulicBoundaryLocationsIndex = 5; - private const int calculationsIndex = 6; + private const int semiProbabilisticCalculationsIndex = 6; + private const int probabilisticCalculationsIndex = 7; private const int sectionsIndex = 0; private const int sectionsStartPointIndex = 1; @@ -74,14 +77,15 @@ private const int combinedAssemblyIndex = 3; private const int hydraulicBoundaryLocationsObserverIndex = 3; - private const int calculationObserverIndex = 4; - private const int sectionsObserverIndex = 5; - private const int sectionsStartPointObserverIndex = 6; - private const int sectionsEndPointObserverIndex = 7; - private const int simpleAssemblyObserverIndex = 8; - private const int detailedAssemblyObserverIndex = 9; - private const int tailorMadeAssemblyObserverIndex = 10; - private const int combinedAssemblyObserverIndex = 11; + private const int semiProbabilisticCalculationObserverIndex = 4; + private const int probabilisticCalculationObserverIndex = 5; + private const int sectionsObserverIndex = 6; + private const int sectionsStartPointObserverIndex = 7; + private const int sectionsEndPointObserverIndex = 8; + private const int simpleAssemblyObserverIndex = 9; + private const int detailedAssemblyObserverIndex = 10; + private const int tailorMadeAssemblyObserverIndex = 11; + private const int combinedAssemblyObserverIndex = 12; [Test] public void Constructor_FailureMechanismNull_ThrowsArgumentNullException() @@ -104,10 +108,10 @@ public void Constructor_AssessmentSectionNull_ThrowsArgumentNullException() { // Call - TestDelegate call = () => new PipingFailureMechanismView(new PipingFailureMechanism(), null); + void Call() => new PipingFailureMechanismView(new PipingFailureMechanism(), null); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Assert.AreEqual("assessmentSection", exception.ParamName); } @@ -269,7 +273,7 @@ Assert.IsInstanceOf(mapData); List mapDataList = mapData.Collection.ToList(); - Assert.AreEqual(7, mapDataList.Count); + Assert.AreEqual(8, mapDataList.Count); MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, mapDataList[referenceLineIndex]); AssertSurfaceLinesMapData(failureMechanism.SurfaceLines, mapDataList[surfaceLinesIndex]); @@ -280,7 +284,8 @@ MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]); AssertStochasticSoilModelsMapData(failureMechanism.StochasticSoilModels, mapDataList[stochasticSoilModelsIndex]); - AssertCalculationsMapData(failureMechanism.Calculations.Cast(), mapDataList[calculationsIndex]); + AssertSemiProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType(), mapDataList[semiProbabilisticCalculationsIndex]); + AssertProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType(), mapDataList[probabilisticCalculationsIndex]); MapDataTestHelper.AssertAssemblyMapDataCollection(expectedSimpleAssembly, expectedDetailedAssembly, @@ -630,19 +635,19 @@ SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( new TestHydraulicBoundaryLocation()); var calculationB = - SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( + ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( new TestHydraulicBoundaryLocation()); calculationA.InputParameters.SurfaceLine = surfaceLineA; calculationB.InputParameters.SurfaceLine = surfaceLineB; failureMechanism.CalculationsGroup.Children.Add(calculationA); - var calculationMapData = (MapLineData) map.Data.Collection.ElementAt(calculationsIndex); + var semiProbabilisticCalculationMapData = (MapLineData) map.Data.Collection.ElementAt(semiProbabilisticCalculationsIndex); var mocks = new MockRepository(); IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); - observers[calculationObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[semiProbabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver()); observers[simpleAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); observers[detailedAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); observers[tailorMadeAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); @@ -654,13 +659,13 @@ failureMechanism.CalculationsGroup.NotifyObservers(); // Then - AssertCalculationsMapData(failureMechanism.Calculations.Cast(), calculationMapData); + AssertSemiProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType(), semiProbabilisticCalculationMapData); mocks.VerifyAll(); } } [Test] - public void GivenViewWithCalculationInputData_WhenCalculationInputUpdatedAndNotified_ThenMapDataUpdated() + public void GivenViewWithSemiProbabilisticCalculationInputData_WhenCalculationInputUpdatedAndNotified_ThenMapDataUpdated() { // Given var surfaceLineA = new PipingSurfaceLine(string.Empty); @@ -682,7 +687,7 @@ var calculationScenario = SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( new TestHydraulicBoundaryLocation()); - + calculationScenario.InputParameters.SurfaceLine = surfaceLineA; var failureMechanism = new PipingFailureMechanism(); @@ -692,11 +697,11 @@ { IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; - var calculationMapData = (MapLineData) map.Data.Collection.ElementAt(calculationsIndex); + var calculationMapData = (MapLineData) map.Data.Collection.ElementAt(semiProbabilisticCalculationsIndex); var mocks = new MockRepository(); IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); - observers[calculationObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[semiProbabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver()); observers[simpleAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); observers[detailedAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); observers[tailorMadeAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); @@ -708,13 +713,13 @@ calculationScenario.InputParameters.NotifyObservers(); // Then - AssertCalculationsMapData(failureMechanism.Calculations.Cast(), calculationMapData); + AssertSemiProbabilisticCalculationsMapData(failureMechanism.Calculations.Cast(), calculationMapData); mocks.VerifyAll(); } } [Test] - public void GivenViewWithCalculationData_WhenCalculationUpdatedAndNotified_ThenMapDataUpdated() + public void GivenViewWithProbabilisticCalculationInputData_WhenCalculationInputUpdatedAndNotified_ThenMapDataUpdated() { // Given var surfaceLineA = new PipingSurfaceLine(string.Empty); @@ -734,6 +739,60 @@ surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5); var calculationScenario = + ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( + new TestHydraulicBoundaryLocation()); + + calculationScenario.InputParameters.SurfaceLine = surfaceLineA; + + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculationScenario); + + using (var view = new PipingFailureMechanismView(failureMechanism, new AssessmentSectionStub())) + { + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + var calculationMapData = (MapLineData) map.Data.Collection.ElementAt(probabilisticCalculationsIndex); + + var mocks = new MockRepository(); + IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); + observers[probabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[simpleAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[detailedAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[tailorMadeAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[combinedAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); + mocks.ReplayAll(); + + // When + calculationScenario.InputParameters.SurfaceLine = surfaceLineB; + calculationScenario.InputParameters.NotifyObservers(); + + // Then + AssertProbabilisticCalculationsMapData(failureMechanism.Calculations.Cast(), calculationMapData); + mocks.VerifyAll(); + } + } + + [Test] + public void GivenViewWithSemiProbabilisticCalculationData_WhenCalculationUpdatedAndNotified_ThenMapDataUpdated() + { + // Given + var surfaceLineA = new PipingSurfaceLine(string.Empty); + surfaceLineA.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.0), + new Point3D(3.0, 0.0, 1.7) + }); + + var surfaceLineB = new PipingSurfaceLine(string.Empty); + surfaceLineB.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.5), + new Point3D(3.0, 0.0, 1.8) + }); + surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3); + surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5); + + var calculationScenario = SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( new TestHydraulicBoundaryLocation()); @@ -746,11 +805,11 @@ { IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; - var calculationMapData = (MapLineData) map.Data.Collection.ElementAt(calculationsIndex); + var calculationMapData = (MapLineData) map.Data.Collection.ElementAt(semiProbabilisticCalculationsIndex); var mocks = new MockRepository(); IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); - observers[calculationObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[semiProbabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver()); observers[simpleAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); observers[detailedAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); observers[tailorMadeAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); @@ -762,12 +821,66 @@ calculationScenario.NotifyObservers(); // Then - AssertCalculationsMapData(failureMechanism.Calculations.Cast(), calculationMapData); + AssertSemiProbabilisticCalculationsMapData(failureMechanism.Calculations.Cast(), calculationMapData); mocks.VerifyAll(); } } [Test] + public void GivenViewWithProbabilisticCalculationData_WhenCalculationUpdatedAndNotified_ThenMapDataUpdated() + { + // Given + var surfaceLineA = new PipingSurfaceLine(string.Empty); + surfaceLineA.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.0), + new Point3D(3.0, 0.0, 1.7) + }); + + var surfaceLineB = new PipingSurfaceLine(string.Empty); + surfaceLineB.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.5), + new Point3D(3.0, 0.0, 1.8) + }); + surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3); + surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5); + + var calculationScenario = + ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( + new TestHydraulicBoundaryLocation()); + + calculationScenario.InputParameters.SurfaceLine = surfaceLineA; + + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculationScenario); + + using (var view = new PipingFailureMechanismView(failureMechanism, new AssessmentSectionStub())) + { + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + var calculationMapData = (MapLineData) map.Data.Collection.ElementAt(probabilisticCalculationsIndex); + + var mocks = new MockRepository(); + IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); + observers[probabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[simpleAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[detailedAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[tailorMadeAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[combinedAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); + mocks.ReplayAll(); + + // When + calculationScenario.Name = "new name"; + calculationScenario.NotifyObservers(); + + // Then + AssertProbabilisticCalculationsMapData(failureMechanism.Calculations.Cast(), calculationMapData); + mocks.VerifyAll(); + } + } + + [Test] public void GivenViewWithAssemblyData_WhenFailureMechanismNotified_ThenMapDataUpdated() { // Given @@ -889,7 +1002,7 @@ var mocks = new MockRepository(); IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); - observers[calculationObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[semiProbabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver()); observers[simpleAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); observers[detailedAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); observers[tailorMadeAssemblyObserverIndex].Expect(obs => obs.UpdateObserver()); @@ -999,13 +1112,14 @@ public void UpdateObserver_DataUpdated_MapLayersSameOrder() { // Setup - const int updatedReferenceLineLayerIndex = referenceLineIndex + 6; + const int updatedReferenceLineLayerIndex = referenceLineIndex + 7; const int updatedSurfaceLineLayerIndex = surfaceLinesIndex - 1; const int updatedSectionCollectionIndex = sectionsCollectionIndex - 1; const int updatedAssemblyResultsCollectionIndex = assemblyResultsIndex - 1; const int updatedHydraulicLocationsLayerIndex = hydraulicBoundaryLocationsIndex - 1; const int updatedStochasticSoilModelsLayerIndex = stochasticSoilModelsIndex - 1; - const int updatedCalculationsIndex = calculationsIndex - 1; + const int updatedSemiProbabilisticCalculationsIndex = semiProbabilisticCalculationsIndex - 1; + const int updatedProbabilisticCalculationsIndex = probabilisticCalculationsIndex - 1; var assessmentSection = new AssessmentSectionStub(); @@ -1040,9 +1154,12 @@ var stochasticSoilModelsData = (MapLineData) mapDataList[updatedStochasticSoilModelsLayerIndex]; Assert.AreEqual("Stochastische ondergrondmodellen", stochasticSoilModelsData.Name); - var calculationsData = (MapLineData) mapDataList[updatedCalculationsIndex]; - Assert.AreEqual("Berekeningen", calculationsData.Name); + var semiProbabilisticCalculationsData = (MapLineData) mapDataList[updatedSemiProbabilisticCalculationsIndex]; + Assert.AreEqual("Semi-probabilistische berekeningen", semiProbabilisticCalculationsData.Name); + var probabilisticCalculationsData = (MapLineData) mapDataList[updatedProbabilisticCalculationsIndex]; + Assert.AreEqual("Probabilistische berekeningen", probabilisticCalculationsData.Name); + var points = new List { new Point2D(2.0, 5.0), @@ -1074,8 +1191,11 @@ var actualStochasticSoilModelsData = (MapLineData) mapDataList[updatedStochasticSoilModelsLayerIndex]; Assert.AreEqual("Stochastische ondergrondmodellen", actualStochasticSoilModelsData.Name); - var actualCalculationsData = (MapLineData) mapDataList[updatedCalculationsIndex]; - Assert.AreEqual("Berekeningen", actualCalculationsData.Name); + var actualSemiProbabilisticCalculationsData = (MapLineData) mapDataList[updatedSemiProbabilisticCalculationsIndex]; + Assert.AreEqual("Semi-probabilistische berekeningen", actualSemiProbabilisticCalculationsData.Name); + + var actualProbabilisticCalculationsData = (MapLineData) mapDataList[updatedProbabilisticCalculationsIndex]; + Assert.AreEqual("Probabilistische berekeningen", actualProbabilisticCalculationsData.Name); } } @@ -1115,7 +1235,7 @@ Assert.AreEqual("Stochastische ondergrondmodellen", mapData.Name); } - private static void AssertCalculationsMapData(IEnumerable calculations, MapData mapData) + private static void AssertSemiProbabilisticCalculationsMapData(IEnumerable calculations, MapData mapData) { Assert.IsInstanceOf(mapData); var calculationsMapData = (MapLineData) mapData; @@ -1137,34 +1257,61 @@ geometries[0].PointCollections.First()); } - Assert.AreEqual("Berekeningen", mapData.Name); + Assert.AreEqual("Semi-probabilistische berekeningen", mapData.Name); } + private static void AssertProbabilisticCalculationsMapData(IEnumerable calculations, MapData mapData) + { + Assert.IsInstanceOf(mapData); + var calculationsMapData = (MapLineData) mapData; + ProbabilisticPipingCalculationScenario[] calculationsArray = calculations.ToArray(); + MapFeature[] calculationsFeatures = calculationsMapData.Features.ToArray(); + Assert.AreEqual(calculationsArray.Length, calculationsFeatures.Length); + + for (var index = 0; index < calculationsArray.Length; index++) + { + MapGeometry[] geometries = calculationsFeatures[index].MapGeometries.ToArray(); + Assert.AreEqual(1, geometries.Length); + + ProbabilisticPipingCalculationScenario calculation = calculationsArray[index]; + CollectionAssert.AreEquivalent(new[] + { + calculation.InputParameters.SurfaceLine.ReferenceLineIntersectionWorldPoint, + calculation.InputParameters.HydraulicBoundaryLocation.Location + }, + geometries[0].PointCollections.First()); + } + + Assert.AreEqual("Probabilistische berekeningen", mapData.Name); + } + private static void AssertEmptyMapData(MapDataCollection mapDataCollection) { Assert.AreEqual("Dijken en dammen - Piping", mapDataCollection.Name); List mapDataList = mapDataCollection.Collection.ToList(); - Assert.AreEqual(7, mapDataList.Count); + Assert.AreEqual(8, mapDataList.Count); var referenceLineMapData = (MapLineData) mapDataList[referenceLineIndex]; var stochasticSoilModelsMapData = (MapLineData) mapDataList[stochasticSoilModelsIndex]; var surfaceLinesMapData = (MapLineData) mapDataList[surfaceLinesIndex]; var hydraulicBoundaryLocationsMapData = (MapPointData) mapDataList[hydraulicBoundaryLocationsIndex]; - var calculationsMapData = (MapLineData) mapDataList[calculationsIndex]; + var semiProbabilisticCalculationsMapData = (MapLineData) mapDataList[semiProbabilisticCalculationsIndex]; + var probabilisticCalculationsMapData = (MapLineData) mapDataList[probabilisticCalculationsIndex]; CollectionAssert.IsEmpty(referenceLineMapData.Features); CollectionAssert.IsEmpty(stochasticSoilModelsMapData.Features); CollectionAssert.IsEmpty(surfaceLinesMapData.Features); CollectionAssert.IsEmpty(hydraulicBoundaryLocationsMapData.Features); - CollectionAssert.IsEmpty(calculationsMapData.Features); + CollectionAssert.IsEmpty(semiProbabilisticCalculationsMapData.Features); Assert.AreEqual("Referentielijn", referenceLineMapData.Name); Assert.AreEqual("Stochastische ondergrondmodellen", stochasticSoilModelsMapData.Name); Assert.AreEqual("Profielschematisaties", surfaceLinesMapData.Name); Assert.AreEqual("Hydraulische belastingen", hydraulicBoundaryLocationsMapData.Name); - Assert.AreEqual("Berekeningen", calculationsMapData.Name); + Assert.AreEqual("Semi-probabilistische berekeningen", semiProbabilisticCalculationsMapData.Name); + Assert.AreEqual("Probabilistische berekeningen", probabilisticCalculationsMapData.Name); var sectionsMapDataCollection = (MapDataCollection) mapDataList[sectionsCollectionIndex]; Assert.AreEqual("Vakindeling", sectionsMapDataCollection.Name); @@ -1227,9 +1374,12 @@ var hydraulicBoundaryLocationsMapDataObserver = mocks.StrictMock(); mapDataArray[hydraulicBoundaryLocationsIndex].Attach(hydraulicBoundaryLocationsMapDataObserver); - var calculationsMapDataObserver = mocks.StrictMock(); - mapDataArray[calculationsIndex].Attach(calculationsMapDataObserver); + var semiProbabilisticCalculationsMapDataObserver = mocks.StrictMock(); + mapDataArray[semiProbabilisticCalculationsIndex].Attach(semiProbabilisticCalculationsMapDataObserver); + var probabilisticCalculationsMapDataObserver = mocks.StrictMock(); + mapDataArray[probabilisticCalculationsIndex].Attach(probabilisticCalculationsMapDataObserver); + MapData[] sectionsCollection = ((MapDataCollection) mapDataArray[sectionsCollectionIndex]).Collection.ToArray(); var sectionsMapDataObserver = mocks.StrictMock(); sectionsCollection[sectionsIndex].Attach(sectionsMapDataObserver); @@ -1259,7 +1409,8 @@ stochasticSoilModelsMapDataObserver, surfaceLinesMapDataObserver, hydraulicBoundaryLocationsMapDataObserver, - calculationsMapDataObserver, + semiProbabilisticCalculationsMapDataObserver, + probabilisticCalculationsMapDataObserver, sectionsMapDataObserver, sectionsStartPointMapDataObserver, sectionsEndPointMapDataObserver,