public void Create_GroupWithChildStabilityPointStructuresCalculationsAndChildCalculationGroups_CreateEntities()
{
// Setup
var group = new CalculationGroup
{
Children =
{
new CalculationGroup
{
Name = "A"
},
new StructuresCalculationScenario <StabilityPointStructuresInput>
{
Name = "B"
},
new CalculationGroup
{
Name = "C"
},
new StructuresCalculationScenario <StabilityPointStructuresInput>
{
Name = "D"
}
}
};
var registry = new PersistenceRegistry();
// Call
CalculationGroupEntity entity = group.Create(registry, 0);
// Assert
CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity1.ToArray();
StabilityPointStructuresCalculationEntity[] childCalculationEntities = entity.StabilityPointStructuresCalculationEntities.ToArray();
Assert.AreEqual(2, childGroupEntities.Length);
Assert.AreEqual(2, childCalculationEntities.Length);
CalculationGroupEntity childEntity1 = childGroupEntities[0];
Assert.AreEqual("A", childEntity1.Name);
Assert.AreEqual(0, childEntity1.Order);
CollectionAssert.IsEmpty(childEntity1.CalculationGroupEntity1);
StabilityPointStructuresCalculationEntity childEntity2 = childCalculationEntities[0];
Assert.AreEqual("B", childEntity2.Name);
Assert.AreEqual(1, childEntity2.Order);
CalculationGroupEntity childEntity3 = childGroupEntities[1];
Assert.AreEqual("C", childEntity3.Name);
Assert.AreEqual(2, childEntity3.Order);
CollectionAssert.IsEmpty(childEntity3.CalculationGroupEntity1);
StabilityPointStructuresCalculationEntity childEntity4 = childCalculationEntities[1];
Assert.AreEqual("D", childEntity4.Name);
Assert.AreEqual(3, childEntity4.Order);
}
private static void SetStabilityPointStructuresOutputEntity(StructuresCalculation <StabilityPointStructuresInput> calculation,
StabilityPointStructuresCalculationEntity entity)
{
if (calculation.HasOutput)
{
entity.StabilityPointStructuresOutputEntities.Add(calculation
.Output
.Create <StabilityPointStructuresOutputEntity>());
}
}
public void Read_ReadConversionCollectorNull_ThrowArgumentNullException()
{
// Setup
var entity = new StabilityPointStructuresCalculationEntity();
// Call
void Call() => entity.Read(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("collector", exception.ParamName);
}
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();
}
private static void ReadOutput(StructuresCalculation <StabilityPointStructuresInput> calculation,
StabilityPointStructuresCalculationEntity entity)
{
StabilityPointStructuresOutputEntity outputEntity = entity.StabilityPointStructuresOutputEntities.SingleOrDefault();
if (outputEntity == null)
{
return;
}
var output = new StructuresOutput(outputEntity.Reliability.ToNullAsNaN(),
outputEntity.GeneralResultFaultTreeIllustrationPointEntity?.Read());
calculation.Output = output;
}
public void Create_WithCalculationGroup_ReturnFailureMechanismEntityWithCalculationGroupEntities()
{
// Setup
StructuresCalculationScenario <StabilityPointStructuresInput> calculation = new TestStabilityPointStructuresCalculationScenario();
calculation.InputParameters.Structure = null;
calculation.InputParameters.HydraulicBoundaryLocation = null;
var failureMechanism = new StabilityPointStructuresFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup
{
Name = "A"
});
failureMechanism.CalculationsGroup.Children.Add(calculation);
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(failureMechanism.CalculationsGroup.Name, entity.CalculationGroupEntity.Name);
Assert.AreEqual(0, entity.CalculationGroupEntity.Order);
CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity.CalculationGroupEntity1
.OrderBy(cge => cge.Order)
.ToArray();
Assert.AreEqual(1, childGroupEntities.Length);
CalculationGroupEntity childGroupEntity = childGroupEntities[0];
Assert.AreEqual("A", childGroupEntity.Name);
Assert.AreEqual(0, childGroupEntity.Order);
StabilityPointStructuresCalculationEntity[] calculationEntities = entity.CalculationGroupEntity.StabilityPointStructuresCalculationEntities
.OrderBy(ce => ce.Order)
.ToArray();
StabilityPointStructuresCalculationEntity calculationEntity = calculationEntities[0];
Assert.AreEqual("Nieuwe berekening", calculationEntity.Name);
Assert.AreEqual(1, calculationEntity.Order);
}
public void Read_EntityWithStructureEntity_ReturnCalculationWithStructure()
{
// Setup
StabilityPointStructure structure = new TestStabilityPointStructure();
var structureEntity = new StabilityPointStructureEntity();
var entity = new StabilityPointStructuresCalculationEntity
{
StabilityPointStructureEntity = structureEntity,
ScenarioContribution = 0
};
var collector = new ReadConversionCollector();
collector.Read(structureEntity, structure);
// Call
StructuresCalculationScenario <StabilityPointStructuresInput> calculation = entity.Read(collector);
// Assert
Assert.AreSame(structure, calculation.InputParameters.Structure);
}
public void Read_EntityWithForeshoreProfileEntity_ReturnCalculationWithForeshoreProfile()
{
// Setup
var profile = new TestForeshoreProfile();
var profileEntity = new ForeshoreProfileEntity();
var entity = new StabilityPointStructuresCalculationEntity
{
ForeshoreProfileEntity = profileEntity,
ScenarioContribution = 0
};
var collector = new ReadConversionCollector();
collector.Read(profileEntity, profile);
// Call
StructuresCalculationScenario <StabilityPointStructuresInput> calculation = entity.Read(collector);
// Assert
Assert.AreSame(profile, calculation.InputParameters.ForeshoreProfile);
}
public void Read_EntityWithHydraulicLocationEntity_ReturnCalculationWithHydraulicBoundaryLocation()
{
// Setup
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "A", 2, 3);
var hydraulicLocationEntity = new HydraulicLocationEntity();
var entity = new StabilityPointStructuresCalculationEntity
{
HydraulicLocationEntity = hydraulicLocationEntity,
ScenarioContribution = 0
};
var collector = new ReadConversionCollector();
collector.Read(hydraulicLocationEntity, hydraulicBoundaryLocation);
// Call
StructuresCalculationScenario <StabilityPointStructuresInput> calculation = entity.Read(collector);
// Assert
Assert.AreSame(hydraulicBoundaryLocation, calculation.InputParameters.HydraulicBoundaryLocation);
}
/// <summary>
/// Creates a <see cref="StabilityPointStructuresCalculationEntity"/> based
/// on the information of the <see cref="StructuresCalculationScenario{T}"/>.
/// </summary>
/// <param name="calculation">The calculation to create a database entity for.</param>
/// <param name="registry">The object keeping track of create operations.</param>
/// <param name="order">The index at where <paramref name="calculation"/> resides
/// in its parent container.</param>
/// <returns>A new <see cref="StabilityPointStructuresCalculationEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="registry"/> is <c>null</c>.</exception>
internal static StabilityPointStructuresCalculationEntity CreateForStabilityPointStructures(this StructuresCalculationScenario <StabilityPointStructuresInput> calculation,
PersistenceRegistry registry, int order)
{
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
var entity = new StabilityPointStructuresCalculationEntity
{
Name = calculation.Name.DeepClone(),
RelevantForScenario = Convert.ToByte(calculation.IsRelevant),
ScenarioContribution = calculation.Contribution,
Comments = calculation.Comments.Body.DeepClone(),
Order = order
};
SetStabilityPointStructuresInputValues(entity, calculation.InputParameters, registry);
SetStabilityPointStructuresOutputEntity(calculation, entity);
return(entity);
}
public void Read_ValidEntityWithOutputEntity_ReturnCalculationWithOutput()
{
// Setup
var entity = new StabilityPointStructuresCalculationEntity
{
StabilityPointStructuresOutputEntities =
{
new StabilityPointStructuresOutputEntity()
},
ScenarioContribution = 0
};
var collector = new ReadConversionCollector();
// Call
StructuresCalculationScenario <StabilityPointStructuresInput> calculation = entity.Read(collector);
// Assert
StructuresOutput calculationOutput = calculation.Output;
Assert.IsNaN(calculationOutput.Reliability);
Assert.IsFalse(calculationOutput.HasGeneralResult);
}
public void Read_ValidEntity_ReturnStabilityPointStructuresCalculation()
{
// Setup
var entity = new StabilityPointStructuresCalculationEntity
{
Name = "name",
RelevantForScenario = Convert.ToByte(true),
ScenarioContribution = 0.0,
Comments = "comments",
StructureNormalOrientation = 1.1,
AllowedLevelIncreaseStorageMean = 2.2,
AllowedLevelIncreaseStorageStandardDeviation = 3.3,
StorageStructureAreaMean = 4.4,
StorageStructureAreaCoefficientOfVariation = 5.5,
FlowWidthAtBottomProtectionMean = 6.6,
FlowWidthAtBottomProtectionStandardDeviation = 7.7,
CriticalOvertoppingDischargeMean = 8.8,
CriticalOvertoppingDischargeCoefficientOfVariation = 9.9,
FailureProbabilityStructureWithErosion = 0.10,
WidthFlowAperturesMean = 11.11,
WidthFlowAperturesStandardDeviation = 12.12,
StormDurationMean = 13.13,
UseBreakWater = Convert.ToByte(true),
BreakWaterType = Convert.ToByte(BreakWaterType.Wall),
BreakWaterHeight = 14.14,
UseForeshore = Convert.ToByte(true),
InsideWaterLevelMean = 15.15,
InsideWaterLevelStandardDeviation = 16.16,
ThresholdHeightOpenWeirMean = 17.17,
ThresholdHeightOpenWeirStandardDeviation = 18.18,
ConstructiveStrengthLinearLoadModelMean = 19.19,
ConstructiveStrengthLinearLoadModelCoefficientOfVariation = 20.20,
ConstructiveStrengthQuadraticLoadModelMean = 21.21,
ConstructiveStrengthQuadraticLoadModelCoefficientOfVariation = 22.22,
BankWidthMean = 23.23,
BankWidthStandardDeviation = 24.24,
InsideWaterLevelFailureConstructionMean = 25.25,
InsideWaterLevelFailureConstructionStandardDeviation = 26.26,
EvaluationLevel = 27.27,
LevelCrestStructureMean = 28.28,
LevelCrestStructureStandardDeviation = 29.29,
VerticalDistance = 30.30,
FailureProbabilityRepairClosure = 0.31,
FailureCollisionEnergyMean = 32.32,
FailureCollisionEnergyCoefficientOfVariation = 33.33,
ShipMassMean = 34.34,
ShipMassCoefficientOfVariation = 35.35,
ShipVelocityMean = 36.36,
ShipVelocityCoefficientOfVariation = 37.37,
LevellingCount = 38,
ProbabilityCollisionSecondaryStructure = 0.39,
FlowVelocityStructureClosableMean = 40.40,
StabilityLinearLoadModelMean = 41.41,
StabilityLinearLoadModelCoefficientOfVariation = 42.42,
StabilityQuadraticLoadModelMean = 43.43,
StabilityQuadraticLoadModelCoefficientOfVariation = 44.44,
AreaFlowAperturesMean = 45.45,
AreaFlowAperturesStandardDeviation = 46.46,
InflowModelType = Convert.ToByte(StabilityPointStructureInflowModelType.FloodedCulvert),
LoadSchematizationType = Convert.ToByte(LoadSchematizationType.Quadratic),
VolumicWeightWater = 47.47,
FactorStormDurationOpenStructure = 48.48,
DrainCoefficientMean = 49.49,
DrainCoefficientStandardDeviation = 50.50
};
var collector = new ReadConversionCollector();
// Call
StructuresCalculationScenario <StabilityPointStructuresInput> calculation = entity.Read(collector);
// Assert
Assert.AreEqual(entity.Name, calculation.Name);
Assert.AreEqual(Convert.ToBoolean(entity.RelevantForScenario), calculation.IsRelevant);
RoundedDoubleTestHelper.AssertRoundedDouble(entity.ScenarioContribution, calculation.Contribution);
Assert.AreEqual(entity.Comments, calculation.Comments.Body);
StabilityPointStructuresInput inputParameters = calculation.InputParameters;
Assert.IsNull(inputParameters.ForeshoreProfile);
Assert.IsNull(inputParameters.Structure);
Assert.IsNull(inputParameters.HydraulicBoundaryLocation);
Assert.AreEqual(entity.StructureNormalOrientation, inputParameters.StructureNormalOrientation.Value);
Assert.AreEqual(entity.AllowedLevelIncreaseStorageMean, inputParameters.AllowedLevelIncreaseStorage.Mean.Value);
Assert.AreEqual(entity.AllowedLevelIncreaseStorageStandardDeviation, inputParameters.AllowedLevelIncreaseStorage.StandardDeviation.Value);
Assert.AreEqual(entity.StorageStructureAreaMean, inputParameters.StorageStructureArea.Mean.Value);
Assert.AreEqual(entity.StorageStructureAreaCoefficientOfVariation, inputParameters.StorageStructureArea.CoefficientOfVariation.Value);
Assert.AreEqual(entity.FlowWidthAtBottomProtectionMean, inputParameters.FlowWidthAtBottomProtection.Mean.Value);
Assert.AreEqual(entity.FlowWidthAtBottomProtectionStandardDeviation, inputParameters.FlowWidthAtBottomProtection.StandardDeviation.Value);
Assert.AreEqual(entity.CriticalOvertoppingDischargeMean, inputParameters.CriticalOvertoppingDischarge.Mean.Value);
Assert.AreEqual(entity.CriticalOvertoppingDischargeCoefficientOfVariation, inputParameters.CriticalOvertoppingDischarge.CoefficientOfVariation.Value);
Assert.AreEqual(entity.FailureProbabilityStructureWithErosion, inputParameters.FailureProbabilityStructureWithErosion);
Assert.AreEqual(entity.WidthFlowAperturesMean, inputParameters.WidthFlowApertures.Mean.Value);
Assert.AreEqual(entity.WidthFlowAperturesStandardDeviation, inputParameters.WidthFlowApertures.StandardDeviation.Value);
Assert.AreEqual(entity.StormDurationMean, inputParameters.StormDuration.Mean.Value);
Assert.AreEqual(Convert.ToBoolean(entity.UseBreakWater), inputParameters.UseBreakWater);
Assert.AreEqual((BreakWaterType)entity.BreakWaterType, inputParameters.BreakWater.Type);
Assert.AreEqual(entity.BreakWaterHeight, inputParameters.BreakWater.Height.Value);
Assert.AreEqual(Convert.ToBoolean(entity.UseForeshore), inputParameters.UseForeshore);
Assert.AreEqual(entity.InsideWaterLevelMean, inputParameters.InsideWaterLevel.Mean.Value);
Assert.AreEqual(entity.InsideWaterLevelStandardDeviation, inputParameters.InsideWaterLevel.StandardDeviation.Value);
Assert.AreEqual(entity.ThresholdHeightOpenWeirMean, inputParameters.ThresholdHeightOpenWeir.Mean.Value);
Assert.AreEqual(entity.ThresholdHeightOpenWeirStandardDeviation, inputParameters.ThresholdHeightOpenWeir.StandardDeviation.Value);
Assert.AreEqual(entity.ConstructiveStrengthLinearLoadModelMean, inputParameters.ConstructiveStrengthLinearLoadModel.Mean.Value);
Assert.AreEqual(entity.ConstructiveStrengthLinearLoadModelCoefficientOfVariation, inputParameters.ConstructiveStrengthLinearLoadModel.CoefficientOfVariation.Value);
Assert.AreEqual(entity.ConstructiveStrengthQuadraticLoadModelMean, inputParameters.ConstructiveStrengthQuadraticLoadModel.Mean.Value);
Assert.AreEqual(entity.ConstructiveStrengthQuadraticLoadModelCoefficientOfVariation, inputParameters.ConstructiveStrengthQuadraticLoadModel.CoefficientOfVariation.Value);
Assert.AreEqual(entity.BankWidthMean, inputParameters.BankWidth.Mean.Value);
Assert.AreEqual(entity.BankWidthStandardDeviation, inputParameters.BankWidth.StandardDeviation.Value);
Assert.AreEqual(entity.InsideWaterLevelFailureConstructionMean, inputParameters.InsideWaterLevelFailureConstruction.Mean.Value);
Assert.AreEqual(entity.InsideWaterLevelFailureConstructionStandardDeviation, inputParameters.InsideWaterLevelFailureConstruction.StandardDeviation.Value);
Assert.AreEqual(entity.EvaluationLevel, inputParameters.EvaluationLevel.Value);
Assert.AreEqual(entity.LevelCrestStructureMean, inputParameters.LevelCrestStructure.Mean.Value);
Assert.AreEqual(entity.LevelCrestStructureStandardDeviation, inputParameters.LevelCrestStructure.StandardDeviation.Value);
Assert.AreEqual(entity.VerticalDistance, inputParameters.VerticalDistance.Value);
Assert.AreEqual(entity.FailureProbabilityRepairClosure, inputParameters.FailureProbabilityRepairClosure);
Assert.AreEqual(entity.FailureCollisionEnergyMean, inputParameters.FailureCollisionEnergy.Mean.Value);
Assert.AreEqual(entity.FailureCollisionEnergyCoefficientOfVariation, inputParameters.FailureCollisionEnergy.CoefficientOfVariation.Value);
Assert.AreEqual(entity.ShipMassMean, inputParameters.ShipMass.Mean.Value);
Assert.AreEqual(entity.ShipMassCoefficientOfVariation, inputParameters.ShipMass.CoefficientOfVariation.Value);
Assert.AreEqual(entity.ShipVelocityMean, inputParameters.ShipVelocity.Mean.Value);
Assert.AreEqual(entity.ShipVelocityCoefficientOfVariation, inputParameters.ShipVelocity.CoefficientOfVariation.Value);
Assert.AreEqual(entity.LevellingCount, inputParameters.LevellingCount);
Assert.AreEqual(entity.ProbabilityCollisionSecondaryStructure, inputParameters.ProbabilityCollisionSecondaryStructure);
Assert.AreEqual(entity.FlowVelocityStructureClosableMean, inputParameters.FlowVelocityStructureClosable.Mean.Value);
Assert.AreEqual(entity.StabilityLinearLoadModelMean, inputParameters.StabilityLinearLoadModel.Mean.Value);
Assert.AreEqual(entity.StabilityLinearLoadModelCoefficientOfVariation, inputParameters.StabilityLinearLoadModel.CoefficientOfVariation.Value);
Assert.AreEqual(entity.StabilityQuadraticLoadModelMean, inputParameters.StabilityQuadraticLoadModel.Mean.Value);
Assert.AreEqual(entity.StabilityQuadraticLoadModelCoefficientOfVariation, inputParameters.StabilityQuadraticLoadModel.CoefficientOfVariation.Value);
Assert.AreEqual(entity.AreaFlowAperturesMean, inputParameters.AreaFlowApertures.Mean.Value);
Assert.AreEqual(entity.AreaFlowAperturesStandardDeviation, inputParameters.AreaFlowApertures.StandardDeviation.Value);
Assert.AreEqual((StabilityPointStructureInflowModelType)entity.InflowModelType, inputParameters.InflowModelType);
Assert.AreEqual((LoadSchematizationType)entity.LoadSchematizationType, inputParameters.LoadSchematizationType);
Assert.AreEqual(entity.VolumicWeightWater, inputParameters.VolumicWeightWater.Value);
Assert.AreEqual(entity.FactorStormDurationOpenStructure, inputParameters.FactorStormDurationOpenStructure.Value);
Assert.AreEqual(entity.DrainCoefficientMean, inputParameters.DrainCoefficient.Mean.Value);
Assert.AreEqual(entity.DrainCoefficientStandardDeviation, inputParameters.DrainCoefficient.StandardDeviation.Value);
Assert.IsFalse(calculation.HasOutput);
}
public void Read_EntityWithNullParameters_ReturnStabilityPointStructuresCalculationWithInputParametersNaN()
{
// Setup
var entity = new StabilityPointStructuresCalculationEntity
{
ScenarioContribution = 0,
StructureNormalOrientation = null,
AllowedLevelIncreaseStorageMean = null,
AllowedLevelIncreaseStorageStandardDeviation = null,
StorageStructureAreaMean = null,
StorageStructureAreaCoefficientOfVariation = null,
FlowWidthAtBottomProtectionMean = null,
FlowWidthAtBottomProtectionStandardDeviation = null,
CriticalOvertoppingDischargeMean = null,
CriticalOvertoppingDischargeCoefficientOfVariation = null,
WidthFlowAperturesMean = null,
WidthFlowAperturesStandardDeviation = null,
StormDurationMean = null,
BreakWaterHeight = null,
InsideWaterLevelMean = null,
InsideWaterLevelStandardDeviation = null,
ThresholdHeightOpenWeirMean = null,
ThresholdHeightOpenWeirStandardDeviation = null,
ConstructiveStrengthLinearLoadModelMean = null,
ConstructiveStrengthLinearLoadModelCoefficientOfVariation = null,
ConstructiveStrengthQuadraticLoadModelMean = null,
ConstructiveStrengthQuadraticLoadModelCoefficientOfVariation = null,
BankWidthMean = null,
BankWidthStandardDeviation = null,
InsideWaterLevelFailureConstructionMean = null,
InsideWaterLevelFailureConstructionStandardDeviation = null,
EvaluationLevel = null,
LevelCrestStructureMean = null,
LevelCrestStructureStandardDeviation = null,
VerticalDistance = null,
FailureCollisionEnergyMean = null,
FailureCollisionEnergyCoefficientOfVariation = null,
ShipMassMean = null,
ShipMassCoefficientOfVariation = null,
ShipVelocityMean = null,
ShipVelocityCoefficientOfVariation = null,
FlowVelocityStructureClosableMean = null,
StabilityLinearLoadModelMean = null,
StabilityLinearLoadModelCoefficientOfVariation = null,
StabilityQuadraticLoadModelMean = null,
StabilityQuadraticLoadModelCoefficientOfVariation = null,
AreaFlowAperturesMean = null,
AreaFlowAperturesStandardDeviation = null,
VolumicWeightWater = null,
FactorStormDurationOpenStructure = null,
DrainCoefficientMean = null,
DrainCoefficientStandardDeviation = null
};
var collector = new ReadConversionCollector();
// Call
StructuresCalculationScenario <StabilityPointStructuresInput> calculation = entity.Read(collector);
// Assert
StabilityPointStructuresInput inputParameters = calculation.InputParameters;
Assert.IsNaN(inputParameters.StructureNormalOrientation);
Assert.IsNaN(inputParameters.AllowedLevelIncreaseStorage.Mean);
Assert.IsNaN(inputParameters.AllowedLevelIncreaseStorage.StandardDeviation);
Assert.IsNaN(inputParameters.StorageStructureArea.Mean);
Assert.IsNaN(inputParameters.StorageStructureArea.CoefficientOfVariation);
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.BreakWater.Height);
Assert.IsNaN(inputParameters.InsideWaterLevel.Mean);
Assert.IsNaN(inputParameters.InsideWaterLevel.StandardDeviation);
Assert.IsNaN(inputParameters.ThresholdHeightOpenWeir.Mean);
Assert.IsNaN(inputParameters.ThresholdHeightOpenWeir.StandardDeviation);
Assert.IsNaN(inputParameters.ConstructiveStrengthLinearLoadModel.Mean);
Assert.IsNaN(inputParameters.ConstructiveStrengthLinearLoadModel.CoefficientOfVariation);
Assert.IsNaN(inputParameters.ConstructiveStrengthQuadraticLoadModel.Mean);
Assert.IsNaN(inputParameters.ConstructiveStrengthQuadraticLoadModel.CoefficientOfVariation);
Assert.IsNaN(inputParameters.BankWidth.Mean);
Assert.IsNaN(inputParameters.BankWidth.StandardDeviation);
Assert.IsNaN(inputParameters.InsideWaterLevelFailureConstruction.Mean);
Assert.IsNaN(inputParameters.InsideWaterLevelFailureConstruction.StandardDeviation);
Assert.IsNaN(inputParameters.EvaluationLevel);
Assert.IsNaN(inputParameters.LevelCrestStructure.Mean);
Assert.IsNaN(inputParameters.LevelCrestStructure.StandardDeviation);
Assert.IsNaN(inputParameters.VerticalDistance);
Assert.IsNaN(inputParameters.FailureCollisionEnergy.Mean);
Assert.IsNaN(inputParameters.FailureCollisionEnergy.CoefficientOfVariation);
Assert.IsNaN(inputParameters.ShipMass.Mean);
Assert.IsNaN(inputParameters.ShipMass.CoefficientOfVariation);
Assert.IsNaN(inputParameters.ShipVelocity.Mean);
Assert.IsNaN(inputParameters.ShipVelocity.CoefficientOfVariation);
Assert.IsNaN(inputParameters.FlowVelocityStructureClosable.Mean);
Assert.IsNaN(inputParameters.StabilityLinearLoadModel.Mean);
Assert.IsNaN(inputParameters.StabilityLinearLoadModel.CoefficientOfVariation);
Assert.IsNaN(inputParameters.StabilityQuadraticLoadModel.Mean);
Assert.IsNaN(inputParameters.StabilityQuadraticLoadModel.CoefficientOfVariation);
Assert.IsNaN(inputParameters.AreaFlowApertures.Mean);
Assert.IsNaN(inputParameters.AreaFlowApertures.StandardDeviation);
Assert.IsNaN(inputParameters.VolumicWeightWater);
Assert.IsNaN(inputParameters.FactorStormDurationOpenStructure);
Assert.IsNaN(inputParameters.DrainCoefficient.Mean);
Assert.IsNaN(inputParameters.DrainCoefficient.StandardDeviation);
}
/// <summary>
/// Reads the <see cref="StabilityPointStructuresCalculationEntity"/> and use the
/// information to update a <see cref="StructuresCalculationScenario{T}"/>.
/// </summary>
/// <param name="entity">The <see cref="StabilityPointStructuresCalculationEntity"/>
/// to create <see cref="StructuresCalculationScenario{T}"/> for.</param>
/// <param name="collector">The object keeping track of read operations.</param>
/// <returns>A new <see cref="StructuresCalculationScenario{T}"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="collector"/> is <c>null</c>.</exception>
internal static StructuresCalculationScenario <StabilityPointStructuresInput> Read(this StabilityPointStructuresCalculationEntity entity,
ReadConversionCollector collector)
{
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
var calculation = new StructuresCalculationScenario <StabilityPointStructuresInput>
{
Name = entity.Name,
IsRelevant = Convert.ToBoolean(entity.RelevantForScenario),
Contribution = (RoundedDouble)entity.ScenarioContribution,
Comments =
{
Body = entity.Comments
}
};
ReadInputParameters(calculation.InputParameters, entity, collector);
ReadOutput(calculation, entity);
return(calculation);
}
private static void SetStabilityPointStructuresInputValues(StabilityPointStructuresCalculationEntity entity,
StabilityPointStructuresInput input, PersistenceRegistry registry)
{
input.Create(entity, registry);
if (input.Structure != null)
{
entity.StabilityPointStructureEntity = registry.Get(input.Structure);
}
entity.InsideWaterLevelMean = input.InsideWaterLevel.Mean.ToNaNAsNull();
entity.InsideWaterLevelStandardDeviation = input.InsideWaterLevel.StandardDeviation.ToNaNAsNull();
entity.ThresholdHeightOpenWeirMean = input.ThresholdHeightOpenWeir.Mean.ToNaNAsNull();
entity.ThresholdHeightOpenWeirStandardDeviation = input.ThresholdHeightOpenWeir.StandardDeviation.ToNaNAsNull();
entity.ConstructiveStrengthLinearLoadModelMean = input.ConstructiveStrengthLinearLoadModel.Mean.ToNaNAsNull();
entity.ConstructiveStrengthLinearLoadModelCoefficientOfVariation = input.ConstructiveStrengthLinearLoadModel.CoefficientOfVariation.ToNaNAsNull();
entity.ConstructiveStrengthQuadraticLoadModelMean = input.ConstructiveStrengthQuadraticLoadModel.Mean.ToNaNAsNull();
entity.ConstructiveStrengthQuadraticLoadModelCoefficientOfVariation = input.ConstructiveStrengthQuadraticLoadModel.CoefficientOfVariation.ToNaNAsNull();
entity.BankWidthMean = input.BankWidth.Mean.ToNaNAsNull();
entity.BankWidthStandardDeviation = input.BankWidth.StandardDeviation.ToNaNAsNull();
entity.InsideWaterLevelFailureConstructionMean = input.InsideWaterLevelFailureConstruction.Mean.ToNaNAsNull();
entity.InsideWaterLevelFailureConstructionStandardDeviation = input.InsideWaterLevelFailureConstruction.StandardDeviation.ToNaNAsNull();
entity.EvaluationLevel = input.EvaluationLevel.ToNaNAsNull();
entity.LevelCrestStructureMean = input.LevelCrestStructure.Mean.ToNaNAsNull();
entity.LevelCrestStructureStandardDeviation = input.LevelCrestStructure.StandardDeviation.ToNaNAsNull();
entity.VerticalDistance = input.VerticalDistance.ToNaNAsNull();
entity.FailureProbabilityRepairClosure = input.FailureProbabilityRepairClosure;
entity.FailureCollisionEnergyMean = input.FailureCollisionEnergy.Mean.ToNaNAsNull();
entity.FailureCollisionEnergyCoefficientOfVariation = input.FailureCollisionEnergy.CoefficientOfVariation.ToNaNAsNull();
entity.ShipMassMean = input.ShipMass.Mean.ToNaNAsNull();
entity.ShipMassCoefficientOfVariation = input.ShipMass.CoefficientOfVariation.ToNaNAsNull();
entity.ShipVelocityMean = input.ShipVelocity.Mean.ToNaNAsNull();
entity.ShipVelocityCoefficientOfVariation = input.ShipVelocity.CoefficientOfVariation.ToNaNAsNull();
entity.LevellingCount = input.LevellingCount;
entity.ProbabilityCollisionSecondaryStructure = input.ProbabilityCollisionSecondaryStructure;
entity.FlowVelocityStructureClosableMean = input.FlowVelocityStructureClosable.Mean.ToNaNAsNull();
entity.StabilityLinearLoadModelMean = input.StabilityLinearLoadModel.Mean.ToNaNAsNull();
entity.StabilityLinearLoadModelCoefficientOfVariation = input.StabilityLinearLoadModel.CoefficientOfVariation.ToNaNAsNull();
entity.StabilityQuadraticLoadModelMean = input.StabilityQuadraticLoadModel.Mean.ToNaNAsNull();
entity.StabilityQuadraticLoadModelCoefficientOfVariation = input.StabilityQuadraticLoadModel.CoefficientOfVariation.ToNaNAsNull();
entity.AreaFlowAperturesMean = input.AreaFlowApertures.Mean.ToNaNAsNull();
entity.AreaFlowAperturesStandardDeviation = input.AreaFlowApertures.StandardDeviation.ToNaNAsNull();
entity.InflowModelType = Convert.ToByte(input.InflowModelType);
entity.LoadSchematizationType = Convert.ToByte(input.LoadSchematizationType);
entity.VolumicWeightWater = input.VolumicWeightWater.ToNaNAsNull();
entity.FactorStormDurationOpenStructure = input.FactorStormDurationOpenStructure.ToNaNAsNull();
entity.DrainCoefficientMean = input.DrainCoefficient.Mean.ToNaNAsNull();
entity.DrainCoefficientStandardDeviation = input.DrainCoefficient.StandardDeviation.ToNaNAsNull();
}
