Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Create/StabilityStoneCover/StabilityStoneCoverFailureMechanismCreateExtensions.cs
===================================================================
diff -u -r11f0867b39150ae5fac83dc178a89fee46d27611 -rb1c3b9019f8f74992a7f1a681d494ae836ce4976
--- Application/Ringtoets/src/Application.Ringtoets.Storage/Create/StabilityStoneCover/StabilityStoneCoverFailureMechanismCreateExtensions.cs	(.../StabilityStoneCoverFailureMechanismCreateExtensions.cs)	(revision 11f0867b39150ae5fac83dc178a89fee46d27611)
+++ Application/Ringtoets/src/Application.Ringtoets.Storage/Create/StabilityStoneCover/StabilityStoneCoverFailureMechanismCreateExtensions.cs	(.../StabilityStoneCoverFailureMechanismCreateExtensions.cs)	(revision b1c3b9019f8f74992a7f1a681d494ae836ce4976)
@@ -43,6 +43,8 @@
             var entity = mechanism.Create(FailureMechanismType.StabilityStoneRevetment, registry);
             AddEntitiesForSectionResults(mechanism.SectionResults, registry);
 
+            entity.CalculationGroupEntity = mechanism.WaveConditionsCalculationGroup.Create(registry, 0);
+
             return entity;
         }
 
Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Read/CalculationGroupEntityReadExtentions.cs
===================================================================
diff -u -rb610d57f72acd9222a40ad4a3215c4f0072bfcb1 -rb1c3b9019f8f74992a7f1a681d494ae836ce4976
--- Application/Ringtoets/src/Application.Ringtoets.Storage/Read/CalculationGroupEntityReadExtentions.cs	(.../CalculationGroupEntityReadExtentions.cs)	(revision b610d57f72acd9222a40ad4a3215c4f0072bfcb1)
+++ Application/Ringtoets/src/Application.Ringtoets.Storage/Read/CalculationGroupEntityReadExtentions.cs	(.../CalculationGroupEntityReadExtentions.cs)	(revision b1c3b9019f8f74992a7f1a681d494ae836ce4976)
@@ -144,6 +144,37 @@
             return group;
         }
 
+        /// <summary>
+        /// Read the <see cref="CalculationGroupEntity"/> and use the information to construct
+        /// a <see cref="CalculationGroup"/>.
+        /// </summary>
+        /// <param name="entity">The <see cref="CalculationGroupEntity"/> to create 
+        /// <see cref="CalculationGroup"/> for.</param>
+        /// <param name="collector">The object keeping track of read operations.</param>
+        /// <returns>A new <see cref="CalculationGroup"/>.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="collector"/> is <c>null</c>.</exception>
+        internal static CalculationGroup ReadAsStabilityStoneCoverWaveConditionsCalculationGroup(this CalculationGroupEntity entity,
+                                                                                        ReadConversionCollector collector)
+        {
+            if (collector == null)
+            {
+                throw new ArgumentNullException("collector");
+            }
+
+            var group = new CalculationGroup(entity.Name, Convert.ToBoolean(entity.IsEditable));
+
+            foreach (object childEntity in GetChildEntitiesInOrder(entity))
+            {
+                var childCalculationGroupEntity = childEntity as CalculationGroupEntity;
+                if (childCalculationGroupEntity != null)
+                {
+                    group.Children.Add(childCalculationGroupEntity.ReadAsStabilityStoneCoverWaveConditionsCalculationGroup(collector));
+                }
+            }
+
+            return group;
+        }
+
         private static IEnumerable GetChildEntitiesInOrder(CalculationGroupEntity entity)
         {
             var sortedList = new SortedList();
Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Read/FailureMechanismEntityReadExtensions.cs
===================================================================
diff -u -rb610d57f72acd9222a40ad4a3215c4f0072bfcb1 -rb1c3b9019f8f74992a7f1a681d494ae836ce4976
--- Application/Ringtoets/src/Application.Ringtoets.Storage/Read/FailureMechanismEntityReadExtensions.cs	(.../FailureMechanismEntityReadExtensions.cs)	(revision b610d57f72acd9222a40ad4a3215c4f0072bfcb1)
+++ Application/Ringtoets/src/Application.Ringtoets.Storage/Read/FailureMechanismEntityReadExtensions.cs	(.../FailureMechanismEntityReadExtensions.cs)	(revision b1c3b9019f8f74992a7f1a681d494ae836ce4976)
@@ -449,7 +449,6 @@
             }
         }
 
