Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.IO/Configurations/GrassCoverErosionInwardsCalculationConfigurationWriter.cs
===================================================================
diff -u -r8336ede0837d35257e8b85c3b0090b0774342d90 -r4c5ed0f6a4b5f4bbf8a39c6dd6d9d372ee54acfb
--- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.IO/Configurations/GrassCoverErosionInwardsCalculationConfigurationWriter.cs	(.../GrassCoverErosionInwardsCalculationConfigurationWriter.cs)	(revision 8336ede0837d35257e8b85c3b0090b0774342d90)
+++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.IO/Configurations/GrassCoverErosionInwardsCalculationConfigurationWriter.cs	(.../GrassCoverErosionInwardsCalculationConfigurationWriter.cs)	(revision 4c5ed0f6a4b5f4bbf8a39c6dd6d9d372ee54acfb)
@@ -19,135 +19,93 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
-using System.Collections.Generic;
+using System;
 using System.Xml;
-using Ringtoets.Common.Data.Probabilistics;
 using Ringtoets.Common.IO.Configurations;
 using Ringtoets.Common.IO.Configurations.Export;
-using Ringtoets.GrassCoverErosionInwards.Data;
 using Ringtoets.GrassCoverErosionInwards.IO.Configurations.Helpers;
 
 namespace Ringtoets.GrassCoverErosionInwards.IO.Configurations
 {
     /// <summary>
     /// Writer for writing a grass cover erosion inwards calculation configuration to XML.
     /// </summary>
-    public class GrassCoverErosionInwardsCalculationConfigurationWriter : CalculationConfigurationWriter<GrassCoverErosionInwardsCalculation>
+    public class GrassCoverErosionInwardsCalculationConfigurationWriter : SchemaCalculationConfigurationWriter<GrassCoverErosionInwardsCalculationConfiguration>
     {
-        protected override void WriteCalculation(GrassCoverErosionInwardsCalculation calculation, XmlWriter writer)
+        /// <summary>
+        /// Creates a new instance of <see cref="GrassCoverErosionInwardsCalculationConfigurationWriter"/>.
+        /// </summary>
+        /// <param name="filePath">The path of the file to write to.</param>
+        /// <exception cref="ArgumentException">Thrown when <paramref name="filePath"/> is invalid.</exception>
+        /// <remarks>A valid path:
+        /// <list type="bullet">
+        /// <item>is not empty or <c>null</c>,</item>
+        /// <item>does not consist out of only whitespace characters,</item>
+        /// <item>does not contain an invalid character,</item>
+        /// <item>does not end with a directory or path separator (empty file name).</item>
+        /// </list></remarks>
+        public GrassCoverErosionInwardsCalculationConfigurationWriter(string filePath) : base(filePath) {}
+
+        protected override void WriteCalculation(GrassCoverErosionInwardsCalculationConfiguration configuration, XmlWriter writer)
         {
             writer.WriteStartElement(ConfigurationSchemaIdentifiers.CalculationElement);
-            writer.WriteAttributeString(ConfigurationSchemaIdentifiers.NameAttribute, calculation.Name);
+            writer.WriteAttributeString(ConfigurationSchemaIdentifiers.NameAttribute, configuration.Name);
 
-            GrassCoverErosionInwardsInput input = calculation.InputParameters;
+            WriteElementWhenContentAvailable(
+                writer,
+                ConfigurationSchemaIdentifiers.HydraulicBoundaryLocationElement,
+                configuration.HydraulicBoundaryLocation);
 
-            WriteHydraulicBoundaryLocation(input, writer);
+            WriteElementWhenContentAvailable(
+                writer,
+                GrassCoverErosionInwardsCalculationConfigurationSchemaIdentifiers.DikeProfileElement,
+                configuration.DikeProfile);
+            WriteElementWhenContentAvailable(
+                writer,
+                ConfigurationSchemaIdentifiers.Orientation,
+                configuration.Orientation);
+            WriteElementWhenContentAvailable(
+                writer,
+                GrassCoverErosionInwardsCalculationConfigurationSchemaIdentifiers.DikeHeightElement,
+                configuration.DikeHeight);
 
-            WriteDikeProfileId(input, writer);
-
-            WriteOrientation(input, writer);
-
-            WriteDikeHeight(input, writer);
-
-            writer.WriteElementString(
+            WriteConfigurationLoadSchematizationTypeWhenAvailable(
+                writer,
                 GrassCoverErosionInwardsCalculationConfigurationSchemaIdentifiers.DikeHeightCalculationTypeElement,
-                HydraulicLoadsCalculationTypeAsXmlString((ConfigurationHydraulicLoadsCalculationType) input.DikeHeightCalculationType));
+                configuration.DikeHeightCalculationType);
 
-            writer.WriteElementString(
+            WriteConfigurationLoadSchematizationTypeWhenAvailable(
+                writer,
                 GrassCoverErosionInwardsCalculationConfigurationSchemaIdentifiers.OvertoppingRateCalculationTypeElement,
-                HydraulicLoadsCalculationTypeAsXmlString((ConfigurationHydraulicLoadsCalculationType) input.OvertoppingRateCalculationType));
+                configuration.OvertoppingRateCalculationType);
 
-            WriteWaveReduction(input, writer);
+            WriteWaveReductionWhenAvailable(writer, configuration.WaveReduction);
 
-            WriteDistributions(CreateInputDistributions(input), writer);
+            writer.WriteStartElement(ConfigurationSchemaIdentifiers.StochastsElement);
 
+            WriteDistributionWhenAvailable(
+                writer,
+                GrassCoverErosionInwardsCalculationConfigurationSchemaIdentifiers.CriticalFlowRateStochastName,
+                configuration.CriticalFlowRate);
+
             writer.WriteEndElement();
-        }
 
-        private static void WriteHydraulicBoundaryLocation(GrassCoverErosionInwardsInput input, XmlWriter writer)
-        {
-            if (input.HydraulicBoundaryLocation == null)
-            {
-                return;
-            }
-
-            writer.WriteElementString(
-                ConfigurationSchemaIdentifiers.HydraulicBoundaryLocationElement,
-                input.HydraulicBoundaryLocation.Name);
+            writer.WriteEndElement();
         }
 
-        private static void WriteDikeProfileId(GrassCoverErosionInwardsInput input, XmlWriter writer)
+        private static void WriteConfigurationLoadSchematizationTypeWhenAvailable(
+            XmlWriter writer,
+            string elementName,
+            ConfigurationHydraulicLoadsCalculationType? configuration)
         {
-            if (input.DikeProfile == null)
+            if (!configuration.HasValue)
             {
                 return;
             }
 
-            writer.WriteElementString(
-                GrassCoverErosionInwardsCalculationConfigurationSchemaIdentifiers.DikeProfileElement,
-                input.DikeProfile.Id);
+            var converter = new ConfigurationHydraulicLoadsCalculationTypeConverter();
+            writer.WriteElementString(elementName,
+                                      converter.ConvertToInvariantString(configuration.Value));
         }
-
-        private static void WriteOrientation(GrassCoverErosionInwardsInput input, XmlWriter writer)
-        {
-            if (input.DikeProfile == null)
-            {
-                return;
-            }
-
-            writer.WriteElementString(
-                ConfigurationSchemaIdentifiers.Orientation,
-                XmlConvert.ToString(input.Orientation));
-        }
-
-        private static void WriteDikeHeight(GrassCoverErosionInwardsInput input, XmlWriter writer)
-        {
-            if (input.DikeProfile == null)
-            {
-                return;
-            }
-
-            writer.WriteElementString(
-                GrassCoverErosionInwardsCalculationConfigurationSchemaIdentifiers.DikeHeightElement,
-                XmlConvert.ToString(input.DikeHeight));
-        }
-
-        private static string HydraulicLoadsCalculationTypeAsXmlString(ConfigurationHydraulicLoadsCalculationType type)
-        {
-            return new ConfigurationHydraulicLoadsCalculationTypeConverter().ConvertToInvariantString(type);
-        }
-
-        private static void WriteWaveReduction(GrassCoverErosionInwardsInput input, XmlWriter writer)
-        {
-            if (input.DikeProfile == null)
-            {
-                return;
-            }
-
-            writer.WriteStartElement(ConfigurationSchemaIdentifiers.WaveReduction);
-
-            writer.WriteElementString(
-                ConfigurationSchemaIdentifiers.UseBreakWater,
-                XmlConvert.ToString(input.UseBreakWater));
-
-            WriteBreakWaterProperties(input.BreakWater, writer);
-
-            writer.WriteElementString(
-                ConfigurationSchemaIdentifiers.UseForeshore,
-                XmlConvert.ToString(input.UseForeshore));
-
-            writer.WriteEndElement();
-        }
-
-        private static IDictionary<string, IDistribution> CreateInputDistributions(GrassCoverErosionInwardsInput calculationInputParameters)
-        {
-            return new Dictionary<string, IDistribution>
-            {
-                {
-                    GrassCoverErosionInwardsCalculationConfigurationSchemaIdentifiers.CriticalFlowRateStochastName,
-                    calculationInputParameters.CriticalFlowRate
-                }
-            };
-        }
     }
 }
\ No newline at end of file