public void Constructor_ValidArguments_ReturnsExpectedValues()
{
// Setup
var random = new Random(21);
var location = new Point2D(random.NextDouble(), random.NextDouble());
var distribution = new VariationCoefficientLogNormalDistribution
{
Mean = random.NextRoundedDouble(0.1, double.MaxValue),
CoefficientOfVariation = random.NextRoundedDouble()
};
// Call
var stress = new MacroStabilityInwardsPreconsolidationStress(location, distribution);
// Assert
Assert.IsInstanceOf <IMacroStabilityInwardsPreconsolidationStress>(stress);
Assert.AreEqual(location, stress.Location);
DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
{
Mean = distribution.Mean,
CoefficientOfVariation = distribution.CoefficientOfVariation
}, stress.Stress);
}
public void Constructor_ExpectedValues()
{
// Setup
var modelFactorStorageVolume = new LogNormalDistribution(2)
{
Mean = (RoundedDouble)1.00,
StandardDeviation = (RoundedDouble)0.20
};
var modelFactorOvertoppingFlow = new LogNormalDistribution(3)
{
Mean = (RoundedDouble)0.09,
StandardDeviation = (RoundedDouble)0.06
};
// Call
var generalHeightStructuresInput = new GeneralHeightStructuresInput();
// Assert
Assert.AreEqual(2, generalHeightStructuresInput.N.NumberOfDecimalPlaces);
Assert.AreEqual(2.0, generalHeightStructuresInput.N, generalHeightStructuresInput.N.GetAccuracy());
Assert.IsFalse(generalHeightStructuresInput.ApplyLengthEffectInSection);
Assert.AreEqual(2, generalHeightStructuresInput.GravitationalAcceleration.NumberOfDecimalPlaces);
Assert.AreEqual(9.81, generalHeightStructuresInput.GravitationalAcceleration, generalHeightStructuresInput.GravitationalAcceleration.GetAccuracy());
DistributionAssert.AreEqual(modelFactorOvertoppingFlow, generalHeightStructuresInput.ModelFactorOvertoppingFlow);
DistributionAssert.AreEqual(modelFactorStorageVolume, generalHeightStructuresInput.ModelFactorStorageVolume);
Assert.AreEqual(2, generalHeightStructuresInput.ModelFactorInflowVolume.NumberOfDecimalPlaces);
Assert.AreEqual(1, generalHeightStructuresInput.ModelFactorInflowVolume, generalHeightStructuresInput.ModelFactorInflowVolume.GetAccuracy());
}
private static void AssertHeightStructureInput(HeightStructure expectedHeightStructure, HeightStructuresInput input)
{
if (expectedHeightStructure == null)
{
Assert.IsNull(input.Structure);
var defaultInput = new HeightStructuresInput();
AssertAreEqual(defaultInput.StructureNormalOrientation, input.StructureNormalOrientation);
DistributionAssert.AreEqual(defaultInput.LevelCrestStructure, input.LevelCrestStructure);
DistributionAssert.AreEqual(defaultInput.CriticalOvertoppingDischarge, input.CriticalOvertoppingDischarge);
DistributionAssert.AreEqual(defaultInput.WidthFlowApertures, input.WidthFlowApertures);
Assert.AreEqual(defaultInput.FailureProbabilityStructureWithErosion, input.FailureProbabilityStructureWithErosion);
DistributionAssert.AreEqual(defaultInput.StorageStructureArea, input.StorageStructureArea);
DistributionAssert.AreEqual(defaultInput.AllowedLevelIncreaseStorage, input.AllowedLevelIncreaseStorage);
}
else
{
AssertAreEqual(expectedHeightStructure.StructureNormalOrientation, input.StructureNormalOrientation);
DistributionAssert.AreEqual(expectedHeightStructure.LevelCrestStructure, input.LevelCrestStructure);
DistributionAssert.AreEqual(expectedHeightStructure.CriticalOvertoppingDischarge, input.CriticalOvertoppingDischarge);
DistributionAssert.AreEqual(expectedHeightStructure.WidthFlowApertures, input.WidthFlowApertures);
Assert.AreEqual(expectedHeightStructure.FailureProbabilityStructureWithErosion, input.FailureProbabilityStructureWithErosion);
DistributionAssert.AreEqual(expectedHeightStructure.StorageStructureArea, input.StorageStructureArea);
DistributionAssert.AreEqual(expectedHeightStructure.AllowedLevelIncreaseStorage, input.AllowedLevelIncreaseStorage);
}
}
private static void AssertCalculationScenario(GrassCoverErosionInwardsCalculationScenario expectedCalculation, GrassCoverErosionInwardsCalculationScenario actualCalculation)
{
Assert.AreEqual(expectedCalculation.Name, actualCalculation.Name);
Assert.AreEqual(expectedCalculation.IsRelevant, actualCalculation.IsRelevant);
Assert.AreEqual(expectedCalculation.Contribution, actualCalculation.Contribution);
GrassCoverErosionInwardsInput expectedInput = expectedCalculation.InputParameters;
GrassCoverErosionInwardsInput actualInput = actualCalculation.InputParameters;
Assert.AreSame(expectedInput.HydraulicBoundaryLocation, actualInput.HydraulicBoundaryLocation);
Assert.AreEqual(expectedInput.Orientation, actualInput.Orientation);
Assert.AreSame(expectedInput.DikeProfile, actualInput.DikeProfile);
Assert.AreEqual(expectedInput.DikeHeight, actualInput.DikeHeight);
Assert.AreEqual(expectedInput.UseForeshore, actualInput.UseForeshore);
Assert.AreEqual(expectedInput.UseBreakWater, actualInput.UseBreakWater);
Assert.AreEqual(expectedInput.BreakWater.Height, actualInput.BreakWater.Height);
Assert.AreEqual(expectedInput.BreakWater.Type, actualInput.BreakWater.Type);
DistributionAssert.AreEqual(expectedInput.CriticalFlowRate, actualInput.CriticalFlowRate);
Assert.AreEqual(expectedInput.ShouldOvertoppingOutputIllustrationPointsBeCalculated,
actualInput.ShouldOvertoppingOutputIllustrationPointsBeCalculated);
Assert.AreEqual(expectedInput.ShouldDikeHeightBeCalculated, actualInput.ShouldDikeHeightBeCalculated);
Assert.AreEqual(expectedInput.DikeHeightTargetProbability, actualInput.DikeHeightTargetProbability);
Assert.AreEqual(expectedInput.ShouldDikeHeightIllustrationPointsBeCalculated,
actualInput.ShouldDikeHeightIllustrationPointsBeCalculated);
Assert.AreEqual(expectedInput.ShouldOvertoppingRateBeCalculated, actualInput.ShouldOvertoppingRateBeCalculated);
Assert.AreEqual(expectedInput.OvertoppingRateTargetProbability, actualInput.OvertoppingRateTargetProbability);
Assert.AreEqual(expectedInput.ShouldOvertoppingRateIllustrationPointsBeCalculated,
actualInput.ShouldOvertoppingRateIllustrationPointsBeCalculated);
}
public void Constructor_WithTop_ReturnsNewInstanceWithTopSet()
{
// Setup
double top = new Random(22).NextDouble();
// Call
var layer = new PipingSoilLayer(top);
// Assert
Assert.NotNull(layer);
Assert.AreEqual(top, layer.Top);
Assert.IsFalse(layer.IsAquifer);
Assert.IsEmpty(layer.MaterialName);
Assert.AreEqual(Color.Empty, layer.Color);
DistributionAssert.AreEqual(new LogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN,
Shift = RoundedDouble.NaN
}, layer.BelowPhreaticLevel);
DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(6)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
}, layer.DiameterD70);
DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(6)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
}, layer.Permeability);
}
public void Constructor_ExpectedValues()
{
// Setup
var criticalFlowRate = new LogNormalDistribution(4)
{
Mean = (RoundedDouble)0.004,
StandardDeviation = (RoundedDouble)0.0006
};
// Call
var input = new GrassCoverErosionInwardsInput();
// Assert
Assert.IsInstanceOf <CloneableObservable>(input);
Assert.IsInstanceOf <ICalculationInputWithHydraulicBoundaryLocation>(input);
Assert.IsInstanceOf <IUseBreakWater>(input);
Assert.IsInstanceOf <IUseForeshore>(input);
Assert.AreEqual(2, input.Orientation.NumberOfDecimalPlaces);
Assert.AreEqual(2, input.DikeHeight.NumberOfDecimalPlaces);
AssertDefaultDikeProfileInput(input);
Assert.IsNull(input.HydraulicBoundaryLocation);
Assert.IsFalse(input.ShouldDikeHeightBeCalculated);
Assert.IsFalse(input.ShouldOvertoppingRateBeCalculated);
Assert.AreEqual(0, input.DikeHeightTargetProbability);
Assert.AreEqual(0, input.OvertoppingRateTargetProbability);
DistributionAssert.AreEqual(criticalFlowRate, input.CriticalFlowRate);
}
private static void AssertStabilityPointStructure(StabilityPointStructure expectedStabilityPointStructure,
StabilityPointStructure actualStabilityPointStructure)
{
Assert.AreEqual(expectedStabilityPointStructure.Name, actualStabilityPointStructure.Name);
Assert.AreEqual(expectedStabilityPointStructure.Id, actualStabilityPointStructure.Id);
Assert.AreEqual(expectedStabilityPointStructure.Location, actualStabilityPointStructure.Location);
Assert.AreEqual(expectedStabilityPointStructure.StructureNormalOrientation, actualStabilityPointStructure.StructureNormalOrientation);
DistributionAssert.AreEqual(expectedStabilityPointStructure.StorageStructureArea, actualStabilityPointStructure.StorageStructureArea);
DistributionAssert.AreEqual(expectedStabilityPointStructure.AllowedLevelIncreaseStorage, actualStabilityPointStructure.AllowedLevelIncreaseStorage);
DistributionAssert.AreEqual(expectedStabilityPointStructure.WidthFlowApertures, actualStabilityPointStructure.WidthFlowApertures);
DistributionAssert.AreEqual(expectedStabilityPointStructure.InsideWaterLevel, actualStabilityPointStructure.InsideWaterLevel);
DistributionAssert.AreEqual(expectedStabilityPointStructure.ThresholdHeightOpenWeir, actualStabilityPointStructure.ThresholdHeightOpenWeir);
DistributionAssert.AreEqual(expectedStabilityPointStructure.CriticalOvertoppingDischarge, actualStabilityPointStructure.CriticalOvertoppingDischarge);
DistributionAssert.AreEqual(expectedStabilityPointStructure.FlowWidthAtBottomProtection, actualStabilityPointStructure.FlowWidthAtBottomProtection);
DistributionAssert.AreEqual(expectedStabilityPointStructure.ConstructiveStrengthLinearLoadModel, actualStabilityPointStructure.ConstructiveStrengthLinearLoadModel);
DistributionAssert.AreEqual(expectedStabilityPointStructure.ConstructiveStrengthQuadraticLoadModel, actualStabilityPointStructure.ConstructiveStrengthQuadraticLoadModel);
DistributionAssert.AreEqual(expectedStabilityPointStructure.BankWidth, actualStabilityPointStructure.BankWidth);
DistributionAssert.AreEqual(expectedStabilityPointStructure.InsideWaterLevelFailureConstruction, actualStabilityPointStructure.InsideWaterLevelFailureConstruction);
Assert.AreEqual(expectedStabilityPointStructure.EvaluationLevel, actualStabilityPointStructure.EvaluationLevel);
DistributionAssert.AreEqual(expectedStabilityPointStructure.LevelCrestStructure, actualStabilityPointStructure.LevelCrestStructure);
Assert.AreEqual(expectedStabilityPointStructure.VerticalDistance, actualStabilityPointStructure.VerticalDistance);
Assert.AreEqual(expectedStabilityPointStructure.FailureProbabilityRepairClosure, actualStabilityPointStructure.FailureProbabilityRepairClosure);
DistributionAssert.AreEqual(expectedStabilityPointStructure.FailureCollisionEnergy, actualStabilityPointStructure.FailureCollisionEnergy);
DistributionAssert.AreEqual(expectedStabilityPointStructure.ShipMass, actualStabilityPointStructure.ShipMass);
DistributionAssert.AreEqual(expectedStabilityPointStructure.ShipVelocity, actualStabilityPointStructure.ShipVelocity);
Assert.AreEqual(expectedStabilityPointStructure.LevellingCount, actualStabilityPointStructure.LevellingCount);
Assert.AreEqual(expectedStabilityPointStructure.ProbabilityCollisionSecondaryStructure, actualStabilityPointStructure.ProbabilityCollisionSecondaryStructure);
DistributionAssert.AreEqual(expectedStabilityPointStructure.FlowVelocityStructureClosable, actualStabilityPointStructure.FlowVelocityStructureClosable);
DistributionAssert.AreEqual(expectedStabilityPointStructure.StabilityLinearLoadModel, actualStabilityPointStructure.StabilityLinearLoadModel);
DistributionAssert.AreEqual(expectedStabilityPointStructure.StabilityQuadraticLoadModel, actualStabilityPointStructure.StabilityQuadraticLoadModel);
DistributionAssert.AreEqual(expectedStabilityPointStructure.AreaFlowApertures, actualStabilityPointStructure.AreaFlowApertures);
Assert.AreEqual(expectedStabilityPointStructure.InflowModelType, actualStabilityPointStructure.InflowModelType);
}
public void GivenInputWithStructure_WhenStructureNull_ThenSchematizationPropertiesSynedToDefaults()
{
// Given
var structure = new TestHeightStructure();
var input = new HeightStructuresInput
{
Structure = structure
};
RoundedDouble expectedDeviationWaveDirection = input.DeviationWaveDirection;
NormalDistribution expectedModelFactorSuperCriticalFlow = input.ModelFactorSuperCriticalFlow;
// Precondition
AssertHeightStructureInput(structure, input);
// When
input.Structure = null;
// Then
AssertAreEqual(expectedDeviationWaveDirection, input.DeviationWaveDirection);
DistributionAssert.AreEqual(expectedModelFactorSuperCriticalFlow, input.ModelFactorSuperCriticalFlow);
Assert.AreEqual(1.0, input.FailureProbabilityStructureWithErosion);
var expectedLevelCrestStructure = new NormalDistribution(2)
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
};
DistributionAssert.AreEqual(expectedLevelCrestStructure, input.LevelCrestStructure);
}
public void Constructor_ExpectedValues()
{
// Call
var input = new HeightStructuresInput();
// Assert
Assert.IsInstanceOf <StructuresInputBase <HeightStructure> >(input);
var expectedModelFactorSuperCriticalFlow = new NormalDistribution(2)
{
Mean = (RoundedDouble)1.1,
StandardDeviation = (RoundedDouble)0.05
};
var expectedLevelCrestStructure = new NormalDistribution(2)
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
};
DistributionAssert.AreEqual(expectedModelFactorSuperCriticalFlow, input.ModelFactorSuperCriticalFlow);
DistributionAssert.AreEqual(expectedLevelCrestStructure, input.LevelCrestStructure);
Assert.AreEqual(2, input.DeviationWaveDirection.NumberOfDecimalPlaces);
Assert.AreEqual(0.0, input.DeviationWaveDirection, input.DeviationWaveDirection.GetAccuracy());
}
private static void AssertCalculation(StructuresCalculationScenario <ClosingStructuresInput> expectedCalculation, StructuresCalculationScenario <ClosingStructuresInput> actualCalculation)
{
Assert.AreEqual(expectedCalculation.Name, actualCalculation.Name);
Assert.AreEqual(expectedCalculation.IsRelevant, actualCalculation.IsRelevant);
Assert.AreEqual(expectedCalculation.Contribution, actualCalculation.Contribution);
Assert.AreSame(expectedCalculation.InputParameters.HydraulicBoundaryLocation, actualCalculation.InputParameters.HydraulicBoundaryLocation);
Assert.AreEqual(expectedCalculation.InputParameters.StructureNormalOrientation, actualCalculation.InputParameters.StructureNormalOrientation);
Assert.AreEqual(expectedCalculation.InputParameters.FactorStormDurationOpenStructure, actualCalculation.InputParameters.FactorStormDurationOpenStructure);
Assert.AreEqual(expectedCalculation.InputParameters.FailureProbabilityOpenStructure, actualCalculation.InputParameters.FailureProbabilityOpenStructure);
Assert.AreEqual(expectedCalculation.InputParameters.FailureProbabilityReparation, actualCalculation.InputParameters.FailureProbabilityReparation);
Assert.AreEqual(expectedCalculation.InputParameters.IdenticalApertures, actualCalculation.InputParameters.IdenticalApertures);
Assert.AreEqual(expectedCalculation.InputParameters.InflowModelType, actualCalculation.InputParameters.InflowModelType);
Assert.AreEqual(expectedCalculation.InputParameters.ProbabilityOpenStructureBeforeFlooding, actualCalculation.InputParameters.ProbabilityOpenStructureBeforeFlooding);
Assert.AreSame(expectedCalculation.InputParameters.ForeshoreProfile, actualCalculation.InputParameters.ForeshoreProfile);
Assert.AreEqual(expectedCalculation.InputParameters.ShouldIllustrationPointsBeCalculated, actualCalculation.InputParameters.ShouldIllustrationPointsBeCalculated);
Assert.AreSame(expectedCalculation.InputParameters.Structure, actualCalculation.InputParameters.Structure);
Assert.AreEqual(expectedCalculation.InputParameters.UseForeshore, actualCalculation.InputParameters.UseForeshore);
Assert.AreEqual(expectedCalculation.InputParameters.UseBreakWater, actualCalculation.InputParameters.UseBreakWater);
Assert.AreEqual(expectedCalculation.InputParameters.BreakWater.Height, actualCalculation.InputParameters.BreakWater.Height);
Assert.AreEqual(expectedCalculation.InputParameters.BreakWater.Type, actualCalculation.InputParameters.BreakWater.Type);
DistributionAssert.AreEqual(expectedCalculation.InputParameters.StormDuration, actualCalculation.InputParameters.StormDuration);
DistributionAssert.AreEqual(expectedCalculation.InputParameters.ModelFactorSuperCriticalFlow, actualCalculation.InputParameters.ModelFactorSuperCriticalFlow);
DistributionAssert.AreEqual(expectedCalculation.InputParameters.FlowWidthAtBottomProtection, actualCalculation.InputParameters.FlowWidthAtBottomProtection);
DistributionAssert.AreEqual(expectedCalculation.InputParameters.WidthFlowApertures, actualCalculation.InputParameters.WidthFlowApertures);
DistributionAssert.AreEqual(expectedCalculation.InputParameters.StorageStructureArea, actualCalculation.InputParameters.StorageStructureArea);
DistributionAssert.AreEqual(expectedCalculation.InputParameters.AllowedLevelIncreaseStorage, actualCalculation.InputParameters.AllowedLevelIncreaseStorage);
DistributionAssert.AreEqual(expectedCalculation.InputParameters.CriticalOvertoppingDischarge, actualCalculation.InputParameters.CriticalOvertoppingDischarge);
DistributionAssert.AreEqual(expectedCalculation.InputParameters.LevelCrestStructureNotClosing, actualCalculation.InputParameters.LevelCrestStructureNotClosing);
DistributionAssert.AreEqual(expectedCalculation.InputParameters.AreaFlowApertures, actualCalculation.InputParameters.AreaFlowApertures);
DistributionAssert.AreEqual(expectedCalculation.InputParameters.DrainCoefficient, actualCalculation.InputParameters.DrainCoefficient);
DistributionAssert.AreEqual(expectedCalculation.InputParameters.InsideWaterLevel, actualCalculation.InputParameters.InsideWaterLevel);
DistributionAssert.AreEqual(expectedCalculation.InputParameters.ThresholdHeightOpenWeir, actualCalculation.InputParameters.ThresholdHeightOpenWeir);
}
public void Constructor_ExpectedValues()
{
// Setup
var phreaticLevelExit = new NormalDistribution(3)
{
Mean = (RoundedDouble)0,
StandardDeviation = (RoundedDouble)0.1
};
var dampingFactorExit = new LogNormalDistribution(3)
{
Mean = (RoundedDouble)0.7,
StandardDeviation = (RoundedDouble)0.1
};
// Call
var pipingInput = new TestPipingInput();
// Assert
Assert.IsInstanceOf <CloneableObservable>(pipingInput);
Assert.IsInstanceOf <ICalculationInputWithHydraulicBoundaryLocation>(pipingInput);
DistributionAssert.AreEqual(phreaticLevelExit, pipingInput.PhreaticLevelExit);
DistributionAssert.AreEqual(dampingFactorExit, pipingInput.DampingFactorExit);
Assert.IsNull(pipingInput.SurfaceLine);
Assert.IsNull(pipingInput.StochasticSoilModel);
Assert.IsNull(pipingInput.StochasticSoilProfile);
Assert.IsNull(pipingInput.HydraulicBoundaryLocation);
Assert.IsNaN(pipingInput.ExitPointL);
Assert.AreEqual(2, pipingInput.ExitPointL.NumberOfDecimalPlaces);
Assert.IsNaN(pipingInput.EntryPointL);
Assert.AreEqual(2, pipingInput.EntryPointL.NumberOfDecimalPlaces);
}
public void Constructor_ExpectedValues()
{
// Setup
var modelFactorStorageVolume = new LogNormalDistribution(2)
{
Mean = (RoundedDouble)1,
StandardDeviation = (RoundedDouble)0.2
};
var modelFactorCollisionLoad = new VariationCoefficientNormalDistribution(1)
{
Mean = (RoundedDouble)1,
CoefficientOfVariation = (RoundedDouble)0.2
};
var modelFactorLoadEffect = new NormalDistribution(2)
{
Mean = (RoundedDouble)1,
StandardDeviation = (RoundedDouble)0.05
};
var modelFactorLongThreshold = new NormalDistribution(2)
{
Mean = (RoundedDouble)0.9,
StandardDeviation = (RoundedDouble)0.05
};
// Call
var inputParameters = new GeneralStabilityPointStructuresInput();
// Assert
Assert.AreEqual(2, inputParameters.N.NumberOfDecimalPlaces);
Assert.AreEqual(3.0, inputParameters.N, inputParameters.N.GetAccuracy());
Assert.IsFalse(inputParameters.ApplyLengthEffectInSection);
Assert.AreEqual(2, inputParameters.GravitationalAcceleration.NumberOfDecimalPlaces);
Assert.AreEqual(9.81, inputParameters.GravitationalAcceleration, inputParameters.GravitationalAcceleration.GetAccuracy());
DistributionAssert.AreEqual(modelFactorStorageVolume, inputParameters.ModelFactorStorageVolume);
DistributionAssert.AreEqual(modelFactorCollisionLoad, inputParameters.ModelFactorCollisionLoad);
DistributionAssert.AreEqual(modelFactorLoadEffect, inputParameters.ModelFactorLoadEffect);
DistributionAssert.AreEqual(modelFactorLongThreshold, inputParameters.ModelFactorLongThreshold);
Assert.AreEqual(2, inputParameters.ModelFactorInflowVolume.NumberOfDecimalPlaces);
Assert.AreEqual(1, inputParameters.ModelFactorInflowVolume, inputParameters.ModelFactorInflowVolume.GetAccuracy());
Assert.AreEqual(0, inputParameters.ModificationFactorWavesSlowlyVaryingPressureComponent.NumberOfDecimalPlaces);
Assert.AreEqual(1, inputParameters.ModificationFactorWavesSlowlyVaryingPressureComponent, inputParameters.ModificationFactorWavesSlowlyVaryingPressureComponent.GetAccuracy());
Assert.AreEqual(0, inputParameters.ModificationFactorDynamicOrImpulsivePressureComponent.NumberOfDecimalPlaces);
Assert.AreEqual(1, inputParameters.ModificationFactorDynamicOrImpulsivePressureComponent, inputParameters.ModificationFactorDynamicOrImpulsivePressureComponent.GetAccuracy());
Assert.AreEqual(2, inputParameters.WaveRatioMaxHN.NumberOfDecimalPlaces);
Assert.AreEqual(5000, inputParameters.WaveRatioMaxHN, inputParameters.WaveRatioMaxHN.GetAccuracy());
Assert.AreEqual(2, inputParameters.WaveRatioMaxHStandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.5, inputParameters.WaveRatioMaxHStandardDeviation, inputParameters.WaveRatioMaxHStandardDeviation.GetAccuracy());
}
public void DefaultConstructor_DefaultValuesSet()
{
// Call
var data = new MacroStabilityInwardsSoilLayerData();
// Assert
Assert.IsFalse(data.IsAquifer);
Assert.IsEmpty(data.MaterialName);
Assert.AreEqual(Color.Empty, data.Color);
Assert.IsFalse(data.UsePop);
Assert.AreEqual(MacroStabilityInwardsShearStrengthModel.CPhi, data.ShearStrengthModel);
DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN,
Shift = RoundedDouble.NaN
}, data.AbovePhreaticLevel);
DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN,
Shift = RoundedDouble.NaN
}, data.BelowPhreaticLevel);
DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
}, data.Cohesion);
DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
}, data.FrictionAngle);
DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
}, data.ShearStrengthRatio);
DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
}, data.StrengthIncreaseExponent);
DistributionAssert.AreEqual(new VariationCoefficientLogNormalDistribution(2)
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
}, data.Pop);
}
public void Import_MissingParametersAndDuplicateIrrelevantParameter_LogWarningAndContinueImportWithDefaultValues()
{
// Setup
var importTarget = new StructureCollection <ClosingStructure>();
string filePath = Path.Combine(testDataPath, nameof(ClosingStructuresImporter),
"MissingAndDuplicateIrrelevantParameters", "Kunstwerken.shp");
var messageProvider = mocks.Stub <IImporterMessageProvider>();
var updateStrategy = mocks.StrictMock <IStructureUpdateStrategy <ClosingStructure> >();
updateStrategy.Expect(u => u.UpdateStructuresWithImportedData(null, null)).IgnoreArguments().WhenCalled(i =>
{
Assert.AreEqual(filePath, i.Arguments[1]);
var defaultStructure = new ClosingStructure(new ClosingStructure.ConstructionProperties
{
Name = "test",
Location = new Point2D(0, 0),
Id = "id"
});
var readStructures = (IEnumerable <ClosingStructure>)i.Arguments[0];
Assert.AreEqual(1, readStructures.Count());
ClosingStructure importedStructure = readStructures.First();
DistributionAssert.AreEqual(defaultStructure.StorageStructureArea, importedStructure.StorageStructureArea);
DistributionAssert.AreEqual(defaultStructure.LevelCrestStructureNotClosing, importedStructure.LevelCrestStructureNotClosing);
DistributionAssert.AreEqual(defaultStructure.AreaFlowApertures, importedStructure.AreaFlowApertures);
Assert.AreEqual(defaultStructure.FailureProbabilityReparation, importedStructure.FailureProbabilityReparation);
});
mocks.ReplayAll();
ReferenceLine referenceLine = CreateReferenceLine();
var structuresImporter = new ClosingStructuresImporter(importTarget, referenceLine,
filePath, messageProvider, updateStrategy);
// Call
var importResult = false;
Action call = () => importResult = structuresImporter.Import();
// Assert
TestHelper.AssertLogMessages(call, msgs =>
{
string[] messages = msgs.ToArray();
Assert.AreEqual(10, messages.Length);
const string structure = "'Coupure Den Oever (90k1)' (KUNST1)";
Assert.AreEqual($"Geen definitie gevonden voor parameter 'KW_BETSLUIT1' van kunstwerk {structure}. Er wordt een standaard waarde gebruikt.", messages[0]);
Assert.AreEqual($"Geen definitie gevonden voor parameter 'KW_BETSLUIT5' van kunstwerk {structure}. Er wordt een standaard waarde gebruikt.", messages[3]);
Assert.AreEqual($"Geen definitie gevonden voor parameter 'KW_BETSLUIT8' van kunstwerk {structure}. Er wordt een standaard waarde gebruikt.", messages[6]);
Assert.AreEqual($"Geen definitie gevonden voor parameter 'KW_BETSLUIT14' van kunstwerk {structure}. Er wordt een standaard waarde gebruikt.", messages[8]);
// Don't care about the other messages.
});
Assert.IsTrue(importResult);
}
public void Import_MissingParametersAndDuplicateIrrelevantParameter_LogWarningAndContinueImport()
{
// Setup
var importTarget = new StructureCollection <HeightStructure>();
string filePath = Path.Combine(testDataPath, nameof(HeightStructuresImporter),
"MissingAndDuplicateIrrelevantParameters", "Kunstwerken.shp");
var messageProvider = mocks.Stub <IImporterMessageProvider>();
var strategy = mocks.StrictMock <IStructureUpdateStrategy <HeightStructure> >();
strategy.Expect(s => s.UpdateStructuresWithImportedData(null, null)).IgnoreArguments()
.WhenCalled(invocation =>
{
Assert.AreSame(invocation.Arguments[1], filePath);
var readStructures = (IEnumerable <HeightStructure>)invocation.Arguments[0];
Assert.AreEqual(1, readStructures.Count());
HeightStructure structure = readStructures.First();
var defaultStructure = new HeightStructure(new HeightStructure.ConstructionProperties
{
Name = "test",
Location = new Point2D(0, 0),
Id = "id"
});
Assert.AreEqual(defaultStructure.StructureNormalOrientation, structure.StructureNormalOrientation);
DistributionAssert.AreEqual(defaultStructure.FlowWidthAtBottomProtection, structure.FlowWidthAtBottomProtection);
Assert.AreEqual(defaultStructure.FailureProbabilityStructureWithErosion, structure.FailureProbabilityStructureWithErosion);
})
.Return(Enumerable.Empty <IObservable>());
mocks.ReplayAll();
ReferenceLine referenceLine = CreateReferenceLine();
var importer = new HeightStructuresImporter(importTarget, referenceLine, filePath,
messageProvider, strategy);
var importResult = false;
// Call
Action call = () => importResult = importer.Import();
// Assert
TestHelper.AssertLogMessages(call, msgs =>
{
string[] messages = msgs.ToArray();
Assert.AreEqual(5, messages.Length);
const string structure = "'Coupure Den Oever (90k1)' (KUNST1)";
Assert.AreEqual($"Geen definitie gevonden voor parameter 'KW_HOOGTE1' van kunstwerk {structure}. Er wordt een standaard waarde gebruikt.", messages[0]);
Assert.AreEqual($"Geen definitie gevonden voor parameter 'KW_HOOGTE3' van kunstwerk {structure}. Er wordt een standaard waarde gebruikt.", messages[1]);
Assert.AreEqual($"Geen definitie gevonden voor parameter 'KW_HOOGTE6' van kunstwerk {structure}. Er wordt een standaard waarde gebruikt.", messages[2]);
// Don't care about the other message.
});
Assert.IsTrue(importResult);
}
private static void AssertPipingSoilLayer(PipingSoilLayer expected, PipingSoilLayer actual)
{
Assert.AreEqual(expected.Top, actual.Top);
Assert.AreEqual(expected.IsAquifer, actual.IsAquifer);
DistributionAssert.AreEqual(expected.BelowPhreaticLevel, actual.BelowPhreaticLevel);
DistributionAssert.AreEqual(expected.DiameterD70, actual.DiameterD70);
DistributionAssert.AreEqual(expected.Permeability, actual.Permeability);
Assert.AreEqual(expected.MaterialName, actual.MaterialName);
Assert.AreEqual(expected.Color, actual.Color);
}
private static void AssertEffectiveThicknessCoverageLayer(LogNormalDistribution effectiveThicknessCoverageLayer, double mean = double.NaN)
{
var expected = new LogNormalDistribution(2)
{
Mean = (RoundedDouble)mean,
StandardDeviation = (RoundedDouble)0.5
};
DistributionAssert.AreEqual(expected, effectiveThicknessCoverageLayer);
}
private static void AssertThicknessAquiferLayer(LogNormalDistribution thicknessAquiferLayer, double mean = double.NaN)
{
var expected = new LogNormalDistribution(2)
{
Mean = (RoundedDouble)mean,
StandardDeviation = (RoundedDouble)0.5
};
DistributionAssert.AreEqual(expected, thicknessAquiferLayer);
}
private static void AssertSeepageLength(VariationCoefficientLogNormalDistribution seepageLength, double mean = double.NaN)
{
var expected = new VariationCoefficientLogNormalDistribution(2)
{
Mean = (RoundedDouble)mean,
CoefficientOfVariation = (RoundedDouble)0.1
};
DistributionAssert.AreEqual(expected, seepageLength);
}
private static void AssertDarcyPermeability(VariationCoefficientLogNormalDistribution darcyPermeability,
double mean = double.NaN,
double standardDeviation = double.NaN)
{
var expected = new VariationCoefficientLogNormalDistribution(6)
{
Mean = (RoundedDouble)mean,
CoefficientOfVariation = (RoundedDouble)standardDeviation
};
DistributionAssert.AreEqual(expected, darcyPermeability);
}
private static void AssertDiameterD70(VariationCoefficientLogNormalDistribution diameterD70,
double mean = double.NaN,
double coefficientOfVariation = double.NaN)
{
var expected = new VariationCoefficientLogNormalDistribution(6)
{
Mean = (RoundedDouble)mean,
CoefficientOfVariation = (RoundedDouble)coefficientOfVariation
};
DistributionAssert.AreEqual(expected, diameterD70);
}
public void GetUpliftModelFactorDesignVariable_GeneralPipingInput_CreateDeterministicDesignVariableForUpliftModelFactor()
{
// Setup
var generalPipingInput = new GeneralPipingInput();
// Call
DeterministicDesignVariable <LogNormalDistribution> upliftModelFactor = SemiProbabilisticPipingDesignVariableFactory.GetUpliftModelFactorDesignVariable(generalPipingInput);
// Assert
DistributionAssert.AreEqual(generalPipingInput.UpliftModelFactor, upliftModelFactor.Distribution);
Assert.AreEqual(generalPipingInput.UpliftModelFactor.Mean, upliftModelFactor.GetDesignValue());
}
public void GetCriticalHeaveGradientDesignVariable_GeneralPipingInput_CreateDeterministicDesignVariableForCriticalHeaveGradient()
{
// Setup
var generalPipingInput = new GeneralPipingInput();
// Call
DeterministicDesignVariable <LogNormalDistribution> criticalHeaveGradient = SemiProbabilisticPipingDesignVariableFactory.GetCriticalHeaveGradientDesignVariable(generalPipingInput);
// Assert
DistributionAssert.AreEqual(generalPipingInput.CriticalHeaveGradient, criticalHeaveGradient.Distribution);
Assert.AreEqual(0.3, criticalHeaveGradient.GetDesignValue());
}
public void GetThicknessCoverageLayer_PipingInputWithoutCoverLayer_CreateDeterministicDesignVariableForThicknessCoverageLayer()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
DesignVariable <LogNormalDistribution> thicknessCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetThicknessCoverageLayer(pipingInput);
// Assert
Assert.IsInstanceOf <DeterministicDesignVariable <LogNormalDistribution> >(thicknessCoverageLayer);
DistributionAssert.AreEqual(DerivedPipingInput.GetThicknessCoverageLayer(pipingInput), thicknessCoverageLayer.Distribution);
Assert.AreEqual(new RoundedDouble(2), thicknessCoverageLayer.GetDesignValue());
}
public void GetThicknessCoverageLayer_PipingInputWithCoverLayer_CreatePercentileBasedDesignVariableForThicknessCoverageLayer()
{
// Setup
PipingInput pipingInput = PipingInputFactory.CreateInputWithAquiferAndCoverageLayer <TestPipingInput>();
// Call
DesignVariable <LogNormalDistribution> thicknessCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetThicknessCoverageLayer(pipingInput);
// Assert
Assert.IsInstanceOf <PercentileBasedDesignVariable <LogNormalDistribution> >(thicknessCoverageLayer);
DistributionAssert.AreEqual(DerivedPipingInput.GetThicknessCoverageLayer(pipingInput), thicknessCoverageLayer.Distribution);
AssertPercentile(0.05, thicknessCoverageLayer);
}
public void GetThicknessAquiferLayer_ValidPipingInput_CreateDesignVariableForThicknessAquiferLayer()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
DesignVariable <LogNormalDistribution> thicknessAquiferLayer =
SemiProbabilisticPipingDesignVariableFactory.GetThicknessAquiferLayer(pipingInput);
// Assert
DistributionAssert.AreEqual(DerivedPipingInput.GetThicknessAquiferLayer(pipingInput), thicknessAquiferLayer.Distribution);
AssertPercentile(0.95, thicknessAquiferLayer);
}
public void GetDarcyPermeability_ValidPipingInput_CreateDesignVariableForDarcyPermeability()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
VariationCoefficientDesignVariable <VariationCoefficientLogNormalDistribution> darcyPermeability =
SemiProbabilisticPipingDesignVariableFactory.GetDarcyPermeability(pipingInput);
// Assert
DistributionAssert.AreEqual(DerivedPipingInput.GetDarcyPermeability(pipingInput), darcyPermeability.Distribution);
AssertPercentile(0.95, darcyPermeability);
}
public void GetDiameter70_ValidPipingInput_CreateDesignVariableForDiameter70()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
VariationCoefficientDesignVariable <VariationCoefficientLogNormalDistribution> d70 =
SemiProbabilisticPipingDesignVariableFactory.GetDiameter70(pipingInput);
// Assert
DistributionAssert.AreEqual(DerivedPipingInput.GetDiameterD70(pipingInput), d70.Distribution);
AssertPercentile(0.05, d70);
}
public void GetSeepageLength_ValidPipingInput_CreateDesignVariableForSeepageLength()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
VariationCoefficientDesignVariable <VariationCoefficientLogNormalDistribution> seepageLength =
SemiProbabilisticPipingDesignVariableFactory.GetSeepageLength(pipingInput);
// Assert
DistributionAssert.AreEqual(DerivedPipingInput.GetSeepageLength(pipingInput), seepageLength.Distribution);
AssertPercentile(0.05, seepageLength);
}
public void Constructor_ExpectedValues()
{
// Setup
var fbFactor = new TruncatedNormalDistribution(2)
{
Mean = (RoundedDouble)4.75,
StandardDeviation = (RoundedDouble)0.5,
LowerBoundary = (RoundedDouble)0.0,
UpperBoundary = (RoundedDouble)99.0
};
var fnFactor = new TruncatedNormalDistribution(2)
{
Mean = (RoundedDouble)2.6,
StandardDeviation = (RoundedDouble)0.35,
LowerBoundary = (RoundedDouble)0.0,
UpperBoundary = (RoundedDouble)99.0
};
var fshallow = new TruncatedNormalDistribution(2)
{
Mean = (RoundedDouble)0.92,
StandardDeviation = (RoundedDouble)0.24,
LowerBoundary = (RoundedDouble)0.0,
UpperBoundary = (RoundedDouble)99.0
};
var frunupModelFactor = new TruncatedNormalDistribution(2)
{
Mean = (RoundedDouble)1,
StandardDeviation = (RoundedDouble)0.07,
LowerBoundary = (RoundedDouble)0.0,
UpperBoundary = (RoundedDouble)99.0
};
// Call
var inputParameters = new GeneralGrassCoverErosionInwardsInput();
// Assert
Assert.AreEqual(2, inputParameters.N.NumberOfDecimalPlaces);
Assert.AreEqual(2.0, inputParameters.N, inputParameters.N.GetAccuracy());
Assert.IsFalse(inputParameters.ApplyLengthEffectInSection);
DistributionAssert.AreEqual(fbFactor, inputParameters.FbFactor);
DistributionAssert.AreEqual(fnFactor, inputParameters.FnFactor);
DistributionAssert.AreEqual(fshallow, inputParameters.FshallowModelFactor);
DistributionAssert.AreEqual(frunupModelFactor, inputParameters.FrunupModelFactor);
Assert.AreEqual(1, inputParameters.CriticalOvertoppingModelFactor);
Assert.AreEqual(1, inputParameters.OvertoppingModelFactor);
}