-
         private static void ReadGrassCoverErosionOutwardsWaveConditionsRootCalculationGroup(CalculationGroupEntity rootCalculationGroupEntity,
                                                      CalculationGroup targetRootCalculationGroup, ReadConversionCollector collector)
         {
@@ -459,6 +458,7 @@
                 targetRootCalculationGroup.Children.Add(calculationBase);
             }
         }
+
         #endregion
 
         #region Grass Cover Slip Off Inwards
@@ -608,6 +608,8 @@
         {
             entity.ReadCommonFailureMechanismProperties(failureMechanism, collector);
             entity.ReadStabilityStoneCoverMechanismSectionResults(failureMechanism, collector);
+
+            ReadStabilityStoneCoverWaveConditionsRootCalculationGroup(entity.CalculationGroupEntity, failureMechanism.WaveConditionsCalculationGroup, collector);
         }
 
         private static void ReadStabilityStoneCoverMechanismSectionResults(this FailureMechanismEntity entity, StabilityStoneCoverFailureMechanism failureMechanism, ReadConversionCollector collector)
@@ -621,6 +623,16 @@
             }
         }
 
+        private static void ReadStabilityStoneCoverWaveConditionsRootCalculationGroup(CalculationGroupEntity rootCalculationGroupEntity,
+                                                     CalculationGroup targetRootCalculationGroup, ReadConversionCollector collector)
+        {
+            CalculationGroup rootCalculationGroup = rootCalculationGroupEntity.ReadAsStabilityStoneCoverWaveConditionsCalculationGroup(collector);
+            foreach (ICalculationBase calculationBase in rootCalculationGroup.Children)
+            {
+                targetRootCalculationGroup.Children.Add(calculationBase);
+            }
+        }
+
         #endregion
 
         #region Strength Stability Point Construction
Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/StabilityStoneCover/StabilityStoneCoverFailureMechanismCreateExtensionsTest.cs
===================================================================
diff -u -r1ff2f27e84cbd5da25a9da66d478467a773cb573 -rb1c3b9019f8f74992a7f1a681d494ae836ce4976
--- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/StabilityStoneCover/StabilityStoneCoverFailureMechanismCreateExtensionsTest.cs	(.../StabilityStoneCoverFailureMechanismCreateExtensionsTest.cs)	(revision 1ff2f27e84cbd5da25a9da66d478467a773cb573)
+++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/StabilityStoneCover/StabilityStoneCoverFailureMechanismCreateExtensionsTest.cs	(.../StabilityStoneCoverFailureMechanismCreateExtensionsTest.cs)	(revision b1c3b9019f8f74992a7f1a681d494ae836ce4976)
@@ -26,6 +26,7 @@
 using Application.Ringtoets.Storage.DbContext;
 using Application.Ringtoets.Storage.TestUtil;
 using NUnit.Framework;
+using Ringtoets.Common.Data.Calculation;
 using Ringtoets.StabilityStoneCover.Data;
 
 namespace Application.Ringtoets.Storage.Test.Create.StabilityStoneCover
@@ -117,5 +118,38 @@
             Assert.AreEqual(1, entity.FailureMechanismSectionEntities.Count);
             Assert.AreEqual(1, entity.FailureMechanismSectionEntities.SelectMany(fms => fms.StabilityStoneCoverSectionResultEntities).Count());
         }
