Index: Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.IO/Configurations/ClosingStructuresCalculationConfigurationImporter.cs
===================================================================
diff -u -r335523a40d190e19b1061804de21c28f74140f52 -r3307edf9e893dd67926dffaac019185b32bbbe86
--- Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.IO/Configurations/ClosingStructuresCalculationConfigurationImporter.cs	(.../ClosingStructuresCalculationConfigurationImporter.cs)	(revision 335523a40d190e19b1061804de21c28f74140f52)
+++ Ringtoets/ClosingStructures/src/Ringtoets.ClosingStructures.IO/Configurations/ClosingStructuresCalculationConfigurationImporter.cs	(.../ClosingStructuresCalculationConfigurationImporter.cs)	(revision 3307edf9e893dd67926dffaac019185b32bbbe86)
@@ -23,6 +23,7 @@
 using System.Collections.Generic;
 using Core.Common.Base.Data;
 using Ringtoets.ClosingStructures.Data;
+using Ringtoets.ClosingStructures.IO.Configurations.Helpers;
 using Ringtoets.Common.Data.Calculation;
 using Ringtoets.Common.Data.DikeProfiles;
 using Ringtoets.Common.Data.Hydraulics;
@@ -101,6 +102,11 @@
                 && TryReadStochasts(readCalculation, calculation)
                 && TryReadOrientation(readCalculation, calculation)
                 && TryReadFailureProbabilityStructureWithErosion(readCalculation, calculation)
