private static void AssertCalculatorInput(GeneralPipingInput generalInput, ProbabilisticPipingInput input, double sectionLength, PipingCalculationInput actualInput)
{
LogNormalDistribution effectiveThicknessCoverageLayer = DerivedPipingInput.GetEffectiveThicknessCoverageLayer(input, generalInput);
LogNormalDistribution saturatedVolumicWeightOfCoverageLayer = DerivedPipingInput.GetSaturatedVolumicWeightOfCoverageLayer(input);
VariationCoefficientLogNormalDistribution seepageLength = DerivedPipingInput.GetSeepageLength(input);
LogNormalDistribution thicknessAquiferLayer = DerivedPipingInput.GetThicknessAquiferLayer(input);
VariationCoefficientLogNormalDistribution darcyPermeability = DerivedPipingInput.GetDarcyPermeability(input);
VariationCoefficientLogNormalDistribution diameterD70 = DerivedPipingInput.GetDiameterD70(input);
var expectedInput = new PipingCalculationInput(
1300001,
sectionLength,
input.PhreaticLevelExit.Mean, input.PhreaticLevelExit.StandardDeviation,
generalInput.WaterVolumetricWeight,
effectiveThicknessCoverageLayer.Mean, effectiveThicknessCoverageLayer.StandardDeviation,
saturatedVolumicWeightOfCoverageLayer.Mean, saturatedVolumicWeightOfCoverageLayer.StandardDeviation,
saturatedVolumicWeightOfCoverageLayer.Shift,
generalInput.UpliftModelFactor.Mean, generalInput.UpliftModelFactor.StandardDeviation,
input.DampingFactorExit.Mean, input.DampingFactorExit.StandardDeviation,
seepageLength.Mean, seepageLength.CoefficientOfVariation,
thicknessAquiferLayer.Mean, thicknessAquiferLayer.StandardDeviation,
generalInput.SandParticlesVolumicWeight,
generalInput.SellmeijerModelFactor.Mean, generalInput.SellmeijerModelFactor.StandardDeviation,
generalInput.BeddingAngle,
generalInput.WhitesDragCoefficient,
generalInput.WaterKinematicViscosity,
darcyPermeability.Mean, darcyPermeability.CoefficientOfVariation,
diameterD70.Mean, diameterD70.CoefficientOfVariation,
generalInput.Gravity,
generalInput.CriticalHeaveGradient.Mean, generalInput.CriticalHeaveGradient.StandardDeviation);
HydraRingDataEqualityHelper.AreEqual(expectedInput, actualInput);
}
public void Calculate_Always_InputPropertiesCorrectlySentToCalculator(BreakWaterType breakWaterType)
{
// Setup
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
WaveImpactAsphaltCoverWaveConditionsCalculation calculation = GetValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
calculation.InputParameters.BreakWater.Type = breakWaterType;
var waveImpactAsphaltCoverFailureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var calculator = new TestWaveConditionsCosineCalculator();
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null))
.IgnoreArguments()
.Return(calculator)
.Repeat
.Times(3);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new WaveImpactAsphaltCoverWaveConditionsCalculationService().Calculate(
calculation,
assessmentSection,
waveImpactAsphaltCoverFailureMechanism.GeneralInput);
// Assert
WaveConditionsCosineCalculationInput[] waveConditionsInputs = calculator.ReceivedInputs.ToArray();
Assert.AreEqual(3, waveConditionsInputs.Length);
var waterLevelIndex = 0;
foreach (WaveConditionsCosineCalculationInput actualInput in waveConditionsInputs)
{
GeneralWaveConditionsInput generalInput = waveImpactAsphaltCoverFailureMechanism.GeneralInput;
WaveConditionsInput input = calculation.InputParameters;
var expectedInput = new WaveConditionsCosineCalculationInput(1,
input.Orientation,
input.HydraulicBoundaryLocation.Id,
assessmentSection.FailureMechanismContribution.MaximumAllowableFloodingProbability,
input.ForeshoreProfile.Geometry.Select(c => new HydraRingForelandPoint(c.X, c.Y)),
new HydraRingBreakWater(BreakWaterTypeHelper.GetHydraRingBreakWaterType(breakWaterType), input.BreakWater.Height),
GetWaterLevels(calculation, assessmentSection).ElementAt(waterLevelIndex++),
generalInput.A,
generalInput.B,
generalInput.C);
HydraRingDataEqualityHelper.AreEqual(expectedInput, actualInput);
}
}
mockRepository.VerifyAll();
}
public void Calculate_WithoutBreakWater_StartsCalculationWithRightParameters(bool useForeshore)
{
// Setup
var waterLevel = (RoundedDouble)4.20;
var a = (RoundedDouble)1.0;
var b = (RoundedDouble)0.8;
var c = (RoundedDouble)0.4;
const double targetProbability = 0.2;
var input = new WaveConditionsInput
{
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(),
ForeshoreProfile = new TestForeshoreProfile(true),
UpperBoundaryRevetment = (RoundedDouble)4,
LowerBoundaryRevetment = (RoundedDouble)3,
StepSize = WaveConditionsInputStepSize.Two,
UseBreakWater = false,
UseForeshore = useForeshore,
Orientation = (RoundedDouble)0
};
var calculator = new TestWaveConditionsCosineCalculator();
RoundedDouble[] waterLevels = input.GetWaterLevels(waterLevel).ToArray();
int nrOfCalculators = waterLevels.Length;
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null))
.IgnoreArguments()
.Return(calculator)
.Repeat
.Times(nrOfCalculators);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new TestWaveConditionsCalculationService().PublicCalculate(a,
b,
c,
targetProbability,
input,
waterLevel,
GetValidHydraulicBoundaryDatabase());
// Assert
for (var i = 0; i < nrOfCalculators; i++)
{
WaveConditionsCosineCalculationInput expectedInput = CreateInput(waterLevels[i], a, b, c, targetProbability, input, useForeshore, false);
HydraRingDataEqualityHelper.AreEqual(expectedInput, calculator.ReceivedInputs.ElementAt(i));
}
}
mockRepository.VerifyAll();
}
public void Constructor_WithoutCoverageLayerParameters_ExpectedValues()
{
// Setup
const int hydraulicBoundaryLocationId = 1000;
const double sectionLength = 1.1;
const double phreaticLevelExitMean = 2.2;
const double phreaticLevelExitStandardDeviation = 3.3;
const double waterVolumetricWeight = 4.4;
const double upliftModelFactorMean = 10.0;
const double upliftModelFactorStandardDeviation = 11.1;
const double dampingFactorExitMean = 12.2;
const double dampingFactorExitStandardDeviation = 13.3;
const double seepageLengthMean = 14.4;
const double seepageLengthCoefficientOfVariation = 15.5;
const double thicknessAquiferLayerMean = 16.6;
const double thicknessAquiferLayerStandardDeviation = 17.7;
const double sandParticlesVolumicWeight = 18.8;
const double sellmeijerModelFactorMean = 19.9;
const double sellmeijerModelFactorStandardDeviation = 20.0;
const double beddingAngle = 21.1;
const double whitesDragCoefficient = 22.2;
const double waterKinematicViscosity = 23.3;
const double darcyPermeabilityMean = 24.4;
const double darcyPermeabilityCoefficientOfVariation = 25.5;
const double diameter70Mean = 26.6;
const double diameter70CoefficientOfVariation = 27.7;
const double gravity = 28.8;
const double criticalHeaveGradientMean = 29.9;
const double criticalHeaveGradientStandardDeviation = 30.0;
// Call
var pipingCalculationInput = new PipingCalculationInput(
hydraulicBoundaryLocationId, sectionLength, phreaticLevelExitMean, phreaticLevelExitStandardDeviation,
waterVolumetricWeight, upliftModelFactorMean, upliftModelFactorStandardDeviation, dampingFactorExitMean,
dampingFactorExitStandardDeviation, seepageLengthMean, seepageLengthCoefficientOfVariation,
thicknessAquiferLayerMean, thicknessAquiferLayerStandardDeviation, sandParticlesVolumicWeight,
sellmeijerModelFactorMean, sellmeijerModelFactorStandardDeviation, beddingAngle, whitesDragCoefficient,
waterKinematicViscosity, darcyPermeabilityMean, darcyPermeabilityCoefficientOfVariation, diameter70Mean,
diameter70CoefficientOfVariation, gravity, criticalHeaveGradientMean, criticalHeaveGradientStandardDeviation);
// Assert
Assert.IsInstanceOf <ExceedanceProbabilityCalculationInput>(pipingCalculationInput);
Assert.AreEqual(1, pipingCalculationInput.CalculationTypeId);
Assert.AreEqual(HydraRingFailureMechanismType.Piping, pipingCalculationInput.FailureMechanismType);
Assert.AreEqual(58, pipingCalculationInput.VariableId);
Assert.AreEqual(3014, pipingCalculationInput.FaultTreeModelId);
Assert.AreEqual(hydraulicBoundaryLocationId, pipingCalculationInput.HydraulicBoundaryLocationId);
HydraRingDataEqualityHelper.AreEqual(GetDefaultPipingVariables(false).ToArray(), pipingCalculationInput.Variables.ToArray());
Assert.IsNaN(pipingCalculationInput.Beta);
HydraRingSection hydraRingSection = pipingCalculationInput.Section;
Assert.AreEqual(1, hydraRingSection.SectionId);
Assert.AreEqual(sectionLength, hydraRingSection.SectionLength);
Assert.IsNaN(hydraRingSection.CrossSectionNormal);
}
public void Constructor_Always_ExpectedValues()
{
// Setup
const int sectionId = 111;
const double sectionNormal = 90;
const int hydraulicBoundaryLocationId = 222;
const double targetProbability = 1.0 / 333;
IEnumerable <HydraRingForelandPoint> forelandPoints = Enumerable.Empty <HydraRingForelandPoint>();
var breakWater = new HydraRingBreakWater(1, 4.4);
const double waterLevel = 5.5;
const double a = 6.6;
const double b = 7.7;
const double beta1 = 8.8;
const double beta2 = 9.9;
// Call
var waveConditionsTrapezoidCalculationInput = new WaveConditionsTrapezoidCalculationInput(sectionId,
sectionNormal,
hydraulicBoundaryLocationId,
targetProbability,
forelandPoints,
breakWater,
waterLevel,
a,
b,
beta1,
beta2);
// Assert
double expectedBeta = StatisticsConverter.ProbabilityToReliability(targetProbability);
Assert.IsInstanceOf <WaveConditionsCalculationInput>(waveConditionsTrapezoidCalculationInput);
Assert.AreEqual(HydraRingFailureMechanismType.QVariant, waveConditionsTrapezoidCalculationInput.FailureMechanismType);
Assert.AreEqual(8, waveConditionsTrapezoidCalculationInput.CalculationTypeId);
Assert.AreEqual(114, waveConditionsTrapezoidCalculationInput.VariableId);
Assert.AreEqual(hydraulicBoundaryLocationId, waveConditionsTrapezoidCalculationInput.HydraulicBoundaryLocationId);
Assert.IsNotNull(waveConditionsTrapezoidCalculationInput.Section);
Assert.AreEqual(sectionId, waveConditionsTrapezoidCalculationInput.Section.SectionId);
Assert.AreEqual(sectionNormal, waveConditionsTrapezoidCalculationInput.Section.CrossSectionNormal);
HydraRingDataEqualityHelper.AreEqual(GetExpectedVariables(waterLevel, a, b, beta1, beta2).ToArray(), waveConditionsTrapezoidCalculationInput.Variables.ToArray());
Assert.AreSame(forelandPoints, waveConditionsTrapezoidCalculationInput.ForelandPoints);
Assert.AreSame(breakWater, waveConditionsTrapezoidCalculationInput.BreakWater);
Assert.AreEqual(expectedBeta, waveConditionsTrapezoidCalculationInput.Beta);
}
public void Constructor_Always_ExpectedValues()
{
// Setup
const int hydraulicBoundaryLocationId = 1000;
const double sectionNormal = 22.2;
const double dikeHeight = 1.1;
const double modelFactorCriticalOvertopping = 2.2;
const double factorFbMean = 3.3;
const double factorFbStandardDeviation = 4.4;
const double factorFbLowerBoundary = 14.4;
const double factorFbUpperBoundary = 15.5;
const double factorFnMean = 5.5;
const double factorFnStandardDeviation = 6.6;
const double factorFnLowerBoundary = 16.6;
const double factorFnUpperBoundary = 17.7;
const double modelFactorOvertopping = 7.7;
const double criticalOvertoppingMean = 8.8;
const double criticalOvertoppingStandardDeviation = 9.9;
const double modelFactorFrunupMean = 10.0;
const double modelFactorFrunupStandardDeviation = 11.1;
const double modelFactorFrunupLowerBoundary = 18.8;
const double modelFactorFrunupUpperBoundary = 19.9;
const double exponentModelFactorShallowMean = 12.2;
const double exponentModelFactorShallowStandardDeviation = 13.3;
const double exponentModelFactorShallowLowerBoundary = 20.0;
const double exponentModelFactorShallowUpperBoundary = 21.1;
var expectedRingProfilePoints = new List <HydraRingRoughnessProfilePoint>
{
new HydraRingRoughnessProfilePoint(1.1, 2.2, 3.3)
};
var expectedRingForelandPoints = new List <HydraRingForelandPoint>
{
new HydraRingForelandPoint(2.2, 3.3)
};
var expectedRingBreakWater = new HydraRingBreakWater(2, 3.3);
// Call
var overtoppingCalculationInput = new OvertoppingCalculationInput(
hydraulicBoundaryLocationId, sectionNormal,
expectedRingProfilePoints, expectedRingForelandPoints, expectedRingBreakWater,
dikeHeight,
modelFactorCriticalOvertopping,
factorFbMean, factorFbStandardDeviation,
factorFbLowerBoundary, factorFbUpperBoundary,
factorFnMean, factorFnStandardDeviation,
factorFnLowerBoundary, factorFnUpperBoundary,
modelFactorOvertopping,
criticalOvertoppingMean, criticalOvertoppingStandardDeviation,
modelFactorFrunupMean, modelFactorFrunupStandardDeviation,
modelFactorFrunupLowerBoundary, modelFactorFrunupUpperBoundary,
exponentModelFactorShallowMean, exponentModelFactorShallowStandardDeviation,
exponentModelFactorShallowLowerBoundary, exponentModelFactorShallowUpperBoundary);
// Assert
Assert.IsInstanceOf <ExceedanceProbabilityCalculationInput>(overtoppingCalculationInput);
Assert.AreEqual(1, overtoppingCalculationInput.CalculationTypeId);
Assert.AreEqual(HydraRingFailureMechanismType.DikesOvertopping, overtoppingCalculationInput.FailureMechanismType);
Assert.AreEqual(1, overtoppingCalculationInput.VariableId);
Assert.AreEqual(1017, overtoppingCalculationInput.FaultTreeModelId);
Assert.AreEqual(hydraulicBoundaryLocationId, overtoppingCalculationInput.HydraulicBoundaryLocationId);
HydraRingDataEqualityHelper.AreEqual(GetDefaultOvertoppingVariables().ToArray(), overtoppingCalculationInput.Variables.ToArray());
CollectionAssert.AreEqual(expectedRingProfilePoints, overtoppingCalculationInput.ProfilePoints);
CollectionAssert.AreEqual(expectedRingForelandPoints, overtoppingCalculationInput.ForelandPoints);
Assert.AreEqual(expectedRingBreakWater, overtoppingCalculationInput.BreakWater);
Assert.IsNaN(overtoppingCalculationInput.Beta);
HydraRingSection hydraRingSection = overtoppingCalculationInput.Section;
Assert.AreEqual(1, hydraRingSection.SectionId);
Assert.IsNaN(hydraRingSection.SectionLength);
Assert.AreEqual(sectionNormal, hydraRingSection.CrossSectionNormal);
}
public void Constructor_ExpectedValues()
{
// Setup
const int hydraulicBoundaryLocationId = 1000;
IEnumerable <HydraRingForelandPoint> forelandPoints = Enumerable.Empty <HydraRingForelandPoint>();
var breakWater = new HydraRingBreakWater(1, 1.1);
const double sectionNormal = 52.2;
const double volumicWeightWater = 1.1;
const double gravitationalAcceleration = 2.2;
const double levelCrestStructureMean = 3.3;
const double levelCrestStructureStandardDeviation = 4.4;
const double structureNormalOrientation = 5.5;
const double factorStormDurationOpenStructure = 6.6;
const double thresholdHeightOpenWeirMean = 7.7;
const double thresholdHeightOpenWeirStandardDeviation = 8.8;
const double insideWaterLevelFailureConstructionMean = 9.9;
const double insideWaterLevelFailureConstructionStandardDeviation = 10.10;
const double failureProbabilityRepairClosure = 11.11;
const double failureCollisionEnergyMean = 12.12;
const double failureCollisionEnergyVariation = 13.13;
const double modelFactorCollisionLoadMean = 14.14;
const double modelFactorCollisionLoadVariation = 15.15;
const double shipMassMean = 16.16;
const double shipMassVariation = 17.17;
const double shipVelocityMean = 18.18;
const double shipVelocityVariation = 19.19;
const int levellingCount = 20;
const double probabilityCollisionSecondaryStructure = 21.21;
const double flowVelocityStructureClosableMean = 22.22;
const double flowVelocityStructureClosableVariation = 23.23;
const double insideWaterLevelMean = 24.24;
const double insideWaterLevelStandardDeviation = 25.25;
const double allowedLevelIncreaseStorageMean = 26.26;
const double allowedLevelIncreaseStorageStandardDeviation = 27.27;
const double modelFactorStorageVolumeMean = 28.28;
const double modelFactorStorageVolumeStandardDeviation = 29.29;
const double storageStructureAreaMean = 30.30;
const double storageStructureAreaVariation = 31.31;
const double modelFactorInflowVolume = 32.32;
const double flowWidthAtBottomProtectionMean = 33.33;
const double flowWidthAtBottomProtectionStandardDeviation = 34.34;
const double criticalOvertoppingDischargeMean = 35.35;
const double criticalOvertoppingDischargeVariation = 36.36;
const double failureProbabilityStructureWithErosion = 37.37;
const double stormDurationMean = 38.38;
const double stormDurationVariation = 39.39;
const double modelFactorLongThresholdMean = 40.40;
const double modelFactorLongThresholdStandardDeviation = 41.41;
const double bankWidthMean = 42.42;
const double bankWidthStandardDeviation = 43.43;
const double evaluationLevel = 44.44;
const double modelFactorLoadEffectMean = 45.45;
const double modelFactorLoadEffectStandardDeviation = 46.46;
const double waveRatioMaxHN = 47.47;
const double waveRatioMaxHStandardDeviation = 48.48;
const double verticalDistance = 49.49;
const double modificationFactorWavesSlowlyVaryingPressureComponent = 50.50;
const double modificationFactorDynamicOrImpulsivePressureComponent = 51.51;
// Call
var input = new TestStructuresStabilityPointCalculationInput(hydraulicBoundaryLocationId, sectionNormal,
forelandPoints, breakWater,
volumicWeightWater,
gravitationalAcceleration,
levelCrestStructureMean, levelCrestStructureStandardDeviation,
structureNormalOrientation,
factorStormDurationOpenStructure,
thresholdHeightOpenWeirMean, thresholdHeightOpenWeirStandardDeviation,
insideWaterLevelFailureConstructionMean, insideWaterLevelFailureConstructionStandardDeviation,
failureProbabilityRepairClosure,
failureCollisionEnergyMean, failureCollisionEnergyVariation,
modelFactorCollisionLoadMean, modelFactorCollisionLoadVariation,
shipMassMean, shipMassVariation,
shipVelocityMean, shipVelocityVariation,
levellingCount,
probabilityCollisionSecondaryStructure,
flowVelocityStructureClosableMean, flowVelocityStructureClosableVariation,
insideWaterLevelMean, insideWaterLevelStandardDeviation,
allowedLevelIncreaseStorageMean, allowedLevelIncreaseStorageStandardDeviation,
modelFactorStorageVolumeMean, modelFactorStorageVolumeStandardDeviation,
storageStructureAreaMean, storageStructureAreaVariation,
modelFactorInflowVolume,
flowWidthAtBottomProtectionMean, flowWidthAtBottomProtectionStandardDeviation,
criticalOvertoppingDischargeMean, criticalOvertoppingDischargeVariation,
failureProbabilityStructureWithErosion,
stormDurationMean, stormDurationVariation,
modelFactorLongThresholdMean, modelFactorLongThresholdStandardDeviation,
bankWidthMean, bankWidthStandardDeviation,
evaluationLevel,
modelFactorLoadEffectMean, modelFactorLoadEffectStandardDeviation,
waveRatioMaxHN, waveRatioMaxHStandardDeviation,
verticalDistance,
modificationFactorWavesSlowlyVaryingPressureComponent,
modificationFactorDynamicOrImpulsivePressureComponent);
// Assert
Assert.IsInstanceOf <ExceedanceProbabilityCalculationInput>(input);
Assert.AreEqual(1, input.CalculationTypeId);
Assert.AreEqual(HydraRingFailureMechanismType.StructuresStructuralFailure, input.FailureMechanismType);
Assert.AreEqual(58, input.VariableId);
Assert.AreEqual(4607, input.FaultTreeModelId);
Assert.AreEqual(6, input.IterationMethodId);
Assert.AreEqual(hydraulicBoundaryLocationId, input.HydraulicBoundaryLocationId);
HydraRingSection section = input.Section;
Assert.AreEqual(1, section.SectionId);
Assert.IsNaN(section.SectionLength);
Assert.AreEqual(sectionNormal, section.CrossSectionNormal);
Assert.AreSame(forelandPoints, input.ForelandPoints);
Assert.AreSame(breakWater, input.BreakWater);
HydraRingDataEqualityHelper.AreEqual(GetDefaultVariables().ToArray(), input.Variables.ToArray());
}
public void Constructor_Always_ExpectedValues()
{
// Setup
const int hydraulicBoundaryLocationId = 1000;
IEnumerable <HydraRingForelandPoint> forelandPoints = Enumerable.Empty <HydraRingForelandPoint>();
var breakWater = new HydraRingBreakWater(1, 1.1);
const double sectionNormal = 26.6;
const double gravitationalAcceleration = 1.1;
const double modelFactorOvertoppingFlowMean = 2.2;
const double modelFactorOvertoppingFlowStandardDeviation = 3.3;
const double levelCrestStructureMean = 4.4;
const double levelCrestStructureStandardDeviation = 5.5;
const double structureNormalOrientation = 6.6;
const double modelFactorSuperCriticalFlowMean = 7.7;
const double modelFactorSuperCriticalFlowStandardDeviation = 8.8;
const double allowedLevelIncreaseStorageMean = 9.9;
const double allowedLevelIncreaseStorageStandardDeviation = 10.0;
const double modelFactorStorageVolumeMean = 11.1;
const double modelFactorStorageVolumeStandardDeviation = 12.2;
const double storageStructureAreaMean = 13.3;
const double storageStructureAreaVariation = 14.4;
const double modelFactorInflowVolume = 15.5;
const double flowWidthAtBottomProtectionMean = 16.6;
const double flowWidthAtBottomProtectionStandardDeviation = 17.7;
const double criticalOvertoppingDischargeMean = 18.8;
const double criticalOvertoppingDischargeVariation = 19.9;
const double failureProbabilityStructureWithErosion = 20.0;
const double widthFlowAperturesMean = 21.1;
const double widthFlowAperturesStandardDeviation = 22.2;
const double deviationWaveDirection = 23.3;
const double stormDurationMean = 24.4;
const double stormDurationVariation = 25.5;
// Call
var input = new StructuresOvertoppingCalculationInput(hydraulicBoundaryLocationId,
sectionNormal,
forelandPoints, breakWater,
gravitationalAcceleration,
modelFactorOvertoppingFlowMean, modelFactorOvertoppingFlowStandardDeviation,
levelCrestStructureMean, levelCrestStructureStandardDeviation,
structureNormalOrientation,
modelFactorSuperCriticalFlowMean, modelFactorSuperCriticalFlowStandardDeviation,
allowedLevelIncreaseStorageMean, allowedLevelIncreaseStorageStandardDeviation,
modelFactorStorageVolumeMean, modelFactorStorageVolumeStandardDeviation,
storageStructureAreaMean, storageStructureAreaVariation,
modelFactorInflowVolume,
flowWidthAtBottomProtectionMean, flowWidthAtBottomProtectionStandardDeviation,
criticalOvertoppingDischargeMean, criticalOvertoppingDischargeVariation,
failureProbabilityStructureWithErosion,
widthFlowAperturesMean, widthFlowAperturesStandardDeviation,
deviationWaveDirection,
stormDurationMean, stormDurationVariation);
// Assert
Assert.IsInstanceOf <ExceedanceProbabilityCalculationInput>(input);
Assert.AreEqual(1, input.CalculationTypeId);
Assert.AreEqual(HydraRingFailureMechanismType.StructuresOvertopping, input.FailureMechanismType);
Assert.AreEqual(60, input.VariableId);
Assert.AreEqual(4404, input.FaultTreeModelId);
Assert.AreEqual(6, input.IterationMethodId);
Assert.AreEqual(hydraulicBoundaryLocationId, input.HydraulicBoundaryLocationId);
HydraRingSection section = input.Section;
Assert.AreEqual(1, section.SectionId);
Assert.IsNaN(section.SectionLength);
Assert.AreEqual(sectionNormal, section.CrossSectionNormal);
Assert.AreSame(forelandPoints, input.ForelandPoints);
Assert.AreSame(breakWater, input.BreakWater);
HydraRingDataEqualityHelper.AreEqual(GetDefaultOvertoppingVariables().ToArray(), input.Variables.ToArray());
}
public void Run_Always_InputPropertiesCorrectlySentToService(BreakWaterType breakWaterType)
{
// Setup
AssessmentSectionStub assessmentSection = CreateAssessmentSection();
ConfigureAssessmentSectionWithHydraulicBoundaryOutput(assessmentSection);
GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
calculation.InputParameters.BreakWater.Type = breakWaterType;
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation,
failureMechanism,
assessmentSection);
var waveConditionsCosineCalculator = new TestWaveConditionsCosineCalculator();
RoundedDouble[] waterLevels = GetWaterLevels(calculation, assessmentSection).ToArray();
int nrOfCalculators = GetNrOfCalculators(calculation, assessmentSection);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null))
.IgnoreArguments()
.Return(waveConditionsCosineCalculator)
.Repeat
.Times(nrOfCalculators);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
activity.Run();
// Assert
WaveConditionsCosineCalculationInput[] waveConditionsInputs = waveConditionsCosineCalculator.ReceivedInputs.ToArray();
Assert.AreEqual(nrOfCalculators, waveConditionsInputs.Length);
WaveConditionsInput input = calculation.InputParameters;
double targetProbability = assessmentSection.FailureMechanismContribution.MaximumAllowableFloodingProbability;
var waterLevelIndex = 0;
GeneralGrassCoverErosionOutwardsInput generalInput = failureMechanism.GeneralInput;
for (var i = 0; i < waveConditionsInputs.Length / 2; i++)
{
var expectedInput = new WaveConditionsCosineCalculationInput(1,
input.Orientation,
input.HydraulicBoundaryLocation.Id,
targetProbability,
input.ForeshoreProfile.Geometry.Select(c => new HydraRingForelandPoint(c.X, c.Y)),
new HydraRingBreakWater(BreakWaterTypeHelper.GetHydraRingBreakWaterType(breakWaterType), input.BreakWater.Height),
waterLevels[waterLevelIndex++],
generalInput.GeneralWaveRunUpWaveConditionsInput.A,
generalInput.GeneralWaveRunUpWaveConditionsInput.B,
generalInput.GeneralWaveRunUpWaveConditionsInput.C);
HydraRingDataEqualityHelper.AreEqual(expectedInput, waveConditionsInputs[i]);
}
waterLevelIndex = 0;
for (int i = waveConditionsInputs.Length / 2; i < waveConditionsInputs.Length; i++)
{
var expectedInput = new WaveConditionsCosineCalculationInput(1,
input.Orientation,
input.HydraulicBoundaryLocation.Id,
targetProbability,
input.ForeshoreProfile.Geometry.Select(c => new HydraRingForelandPoint(c.X, c.Y)),
new HydraRingBreakWater(BreakWaterTypeHelper.GetHydraRingBreakWaterType(breakWaterType), input.BreakWater.Height),
waterLevels[waterLevelIndex++],
generalInput.GeneralWaveImpactWaveConditionsInput.A,
generalInput.GeneralWaveImpactWaveConditionsInput.B,
generalInput.GeneralWaveImpactWaveConditionsInput.C);
HydraRingDataEqualityHelper.AreEqual(expectedInput, waveConditionsInputs[i]);
}
}
mockRepository.VerifyAll();
}
public void Calculate_ValidInput_InputPropertiesCorrectlySentToCalculator(bool usePreprocessor)
{
// Setup
string preprocessorDirectory = usePreprocessor
? validPreprocessorDirectory
: string.Empty;
var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
validHlcdFilePath,
false,
preprocessorDirectory);
var mocks = new MockRepository();
var calculator = new TestStructuresCalculator <ExceedanceProbabilityCalculationInput>
{
OutputDirectory = validHydraulicBoundaryDatabaseFilePath
};
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <ExceedanceProbabilityCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
calculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator);
const string performedCalculationMessage = "Calculation successful";
var messageProvider = mocks.StrictMock <IStructuresCalculationMessageProvider>();
messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validHydraulicBoundaryDatabaseFilePath)).Return(performedCalculationMessage);
mocks.ReplayAll();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
var calculation = new TestStructuresCalculation
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation
}
};
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
var service = new TestStructuresCalculationService(messageProvider);
// Call
service.Calculate(calculation, new GeneralTestInput(), calculationSettings);
// Assert
ExceedanceProbabilityCalculationInput[] calculationInputs = calculator.ReceivedInputs.ToArray();
Assert.AreEqual(1, calculationInputs.Length);
var expectedInput = new TestExceedanceProbabilityCalculationInput(hydraulicBoundaryLocation.Id);
ExceedanceProbabilityCalculationInput actualInput = calculationInputs[0];
HydraRingDataEqualityHelper.AreEqual(expectedInput, actualInput);
Assert.IsFalse(calculator.IsCanceled);
}
mocks.VerifyAll();
}
public void Constructor_Always_ExpectedValues()
{
// Setup
const double targetProbability = 1.0 / 10000;
const int hydraulicBoundaryLocationId = 1000;
const double sectionNormal = 19.9;
const double modelFactorCriticalOvertopping = 1.1;
const double factorFbMean = 2.2;
const double factorFbStandardDeviation = 3.3;
const double factorFbLowerBoundary = 4.4;
const double factorFbUpperBoundary = 5.5;
const double factorFnMean = 6.6;
const double factorFnStandardDeviation = 7.7;
const double factorFnLowerBoundary = 8.8;
const double factorFnUpperBoundary = 9.9;
const double modelFactorOvertopping = 10.0;
const double modelFactorFrunupMean = 11.1;
const double modelFactorFrunupStandardDeviation = 12.2;
const double modelFactorFrunupLowerBoundary = 13.3;
const double modelFactorFrunupUpperBoundary = 14.4;
const double exponentModelFactorShallowMean = 15.5;
const double exponentModelFactorShallowStandardDeviation = 16.6;
const double exponentModelFactorShallowLowerBoundary = 17.7;
const double exponentModelFactorShallowUpperBoundary = 18.8;
var expectedRingProfilePoints = new List <HydraRingRoughnessProfilePoint>
{
new HydraRingRoughnessProfilePoint(1.1, 2.2, 3.3)
};
var expectedRingForelandPoints = new List <HydraRingForelandPoint>
{
new HydraRingForelandPoint(2.2, 3.3)
};
var expectedRingBreakWater = new HydraRingBreakWater(2, 3.3);
// Call
var input = new HydraulicLoadsCalculationInputImplementation(hydraulicBoundaryLocationId, targetProbability, sectionNormal,
expectedRingProfilePoints, expectedRingForelandPoints, expectedRingBreakWater,
modelFactorCriticalOvertopping,
factorFbMean, factorFbStandardDeviation,
factorFbLowerBoundary, factorFbUpperBoundary,
factorFnMean, factorFnStandardDeviation,
factorFnLowerBoundary, factorFnUpperBoundary,
modelFactorOvertopping,
modelFactorFrunupMean, modelFactorFrunupStandardDeviation,
modelFactorFrunupLowerBoundary, modelFactorFrunupUpperBoundary,
exponentModelFactorShallowMean, exponentModelFactorShallowStandardDeviation,
exponentModelFactorShallowLowerBoundary, exponentModelFactorShallowUpperBoundary);
// Assert
double expectedBeta = StatisticsConverter.ProbabilityToReliability(targetProbability);
Assert.IsInstanceOf <ReliabilityIndexCalculationInput>(input);
Assert.AreEqual(9, input.CalculationTypeId);
Assert.AreEqual(1017, input.FaultTreeModelId);
Assert.AreEqual(hydraulicBoundaryLocationId, input.HydraulicBoundaryLocationId);
Assert.IsNotNull(input.Section);
HydraRingDataEqualityHelper.AreEqual(GetDefaultHydraulicLoadsVariables().ToArray(), input.Variables.ToArray());
CollectionAssert.AreEqual(expectedRingProfilePoints, input.ProfilePoints);
CollectionAssert.AreEqual(expectedRingForelandPoints, input.ForelandPoints);
Assert.AreEqual(expectedRingBreakWater, input.BreakWater);
Assert.AreEqual(expectedBeta, input.Beta);
HydraRingSection hydraRingSection = input.Section;
Assert.AreEqual(1, hydraRingSection.SectionId);
Assert.IsNaN(hydraRingSection.SectionLength);
Assert.AreEqual(sectionNormal, hydraRingSection.CrossSectionNormal);
}
public void Constructor_ExpectedValues()
{
// Setup
const int hydraulicBoundaryLocationId = 1000;
IEnumerable <HydraRingForelandPoint> forelandPoints = Enumerable.Empty <HydraRingForelandPoint>();
var breakWater = new HydraRingBreakWater(1, 1.1);
const double sectionNormal = 21.1;
const double gravitationalAcceleration = 1.1;
const double factorStormDurationOpenStructure = 2.2;
const double failureProbabilityOpenStructure = 3.3;
const double failureProbabilityReparation = 4.4;
const int identicalApertures = 5;
const double allowedLevelIncreaseStorageMean = 6.6;
const double allowedLevelIncreaseStorageStandardDeviation = 7.7;
const double modelFactorStorageVolumeMean = 8.8;
const double modelFactorStorageVolumeStandardDeviation = 9.9;
const double storageStructureAreaMean = 10.0;
const double storageStructureAreaVariation = 11.1;
const double modelFactorInflowVolume = 12.2;
const double flowWidthAtBottomProtectionMean = 13.3;
const double flowWidthAtBottomProtectionStandardDeviation = 14.4;
const double criticalOvertoppingDischargeMean = 15.5;
const double criticalOvertoppingDischargeVariation = 16.6;
const double failureProbabilityStructureWithErosion = 17.7;
const double stormDurationMean = 18.8;
const double stormDurationVariation = 19.9;
const double probabilityOpenStructureBeforeFlooding = 20.0;
// Call
var input = new TestStructuresClosureCalculationInput(hydraulicBoundaryLocationId,
sectionNormal,
forelandPoints, breakWater,
gravitationalAcceleration,
factorStormDurationOpenStructure,
failureProbabilityOpenStructure,
failureProbabilityReparation,
identicalApertures,
allowedLevelIncreaseStorageMean, allowedLevelIncreaseStorageStandardDeviation,
modelFactorStorageVolumeMean, modelFactorStorageVolumeStandardDeviation,
storageStructureAreaMean, storageStructureAreaVariation,
modelFactorInflowVolume,
flowWidthAtBottomProtectionMean, flowWidthAtBottomProtectionStandardDeviation,
criticalOvertoppingDischargeMean, criticalOvertoppingDischargeVariation,
failureProbabilityStructureWithErosion,
stormDurationMean, stormDurationVariation,
probabilityOpenStructureBeforeFlooding);
// Assert
Assert.IsInstanceOf <ExceedanceProbabilityCalculationInput>(input);
Assert.AreEqual(1, input.CalculationTypeId);
Assert.AreEqual(HydraRingFailureMechanismType.StructuresClosure, input.FailureMechanismType);
Assert.AreEqual(58, input.VariableId);
Assert.AreEqual(4505, input.FaultTreeModelId);
Assert.AreEqual(6, input.IterationMethodId);
Assert.AreEqual(hydraulicBoundaryLocationId, input.HydraulicBoundaryLocationId);
HydraRingSection section = input.Section;
Assert.AreEqual(1, section.SectionId);
Assert.IsNaN(section.SectionLength);
Assert.AreEqual(sectionNormal, section.CrossSectionNormal);
Assert.AreSame(forelandPoints, input.ForelandPoints);
Assert.AreSame(breakWater, input.BreakWater);
HydraRingDataEqualityHelper.AreEqual(GetDefaultVariables().ToArray(), input.Variables.ToArray());
}
public void Calculate_VariousCalculationsWithBreakWater_InputPropertiesCorrectlySentToCalculator(BreakWaterType breakWaterType)
{
// Setup
var failureMechanism = new HeightStructuresFailureMechanism();
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mockRepository);
var calculator = new TestStructuresCalculator <StructuresOvertoppingCalculationInput>();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>(null))
.IgnoreArguments()
.Return(calculator);
mockRepository.ReplayAll();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001),
ForeshoreProfile = new TestForeshoreProfile(true)
{
BreakWater =
{
Type = breakWaterType
}
}
}
};
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new HeightStructuresCalculationService().Calculate(calculation,
failureMechanism.GeneralInput,
CreateCalculationSettings());
// Assert
StructuresOvertoppingCalculationInput[] overtoppingCalculationInputs = calculator.ReceivedInputs.ToArray();
Assert.AreEqual(1, overtoppingCalculationInputs.Length);
GeneralHeightStructuresInput generalInput = failureMechanism.GeneralInput;
HeightStructuresInput input = calculation.InputParameters;
var expectedInput = new StructuresOvertoppingCalculationInput(
1300001,
input.StructureNormalOrientation,
input.ForeshoreGeometry.Select(c => new HydraRingForelandPoint(c.X, c.Y)),
new HydraRingBreakWater(BreakWaterTypeHelper.GetHydraRingBreakWaterType(breakWaterType), input.BreakWater.Height),
generalInput.GravitationalAcceleration,
generalInput.ModelFactorOvertoppingFlow.Mean, generalInput.ModelFactorOvertoppingFlow.StandardDeviation,
input.LevelCrestStructure.Mean, input.LevelCrestStructure.StandardDeviation,
input.StructureNormalOrientation,
input.ModelFactorSuperCriticalFlow.Mean, input.ModelFactorSuperCriticalFlow.StandardDeviation,
input.AllowedLevelIncreaseStorage.Mean, input.AllowedLevelIncreaseStorage.StandardDeviation,
generalInput.ModelFactorStorageVolume.Mean, generalInput.ModelFactorStorageVolume.StandardDeviation,
input.StorageStructureArea.Mean, input.StorageStructureArea.CoefficientOfVariation,
generalInput.ModelFactorInflowVolume,
input.FlowWidthAtBottomProtection.Mean, input.FlowWidthAtBottomProtection.StandardDeviation,
input.CriticalOvertoppingDischarge.Mean, input.CriticalOvertoppingDischarge.CoefficientOfVariation,
input.FailureProbabilityStructureWithErosion,
input.WidthFlowApertures.Mean, input.WidthFlowApertures.StandardDeviation,
input.DeviationWaveDirection,
input.StormDuration.Mean, input.StormDuration.CoefficientOfVariation);
StructuresOvertoppingCalculationInput actualInput = overtoppingCalculationInputs[0];
HydraRingDataEqualityHelper.AreEqual(expectedInput, actualInput);
Assert.IsFalse(calculator.IsCanceled);
}
mockRepository.VerifyAll();
}
