public void ConstructiveStrengthQuadraticLoadModel_Always_ExpectedValues()
{
// Setup
var random = new Random(22);
var input = new StabilityPointStructuresInput();
var mean = (RoundedDouble)(0.01 + random.NextDouble());
var variation = (RoundedDouble)(0.01 + random.NextDouble());
var distributionToSet = new VariationCoefficientLogNormalDistribution(5)
{
Mean = mean,
CoefficientOfVariation = variation
};
// Call
input.ConstructiveStrengthQuadraticLoadModel = distributionToSet;
// Assert
var expectedDistribution = new VariationCoefficientLogNormalDistribution(2)
{
Mean = mean,
CoefficientOfVariation = variation
};
DistributionTestHelper.AssertDistributionCorrectlySet(input.ConstructiveStrengthQuadraticLoadModel, distributionToSet, expectedDistribution);
}
public void DrainCoefficient_Always_ExpectedValues()
{
// Setup
var random = new Random(22);
var input = new StabilityPointStructuresInput();
RoundedDouble mean = random.NextRoundedDouble(0.01, 1.0);
RoundedDouble standardDeviation = random.NextRoundedDouble(0.01, 1.0);
var distributionToSet = new LogNormalDistribution(5)
{
Mean = mean,
StandardDeviation = standardDeviation
};
// Call
input.DrainCoefficient = distributionToSet;
// Assert
var expectedDistribution = new LogNormalDistribution(2)
{
Mean = mean,
StandardDeviation = standardDeviation
};
DistributionTestHelper.AssertDistributionCorrectlySet(input.DrainCoefficient, distributionToSet, expectedDistribution);
}
public void SynchronizeStructureInput_ChangedStructure_ExpectedValues()
{
// Setup
var differentStructure = new StabilityPointStructure(new StabilityPointStructure.ConstructionProperties
{
Id = "Test id",
Name = "Test name",
Location = new Point2D(-1, -1)
});
var input = new StabilityPointStructuresInput
{
Structure = new TestStabilityPointStructure()
};
input.Structure.CopyProperties(differentStructure);
// Precondition
AssertStabilityPointStructureInput(new TestStabilityPointStructure(), input);
// Call
input.SynchronizeStructureInput();
// Assert
AssertStabilityPointStructureInput(differentStructure, input);
}
public void ShipVelocity_Always_ExpectedValues()
{
// Setup
var random = new Random(22);
var input = new StabilityPointStructuresInput();
var mean = (RoundedDouble)(0.01 + random.NextDouble());
var variation = (RoundedDouble)(0.01 + random.NextDouble());
var distributionToSet = new VariationCoefficientNormalDistribution(5)
{
Mean = mean,
CoefficientOfVariation = variation
};
// Call
input.ShipVelocity = distributionToSet;
// Assert
var expectedDistribution = new VariationCoefficientNormalDistribution(2)
{
Mean = mean,
CoefficientOfVariation = variation
};
DistributionTestHelper.AssertDistributionCorrectlySet(input.ShipVelocity, distributionToSet, expectedDistribution);
}
/// <summary>
/// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
/// are clones.
/// </summary>
/// <param name="original">The original object.</param>
/// <param name="clone">The cloned object.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="original"/> and
/// <paramref name="clone"/> are not clones.</exception>
public static void AreClones(StabilityPointStructuresInput original, StabilityPointStructuresInput clone)
{
CommonCloneAssert.AreClones(original, clone);
CoreCloneAssert.AreObjectClones(original.InsideWaterLevelFailureConstruction, clone.InsideWaterLevelFailureConstruction, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.InsideWaterLevel, clone.InsideWaterLevel, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.DrainCoefficient, clone.DrainCoefficient, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.LevelCrestStructure, clone.LevelCrestStructure, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.ThresholdHeightOpenWeir, clone.ThresholdHeightOpenWeir, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.AreaFlowApertures, clone.AreaFlowApertures, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.ConstructiveStrengthLinearLoadModel, clone.ConstructiveStrengthLinearLoadModel, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.ConstructiveStrengthQuadraticLoadModel, clone.ConstructiveStrengthQuadraticLoadModel, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.StabilityLinearLoadModel, clone.StabilityLinearLoadModel, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.StabilityQuadraticLoadModel, clone.StabilityQuadraticLoadModel, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.FailureCollisionEnergy, clone.FailureCollisionEnergy, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.ShipMass, clone.ShipMass, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.ShipVelocity, clone.ShipVelocity, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.BankWidth, clone.BankWidth, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.FlowVelocityStructureClosable, clone.FlowVelocityStructureClosable, DistributionAssert.AreEqual);
Assert.AreEqual(original.VolumicWeightWater, clone.VolumicWeightWater);
Assert.AreEqual(original.FactorStormDurationOpenStructure, clone.FactorStormDurationOpenStructure);
Assert.AreEqual(original.EvaluationLevel, clone.EvaluationLevel);
Assert.AreEqual(original.VerticalDistance, clone.VerticalDistance);
Assert.AreEqual(original.FailureProbabilityRepairClosure, clone.FailureProbabilityRepairClosure);
Assert.AreEqual(original.ProbabilityCollisionSecondaryStructure, clone.ProbabilityCollisionSecondaryStructure);
Assert.AreEqual(original.InflowModelType, clone.InflowModelType);
Assert.AreEqual(original.LoadSchematizationType, clone.LoadSchematizationType);
Assert.AreEqual(original.LevellingCount, clone.LevellingCount);
}
public void BankWidth_Always_ExpectedValues()
{
// Setup
var random = new Random(22);
var input = new StabilityPointStructuresInput();
var mean = (RoundedDouble)(0.01 + random.NextDouble());
var standardDeviation = (RoundedDouble)(0.01 + random.NextDouble());
var distributionToSet = new NormalDistribution(5)
{
Mean = mean,
StandardDeviation = standardDeviation
};
// Call
input.BankWidth = distributionToSet;
// Assert
var expectedDistribution = new NormalDistribution(2)
{
Mean = mean,
StandardDeviation = standardDeviation
};
DistributionTestHelper.AssertDistributionCorrectlySet(input.BankWidth, distributionToSet, expectedDistribution);
}
public void ProbabilityCollisionSecondaryStructure_ValidValues_ExpectedValues(double probability)
{
// Setup
var input = new StabilityPointStructuresInput();
// Call
input.ProbabilityCollisionSecondaryStructure = probability;
// Assert
Assert.AreEqual(probability, input.ProbabilityCollisionSecondaryStructure);
}
public void FailureProbabilityRepairClosure_ValidValues_ExpectedValues(double probability)
{
// Setup
var input = new StabilityPointStructuresInput();
// Call
input.FailureProbabilityRepairClosure = probability;
// Assert
Assert.AreEqual(probability, input.FailureProbabilityRepairClosure);
}
public void ProbabilityCollisionSecondaryStructure_InvalidValues_ThrowsArgumentOutOfRangeException(double probability)
{
// Setup
var input = new StabilityPointStructuresInput();
// Call
TestDelegate call = () => input.ProbabilityCollisionSecondaryStructure = probability;
// Assert
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(call, "Kans moet in het bereik [0,0, 1,0] liggen.");
}
public void SynchronizeStructureInput_StructureNotSet_ExpectedValues()
{
// Setup
var input = new StabilityPointStructuresInput();
// Call
input.SynchronizeStructureInput();
// Assert
AssertStabilityPointStructureInput(null, input);
}
public void FailureProbabilityRepairClosure_InvalidValues_ThrowsArgumentOutOfRangeException(double probability)
{
// Setup
var input = new StabilityPointStructuresInput();
// Call
TestDelegate call = () => input.FailureProbabilityRepairClosure = probability;
// Assert
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(call, "De waarde voor de faalkans moet in het bereik [0,0, 1,0] liggen.");
}
public void IsStructureInputSynchronized_StructureNotSet_ReturnFalse()
{
// Setup
var input = new StabilityPointStructuresInput();
// Call
bool isStructureInputSynchronized = input.IsStructureInputSynchronized;
// Assert
Assert.IsFalse(isStructureInputSynchronized);
}
public void Structure_Null_ExpectedValues()
{
// Setup
var input = new StabilityPointStructuresInput();
// Call
input.Structure = null;
// Assert
AssertStabilityPointStructureInput(null, input);
}
public void VerticalDistance_InvalidValue_ThrowsArgumentOutOfRangeException()
{
// Setup
var input = new StabilityPointStructuresInput();
// Call
TestDelegate call = () => input.VerticalDistance = (RoundedDouble)(-0.01);
// Assert
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(
call, "De waarde voor afstand onderkant wand en teen dijk moet groter of gelijk zijn aan 0.");
}
public void Structure_NotNull_ExpectedValues()
{
// Setup
var input = new StabilityPointStructuresInput();
var structure = new TestStabilityPointStructure();
// Call
input.Structure = structure;
// Assert
AssertStabilityPointStructureInput(structure, input);
}
public void LevellingCount_InvalidValue_ThrowsArgumentOutOfRangeException()
{
// Setup
var input = new StabilityPointStructuresInput();
// Call
TestDelegate call = () => input.LevellingCount = -1;
// Assert
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(
call, "De waarde voor aantal nivelleringen per jaar moet groter of gelijk zijn aan 0.");
}
public void LevellingCount_ValidValue_ExpectedValues()
{
// Setup
var input = new StabilityPointStructuresInput();
int levellingCount = new Random(21).Next(0, int.MaxValue);
// Call
input.LevellingCount = levellingCount;
// Assert
Assert.AreEqual(levellingCount, input.LevellingCount);
}
public void VerticalDistance_ValidValue_ExpectedValues(double verticalDistance)
{
// Setup
var input = new StabilityPointStructuresInput();
// Call
input.VerticalDistance = (RoundedDouble)verticalDistance;
// Assert
Assert.AreEqual(2, input.VerticalDistance.NumberOfDecimalPlaces);
AssertAreEqual(verticalDistance, input.VerticalDistance);
}
public void Clone_Always_ReturnNewInstanceWithCopiedValues()
{
// Setup
var original = new StabilityPointStructuresInput();
StabilityPointStructuresTestDataGenerator.SetRandomDataToStabilityPointStructuresInput(original);
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, StabilityPointStructuresCloneAssert.AreClones);
}
public void EvaluationLevel_Always_ExpectedValues()
{
// Setup
var random = new Random(22);
var input = new StabilityPointStructuresInput();
var evaluationLevel = new RoundedDouble(5, random.NextDouble());
// Call
input.EvaluationLevel = evaluationLevel;
// Assert
Assert.AreEqual(2, input.EvaluationLevel.NumberOfDecimalPlaces);
AssertAreEqual(evaluationLevel, input.EvaluationLevel);
}
public void VolumicWeightWater_Always_ExpectedValues()
{
// Setup
var input = new StabilityPointStructuresInput();
var random = new Random(22);
var volumicWeightWater = new RoundedDouble(5, random.NextDouble());
// Call
input.VolumicWeightWater = volumicWeightWater;
// Assert
Assert.AreEqual(2, input.VolumicWeightWater.NumberOfDecimalPlaces);
AssertAreEqual(volumicWeightWater, input.VolumicWeightWater);
}
public void FactorStormDurationOpenStructure_Always_ExpectedValues()
{
// Setup
var input = new StabilityPointStructuresInput();
var random = new Random(22);
var factorStormDurationOpenStructure = new RoundedDouble(5, random.NextDouble());
// Call
input.FactorStormDurationOpenStructure = factorStormDurationOpenStructure;
// Assert
Assert.AreEqual(2, input.FactorStormDurationOpenStructure.NumberOfDecimalPlaces);
AssertAreEqual(factorStormDurationOpenStructure, input.FactorStormDurationOpenStructure);
}
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 IsStructureInputSynchronized_StructureAndInputInSync_ReturnTrue()
{
// Setup
var structure = new TestStabilityPointStructure();
var input = new StabilityPointStructuresInput
{
Structure = structure
};
// Call
bool isStructureInputSynchronized = input.IsStructureInputSynchronized;
// Assert
Assert.IsTrue(isStructureInputSynchronized);
}
public void IsStructureInputSynchronized_StructureAndInputNotInSync_ReturnFalse(StabilityPointStructure modifiedStructure)
{
// Setup
var structure = new TestStabilityPointStructure();
var input = new StabilityPointStructuresInput
{
Structure = structure
};
structure.CopyProperties(modifiedStructure);
// Call
bool isStructureInputSynchronized = input.IsStructureInputSynchronized;
// Assert
Assert.IsFalse(isStructureInputSynchronized);
}
public void ConstructorWithData_Always_ExpectedPropertiesSet()
{
// Setup
var assessmentSection = mocksRepository.Stub <IAssessmentSection>();
mocksRepository.ReplayAll();
var input = new StabilityPointStructuresInput();
var calculation = new StructuresCalculation <StabilityPointStructuresInput>();
var failureMechanism = new StabilityPointStructuresFailureMechanism();
// Call
var context = new StabilityPointStructuresInputContext(input, calculation, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <InputContextBase <StabilityPointStructuresInput, StructuresCalculation <StabilityPointStructuresInput>, StabilityPointStructuresFailureMechanism> >(context);
Assert.AreSame(input, context.WrappedData);
Assert.AreSame(calculation, context.Calculation);
Assert.AreSame(failureMechanism, context.FailureMechanism);
Assert.AreSame(assessmentSection, context.AssessmentSection);
mocksRepository.VerifyAll();
}
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);
}
/// <summary>
/// This method sets random data values to all properties of <paramref name="input"/>.
/// </summary>
/// <param name="input">The input to set the random data values to.</param>
public static void SetRandomDataToStabilityPointStructuresInput(StabilityPointStructuresInput input)
{
var random = new Random(21);
input.Structure = new TestStabilityPointStructure();
input.InsideWaterLevelFailureConstruction = new NormalDistribution
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
};
input.InsideWaterLevel = new NormalDistribution
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
};
input.DrainCoefficient = new LogNormalDistribution
{
Mean = random.NextRoundedDouble()
};
input.LevelCrestStructure = new NormalDistribution
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
};
input.ThresholdHeightOpenWeir = new NormalDistribution
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
};
input.AreaFlowApertures = new LogNormalDistribution
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
};
input.ConstructiveStrengthLinearLoadModel = new VariationCoefficientLogNormalDistribution
{
Mean = random.NextRoundedDouble(),
CoefficientOfVariation = random.NextRoundedDouble()
};
input.ConstructiveStrengthQuadraticLoadModel = new VariationCoefficientLogNormalDistribution
{
Mean = random.NextRoundedDouble(),
CoefficientOfVariation = random.NextRoundedDouble()
};
input.StabilityLinearLoadModel = new VariationCoefficientLogNormalDistribution
{
Mean = random.NextRoundedDouble(),
CoefficientOfVariation = random.NextRoundedDouble()
};
input.StabilityQuadraticLoadModel = new VariationCoefficientLogNormalDistribution
{
Mean = random.NextRoundedDouble(),
CoefficientOfVariation = random.NextRoundedDouble()
};
input.FailureCollisionEnergy = new VariationCoefficientLogNormalDistribution
{
Mean = random.NextRoundedDouble(),
CoefficientOfVariation = random.NextRoundedDouble()
};
input.ShipMass = new VariationCoefficientNormalDistribution
{
Mean = random.NextRoundedDouble(),
CoefficientOfVariation = random.NextRoundedDouble()
};
input.ShipVelocity = new VariationCoefficientNormalDistribution
{
Mean = random.NextRoundedDouble(),
CoefficientOfVariation = random.NextRoundedDouble()
};
input.BankWidth = new NormalDistribution
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
};
input.FlowVelocityStructureClosable = new VariationCoefficientNormalDistribution
{
Mean = random.NextRoundedDouble()
};
input.VolumicWeightWater = random.NextRoundedDouble();
input.FactorStormDurationOpenStructure = random.NextRoundedDouble();
input.EvaluationLevel = random.NextRoundedDouble();
input.VerticalDistance = random.NextRoundedDouble();
input.FailureProbabilityRepairClosure = random.NextDouble();
input.ProbabilityCollisionSecondaryStructure = random.NextDouble();
input.InflowModelType = random.NextEnumValue <StabilityPointStructureInflowModelType>();
input.LoadSchematizationType = random.NextEnumValue <LoadSchematizationType>();
input.LevellingCount = random.Next();
CommonTestDataGenerator.SetRandomDataToStructuresInput(input);
}
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);
}
public void Constructor_ExpectedValues()
{
// Call
var input = new StabilityPointStructuresInput();
// Assert
Assert.IsInstanceOf <StructuresInputBase <StabilityPointStructure> >(input);
AssertAreEqual(9.81, input.VolumicWeightWater);
Assert.AreEqual(2, input.VolumicWeightWater.NumberOfDecimalPlaces);
var expectedInsideWaterLevelFailureConstruction = new NormalDistribution(2)
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
};
var expectedInsideWaterLevel = new NormalDistribution(2)
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
};
var expectedDrainCoefficient = new LogNormalDistribution(2)
{
Mean = (RoundedDouble)1,
StandardDeviation = (RoundedDouble)0.2
};
var expectedFlowVelocityStructureClosable = new VariationCoefficientNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = (RoundedDouble)0.2
};
var expectedLevelCrestStructure = new NormalDistribution(2)
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
};
var expectedThresholdHeightOpenWeir = new NormalDistribution(2)
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
};
var expectedAreaFlowApertures = new LogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
};
var expectedConstructiveStrengthLinearLoadModel = new VariationCoefficientLogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
};
var expectedConstructiveStrengthQuadraticLoadModel = new VariationCoefficientLogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
};
var expectedStabilityLinearLoadModel = new VariationCoefficientLogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
};
var expectedStabilityQuadraticLoadModel = new VariationCoefficientLogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
};
var expectedFailureCollisionEnergy = new VariationCoefficientLogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
};
var expectedShipMass = new VariationCoefficientNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
};
var expectedShipVelocity = new VariationCoefficientNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
};
var expectedBankWidth = new NormalDistribution(2)
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
};
DistributionAssert.AreEqual(expectedInsideWaterLevelFailureConstruction, input.InsideWaterLevelFailureConstruction);
DistributionAssert.AreEqual(expectedInsideWaterLevel, input.InsideWaterLevel);
Assert.AreEqual(2, input.FactorStormDurationOpenStructure.NumberOfDecimalPlaces);
Assert.AreEqual(1.0, input.FactorStormDurationOpenStructure, input.FactorStormDurationOpenStructure.GetAccuracy());
DistributionAssert.AreEqual(expectedDrainCoefficient, input.DrainCoefficient);
DistributionAssert.AreEqual(expectedFlowVelocityStructureClosable, input.FlowVelocityStructureClosable);
DistributionAssert.AreEqual(expectedLevelCrestStructure, input.LevelCrestStructure);
DistributionAssert.AreEqual(expectedThresholdHeightOpenWeir, input.ThresholdHeightOpenWeir);
DistributionAssert.AreEqual(expectedAreaFlowApertures, input.AreaFlowApertures);
DistributionAssert.AreEqual(expectedConstructiveStrengthLinearLoadModel, input.ConstructiveStrengthLinearLoadModel);
DistributionAssert.AreEqual(expectedConstructiveStrengthQuadraticLoadModel, input.ConstructiveStrengthQuadraticLoadModel);
DistributionAssert.AreEqual(expectedStabilityLinearLoadModel, input.StabilityLinearLoadModel);
DistributionAssert.AreEqual(expectedStabilityQuadraticLoadModel, input.StabilityQuadraticLoadModel);
Assert.AreEqual(0, input.FailureProbabilityRepairClosure);
DistributionAssert.AreEqual(expectedFailureCollisionEnergy, input.FailureCollisionEnergy);
DistributionAssert.AreEqual(expectedShipMass, input.ShipMass);
DistributionAssert.AreEqual(expectedShipVelocity, input.ShipVelocity);
Assert.AreEqual(0, input.LevellingCount);
Assert.AreEqual(0, input.ProbabilityCollisionSecondaryStructure);
DistributionAssert.AreEqual(expectedBankWidth, input.BankWidth);
Assert.AreEqual(2, input.EvaluationLevel.NumberOfDecimalPlaces);
AssertAreEqual(double.NaN, input.EvaluationLevel);
Assert.AreEqual(2, input.VerticalDistance.NumberOfDecimalPlaces);
AssertAreEqual(double.NaN, input.VerticalDistance);
Assert.AreEqual(0, (int)input.InflowModelType);
Assert.AreEqual(LoadSchematizationType.Linear, input.LoadSchematizationType);
}