+                && TryReadFailureProbabilityOpenStructure(readCalculation, calculation)
+                && TryReadFailureProbabilityReparation(readCalculation, calculation)
+                && TryReadProbabilityOrFrequencyOpenStructureBeforeFlooding(readCalculation, calculation)
+                && TryReadInflowModelType(readCalculation, calculation)
+                && TryReadIdenticalApertures(readCalculation, calculation)
                 && readCalculation.WaveReduction.ValidateWaveReduction(calculation.InputParameters.ForeshoreProfile, calculation.Name, Log))
             {
                 ReadWaveReductionParameters(readCalculation.WaveReduction, calculation.InputParameters);
@@ -244,27 +250,60 @@
         {
             if (readCalculation.FailureProbabilityStructureWithErosion.HasValue)
             {
+                double failureProbability = readCalculation.FailureProbabilityStructureWithErosion.Value;
+
+                try
+                {
+                    calculation.InputParameters.FailureProbabilityStructureWithErosion = (RoundedDouble) failureProbability;
+                }
+                catch (ArgumentOutOfRangeException e)
+                {
+                    Log.LogOutOfRangeException(string.Format(
+                                                   RingtoetsCommonIOResources.TryReadParameter_Value_0_ParameterName_1_is_invalid,
+                                                   failureProbability,
+                                                   RingtoetsCommonIOResources.CalculationConfigurationImporter_FailureProbabilityStructureWithErosion_DisplayName),
+                                               calculation.Name,
+                                               e);
+
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Reads the failure probability open structure.
+        /// </summary>
+        /// <param name="readCalculation">The calculation read from the imported file.</param>
+        /// <param name="calculation">The calculation to configure.</param>
+        /// <returns><c>false</c> when the failure probability open structure is invalid or when there is a failure probability
+        /// open structure but no structure defined, <c>true</c> otherwise.</returns>
+        private bool TryReadFailureProbabilityOpenStructure(ClosingStructuresCalculationConfiguration readCalculation, StructuresCalculation<ClosingStructuresInput> calculation)
+        {
+            if (readCalculation.FailureProbabilityOpenStructure.HasValue)
+            {
                 if (calculation.InputParameters.Structure == null)
                 {
                     Log.LogCalculationConversionError(string.Format(RingtoetsCommonIOResources.CalculationConfigurationImporter_TryParameter_No_Structure_to_assign_Parameter_0_,
-                                                                    RingtoetsCommonIOResources.CalculationConfigurationImporter_FailureProbabilityStructureWithErosion_DisplayName),
+                                                                    RingtoetsCommonIOResources.CalculationConfigurationImporter_FailureProbabilityOpenStructure_DisplayName),
                                                       calculation.Name);
 
                     return false;
                 }
 
-                double failureProbability = readCalculation.FailureProbabilityStructureWithErosion.Value;
+                double failureProbability = readCalculation.FailureProbabilityOpenStructure.Value;
 
                 try
                 {
-                    calculation.InputParameters.FailureProbabilityStructureWithErosion = (RoundedDouble) failureProbability;
+                    calculation.InputParameters.FailureProbabilityOpenStructure = (RoundedDouble) failureProbability;
                 }
                 catch (ArgumentOutOfRangeException e)
                 {
                     Log.LogOutOfRangeException(string.Format(
                                                    RingtoetsCommonIOResources.TryReadParameter_Value_0_ParameterName_1_is_invalid,
                                                    failureProbability,
-                                                   RingtoetsCommonIOResources.CalculationConfigurationImporter_FailureProbabilityStructureWithErosion_DisplayName),
+                                                   RingtoetsCommonIOResources.CalculationConfigurationImporter_FailureProbabilityOpenStructure_DisplayName),
                                                calculation.Name,
                                                e);
 
@@ -275,6 +314,144 @@
             return true;
         }
 
+        /// <summary>
+        /// Reads the failure probability reparation.
+        /// </summary>
+        /// <param name="readCalculation">The calculation read from the imported file.</param>
+        /// <param name="calculation">The calculation to configure.</param>
+        /// <returns><c>false</c> when the failure probability reparation is invalid or when there is a failure probability 
+        /// reparation but no structure defined, <c>true</c> otherwise.</returns>
+        private bool TryReadFailureProbabilityReparation(ClosingStructuresCalculationConfiguration readCalculation, StructuresCalculation<ClosingStructuresInput> calculation)
+        {
+            if (readCalculation.FailureProbabilityReparation.HasValue)
+            {
+                if (calculation.InputParameters.Structure == null)
+                {
+                    Log.LogCalculationConversionError(string.Format(RingtoetsCommonIOResources.CalculationConfigurationImporter_TryParameter_No_Structure_to_assign_Parameter_0_,
+                                                                    RingtoetsCommonIOResources.CalculationConfigurationImporter_FailureProbabilityReparation_DisplayName),
+                                                      calculation.Name);
+
+                    return false;
+                }
+
+                double failureProbability = readCalculation.FailureProbabilityReparation.Value;
+
+                try
+                {
+                    calculation.InputParameters.FailureProbabilityReparation = (RoundedDouble) failureProbability;
+                }
+                catch (ArgumentOutOfRangeException e)
+                {
+                    Log.LogOutOfRangeException(string.Format(
+                                                   RingtoetsCommonIOResources.TryReadParameter_Value_0_ParameterName_1_is_invalid,
+                                                   failureProbability,
+                                                   RingtoetsCommonIOResources.CalculationConfigurationImporter_FailureProbabilityReparation_DisplayName),
+                                               calculation.Name,
+                                               e);
+
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Reads the probability or frequency open structure before flooding.
+        /// </summary>
+        /// <param name="readCalculation">The calculation read from the imported file.</param>
+        /// <param name="calculation">The calculation to configure.</param>
+        /// <returns><c>false</c> when the probability or frequency open structure before flooding is invalid or when there is a 
+        /// probability or frequency open structure before flooding but no structure defined, <c>true</c> otherwise.</returns>
+        private bool TryReadProbabilityOrFrequencyOpenStructureBeforeFlooding(ClosingStructuresCalculationConfiguration readCalculation, StructuresCalculation<ClosingStructuresInput> calculation)
+        {
+            if (readCalculation.ProbabilityOrFrequencyOpenStructureBeforeFlooding.HasValue)
+            {
+                if (calculation.InputParameters.Structure == null)
+                {
+                    Log.LogCalculationConversionError(string.Format(RingtoetsCommonIOResources.CalculationConfigurationImporter_TryParameter_No_Structure_to_assign_Parameter_0_,
+                                                                    RingtoetsCommonIOResources.CalculationConfigurationImporter_ProbabilityOrFrequencyOpenStructureBeforeFlooding_DisplayName),
+                                                      calculation.Name);
+
+                    return false;
+                }
+
+                double failureProbability = readCalculation.ProbabilityOrFrequencyOpenStructureBeforeFlooding.Value;
+
+                try
+                {
+                    calculation.InputParameters.ProbabilityOrFrequencyOpenStructureBeforeFlooding = (RoundedDouble) failureProbability;
+                }
+                catch (ArgumentOutOfRangeException e)
+                {
+                    Log.LogOutOfRangeException(string.Format(
+                                                   RingtoetsCommonIOResources.TryReadParameter_Value_0_ParameterName_1_is_invalid,
+                                                   failureProbability,
+                                                   RingtoetsCommonIOResources.CalculationConfigurationImporter_ProbabilityOrFrequencyOpenStructureBeforeFlooding_DisplayName),
+                                               calculation.Name,
+                                               e);
+
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Reads the inflow model type.
+        /// </summary>
+        /// <param name="readCalculation">The calculation read from the imported file.</param>
+        /// <param name="calculation">The calculation to configure.</param>
+        /// <returns><c>false</c> when the inflow model type is invalid or when there is a 
+        /// inflow model type but no structure defined, <c>true</c> otherwise.</returns>
+        private bool TryReadInflowModelType(ClosingStructuresCalculationConfiguration readCalculation, StructuresCalculation<ClosingStructuresInput> calculation)
+        {
+            if (readCalculation.InflowModelType.HasValue)
+            {
+                if (calculation.InputParameters.Structure == null)
+                {
+                    Log.LogCalculationConversionError(string.Format(RingtoetsCommonIOResources.CalculationConfigurationImporter_TryParameter_No_Structure_to_assign_Parameter_0_,
+                                                                    RingtoetsCommonIOResources.CalculationConfigurationImporter_InflowModelType_DisplayName),
+                                                      calculation.Name);
+
+                    return false;
+                }
+
+                calculation.InputParameters.InflowModelType =
+                    (ClosingStructureInflowModelType) new ConfigurationClosingStructureInflowModelTypeConverter()
+                        .ConvertTo(readCalculation.InflowModelType.Value, typeof(ClosingStructureInflowModelType));
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Reads the number of identical apertures.
+        /// </summary>
+        /// <param name="readCalculation">The calculation read from the imported file.</param>
+        /// <param name="calculation">The calculation to configure.</param>
+        /// <returns><c>false</c> when the number of identical apertures is invalid or when there is a 
+        /// number of identical apertures but no structure defined, <c>true</c> otherwise.</returns>
+        private bool TryReadIdenticalApertures(ClosingStructuresCalculationConfiguration readCalculation, StructuresCalculation<ClosingStructuresInput> calculation)
+        {
+            if (readCalculation.IdenticalApertures.HasValue)
+            {
+                if (calculation.InputParameters.Structure == null)
+                {
+                    Log.LogCalculationConversionError(string.Format(RingtoetsCommonIOResources.CalculationConfigurationImporter_TryParameter_No_Structure_to_assign_Parameter_0_,
+                                                                    RingtoetsCommonIOResources.CalculationConfigurationImporter_IdenticalApertures_DisplayName),
+                                                      calculation.Name);
+
+                    return false;
+                }
+
+                calculation.InputParameters.IdenticalApertures = readCalculation.IdenticalApertures.Value;
+            }
+
+            return true;
+        }
+
         private bool TryReadHydraulicBoundaryLocation(string locationName, StructuresCalculation<ClosingStructuresInput> calculation)
         {
             HydraulicBoundaryLocation location;