Index: Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/FaultTreeIllustrationPointBaseProperties.cs
===================================================================
diff -u
--- Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/FaultTreeIllustrationPointBaseProperties.cs	(revision 0)
+++ Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/FaultTreeIllustrationPointBaseProperties.cs	(revision 0247a9558110b4efa96a4b38a8a5cf4bb611d650)
@@ -0,0 +1,175 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets 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 System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using Core.Common.Base.Data;
+using Core.Common.Gui.Converters;
+using Core.Common.Gui.PropertyBag;
+using Core.Common.Utils;
+using Core.Common.Utils.Attributes;
+using Ringtoets.Common.Data.IllustrationPoints;
+using Ringtoets.Common.Forms.Properties;
+using Ringtoets.Common.Forms.TypeConverters;
+
+namespace Ringtoets.Common.Forms.PropertyClasses
+{
+    /// <summary>
+    /// Properties for the Fault tree of Illustration Points.
+    /// </summary>
+    [TypeConverter(typeof(ExpandableObjectConverter))]
+    public class FaultTreeIllustrationPointBaseProperties : ObjectProperties<TopLevelFaultTreeIllustrationPoint>
+    {
+        /// <summary>
+        /// Creates a new instance of <see cref="FaultTreeIllustrationPointBaseProperties"/>.
+        /// </summary>
+        /// <param name="faultTreeData">The data to use for the properties. </param>
+        /// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
+        public FaultTreeIllustrationPointBaseProperties(
+            TopLevelFaultTreeIllustrationPoint faultTreeData)
+        {
+            if (faultTreeData == null)
+            {
+                throw new ArgumentNullException(nameof(faultTreeData));
+            }
+            data = faultTreeData;
+        }
+
+        [ReadOnly(true)]
+        [TypeConverter(typeof(NoProbabilityValueDoubleConverter))]
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.CalculationOutput_CalculatedProbability_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.CalculationOutput_CalculatedProbability_Description))]
+        public double CalculatedProbability
+        {
+            get
+            {
+                return StatisticsConverter.ReliabilityToProbability(data.FaultTreeNodeRoot.Data.Beta);
+            }
+        }
+
+        [ReadOnly(true)]
+        [TypeConverter(typeof(NoValueRoundedDoubleConverter))]
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.CalculationOutput_CalculatedReliability_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.CalculationOutput_CalculatedReliability_Description))]
+        public RoundedDouble Reliability
+        {
+            get
+            {
+                return data.FaultTreeNodeRoot.Data.Beta;
+            }
+        }
+
+        [ReadOnly(true)]
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.IllustrationPoint_WindDirection_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.IllustrationPoint_WindDirection_Description))]
+        public string WindDirection
+        {
+            get
+            {
+                return data.WindDirection.Name;
+            }
+        }
+
+        [ReadOnly(true)]
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.IllustrationPoint_ClosingSituation_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.IllustrationPoint_ClosingSituation_Description))]
+        public string ClosingSituation
+        {
+            get
+            {
+                return data.ClosingSituation;
+            }
+        }
+
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.HydraulicBoundaryDatabase_AlphaValues_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.HydraulicBoundaryDatabase_AlphaValues_Description))]
+        [TypeConverter(typeof(KeyValueExpandableArrayConverter))]
+        [KeyValueElement(nameof(Stochast.Name), nameof(Stochast.Alpha))]
+        public Stochast[] AlphaValues
+        {
+            get
+            {
+                return ((FaultTreeIllustrationPoint) data.FaultTreeNodeRoot.Data).Stochasts.ToArray();
+            }
+        }
+
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.HydraulicBoundaryDatabase_Durations_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.HydraulicBoundaryDatabase_Durations_Description))]
+        [TypeConverter(typeof(KeyValueExpandableArrayConverter))]
+        [KeyValueElement(nameof(Stochast.Name), nameof(Stochast.Duration))]
+        public Stochast[] Durations
+        {
+            get
+            {
+                return ((FaultTreeIllustrationPoint) data.FaultTreeNodeRoot.Data).Stochasts.ToArray();
+            }
+        }
+
+        [ReadOnly(true)]
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.IllustrationPointProperty_IllustrationPoints_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.IllustrationPointProperty_IllustrationPoints_Description))]
+        [TypeConverter(typeof(ExpandableArrayConverter))]
+        [KeyValueElement(nameof(WindDirection), "")]
+        public IllustrationPointChildProperties[] IllustrationPoints
+        {
+            get
+            {
+                var points = new List<IllustrationPointChildProperties>();
+                foreach (IllustrationPointNode illustrationPointNode in data.FaultTreeNodeRoot.Children)
+                {
+                    var faultTree = illustrationPointNode.Data as FaultTreeIllustrationPoint;
+                    if (faultTree != null)
+                    {
+                        points.Add(new FaultTreeIllustrationPointChildProperties(illustrationPointNode, WindDirection));
+                        continue;
+                    }
+
+                    var subMechanism = illustrationPointNode.Data as SubMechanismIllustrationPoint;
+                    if (subMechanism != null)
+                    {
+                        points.Add(new SubMechanismIllustrationPointChildProperties(illustrationPointNode, WindDirection));
+                        continue;
+                    }
+                    
+                    // If type is not supported, throw exception (currently not possible, safeguard for future)
+                    throw new NotSupportedException("IllustrationPointNode is not of a supported type (FaultTree/SubMechanism)");
+
+
+                }
+                return points.ToArray();
+            }
+        }
+
+        public override string ToString()
+        {
+            return $"{WindDirection}";
+        }
+    }
+}
\ No newline at end of file
Fisheye: Tag 0247a9558110b4efa96a4b38a8a5cf4bb611d650 refers to a dead (removed) revision in file `Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/FaultTreeIllustrationPointBaseProperty.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/FaultTreeIllustrationPointChildProperties.cs
===================================================================
diff -u
--- Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/FaultTreeIllustrationPointChildProperties.cs	(revision 0)
+++ Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/FaultTreeIllustrationPointChildProperties.cs	(revision 0247a9558110b4efa96a4b38a8a5cf4bb611d650)
@@ -0,0 +1,88 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets 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 System.ComponentModel;
+using System.Linq;
+using Core.Common.Gui.Attributes;
+using Core.Common.Gui.Converters;
+using Core.Common.Utils.Attributes;
+using Ringtoets.Common.Data.IllustrationPoints;
+using Ringtoets.Common.Forms.Properties;
+
+namespace Ringtoets.Common.Forms.PropertyClasses
+{
+    /// <summary>
+    /// Properties for the (child) Fault tree of Illustration Points
+    /// </summary>
+    [TypeConverter(typeof(ExpandableObjectConverter))]
+    public class FaultTreeIllustrationPointChildProperties : IllustrationPointChildProperties
+    {
+        /// <summary>
+        /// Creates a new instance of <see cref="FaultTreeIllustrationPointChildProperties"/>.
+        /// </summary>
+        /// <param name="illustrationPointNode">The data to use for the properties. </param>
+        /// <param name="windDirection">String containing the wind direction for this illustration point</param>
+        /// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c> or when illustrationPointNode is of the wrong type.</exception>
+        /// <exception cref="ArgumentException">Thrown when the illustration point node is not of type <see cref="FaultTreeIllustrationPoint"/></exception>
+        public FaultTreeIllustrationPointChildProperties(
+            IllustrationPointNode illustrationPointNode, string windDirection) : base(illustrationPointNode, windDirection)
+        {
+            if (!(data.Data is FaultTreeIllustrationPoint))
+            {
+                throw new ArgumentException("illustrationPointNode data type has to be FaultTreeIllustrationPoint");
+            }
+        }
+
+        [PropertyOrder(4)]
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.HydraulicBoundaryDatabase_AlphaValues_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.HydraulicBoundaryDatabase_AlphaValues_Description))]
+        [TypeConverter(typeof(KeyValueExpandableArrayConverter))]
+        [KeyValueElement(nameof(Stochast.Name), nameof(Stochast.Alpha))]
+        public Stochast[] AlphaValues
+        {
+            get
+            {
+                return ((FaultTreeIllustrationPoint) data.Data).Stochasts.ToArray();
+            }
+        }
+
+        [PropertyOrder(5)]
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.HydraulicBoundaryDatabase_Durations_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.HydraulicBoundaryDatabase_Durations_Description))]
+        [TypeConverter(typeof(KeyValueExpandableArrayConverter))]
+        [KeyValueElement(nameof(Stochast.Name), nameof(Stochast.Duration))]
+        public Stochast[] Durations
+        {
+            get
+            {
+                return ((FaultTreeIllustrationPoint) data.Data).Stochasts.ToArray();
+            }
+        }
+
+        public override string ToString()
+        {
+            return $"{Name}";
+        }
+    }
+}
\ No newline at end of file
Fisheye: Tag 0247a9558110b4efa96a4b38a8a5cf4bb611d650 refers to a dead (removed) revision in file `Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/FaultTreeIllustrationPointChildProperty.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/IllustrationPointChildProperties.cs
===================================================================
diff -u
--- Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/IllustrationPointChildProperties.cs	(revision 0)
+++ Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/IllustrationPointChildProperties.cs	(revision 0247a9558110b4efa96a4b38a8a5cf4bb611d650)
@@ -0,0 +1,156 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets 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 System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using Core.Common.Base.Data;
+using Core.Common.Gui.Attributes;
+using Core.Common.Gui.Converters;
+using Core.Common.Gui.PropertyBag;
+using Core.Common.Utils;
+using Core.Common.Utils.Attributes;
+using Ringtoets.Common.Data.IllustrationPoints;
+using Ringtoets.Common.Forms.Properties;
+using Ringtoets.Common.Forms.TypeConverters;
+
+namespace Ringtoets.Common.Forms.PropertyClasses
+{
+    /// <summary>
+    /// Base properties for the child Illustration Points in a tree
+    /// </summary>
+    [TypeConverter(typeof(ExpandableObjectConverter))]
+    public class IllustrationPointChildProperties : ObjectProperties<IllustrationPointNode>
+    {
+        /// <summary>
+        /// Creates a new instance of <see cref="IllustrationPointChildProperties"/>.
+        /// </summary>
+        /// <param name="illustrationPointNode">The data to use for the properties. </param>
+        /// <param name="windDirection">String containing the wind direction for this illustration point</param>
+        /// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
+        public IllustrationPointChildProperties(
+            IllustrationPointNode illustrationPointNode, string windDirection)
+        {
+            if (illustrationPointNode == null)
+            {
+                throw new ArgumentNullException(nameof(illustrationPointNode));
+            }
+            if (windDirection == null)
+            {
+                throw new ArgumentNullException(nameof(windDirection));
+            }
+            data = illustrationPointNode;
+            WindDirection = windDirection;
+        }
+
+        [ReadOnly(true)]
+        [PropertyOrder(0)]
+        [TypeConverter(typeof(NoProbabilityValueDoubleConverter))]
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.CalculationOutput_CalculatedProbability_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.CalculationOutput_CalculatedProbability_Description))]
+        public double CalculatedProbability
+        {
+            get
+            {
+                return StatisticsConverter.ReliabilityToProbability(data.Data.Beta);
+            }
+        }
+
+        [ReadOnly(true)]
+        [PropertyOrder(1)]
+        [TypeConverter(typeof(NoValueRoundedDoubleConverter))]
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.CalculationOutput_CalculatedReliability_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.CalculationOutput_CalculatedReliability_Description))]
+        public RoundedDouble Reliability
+        {
+            get
+            {
+                return data.Data.Beta;
+            }
+        }
+
+        [ReadOnly(true)]
+        [PropertyOrder(2)]
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.IllustrationPoint_WindDirection_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.IllustrationPoint_WindDirection_Description))]
+        public string WindDirection { get; }
+
+        [ReadOnly(true)]
+        [PropertyOrder(3)]
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.IllustrationPoint_ClosingSituation_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.IllustrationPoint_ClosingSituation_Description))]
+        public string Name
+        {
+            get
+            {
+                return data.Data.Name;
+            }
+        }
+
+        [ReadOnly(true)]
+        [DynamicVisible]
+        [PropertyOrder(6)]
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.IllustrationPointProperty_IllustrationPoints_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.IllustrationPointProperty_IllustrationPoints_Description))]
+        [TypeConverter(typeof(ExpandableArrayConverter))]
+        [KeyValueElement(nameof(WindDirection), "")]
+        public IllustrationPointChildProperties[] IllustrationPoints
+        {
+            get
+            {
+                var points = new List<IllustrationPointChildProperties>();
+                foreach (IllustrationPointNode illustrationPointNode in data.Children)
+                {
+                    var faultTree = illustrationPointNode.Data as FaultTreeIllustrationPoint;
+                    if (faultTree != null)
+                    {
+                        points.Add(new FaultTreeIllustrationPointChildProperties(illustrationPointNode, WindDirection));
+                        continue;
+                    }
+
+                    var subMechanism = illustrationPointNode.Data as SubMechanismIllustrationPoint;
+                    if (subMechanism != null)
+                    {
+                        points.Add(new SubMechanismIllustrationPointChildProperties(illustrationPointNode, WindDirection));
+                    }
+                }
+                return points.ToArray();
+            }
+        }
+
+        [DynamicVisibleValidationMethod]
+        public bool IsDynamicVisible(string propertyName)
+        {
+            return propertyName == "IllustrationPoints" && data.Children.Any();
+        }
+
+        public override string ToString()
+        {
+            return $"{Name}";
+        }
+    }
+}
\ No newline at end of file
Fisheye: Tag 0247a9558110b4efa96a4b38a8a5cf4bb611d650 refers to a dead (removed) revision in file `Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/IllustrationPointChildProperty.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/StructuresOutputProperties.cs
===================================================================
diff -u -r5046628898b8fd85f7d2cfeb8a3192e2dcdc33e3 -r0247a9558110b4efa96a4b38a8a5cf4bb611d650
--- Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/StructuresOutputProperties.cs	(.../StructuresOutputProperties.cs)	(revision 5046628898b8fd85f7d2cfeb8a3192e2dcdc33e3)
+++ Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/StructuresOutputProperties.cs	(.../StructuresOutputProperties.cs)	(revision 0247a9558110b4efa96a4b38a8a5cf4bb611d650)
@@ -101,12 +101,12 @@
         [ResourcesDisplayName(typeof(Resources), nameof(Resources.IllustrationPointProperty_IllustrationPoints_DisplayName))]
         [ResourcesDescription(typeof(Resources), nameof(Resources.IllustrationPointProperty_IllustrationPoints_Description))]
         [TypeConverter(typeof(ExpandableArrayConverter))]
-        [KeyValueElement(nameof(FaultTreeIllustrationPointBaseProperty.WindDirection), "")]
-        public FaultTreeIllustrationPointBaseProperty[] IllustrationPoints
+        [KeyValueElement(nameof(FaultTreeIllustrationPointBaseProperties.WindDirection), "")]
+        public FaultTreeIllustrationPointBaseProperties[] IllustrationPoints
         {
             get
             {
-                return data.GeneralResult.TopLevelIllustrationPoints.Select(point => new FaultTreeIllustrationPointBaseProperty(point)).ToArray();
+                return data.GeneralResult.TopLevelIllustrationPoints.Select(point => new FaultTreeIllustrationPointBaseProperties(point)).ToArray();
             }
         }
 
Index: Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/SubMechanismIllustrationPointChildProperties.cs
===================================================================
diff -u
--- Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/SubMechanismIllustrationPointChildProperties.cs	(revision 0)
+++ Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/SubMechanismIllustrationPointChildProperties.cs	(revision 0247a9558110b4efa96a4b38a8a5cf4bb611d650)
@@ -0,0 +1,69 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets 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 System.ComponentModel;
+using System.Linq;
+using Core.Common.Gui.Attributes;
+using Core.Common.Gui.Converters;
+using Core.Common.Utils.Attributes;
+using Ringtoets.Common.Data.IllustrationPoints;
+using Ringtoets.Common.Forms.Properties;
+
+namespace Ringtoets.Common.Forms.PropertyClasses
+{
+    /// <summary>
+    /// Properties for the Submechanism Illustration Points.
+    /// </summary>
+    [TypeConverter(typeof(ExpandableObjectConverter))]
+    public class SubMechanismIllustrationPointChildProperties : IllustrationPointChildProperties
+    {
+        /// <summary>
+        /// Creates a new instance of <see cref="SubMechanismIllustrationPointChildProperties"/>.
+        /// </summary>
+        /// <param name="illustrationPointNode">The data to use for the properties. </param>
+        /// <param name="windDirection">String containing the wind direction for this illustration point</param>
+        /// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
+        /// <exception cref="ArgumentException">Thrown when the illustration point node is not of type <see cref="SubMechanismIllustrationPoint"/></exception>
+        public SubMechanismIllustrationPointChildProperties(
+            IllustrationPointNode illustrationPointNode, string windDirection) : base(illustrationPointNode, windDirection)
+        {
+            if (!(data.Data is SubMechanismIllustrationPoint))
+            {
+                throw new ArgumentException("illustrationPointNode data type has to be SubMechanismIllustrationPoint");
+            }
+        }
+
+        [PropertyOrder(4)]
+        [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_IllustrationPoints))]
+        [ResourcesDisplayName(typeof(Resources), nameof(Resources.IllustrationPoint_Realization_DisplayName))]
+        [ResourcesDescription(typeof(Resources), nameof(Resources.IllustrationPoint_Realization_Description))]
+        [TypeConverter(typeof(KeyValueExpandableArrayConverter))]
+        [KeyValueElement(nameof(Stochast.Name), nameof(SubMechanismIllustrationPointStochast.Realization))]
+        public SubMechanismIllustrationPointStochast[] SubMechanismStochasts
+        {
+            get
+            {
+                return ((SubMechanismIllustrationPoint) data.Data).Stochasts.ToArray();
+            }
+        }
+    }
+}
\ No newline at end of file
Fisheye: Tag 0247a9558110b4efa96a4b38a8a5cf4bb611d650 refers to a dead (removed) revision in file `Ringtoets/Common/src/Ringtoets.Common.Forms/PropertyClasses/SubMechanismIllustrationPointChildProperty.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/Common/src/Ringtoets.Common.Forms/Ringtoets.Common.Forms.csproj
===================================================================
diff -u -reea09a6357b41d9773a802b22f921817fda018ef -r0247a9558110b4efa96a4b38a8a5cf4bb611d650
--- Ringtoets/Common/src/Ringtoets.Common.Forms/Ringtoets.Common.Forms.csproj	(.../Ringtoets.Common.Forms.csproj)	(revision eea09a6357b41d9773a802b22f921817fda018ef)
+++ Ringtoets/Common/src/Ringtoets.Common.Forms/Ringtoets.Common.Forms.csproj	(.../Ringtoets.Common.Forms.csproj)	(revision 0247a9558110b4efa96a4b38a8a5cf4bb611d650)
@@ -81,10 +81,10 @@
       <DesignTime>True</DesignTime>
       <DependentUpon>Resources.resx</DependentUpon>
     </Compile>