+
+        [Test]
+        [TestCase(true)]
+        [TestCase(false)]
+        public void Create_WithCalculationGroup_ReturnFailureMechanismEntityWithCalculationGroupEntities(bool isRelevant)
+        {
+            // Setup
+            var failureMechanism = new StabilityStoneCoverFailureMechanism();
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(new CalculationGroup("A", true));
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(new CalculationGroup("B", true));
+
+            var registry = new PersistenceRegistry();
+
+            // Call
+            FailureMechanismEntity entity = failureMechanism.Create(registry);
+
+            // Assert
+            Assert.IsNotNull(entity);
+            Assert.AreEqual(failureMechanism.WaveConditionsCalculationGroup.Name, entity.CalculationGroupEntity.Name);
+            Assert.AreEqual(Convert.ToByte(failureMechanism.WaveConditionsCalculationGroup.IsNameEditable), entity.CalculationGroupEntity.IsEditable);
+            Assert.AreEqual(0, entity.CalculationGroupEntity.Order);
+
+            CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity.CalculationGroupEntity1
+                                                                .OrderBy(cge => cge.Order)
+                                                                .ToArray();
+            Assert.AreEqual(2, childGroupEntities.Length);
+            Assert.AreEqual("A", childGroupEntities[0].Name);
+            Assert.AreEqual(1, childGroupEntities[0].IsEditable);
+            Assert.AreEqual(0, childGroupEntities[0].Order);
+            Assert.AreEqual("B", childGroupEntities[1].Name);
+            Assert.AreEqual(1, childGroupEntities[1].IsEditable);
+            Assert.AreEqual(1, childGroupEntities[1].Order);
+        }
     }
 }
\ No newline at end of file
Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/AssessmentSectionEntityReadExtensionsTest.cs
===================================================================
diff -u -r765a93eb01cea4448d1dad2bbd6a4145b07b2d18 -rb1c3b9019f8f74992a7f1a681d494ae836ce4976
--- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/AssessmentSectionEntityReadExtensionsTest.cs	(.../AssessmentSectionEntityReadExtensionsTest.cs)	(revision 765a93eb01cea4448d1dad2bbd6a4145b07b2d18)
+++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/AssessmentSectionEntityReadExtensionsTest.cs	(.../AssessmentSectionEntityReadExtensionsTest.cs)	(revision b1c3b9019f8f74992a7f1a681d494ae836ce4976)
@@ -443,6 +443,45 @@
         }
 
         [Test]
+        [TestCase(true, TestName = "StabilityStoneCoverGroupsSet_ReturnsNewAssessmentSectionWithCalculationGroupStabilityStoneCover(true)")]
+        [TestCase(false, TestName = "StabilityStoneCoverGroupsSet_ReturnsNewAssessmentSectionWithCalculationGroupStabilityStoneCover(false)")]
+        public void Read_WithStabilityStoneCoverFailureMechanismWithWaveConditionsCalculationGroupsSet_ReturnsNewAssessmentSectionWithCalculationGroupsInFailureMechanism(bool isRelevant)
+        {
+            // Setup
+            var entity = CreateAssessmentSectionEntity();
+
+            var failureMechanismEntity = new FailureMechanismEntity
+            {
+                FailureMechanismType = (int)FailureMechanismType.StabilityStoneRevetment,
+                CalculationGroupEntity = new CalculationGroupEntity
+                {
+                    CalculationGroupEntity1 =
+                    {
+                        new CalculationGroupEntity
+                        {
+                            Order = 0
+                        },
+                        new CalculationGroupEntity
+                        {
+                            Order = 1
+                        }
+                    }
+                },
+                IsRelevant = Convert.ToByte(isRelevant)
+            };
+            entity.FailureMechanismEntities.Add(failureMechanismEntity);
+
+            var collector = new ReadConversionCollector();
+
+            // Call
+            var section = entity.Read(collector);
+
+            // Assert
+            IList<ICalculationBase> childCalculationGroups = section.StabilityStoneCover.WaveConditionsCalculationGroup.Children;
+            Assert.AreEqual(2, childCalculationGroups.Count);
+        }
+
+        [Test]
         [TestCase(true)]
         [TestCase(false)]
         public void Read_WithStandAloneFailureMechanismsSet_ReturnsNewAssessmentSectionWithFailureMechanismsSet(bool isRelevant)
@@ -456,7 +495,6 @@
             var closingEntityComment = "16";
             var failingOfConstructionPointEntityComment = "22";
             var failingOfConstructionLengthwiseEntityComment = "23";
-            var stoneRevetmentEntityComment = "36";
             var waveImpactEntityComment = "77";
             var waterPressureEntityComment = "78";
             var grassCoverSlipoffOutwardsEntityComment = "134";
