Index: Riskeer/DuneErosion/src/Riskeer.DuneErosion.Forms/Views/DuneErosionLocationsMapLayer.cs
===================================================================
diff -u -rf71699bcc12551d73205e827eb615af5694fe8a6 -r53eba129a427d153e4dd31047e6566513bc04892
--- Riskeer/DuneErosion/src/Riskeer.DuneErosion.Forms/Views/DuneErosionLocationsMapLayer.cs	(.../DuneErosionLocationsMapLayer.cs)	(revision f71699bcc12551d73205e827eb615af5694fe8a6)
+++ Riskeer/DuneErosion/src/Riskeer.DuneErosion.Forms/Views/DuneErosionLocationsMapLayer.cs	(.../DuneErosionLocationsMapLayer.cs)	(revision 53eba129a427d153e4dd31047e6566513bc04892)
@@ -27,6 +27,8 @@
 using Riskeer.Common.Forms.Factories;
 using Riskeer.DuneErosion.Data;
 using Riskeer.DuneErosion.Forms.Factories;
+using Riskeer.DuneErosion.Forms.Properties;
+using RiskeerCommonUtilResources = Riskeer.Common.Util.Properties.Resources;
 
 namespace Riskeer.DuneErosion.Forms.Views
 {
@@ -43,6 +45,8 @@
 
         private List<RecursiveObserver<IObservableEnumerable<DuneLocationCalculation>, DuneLocationCalculation>> calculationsForTargetProbabilityObservers;
 
+        private ISet<MetaDataItemsLookup> currentMetaDataItems;
+
         /// <summary>
         /// Creates a new instance of <see cref="DuneErosionLocationsMapLayer"/>.
         /// </summary>
@@ -62,6 +66,7 @@
             CreateObservers();
 
             MapData = RiskeerMapDataFactory.CreateHydraulicBoundaryLocationsMapData();
+            currentMetaDataItems = new HashSet<MetaDataItemsLookup>();
             SetFeatures();
         }
 
@@ -150,12 +155,110 @@
 
         private void SetFeatures()
         {
+            IReadOnlyDictionary<IObservableEnumerable<DuneLocationCalculation>, double> calculationsForTargetProbabilities =
+                failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities
+                                .OrderByDescending(tp => tp.TargetProbability)
+                                .ToDictionary(tp => (IObservableEnumerable<DuneLocationCalculation>) tp.DuneLocationCalculations,
+                                              tp => tp.TargetProbability);
+
             IEnumerable<AggregatedDuneLocation> locations = AggregatedDuneLocationFactory.CreateAggregatedDuneLocations(
-                failureMechanism.DuneLocations, failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities
-                                                                .OrderByDescending(tp => tp.TargetProbability)
-                                                                .ToDictionary(tp => (IObservableEnumerable<DuneLocationCalculation>) tp.DuneLocationCalculations,
-                                                                              tp => tp.TargetProbability));
+                failureMechanism.DuneLocations, calculationsForTargetProbabilities);
+
             MapData.Features = DuneErosionMapDataFeaturesFactory.CreateDuneLocationFeatures(locations);
+
+            if (MapData.Features.Any())
+            {
+                UpdateMetaData(calculationsForTargetProbabilities);
+            }
         }