-    <Compile Include="PropertyClasses\IllustrationPointChildProperty.cs" />
-    <Compile Include="PropertyClasses\SubMechanismIllustrationPointChildProperty.cs" />
-    <Compile Include="PropertyClasses\FaultTreeIllustrationPointChildProperty.cs" />
-    <Compile Include="PropertyClasses\FaultTreeIllustrationPointBaseProperty.cs" />
+    <Compile Include="PropertyClasses\IllustrationPointChildProperties.cs" />
+    <Compile Include="PropertyClasses\SubMechanismIllustrationPointChildProperties.cs" />
+    <Compile Include="PropertyClasses\FaultTreeIllustrationPointChildProperties.cs" />
+    <Compile Include="PropertyClasses\FaultTreeIllustrationPointBaseProperties.cs" />
     <Compile Include="PropertyClasses\ForeshoreProfileCollectionProperties.cs" />
     <Compile Include="PropertyClasses\StructureCollectionProperties.cs" />
     <Compile Include="PropertyClasses\StructuresOutputProperties.cs" />
Index: Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/FaultTreeIllustrationPointBasePropertyTest.cs
===================================================================
diff -u -r5046628898b8fd85f7d2cfeb8a3192e2dcdc33e3 -r0247a9558110b4efa96a4b38a8a5cf4bb611d650
--- Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/FaultTreeIllustrationPointBasePropertyTest.cs	(.../FaultTreeIllustrationPointBasePropertyTest.cs)	(revision 5046628898b8fd85f7d2cfeb8a3192e2dcdc33e3)
+++ Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/FaultTreeIllustrationPointBasePropertyTest.cs	(.../FaultTreeIllustrationPointBasePropertyTest.cs)	(revision 0247a9558110b4efa96a4b38a8a5cf4bb611d650)
@@ -38,7 +38,7 @@
             const string expectedMessage = "Value cannot be null.";
 
             // Call
