private static void ReadInputParameters(StabilityPointStructuresInput inputParameters,
StabilityPointStructuresCalculationEntity entity,
ReadConversionCollector collector)
{
if (entity.StabilityPointStructureEntity != null)
{
inputParameters.Structure = entity.StabilityPointStructureEntity.Read(collector);
}
entity.Read(inputParameters, collector);
inputParameters.InsideWaterLevel.Mean = (RoundedDouble)entity.InsideWaterLevelMean.ToNullAsNaN();
inputParameters.InsideWaterLevel.StandardDeviation = (RoundedDouble)entity.InsideWaterLevelStandardDeviation.ToNullAsNaN();
inputParameters.ThresholdHeightOpenWeir.Mean = (RoundedDouble)entity.ThresholdHeightOpenWeirMean.ToNullAsNaN();
inputParameters.ThresholdHeightOpenWeir.StandardDeviation = (RoundedDouble)entity.ThresholdHeightOpenWeirStandardDeviation.ToNullAsNaN();
inputParameters.ConstructiveStrengthLinearLoadModel.Mean = (RoundedDouble)entity.ConstructiveStrengthLinearLoadModelMean.ToNullAsNaN();
inputParameters.ConstructiveStrengthLinearLoadModel.CoefficientOfVariation = (RoundedDouble)entity.ConstructiveStrengthLinearLoadModelCoefficientOfVariation.ToNullAsNaN();
inputParameters.ConstructiveStrengthQuadraticLoadModel.Mean = (RoundedDouble)entity.ConstructiveStrengthQuadraticLoadModelMean.ToNullAsNaN();
inputParameters.ConstructiveStrengthQuadraticLoadModel.CoefficientOfVariation = (RoundedDouble)entity.ConstructiveStrengthQuadraticLoadModelCoefficientOfVariation.ToNullAsNaN();
inputParameters.BankWidth.Mean = (RoundedDouble)entity.BankWidthMean.ToNullAsNaN();
inputParameters.BankWidth.StandardDeviation = (RoundedDouble)entity.BankWidthStandardDeviation.ToNullAsNaN();
inputParameters.InsideWaterLevelFailureConstruction.Mean = (RoundedDouble)entity.InsideWaterLevelFailureConstructionMean.ToNullAsNaN();
inputParameters.InsideWaterLevelFailureConstruction.StandardDeviation = (RoundedDouble)entity.InsideWaterLevelFailureConstructionStandardDeviation.ToNullAsNaN();
inputParameters.EvaluationLevel = (RoundedDouble)entity.EvaluationLevel.ToNullAsNaN();
inputParameters.LevelCrestStructure.Mean = (RoundedDouble)entity.LevelCrestStructureMean.ToNullAsNaN();
inputParameters.LevelCrestStructure.StandardDeviation = (RoundedDouble)entity.LevelCrestStructureStandardDeviation.ToNullAsNaN();
inputParameters.VerticalDistance = (RoundedDouble)entity.VerticalDistance.ToNullAsNaN();
inputParameters.FailureProbabilityRepairClosure = entity.FailureProbabilityRepairClosure;
inputParameters.FailureCollisionEnergy.Mean = (RoundedDouble)entity.FailureCollisionEnergyMean.ToNullAsNaN();
inputParameters.FailureCollisionEnergy.CoefficientOfVariation = (RoundedDouble)entity.FailureCollisionEnergyCoefficientOfVariation.ToNullAsNaN();
inputParameters.ShipMass.Mean = (RoundedDouble)entity.ShipMassMean.ToNullAsNaN();
inputParameters.ShipMass.CoefficientOfVariation = (RoundedDouble)entity.ShipMassCoefficientOfVariation.ToNullAsNaN();
inputParameters.ShipVelocity.Mean = (RoundedDouble)entity.ShipVelocityMean.ToNullAsNaN();
inputParameters.ShipVelocity.CoefficientOfVariation = (RoundedDouble)entity.ShipVelocityCoefficientOfVariation.ToNullAsNaN();
inputParameters.LevellingCount = entity.LevellingCount;
inputParameters.ProbabilityCollisionSecondaryStructure = entity.ProbabilityCollisionSecondaryStructure;
inputParameters.FlowVelocityStructureClosable.Mean = (RoundedDouble)entity.FlowVelocityStructureClosableMean.ToNullAsNaN();
inputParameters.StabilityLinearLoadModel.Mean = (RoundedDouble)entity.StabilityLinearLoadModelMean.ToNullAsNaN();
inputParameters.StabilityLinearLoadModel.CoefficientOfVariation = (RoundedDouble)entity.StabilityLinearLoadModelCoefficientOfVariation.ToNullAsNaN();
inputParameters.StabilityQuadraticLoadModel.Mean = (RoundedDouble)entity.StabilityQuadraticLoadModelMean.ToNullAsNaN();
inputParameters.StabilityQuadraticLoadModel.CoefficientOfVariation = (RoundedDouble)entity.StabilityQuadraticLoadModelCoefficientOfVariation.ToNullAsNaN();
inputParameters.AreaFlowApertures.Mean = (RoundedDouble)entity.AreaFlowAperturesMean.ToNullAsNaN();
inputParameters.AreaFlowApertures.StandardDeviation = (RoundedDouble)entity.AreaFlowAperturesStandardDeviation.ToNullAsNaN();
inputParameters.InflowModelType = (StabilityPointStructureInflowModelType)entity.InflowModelType;
inputParameters.LoadSchematizationType = (LoadSchematizationType)entity.LoadSchematizationType;
inputParameters.VolumicWeightWater = (RoundedDouble)entity.VolumicWeightWater.ToNullAsNaN();
inputParameters.FactorStormDurationOpenStructure = (RoundedDouble)entity.FactorStormDurationOpenStructure.ToNullAsNaN();
inputParameters.DrainCoefficient.Mean = (RoundedDouble)entity.DrainCoefficientMean.ToNullAsNaN();
inputParameters.DrainCoefficient.StandardDeviation = (RoundedDouble)entity.DrainCoefficientStandardDeviation.ToNullAsNaN();
}
public void Read_EntityWithCalculationOutputEntityWithBlocksAndColumns_CalculationWithOutput()
{
// Setup
const double outputALevel = 5.4;
const double outputBLevel = 2.3;
const double outputCLevel = 13.2;
var entity = new StabilityStoneCoverWaveConditionsCalculationEntity
{
StabilityStoneCoverWaveConditionsOutputEntities =
{
new StabilityStoneCoverWaveConditionsOutputEntity
{
CalculationConvergence = Convert.ToByte(CalculationConvergence.NotCalculated),
WaterLevel = outputBLevel,
Order = 1,
OutputType = Convert.ToByte(StabilityStoneCoverWaveConditionsOutputType.Columns)
},
new StabilityStoneCoverWaveConditionsOutputEntity
{
CalculationConvergence = Convert.ToByte(CalculationConvergence.NotCalculated),
WaterLevel = outputCLevel,
Order = 2,
OutputType = Convert.ToByte(StabilityStoneCoverWaveConditionsOutputType.Blocks)
},
new StabilityStoneCoverWaveConditionsOutputEntity
{
CalculationConvergence = Convert.ToByte(CalculationConvergence.NotCalculated),
WaterLevel = outputALevel,
Order = 0,
OutputType = Convert.ToByte(StabilityStoneCoverWaveConditionsOutputType.Columns)
}
}
};
var collector = new ReadConversionCollector();
// Call
StabilityStoneCoverWaveConditionsCalculation calculation = entity.Read(collector);
// Assert
Assert.IsNotNull(calculation.Output);
double accuracy = calculation.Output.ColumnsOutput.ElementAt(0).WaterLevel.GetAccuracy();
Assert.AreEqual(2, calculation.Output.ColumnsOutput.Count());
Assert.AreEqual(outputALevel, calculation.Output.ColumnsOutput.ElementAt(0).WaterLevel, accuracy);
Assert.AreEqual(outputBLevel, calculation.Output.ColumnsOutput.ElementAt(1).WaterLevel, accuracy);
Assert.AreEqual(1, calculation.Output.BlocksOutput.Count());
Assert.AreEqual(outputCLevel, calculation.Output.BlocksOutput.ElementAt(0).WaterLevel, accuracy);
}
public void Read_EntityWithCalculationOutputEntityWithWaveRunUpAndWaveImpactWithWaveDirection_CalculationWithOutput()
{
// Setup
const double outputALevel = 0;
const double outputBLevel = 1.1;
const double outputCLevel = 2.2;
var entity = new GrassCoverErosionOutwardsWaveConditionsCalculationEntity
{
GrassCoverErosionOutwardsWaveConditionsOutputEntities =
{
new GrassCoverErosionOutwardsWaveConditionsOutputEntity
{
WaterLevel = outputBLevel,
Order = 1,
CalculationConvergence = Convert.ToByte(CalculationConvergence.NotCalculated),
OutputType = Convert.ToByte(GrassCoverErosionOutwardsWaveConditionsOutputType.WaveRunUp)
},
new GrassCoverErosionOutwardsWaveConditionsOutputEntity
{
WaterLevel = outputALevel,
Order = 0,
CalculationConvergence = Convert.ToByte(CalculationConvergence.NotCalculated),
OutputType = Convert.ToByte(GrassCoverErosionOutwardsWaveConditionsOutputType.WaveRunUp)
},
new GrassCoverErosionOutwardsWaveConditionsOutputEntity
{
WaterLevel = outputCLevel,
Order = 2,
CalculationConvergence = Convert.ToByte(CalculationConvergence.NotCalculated),
OutputType = Convert.ToByte(GrassCoverErosionOutwardsWaveConditionsOutputType.WaveImpactWithWaveDirection)
}
}
};
var collector = new ReadConversionCollector();
// Call
GrassCoverErosionOutwardsWaveConditionsCalculation calculation = entity.Read(collector);
// Assert
Assert.IsNotNull(calculation.Output);
double accuracy = calculation.Output.WaveImpactWithWaveDirectionOutput.First().WaterLevel.GetAccuracy();
Assert.AreEqual(2, calculation.Output.WaveRunUpOutput.Count());
Assert.AreEqual(outputALevel, calculation.Output.WaveRunUpOutput.ElementAt(0).WaterLevel, accuracy);
Assert.AreEqual(outputBLevel, calculation.Output.WaveRunUpOutput.ElementAt(1).WaterLevel, accuracy);
Assert.AreEqual(1, calculation.Output.WaveImpactWithWaveDirectionOutput.Count());
Assert.AreEqual(outputCLevel, calculation.Output.WaveImpactWithWaveDirectionOutput.ElementAt(0).WaterLevel, accuracy);
}
private static void SetInputParameters(MacroStabilityInwardsInput inputParameters,
MacroStabilityInwardsCalculationEntity entity,
ReadConversionCollector collector)
{
SetHydraulicBoundaryLocationPropertiesToInput(inputParameters, entity, collector);
SetSurfaceLineToInput(inputParameters, entity, collector);
SetStochasticSoilModelToInput(inputParameters, entity, collector);
inputParameters.SlipPlaneMinimumLength = (RoundedDouble)entity.SlipPlaneMinimumLength.ToNullAsNaN();
inputParameters.SlipPlaneMinimumDepth = (RoundedDouble)entity.SlipPlaneMinimumDepth.ToNullAsNaN();
inputParameters.MaximumSliceWidth = (RoundedDouble)entity.MaximumSliceWidth.ToNullAsNaN();
inputParameters.MoveGrid = Convert.ToBoolean(entity.MoveGrid);
inputParameters.DikeSoilScenario = (MacroStabilityInwardsDikeSoilScenario)entity.DikeSoilScenario;
inputParameters.WaterLevelRiverAverage = (RoundedDouble)entity.WaterLevelRiverAverage.ToNullAsNaN();
inputParameters.DrainageConstructionPresent = Convert.ToBoolean(entity.DrainageConstructionPresent);
inputParameters.XCoordinateDrainageConstruction = (RoundedDouble)entity.DrainageConstructionCoordinateX.ToNullAsNaN();
inputParameters.ZCoordinateDrainageConstruction = (RoundedDouble)entity.DrainageConstructionCoordinateZ.ToNullAsNaN();
inputParameters.MinimumLevelPhreaticLineAtDikeTopRiver = (RoundedDouble)entity.MinimumLevelPhreaticLineAtDikeTopRiver.ToNullAsNaN();
inputParameters.MinimumLevelPhreaticLineAtDikeTopPolder = (RoundedDouble)entity.MinimumLevelPhreaticLineAtDikeTopPolder.ToNullAsNaN();
SetLocationInputExtremeToInput(inputParameters.LocationInputExtreme, entity);
SetLocationInputDailyToInput(inputParameters.LocationInputDaily, entity);
inputParameters.AdjustPhreaticLine3And4ForUplift = Convert.ToBoolean(entity.AdjustPhreaticLine3And4ForUplift);
inputParameters.LeakageLengthOutwardsPhreaticLine4 = (RoundedDouble)entity.LeakageLengthOutwardsPhreaticLine4.ToNullAsNaN();
inputParameters.LeakageLengthInwardsPhreaticLine4 = (RoundedDouble)entity.LeakageLengthInwardsPhreaticLine4.ToNullAsNaN();
inputParameters.LeakageLengthOutwardsPhreaticLine3 = (RoundedDouble)entity.LeakageLengthOutwardsPhreaticLine3.ToNullAsNaN();
inputParameters.LeakageLengthInwardsPhreaticLine3 = (RoundedDouble)entity.LeakageLengthInwardsPhreaticLine3.ToNullAsNaN();
inputParameters.PiezometricHeadPhreaticLine2Outwards = (RoundedDouble)entity.PiezometricHeadPhreaticLine2Outwards.ToNullAsNaN();
inputParameters.PiezometricHeadPhreaticLine2Inwards = (RoundedDouble)entity.PiezometricHeadPhreaticLine2Inwards.ToNullAsNaN();
inputParameters.GridDeterminationType = (MacroStabilityInwardsGridDeterminationType)entity.GridDeterminationType;
inputParameters.TangentLineDeterminationType = (MacroStabilityInwardsTangentLineDeterminationType)entity.TangentLineDeterminationType;
inputParameters.TangentLineZTop = (RoundedDouble)entity.TangentLineZTop.ToNullAsNaN();
inputParameters.TangentLineZBottom = (RoundedDouble)entity.TangentLineZBottom.ToNullAsNaN();
inputParameters.TangentLineNumber = entity.TangentLineNumber;
SetGridparametersToInput(inputParameters.LeftGrid, inputParameters.RightGrid, entity);
inputParameters.CreateZones = Convert.ToBoolean(entity.CreateZones);
inputParameters.ZoningBoundariesDeterminationType = (MacroStabilityInwardsZoningBoundariesDeterminationType)entity.ZoningBoundariesDeterminationType;
inputParameters.ZoneBoundaryLeft = (RoundedDouble)entity.ZoneBoundaryLeft.ToNullAsNaN();
inputParameters.ZoneBoundaryRight = (RoundedDouble)entity.ZoneBoundaryRight.ToNullAsNaN();
}
public void Read_EntityWithStochasticSoilProfileEntityNotYetInCollector_CalculationWithCreatedStochasticSoilProfileAndRegisteredNewEntities()
{
// Setup
var stochasticSoilProfileEntity = new PipingStochasticSoilProfileEntity
{
PipingSoilProfileEntity = new PipingSoilProfileEntity
{
Name = "SoilProfile",
PipingSoilLayerEntities =
{
new PipingSoilLayerEntity()
}
}
};
var random = new Random(21);
var geometry = new[]
{
new Point2D(random.NextDouble(), random.NextDouble())
};
var stochasticSoilModelEntity = new StochasticSoilModelEntity
{
Name = "StochasticSoilModel",
StochasticSoilModelSegmentPointXml = new Point2DCollectionXmlSerializer().ToXml(geometry),
PipingStochasticSoilProfileEntities =
{
stochasticSoilProfileEntity
}
};
stochasticSoilProfileEntity.StochasticSoilModelEntity = stochasticSoilModelEntity;
var entity = new ProbabilisticPipingCalculationEntity
{
PipingStochasticSoilProfileEntity = stochasticSoilProfileEntity,
EntryPointL = 1,
ExitPointL = 2,
DampingFactorExitMean = 1
};
var collector = new ReadConversionCollector();
// Call
entity.Read(collector);
// Assert
Assert.IsTrue(collector.Contains(stochasticSoilProfileEntity));
Assert.IsTrue(collector.ContainsPipingStochasticSoilModel(stochasticSoilModelEntity));
}
public void Read_NullValues_ReturnHeightStructureWithNaN()
{
// Setup
var entity = new HeightStructureEntity
{
Name = "A",
Id = "B",
X = null,
Y = null,
StructureNormalOrientation = null,
LevelCrestStructureMean = null,
LevelCrestStructureStandardDeviation = null,
FlowWidthAtBottomProtectionMean = null,
FlowWidthAtBottomProtectionStandardDeviation = null,
CriticalOvertoppingDischargeMean = null,
CriticalOvertoppingDischargeCoefficientOfVariation = null,
WidthFlowAperturesMean = null,
WidthFlowAperturesStandardDeviation = null,
FailureProbabilityStructureWithErosion = null,
StorageStructureAreaMean = null,
StorageStructureAreaCoefficientOfVariation = null,
AllowedLevelIncreaseStorageMean = null,
AllowedLevelIncreaseStorageStandardDeviation = null
};
var collector = new ReadConversionCollector();
// Call
HeightStructure structure = entity.Read(collector);
// Assert
Assert.IsNaN(structure.Location.X);
Assert.IsNaN(structure.Location.Y);
Assert.IsNaN(structure.StructureNormalOrientation);
Assert.IsNaN(structure.LevelCrestStructure.Mean.Value);
Assert.IsNaN(structure.LevelCrestStructure.StandardDeviation.Value);
Assert.IsNaN(structure.FlowWidthAtBottomProtection.Mean.Value);
Assert.IsNaN(structure.FlowWidthAtBottomProtection.StandardDeviation.Value);
Assert.IsNaN(structure.CriticalOvertoppingDischarge.Mean.Value);
Assert.IsNaN(structure.CriticalOvertoppingDischarge.CoefficientOfVariation.Value);
Assert.IsNaN(structure.WidthFlowApertures.Mean.Value);
Assert.IsNaN(structure.WidthFlowApertures.StandardDeviation.Value);
Assert.IsNaN(structure.FailureProbabilityStructureWithErosion);
Assert.IsNaN(structure.StorageStructureArea.Mean.Value);
Assert.IsNaN(structure.StorageStructureArea.CoefficientOfVariation.Value);
Assert.IsNaN(structure.AllowedLevelIncreaseStorage.Mean.Value);
Assert.IsNaN(structure.AllowedLevelIncreaseStorage.StandardDeviation.Value);
}
/// <summary>
/// Read the <see cref="AssessmentSectionEntity"/> and use the information to construct a <see cref="AssessmentSection"/>.
/// </summary>
/// <param name="entity">The <see cref="AssessmentSectionEntity"/> to create <see cref="AssessmentSection"/> for.</param>
/// <param name="collector">The object keeping track of read operations.</param>
/// <returns>A new <see cref="AssessmentSection"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="collector"/> is <c>null</c>.</exception>
internal static AssessmentSection Read(this AssessmentSectionEntity entity, ReadConversionCollector collector)
{
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
var assessmentSection = new AssessmentSection((AssessmentSectionComposition)entity.Composition,
entity.MaximumAllowableFloodingProbability,
entity.SignalFloodingProbability)
{
Id = entity.Id,
Name = entity.Name,
Comments =
{
Body = entity.Comments
},
FailureMechanismContribution =
{
NormativeProbabilityType = (NormativeProbabilityType)entity.NormativeProbabilityType
}
};
entity.ReadBackgroundData(assessmentSection);
entity.ReadHydraulicDatabase(assessmentSection, collector);
entity.ReadHydraulicLocationCalculationsForTargetProbabilities(assessmentSection, collector);
entity.ReadReferenceLine(assessmentSection);
entity.ReadPipingFailureMechanism(assessmentSection, collector);
entity.ReadGrassCoverErosionInwardsFailureMechanism(assessmentSection, collector);
entity.ReadHeightStructuresFailureMechanism(assessmentSection, collector);
entity.ReadWaterPressureAsphaltCoverFailureMechanism(assessmentSection, collector);
entity.ReadClosingStructuresFailureMechanism(assessmentSection, collector);
entity.ReadMacroStabilityInwardsFailureMechanism(assessmentSection, collector);
entity.ReadWaveImpactAsphaltCoverFailureMechanism(assessmentSection, collector);
entity.ReadGrassCoverErosionOutwardsFailureMechanism(assessmentSection, collector);
entity.ReadGrassCoverSlipOffInwardsFailureMechanism(assessmentSection, collector);
entity.ReadGrassCoverSlipOffOutwardsFailureMechanism(assessmentSection, collector);
entity.ReadMicrostabilityFailureMechanism(assessmentSection, collector);
entity.ReadPipingStructureFailureMechanism(assessmentSection, collector);
entity.ReadDuneErosionFailureMechanism(assessmentSection, collector);
entity.ReadStabilityStoneCoverFailureMechanism(assessmentSection, collector);
entity.ReadStabilityPointStructuresFailureMechanism(assessmentSection, collector);
entity.ReadSpecificFailureMechanisms(assessmentSection, collector);
return(assessmentSection);
}
public void Read_AlreadyReadDikeProfileEntity_ReturnDikeProfile()
{
// Setup
var registeredEntity = new DikeProfileEntity();
DikeProfile registeredProfile = DikeProfileTestFactory.CreateDikeProfile();
var collector = new ReadConversionCollector();
collector.Read(registeredEntity, registeredProfile);
// Call
DikeProfile returnedProfile = registeredEntity.Read(collector);
// Assert
Assert.AreSame(registeredProfile, returnedProfile);
}
public void Read_EntityRegistered_ReturnRegisteredStructure()
{
// Setup
var entity = new ClosingStructureEntity();
ClosingStructure registeredStructure = new TestClosingStructure();
var collector = new ReadConversionCollector();
collector.Read(entity, registeredStructure);
// Call
ClosingStructure readStructure = entity.Read(collector);
// Assert
Assert.AreSame(registeredStructure, readStructure);
}
public void Read_EntityWithNoAssessmentSections_ThrowsEntityReadException()
{
// Setup
var entity = new ProjectEntity();
var collector = new ReadConversionCollector();
// Call
void Call() => entity.Read(collector);
// Assert
var exception = Assert.Throws <EntityReadException>(Call);
const string message = "Het project bevat geen traject. Dit bestand is mogelijk een gemigreerd project met geen trajecten.";
Assert.AreEqual(message, exception.Message);
}
public void Get_DataModelAdded_ReturnsEntity()
{
// Setup
var collector = new ReadConversionCollector();
TDataModel dataModel = CreateDataModel();
var entity = new TEntity();
registerToCollector(collector, entity, dataModel);
// Call
TDataModel result = getFromCollector(collector, entity);
// Assert
Assert.AreSame(dataModel, result);
}
public void ReadAsPipingSurfaceLine_SurfaceLineEntityWithPointsAndAllCharacteristicPointsSetToSamePoint_ReturnsExpectedSurfaceLine()
{
// Setup
var collector = new ReadConversionCollector();
var random = new Random(31);
Point3D[] points =
{
CreatePoint3D(random),
CreatePoint3D(random)
};
var entity = new SurfaceLineEntity
{
Name = "Better name.",
ReferenceLineIntersectionX = random.NextDouble(),
ReferenceLineIntersectionY = random.NextDouble(),
PointsXml = new Point3DCollectionXmlSerializer().ToXml(points),
PipingCharacteristicPointEntities =
{
CreatePipingCharacteristicPointEntity(points[0], PipingCharacteristicPointType.BottomDitchDikeSide),
CreatePipingCharacteristicPointEntity(points[0], PipingCharacteristicPointType.BottomDitchPolderSide),
CreatePipingCharacteristicPointEntity(points[0], PipingCharacteristicPointType.DikeToeAtPolder),
CreatePipingCharacteristicPointEntity(points[0], PipingCharacteristicPointType.DikeToeAtRiver),
CreatePipingCharacteristicPointEntity(points[0], PipingCharacteristicPointType.DitchDikeSide),
CreatePipingCharacteristicPointEntity(points[0], PipingCharacteristicPointType.DitchPolderSide)
}
};
// Call
PipingSurfaceLine surfaceLine = entity.ReadAsPipingSurfaceLine(collector);
// Assert
Assert.AreEqual(entity.Name, surfaceLine.Name);
Assert.AreEqual(entity.ReferenceLineIntersectionX, surfaceLine.ReferenceLineIntersectionWorldPoint.X);
Assert.AreEqual(entity.ReferenceLineIntersectionY, surfaceLine.ReferenceLineIntersectionWorldPoint.Y);
Point3D[] geometry = surfaceLine.Points.ToArray();
Assert.AreEqual(2, geometry.Length);
Point3D geometryPoint = geometry[0];
Assert.AreSame(geometryPoint, surfaceLine.BottomDitchDikeSide);
Assert.AreSame(geometryPoint, surfaceLine.BottomDitchPolderSide);
Assert.AreSame(geometryPoint, surfaceLine.DikeToeAtPolder);
Assert.AreSame(geometryPoint, surfaceLine.DikeToeAtRiver);
Assert.AreSame(geometryPoint, surfaceLine.DitchDikeSide);
Assert.AreSame(geometryPoint, surfaceLine.DitchPolderSide);
}
private static void ReadInputParameters(HeightStructuresInput inputParameters,
HeightStructuresCalculationEntity entity,
ReadConversionCollector collector)
{
if (entity.HeightStructureEntity != null)
{
inputParameters.Structure = entity.HeightStructureEntity.Read(collector);
}
entity.Read(inputParameters, collector);
inputParameters.DeviationWaveDirection = (RoundedDouble)entity.DeviationWaveDirection.ToNullAsNaN();
inputParameters.ModelFactorSuperCriticalFlow.Mean = (RoundedDouble)entity.ModelFactorSuperCriticalFlowMean.ToNullAsNaN();
inputParameters.LevelCrestStructure.Mean = (RoundedDouble)entity.LevelCrestStructureMean.ToNullAsNaN();
inputParameters.LevelCrestStructure.StandardDeviation = (RoundedDouble)entity.LevelCrestStructureStandardDeviation.ToNullAsNaN();
}
public void Read_EntityWithNullValues_ReturnSpecificFailureMechanism()
{
// Setup
var entity = new SpecificFailureMechanismEntity
{
N = 1.1
};
var collector = new ReadConversionCollector();
// Call
SpecificFailureMechanism specificFailureMechanism = entity.Read(collector);
// Assert
FailureMechanismAssemblyResult assemblyResult = specificFailureMechanism.AssemblyResult;
Assert.IsNaN(assemblyResult.ManualFailureMechanismAssemblyProbability);
}
public void Read_EntityWithHydraulicBoundaryLocationNotYetInCollector_CalculationWithCreatedHydraulicBoundaryLocationAndRegisteredNewEntities()
{
// Setup
HydraulicLocationEntity hydraulicLocationEntity = HydraulicLocationEntityTestFactory.CreateHydraulicLocationEntity();
var entity = new WaveImpactAsphaltCoverWaveConditionsCalculationEntity
{
HydraulicLocationEntity = hydraulicLocationEntity
};
var collector = new ReadConversionCollector();
// Call
entity.Read(collector);
// Assert
Assert.IsTrue(collector.Contains(hydraulicLocationEntity));
}
public void Read_SameHydraulicLocationEntityTwice_ReturnSameHydraulicBoundaryLocation()
{
// Setup
var entity = new HydraulicLocationEntity
{
Name = "A"
};
var collector = new ReadConversionCollector();
// Call
HydraulicBoundaryLocation location1 = entity.Read(collector);
HydraulicBoundaryLocation location2 = entity.Read(collector);
// Assert
Assert.AreSame(location1, location2);
}
public void Read_WithGeometryAndBreakWaterTypeAndValues_CompleteForeshoreProfile()
{
// Setup
const string name = "testName";
const string id = "testId";
var random = new Random(21);
int order = random.Next();
double orientation = random.NextDouble();
double x0 = random.NextDouble();
double height = random.NextDouble();
const BreakWaterType breakWaterType = BreakWaterType.Wall;
var points = new[]
{
new Point2D(0, 0)
};
string pointXml = new Point2DCollectionXmlSerializer().ToXml(points);
var entity = new ForeshoreProfileEntity
{
Order = order,
Id = id,
Name = name,
Orientation = orientation,
X0 = x0,
BreakWaterType = Convert.ToByte(breakWaterType),
BreakWaterHeight = height,
GeometryXml = pointXml
};
var readConversionCollector = new ReadConversionCollector();
// Call
ForeshoreProfile foreshoreProfile = entity.Read(readConversionCollector);
// Assert
Assert.IsNotNull(foreshoreProfile);
Assert.AreEqual(name, foreshoreProfile.Name);
Assert.AreEqual(order, entity.Order);
Assert.AreEqual(id, foreshoreProfile.Id);
Assert.AreEqual(name, entity.Name);
Assert.AreEqual(orientation, foreshoreProfile.Orientation, foreshoreProfile.Orientation.GetAccuracy());
Assert.AreEqual(x0, entity.X0);
Assert.AreEqual(breakWaterType, foreshoreProfile.BreakWater.Type);
Assert.IsTrue(foreshoreProfile.HasBreakWater);
CollectionAssert.AreEqual(points, foreshoreProfile.Geometry);
}
public void Read_DikeProfileEntityWithBreakWater_ReturnDikeProfileWithBreakWater(BreakWaterType type, double height)
{
// Setup
var foreshorePoints = new Point2D[0];
var roughnessPoints = new[]
{
new RoughnessPoint(new Point2D(1.1, 2.2), 1.0),
new RoughnessPoint(new Point2D(3.3, 4.4), 0.6),
new RoughnessPoint(new Point2D(5.5, 6.6), 1.0),
new RoughnessPoint(new Point2D(7.7, 8.8), 0.5)
};
var entity = new DikeProfileEntity
{
Id = "with_breakwater",
Name = "I have a Breakwater!",
Orientation = 360.0,
BreakWaterHeight = height,
BreakWaterType = Convert.ToByte(type),
ForeshoreXml = new Point2DCollectionXmlSerializer().ToXml(foreshorePoints),
DikeGeometryXml = new RoughnessPointCollectionXmlSerializer().ToXml(roughnessPoints),
DikeHeight = 4.5,
X = 93.0,
Y = 945.6,
X0 = 9.34
};
var collector = new ReadConversionCollector();
// Call
DikeProfile dikeProfile = entity.Read(collector);
// Assert
Assert.AreEqual(entity.Id, dikeProfile.Id);
Assert.AreEqual(entity.Name, dikeProfile.Name);
Assert.AreEqual(entity.Orientation, dikeProfile.Orientation.Value);
CollectionAssert.AreEqual(foreshorePoints, dikeProfile.ForeshoreGeometry);
CollectionAssert.AreEqual(roughnessPoints, dikeProfile.DikeGeometry, new RoughnessPointComparer());
Assert.AreEqual(entity.X, dikeProfile.WorldReferencePoint.X);
Assert.AreEqual(entity.Y, dikeProfile.WorldReferencePoint.Y);
Assert.AreEqual(entity.X0, dikeProfile.X0);
Assert.AreEqual(height, dikeProfile.BreakWater.Height.Value);
Assert.AreEqual(type, dikeProfile.BreakWater.Type);
Assert.IsTrue(collector.Contains(entity));
}
public void Read_ValidEntityWithoutSections_ReturnSpecificFailureMechanism()
{
// Setup
var entity = new SpecificFailureMechanismEntity
{
N = 1.1
};
var collector = new ReadConversionCollector();
// Call
SpecificFailureMechanism specificFailureMechanism = entity.Read(collector);
// Assert
Assert.AreEqual(entity.FailureMechanismSectionEntities.Count, specificFailureMechanism.Sections.Count());
Assert.IsNull(specificFailureMechanism.FailureMechanismSectionSourcePath);
}
public void Read_SameDuneLocationEntityTwice_ReturnSameDuneLocation()
{
// Setup
var entity = new DuneLocationEntity
{
Name = "A"
};
var collector = new ReadConversionCollector();
// Call
DuneLocation location1 = entity.Read(collector);
DuneLocation location2 = entity.Read(collector);
// Assert
Assert.AreSame(location1, location2);
}
/// <summary>
/// Reads all the information from the entity and updated the given input object,
/// with the exception of the <see cref="StructuresInputBase{T}.Structure"/> property.
/// </summary>
/// <typeparam name="T">The type of structure residing in <paramref name="inputToUpdate"/>.</typeparam>
/// <param name="entity">The entity.</param>
/// <param name="inputToUpdate">The input object to update.</param>
/// <param name="collector">The object keeping track of read operations.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="inputToUpdate"/>
/// or <paramref name="collector"/> is <c>null</c>.</exception>
internal static void Read <T>(this IStructuresCalculationEntity entity,
StructuresInputBase <T> inputToUpdate,
ReadConversionCollector collector) where T : StructureBase
{
if (inputToUpdate == null)
{
throw new ArgumentNullException(nameof(inputToUpdate));
}
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
if (entity.ForeshoreProfileEntity != null)
{
inputToUpdate.ForeshoreProfile = entity.ForeshoreProfileEntity.Read(collector);
}
if (entity.HydraulicLocationEntity != null)
{
inputToUpdate.HydraulicBoundaryLocation = entity.HydraulicLocationEntity.Read(collector);
}
inputToUpdate.StructureNormalOrientation = (RoundedDouble)entity.StructureNormalOrientation.ToNullAsNaN();
inputToUpdate.AllowedLevelIncreaseStorage.Mean = (RoundedDouble)entity.AllowedLevelIncreaseStorageMean.ToNullAsNaN();
inputToUpdate.AllowedLevelIncreaseStorage.StandardDeviation = (RoundedDouble)entity.AllowedLevelIncreaseStorageStandardDeviation.ToNullAsNaN();
inputToUpdate.StorageStructureArea.Mean = (RoundedDouble)entity.StorageStructureAreaMean.ToNullAsNaN();
inputToUpdate.StorageStructureArea.CoefficientOfVariation = (RoundedDouble)entity.StorageStructureAreaCoefficientOfVariation.ToNullAsNaN();
inputToUpdate.FlowWidthAtBottomProtection.Mean = (RoundedDouble)entity.FlowWidthAtBottomProtectionMean.ToNullAsNaN();
inputToUpdate.FlowWidthAtBottomProtection.StandardDeviation = (RoundedDouble)entity.FlowWidthAtBottomProtectionStandardDeviation.ToNullAsNaN();
inputToUpdate.CriticalOvertoppingDischarge.Mean = (RoundedDouble)entity.CriticalOvertoppingDischargeMean.ToNullAsNaN();
inputToUpdate.CriticalOvertoppingDischarge.CoefficientOfVariation = (RoundedDouble)entity.CriticalOvertoppingDischargeCoefficientOfVariation.ToNullAsNaN();
inputToUpdate.FailureProbabilityStructureWithErosion = entity.FailureProbabilityStructureWithErosion;
inputToUpdate.WidthFlowApertures.Mean = (RoundedDouble)entity.WidthFlowAperturesMean.ToNullAsNaN();
inputToUpdate.WidthFlowApertures.StandardDeviation = (RoundedDouble)entity.WidthFlowAperturesStandardDeviation.ToNullAsNaN();
inputToUpdate.StormDuration.Mean = (RoundedDouble)entity.StormDurationMean.ToNullAsNaN();
inputToUpdate.UseBreakWater = Convert.ToBoolean(entity.UseBreakWater);
inputToUpdate.BreakWater.Type = (BreakWaterType)entity.BreakWaterType;
inputToUpdate.BreakWater.Height = (RoundedDouble)entity.BreakWaterHeight.ToNullAsNaN();
inputToUpdate.UseForeshore = Convert.ToBoolean(entity.UseForeshore);
inputToUpdate.ShouldIllustrationPointsBeCalculated = Convert.ToBoolean(entity.ShouldIllustrationPointsBeCalculated);
}
public void Read_DikeProfileEntityWithBreakWaterPropertiesNull_ReturnDikeProfileWithoutBreakWater()
{
// Setup
var foreshorePoints = new[]
{
new Point2D(-9.9, 8.8),
new Point2D(-7.7, 5.5)
};
var roughnessPoints = new[]
{
new RoughnessPoint(new Point2D(-7.7, 5.5), 1.0),
new RoughnessPoint(new Point2D(5.5, 6.6), 0.5)
};
var entity = new DikeProfileEntity
{
Id = "saved",
Name = "Just saved",
Orientation = 45.67,
BreakWaterHeight = null,
BreakWaterType = null,
ForeshoreXml = new Point2DCollectionXmlSerializer().ToXml(foreshorePoints),
DikeGeometryXml = new RoughnessPointCollectionXmlSerializer().ToXml(roughnessPoints),
DikeHeight = 1.2,
X = 3.4,
Y = 5.6,
X0 = -7.8
};
var collector = new ReadConversionCollector();
// Call
DikeProfile dikeProfile = entity.Read(collector);
// Assert
Assert.AreEqual(entity.Id, dikeProfile.Id);
Assert.AreEqual(entity.Name, dikeProfile.Name);
Assert.AreEqual(entity.Orientation, dikeProfile.Orientation.Value);
CollectionAssert.AreEqual(foreshorePoints, dikeProfile.ForeshoreGeometry);
CollectionAssert.AreEqual(roughnessPoints, dikeProfile.DikeGeometry, new RoughnessPointComparer());
Assert.AreEqual(entity.X, dikeProfile.WorldReferencePoint.X);
Assert.AreEqual(entity.Y, dikeProfile.WorldReferencePoint.Y);
Assert.AreEqual(entity.X0, dikeProfile.X0);
Assert.IsFalse(dikeProfile.HasBreakWater);
}
public void ReadAsMacroStabilityInwardsSurfaceLine_SurfaceLineEntityReadMultipleTimes_ReturnSameSurfaceLine()
{
// Setup
var collector = new ReadConversionCollector();
var entity = new SurfaceLineEntity
{
Name = "surface line",
PointsXml = new Point3DCollectionXmlSerializer().ToXml(new Point3D[0])
};
// Call
MacroStabilityInwardsSurfaceLine surfaceLine1 = entity.ReadAsMacroStabilityInwardsSurfaceLine(collector);
MacroStabilityInwardsSurfaceLine surfaceLine2 = entity.ReadAsMacroStabilityInwardsSurfaceLine(collector);
// Assert
Assert.AreSame(surfaceLine1, surfaceLine2);
}
public void Read_SameHydraulicLocationCalculationForTargetProbabilityCollectionEntityTwice_ReturnsSameHydraulicBoundaryLocationCalculationsForTargetProbability()
{
// Setup
var random = new Random(21);
var collectionEntity = new HydraulicLocationCalculationForTargetProbabilityCollectionEntity
{
TargetProbability = random.NextDouble(0, 0.1)
};
var collector = new ReadConversionCollector();
// Call
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsOne = collectionEntity.Read(collector);
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsTwo = collectionEntity.Read(collector);
// Assert
Assert.AreSame(calculationsOne, calculationsTwo);
}
public void Read_EntityWithHydraulicBoundaryLocationCalculationsForTargetProbabilityNotYetInCollector_CalculationWithCreatedHydraulicBoundaryLocationCalculationsForTargetProbabilityAndRegisteredNewEntities()
{
// Setup
HydraulicLocationCalculationForTargetProbabilityCollectionEntity calculationForTargetProbabilityCollectionEntity =
HydraulicLocationCalculationForTargetProbabilityCollectionEntityTestFactory.CreateHydraulicLocationCalculationForTargetProbabilityCollectionEntity();
var entity = new StabilityStoneCoverWaveConditionsCalculationEntity
{
HydraulicLocationCalculationForTargetProbabilityCollectionEntity = calculationForTargetProbabilityCollectionEntity
};
var collector = new ReadConversionCollector();
// Call
entity.Read(collector);
// Assert
Assert.IsTrue(collector.Contains(calculationForTargetProbabilityCollectionEntity));
}
public void Read_EntityWithForeshoreProfile_ReturnCalculation(bool flagUsage, BreakWaterType type, int randomSeed)
{
// Setup
var random = new Random(randomSeed);
double breakWaterHeight = random.NextDouble();
var points = new[]
{
new Point2D(0, 0)
};
string pointXml = new Point2DCollectionXmlSerializer().ToXml(points);
var foreshoreEntity = new ForeshoreProfileEntity
{
Id = "id",
BreakWaterHeight = breakWaterHeight,
BreakWaterType = Convert.ToByte(type),
GeometryXml = pointXml
};
var entity = new HeightStructuresCalculationEntity
{
UseForeshore = Convert.ToByte(flagUsage),
UseBreakWater = Convert.ToByte(!flagUsage),
ForeshoreProfileEntity = foreshoreEntity,
BreakWaterType = Convert.ToByte(type),
BreakWaterHeight = breakWaterHeight,
ScenarioContribution = 0
};
var collector = new ReadConversionCollector();
// Call
StructuresCalculationScenario <HeightStructuresInput> calculation = entity.Read(collector);
// Assert
HeightStructuresInput input = calculation.InputParameters;
Assert.AreEqual(flagUsage, input.UseForeshore);
Assert.AreEqual(!flagUsage, input.UseBreakWater);
Assert.AreEqual(type, input.BreakWater.Type);
Assert.AreEqual(breakWaterHeight, input.BreakWater.Height, input.BreakWater.Height.GetAccuracy());
CollectionAssert.AreEqual(points, input.ForeshoreProfile.Geometry);
Assert.IsNotNull(input.ForeshoreProfile);
}
public void Read_EntityWithNullParameters_ReturnHeightStructuresCalculationWithInputParametersNaN()
{
// Setup
var entity = new HeightStructuresCalculationEntity
{
ScenarioContribution = 0,
StructureNormalOrientation = null,
ModelFactorSuperCriticalFlowMean = null,
AllowedLevelIncreaseStorageMean = null,
AllowedLevelIncreaseStorageStandardDeviation = null,
FlowWidthAtBottomProtectionMean = null,
FlowWidthAtBottomProtectionStandardDeviation = null,
CriticalOvertoppingDischargeMean = null,
CriticalOvertoppingDischargeCoefficientOfVariation = null,
WidthFlowAperturesMean = null,
WidthFlowAperturesStandardDeviation = null,
StormDurationMean = null,
LevelCrestStructureMean = null,
LevelCrestStructureStandardDeviation = null,
DeviationWaveDirection = null
};
var collector = new ReadConversionCollector();
// Call
StructuresCalculationScenario <HeightStructuresInput> calculation = entity.Read(collector);
// Assert
HeightStructuresInput inputParameters = calculation.InputParameters;
Assert.IsNaN(inputParameters.StructureNormalOrientation);
Assert.IsNaN(inputParameters.ModelFactorSuperCriticalFlow.Mean);
Assert.IsNaN(inputParameters.AllowedLevelIncreaseStorage.Mean);
Assert.IsNaN(inputParameters.AllowedLevelIncreaseStorage.StandardDeviation);
Assert.IsNaN(inputParameters.FlowWidthAtBottomProtection.Mean);
Assert.IsNaN(inputParameters.FlowWidthAtBottomProtection.StandardDeviation);
Assert.IsNaN(inputParameters.CriticalOvertoppingDischarge.Mean);
Assert.IsNaN(inputParameters.CriticalOvertoppingDischarge.CoefficientOfVariation);
Assert.IsNaN(inputParameters.WidthFlowApertures.Mean);
Assert.IsNaN(inputParameters.WidthFlowApertures.StandardDeviation);
Assert.IsNaN(inputParameters.StormDuration.Mean);
Assert.IsNaN(inputParameters.LevelCrestStructure.Mean);
Assert.IsNaN(inputParameters.LevelCrestStructure.StandardDeviation);
Assert.IsNaN(inputParameters.DeviationWaveDirection);
}
public void ReadAsMacroStabilityInwardsSurfaceLine_SurfaceLineEntityWithGeometryPointXmlButNoCharacteristicPoints_ReturnSurfaceLineWithGeometry()
{
// Setup
var collector = new ReadConversionCollector();
var random = new Random(31);
Point3D[] points =
{
CreatePoint3D(random),
CreatePoint3D(random),
CreatePoint3D(random)
};
var entity = new SurfaceLineEntity
{
Name = nameof(SurfaceLineEntity),
ReferenceLineIntersectionX = random.NextDouble(),
ReferenceLineIntersectionY = random.NextDouble(),
PointsXml = new Point3DCollectionXmlSerializer().ToXml(points)
};
// Call
MacroStabilityInwardsSurfaceLine surfaceLine = entity.ReadAsMacroStabilityInwardsSurfaceLine(collector);
// Assert
Assert.AreEqual(entity.Name, surfaceLine.Name);
Assert.AreEqual(entity.ReferenceLineIntersectionX, surfaceLine.ReferenceLineIntersectionWorldPoint.X);
Assert.AreEqual(entity.ReferenceLineIntersectionY, surfaceLine.ReferenceLineIntersectionWorldPoint.Y);
CollectionAssert.AreEqual(points, surfaceLine.Points);
Assert.IsNull(surfaceLine.SurfaceLevelOutside);
Assert.IsNull(surfaceLine.DikeToeAtRiver);
Assert.IsNull(surfaceLine.DikeTopAtPolder);
Assert.IsNull(surfaceLine.DikeTopAtRiver);
Assert.IsNull(surfaceLine.ShoulderBaseInside);
Assert.IsNull(surfaceLine.ShoulderTopInside);
Assert.IsNull(surfaceLine.DikeToeAtPolder);
Assert.IsNull(surfaceLine.DitchDikeSide);
Assert.IsNull(surfaceLine.BottomDitchDikeSide);
Assert.IsNull(surfaceLine.BottomDitchPolderSide);
Assert.IsNull(surfaceLine.DitchPolderSide);
Assert.IsNull(surfaceLine.SurfaceLevelInside);
}
private static void ReadHydraulicLocationCalculationsForTargetProbabilities(this AssessmentSectionEntity entity,
IAssessmentSection assessmentSection,
ReadConversionCollector collector)
{
IEnumerable <HydraulicLocationCalculationForTargetProbabilityCollectionEntity> waterLevelHydraulicLocationCalculationForTargetProbabilityCollectionEntities =
entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntities
.Where(e => e.HydraulicBoundaryLocationCalculationType == (short)HydraulicBoundaryLocationCalculationType.WaterLevel)
.OrderBy(e => e.Order);
assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.AddRange(waterLevelHydraulicLocationCalculationForTargetProbabilityCollectionEntities.Select(e => e.Read(collector))
.ToArray());
IEnumerable <HydraulicLocationCalculationForTargetProbabilityCollectionEntity> waveHeightHydraulicLocationCalculationForTargetProbabilityCollectionEntities =
entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntities
.Where(e => e.HydraulicBoundaryLocationCalculationType == (short)HydraulicBoundaryLocationCalculationType.WaveHeight)
.OrderBy(e => e.Order);
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.AddRange(waveHeightHydraulicLocationCalculationForTargetProbabilityCollectionEntities.Select(e => e.Read(collector))
.ToArray());
}
public void Read_ValidEntity_ReturnSpecificFailureMechanism()
{
// Setup
var random = new Random(21);
bool inAssembly = random.NextBoolean();
var probabilityResultType = random.NextEnumValue <FailureMechanismAssemblyProbabilityResultType>();
const string filePath = "failureMechanismSections/File/Path";
var entity = new SpecificFailureMechanismEntity
{
Name = "Specific failure mechanism name",
Code = "FAALMECHANISME",
N = random.NextDouble(1.0, 20.0),
ApplyLengthEffectInSection = Convert.ToByte(random.NextBoolean()),
InAssembly = Convert.ToByte(inAssembly),
InAssemblyInputComments = "Some input text",
InAssemblyOutputComments = "Some output text",
NotInAssemblyComments = "Some not in assembly text",
FailureMechanismSectionCollectionSourcePath = filePath,
FailureMechanismAssemblyResultProbabilityResultType = Convert.ToByte(probabilityResultType),
FailureMechanismAssemblyResultManualFailureMechanismAssemblyProbability = random.NextDouble(),
FailureMechanismSectionEntities =
{
CreateSimpleFailureMechanismSectionEntity()
}
};
var collector = new ReadConversionCollector();
// Call
SpecificFailureMechanism specificFailureMechanism = entity.Read(collector);
// Assert
FailureMechanismEntityTestHelper.AssertIFailureMechanismEntityProperties(entity, specificFailureMechanism);
Assert.AreEqual(entity.Name, specificFailureMechanism.Name);
Assert.AreEqual(entity.Code, specificFailureMechanism.Code);
Assert.AreEqual(entity.FailureMechanismSectionEntities.Count, specificFailureMechanism.Sections.Count());
Assert.AreEqual(filePath, specificFailureMechanism.FailureMechanismSectionSourcePath);
Assert.AreEqual(entity.N, specificFailureMechanism.GeneralInput.N, specificFailureMechanism.GeneralInput.N.GetAccuracy());
Assert.AreEqual(Convert.ToBoolean(entity.ApplyLengthEffectInSection), specificFailureMechanism.GeneralInput.ApplyLengthEffectInSection);
}