+
+        private void UpdateMetaData(IReadOnlyDictionary<IObservableEnumerable<DuneLocationCalculation>, double> calculationsForTargetProbabilities)
+        {
+            var newMetaDataItems = new HashSet<MetaDataItemsLookup>();
+
+            var waterLevelMetaDataItemsCounter = 0;
+            var waveHeightMetaDataItemsCounter = 0;
+            var wavePeriodMetaDataItemsCounter = 0;
+            foreach (string metaData in MapData.MetaData)
+            {
+                if (metaData.Contains(string.Format(Resources.MetaData_WaterLevel_TargetProbability_0, string.Empty)))
+                {
+                    AddMetaDataItemToLookup(newMetaDataItems, calculationsForTargetProbabilities.ElementAt(waterLevelMetaDataItemsCounter).Key,
+                                            lookupItem => lookupItem.WaterLevelMetaDataItem = metaData);
+                    waterLevelMetaDataItemsCounter++;
+                }
+                else if (metaData.Contains(string.Format(Resources.MetaData_WaveHeight_TargetProbability_0, string.Empty)))
+                {
+                    AddMetaDataItemToLookup(newMetaDataItems, calculationsForTargetProbabilities.ElementAt(waveHeightMetaDataItemsCounter).Key,
+                                            lookupItem => lookupItem.WaveHeightMetaDataItem = metaData);
+                    waveHeightMetaDataItemsCounter++;
+                }
+                else if (metaData.Contains(string.Format(Resources.MetaData_WavePeriod_TargetProbability_0, string.Empty)))
+                {
+                    AddMetaDataItemToLookup(newMetaDataItems, calculationsForTargetProbabilities.ElementAt(wavePeriodMetaDataItemsCounter).Key,
+                                            lookupItem => lookupItem.WavePeriodMetaDataItem = metaData);
+                    wavePeriodMetaDataItemsCounter++;
+                }
+            }
+
+            foreach (MetaDataItemsLookup currentMetaDataItem in currentMetaDataItems)
+            {
+                if (MapData.SelectedMetaDataAttribute == currentMetaDataItem.WaterLevelMetaDataItem
+                    || MapData.SelectedMetaDataAttribute == currentMetaDataItem.WaveHeightMetaDataItem
+                    || MapData.SelectedMetaDataAttribute == currentMetaDataItem.WavePeriodMetaDataItem)
+                {
+                    MetaDataItemsLookup newMetaDataItem = newMetaDataItems.FirstOrDefault(i => i.Calculations.Equals(currentMetaDataItem.Calculations));
+
+                    if (newMetaDataItem == null)
+                    {
+                        MapData.SelectedMetaDataAttribute = RiskeerCommonUtilResources.MetaData_Name;
+                    }
+                    else
+                    {
+                        SetSelectedMetaDataAttribute(currentMetaDataItem.WaterLevelMetaDataItem, newMetaDataItem.WaterLevelMetaDataItem);
+                        SetSelectedMetaDataAttribute(currentMetaDataItem.WaveHeightMetaDataItem, newMetaDataItem.WaveHeightMetaDataItem);
+                        SetSelectedMetaDataAttribute(currentMetaDataItem.WavePeriodMetaDataItem, newMetaDataItem.WavePeriodMetaDataItem);
+                    }
+                }
+            }
+
+            currentMetaDataItems = newMetaDataItems;
+        }
+
+        private static void AddMetaDataItemToLookup(ISet<MetaDataItemsLookup> lookup, IObservableEnumerable<DuneLocationCalculation> calculations,
+                                                    Action<MetaDataItemsLookup> setMetaDataAction)
+        {
+            MetaDataItemsLookup lookupItem = lookup.FirstOrDefault(i => i.Calculations.Equals(calculations));
+
+            if (lookupItem == null)
+            {
+                lookupItem = new MetaDataItemsLookup
+                {
+                    Calculations = calculations
+                };
+                lookup.Add(lookupItem);
+            }
+
+            setMetaDataAction(lookupItem);
+        }
+
+        private void SetSelectedMetaDataAttribute(string metaDataItem, string newMetaDataItem)
+        {
+            if (metaDataItem != newMetaDataItem && metaDataItem == MapData.SelectedMetaDataAttribute)
+            {
+                MapData.SelectedMetaDataAttribute = newMetaDataItem;
+            }
+        }
+
+        private class MetaDataItemsLookup
+        {
+            public IObservableEnumerable<DuneLocationCalculation> Calculations { get; set; }
+
+            public string WaterLevelMetaDataItem { get; set; }
+
+            public string WaveHeightMetaDataItem { get; set; }
+
+            public string WavePeriodMetaDataItem { get; set; }
+        }
     }
 }
\ No newline at end of file
Index: Riskeer/DuneErosion/test/Riskeer.DuneErosion.Forms.Test/Views/DuneErosionLocationsMapLayerTest.cs
===================================================================
diff -u -r8880b07d0197da2fecc5ca7da489d82cbbab0d02 -r53eba129a427d153e4dd31047e6566513bc04892
--- Riskeer/DuneErosion/test/Riskeer.DuneErosion.Forms.Test/Views/DuneErosionLocationsMapLayerTest.cs	(.../DuneErosionLocationsMapLayerTest.cs)	(revision 8880b07d0197da2fecc5ca7da489d82cbbab0d02)
+++ Riskeer/DuneErosion/test/Riskeer.DuneErosion.Forms.Test/Views/DuneErosionLocationsMapLayerTest.cs	(.../DuneErosionLocationsMapLayerTest.cs)	(revision 53eba129a427d153e4dd31047e6566513bc04892)
@@ -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.
 //
@@ -287,6 +287,134 @@
             mocks.VerifyAll();
         }
 