@@ -471,7 +509,6 @@
             entity.FailureMechanismEntities.Add(CreateFailureMechanismEntity(isRelevant, closingEntityComment, FailureMechanismType.ReliabilityClosingOfStructure));
             entity.FailureMechanismEntities.Add(CreateFailureMechanismEntity(isRelevant, failingOfConstructionPointEntityComment, FailureMechanismType.StrengthAndStabilityPointConstruction));
             entity.FailureMechanismEntities.Add(CreateFailureMechanismEntity(isRelevant, failingOfConstructionLengthwiseEntityComment, FailureMechanismType.StrengthAndStabilityParallelConstruction));
-            entity.FailureMechanismEntities.Add(CreateFailureMechanismEntity(isRelevant, stoneRevetmentEntityComment, FailureMechanismType.StabilityStoneRevetment));
             entity.FailureMechanismEntities.Add(CreateFailureMechanismEntity(isRelevant, waveImpactEntityComment, FailureMechanismType.WaveImpactOnAsphaltRevetment));
             entity.FailureMechanismEntities.Add(CreateFailureMechanismEntity(isRelevant, waterPressureEntityComment, FailureMechanismType.WaterOverpressureAsphaltRevetment));
             entity.FailureMechanismEntities.Add(CreateFailureMechanismEntity(isRelevant, grassCoverSlipoffOutwardsEntityComment, FailureMechanismType.GrassRevetmentSlidingOutwards));
@@ -492,7 +529,6 @@
             AssertFailureMechanismEqual(isRelevant, closingEntityComment, 2, section.ClosingStructure);
             AssertFailureMechanismEqual(isRelevant, failingOfConstructionPointEntityComment, 2, section.StrengthStabilityPointConstruction);
             AssertFailureMechanismEqual(isRelevant, failingOfConstructionLengthwiseEntityComment, 2, section.StrengthStabilityLengthwiseConstruction);
-            AssertFailureMechanismEqual(isRelevant, stoneRevetmentEntityComment, 2, section.StabilityStoneCover);
             AssertFailureMechanismEqual(isRelevant, waveImpactEntityComment, 2, section.WaveImpactAsphaltCover);
             AssertFailureMechanismEqual(isRelevant, waterPressureEntityComment, 2, section.WaterPressureAsphaltCover);
             AssertFailureMechanismEqual(isRelevant, grassCoverSlipoffOutwardsEntityComment, 2, section.GrassCoverSlipOffOutwards);
Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/CalculationGroupEntityReadExtentionsTest.cs
===================================================================
diff -u -rb610d57f72acd9222a40ad4a3215c4f0072bfcb1 -rb1c3b9019f8f74992a7f1a681d494ae836ce4976
--- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/CalculationGroupEntityReadExtentionsTest.cs	(.../CalculationGroupEntityReadExtentionsTest.cs)	(revision b610d57f72acd9222a40ad4a3215c4f0072bfcb1)
+++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/CalculationGroupEntityReadExtentionsTest.cs	(.../CalculationGroupEntityReadExtentionsTest.cs)	(revision b1c3b9019f8f74992a7f1a681d494ae836ce4976)
@@ -564,5 +564,111 @@
             Assert.IsTrue(rootChildGroup1Child2.IsNameEditable);
             CollectionAssert.IsEmpty(rootChildGroup1Child2.Children);
         }
