Index: Riskeer/Integration/src/Riskeer.Integration.Forms/PropertyClasses/IFailureMechanismContributionNormChangeHandler.cs
===================================================================
diff -u
--- Riskeer/Integration/src/Riskeer.Integration.Forms/PropertyClasses/IFailureMechanismContributionNormChangeHandler.cs	(revision 0)
+++ Riskeer/Integration/src/Riskeer.Integration.Forms/PropertyClasses/IFailureMechanismContributionNormChangeHandler.cs	(revision a18a961b395ee6b46324cc00b022074eb091ff19)
@@ -0,0 +1,58 @@
+// Copyright (C) Stichting Deltares 2021. All rights reserved.
+//
+// This file is part of Riskeer.
+//
+// Riskeer is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using Riskeer.Common.Data.AssessmentSection;
+using Riskeer.Common.Data.Contribution;
+
+namespace Riskeer.Integration.Forms.PropertyClasses
+{
+    /// <summary>
+    /// Interface for an object that can properly change the <see cref="FailureMechanismContribution.Norm"/>
+    /// of an <see cref="IAssessmentSection"/>.
+    /// </summary>
+    public interface IFailureMechanismContributionNormChangeHandler
+    {
+        /// <summary>
+        /// Change the normative norm type.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="action"/>
+        /// is <c>null</c>.</exception>
+        void ChangeNormativeNormType(Action action);
+
+        /// <summary>
+        /// Change the normative norm.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="action"/>
+        /// is <c>null</c>.</exception>
+        void ChangeNormativeNorm(Action action);
+
+        /// <summary>
+        /// Change the norm.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="action"/>
+        /// is <c>null</c>.</exception>
+        void ChangeNorm(Action action);
+    }
+}
\ No newline at end of file
Index: Riskeer/Integration/src/Riskeer.Integration.Plugin/Handlers/FailureMechanismContributionNormChangeHandler.cs
===================================================================
diff -u -r637f1c4a9c53bbc1968c7a2336ff9ebc892d5ea3 -ra18a961b395ee6b46324cc00b022074eb091ff19
--- Riskeer/Integration/src/Riskeer.Integration.Plugin/Handlers/FailureMechanismContributionNormChangeHandler.cs	(.../FailureMechanismContributionNormChangeHandler.cs)	(revision 637f1c4a9c53bbc1968c7a2336ff9ebc892d5ea3)
+++ Riskeer/Integration/src/Riskeer.Integration.Plugin/Handlers/FailureMechanismContributionNormChangeHandler.cs	(.../FailureMechanismContributionNormChangeHandler.cs)	(revision a18a961b395ee6b46324cc00b022074eb091ff19)
@@ -28,6 +28,7 @@
 using Riskeer.Common.Data.AssessmentSection;
 using Riskeer.Common.Data.Calculation;
 using Riskeer.Common.Data.Contribution;
+using Riskeer.Integration.Forms.PropertyClasses;
 using Riskeer.Integration.Plugin.Properties;
 using Riskeer.Integration.Service;
 using CoreCommonBaseResources = Core.Common.Base.Properties.Resources;
@@ -62,29 +63,42 @@
 
         public void ChangeNormativeNormType(Action action)
         {
-            // Clear only Piping and macro without manual assessment level
             PerformAction(action, "Als u de norm aanpast, dan worden de rekenresultaten van semi-probabilistische berekeningen zonder handmatig toetspeil verwijderd. " +
                                   Environment.NewLine + Environment.NewLine +
                                   "Weet u zeker dat u wilt doorgaan?",
-                          () => new IObservable[0]);
+                          () =>
+                          {
+                              var affectedObjects = new List<IObservable>();
+                              affectedObjects.AddRange(ClearAllNormDependentSemiProbabilisticCalculationOutput());
+                              return affectedObjects;
+                          });
         }
 
         public void ChangeNormativeNorm(Action action)
         {
-            // Clear only locations depending on this norm and Piping and macro without manual assessment level
             PerformAction(action, "Als u de norm aanpast, dan worden de rekenresultaten van alle hydraulische belastingenlocaties behorende bij deze norm en semi-probabilistische berekeningen zonder handmatig toetspeil verwijderd. " +
                                   Environment.NewLine + Environment.NewLine +
                                   "Weet u zeker dat u wilt doorgaan?",
-                          () => new IObservable[0]);
+                          () =>
+                          {
+                              var affectedObjects = new List<IObservable>();
+                              affectedObjects.AddRange(ClearNormDependingHydraulicBoundaryLocationCalculationOutput());
+                              affectedObjects.AddRange(ClearAllNormDependentSemiProbabilisticCalculationOutput());
+                              return affectedObjects;
+                          });
         }
 
         public void ChangeNorm(Action action)
         {
-            // Clear only locations depending on this norm
             PerformAction(action, "Als u de norm aanpast, dan worden de rekenresultaten van alle hydraulische belastingenlocaties behorende bij deze norm verwijderd. " +
                                   Environment.NewLine + Environment.NewLine +
                                   "Weet u zeker dat u wilt doorgaan?",
-                          () => new IObservable[0]);
+                          () =>
+                          {
+                              var affectedObjects = new List<IObservable>();
+                              affectedObjects.AddRange(ClearNormDependingHydraulicBoundaryLocationCalculationOutput());
+                              return affectedObjects;
+                          });
         }
 
         private void PerformAction(Action action, string confirmationMessage, Func<IEnumerable<IObservable>> clearDataFunc)