+        [Test]
+        [TestCaseSource(nameof(GetDisplayNameFormats))]
+        public void GivenMapLayerWithDuneLocations_WhenSelectedTargetProbabilityRemovedAndNotified_ThenMapDataUpdatedSelectedMetaDataAttributeResetToDefault(string displayName)
+        {
+            // Given
+            var mocks = new MockRepository();
+            var observer = mocks.StrictMock<IObserver>();
+            observer.Expect(o => o.UpdateObserver());
+            mocks.ReplayAll();
+
+            var failureMechanism = new DuneErosionFailureMechanism();
+            failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Add(
+                new DuneLocationCalculationsForTargetProbability(0.1));
+            failureMechanism.SetDuneLocations(new[]
+            {
+                new TestDuneLocation("test1")
+            });
+
+            using (var mapLayer = new DuneErosionLocationsMapLayer(failureMechanism))
+            {
+                DuneLocationCalculationsForTargetProbability calculationsForTargetProbability = failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.First();
+                mapLayer.MapData.SelectedMetaDataAttribute = string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability));
+                mapLayer.MapData.NotifyObservers();
+
+                mapLayer.MapData.Attach(observer);
+
+                // Precondition
+                AssertDuneLocationsMapData(failureMechanism, mapLayer.MapData);
+
+                // When
+                failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Remove(calculationsForTargetProbability);
+                failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.NotifyObservers();
+
+                // Then
+                AssertDuneLocationsMapData(failureMechanism, mapLayer.MapData);
+                Assert.AreEqual("Naam", mapLayer.MapData.SelectedMetaDataAttribute);
+            }
+
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        [TestCaseSource(nameof(GetDisplayNameFormats))]
+        public void GivenMapLayerWithDuneLocations_WhenNotSelectedTargetProbabilityRemovedAndNotified_ThenMapDataUpdated(string displayName)
+        {
+            // Given
+            var mocks = new MockRepository();
+            var observer = mocks.StrictMock<IObserver>();
+            observer.Expect(o => o.UpdateObserver());
+            mocks.ReplayAll();
+
+            var failureMechanism = new DuneErosionFailureMechanism();
+            failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Add(
+                new DuneLocationCalculationsForTargetProbability(0.1));
+            failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Add(
+                new DuneLocationCalculationsForTargetProbability(0.001));
+            failureMechanism.SetDuneLocations(new[]
+            {
+                new TestDuneLocation("test1")
+            });
+
+            using (var mapLayer = new DuneErosionLocationsMapLayer(failureMechanism))
+            {
+                DuneLocationCalculationsForTargetProbability calculationsForTargetProbabilityToRemove = failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.First();
+                DuneLocationCalculationsForTargetProbability calculationsForTargetProbability = failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Last();
+                mapLayer.MapData.SelectedMetaDataAttribute = string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability));
+                mapLayer.MapData.NotifyObservers();
+
+                mapLayer.MapData.Attach(observer);
+
+                // Precondition
+                AssertDuneLocationsMapData(failureMechanism, mapLayer.MapData);
+
+                // When
+                failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Remove(calculationsForTargetProbabilityToRemove);
+                failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.NotifyObservers();
+
+                // Then
+                AssertDuneLocationsMapData(failureMechanism, mapLayer.MapData);
+                Assert.AreEqual(string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability)),
+                                mapLayer.MapData.SelectedMetaDataAttribute);
+            }
+
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        [TestCaseSource(nameof(GetDisplayNameFormats))]
+        public void GivenMapLayerWithDuneLocations_WhenSelectedTargetProbabilityChangedAndNotified_ThenMapDataAndSelectedMetaDataAttributeUpdated(string displayName)
+        {
+            // Given
+            var mocks = new MockRepository();
+            var observer = mocks.StrictMock<IObserver>();
+            observer.Expect(o => o.UpdateObserver());
+            mocks.ReplayAll();
+
+            var failureMechanism = new DuneErosionFailureMechanism();
+            failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Add(
+                new DuneLocationCalculationsForTargetProbability(0.1));
+            failureMechanism.SetDuneLocations(new[]
+            {
+                new TestDuneLocation("test1")
+            });
+
+            using (var mapLayer = new DuneErosionLocationsMapLayer(failureMechanism))
+            {
+                DuneLocationCalculationsForTargetProbability calculationsForTargetProbability = failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Last();
+                mapLayer.MapData.SelectedMetaDataAttribute = string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability));
+                mapLayer.MapData.NotifyObservers();
+
+                mapLayer.MapData.Attach(observer);
+
+                // Precondition
+                AssertDuneLocationsMapData(failureMechanism, mapLayer.MapData);
+
+                // When
+                calculationsForTargetProbability.TargetProbability = 0.005;
+                calculationsForTargetProbability.NotifyObservers();
+
+                // Then
+                AssertDuneLocationsMapData(failureMechanism, mapLayer.MapData);
+                Assert.AreEqual(string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability)),
+                                mapLayer.MapData.SelectedMetaDataAttribute);
+            }
+
+            mocks.VerifyAll();
+        }
+
         private static void AssertDuneLocationsMapData(DuneErosionFailureMechanism failureMechanism,
                                                        MapData mapData)
         {
@@ -296,5 +424,12 @@
             var duneLocationsMapData = (MapPointData) mapData;
             DuneErosionMapFeaturesTestHelper.AssertDuneLocationFeaturesData(failureMechanism, duneLocationsMapData.Features);
         }
+
+        private static IEnumerable<TestCaseData> GetDisplayNameFormats()
+        {
+            yield return new TestCaseData("Rekenwaarde h - {0}");
+            yield return new TestCaseData("Rekenwaarde Hs - {0}");
+            yield return new TestCaseData("Rekenwaarde Tp - {0}");
+        }
     }
 }
\ No newline at end of file