+
+        [Test]
+        public void ReadAsStabilityStoneCoverWaveConditionsCalculationGroup_CollectorIsNull_ThrowArgumentNullException()
+        {
+            // Setup
+            var entity = new CalculationGroupEntity();
+
+            // Call
+            TestDelegate call = () => entity.ReadAsStabilityStoneCoverWaveConditionsCalculationGroup(null);
+
+            // Assert
+            string paramName = Assert.Throws<ArgumentNullException>(call).ParamName;
+            Assert.AreEqual("collector", paramName);
+        }
+
+        [Test]
+        [TestCase("HAbba", 1)]
+        [TestCase("Dooeis", 0)]
+        public void ReadAsStabilityStoneCoverWaveConditionsCalculationGroup_EntityWithoutChildren_CreateCalculationGroupWithoutChildren(
+            string name, byte isEditable)
+        {
+            // Setup
+            var entity = new CalculationGroupEntity
+            {
+                Name = name,
+                IsEditable = isEditable
+            };
+
+            var collector = new ReadConversionCollector();
+
+            // Call
+            CalculationGroup group = entity.ReadAsStabilityStoneCoverWaveConditionsCalculationGroup(collector);
+
+            // Assert
+            Assert.AreEqual(name, group.Name);
+            Assert.AreEqual(Convert.ToBoolean(isEditable), group.IsNameEditable);
+            CollectionAssert.IsEmpty(group.Children);
+        }
+
+        [Test]
+        public void ReadAsStabilityStoneCoverWaveConditionsCalculationGroup_EntityWithChildGroups_CreateCalculationGroupWithChildGroups()
+        {
+            // Setup
+            var rootGroupEntity = new CalculationGroupEntity
+            {
+                Name = "A",
+                CalculationGroupEntity1 =
+                {
+                    new CalculationGroupEntity
+                    {
+                        Name = "AA",
+                        IsEditable = 1,
+                        Order = 0
+                    },
+                    new CalculationGroupEntity
+                    {
+                        Name = "AB",
+                        IsEditable = 0,
+                        CalculationGroupEntity1 =
+                        {
+                            new CalculationGroupEntity
+                            {
+                                Name = "ABA",
+                                IsEditable = 0,
+                                Order = 0
+                            },
+                            new CalculationGroupEntity
+                            {
+                                Name = "ABB",
+                                IsEditable = 1,
+                                Order = 1
+                            }
+                        },
+                        Order = 1
+                    }
+                }
+            };
+
+            var collector = new ReadConversionCollector();
+
+            // Call
+            var rootGroup = rootGroupEntity.ReadAsStabilityStoneCoverWaveConditionsCalculationGroup(collector);
+
+            // Assert
+            Assert.AreEqual("A", rootGroup.Name);
+            Assert.IsFalse(rootGroup.IsNameEditable);
+
+            ICalculationBase[] rootChildren = rootGroup.Children.ToArray();
+            var rootChildGroup1 = (CalculationGroup)rootChildren[0];
+            Assert.AreEqual("AA", rootChildGroup1.Name);
+            Assert.IsTrue(rootChildGroup1.IsNameEditable);
+            CollectionAssert.IsEmpty(rootChildGroup1.Children);
+            var rootChildGroup2 = (CalculationGroup)rootChildren[1];
+            Assert.AreEqual("AB", rootChildGroup2.Name);
+            Assert.IsFalse(rootChildGroup2.IsNameEditable);
+
+            ICalculationBase[] rootChildGroup2Children = rootChildGroup2.Children.ToArray();
+            var rootChildGroup1Child1 = (CalculationGroup)rootChildGroup2Children[0];
+            Assert.AreEqual("ABA", rootChildGroup1Child1.Name);
+            Assert.IsFalse(rootChildGroup1Child1.IsNameEditable);
+            CollectionAssert.IsEmpty(rootChildGroup1Child1.Children);
+            var rootChildGroup1Child2 = (CalculationGroup)rootChildGroup2Children[1];
+            Assert.AreEqual("ABB", rootChildGroup1Child2.Name);
+            Assert.IsTrue(rootChildGroup1Child2.IsNameEditable);
+            CollectionAssert.IsEmpty(rootChildGroup1Child2.Children);
+        }
     }
 }
\ No newline at end of file
Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/FailureMechanismEntityReadExtensionsTest.cs
===================================================================
diff -u -rb610d57f72acd9222a40ad4a3215c4f0072bfcb1 -rb1c3b9019f8f74992a7f1a681d494ae836ce4976
--- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/FailureMechanismEntityReadExtensionsTest.cs	(.../FailureMechanismEntityReadExtensionsTest.cs)	(revision b610d57f72acd9222a40ad4a3215c4f0072bfcb1)
+++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/FailureMechanismEntityReadExtensionsTest.cs	(.../FailureMechanismEntityReadExtensionsTest.cs)	(revision b1c3b9019f8f74992a7f1a681d494ae836ce4976)
@@ -32,6 +32,7 @@
 using Ringtoets.GrassCoverErosionInwards.Data;
 using Ringtoets.GrassCoverErosionOutwards.Data;
 using Ringtoets.Piping.Data;
+using Ringtoets.StabilityStoneCover.Data;
 
 namespace Application.Ringtoets.Storage.Test.Read
 {
@@ -605,6 +606,50 @@
             Assert.AreEqual("Child2", child2.Name);
         }
 