@@ -123,40 +137,28 @@
             }
         }
 
-        private IEnumerable<IObservable> ClearAllNormDependentCalculationOutput()
+        private IEnumerable<IObservable> ClearAllNormDependentSemiProbabilisticCalculationOutput()
         {
-            List<IObservable> affectedObjects = RiskeerDataSynchronizationService.ClearFailureMechanismCalculationOutputs(assessmentSection).ToList();
-            if (affectedObjects.Count > 0)
+            IEnumerable<IObservable> affectedObjects = RiskeerDataSynchronizationService.ClearAllSemiProbabilisticCalculationOutput(assessmentSection);
+            if (affectedObjects.Any())
             {
-                log.InfoFormat(Resources.ChangeHandler_Results_of_NumberOfCalculations_0_calculations_cleared,
-                               affectedObjects.OfType<ICalculation>().Count());
+                log.InfoFormat(Resources.FailureMechanismContributionNormChangeHandler_ClearAllNormDependentSemiProbabilisticCalculationOutput_Results_of_NumberOfCalculations_0_calculations_cleared,
+                               affectedObjects.OfType<ICalculationScenario>().Count());
             }
 
-            affectedObjects.AddRange(ClearAllHydraulicBoundaryLocationCalculationOutput());
-
             return affectedObjects;
         }
 
-        private IEnumerable<IObservable> ClearAllHydraulicBoundaryLocationCalculationOutput()
+        private IEnumerable<IObservable> ClearNormDependingHydraulicBoundaryLocationCalculationOutput()
         {
-            IEnumerable<IObservable> affectedObjects = RiskeerDataSynchronizationService.ClearHydraulicBoundaryLocationCalculationOutput(assessmentSection);
+            IEnumerable<IObservable> affectedObjects = RiskeerDataSynchronizationService.ClearHydraulicBoundaryLocationCalculationOutputForNormativeNorm(assessmentSection);
 
             if (affectedObjects.Any())
             {
-                log.Info(Resources.FailureMechanismContributionNormChangeHandler_Waveheight_and_design_water_level_results_cleared);
-                return affectedObjects;
+                log.Info(Resources.FailureMechanismContributionNormChangeHandler_ClearNormDependingHydraulicBoundaryLocationCalculationOutput_Calculation_results_cleared);
             }
 
-            return Enumerable.Empty<IObservable>();
+            return affectedObjects;
         }
     }
-
-    public interface IFailureMechanismContributionNormChangeHandler
-    {
-        void ChangeNormativeNormType(Action action);
-
-        void ChangeNormativeNorm(Action action);
-
-        void ChangeNorm(Action action);
-    }
 }
\ No newline at end of file
Index: Riskeer/Integration/src/Riskeer.Integration.Plugin/Properties/Resources.Designer.cs
===================================================================
diff -u -r426bffa17b9f5056b2f1399c76326f8eb84405b1 -ra18a961b395ee6b46324cc00b022074eb091ff19
--- Riskeer/Integration/src/Riskeer.Integration.Plugin/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision 426bffa17b9f5056b2f1399c76326f8eb84405b1)
+++ Riskeer/Integration/src/Riskeer.Integration.Plugin/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision a18a961b395ee6b46324cc00b022074eb091ff19)
@@ -1,4 +1,4 @@
-// Copyright (C) Stichting Deltares 2021. All rights reserved.
+// Copyright (C) Stichting Deltares 2021. All rights reserved.
 //
 // This file is part of Riskeer.
 //
@@ -281,24 +281,35 @@
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to De resultaten van {0} berekeningen zijn verwijderd..
+        ///   Looks up a localized string similar to Opmerkingen.
         /// </summary>