-            TestDelegate test = () => new FaultTreeIllustrationPointBaseProperty(null);
+            TestDelegate test = () => new FaultTreeIllustrationPointBaseProperties(null);
 
             // Assert
             TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, expectedMessage);
@@ -65,7 +65,7 @@
             });
 
             // Call
-            var faultTree = new FaultTreeIllustrationPointBaseProperty(topLevel);
+            var faultTree = new FaultTreeIllustrationPointBaseProperties(topLevel);
 
             // Assert
             Assert.AreEqual(faultTree.WindDirection, "N");
@@ -88,7 +88,7 @@
         public void ToString_CorrectValue_ReturnsCorrectString()
         {
             // Setup
-            var faultTree = new FaultTreeIllustrationPointBaseProperty(
+            var faultTree = new FaultTreeIllustrationPointBaseProperties(
                 new TopLevelFaultTreeIllustrationPoint(
                     new WindDirection("SSE", 5.0),
                     "closing situation",
Index: Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/FaultTreeIllustrationPointChildPropertyTest.cs
===================================================================
diff -u -r5046628898b8fd85f7d2cfeb8a3192e2dcdc33e3 -r0247a9558110b4efa96a4b38a8a5cf4bb611d650
--- Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/FaultTreeIllustrationPointChildPropertyTest.cs	(.../FaultTreeIllustrationPointChildPropertyTest.cs)	(revision 5046628898b8fd85f7d2cfeb8a3192e2dcdc33e3)
+++ Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/FaultTreeIllustrationPointChildPropertyTest.cs	(.../FaultTreeIllustrationPointChildPropertyTest.cs)	(revision 0247a9558110b4efa96a4b38a8a5cf4bb611d650)
@@ -20,6 +20,7 @@
 // All rights reserved.
 
 using System;
+using System.ComponentModel;
 using Core.Common.TestUtil;
 using Core.Common.Utils;
 using NUnit.Framework;
@@ -32,14 +33,24 @@
     [TestFixture]
     public class FaultTreeIllustrationPointChildPropertyTest
     {
+        private const int probabilityPropertyIndex = 0;
+        private const int reliabilityPropertyIndex = 1;
+        private const int windDirectionPropertyIndex = 2;
+        private const int closingScenarioPropertyIndex = 3;
+        private const int alphasPropertyIndex = 4;
+        private const int durationsPropertyIndex = 5;
+        private const int illustrationPointPropertyIndex = 6;
+
+        private const string illustrationPointsCategoryName = "Illustratiepunten";
+
         [Test]
         public void Constructor_InvalidIllustrationPointType_ThrowsException()
         {
             // Setup
             const string expectedMessage = "illustrationPointNode data type has to be FaultTreeIllustrationPoint";
 
             // Call
-            TestDelegate test = () => new FaultTreeIllustrationPointChildProperty(new IllustrationPointNode(new TestSubMechanismIllustrationPoint()), "N");
+            TestDelegate test = () => new FaultTreeIllustrationPointChildProperties(new IllustrationPointNode(new TestSubMechanismIllustrationPoint()), "N");
 
             // Assert
             TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, expectedMessage);
@@ -65,7 +76,7 @@
             illustrationPointNode.SetChildren(illustrationPointNodeChildren);
 
             // Call
-            var faultTree = new FaultTreeIllustrationPointChildProperty(illustrationPointNode, "N");
+            var faultTree = new FaultTreeIllustrationPointChildProperties(illustrationPointNode, "N");
 
             // Assert
             Assert.AreEqual(faultTree.WindDirection, "N");
@@ -90,10 +101,147 @@
         }
 
         [Test]
+        public void Constructor_WithChildIllustrationPointNodes_PropertiesHaveExpectedAttributesValues()
+        {
+            // Setup
+            var illustrationPointNode = new IllustrationPointNode(new FaultTreeIllustrationPoint("N",
+                                                                                                 1.5,
+                                                                                                 new Stochast[0],
+                                                                                                 CombinationType.And));
+            illustrationPointNode.SetChildren(new[]
+            {
+                new IllustrationPointNode(new FaultTreeIllustrationPoint("N",
+                                                                         7.2,
+                                                                         new Stochast[0],
+                                                                         CombinationType.And)),
+                new IllustrationPointNode(new SubMechanismIllustrationPoint("N",
+                                                                            7.2,
+                                                                            new SubMechanismIllustrationPointStochast[0],
+                                                                            new IllustrationPointResult[0]))
+            });
+
+            // Call
+            var faultTree = new FaultTreeIllustrationPointChildProperties(illustrationPointNode, "N");
+
+            // Assert
+            PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(faultTree);
+            Assert.AreEqual(7, dynamicProperties.Count);
+
+            PropertyDescriptor probabilityProperty = dynamicProperties[probabilityPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(probabilityProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Berekende kans [1/jaar]",
+                                                                            "De berekende kans van voorkomen van het berekende resultaat.",
+                                                                            true);
+
+            PropertyDescriptor reliabilityProperty = dynamicProperties[reliabilityPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(reliabilityProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Betrouwbaarheidsindex berekende kans [-]",
+                                                                            "Betrouwbaarheidsindex van de berekende kans van voorkomen van het berekende resultaat.",
+                                                                            true);
+
+            PropertyDescriptor windDirectionProperty = dynamicProperties[windDirectionPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(windDirectionProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Windrichting",
+                                                                            "De windrichting waarvoor dit illlustratiepunt is berekend.",
+                                                                            true);
+
+            PropertyDescriptor closingScenarioProperty = dynamicProperties[closingScenarioPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(closingScenarioProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Sluitscenario",
+                                                                            "Het sluitscenario waarvoor dit illustratiepunt is berekend.",
+                                                                            true);
+
+            PropertyDescriptor alphasProperty = dynamicProperties[alphasPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(alphasProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Alfa's [-]",
+                                                                            "Berekende invloedscoëfficiënten voor alle beschouwde stochasten.",
+                                                                            true);
+
+            PropertyDescriptor durationsProperty = dynamicProperties[durationsPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(durationsProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Tijdsduren [min]",
+                                                                            "Tijdsduren waarop de stochasten betrekking hebben.",
+                                                                            true);
+
+            PropertyDescriptor illustrationPointProperty = dynamicProperties[illustrationPointPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(illustrationPointProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Illustratiepunten",
+                                                                            "",
+                                                                            true);
+        }
+
+        [Test]
+        public void Constructor_WithoutChildIllustrationPointNodes_PropertiesHaveExpectedAttributesValues()
+        {
+            // Setup
+            // Setup
+            var illustrationPointNode = new IllustrationPointNode(new FaultTreeIllustrationPoint("N",
+                                                                                                 1.5,
+                                                                                                 new Stochast[0],
+                                                                                                 CombinationType.And));
+
+            // Call
+            var faultTree = new FaultTreeIllustrationPointChildProperties(illustrationPointNode, "N");
+
+            // Assert
+            PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(faultTree);
+            Assert.AreEqual(6, dynamicProperties.Count);
+
+            PropertyDescriptor probabilityProperty = dynamicProperties[probabilityPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(probabilityProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Berekende kans [1/jaar]",
+                                                                            "De berekende kans van voorkomen van het berekende resultaat.",
+                                                                            true);
+
+            PropertyDescriptor reliabilityProperty = dynamicProperties[reliabilityPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(reliabilityProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Betrouwbaarheidsindex berekende kans [-]",
+                                                                            "Betrouwbaarheidsindex van de berekende kans van voorkomen van het berekende resultaat.",
+                                                                            true);
+
+            PropertyDescriptor windDirectionProperty = dynamicProperties[windDirectionPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(windDirectionProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Windrichting",
+                                                                            "De windrichting waarvoor dit illlustratiepunt is berekend.",
+                                                                            true);
+
+            PropertyDescriptor closingScenarioProperty = dynamicProperties[closingScenarioPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(closingScenarioProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Sluitscenario",
+                                                                            "Het sluitscenario waarvoor dit illustratiepunt is berekend.",
+                                                                            true);
+
+            PropertyDescriptor alphasProperty = dynamicProperties[alphasPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(alphasProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Alfa's [-]",
+                                                                            "Berekende invloedscoëfficiënten voor alle beschouwde stochasten.",
+                                                                            true);
+
+            PropertyDescriptor durationsProperty = dynamicProperties[durationsPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(durationsProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Tijdsduren [min]",
+                                                                            "Tijdsduren waarop de stochasten betrekking hebben.",
+                                                                            true);
+        }
+
+        [Test]
         public void ToString_CorrectValue_ReturnsCorrectString()
         {
             // Setup
-            var faultTree = new FaultTreeIllustrationPointChildProperty(new IllustrationPointNode(new FaultTreeIllustrationPoint("N",
+            var faultTree = new FaultTreeIllustrationPointChildProperties(new IllustrationPointNode(new FaultTreeIllustrationPoint("N",
                                                                                                                                  1.5,
                                                                                                                                  new Stochast[0],
                                                                                                                                  CombinationType.And)),
Index: Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/IllustrationPointChildPropertyTest.cs
===================================================================
diff -u -r5046628898b8fd85f7d2cfeb8a3192e2dcdc33e3 -r0247a9558110b4efa96a4b38a8a5cf4bb611d650
--- Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/IllustrationPointChildPropertyTest.cs	(.../IllustrationPointChildPropertyTest.cs)	(revision 5046628898b8fd85f7d2cfeb8a3192e2dcdc33e3)
+++ Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/IllustrationPointChildPropertyTest.cs	(.../IllustrationPointChildPropertyTest.cs)	(revision 0247a9558110b4efa96a4b38a8a5cf4bb611d650)
@@ -33,14 +33,16 @@
     [TestFixture]
     public class IllustrationPointChildPropertyTest
     {
+        private const string illustrationPointCategoryName = "Illustratiepunten";
+
         [Test]
         public void Constructor_IllustrationPointNodeNull_ThrowsException()
         {
             // Setup
             const string expectedMessage = "Value cannot be null.";
 
             // Call
-            TestDelegate test = () => new IllustrationPointChildProperty(null, "N");
+            TestDelegate test = () => new IllustrationPointChildProperties(null, "N");
 
             // Assert
             TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, expectedMessage);
@@ -53,7 +55,7 @@
             const string expectedMessage = "Value cannot be null.";
 
             // Call
-            TestDelegate test = () => new IllustrationPointChildProperty(new IllustrationPointNode(new TestIllustrationPoint()), null);
+            TestDelegate test = () => new IllustrationPointChildProperties(new IllustrationPointNode(new TestIllustrationPoint()), null);
 
             // Assert
             TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, expectedMessage);
@@ -65,7 +67,7 @@
             // Setup
 
             // Call
-            var faultTree = new IllustrationPointChildProperty(new IllustrationPointNode(new SubMechanismIllustrationPoint("N",
+            var faultTree = new IllustrationPointChildProperties(new IllustrationPointNode(new SubMechanismIllustrationPoint("N",
                                                                                                                            1.5,
                                                                                                                            new SubMechanismIllustrationPointStochast[0],
                                                                                                                            new IllustrationPointResult[0])),
@@ -103,7 +105,7 @@
             });
 
             // Call
-            var faultTree = new IllustrationPointChildProperty(illustrationPointNode, "N");
+            var faultTree = new IllustrationPointChildProperties(illustrationPointNode, "N");
 
             // Assert
             Assert.AreEqual(faultTree.WindDirection, "N");
@@ -120,7 +122,7 @@
         public void ToString_CorrectValue_ReturnsCorrectString()
         {
             // Setup
-            var faultTree = new IllustrationPointChildProperty(new IllustrationPointNode(new SubMechanismIllustrationPoint("N",
+            var faultTree = new IllustrationPointChildProperties(new IllustrationPointNode(new SubMechanismIllustrationPoint("N",
                                                                                                                            1.5,
                                                                                                                            new SubMechanismIllustrationPointStochast[0],
                                                                                                                            new IllustrationPointResult[0])),
@@ -154,43 +156,43 @@
             });
 
             // Call
-            var faultTree = new IllustrationPointChildProperty(illustrationPointNode, "N");
+            var faultTree = new IllustrationPointChildProperties(illustrationPointNode, "N");
 
             // Assert
             PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(faultTree);
             Assert.AreEqual(5, dynamicProperties.Count);
 
             PropertyDescriptor probabilityProperty = dynamicProperties[0];
             PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(probabilityProperty,
-                                                                            "Misc",
+                                                                            illustrationPointCategoryName,
                                                                             "Berekende kans [1/jaar]",
                                                                             "De berekende kans van voorkomen van het berekende resultaat.",
                                                                             true);
 
             PropertyDescriptor reliabilityProperty = dynamicProperties[1];
             PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(reliabilityProperty,
-                                                                            "Misc",
+                                                                            illustrationPointCategoryName,
                                                                             "Betrouwbaarheidsindex berekende kans [-]",
                                                                             "Betrouwbaarheidsindex van de berekende kans van voorkomen van het berekende resultaat.",
                                                                             true);
 
             PropertyDescriptor windDirectionProperty = dynamicProperties[2];
             PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(windDirectionProperty,
-                                                                            "Misc",
+                                                                            illustrationPointCategoryName,
                                                                             "Windrichting",
                                                                             "De windrichting waarvoor dit illlustratiepunt is berekend.",
                                                                             true);
 
             PropertyDescriptor closingScenarioProperty = dynamicProperties[3];
             PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(closingScenarioProperty,
-                                                                            "Misc",
+                                                                            illustrationPointCategoryName,
                                                                             "Sluitscenario",
                                                                             "Het sluitscenario waarvoor dit illustratiepunt is berekend.",
                                                                             true);
 
             PropertyDescriptor illustrationPointProperty = dynamicProperties[4];
             PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(illustrationPointProperty,
-                                                                            "Misc",
+                                                                            illustrationPointCategoryName,
                                                                             "Illustratiepunten",
                                                                             "",
                                                                             true);
@@ -205,36 +207,36 @@
                                                                                                     new SubMechanismIllustrationPointStochast[0],
                                                                                                     new IllustrationPointResult[0]));
             // Call
-            var faultTree = new IllustrationPointChildProperty(illustrationPointNode, "N");
+            var faultTree = new IllustrationPointChildProperties(illustrationPointNode, "N");
 
             // Assert
             PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(faultTree);
             Assert.AreEqual(4, dynamicProperties.Count);
 
             PropertyDescriptor probabilityProperty = dynamicProperties[0];
             PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(probabilityProperty,
-                                                                            "Misc",
+                                                                            illustrationPointCategoryName,
                                                                             "Berekende kans [1/jaar]",
                                                                             "De berekende kans van voorkomen van het berekende resultaat.",
                                                                             true);
 
             PropertyDescriptor reliabilityProperty = dynamicProperties[1];
             PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(reliabilityProperty,
-                                                                            "Misc",
+                                                                            illustrationPointCategoryName,
                                                                             "Betrouwbaarheidsindex berekende kans [-]",
                                                                             "Betrouwbaarheidsindex van de berekende kans van voorkomen van het berekende resultaat.",
                                                                             true);
 
             PropertyDescriptor windDirectionProperty = dynamicProperties[2];
             PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(windDirectionProperty,
-                                                                            "Misc",
+                                                                            illustrationPointCategoryName,
                                                                             "Windrichting",
                                                                             "De windrichting waarvoor dit illlustratiepunt is berekend.",
                                                                             true);
 
             PropertyDescriptor closingScenarioProperty = dynamicProperties[3];
             PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(closingScenarioProperty,
-                                                                            "Misc",
+                                                                            illustrationPointCategoryName,
                                                                             "Sluitscenario",
                                                                             "Het sluitscenario waarvoor dit illustratiepunt is berekend.",
                                                                             true);
Index: Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/StructuresOutputPropertiesTest.cs
===================================================================
diff -u -r5046628898b8fd85f7d2cfeb8a3192e2dcdc33e3 -r0247a9558110b4efa96a4b38a8a5cf4bb611d650
--- Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/StructuresOutputPropertiesTest.cs	(.../StructuresOutputPropertiesTest.cs)	(revision 5046628898b8fd85f7d2cfeb8a3192e2dcdc33e3)
+++ Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/StructuresOutputPropertiesTest.cs	(.../StructuresOutputPropertiesTest.cs)	(revision 0247a9558110b4efa96a4b38a8a5cf4bb611d650)
@@ -95,7 +95,7 @@
 
             var expectedFaultTreeIllustrationPointBaseProperty = new[]
             {
-                new FaultTreeIllustrationPointBaseProperty(topLevelFaultTreeIllustrationPoint)
+                new FaultTreeIllustrationPointBaseProperties(topLevelFaultTreeIllustrationPoint)
             };
             var generalResult = new GeneralResult<TopLevelFaultTreeIllustrationPoint>(new WindDirection("SSE", 5.0), 
                                                                                       new Stochast[0], 
Index: Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/SubMechanismIllustrationPointChildPropertyTest.cs
===================================================================
diff -u -r5046628898b8fd85f7d2cfeb8a3192e2dcdc33e3 -r0247a9558110b4efa96a4b38a8a5cf4bb611d650
--- Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/SubMechanismIllustrationPointChildPropertyTest.cs	(.../SubMechanismIllustrationPointChildPropertyTest.cs)	(revision 5046628898b8fd85f7d2cfeb8a3192e2dcdc33e3)
+++ Ringtoets/Common/test/Ringtoets.Common.Forms.Test/PropertyClasses/SubMechanismIllustrationPointChildPropertyTest.cs	(.../SubMechanismIllustrationPointChildPropertyTest.cs)	(revision 0247a9558110b4efa96a4b38a8a5cf4bb611d650)
@@ -20,6 +20,7 @@
 // All rights reserved.
 
 using System;
+using System.ComponentModel;
 using Core.Common.TestUtil;
 using Core.Common.Utils;
 using NUnit.Framework;
@@ -31,14 +32,22 @@
     [TestFixture]
     public class SubMechanismIllustrationPointChildPropertyTest
     {
+        private const int probabilityPropertyIndex = 0;
+        private const int reliabilityPropertyIndex = 1;
+        private const int windDirectionPropertyIndex = 2;
+        private const int closingScenarioPropertyIndex = 3;
+        private const int subMechanismStochastPropertyIndex = 4;
+
+        private const string illustrationPointsCategoryName = "Illustratiepunten";
+
         [Test]
         public void Constructor_InvalidIllustrationPointType_ThrowsException()
         {
             // Setup
             const string expectedMessage = "illustrationPointNode data type has to be SubMechanismIllustrationPoint";
 
             // Call
-            TestDelegate test = () => new SubMechanismIllustrationPointChildProperty(new IllustrationPointNode(
+            TestDelegate test = () => new SubMechanismIllustrationPointChildProperties(new IllustrationPointNode(
                                                                                          new FaultTreeIllustrationPoint("N",
                                                                                                                         1.5,
                                                                                                                         new Stochast[0],
@@ -55,7 +64,7 @@
             // Setup
 
             // Call
-            var faultTree = new SubMechanismIllustrationPointChildProperty(new IllustrationPointNode(
+            var faultTree = new SubMechanismIllustrationPointChildProperties(new IllustrationPointNode(
                                                                                new SubMechanismIllustrationPoint("N",
                                                                                                                  1.5,
                                                                                                                  new SubMechanismIllustrationPointStochast[0],
@@ -77,10 +86,61 @@
         }
 
         [Test]
+        public void Constructor_WithSubMechanismIllustrationPoint_PropertiesHaveExpectedAttributesValues()
+        {
+            // Call
+            var faultTree = new SubMechanismIllustrationPointChildProperties(new IllustrationPointNode(
+                                                                               new SubMechanismIllustrationPoint("N",
+                                                                                                                 1.5,
+                                                                                                                 new SubMechanismIllustrationPointStochast[0],
+                                                                                                                 new IllustrationPointResult[0])),
+                                                                           "N");
+
+            // Assert
+            PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(faultTree);
+            Assert.AreEqual(5, dynamicProperties.Count);
+
+            PropertyDescriptor probabilityProperty = dynamicProperties[probabilityPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(probabilityProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Berekende kans [1/jaar]",
+                                                                            "De berekende kans van voorkomen van het berekende resultaat.",
+                                                                            true);
+
+            PropertyDescriptor reliabilityProperty = dynamicProperties[reliabilityPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(reliabilityProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Betrouwbaarheidsindex berekende kans [-]",
+                                                                            "Betrouwbaarheidsindex van de berekende kans van voorkomen van het berekende resultaat.",
+                                                                            true);
+
+            PropertyDescriptor windDirectionProperty = dynamicProperties[windDirectionPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(windDirectionProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Windrichting",
+                                                                            "De windrichting waarvoor dit illlustratiepunt is berekend.",
+                                                                            true);
+
+            PropertyDescriptor closingScenarioProperty = dynamicProperties[closingScenarioPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(closingScenarioProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Sluitscenario",
+                                                                            "Het sluitscenario waarvoor dit illustratiepunt is berekend.",
+                                                                            true);
+
+            PropertyDescriptor subMechanismStochastProperty = dynamicProperties[subMechanismStochastPropertyIndex];
+            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(subMechanismStochastProperty,
+                                                                            illustrationPointsCategoryName,
+                                                                            "Waarden in het illustratiepunt",
+                                                                            "Realisaties van de stochasten in het illustratiepunt",
+                                                                            true);
+        }
+
+        [Test]
         public void ToString_CorrectValue_ReturnsCorrectString()
         {
             // Setup
-            var faultTree = new SubMechanismIllustrationPointChildProperty(new IllustrationPointNode(
+            var faultTree = new SubMechanismIllustrationPointChildProperties(new IllustrationPointNode(
                                                                                new SubMechanismIllustrationPoint("N",
                                                                                                                  1.5,
                                                                                                                  new SubMechanismIllustrationPointStochast[0],