+        [Test]
+        public void ReadAsStabilityStoneCoverFailureMechanism_WithWaveConditionsCalculationGroup_ReturnsNewStabilityStoneCoverFailureMechanismWithCalculationGroupSet()
+        {
+            // Setup
+            var entity = new FailureMechanismEntity
+            {
+                CalculationGroupEntity = new CalculationGroupEntity
+                {
+                    IsEditable = 0,
+                    Name = "Berekeningen",
+                    Order = 0,
+                    CalculationGroupEntity1 =
+                    {
+                        new CalculationGroupEntity
+                        {
+                            IsEditable = 1,
+                            Name = "Child1",
+                            Order = 0
+                        },
+                        new CalculationGroupEntity
+                        {
+                            IsEditable = 1,
+                            Name = "Child2",
+                            Order = 1
+                        },
+                    }
+                }
+            };
+            var collector = new ReadConversionCollector();
+            var failureMechanism = new StabilityStoneCoverFailureMechanism();
+
+            // Call
+            entity.ReadAsStabilityStoneCoverFailureMechanism(failureMechanism, collector);
+
+            // Assert
+            Assert.AreEqual(2, failureMechanism.WaveConditionsCalculationGroup.Children.Count);
+
+            ICalculationBase child1 = failureMechanism.WaveConditionsCalculationGroup.Children[0];
+            Assert.AreEqual("Child1", child1.Name);
+
+            ICalculationBase child2 = failureMechanism.WaveConditionsCalculationGroup.Children[1];
+            Assert.AreEqual("Child2", child2.Name);
+        }
+
         #endregion
     }
 }
\ No newline at end of file
Index: Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectTestHelper.cs
===================================================================
diff -u -r765a93eb01cea4448d1dad2bbd6a4145b07b2d18 -rb1c3b9019f8f74992a7f1a681d494ae836ce4976
--- Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectTestHelper.cs	(.../RingtoetsProjectTestHelper.cs)	(revision 765a93eb01cea4448d1dad2bbd6a4145b07b2d18)
+++ Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectTestHelper.cs	(.../RingtoetsProjectTestHelper.cs)	(revision b1c3b9019f8f74992a7f1a681d494ae836ce4976)
@@ -77,14 +77,17 @@
             AddSections(grassCoverErosionOutwardsFailureMechanism);
             SetSectionResults(grassCoverErosionOutwardsFailureMechanism.SectionResults);
 
+            StabilityStoneCoverFailureMechanism stabilityStoneCoverFailureMechanism = assessmentSection.StabilityStoneCover;
+            ConfigureStabilityStoneCoverFailureMechanism(stabilityStoneCoverFailureMechanism);
+            AddSections(stabilityStoneCoverFailureMechanism);
+            SetSectionResults(stabilityStoneCoverFailureMechanism.SectionResults);
+
             AddSections(assessmentSection.MacrostabilityInwards);
             SetSectionResults(assessmentSection.MacrostabilityInwards.SectionResults);
             AddSections(assessmentSection.MacrostabilityOutwards);
             SetSectionResults(assessmentSection.MacrostabilityOutwards.SectionResults);
             AddSections(assessmentSection.Microstability);
             SetSectionResults(assessmentSection.Microstability.SectionResults);
-            AddSections(assessmentSection.StabilityStoneCover);
-            SetSectionResults(assessmentSection.StabilityStoneCover.SectionResults);
             AddSections(assessmentSection.WaveImpactAsphaltCover);
             SetSectionResults(assessmentSection.WaveImpactAsphaltCover.SectionResults);
             AddSections(assessmentSection.WaterPressureAsphaltCover);
@@ -364,6 +367,25 @@
             failureMechanism.GeneralInput.N = 15;
         }
 
+        private static void ConfigureStabilityStoneCoverFailureMechanism(StabilityStoneCoverFailureMechanism failureMechanism)
+        {
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(new CalculationGroup
+            {
+                Name = "SSC A"
+            });
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(new CalculationGroup
+            {
+                Name = "SSC B",
+                Children =
+                {
+                    new CalculationGroup
+                    {
+                        Name = "SSC B 1",
+                    }
+                }
+            });
+        }
+
         private static void SetSectionResults(IEnumerable<PipingFailureMechanismSectionResult> sectionResults)
         {
             var random = new Random(21);