-        public static string ChangeHandler_Results_of_NumberOfCalculations_0_calculations_cleared {
+        public static string Comment_DisplayName {
             get {
-                return ResourceManager.GetString("ChangeHandler_Results_of_NumberOfCalculations_0_calculations_cleared", resourceCulture);
+                return ResourceManager.GetString("Comment_DisplayName", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Opmerkingen.
+        ///   Looks up a localized string similar to De resultaten van {0} semi-probabilistische berekeningen zonder handmatige waterstand zijn verwijderd..
         /// </summary>
-        public static string Comment_DisplayName {
+        public static string FailureMechanismContributionNormChangeHandler_ClearAllNormDependentSemiProbabilisticCalculationOutput_Results_of_NumberOfCalculations_0_calculations_cleared {
             get {
-                return ResourceManager.GetString("Comment_DisplayName", resourceCulture);
+                return ResourceManager.GetString("FailureMechanismContributionNormChangeHandler_ClearAllNormDependentSemiProbabilis" +
+                        "ticCalculationOutput_Results_of_NumberOfCalculations_0_calculations_cleared", resourceCulture);
             }
         }
         
         /// <summary>
+        ///   Looks up a localized string similar to Alle berekende hydraulische belastingen behorende bij de gewijzigde norm zijn verwijderd..
+        /// </summary>
+        public static string FailureMechanismContributionNormChangeHandler_ClearNormDependingHydraulicBoundaryLocationCalculationOutput_Calculation_results_cleared {
+            get {
+                return ResourceManager.GetString("FailureMechanismContributionNormChangeHandler_ClearNormDependingHydraulicBoundary" +
+                        "LocationCalculationOutput_Calculation_results_cleared", resourceCulture);
+            }
+        }
+        
+        /// <summary>
         ///   Looks up a localized string similar to Als u de norm aanpast, dan worden alle rekenresultaten van alle hydraulische belastingenlocaties en toetssporen verwijderd.
         ///
         ///Weet u zeker dat u wilt doorgaan?.
@@ -311,16 +322,6 @@
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Alle berekende hydraulische belastingen zijn verwijderd..
-        /// </summary>
-        public static string FailureMechanismContributionNormChangeHandler_Waveheight_and_design_water_level_results_cleared {
-            get {
-                return ResourceManager.GetString("FailureMechanismContributionNormChangeHandler_Waveheight_and_design_water_level_r" +
-                        "esults_cleared", resourceCulture);
-            }
-        }
-        
-        /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
         public static System.Drawing.Bitmap Foreshore {
Index: Riskeer/Integration/src/Riskeer.Integration.Plugin/Properties/Resources.resx
===================================================================
diff -u -r426bffa17b9f5056b2f1399c76326f8eb84405b1 -ra18a961b395ee6b46324cc00b022074eb091ff19
--- Riskeer/Integration/src/Riskeer.Integration.Plugin/Properties/Resources.resx	(.../Resources.resx)	(revision 426bffa17b9f5056b2f1399c76326f8eb84405b1)
+++ Riskeer/Integration/src/Riskeer.Integration.Plugin/Properties/Resources.resx	(.../Resources.resx)	(revision a18a961b395ee6b46324cc00b022074eb091ff19)
@@ -140,12 +140,12 @@
 
 Wilt u doorgaan?</value>
   </data>
-    <data name="ChangeHandler_Results_of_NumberOfCalculations_0_calculations_cleared" xml:space="preserve">
-    <value>De resultaten van {0} berekeningen zijn verwijderd.</value>
+    <data name="FailureMechanismContributionNormChangeHandler_ClearAllNormDependentSemiProbabilisticCalculationOutput_Results_of_NumberOfCalculations_0_calculations_cleared" xml:space="preserve">
+    <value>De resultaten van {0} semi-probabilistische berekeningen zonder handmatige waterstand zijn verwijderd.</value>
   </data>
-    <data name="FailureMechanismContributionNormChangeHandler_Waveheight_and_design_water_level_results_cleared"
+    <data name="FailureMechanismContributionNormChangeHandler_ClearNormDependingHydraulicBoundaryLocationCalculationOutput_Calculation_results_cleared"
           xml:space="preserve">
-    <value>Alle berekende hydraulische belastingen zijn verwijderd.</value>
+    <value>Alle berekende hydraulische belastingen behorende bij de gewijzigde norm zijn verwijderd.</value>
   </data>
     <data name="FailureMechanismContributionNormChangeHandler_Confirm_change_norm_and_clear_dependent_data"
           xml:space="preserve">
Index: Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/Handlers/FailureMechanismContributionNormChangeHandlerTest.cs
===================================================================
diff -u -rb3501173ad479cdddcd0b8a2dcc97826a1ff0edd -ra18a961b395ee6b46324cc00b022074eb091ff19
--- Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/Handlers/FailureMechanismContributionNormChangeHandlerTest.cs	(.../FailureMechanismContributionNormChangeHandlerTest.cs)	(revision b3501173ad479cdddcd0b8a2dcc97826a1ff0edd)
+++ Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/Handlers/FailureMechanismContributionNormChangeHandlerTest.cs	(.../FailureMechanismContributionNormChangeHandlerTest.cs)	(revision a18a961b395ee6b46324cc00b022074eb091ff19)
@@ -24,18 +24,18 @@
 using System.Linq;
 using Core.Common.Base;
 using Core.Common.TestUtil;
+using Core.Common.Util.Extensions;
 using NUnit.Extensions.Forms;
 using NUnit.Framework;
 using Rhino.Mocks;
 using Riskeer.Common.Data.AssessmentSection;
 using Riskeer.Common.Data.Calculation;
-using Riskeer.Common.Data.Hydraulics;
-using Riskeer.Common.Forms.PropertyClasses;
-using Riskeer.DuneErosion.Data;
-using Riskeer.DuneErosion.Data.TestUtil;
 using Riskeer.Integration.Data;
+using Riskeer.Integration.Forms.PropertyClasses;
 using Riskeer.Integration.Plugin.Handlers;
 using Riskeer.Integration.TestUtil;
+using Riskeer.MacroStabilityInwards.Data;
+using Riskeer.Piping.Data.SemiProbabilistic;
 
 namespace Riskeer.Integration.Plugin.Test.Handlers
 {
@@ -54,7 +54,7 @@
             var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
 
             // Assert
-            Assert.IsInstanceOf<IObservablePropertyChangeHandler>(handler);
+            Assert.IsInstanceOf<IFailureMechanismContributionNormChangeHandler>(handler);
             mocks.VerifyAll();
         }
 
@@ -70,22 +70,26 @@
         }
 
         [Test]
-        public void SetPropertyValueAfterConfirmation_SetValueNull_ThrowArgumentNullException()
+        public void ChangeNormativeNormType_ActionNull_ThrowsArgumentNullException()
         {
             // Setup
-            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput();
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
 
             // Call
-            void Call() => handler.SetPropertyValueAfterConfirmation(null);
+            void Call() => handler.ChangeNormativeNormType(null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(Call);
-            Assert.AreEqual("setValue", exception.ParamName);
+            Assert.AreEqual("action", exception.ParamName);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void SetPropertyValueAfterConfirmation_Always_ConfirmationRequired()
+        public void ChangeNormativeNormType_WithAction_ConfirmationRequired()
         {
             // Setup
             var title = "";
@@ -99,257 +103,418 @@
                 tester.ClickCancel();
             };
 
-            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput();
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
 
             // Call
-            handler.SetPropertyValueAfterConfirmation(() => {});
+            handler.ChangeNormativeNormType(() => {});
 
             // Assert
             Assert.AreEqual("Bevestigen", title);
-            string expectedMessage = "Als u de norm aanpast, dan worden alle rekenresultaten van alle hydraulische belastingenlocaties en toetssporen verwijderd."
+            string expectedMessage = "Als u de norm aanpast, dan worden de rekenresultaten van semi-probabilistische berekeningen zonder handmatig toetspeil verwijderd. "
                                      + Environment.NewLine
-                                     + Environment.NewLine +
-                                     "Weet u zeker dat u wilt doorgaan?";
+                                     + Environment.NewLine
+                                     + "Weet u zeker dat u wilt doorgaan?";
             Assert.AreEqual(expectedMessage, message);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void SetPropertyValueAfterConfirmation_FullyConfiguredAssessmentSectionConfirmationGiven_AllCalculationOutputClearedAndContributionsUpdatedAndReturnsAllAffectedObjects()
+        public void GivenCalculationsWithOutput_WhenChangingNormativeNormType_ThenAllDependingOutputClearedAndActionPerformedAndAllAffectedObjectsNotified()
         {
-            // Setup
+            // Given
             DialogBoxHandler = (name, wnd) =>
             {
                 var tester = new MessageBoxTester(wnd);
                 tester.ClickOk();
             };
 
             AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
-            ICalculation[] expectedAffectedCalculations = assessmentSection.GetFailureMechanisms()
-                                                                           .SelectMany(fm => fm.Calculations)
-                                                                           .Where(c => c.HasOutput)
+            ICalculation[] expectedAffectedCalculations = assessmentSection.Piping
+                                                                           .Calculations
+                                                                           .OfType<SemiProbabilisticPipingCalculationScenario>()
+                                                                           .Where(c => c.HasOutput && !c.InputParameters.UseAssessmentLevelManualInput)
+                                                                           .Concat<ICalculation>(
+                                                                               assessmentSection.MacroStabilityInwards
+                                                                                                .Calculations
+                                                                                                .OfType<MacroStabilityInwardsCalculationScenario>()
+                                                                                                .Where(c => c.HasOutput && !c.InputParameters.UseAssessmentLevelManualInput))
                                                                            .ToArray();
 
-            IEnumerable<IObservable> userDefinedCalculations = GetUserDefinedCalculations(assessmentSection);
-
             IEnumerable<IObservable> expectedAffectedObjects =
-                expectedAffectedCalculations.Cast<IObservable>()
-                                            .Concat(assessmentSection.GetFailureMechanisms())
-                                            .Concat(assessmentSection.WaterLevelCalculationsForSignalingNorm)
-                                            .Concat(assessmentSection.WaterLevelCalculationsForLowerLimitNorm)
-                                            .Concat(userDefinedCalculations)
-                                            .Concat(GetAllAffectedDuneLocationCalculations(assessmentSection.DuneErosion))
-                                            .Concat(new IObservable[]
+                expectedAffectedCalculations.Concat(new IObservable[]
                                             {
                                                 assessmentSection.FailureMechanismContribution
-                                            }).ToArray();
+                                            })
+                                            .ToArray();
 
-            var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
+            var mocks = new MockRepository();
+            var observer = mocks.StrictMock<IObserver>();
+            observer.Expect(o => o.UpdateObserver()).Repeat.Times(expectedAffectedObjects.Count());
+            mocks.ReplayAll();
 
-            IEnumerable<IObservable> affectedObjects = null;
+            expectedAffectedObjects.ForEachElementDo(obj => obj.Attach(observer));
 
-            // Call
-            void Call() => affectedObjects = handler.SetPropertyValueAfterConfirmation(() => {});
+            var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
 
-            // Assert
+            // When
+            var actionPerformed = false;
+            void Call() => handler.ChangeNormativeNormType(() => actionPerformed = true);
+
+            // Then
             var expectedMessages = new[]
             {
-                "De resultaten van 36 berekeningen zijn verwijderd.",
-                "Alle berekende hydraulische belastingen zijn verwijderd."
+                $"De resultaten van {expectedAffectedCalculations.Length} semi-probabilistische berekeningen zonder handmatige waterstand zijn verwijderd."
             };
-            TestHelper.AssertLogMessagesAreGenerated(Call, expectedMessages, 2);
-
-            CollectionAssert.IsEmpty(assessmentSection.GetFailureMechanisms().SelectMany(fm => fm.Calculations).Where(c => c.HasOutput),
-                                     "There should be no calculations with output.");
-
-            AssertHydraulicBoundaryLocationCalculationOutput(assessmentSection, false);
-            DuneLocationsTestHelper.AssertDuneLocationCalculationsHaveNoOutputs(assessmentSection.DuneErosion);
-
-            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+            TestHelper.AssertLogMessagesAreGenerated(Call, expectedMessages, 1);
+            Assert.IsTrue(actionPerformed);
+            CollectionAssert.IsEmpty(expectedAffectedCalculations.Where(c => c.HasOutput));
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void SetPropertyValueAfterConfirmation_FullyConfiguredAssessmentSectionWithoutCalculationOutputConfirmationGiven_NormChangedContributionsUpdatedAndReturnsAllAffectedObjects()
+        public void GivenCalculationsWithoutOutput_WhenChangingNormativeNormType_ThenActionPerformedAndContributionNotified()
         {
-            // Setup
+            // Given
             DialogBoxHandler = (name, wnd) =>
             {
                 var tester = new MessageBoxTester(wnd);
                 tester.ClickOk();
             };
 
-            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput();
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
+            ICalculation[] calculations = assessmentSection.Piping
+                                                           .Calculations
+                                                           .OfType<SemiProbabilisticPipingCalculationScenario>()
+                                                           .Where(c => c.HasOutput && !c.InputParameters.UseAssessmentLevelManualInput)
+                                                           .Concat<ICalculation>(
+                                                               assessmentSection.MacroStabilityInwards
+                                                                                .Calculations
+                                                                                .OfType<MacroStabilityInwardsCalculationScenario>()
+                                                                                .Where(c => c.HasOutput && !c.InputParameters.UseAssessmentLevelManualInput))
+                                                           .ToArray();
 
-            IEnumerable<IObservable> userDefinedCalculations = GetUserDefinedCalculations(assessmentSection);
+            calculations.ForEachElementDo(c => c.ClearOutput());
 
-            List<IObservable> expectedAffectedObjects =
-                assessmentSection.GetFailureMechanisms().Cast<IObservable>()
-                                 .Concat(assessmentSection.WaterLevelCalculationsForSignalingNorm)
-                                 .Concat(assessmentSection.WaterLevelCalculationsForLowerLimitNorm)
-                                 .Concat(userDefinedCalculations)
-                                 .Concat(GetAllAffectedDuneLocationCalculations(assessmentSection.DuneErosion))
-                                 .Concat(new IObservable[]
-                                 {
-                                     assessmentSection.FailureMechanismContribution
-                                 }).ToList();
+            var mocks = new MockRepository();
+            var observer = mocks.StrictMock<IObserver>();
+            observer.Expect(o => o.UpdateObserver()).Repeat.Once();
+            mocks.ReplayAll();
 
+            assessmentSection.FailureMechanismContribution.Attach(observer);
+
             var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
 
-            IEnumerable<IObservable> affectedObjects = null;
+            // When
+            var actionPerformed = false;
+            void Call() => handler.ChangeNormativeNormType(() => actionPerformed = true);
 
-            // Call
-            void Call() => affectedObjects = handler.SetPropertyValueAfterConfirmation(() => {});
+            // Then
+            TestHelper.AssertLogMessagesCount(Call, 0);
+            Assert.IsTrue(actionPerformed);
+            mocks.VerifyAll();
+        }
 
-            // Assert
-            TestHelper.AssertLogMessageIsGenerated(Call, "Alle berekende hydraulische belastingen zijn verwijderd.", 1);
+        [Test]
+        public void ChangeNormativeNormActionNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
 
-            AssertHydraulicBoundaryLocationCalculationOutput(assessmentSection, false);
-            DuneLocationsTestHelper.AssertDuneLocationCalculationsHaveNoOutputs(assessmentSection.DuneErosion);
+            var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
 
-            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+            // Call
+            void Call() => handler.ChangeNormativeNorm(null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("action", exception.ParamName);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void SetPropertyValueAfterConfirmation_FullyConfiguredAssessmentSectionWithoutCalculatedHydraulicBoundaryLocationsConfirmationGiven_AllFailureMechanismCalculationOutputClearedAndContributionsUpdatedAndReturnsAllAffectedObjects()
+        public void ChangeNormativeNorm_WithAction_ConfirmationRequired()
         {
             // Setup
+            var title = "";
+            var message = "";
             DialogBoxHandler = (name, wnd) =>
             {
                 var tester = new MessageBoxTester(wnd);
-                tester.ClickOk();
+                title = tester.Title;
+                message = tester.Text;
+
+                tester.ClickCancel();
             };
 
-            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput();
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
 
-            ICalculation[] expectedAffectedCalculations = assessmentSection.GetFailureMechanisms()
-                                                                           .SelectMany(fm => fm.Calculations)
-                                                                           .Where(c => c.HasOutput)
-                                                                           .ToArray();
             var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
 
-            IEnumerable<IObservable> affectedObjects = null;
-
             // Call
-            void Call() => affectedObjects = handler.SetPropertyValueAfterConfirmation(() => {});
+            handler.ChangeNormativeNorm(() => {});
 
             // Assert
-            TestHelper.AssertLogMessageIsGenerated(Call, "De resultaten van 36 berekeningen zijn verwijderd.", 1);
-
-            CollectionAssert.IsEmpty(assessmentSection.GetFailureMechanisms().SelectMany(fm => fm.Calculations).Where(c => c.HasOutput),
-                                     "There should be no calculations with output.");
-
-            IEnumerable<IObservable> expectedAffectedObjects = expectedAffectedCalculations.Cast<IObservable>()
-                                                                                           .Concat(assessmentSection.GetFailureMechanisms())
-                                                                                           .Concat(new IObservable[]
-                                                                                           {
-                                                                                               assessmentSection.FailureMechanismContribution
-                                                                                           });
-            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+            Assert.AreEqual("Bevestigen", title);
+            string expectedMessage = "Als u de norm aanpast, dan worden de rekenresultaten van alle hydraulische belastingenlocaties behorende bij deze norm en semi-probabilistische berekeningen zonder handmatig toetspeil verwijderd. "
+                                     + Environment.NewLine
+                                     + Environment.NewLine
+                                     + "Weet u zeker dat u wilt doorgaan?";
+            Assert.AreEqual(expectedMessage, message);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void SetPropertyValueAfterConfirmation_FullyConfiguredAssessmentSectionConfirmationGiven_HandlerExecuted()
+        public void GivenCalculationsWithOutput_WhenChangingNormativeNorm_ThenAllDependingOutputClearedAndActionPerformedAndAllAffectedObjectsNotified()
         {
-            // Setup
+            // Given
             DialogBoxHandler = (name, wnd) =>
             {
                 var tester = new MessageBoxTester(wnd);
                 tester.ClickOk();
             };
 
             AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
+            ICalculation[] expectedAffectedCalculations = assessmentSection.Piping
+                                                                           .Calculations
+                                                                           .OfType<SemiProbabilisticPipingCalculationScenario>()
+                                                                           .Where(c => c.HasOutput && !c.InputParameters.UseAssessmentLevelManualInput)
+                                                                           .Concat<ICalculation>(
+                                                                               assessmentSection.MacroStabilityInwards
+                                                                                                .Calculations
+                                                                                                .OfType<MacroStabilityInwardsCalculationScenario>()
+                                                                                                .Where(c => c.HasOutput && !c.InputParameters.UseAssessmentLevelManualInput))
+                                                                           .ToArray();
 
+            IEnumerable<IObservable> expectedAffectedObjects =
+                expectedAffectedCalculations.Concat(new IObservable[]
+                                            {
+                                                assessmentSection.FailureMechanismContribution
+                                            })
+                                            .Concat(assessmentSection.WaterLevelCalculationsForLowerLimitNorm)
+                                            .ToArray();
+
+            var mocks = new MockRepository();
+            var observer = mocks.StrictMock<IObserver>();
+            observer.Expect(o => o.UpdateObserver()).Repeat.Times(expectedAffectedObjects.Count());
+            mocks.ReplayAll();
+
+            expectedAffectedObjects.ForEachElementDo(obj => obj.Attach(observer));
+
             var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
 
-            var handlerExecuted = false;
+            // Precondition
+            CollectionAssert.IsNotEmpty(assessmentSection.WaterLevelCalculationsForLowerLimitNorm.Where(c => c.HasOutput));
 
-            // Call
-            handler.SetPropertyValueAfterConfirmation(() => handlerExecuted = true);
+            // When
+            var actionPerformed = false;
+            void Call() => handler.ChangeNormativeNorm(() => actionPerformed = true);
 
-            // Assert
-            Assert.IsTrue(handlerExecuted);
+            // Then
+            var expectedMessages = new[]
+            {
+                "Alle berekende hydraulische belastingen behorende bij de gewijzigde norm zijn verwijderd.",
+                $"De resultaten van {expectedAffectedCalculations.Length} semi-probabilistische berekeningen zonder handmatige waterstand zijn verwijderd."
+            };
+            TestHelper.AssertLogMessagesAreGenerated(Call, expectedMessages, 2);
+
+            Assert.IsTrue(actionPerformed);
+            CollectionAssert.IsEmpty(expectedAffectedCalculations.Where(c => c.HasOutput));
+            CollectionAssert.IsEmpty(assessmentSection.WaterLevelCalculationsForLowerLimitNorm.Where(c => c.HasOutput));
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void SetPropertyValueAfterConfirmation_ConfirmationNotGiven_SetValueNotCalledNoAffectedObjects()
+        public void GivenCalculationsWithoutOutput_WhenChangingNormativeNorm_ThenActionPerformedAndContributionNotified()
         {
-            // Setup
+            // Given
             DialogBoxHandler = (name, wnd) =>
             {
                 var tester = new MessageBoxTester(wnd);
-                tester.ClickCancel();
+                tester.ClickOk();
             };
 
             AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
+            ICalculation[] calculations = assessmentSection.Piping
+                                                           .Calculations
+                                                           .OfType<SemiProbabilisticPipingCalculationScenario>()
+                                                           .Where(c => c.HasOutput && !c.InputParameters.UseAssessmentLevelManualInput)
+                                                           .Concat<ICalculation>(
+                                                               assessmentSection.MacroStabilityInwards
+                                                                                .Calculations
+                                                                                .OfType<MacroStabilityInwardsCalculationScenario>()
+                                                                                .Where(c => c.HasOutput && !c.InputParameters.UseAssessmentLevelManualInput))
+                                                           .ToArray();
+            var mocks = new MockRepository();
+            var observer = mocks.StrictMock<IObserver>();
+            observer.Expect(o => o.UpdateObserver()).Repeat.Once();
+            mocks.ReplayAll();
+
+            calculations.ForEachElementDo(c =>
+            {
+                c.ClearOutput();
+                c.Attach(observer);
+            });
+            assessmentSection.WaterLevelCalculationsForLowerLimitNorm.ForEachElementDo(c =>
+            {
+                c.Output = null;
+                c.Attach(observer);
+            });
+            assessmentSection.FailureMechanismContribution.Attach(observer);
+
             var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
 
-            var propertySet = 0;
+            // When
+            var actionPerformed = false;
+            void Call() => handler.ChangeNormativeNorm(() => actionPerformed = true);
 
-            // Call
-            IEnumerable<IObservable> affectedObjects = handler.SetPropertyValueAfterConfirmation(() => propertySet++);
+            // Then
+            TestHelper.AssertLogMessagesCount(Call, 0);
+            Assert.IsTrue(actionPerformed);
+            mocks.VerifyAll();
+        }
 
-            // Assert
-            Assert.AreEqual(0, propertySet);
+        [Test]
+        public void ChangeNormActionNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
 
-            AssertHydraulicBoundaryLocationCalculationOutput(assessmentSection, true);
+            var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
 
-            Assert.IsNotNull(assessmentSection.DuneErosion.CalculationsForMechanismSpecificFactorizedSignalingNorm.First().Output);
-            Assert.IsNotNull(assessmentSection.DuneErosion.CalculationsForMechanismSpecificSignalingNorm.First().Output);
-            Assert.IsNotNull(assessmentSection.DuneErosion.CalculationsForMechanismSpecificLowerLimitNorm.First().Output);
-            Assert.IsNotNull(assessmentSection.DuneErosion.CalculationsForLowerLimitNorm.First().Output);
-            Assert.IsNotNull(assessmentSection.DuneErosion.CalculationsForFactorizedLowerLimitNorm.First().Output);
+            // Call
+            void Call() => handler.ChangeNorm(null);
 
-            CollectionAssert.IsEmpty(affectedObjects);
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("action", exception.ParamName);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void SetPropertyValueAfterConfirmation_ConfirmationGivenExceptionInSetValue_ExceptionBubbled()
+        public void ChangeNorm_WithAction_ConfirmationRequired()
         {
             // Setup
+            var title = "";
+            var message = "";
             DialogBoxHandler = (name, wnd) =>
             {
                 var tester = new MessageBoxTester(wnd);
-                tester.ClickOk();
+                title = tester.Title;
+                message = tester.Text;
+
+                tester.ClickCancel();
             };
 
-            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
-            var expectedException = new Exception();
 
             // Call
-            void Call() => handler.SetPropertyValueAfterConfirmation(() => throw expectedException);
+            handler.ChangeNorm(() => {});
 
             // Assert
-            var exception = Assert.Throws<Exception>(Call);
-            Assert.AreSame(expectedException, exception);
+            Assert.AreEqual("Bevestigen", title);
+            string expectedMessage = "Als u de norm aanpast, dan worden de rekenresultaten van alle hydraulische belastingenlocaties behorende bij deze norm verwijderd. "
+                                     + Environment.NewLine
+                                     + Environment.NewLine
+                                     + "Weet u zeker dat u wilt doorgaan?";
+            Assert.AreEqual(expectedMessage, message);
+            mocks.VerifyAll();
         }
 
-        private static IEnumerable<IObservable> GetUserDefinedCalculations(IAssessmentSection assessmentSection)
+        [Test]
+        public void GivenCalculationsWithOutput_WhenChangingNorm_ThenAllDependingOutputClearedAndActionPerformedAndAllAffectedObjectsNotified()
         {
-            var userDefinedCalculations = new List<IObservable>();
-
-            foreach (ObservableList<HydraulicBoundaryLocationCalculation> element in assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.Select(c => c.HydraulicBoundaryLocationCalculations))
+            // Given
+            DialogBoxHandler = (name, wnd) =>
             {
-                userDefinedCalculations.AddRange(element);
-            }
+                var tester = new MessageBoxTester(wnd);
+                tester.ClickOk();
+            };
 
-            foreach (ObservableList<HydraulicBoundaryLocationCalculation> element in assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.Select(c => c.HydraulicBoundaryLocationCalculations))
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
+
+            IEnumerable<IObservable> expectedAffectedObjects = new IObservable[]
+                                                               {
+                                                                   assessmentSection.FailureMechanismContribution
+                                                               }
+                                                               .Concat(assessmentSection.WaterLevelCalculationsForLowerLimitNorm)
+                                                               .ToArray();
+
+            var mocks = new MockRepository();
+            var observer = mocks.StrictMock<IObserver>();
+            observer.Expect(o => o.UpdateObserver()).Repeat.Times(expectedAffectedObjects.Count());
+            mocks.ReplayAll();
+
+            expectedAffectedObjects.ForEachElementDo(obj => obj.Attach(observer));
+
+            var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
+
+            // Precondition
+            CollectionAssert.IsNotEmpty(assessmentSection.WaterLevelCalculationsForLowerLimitNorm.Where(c => c.HasOutput));
+
+            // When
+            var actionPerformed = false;
+            void Call() => handler.ChangeNorm(() => actionPerformed = true);
+
+            // Then
+            var expectedMessages = new[]
             {
-                userDefinedCalculations.AddRange(element);
-            }
+                "Alle berekende hydraulische belastingen behorende bij de gewijzigde norm zijn verwijderd."
+            };
+            TestHelper.AssertLogMessagesAreGenerated(Call, expectedMessages, 1);
 
-            return userDefinedCalculations;
+            Assert.IsTrue(actionPerformed);
+            CollectionAssert.IsEmpty(assessmentSection.WaterLevelCalculationsForLowerLimitNorm.Where(c => c.HasOutput));
+            mocks.VerifyAll();
         }
 
-        private static IEnumerable<IObservable> GetAllAffectedDuneLocationCalculations(DuneErosionFailureMechanism failureMechanism)
+        [Test]
+        public void GivenCalculationsWithoutOutput_WhenChangingNorm_ThenActionPerformedAndContributionNotified()
         {
-            return DuneLocationsTestHelper.GetAllDuneLocationCalculationsWithOutput(failureMechanism);
-        }
+            // Given
+            DialogBoxHandler = (name, wnd) =>
+            {
+                var tester = new MessageBoxTester(wnd);
+                tester.ClickOk();
+            };
 
-        private static void AssertHydraulicBoundaryLocationCalculationOutput(AssessmentSection assessmentSection, bool hasOutput)
-        {
-            Assert.IsTrue(assessmentSection.WaterLevelCalculationsForSignalingNorm.All(c => c.HasOutput == hasOutput));
-            Assert.IsTrue(assessmentSection.WaterLevelCalculationsForLowerLimitNorm.All(c => c.HasOutput == hasOutput));
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
+
+            var mocks = new MockRepository();
+            var observer = mocks.StrictMock<IObserver>();
+            observer.Expect(o => o.UpdateObserver()).Repeat.Once();
+            mocks.ReplayAll();
+
+            assessmentSection.WaterLevelCalculationsForLowerLimitNorm.ForEachElementDo(c =>
+            {
+                c.Output = null;
+                c.Attach(observer);
+            });
+            assessmentSection.FailureMechanismContribution.Attach(observer);
+
+            var handler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
+
+            // When
+            var actionPerformed = false;
+            void Call() => handler.ChangeNorm(() => actionPerformed = true);
+
+            // Then
+            TestHelper.AssertLogMessagesCount(Call, 0);
+            Assert.IsTrue(actionPerformed);
+            mocks.VerifyAll();
         }
     }
 }
\ No newline at end of file