/// <summary>
/// Asserts whether the <see cref="PersistableDataModel"/> contains the data
/// that is representative for the <paramref name="calculation"/>
/// and the <paramref name="filePath"/>.
/// </summary>
/// <param name="calculation">The calculation that contains the original data.</param>
/// <param name="filePath">The file path that is used.</param>
/// <param name="persistableDataModel">The <see cref="PersistableDataModel"/> that needs to be asserted.</param>
/// <exception cref="AssertionException">Thrown when the data in <paramref name="persistableDataModel"/>
/// is not correct.</exception>
public static void AssertPersistableDataModel(MacroStabilityInwardsCalculation calculation, string filePath, PersistableDataModel persistableDataModel)
{
AssertProjectInfo(calculation, filePath, persistableDataModel.Info);
AssertCalculationSettings(calculation.Output.SlidingCurve, persistableDataModel.CalculationSettings);
IEnumerable <MacroStabilityInwardsSoilLayer2D> layers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(calculation.InputParameters.SoilProfileUnderSurfaceLine.Layers);
AssertPersistableSoils(layers, persistableDataModel.Soils.Soils);
AssertPersistableGeometry(layers, persistableDataModel.Geometry);
AssertPersistableSoilLayers(layers, persistableDataModel.SoilLayers, persistableDataModel.Soils.Soils, persistableDataModel.Geometry);
AssertWaternets(new[]
{
DerivedMacroStabilityInwardsInput.GetWaternetDaily(calculation.InputParameters, new GeneralMacroStabilityInwardsInput()),
DerivedMacroStabilityInwardsInput.GetWaternetExtreme(calculation.InputParameters, new GeneralMacroStabilityInwardsInput(), RoundedDouble.NaN)
}, persistableDataModel.Waternets);
AssertWaternetCreatorSettings(calculation.InputParameters, persistableDataModel.WaternetCreatorSettings, AssessmentSectionTestHelper.GetTestAssessmentLevel(), new[]
{
MacroStabilityInwardsExportStageType.Daily,
MacroStabilityInwardsExportStageType.Extreme
});
AssertStates(calculation.InputParameters.SoilProfileUnderSurfaceLine, persistableDataModel.States);
Assert.IsNull(persistableDataModel.AssessmentResults);
Assert.IsNull(persistableDataModel.Decorations);
Assert.IsNull(persistableDataModel.Loads);
Assert.IsNull(persistableDataModel.NailPropertiesForSoils);
Assert.IsNull(persistableDataModel.Reinforcements);
Assert.IsNull(persistableDataModel.SoilCorrelations);
Assert.IsNull(persistableDataModel.SoilVisualizations);
Assert.IsNull(persistableDataModel.StateCorrelations);
AssertStages(persistableDataModel.Stages, persistableDataModel.CalculationSettings, persistableDataModel.Geometry, persistableDataModel.SoilLayers,
persistableDataModel.Waternets, persistableDataModel.WaternetCreatorSettings, persistableDataModel.States);
}
private void UpdateInputChartData()
{
MacroStabilityInwardsInput input = data.InputParameters;
MacroStabilityInwardsSurfaceLine surfaceLine = input.SurfaceLine;
IMacroStabilityInwardsSoilProfile <IMacroStabilityInwardsSoilLayer> soilProfile = input.StochasticSoilProfile?.SoilProfile;
if (!ReferenceEquals(currentSoilProfile, soilProfile) || !ReferenceEquals(currentSurfaceLine, surfaceLine))
{
currentSoilProfile = soilProfile;
currentSurfaceLine = surfaceLine;
SetSoilProfileChartData();
}
SetWaternetExtremeChartData(DerivedMacroStabilityInwardsInput.GetWaternetExtreme(input, generalInput, GetEffectiveAssessmentLevel()));
SetWaternetDailyChartData(DerivedMacroStabilityInwardsInput.GetWaternetDaily(input, generalInput));
if (data.Output != null)
{
SetSurfaceLineChartData(surfaceLine);
SetSoilLayerAreas();
SetWaternetDatas(surfaceLine);
}
else
{
SetSurfaceLineChartData(null);
SetEmptySoilLayerAreas();
SetEmptyWaternets();
}
soilProfileChartData.Collection.ForEachElementDo(sp => sp.NotifyObservers());
waternetZonesDailyChartData.Collection.ForEachElementDo(cd => cd.NotifyObservers());
waternetZonesExtremeChartData.Collection.ForEachElementDo(cd => cd.NotifyObservers());
}
public void GetWaternetExtreme_InputNull_ThrowsArgumentNullException()
{
// Call
void Call() => DerivedMacroStabilityInwardsInput.GetWaternetExtreme(null, new GeneralMacroStabilityInwardsInput(), RoundedDouble.NaN);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("input", exception.ParamName);
}
public void GetWaternetExtreme_GeneralInputNull_ThrowsArgumentNullException()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
// Call
void Call() => DerivedMacroStabilityInwardsInput.GetWaternetExtreme(calculation.InputParameters, null, RoundedDouble.NaN);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("generalInput", exception.ParamName);
}
/// <summary>
/// Asserts whether <paramref name="actual"/> corresponds to the input of <paramref name="calculationScenario"/>.
/// </summary>
/// <param name="calculationScenario">The original <see cref="MacroStabilityInwardsCalculationScenario"/>.</param>
/// <param name="actual">The actual <see cref="ChartDataCollection"/>.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="actual"/>
/// does not correspond to <paramref name="calculationScenario"/>.</exception>
public static void AssertInputChartData(MacroStabilityInwardsCalculationScenario calculationScenario, ChartDataCollection actual)
{
Assert.AreEqual(nrOfChartData, actual.Collection.Count());
MacroStabilityInwardsViewChartDataAssert.AssertSurfaceLineChartData(calculationScenario.InputParameters.SurfaceLine, actual.Collection.ElementAt(surfaceLineIndex));
MacroStabilityInwardsViewChartDataAssert.AssertSoilProfileChartData(calculationScenario.InputParameters.SoilProfileUnderSurfaceLine,
calculationScenario.InputParameters.StochasticSoilProfile.SoilProfile.Name,
true,
actual.Collection.ElementAt(soilProfileIndex));
AssertWaternetChartData(DerivedMacroStabilityInwardsInput.GetWaternetExtreme(calculationScenario.InputParameters, new GeneralMacroStabilityInwardsInput(), RoundedDouble.NaN),
(ChartDataCollection)actual.Collection.ElementAt(waternetZonesExtremeIndex));
AssertWaternetChartData(DerivedMacroStabilityInwardsInput.GetWaternetDaily(calculationScenario.InputParameters, new GeneralMacroStabilityInwardsInput()),
(ChartDataCollection)actual.Collection.ElementAt(waternetZonesDailyIndex));
}
/// <summary>
/// Creates a new <see cref="PersistableDataModel"/>.
/// </summary>
/// <param name="calculation">The calculation to get the data from.</param>
/// <param name="generalInput">General calculation parameters that are the same across all calculations.</param>
/// <param name="getNormativeAssessmentLevelFunc"><see cref="Func{TResult}"/>
/// for obtaining the normative assessment level.</param>
/// <param name="filePath">The filePath that is used.</param>
/// <returns>A created <see cref="PersistableDataModel"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/>,
/// <paramref name="generalInput"/> or <paramref name="getNormativeAssessmentLevelFunc"/> is <c>null</c>.</exception>
/// <exception cref="InvalidOperationException">Thrown when <paramref name="calculation"/>
/// has no output.</exception>
public static PersistableDataModel Create(MacroStabilityInwardsCalculation calculation,
GeneralMacroStabilityInwardsInput generalInput,
Func <RoundedDouble> getNormativeAssessmentLevelFunc,
string filePath)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
if (getNormativeAssessmentLevelFunc == null)
{
throw new ArgumentNullException(nameof(getNormativeAssessmentLevelFunc));
}
if (!calculation.HasOutput)
{
throw new InvalidOperationException("Calculation must have output.");
}
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
MacroStabilityInwardsInput input = calculation.InputParameters;
IMacroStabilityInwardsSoilProfileUnderSurfaceLine soilProfile = input.SoilProfileUnderSurfaceLine;
return(new PersistableDataModel
{
Info = PersistableProjectInfoFactory.Create(calculation, filePath),
CalculationSettings = PersistableCalculationSettingsFactory.Create(calculation.Output.SlidingCurve, idFactory, registry),
Soils = PersistableSoilCollectionFactory.Create(soilProfile, idFactory, registry),
Geometry = PersistableGeometryFactory.Create(soilProfile, idFactory, registry),
SoilLayers = PersistableSoilLayerCollectionFactory.Create(soilProfile, idFactory, registry),
Waternets = PersistableWaternetFactory.Create(
DerivedMacroStabilityInwardsInput.GetWaternetDaily(input, generalInput),
DerivedMacroStabilityInwardsInput.GetWaternetExtreme(input, generalInput, GetEffectiveAssessmentLevel(input, getNormativeAssessmentLevelFunc)),
generalInput, idFactory, registry),
WaternetCreatorSettings = PersistableWaternetCreatorSettingsFactory.Create(input, GetEffectiveAssessmentLevel(input, getNormativeAssessmentLevelFunc),
idFactory, registry),
States = PersistableStateFactory.Create(soilProfile, idFactory, registry),
Stages = PersistableStageFactory.Create(idFactory, registry)
});
}
public void GetWaternetDaily_ValidInput_ReturnsMacroStabilityInwardsWaternet()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
MacroStabilityInwardsWaternet waternet = DerivedMacroStabilityInwardsInput.GetWaternetDaily(calculation.InputParameters, new GeneralMacroStabilityInwardsInput());
// Assert
var calculatorFactory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance;
CalculatorOutputAssert.AssertWaternet(calculatorFactory.LastCreatedWaternetDailyCalculator.Output, waternet);
}
}
public void GetWaternetExtreme_SurfaceLineNull_ReturnsMacroStabilityInwardsWaternet()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculation.InputParameters.SurfaceLine = null;
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
MacroStabilityInwardsWaternet waternet = DerivedMacroStabilityInwardsInput.GetWaternetExtreme(calculation.InputParameters, new GeneralMacroStabilityInwardsInput(), RoundedDouble.NaN);
// Assert
Assert.IsNotNull(waternet);
CollectionAssert.IsEmpty(waternet.PhreaticLines);
CollectionAssert.IsEmpty(waternet.WaternetLines);
}
}
public void GetWaternetExtreme_ValidInput_SetsAssessmentLevelToCalculatorInputAndReturnsMacroStabilityInwardsWaternet()
{
// Setup
RoundedDouble assessmentLevel = new Random(21).NextRoundedDouble();
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
MacroStabilityInwardsWaternet waternet = DerivedMacroStabilityInwardsInput.GetWaternetExtreme(calculation.InputParameters, new GeneralMacroStabilityInwardsInput(), assessmentLevel);
// Assert
var calculatorFactory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance;
WaternetCalculatorStub calculator = calculatorFactory.LastCreatedWaternetExtremeCalculator;
Assert.AreEqual(assessmentLevel, calculator.Input.AssessmentLevel);
CalculatorOutputAssert.AssertWaternet(calculator.Output, waternet);
}
}
private void SetChartData()
{
MacroStabilityInwardsInput macroStabilityInwardsInput = data.InputParameters;
MacroStabilityInwardsSurfaceLine surfaceLine = macroStabilityInwardsInput.SurfaceLine;
IMacroStabilityInwardsSoilProfile <IMacroStabilityInwardsSoilLayer> soilProfile = macroStabilityInwardsInput.StochasticSoilProfile?.SoilProfile;
hydraulicLocationCalculationObserver.Observable = getHydraulicBoundaryLocationCalculationFunc();
SetSurfaceLineChartData(surfaceLine);
SetSoilProfileChartData(surfaceLine, soilProfile);
SetWaternetExtremeChartData(DerivedMacroStabilityInwardsInput.GetWaternetExtreme(macroStabilityInwardsInput, generalInput, GetEffectiveAssessmentLevel()), surfaceLine);
SetWaternetDailyChartData(DerivedMacroStabilityInwardsInput.GetWaternetDaily(macroStabilityInwardsInput, generalInput), surfaceLine);
MacroStabilityInwardsGridDeterminationType gridDeterminationType = macroStabilityInwardsInput.GridDeterminationType;
MacroStabilityInwardsGrid leftGrid = macroStabilityInwardsInput.LeftGrid;
MacroStabilityInwardsGrid rightGrid = macroStabilityInwardsInput.RightGrid;
leftGridChartData.Points = MacroStabilityInwardsChartDataPointsFactory.CreateGridPoints(leftGrid, gridDeterminationType);
rightGridChartData.Points = MacroStabilityInwardsChartDataPointsFactory.CreateGridPoints(rightGrid, gridDeterminationType);
tangentLinesData.Lines = MacroStabilityInwardsChartDataPointsFactory.CreateTangentLines(macroStabilityInwardsInput.GridDeterminationType,
macroStabilityInwardsInput.TangentLineDeterminationType,
macroStabilityInwardsInput.TangentLineZBottom,
macroStabilityInwardsInput.TangentLineZTop,
macroStabilityInwardsInput.TangentLineNumber,
macroStabilityInwardsInput.SurfaceLine);
currentSoilProfile = soilProfile;
if (surfaceLine != null)
{
if (currentSurfaceLine == null)
{
currentSurfaceLine = new MacroStabilityInwardsSurfaceLine(surfaceLine.Name);
}
currentSurfaceLine.CopyProperties(surfaceLine);
}
else
{
currentSurfaceLine = null;
}
}
public void GivenViewWithWaternets_WhenObserversNotifiedAndWaternetSame_ThenChartDataNotUpdated()
{
// Setup
MacroStabilityInwardsStochasticSoilProfile originalSoilProfile = MacroStabilityInwardsStochasticSoilProfileTestFactory.CreateMacroStabilityInwardsStochasticSoilProfile2D();
var calculation = new MacroStabilityInwardsCalculationScenario
{
InputParameters =
{
StochasticSoilProfile = originalSoilProfile,
SurfaceLine = GetSurfaceLineWithGeometry()
},
Output = MacroStabilityInwardsOutputTestFactory.CreateOutput()
};
using (new MacroStabilityInwardsCalculatorFactoryConfig())
using (var control = new MacroStabilityInwardsOutputChartControl(calculation,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel))
{
// Precondition
ChartData[] chartData = GetChartControl(control).Data.Collection.ToArray();
var waternetExtremeChartDataCollection = (ChartDataCollection)chartData[waternetZonesExtremeIndex];
var waternetDailyChartDataCollection = (ChartDataCollection)chartData[waternetZonesDailyIndex];
MacroStabilityInwardsOutputViewChartDataAssert.AssertWaternetChartData(DerivedMacroStabilityInwardsInput.GetWaternetExtreme(calculation.InputParameters, new GeneralMacroStabilityInwardsInput(), RoundedDouble.NaN),
waternetExtremeChartDataCollection);
MacroStabilityInwardsOutputViewChartDataAssert.AssertWaternetChartData(DerivedMacroStabilityInwardsInput.GetWaternetDaily(calculation.InputParameters, new GeneralMacroStabilityInwardsInput()),
waternetDailyChartDataCollection);
IEnumerable <ChartData> waternetExtremeChartData = waternetExtremeChartDataCollection.Collection;
IEnumerable <ChartData> waternetDailyChartData = waternetDailyChartDataCollection.Collection;
// Call
control.UpdateChartData();
// Assert
CollectionAssert.AreEqual(waternetExtremeChartData, ((ChartDataCollection)chartData[waternetZonesExtremeIndex]).Collection);
CollectionAssert.AreEqual(waternetDailyChartData, ((ChartDataCollection)chartData[waternetZonesDailyIndex]).Collection);
}
}
