public void LevelCrestStructureNotClosing_Always_ExpectedValues()
{
// Setup
var random = new Random(22);
var input = new ClosingStructuresInput();
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.LevelCrestStructureNotClosing = distributionToSet;
// Assert
var expectedDistribution = new NormalDistribution(2)
{
Mean = mean,
StandardDeviation = standardDeviation
};
DistributionTestHelper.AssertDistributionCorrectlySet(input.LevelCrestStructureNotClosing, distributionToSet, expectedDistribution);
}
private static void ReadInputParameters(ClosingStructuresInput inputParameters,
ClosingStructuresCalculationEntity entity,
ReadConversionCollector collector)
{
if (entity.ClosingStructureEntity != null)
{
inputParameters.Structure = entity.ClosingStructureEntity.Read(collector);
}
entity.Read(inputParameters, collector);
inputParameters.InflowModelType = (ClosingStructureInflowModelType)entity.InflowModelType;
inputParameters.InsideWaterLevel.Mean = (RoundedDouble)entity.InsideWaterLevelMean.ToNullAsNaN();
inputParameters.InsideWaterLevel.StandardDeviation = (RoundedDouble)entity.InsideWaterLevelStandardDeviation.ToNullAsNaN();
inputParameters.DeviationWaveDirection = (RoundedDouble)entity.DeviationWaveDirection.ToNullAsNaN();
inputParameters.ModelFactorSuperCriticalFlow.Mean = (RoundedDouble)entity.ModelFactorSuperCriticalFlowMean.ToNullAsNaN();
inputParameters.DrainCoefficient.Mean = (RoundedDouble)entity.DrainCoefficientMean.ToNullAsNaN();
inputParameters.DrainCoefficient.StandardDeviation = (RoundedDouble)entity.DrainCoefficientStandardDeviation.ToNullAsNaN();
inputParameters.FactorStormDurationOpenStructure = (RoundedDouble)entity.FactorStormDurationOpenStructure.ToNullAsNaN();
inputParameters.ThresholdHeightOpenWeir.Mean = (RoundedDouble)entity.ThresholdHeightOpenWeirMean.ToNullAsNaN();
inputParameters.ThresholdHeightOpenWeir.StandardDeviation = (RoundedDouble)entity.ThresholdHeightOpenWeirStandardDeviation.ToNullAsNaN();
inputParameters.AreaFlowApertures.Mean = (RoundedDouble)entity.AreaFlowAperturesMean.ToNullAsNaN();
inputParameters.AreaFlowApertures.StandardDeviation = (RoundedDouble)entity.AreaFlowAperturesStandardDeviation.ToNullAsNaN();
inputParameters.FailureProbabilityOpenStructure = entity.FailureProbabilityOpenStructure;
inputParameters.FailureProbabilityReparation = entity.FailureProbabilityReparation;
inputParameters.IdenticalApertures = entity.IdenticalApertures;
inputParameters.LevelCrestStructureNotClosing.Mean = (RoundedDouble)entity.LevelCrestStructureNotClosingMean.ToNullAsNaN();
inputParameters.LevelCrestStructureNotClosing.StandardDeviation = (RoundedDouble)entity.LevelCrestStructureNotClosingStandardDeviation.ToNullAsNaN();
inputParameters.ProbabilityOpenStructureBeforeFlooding = entity.ProbabilityOpenStructureBeforeFlooding;
}
public void SynchronizeStructureInput_ChangedStructure_ExpectedValues()
{
// Setup
var differentStructure = new ClosingStructure(new ClosingStructure.ConstructionProperties
{
Id = "Test id",
Name = "Test name",
Location = new Point2D(-1, -1)
});
var input = new ClosingStructuresInput
{
Structure = new TestClosingStructure()
};
input.Structure.CopyProperties(differentStructure);
// Precondition
AssertClosingStructureInput(new TestClosingStructure(), input);
// Call
input.SynchronizeStructureInput();
// Assert
AssertClosingStructureInput(differentStructure, input);
}
public void AreaFlowApertures_Always_ExpectedValues()
{
// Setup
var random = new Random(22);
var input = new ClosingStructuresInput();
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.AreaFlowApertures = distributionToSet;
// Assert
var expectedDistribution = new LogNormalDistribution(2)
{
Mean = mean,
StandardDeviation = standardDeviation
};
DistributionTestHelper.AssertDistributionCorrectlySet(input.AreaFlowApertures, distributionToSet, expectedDistribution);
}
public void SynchronizeStructureInput_StructureNotSet_ExpectedValues()
{
// Setup
var input = new ClosingStructuresInput();
// Call
input.SynchronizeStructureInput();
// Assert
AssertClosingStructureInput(null, input);
}
public void ProbabilityOpenStructureBeforeFlooding_InvalidValues_ThrowsArgumentOutOfRangeException(double probability)
{
// Setup
var input = new ClosingStructuresInput();
// Call
TestDelegate call = () => input.ProbabilityOpenStructureBeforeFlooding = probability;
// Assert
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(call, "De waarde voor de faalkans moet in het bereik [0,0, 1,0] liggen.");
}
public void FailureProbabilityReparation_ValidValues_ExpectedValues(double probability)
{
// Setup
var input = new ClosingStructuresInput();
// Call
input.FailureProbabilityReparation = probability;
// Assert
Assert.AreEqual(probability, input.FailureProbabilityReparation);
}
public void IsStructureInputSynchronized_StructureNotSet_ReturnFalse()
{
// Setup
var input = new ClosingStructuresInput();
// Call
bool isStructureInputSynchronized = input.IsStructureInputSynchronized;
// Assert
Assert.IsFalse(isStructureInputSynchronized);
}
public void ProbabilityOpenStructureBeforeFlooding_ValidValues_ExpectedValues(double probability)
{
// Setup
var input = new ClosingStructuresInput();
// Call
input.ProbabilityOpenStructureBeforeFlooding = probability;
// Assert
Assert.AreEqual(probability, input.ProbabilityOpenStructureBeforeFlooding);
}
public void Structure_Null_ExpectedValues()
{
// Setup
var input = new ClosingStructuresInput();
// Call
input.Structure = null;
// Assert
AssertClosingStructureInput(null, input);
}
public void IdenticalApertures_InvalidValue_ThrowsArgumentOutOfRangeException()
{
// Setup
var input = new ClosingStructuresInput();
// Call
TestDelegate call = () => input.IdenticalApertures = 0;
// Assert
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(call, "De waarde voor het aantal identieke openingen moet groter of gelijk zijn aan 1.");
}
public void Structure_NotNull_ExpectedValues()
{
// Setup
var input = new ClosingStructuresInput();
var structure = new TestClosingStructure();
// Call
input.Structure = structure;
// Assert
AssertClosingStructureInput(structure, input);
}
public void IdenticalApertures_ValidValue_ExpectedValues()
{
// Setup
var input = new ClosingStructuresInput();
int newValue = new Random(21).Next(1, int.MaxValue);
// Call
input.IdenticalApertures = newValue;
// Assert
Assert.AreEqual(newValue, input.IdenticalApertures);
}
public void Clone_Always_ReturnNewInstanceWithCopiedValues()
{
// Setup
var original = new ClosingStructuresInput();
ClosingStructuresTestDataGenerator.SetRandomDataToClosingStructuresInput(original);
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, ClosingStructuresCloneAssert.AreClones);
}
public void DeviationWaveDirection_ValidValues_ExpectedValues(double validValue)
{
// Setup
var input = new ClosingStructuresInput();
var deviationWaveDirection = new RoundedDouble(5, validValue);
// Call
input.DeviationWaveDirection = deviationWaveDirection;
// Assert
Assert.AreEqual(2, input.DeviationWaveDirection.NumberOfDecimalPlaces);
AssertAreEqual(deviationWaveDirection, input.DeviationWaveDirection);
}
public void FactorStormDurationOpenStructure_Always_ExpectedValues()
{
// Setup
var random = new Random(22);
var input = new ClosingStructuresInput();
var factorStormDurationOpenStructure = new RoundedDouble(5, random.NextDouble());
// Call
input.FactorStormDurationOpenStructure = factorStormDurationOpenStructure;
// Assert
Assert.AreEqual(2, input.FactorStormDurationOpenStructure.NumberOfDecimalPlaces);
AssertAreEqual(factorStormDurationOpenStructure, input.FactorStormDurationOpenStructure);
}
/// <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 SetRandomDataToClosingStructuresInput(ClosingStructuresInput input)
{
var random = new Random(21);
input.Structure = new TestClosingStructure();
input.ThresholdHeightOpenWeir = new NormalDistribution
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
};
input.ModelFactorSuperCriticalFlow = new NormalDistribution
{
Mean = random.NextRoundedDouble()
};
input.DrainCoefficient = new LogNormalDistribution
{
Mean = random.NextRoundedDouble()
};
input.AreaFlowApertures = new LogNormalDistribution
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
};
input.LevelCrestStructureNotClosing = new NormalDistribution
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
};
input.InsideWaterLevel = new NormalDistribution
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
};
input.FactorStormDurationOpenStructure = random.NextRoundedDouble();
input.FailureProbabilityOpenStructure = random.NextDouble();
input.FailureProbabilityReparation = random.NextDouble();
input.ProbabilityOpenStructureBeforeFlooding = random.NextDouble();
input.DeviationWaveDirection = random.NextRoundedDouble();
input.InflowModelType = random.NextEnumValue <ClosingStructureInflowModelType>();
input.IdenticalApertures = random.Next();
CommonTestDataGenerator.SetRandomDataToStructuresInput(input);
}
public void DeviationWaveDirection_InvalidValues_ThrowsArgumentOutOfRangeException(double invalidValue)
{
// Setup
var input = new ClosingStructuresInput();
// Call
TestDelegate call = () => input.DeviationWaveDirection = (RoundedDouble)invalidValue;
// Assert
const string expectedMessage = "De waarde voor de afwijking van de golfrichting moet in het bereik [-360,00, 360,00] liggen.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(call,
expectedMessage);
}
public void IsStructureInputSynchronized_StructureAndInputInSync_ReturnTrue()
{
// Setup
var structure = new TestClosingStructure();
var input = new ClosingStructuresInput
{
Structure = structure
};
// Call
bool isStructureInputSynchronized = input.IsStructureInputSynchronized;
// Assert
Assert.IsTrue(isStructureInputSynchronized);
}
public void IsStructureInputSynchronized_StructureAndInputNotInSync_ReturnFalse(ClosingStructure modifiedStructure)
{
// Setup
var structure = new TestClosingStructure();
var input = new ClosingStructuresInput
{
Structure = structure
};
structure.CopyProperties(modifiedStructure);
// Call
bool isStructureInputSynchronized = input.IsStructureInputSynchronized;
// Assert
Assert.IsFalse(isStructureInputSynchronized);
}
/// <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(ClosingStructuresInput original, ClosingStructuresInput clone)
{
CommonCloneAssert.AreClones(original, clone);
CoreCloneAssert.AreObjectClones(original.ThresholdHeightOpenWeir, clone.ThresholdHeightOpenWeir, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.ModelFactorSuperCriticalFlow, clone.ModelFactorSuperCriticalFlow, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.DrainCoefficient, clone.DrainCoefficient, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.AreaFlowApertures, clone.AreaFlowApertures, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.LevelCrestStructureNotClosing, clone.LevelCrestStructureNotClosing, DistributionAssert.AreEqual);
CoreCloneAssert.AreObjectClones(original.InsideWaterLevel, clone.InsideWaterLevel, DistributionAssert.AreEqual);
Assert.AreEqual(original.FactorStormDurationOpenStructure, clone.FactorStormDurationOpenStructure);
Assert.AreEqual(original.FailureProbabilityOpenStructure, clone.FailureProbabilityOpenStructure);
Assert.AreEqual(original.FailureProbabilityReparation, clone.FailureProbabilityReparation);
Assert.AreEqual(original.ProbabilityOpenStructureBeforeFlooding, clone.ProbabilityOpenStructureBeforeFlooding);
Assert.AreEqual(original.DeviationWaveDirection, clone.DeviationWaveDirection);
Assert.AreEqual(original.InflowModelType, clone.InflowModelType);
Assert.AreEqual(original.IdenticalApertures, clone.IdenticalApertures);
}
private static void AssertClosingStructureInput(ClosingStructure expectedClosingStructure, ClosingStructuresInput input)
{
if (expectedClosingStructure == null)
{
Assert.IsNull(input.Structure);
var defaultInput = new ClosingStructuresInput();
AssertAreEqual(defaultInput.StructureNormalOrientation, input.StructureNormalOrientation);
DistributionAssert.AreEqual(defaultInput.LevelCrestStructureNotClosing, input.LevelCrestStructureNotClosing);
DistributionAssert.AreEqual(defaultInput.FlowWidthAtBottomProtection, input.FlowWidthAtBottomProtection);
DistributionAssert.AreEqual(defaultInput.CriticalOvertoppingDischarge, input.CriticalOvertoppingDischarge);
DistributionAssert.AreEqual(defaultInput.WidthFlowApertures, input.WidthFlowApertures);
DistributionAssert.AreEqual(defaultInput.StorageStructureArea, input.StorageStructureArea);
DistributionAssert.AreEqual(defaultInput.AllowedLevelIncreaseStorage, input.AllowedLevelIncreaseStorage);
Assert.AreEqual(defaultInput.InflowModelType, input.InflowModelType);
DistributionAssert.AreEqual(defaultInput.AreaFlowApertures, input.AreaFlowApertures);
Assert.AreEqual(defaultInput.FailureProbabilityOpenStructure, input.FailureProbabilityOpenStructure);
Assert.AreEqual(defaultInput.FailureProbabilityReparation, input.FailureProbabilityReparation);
Assert.AreEqual(defaultInput.IdenticalApertures, input.IdenticalApertures);
DistributionAssert.AreEqual(defaultInput.InsideWaterLevel, input.InsideWaterLevel);
Assert.AreEqual(defaultInput.ProbabilityOpenStructureBeforeFlooding, input.ProbabilityOpenStructureBeforeFlooding);
DistributionAssert.AreEqual(defaultInput.ThresholdHeightOpenWeir, input.ThresholdHeightOpenWeir);
}
else
{
AssertAreEqual(expectedClosingStructure.StructureNormalOrientation, input.StructureNormalOrientation);
DistributionAssert.AreEqual(expectedClosingStructure.LevelCrestStructureNotClosing, input.LevelCrestStructureNotClosing);
DistributionAssert.AreEqual(expectedClosingStructure.FlowWidthAtBottomProtection, input.FlowWidthAtBottomProtection);
DistributionAssert.AreEqual(expectedClosingStructure.CriticalOvertoppingDischarge, input.CriticalOvertoppingDischarge);
DistributionAssert.AreEqual(expectedClosingStructure.WidthFlowApertures, input.WidthFlowApertures);
DistributionAssert.AreEqual(expectedClosingStructure.StorageStructureArea, input.StorageStructureArea);
DistributionAssert.AreEqual(expectedClosingStructure.AllowedLevelIncreaseStorage, input.AllowedLevelIncreaseStorage);
Assert.AreEqual(expectedClosingStructure.InflowModelType, input.InflowModelType);
DistributionAssert.AreEqual(expectedClosingStructure.AreaFlowApertures, input.AreaFlowApertures);
Assert.AreEqual(expectedClosingStructure.FailureProbabilityOpenStructure, input.FailureProbabilityOpenStructure);
Assert.AreEqual(expectedClosingStructure.FailureProbabilityReparation, input.FailureProbabilityReparation);
Assert.AreEqual(expectedClosingStructure.IdenticalApertures, input.IdenticalApertures);
DistributionAssert.AreEqual(expectedClosingStructure.InsideWaterLevel, input.InsideWaterLevel);
Assert.AreEqual(expectedClosingStructure.ProbabilityOpenStructureBeforeFlooding, input.ProbabilityOpenStructureBeforeFlooding);
DistributionAssert.AreEqual(expectedClosingStructure.ThresholdHeightOpenWeir, input.ThresholdHeightOpenWeir);
}
}
public void ModelFactorSuperCriticalFlow_Always_ExpectedValues()
{
// Setup
var random = new Random(22);
var input = new ClosingStructuresInput();
RoundedDouble mean = random.NextRoundedDouble(0.01, 1.0);
var distributionToSet = new NormalDistribution(5)
{
Mean = mean,
StandardDeviation = random.NextRoundedDouble()
};
// Call
input.ModelFactorSuperCriticalFlow = distributionToSet;
// Assert
var expectedDistribution = new NormalDistribution(2)
{
Mean = mean,
StandardDeviation = input.ModelFactorSuperCriticalFlow.StandardDeviation
};
DistributionTestHelper.AssertDistributionCorrectlySet(input.ModelFactorSuperCriticalFlow, distributionToSet, expectedDistribution);
}
private static void SetClosingStructuresInputValues(ClosingStructuresCalculationEntity entity, ClosingStructuresInput input,
PersistenceRegistry registry)
{
input.Create(entity, registry);
if (input.Structure != null)
{
entity.ClosingStructureEntity = registry.Get(input.Structure);
}
entity.InflowModelType = Convert.ToByte(input.InflowModelType);
entity.InsideWaterLevelMean = input.InsideWaterLevel.Mean.ToNaNAsNull();
entity.InsideWaterLevelStandardDeviation = input.InsideWaterLevel.StandardDeviation.ToNaNAsNull();
entity.DeviationWaveDirection = input.DeviationWaveDirection.ToNaNAsNull();
entity.ModelFactorSuperCriticalFlowMean = input.ModelFactorSuperCriticalFlow.Mean.ToNaNAsNull();
entity.DrainCoefficientMean = input.DrainCoefficient.Mean.ToNaNAsNull();
entity.DrainCoefficientStandardDeviation = input.DrainCoefficient.StandardDeviation.ToNaNAsNull();
entity.FactorStormDurationOpenStructure = input.FactorStormDurationOpenStructure.ToNaNAsNull();
entity.ThresholdHeightOpenWeirMean = input.ThresholdHeightOpenWeir.Mean.ToNaNAsNull();
entity.ThresholdHeightOpenWeirStandardDeviation = input.ThresholdHeightOpenWeir.StandardDeviation.ToNaNAsNull();
entity.AreaFlowAperturesMean = input.AreaFlowApertures.Mean.ToNaNAsNull();
entity.AreaFlowAperturesStandardDeviation = input.AreaFlowApertures.StandardDeviation.ToNaNAsNull();
entity.FailureProbabilityOpenStructure = input.FailureProbabilityOpenStructure;
entity.FailureProbabilityReparation = input.FailureProbabilityReparation;
entity.IdenticalApertures = input.IdenticalApertures;
entity.LevelCrestStructureNotClosingMean = input.LevelCrestStructureNotClosing.Mean.ToNaNAsNull();
entity.LevelCrestStructureNotClosingStandardDeviation = input.LevelCrestStructureNotClosing.StandardDeviation.ToNaNAsNull();
entity.ProbabilityOpenStructureBeforeFlooding = input.ProbabilityOpenStructureBeforeFlooding;
}
public void Read_EntityWithNullParameters_ReturnClosingStructuresCalculationWithInputParametersNaN()
{
// Setup
var entity = new ClosingStructuresCalculationEntity
{
ScenarioContribution = 0,
StructureNormalOrientation = null,
ModelFactorSuperCriticalFlowMean = 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,
DeviationWaveDirection = null,
DrainCoefficientMean = null,
DrainCoefficientStandardDeviation = null,
FactorStormDurationOpenStructure = null,
ThresholdHeightOpenWeirMean = null,
ThresholdHeightOpenWeirStandardDeviation = null,
AreaFlowAperturesMean = null,
AreaFlowAperturesStandardDeviation = null,
LevelCrestStructureNotClosingMean = null,
LevelCrestStructureNotClosingStandardDeviation = null,
IdenticalApertures = 1
};
var collector = new ReadConversionCollector();
// Call
StructuresCalculationScenario <ClosingStructuresInput> calculation = entity.Read(collector);
// Assert
ClosingStructuresInput 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.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.DeviationWaveDirection);
Assert.IsNaN(inputParameters.DrainCoefficient.Mean);
Assert.IsNaN(inputParameters.DrainCoefficient.StandardDeviation);
Assert.IsNaN(inputParameters.FactorStormDurationOpenStructure);
Assert.IsNaN(inputParameters.ThresholdHeightOpenWeir.Mean);
Assert.IsNaN(inputParameters.ThresholdHeightOpenWeir.StandardDeviation);
Assert.IsNaN(inputParameters.AreaFlowApertures.Mean);
Assert.IsNaN(inputParameters.AreaFlowApertures.StandardDeviation);
Assert.IsNaN(inputParameters.LevelCrestStructureNotClosing.Mean);
Assert.IsNaN(inputParameters.LevelCrestStructureNotClosing.StandardDeviation);
}
public void Read_ValidEntity_ReturnClosingStructuresCalculation()
{
// Setup
var entity = new ClosingStructuresCalculationEntity
{
Name = "name",
RelevantForScenario = Convert.ToByte(true),
ScenarioContribution = 0.0,
Comments = "comments",
StructureNormalOrientation = 1.1,
ModelFactorSuperCriticalFlowMean = 2.2,
AllowedLevelIncreaseStorageMean = 3.3,
AllowedLevelIncreaseStorageStandardDeviation = 4.4,
StorageStructureAreaMean = 5.5,
StorageStructureAreaCoefficientOfVariation = 6.6,
FlowWidthAtBottomProtectionMean = 7.7,
FlowWidthAtBottomProtectionStandardDeviation = 8.8,
CriticalOvertoppingDischargeMean = 9.9,
CriticalOvertoppingDischargeCoefficientOfVariation = 10.10,
FailureProbabilityStructureWithErosion = 0.11,
WidthFlowAperturesMean = 12.12,
WidthFlowAperturesStandardDeviation = 13.13,
StormDurationMean = 14.14,
UseBreakWater = Convert.ToByte(true),
BreakWaterType = Convert.ToByte(BreakWaterType.Wall),
BreakWaterHeight = 15.15,
UseForeshore = Convert.ToByte(true),
InflowModelType = Convert.ToByte(ClosingStructureInflowModelType.LowSill),
InsideWaterLevelMean = 16.16,
InsideWaterLevelStandardDeviation = 17.17,
DeviationWaveDirection = 18.18,
DrainCoefficientMean = 19.19,
DrainCoefficientStandardDeviation = 20.20,
FactorStormDurationOpenStructure = 21.21,
ThresholdHeightOpenWeirMean = 22.22,
ThresholdHeightOpenWeirStandardDeviation = 23.23,
AreaFlowAperturesMean = 24.24,
AreaFlowAperturesStandardDeviation = 25.25,
FailureProbabilityOpenStructure = 0.26,
FailureProbabilityReparation = 0.27,
IdenticalApertures = 28,
LevelCrestStructureNotClosingMean = 29.29,
LevelCrestStructureNotClosingStandardDeviation = 30.30,
ProbabilityOpenStructureBeforeFlooding = 0.31
};
var collector = new ReadConversionCollector();
// Call
StructuresCalculationScenario <ClosingStructuresInput> 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);
ClosingStructuresInput 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.ModelFactorSuperCriticalFlowMean, inputParameters.ModelFactorSuperCriticalFlow.Mean.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((ClosingStructureInflowModelType)entity.InflowModelType, inputParameters.InflowModelType);
Assert.AreEqual(entity.InsideWaterLevelMean, inputParameters.InsideWaterLevel.Mean.Value);
Assert.AreEqual(entity.InsideWaterLevelStandardDeviation, inputParameters.InsideWaterLevel.StandardDeviation.Value);
Assert.AreEqual(entity.DeviationWaveDirection, inputParameters.DeviationWaveDirection.Value);
Assert.AreEqual(entity.DrainCoefficientMean, inputParameters.DrainCoefficient.Mean.Value);
Assert.AreEqual(entity.DrainCoefficientStandardDeviation, inputParameters.DrainCoefficient.StandardDeviation.Value);
Assert.AreEqual(entity.FactorStormDurationOpenStructure, inputParameters.FactorStormDurationOpenStructure.Value);
Assert.AreEqual(entity.ThresholdHeightOpenWeirMean, inputParameters.ThresholdHeightOpenWeir.Mean.Value);
Assert.AreEqual(entity.ThresholdHeightOpenWeirStandardDeviation, inputParameters.ThresholdHeightOpenWeir.StandardDeviation.Value);
Assert.AreEqual(entity.AreaFlowAperturesMean, inputParameters.AreaFlowApertures.Mean.Value);
Assert.AreEqual(entity.AreaFlowAperturesStandardDeviation, inputParameters.AreaFlowApertures.StandardDeviation.Value);
Assert.AreEqual(entity.FailureProbabilityOpenStructure, inputParameters.FailureProbabilityOpenStructure);
Assert.AreEqual(entity.FailureProbabilityReparation, inputParameters.FailureProbabilityReparation);
Assert.AreEqual(entity.IdenticalApertures, inputParameters.IdenticalApertures);
Assert.AreEqual(entity.LevelCrestStructureNotClosingMean, inputParameters.LevelCrestStructureNotClosing.Mean.Value);
Assert.AreEqual(entity.LevelCrestStructureNotClosingStandardDeviation, inputParameters.LevelCrestStructureNotClosing.StandardDeviation.Value);
Assert.AreEqual(entity.ProbabilityOpenStructureBeforeFlooding, inputParameters.ProbabilityOpenStructureBeforeFlooding);
Assert.IsFalse(calculation.HasOutput);
}
public void GivenInputWithStructure_WhenStructureNull_ThenSchematizationPropertiesSynedToDefaults()
{
// Given
var structure = new TestClosingStructure();
var input = new ClosingStructuresInput
{
Structure = structure
};
RoundedDouble expectedFactorStormDurationOpenStructure = input.FactorStormDurationOpenStructure;
NormalDistribution expectedModelFactorSuperCriticalFlow = input.ModelFactorSuperCriticalFlow;
LogNormalDistribution expectedDrainCoefficient = input.DrainCoefficient;
RoundedDouble expectedDeviationWaveDirection = input.DeviationWaveDirection;
double expectedFailureProbabilityStructureWithErosion = input.FailureProbabilityStructureWithErosion;
// Precondition
AssertClosingStructureInput(structure, input);
// When
input.Structure = null;
// Then
Assert.AreEqual(0, input.FailureProbabilityOpenStructure);
Assert.AreEqual(0, input.FailureProbabilityReparation);
Assert.AreEqual(2, input.FactorStormDurationOpenStructure.NumberOfDecimalPlaces);
Assert.AreEqual(expectedFactorStormDurationOpenStructure, input.FactorStormDurationOpenStructure,
input.FactorStormDurationOpenStructure.GetAccuracy());
Assert.AreEqual(2, input.DeviationWaveDirection.NumberOfDecimalPlaces);
Assert.AreEqual(expectedDeviationWaveDirection, input.DeviationWaveDirection,
input.DeviationWaveDirection.GetAccuracy());
DistributionAssert.AreEqual(expectedModelFactorSuperCriticalFlow, input.ModelFactorSuperCriticalFlow);
DistributionAssert.AreEqual(expectedDrainCoefficient, input.DrainCoefficient);
Assert.AreEqual(expectedFailureProbabilityStructureWithErosion,
input.FailureProbabilityStructureWithErosion);
var expectedInsideWaterLevel = 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 expectedLevelCrestStructureNotClosing = new NormalDistribution(2)
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
};
DistributionAssert.AreEqual(expectedInsideWaterLevel, input.InsideWaterLevel);
DistributionAssert.AreEqual(expectedThresholdHeightOpenWeir, input.ThresholdHeightOpenWeir);
DistributionAssert.AreEqual(expectedAreaFlowApertures, input.AreaFlowApertures);
DistributionAssert.AreEqual(expectedLevelCrestStructureNotClosing, input.LevelCrestStructureNotClosing);
Assert.AreEqual(1.0, input.ProbabilityOpenStructureBeforeFlooding);
Assert.AreEqual(1, input.IdenticalApertures);
Assert.AreEqual(0, (int)input.InflowModelType);
}
public void Constructor_ExpectedValues()
{
// Call
var input = new ClosingStructuresInput();
// Assert
Assert.IsInstanceOf <StructuresInputBase <ClosingStructure> >(input);
Assert.AreEqual(0, input.FailureProbabilityOpenStructure);
Assert.AreEqual(0, input.FailureProbabilityReparation);
Assert.AreEqual(2, input.FactorStormDurationOpenStructure.NumberOfDecimalPlaces);
Assert.AreEqual(1.0, input.FactorStormDurationOpenStructure, input.FactorStormDurationOpenStructure.GetAccuracy());
Assert.AreEqual(2, input.DeviationWaveDirection.NumberOfDecimalPlaces);
Assert.AreEqual(0.0, input.DeviationWaveDirection, input.DeviationWaveDirection.GetAccuracy());
var expectedInsideWaterLevel = new NormalDistribution(2)
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
};
var expectedModelFactorSuperCriticalFlow = new NormalDistribution(2)
{
Mean = (RoundedDouble)1.1,
StandardDeviation = (RoundedDouble)0.05
};
var expectedDrainCoefficient = new LogNormalDistribution(2)
{
Mean = (RoundedDouble)1,
StandardDeviation = (RoundedDouble)0.2
};
var expectedThresholdHeightOpenWeir = new NormalDistribution(2)
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
};
var expectedAreaFlowApertures = new LogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
};
var expectedLevelCrestStructureNotClosing = new NormalDistribution(2)
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
};
DistributionAssert.AreEqual(expectedInsideWaterLevel, input.InsideWaterLevel);
DistributionAssert.AreEqual(expectedModelFactorSuperCriticalFlow, input.ModelFactorSuperCriticalFlow);
DistributionAssert.AreEqual(expectedDrainCoefficient, input.DrainCoefficient);
DistributionAssert.AreEqual(expectedThresholdHeightOpenWeir, input.ThresholdHeightOpenWeir);
DistributionAssert.AreEqual(expectedAreaFlowApertures, input.AreaFlowApertures);
DistributionAssert.AreEqual(expectedLevelCrestStructureNotClosing, input.LevelCrestStructureNotClosing);
Assert.AreEqual(1.0, input.ProbabilityOpenStructureBeforeFlooding);
Assert.AreEqual(1, input.IdenticalApertures);
Assert.AreEqual(0, (int)input.InflowModelType);
}
