public void Run_HydraulicBoundaryDatabaseWithCanUsePreprocessorFalse_CreateWaveConditionsCosineCalculatorAsExpected()
{
// Setup
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
StabilityStoneCoverWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
CalculatableActivity activity = StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivity(
calculation,
new StabilityStoneCoverFailureMechanism(),
assessmentSection);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveConditionsCosineCalculator())
.Repeat
.Times(GetWaterLevels(calculation, assessmentSection).Count() * 2);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
activity.Run();
}
// Assert
mockRepository.VerifyAll();
}
public void CalculateWaveHeights_ValidPathOneCalculation_LogsMessages()
{
// Setup
const string hydraulicLocationName = "name";
const string calculationIdentifier = "1/100";
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks);
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveHeightCalculator());
mocks.ReplayAll();
assessmentSection.HydraulicBoundaryDatabase.FilePath = validFilePath;
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (var viewParent = new TestViewParentForm())
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
var guiService = new HydraulicBoundaryLocationCalculationGuiService(viewParent);
// Call
void Call() =>
guiService.CalculateWaveHeights(new[]
{
new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation(hydraulicLocationName))
}, assessmentSection, 0.01, calculationIdentifier);
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(8, msgs.Length);
string activityDescription = GetWaveHeightCalculationActivityDescription(hydraulicLocationName, calculationIdentifier);
Assert.AreEqual($"{activityDescription} is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]);
Assert.AreEqual($"Golfhoogte berekening voor locatie 'name' ({calculationIdentifier}) is niet geconvergeerd.", msgs[4]);
StringAssert.StartsWith("Golfhoogte berekening is uitgevoerd op de tijdelijke locatie", msgs[5]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[6]);
Assert.AreEqual($"{activityDescription} is gelukt.", msgs[7]);
});
}
mocks.VerifyAll();
}
private static void AssertDesignWaterLevelCalculationActivity(Activity activity,
HydraulicBoundaryLocation hydraulicBoundaryLocation,
string calculationIdentifier,
double targetProbability,
HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
var mocks = new MockRepository();
var calculator = new TestDesignWaterLevelCalculator();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator);
mocks.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
Action call = activity.Run;
string expectedLogMessage = $"Waterstand berekenen voor locatie '{hydraulicBoundaryLocation.Name}' ({calculationIdentifier}) is gestart.";
TestHelper.AssertLogMessageIsGenerated(call, expectedLogMessage);
AssessmentLevelCalculationInput designWaterLevelCalculationInput = calculator.ReceivedInputs.Single();
Assert.AreEqual(hydraulicBoundaryLocation.Id, designWaterLevelCalculationInput.HydraulicBoundaryLocationId);
Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(targetProbability), designWaterLevelCalculationInput.Beta);
}
mocks.VerifyAll();
}
private static void AssertStabilityPointStructuresCalculationActivity(Activity activity,
ICalculation <StabilityPointStructuresInput> calculation,
HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
var mocks = new MockRepository();
var testCalculator = new TestStructuresCalculator <StructuresStabilityPointCalculationInput>();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresStabilityPointCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(testCalculator);
mocks.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.Run();
StructuresStabilityPointCalculationInput actualInput = testCalculator.ReceivedInputs.Single();
Assert.AreEqual(calculation.InputParameters.FailureProbabilityStructureWithErosion,
actualInput.Variables.Single(v => v.VariableId == 105).Value);
}
mocks.VerifyAll();
}
private static void AssertWaveImpactAsphaltCoverWaveConditionsCalculationActivity(Activity activity,
WaveImpactAsphaltCoverWaveConditionsCalculation calculation,
RoundedDouble assessmentLevel,
HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
var mocks = new MockRepository();
var testCalculator = new TestWaveConditionsCosineCalculator();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
int nrOfCalculations = calculation.InputParameters.GetWaterLevels(assessmentLevel).Count();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(testCalculator)
.Repeat
.Times(nrOfCalculations);
mocks.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.Run();
Assert.AreEqual(nrOfCalculations, testCalculator.ReceivedInputs.Count());
foreach (WaveConditionsCosineCalculationInput input in testCalculator.ReceivedInputs)
{
Assert.AreEqual(calculation.InputParameters.BreakWater.Height, input.BreakWater.Height);
}
}
mocks.VerifyAll();
}
private static void AssertGrassCoverErosionInwardsCalculationActivity(Activity activity,
GrassCoverErosionInwardsCalculation calculation,
HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
var mocks = new MockRepository();
var testCalculator = new TestOvertoppingCalculator();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(testCalculator);
mocks.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.Run();
Assert.AreEqual(calculation.InputParameters.BreakWater.Height, testCalculator.ReceivedInputs.Single().BreakWater.Height);
}
mocks.VerifyAll();
}
public void Run_HydraulicBoundaryDatabaseWithUsePreprocessorFalse_ExpectedPreprocessorDirectorySetToCalculator()
{
// Setup
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike)
{
HydraulicBoundaryDatabase =
{
FilePath = validFilePath,
Locations =
{
new HydraulicBoundaryLocation(1300001, string.Empty, 0, 0)
},
HydraulicLocationConfigurationSettings =
{
CanUsePreprocessor = true,
UsePreprocessor = false,
PreprocessorDirectory = "InvalidPreprocessorDirectory"
}
}
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestStructuresCalculator <StructuresOvertoppingCalculationInput>());
mockRepository.ReplayAll();
var failureMechanism = new HeightStructuresFailureMechanism();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)
}
};
CalculatableActivity activity = HeightStructuresCalculationActivityFactory.CreateCalculationActivity(calculation,
failureMechanism,
assessmentSection);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
activity.Run();
}
// Assert
mockRepository.VerifyAll();
}
protected override void PerformCalculation()
{
calculation.ClearOutput();
calculationService.Calculate(calculation,
failureMechanism.GeneralInput,
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase));
}
public void Calculate_VariousHydraulicBoundaryDatabaseConfigurations_StartsCalculationWithRightParameters(
HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
// 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,
Orientation = (RoundedDouble)0
};
var calculator = new TestWaveConditionsCosineCalculator();
int nrOfCalculators = input.GetWaterLevels(waterLevel).Count();
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator)
.Repeat
.Times(nrOfCalculators);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new TestWaveConditionsCalculationService().PublicCalculate(a,
b,
c,
targetProbability,
input,
waterLevel,
hydraulicBoundaryDatabase);
// Assert
for (var i = 0; i < nrOfCalculators; i++)
{
Assert.AreEqual(hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.UsePreprocessor,
calculator.ReceivedInputs.ElementAt(i).PreprocessorSetting.RunPreprocessor);
}
}
mockRepository.VerifyAll();
}
public void GivenValidCalculations_WhenCalculatingAllFromContextMenu_ThenAllCalculationsScheduled()
{
// Given
var failureMechanism = new StabilityStoneCoverFailureMechanism();
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
HydraulicBoundaryLocation hydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First();
StabilityStoneCoverWaveConditionsCalculation calculationA = GetValidCalculation(hydraulicBoundaryLocation);
StabilityStoneCoverWaveConditionsCalculation calculationB = GetValidCalculation(hydraulicBoundaryLocation);
List <ICalculationBase> calculations = failureMechanism.CalculationsGroup.Children;
calculations.AddRange(new[]
{
calculationA,
calculationB
});
var nodeData = new StabilityStoneCoverFailureMechanismContext(failureMechanism, assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.MainWindow).Return(mainWindow);
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveConditionsCosineCalculator())
.Repeat
.Times(12);
mocks.ReplayAll();
plugin.Gui = gui;
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// When
contextMenu.Items[contextMenuCalculateAllIndex].PerformClick();
// Then
Assert.AreEqual(3, calculationA.Output.BlocksOutput.Count());
Assert.AreEqual(3, calculationA.Output.ColumnsOutput.Count());
Assert.AreEqual(3, calculationB.Output.BlocksOutput.Count());
Assert.AreEqual(3, calculationB.Output.ColumnsOutput.Count());
}
}
}
public void CreateSettings_WithHydraulicBoundaryDatabaseWithVariousPreprocessorConfigurations_ReturnsExpectedSettings(
HydraulicBoundaryDatabase database,
string expectedPreprocessorDirectory)
{
// Call
HydraulicBoundaryCalculationSettings settings = HydraulicBoundaryCalculationSettingsFactory.CreateSettings(database);
// Assert
Assert.AreEqual(expectedPreprocessorDirectory, settings.PreprocessorDirectory);
}
public void CreateSettings_HydraulicBoundaryDatabaseNull_ThrowsArgumentNullException()
{
// Call
TestDelegate call = () => HydraulicBoundaryCalculationSettingsFactory.CreateSettings(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(call);
Assert.AreEqual("hydraulicBoundaryDatabase", exception.ParamName);
}
protected override void PerformCalculation()
{
calculation.ClearOutput();
FailureMechanismSection section = failureMechanism.Sections.Single(
s => calculation.IsSurfaceLineIntersectionWithReferenceLineInSection(
Math2D.ConvertPointsToLineSegments(s.Points)));
service.Calculate(calculation, failureMechanism.GeneralInput,
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
section.Length);
}
public void Run_HydraulicBoundaryDatabaseWithUsePreprocessorTrue_ExpectedPreprocessorDirectorySetToCalculator()
{
// Setup
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike)
{
HydraulicBoundaryDatabase =
{
FilePath = validFilePath,
HydraulicLocationConfigurationSettings =
{
CanUsePreprocessor = true,
UsePreprocessor = true,
PreprocessorDirectory = validPreprocessorDirectory
}
}
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresClosureCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestStructuresCalculator <StructuresClosureCalculationInput>());
mockRepository.ReplayAll();
var failureMechanism = new ClosingStructuresFailureMechanism();
var calculation = new TestClosingStructuresCalculationScenario();
CalculatableActivity activity = ClosingStructuresCalculationActivityFactory.CreateCalculationActivity(calculation,
failureMechanism,
assessmentSection);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
activity.Run();
}
// Assert
mockRepository.VerifyAll();
}
public void Run_HydraulicBoundaryDatabaseWithUsePreprocessorFalse_CreateWaveConditionsCosineCalculatorAsExpected()
{
// Setup
AssessmentSectionStub assessmentSection = CreateAssessmentSection();
ConfigureAssessmentSectionWithHydraulicBoundaryOutput(assessmentSection);
GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.CanUsePreprocessor = true;
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.UsePreprocessor = false;
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.PreprocessorDirectory = "InvalidPreprocessorDirectory";
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation,
failureMechanism,
assessmentSection);
int nrOfCalculators = GetNrOfCalculators(calculation, assessmentSection);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveConditionsCosineCalculator())
.Repeat
.Times(nrOfCalculators);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
activity.Run();
}
// Assert
mockRepository.VerifyAll();
}
public void Calculate_HydraulicBoundaryDatabaseWithUsePreprocessorFalse_ExpectedPreprocessorDirectorySetToCalculator()
{
// Setup
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.CanUsePreprocessor = true;
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.UsePreprocessor = false;
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.PreprocessorDirectory = "InvalidPreprocessorDirectory";
WaveImpactAsphaltCoverWaveConditionsCalculation calculation = GetValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
var waveImpactAsphaltCoverFailureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var calculator = new TestWaveConditionsCosineCalculator();
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator)
.Repeat
.Times(3);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new WaveImpactAsphaltCoverWaveConditionsCalculationService().Calculate(
calculation,
assessmentSection,
waveImpactAsphaltCoverFailureMechanism.GeneralInput);
}
// Assert
mockRepository.VerifyAll();
}
private static void AssertDuneLocationCalculationActivity(Activity activity,
string calculationIdentifier,
string locationName,
long locationId,
double targetProbability,
HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
var calculator = new TestDunesBoundaryConditionsCalculator();
var mocks = new MockRepository();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator);
mocks.ReplayAll();
void Call()
{
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.Run();
}
}
var expectedLogMessage = $"Hydraulische belastingen berekenen voor locatie '{locationName}' ({calculationIdentifier}) is gestart.";
TestHelper.AssertLogMessageIsGenerated(Call, expectedLogMessage);
DunesBoundaryConditionsCalculationInput dunesBoundaryConditionsCalculationInput = calculator.ReceivedInputs.Last();
Assert.AreEqual(locationId, dunesBoundaryConditionsCalculationInput.HydraulicBoundaryLocationId);
Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(targetProbability), dunesBoundaryConditionsCalculationInput.Beta);
mocks.VerifyAll();
}
/// <summary>
/// Creates a collection of <see cref="CalculatableActivity"/> based on <paramref name="calculations"/>.
/// </summary>
/// <param name="calculations">The calculations to create activities for.</param>
/// <param name="assessmentSection">The assessment section the calculations belong to.</param>
/// <param name="targetProbability">The target probability to use during the calculations.</param>
/// <param name="calculationIdentifier">The calculation identifier to use in all messages.</param>
/// <returns>A collection of <see cref="CalculatableActivity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculations"/> or
/// <paramref name="assessmentSection"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when <paramref name="calculationIdentifier"/> is <c>null</c> or empty.</exception>
public static IEnumerable <CalculatableActivity> CreateCalculationActivities(IEnumerable <DuneLocationCalculation> calculations,
IAssessmentSection assessmentSection,
double targetProbability,
string calculationIdentifier)
{
if (calculations == null)
{
throw new ArgumentNullException(nameof(calculations));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
HydraulicBoundaryCalculationSettings settings = HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase);
return(calculations.Select(calculation => new DuneLocationCalculationActivity(calculation,
settings,
targetProbability,
calculationIdentifier)).ToArray());
}
public void CreateSettings_WithHydraulicBoundaryDatabaseWithFilePath_ReturnsExpectedSettings()
{
// Setup
const string hydraulicBoundaryDatabaseFilePath = "some//FilePath//HRD dutch coast south.sqlite";
const string hlcdFilePath = "some//FilePath//HLCD dutch coast south.sqlite";
bool usePreprocessorClosure = new Random(21).NextBoolean();
var database = new HydraulicBoundaryDatabase
{
FilePath = hydraulicBoundaryDatabaseFilePath
};
database.HydraulicLocationConfigurationSettings.SetValues(hlcdFilePath, string.Empty, 10, string.Empty,
usePreprocessorClosure, null, null, null, null, null, null);
// Call
HydraulicBoundaryCalculationSettings settings = HydraulicBoundaryCalculationSettingsFactory.CreateSettings(database);
// Assert
Assert.AreEqual(hydraulicBoundaryDatabaseFilePath, settings.HydraulicBoundaryDatabaseFilePath);
Assert.AreEqual(hlcdFilePath, settings.HlcdFilePath);
Assert.AreEqual(usePreprocessorClosure, settings.UsePreprocessorClosure);
}
public void Calculate_ValidPathOneCalculation_LogsMessages()
{
// Setup
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
FilePath = validFilePath,
HydraulicLocationConfigurationSettings =
{
CanUsePreprocessor = true,
UsePreprocessor = true,
PreprocessorDirectory = validPreprocessorDirectory
}
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(hydraulicBoundaryDatabase);
const string calculationIdentifier = "1/100";
const string duneLocationName = "duneLocationName";
var mocks = new MockRepository();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestDunesBoundaryConditionsCalculator());
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase)
.Return(hydraulicBoundaryDatabase);
mocks.ReplayAll();
using (var viewParent = new TestViewParentForm())
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
var guiService = new DuneLocationCalculationGuiService(viewParent);
// Call
void Call() =>
guiService.Calculate(new[]
{
new DuneLocationCalculation(new TestDuneLocation(duneLocationName))
}, assessmentSection, 0.01, calculationIdentifier);
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(8, msgs.Length);
Assert.AreEqual($"Hydraulische belastingen berekenen voor locatie '{duneLocationName}' ({calculationIdentifier}) is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]);
Assert.AreEqual($"Hydraulische belastingenberekening voor locatie '{duneLocationName}' ({calculationIdentifier}) is niet geconvergeerd.", msgs[4]);
StringAssert.StartsWith("Hydraulische belastingenberekening is uitgevoerd op de tijdelijke locatie", msgs[5]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[6]);
Assert.AreEqual($"Hydraulische belastingen berekenen voor locatie '{duneLocationName}' ({calculationIdentifier}) is gelukt.", msgs[7]);
});
}
mocks.VerifyAll();
}
/// <summary>
/// Performs a grass cover erosion inwards calculation based on the supplied <see cref="GrassCoverErosionInwardsCalculation"/>
/// and sets <see cref="GrassCoverErosionInwardsCalculation.Output"/> if the calculation was successful. Error and status
/// information is logged during the execution of the operation.
/// </summary>
/// <param name="calculation">The <see cref="GrassCoverErosionInwardsCalculation"/> that holds all the information required to perform the calculation.</param>
/// <param name="assessmentSection">The <see cref="IAssessmentSection"/> that holds information about the target probability used in the calculation.</param>
/// <param name="generalInput">Calculation input parameters that apply to all <see cref="GrassCoverErosionInwardsCalculation"/> instances.</param>
/// <exception cref="ArgumentNullException">Thrown when one of the following parameters is <c>null</c>:
/// <list type="bullet">
/// <item><paramref name="calculation"/></item>
/// <item><paramref name="assessmentSection"/></item>
/// <item><paramref name="generalInput"/></item>
/// </list></exception>
/// <exception cref="ArgumentException">Thrown when the hydraulic boundary database file path contains invalid characters.</exception>
/// <exception cref="CriticalFileReadException">Thrown when:
/// <list type="bullet">
/// <item>No settings database file could be found at the location of the hydraulic boundary database file path
/// with the same name.</item>
/// <item>Unable to open settings database file.</item>
/// <item>Unable to read required data from database file.</item>
/// </list>
/// </exception>
/// <exception cref="SecurityException">Thrown when the temporary working directory can't be accessed due to missing permissions.</exception>
/// <exception cref="IOException">Thrown when the specified path is not valid, the network name is not known
/// or an I/O error occurred while opening the file.</exception>
/// <exception cref="UnauthorizedAccessException">Thrown when the directory can't be created due to missing
/// the required permissions.</exception>
/// <exception cref="NotSupportedException">Thrown when <see cref="HydraRingCalculationInput.FailureMechanismType"/>
/// is not the same with already added input.</exception>
/// <exception cref="Win32Exception">Thrown when there was an error in opening the associated file
/// or the wait setting could not be accessed.</exception>
/// <exception cref="HydraRingFileParserException">Thrown when an error occurs during parsing of the Hydra-Ring output.</exception>
/// <exception cref="HydraRingCalculationException">Thrown when an error occurs during the calculation.</exception>
internal void Calculate(GrassCoverErosionInwardsCalculation calculation,
IAssessmentSection assessmentSection,
GeneralGrassCoverErosionInwardsInput generalInput)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
HydraulicBoundaryCalculationSettings calculationSettings =
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase);
int numberOfCalculators = CreateCalculators(calculation, calculationSettings);
string hydraulicBoundaryDatabaseFilePath = calculationSettings.HydraulicBoundaryDatabaseFilePath;
bool usePreprocessor = !string.IsNullOrEmpty(calculationSettings.PreprocessorDirectory);
CalculationServiceHelper.LogCalculationBegin();
try
{
OvertoppingOutput overtoppingOutput = CalculateOvertopping(calculation,
generalInput,
hydraulicBoundaryDatabaseFilePath,
usePreprocessor,
numberOfCalculators);
if (canceled)
{
return;
}
DikeHeightOutput dikeHeightOutput = CalculateDikeHeight(calculation,
generalInput,
hydraulicBoundaryDatabaseFilePath,
usePreprocessor,
numberOfCalculators);
if (canceled)
{
return;
}
OvertoppingRateOutput overtoppingRateOutput = CalculateOvertoppingRate(calculation,
generalInput,
hydraulicBoundaryDatabaseFilePath,
usePreprocessor,
numberOfCalculators);
if (canceled)
{
return;
}
calculation.Output = new GrassCoverErosionInwardsOutput(
overtoppingOutput,
dikeHeightOutput,
overtoppingRateOutput);
}
finally
{
CalculationServiceHelper.LogCalculationEnd();
overtoppingCalculator = null;
dikeHeightCalculator = null;
overtoppingRateCalculator = null;
}
}
public void CreateHydraulicLoadCalculationActivities_WithValidDataAndAllFailureMechanismsRelevant_ExpectedActivitiesCreated()
{
// Setup
AssessmentSection assessmentSection = CreateAssessmentSection();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
IEnumerable <HydraulicBoundaryLocation> hydraulicBoundaryLocations = new[]
{
hydraulicBoundaryLocation
};
assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.AddRange(
new[]
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1),
new HydraulicBoundaryLocationCalculationsForTargetProbability(0.01)
});
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.AddRange(
new[]
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(0.025),
new HydraulicBoundaryLocationCalculationsForTargetProbability(0.0025)
});
assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryLocations);
AddStabilityStoneCoverCalculation(assessmentSection, hydraulicBoundaryLocation);
AddWaveImpactAsphaltCoverCalculation(assessmentSection, hydraulicBoundaryLocation);
AddGrassCoverErosionOutwardsCalculation(assessmentSection, hydraulicBoundaryLocation);
AddDuneLocationCalculation(assessmentSection);
var mocks = new MockRepository();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
HydraulicBoundaryCalculationSettings expectedCalculationSettings =
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase);
using (mocks.Ordered())
{
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestDesignWaterLevelCalculator
{
DesignWaterLevel = 2.0
}).Repeat.Times(4);
calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveHeightCalculator()).Repeat.Times(2);
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveConditionsCosineCalculator()).Repeat.Times(9);
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveConditionsCosineCalculator()).Repeat.Times(6);
calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestDunesBoundaryConditionsCalculator()).Repeat.Once();
}
mocks.ReplayAll();
// Call
IEnumerable <CalculatableActivity> activities =
AssessmentSectionCalculationActivityFactory.CreateHydraulicLoadCalculationActivities(assessmentSection);
// Assert
Assert.AreEqual(10, activities.Count());
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activities.ForEachElementDo(activity => activity.Run());
}
mocks.VerifyAll();
}
public void CalculateForSelectedButton_HydraulicBoundaryDatabaseWithUsePreprocessorFalse_CreateDunesBoundaryConditionsCalculatorCalledAsExpected()
{
// Setup
const double targetProbability = 0.01;
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
FilePath = hydraulicBoundaryDatabaseFilePath,
HydraulicLocationConfigurationSettings =
{
CanUsePreprocessor = true,
UsePreprocessor = false,
PreprocessorDirectory = "InvalidPreprocessorDirectory"
}
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(hydraulicBoundaryDatabase);
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.Id).Return("1");
assessmentSection.Stub(a => a.FailureMechanismContribution)
.Return(FailureMechanismContributionTestFactory.CreateFailureMechanismContribution());
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase).Return(hydraulicBoundaryDatabase);
assessmentSection.Stub(a => a.Attach(null)).IgnoreArguments();
assessmentSection.Stub(a => a.Detach(null)).IgnoreArguments();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
var dunesBoundaryConditionsCalculator = new TestDunesBoundaryConditionsCalculator();
calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(dunesBoundaryConditionsCalculator);
mocks.ReplayAll();
var failureMechanism = new DuneErosionFailureMechanism();
using (var view = new DuneLocationCalculationsView(GenerateDuneLocationCalculations(),
failureMechanism,
assessmentSection,
() => targetProbability,
() => "1/100"))
{
testForm.Controls.Add(view);
testForm.Show();
var dataGridView = (DataGridView)view.Controls.Find("dataGridView", true)[0];
DataGridViewRowCollection rows = dataGridView.Rows;
rows[0].Cells[calculateColumnIndex].Value = true;
var buttonTester = new ButtonTester("CalculateForSelectedButton", testForm);
using (var viewParent = new TestViewParentForm())
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
view.CalculationGuiService = new DuneLocationCalculationGuiService(viewParent);
// Call
buttonTester.Click();
// Assert
DunesBoundaryConditionsCalculationInput dunesBoundaryConditionsCalculationInput = dunesBoundaryConditionsCalculator.ReceivedInputs.First();
Assert.AreEqual(1, dunesBoundaryConditionsCalculationInput.HydraulicBoundaryLocationId);
Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(targetProbability), dunesBoundaryConditionsCalculationInput.Beta);
}
}
}
public void ContextMenuStrip_ClickOnCalculateAllItem_ScheduleAllChildCalculations()
{
// Setup
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocksRepository);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new GrassCoverErosionInwardsCalculation
{
Name = "A",
InputParameters =
{
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(),
DikeProfile = DikeProfileTestFactory.CreateDikeProfile()
}
});
failureMechanism.CalculationsGroup.Children.Add(new GrassCoverErosionInwardsCalculation
{
Name = "B",
InputParameters =
{
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(),
DikeProfile = DikeProfileTestFactory.CreateDikeProfile()
}
});
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
FilePath = Path.Combine(testDataPath, "complete.sqlite")
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(hydraulicBoundaryDatabase);
var assessmentSection = mocksRepository.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.Id).Return(string.Empty);
assessmentSection.Stub(a => a.FailureMechanismContribution)
.Return(FailureMechanismContributionTestFactory.CreateFailureMechanismContribution());
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase).Return(hydraulicBoundaryDatabase);
var context = new GrassCoverErosionInwardsFailureMechanismContext(failureMechanism, assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
var gui = mocksRepository.Stub <IGui>();
gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(g => g.MainWindow).Return(mocksRepository.Stub <IMainWindow>());
int nrOfCalculators = failureMechanism.Calculations.Count();
var calculatorFactory = mocksRepository.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestOvertoppingCalculator())
.Repeat
.Times(nrOfCalculators);
mocksRepository.ReplayAll();
plugin.Gui = gui;
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
TestHelper.AssertLogMessages(() => contextMenu.Items[contextMenuCalculateAllIndex].PerformClick(), messages =>
{
List <string> messageList = messages.ToList();
// Assert
Assert.AreEqual(14, messageList.Count);
Assert.AreEqual("Uitvoeren van berekening 'A' is gestart.", messageList[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(messageList[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(messageList[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(messageList[3]);
StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", messageList[4]);
CalculationServiceTestHelper.AssertCalculationEndMessage(messageList[5]);
Assert.AreEqual("Uitvoeren van berekening 'A' is gelukt.", messageList[6]);
Assert.AreEqual("Uitvoeren van berekening 'B' is gestart.", messageList[7]);
CalculationServiceTestHelper.AssertValidationStartMessage(messageList[8]);
CalculationServiceTestHelper.AssertValidationEndMessage(messageList[9]);
CalculationServiceTestHelper.AssertCalculationStartMessage(messageList[10]);
StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", messageList[11]);
CalculationServiceTestHelper.AssertCalculationEndMessage(messageList[12]);
Assert.AreEqual("Uitvoeren van berekening 'B' is gelukt.", messageList[13]);
});
}
}
}
public void CreateCalculationActivities_WithValidDataAndAllFailureMechanismsRelevant_ExpectedActivitiesCreated()
{
// Setup
AssessmentSection assessmentSection = CreateAssessmentSection();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
IEnumerable <HydraulicBoundaryLocation> hydraulicBoundaryLocations = new[]
{
hydraulicBoundaryLocation
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryLocations);
AddSemiProbabilisticPipingCalculationScenario(assessmentSection, hydraulicBoundaryLocation);
AddProbabilisticPipingCalculationScenario(assessmentSection, hydraulicBoundaryLocation);
AddGrassCoverErosionInwardsCalculation(assessmentSection, hydraulicBoundaryLocation);
AddMacroStabilityInwardsCalculationScenario(assessmentSection, hydraulicBoundaryLocation);
AddHeightStructuresCalculation(assessmentSection, hydraulicBoundaryLocation);
AddClosingStructuresCalculation(assessmentSection, hydraulicBoundaryLocation);
AddStabilityPointStructuresCalculation(assessmentSection, hydraulicBoundaryLocation);
var mocks = new MockRepository();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
HydraulicBoundaryCalculationSettings expectedCalculationSettings =
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase);
using (mocks.Ordered())
{
calculatorFactory.Expect(cf => cf.CreatePipingCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestPipingCalculator());
calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestOvertoppingCalculator());
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestStructuresCalculator <StructuresOvertoppingCalculationInput>());
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresClosureCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestStructuresCalculator <StructuresClosureCalculationInput>());
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresStabilityPointCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestStructuresCalculator <StructuresStabilityPointCalculationInput>());
}
mocks.ReplayAll();
// Call
IEnumerable <CalculatableActivity> activities =
AssessmentSectionCalculationActivityFactory.CreateCalculationActivities(assessmentSection);
// Assert
Assert.AreEqual(7, activities.Count());
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
using (new PipingSubCalculatorFactoryConfig())
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
var pipingTestFactory = (TestPipingSubCalculatorFactory)PipingSubCalculatorFactory.Instance;
var macroStabilityTestFactory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance;
Assert.IsFalse(pipingTestFactory.LastCreatedUpliftCalculator.Calculated);
Assert.IsFalse(macroStabilityTestFactory.LastCreatedUpliftVanCalculator.Calculated);
activities.ForEachElementDo(activity => activity.Run());
Assert.IsTrue(pipingTestFactory.LastCreatedUpliftCalculator.Calculated);
Assert.IsTrue(macroStabilityTestFactory.LastCreatedUpliftVanCalculator.Calculated);
}
mocks.VerifyAll();
}
public void GivenValidCalculations_WhenCalculatingAllFromContextMenu_ThenAllCalculationsScheduled()
{
// Given
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("Test");
var assessmentSection = new AssessmentSectionStub
{
HydraulicBoundaryDatabase =
{
FilePath = validFilePath
}
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.ElementAt(0).Output =
new TestHydraulicBoundaryLocationCalculationOutput(2.0);
GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(hydraulicBoundaryLocation);
failureMechanism.CalculationsGroup.Children.Add(calculation);
var context = new GrassCoverErosionOutwardsFailureMechanismContext(failureMechanism, assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(g => g.ProjectOpened += null).IgnoreArguments();
gui.Stub(g => g.ProjectOpened -= null).IgnoreArguments();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.DocumentViewController).Return(mocks.Stub <IDocumentViewController>());
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
var waveConditionsCalculator = new TestWaveConditionsCosineCalculator
{
Converged = false
};
HydraulicBoundaryCalculationSettings expectedCalculationSettings = HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase);
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings,
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(waveConditionsCalculator)
.Repeat
.Times(6);
mocks.ReplayAll();
plugin.Gui = gui;
plugin.Activate();
using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(context, null, treeViewControl))
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// When
void Call() => contextMenuAdapter.Items[contextMenuCalculateAllIndex].PerformClick();
// Then
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(28, msgs.Length);
Assert.AreEqual($"Golfcondities berekenen voor '{calculation.Name}' is gestart.", msgs.ElementAt(0));
CalculationServiceTestHelper.AssertValidationStartMessage(msgs.ElementAt(1));
CalculationServiceTestHelper.AssertValidationEndMessage(msgs.ElementAt(2));
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs.ElementAt(3));
IEnumerable <RoundedDouble> waterLevels = calculation.InputParameters.GetWaterLevels(
assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result);
Assert.AreEqual(3, waterLevels.Count());
AssertWaveConditionsCalculationMessages(msgs, waterLevels, "golfoploop", 4);
AssertWaveConditionsCalculationMessages(msgs, waterLevels, "golfklap", 15);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs.ElementAt(26));
Assert.AreEqual($"Golfcondities berekenen voor '{calculation.Name}' is gelukt.", msgs.ElementAt(27));
});
}
}
}
/// <summary>
/// Performs a wave conditions calculation based on the supplied <see cref="WaveConditionsInput"/>
/// and returns the output. Error and status information is logged during the execution
/// of the operation.
/// </summary>
/// <param name="waveConditionsInput">The <see cref="WaveConditionsInput"/> that holds all the information
/// required to perform the calculation.</param>
/// <param name="assessmentLevel">The assessment level to use for determining water levels.</param>
/// <param name="a">The 'a' factor decided on failure mechanism level.</param>
/// <param name="b">The 'b' factor decided on failure mechanism level.</param>
/// <param name="c">The 'c' factor decided on failure mechanism level.</param>
/// <param name="targetProbability">The target probability to use.</param>
/// <param name="hydraulicBoundaryDatabase">The hydraulic boundary database to perform the calculations with.</param>
/// <returns>An <see cref="IEnumerable{T}"/> of <see cref="WaveConditionsOutput"/>.</returns>
/// <remarks>Preprocessing is disabled when the preprocessor directory equals <see cref="string.Empty"/>.</remarks>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="waveConditionsInput"/> or
/// <paramref name="hydraulicBoundaryDatabase"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when the hydraulic boundary database file path
/// contains invalid characters.</exception>
/// <exception cref="CriticalFileReadException">Thrown when:
/// <list type="bullet">
/// <item>No settings database file could be found at the location of the hydraulic boundary database file path
/// with the same name.</item>
/// <item>Unable to open settings database file.</item>
/// <item>Unable to read required data from database file.</item>
/// </list>
/// </exception>
/// <exception cref="HydraRingCalculationException">Thrown when an error occurs during
/// the calculations.</exception>
protected IEnumerable <WaveConditionsOutput> CalculateWaveConditions(WaveConditionsInput waveConditionsInput,
RoundedDouble assessmentLevel,
RoundedDouble a,
RoundedDouble b,
RoundedDouble c,
double targetProbability,
HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
if (waveConditionsInput == null)
{
throw new ArgumentNullException(nameof(waveConditionsInput));
}
if (hydraulicBoundaryDatabase == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryDatabase));
}
var calculationsFailed = 0;
var outputs = new List <WaveConditionsOutput>();
RoundedDouble[] waterLevels = waveConditionsInput.GetWaterLevels(assessmentLevel).ToArray();
foreach (RoundedDouble waterLevel in waterLevels.TakeWhile(waterLevel => !Canceled))
{
try
{
log.Info(string.Format(CultureInfo.CurrentCulture,
Resources.WaveConditionsCalculationService_OnRun_Calculation_for_waterlevel_0_started,
waterLevel));
NotifyProgress(waterLevel, currentStep++, TotalWaterLevelCalculations);
WaveConditionsOutput output = CalculateWaterLevel(waterLevel,
a, b, c, targetProbability,
waveConditionsInput,
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase));
if (output != null)
{
outputs.Add(output);
}
else
{
calculationsFailed++;
outputs.Add(WaveConditionsOutputFactory.CreateFailedOutput(waterLevel, targetProbability));
}
}
finally
{
log.Info(string.Format(CultureInfo.CurrentCulture,
Resources.WaveConditionsCalculationService_OnRun_Calculation_for_waterlevel_0_ended,
waterLevel));
}
}
if (calculationsFailed == waterLevels.Length)
{
string message = string.Format(CultureInfo.CurrentCulture,
Resources.WaveConditionsCalculationService_CalculateWaterLevel_Error_in_wave_conditions_calculation_for_all_waterlevels);
log.Error(message);
throw new HydraRingCalculationException(message);
}
return(outputs);
}
public void GivenValidCalculations_WhenCalculatingAllFromContextMenu_ThenAllCalculationsScheduled()
{
// Given
var assessmentSection = new AssessmentSectionStub
{
HydraulicBoundaryDatabase =
{
FilePath = validFilePath
}
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
var failureMechanism = new DuneErosionFailureMechanism
{
DuneLocationCalculationsForUserDefinedTargetProbabilities =
{
new DuneLocationCalculationsForTargetProbability(0.1),
new DuneLocationCalculationsForTargetProbability(0.01)
}
};
var duneLocation = new TestDuneLocation("Test");
failureMechanism.SetDuneLocations(new[]
{
duneLocation
});
var groupContext = new DuneLocationCalculationsForUserDefinedTargetProbabilitiesGroupContext(failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities,
failureMechanism,
assessmentSection);
var mocks = new MockRepository();
using (var treeViewControl = new TreeViewControl())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(cmp => cmp.Get(groupContext, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.DocumentViewController).Return(mocks.Stub <IDocumentViewController>());
gui.Stub(g => g.ViewHost).Return(mocks.Stub <IViewHost>());
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
var dunesBoundaryConditionsCalculator = new TestDunesBoundaryConditionsCalculator
{
Converged = false
};
calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(dunesBoundaryConditionsCalculator).Repeat.Times(2);
mocks.ReplayAll();
using (var plugin = new DuneErosionPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
plugin.Gui = gui;
plugin.Activate();
using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(groupContext, null, treeViewControl))
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// When
void Call() => contextMenuAdapter.Items[contextMenuCalculateAllIndex].PerformClick();
// Then
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(16, msgs.Length);
const string calculationTypeDisplayName = "Hydraulische belastingen";
const string calculationDisplayName = "Hydraulische belastingenberekening";
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
duneLocation.Name, calculationTypeDisplayName, calculationDisplayName, "1/10", msgs, 0);
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
duneLocation.Name, calculationTypeDisplayName, calculationDisplayName, "1/100", msgs, 8);
});
}
}
}
mocks.VerifyAll();
}
public void PerformDuneLocationCalculationsFromContextMenu_HydraulicBoundaryDatabaseWithUsePreprocessorFalse_SendsRightInputToCalculationService()
{
// Setup
var duneLocationCalculationsForTargetProbability = new DuneLocationCalculationsForTargetProbability(0.01)
{
DuneLocationCalculations =
{
new DuneLocationCalculation(new DuneLocation(1300001, "A", new Point2D(0, 0), new DuneLocation.ConstructionProperties
{
CoastalAreaId = 0,
Offset = 0,
Orientation = 0,
D50 = 0.000007
}))
}
};
var failureMechanism = new DuneErosionFailureMechanism();
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Add(duneLocationCalculationsForTargetProbability);
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
FilePath = validFilePath,
HydraulicLocationConfigurationSettings =
{
CanUsePreprocessor = true,
UsePreprocessor = false,
PreprocessorDirectory = "InvalidPreprocessorDirectory"
}
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(hydraulicBoundaryDatabase);
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase).Return(hydraulicBoundaryDatabase);
assessmentSection.Stub(a => a.Id).Return("13-1");
assessmentSection.Stub(a => a.GetFailureMechanisms()).Return(new[]
{
failureMechanism
});
assessmentSection.Stub(a => a.FailureMechanismContribution)
.Return(FailureMechanismContributionTestFactory.CreateFailureMechanismContribution());
var context = new DuneLocationCalculationsForUserDefinedTargetProbabilityContext(duneLocationCalculationsForTargetProbability,
failureMechanism,
assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(g => g.ViewHost).Return(mocks.Stub <IViewHost>());
var dunesBoundaryConditionsCalculator = new TestDunesBoundaryConditionsCalculator();
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(dunesBoundaryConditionsCalculator);
mocks.ReplayAll();
plugin.Gui = gui;
plugin.Activate();
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
contextMenu.Items[contextMenuCalculateAllIndex].PerformClick();
// Assert
DunesBoundaryConditionsCalculationInput dunesBoundaryConditionsCalculationInput = dunesBoundaryConditionsCalculator.ReceivedInputs.First();
Assert.AreEqual(duneLocationCalculationsForTargetProbability.DuneLocationCalculations[0].DuneLocation.Id,
dunesBoundaryConditionsCalculationInput.HydraulicBoundaryLocationId);
Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(duneLocationCalculationsForTargetProbability.TargetProbability),
dunesBoundaryConditionsCalculationInput.Beta);
}
}
}
public void GivenValidCalculations_WhenCalculatingAllFromContextMenu_ThenLogMessagesAddedOutputSet()
{
// Given
var mockRepository = new MockRepository();
var assessmentSection = new AssessmentSectionStub
{
HydraulicBoundaryDatabase =
{
FilePath = Path.Combine(testDataPath, "HRD ijsselmeer.sqlite")
}
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName");
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
var context = new WaveHeightCalculationsForUserDefinedTargetProbabilitiesGroupContext(
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities,
assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mockRepository);
IGui gui = StubFactory.CreateGuiStub(mockRepository);
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.ProjectStore).Return(mockRepository.Stub <IStoreProject>());
gui.Stub(g => g.DocumentViewController).Return(mockRepository.Stub <IDocumentViewController>());
var waveHeightCalculator = new TestWaveHeightCalculator
{
Converged = false
};
var calculatorFactory = mockRepository.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(waveHeightCalculator)
.Repeat
.Times(2);
mockRepository.ReplayAll();
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (var plugin = new RiskeerPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
plugin.Gui = gui;
plugin.Activate();
using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(context, null, treeViewControl))
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// When
void Call() => contextMenuAdapter.Items[contextMenuRunWaveHeightCalculationsIndex].PerformClick();
// Then
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(16, msgs.Length);
const string calculationTypeDisplayName = "Golfhoogte";
const string calculationDisplayName = "Golfhoogte berekening";
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, calculationTypeDisplayName, calculationDisplayName, "1/4.000", msgs, 0);
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, calculationTypeDisplayName, calculationDisplayName, "1/40.000", msgs, 8);
});
AssertHydraulicBoundaryLocationCalculationOutput(waveHeightCalculator, assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities[0].HydraulicBoundaryLocationCalculations[0].Output);
AssertHydraulicBoundaryLocationCalculationOutput(waveHeightCalculator, assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities[1].HydraulicBoundaryLocationCalculations[0].Output);
}
}
}
mockRepository.VerifyAll();
}