public void GetInitialFailureMechanismResultProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var failureMechanismSectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
const double factorOfStability1 = 1.0 / 10.0;
const double factorOfStability2 = 1.0 / 20.0;
MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario1 =
MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenario(factorOfStability1, section);
MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario2 =
MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenario(factorOfStability2, section);
MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario3 =
MacroStabilityInwardsCalculationScenarioTestFactory.CreateIrrelevantMacroStabilityInwardsCalculationScenario(section);
macroStabilityInwardsCalculationScenario1.Contribution = (RoundedDouble)0.2111;
macroStabilityInwardsCalculationScenario2.Contribution = (RoundedDouble)0.7889;
MacroStabilityInwardsCalculationScenario[] calculations =
{
macroStabilityInwardsCalculationScenario1,
macroStabilityInwardsCalculationScenario2,
macroStabilityInwardsCalculationScenario3
};
// Call
double initialFailureMechanismResultProbability = failureMechanismSectionResult.GetInitialFailureMechanismResultProbability(calculations, 1.1);
// Assert
Assert.AreEqual(0.99052414832077185, initialFailureMechanismResultProbability);
}
public void Constructor_CalculationWithoutOutputAndWithWaternet_ChartDataEmpty()
{
// Setup
MacroStabilityInwardsSurfaceLine surfaceLine = GetSurfaceLineWithGeometry();
MacroStabilityInwardsStochasticSoilProfile stochasticSoilProfile = MacroStabilityInwardsStochasticSoilProfileTestFactory.CreateMacroStabilityInwardsStochasticSoilProfile2D();
var calculation = new MacroStabilityInwardsCalculationScenario
{
InputParameters =
{
SurfaceLine = surfaceLine,
StochasticSoilProfile = stochasticSoilProfile
}
};
// Call
using (new MacroStabilityInwardsCalculatorFactoryConfig())
using (var control = new MacroStabilityInwardsOutputChartControl(calculation,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel))
{
// Assert
IChartControl chartControl = GetChartControl(control);
ChartDataCollection chartData = chartControl.Data;
MacroStabilityInwardsOutputViewChartDataAssert.AssertEmptyChartDataWithEmptySoilLayerAndWithWaternetChartData(chartData);
MacroStabilityInwardsOutputViewChartDataAssert.AssertEmptyOutputChartData(chartData);
Assert.AreEqual(calculation.Name, chartControl.ChartTitle);
}
}
public void GivenViewWithWaternets_WhenWaternetSetEmpty_ThenNoChartData()
{
// 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
MacroStabilityInwardsOutputViewChartDataAssert.AssertInputChartData(calculation, GetChartControl(control).Data);
var calculatorFactory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance;
calculatorFactory.LastCreatedWaternetDailyCalculator.Output = WaternetCalculatorResultTestFactory.CreateEmptyResult();
calculatorFactory.LastCreatedWaternetExtremeCalculator.Output = WaternetCalculatorResultTestFactory.CreateEmptyResult();
// Call
control.UpdateChartData();
// Assert
MacroStabilityInwardsOutputViewChartDataAssert.AssertEmptyWaternetChartData(GetChartControl(control).Data);
}
}
private static MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy CreateStrategyForMultipleScenarios(FailureMechanismSection section)
{
var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
const double factorOfStability1 = 1.0 / 10.0;
const double factorOfStability2 = 1.0 / 20.0;
MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario1 =
MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenario(factorOfStability1, section);
MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario2 =
MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenario(factorOfStability2, section);
MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario3 =
MacroStabilityInwardsCalculationScenarioTestFactory.CreateIrrelevantMacroStabilityInwardsCalculationScenario(section);
macroStabilityInwardsCalculationScenario1.Contribution = (RoundedDouble)0.2111;
macroStabilityInwardsCalculationScenario2.Contribution = (RoundedDouble)0.7889;
MacroStabilityInwardsCalculationScenario[] calculations =
{
macroStabilityInwardsCalculationScenario1,
macroStabilityInwardsCalculationScenario2,
macroStabilityInwardsCalculationScenario3
};
return(new MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy(
sectionResult, calculations, new MacroStabilityInwardsFailureMechanism()));
}
public void GivenPropertiesWithData_WhenChangingProperties_ThenPropertiesSetOnInput()
{
// Given
var calculation = new MacroStabilityInwardsCalculationScenario();
MacroStabilityInwardsInput input = calculation.InputParameters;
var handler = new ObservablePropertyChangeHandler(calculation, input);
var properties = new MacroStabilityInwardsGridSettingsProperties(input, handler);
var random = new Random(21);
bool moveGrid = random.NextBoolean();
var gridDeterminationType = random.NextEnumValue <MacroStabilityInwardsGridDeterminationType>();
var tangentLineDeterminationType = random.NextEnumValue <MacroStabilityInwardsTangentLineDeterminationType>();
double tangentLineZTop = random.NextDouble(2.0, 3.0);
double tangentLineZBottom = random.NextDouble(0.0, 1.0);
int tangentLineNumber = random.Next(1, 51);
// When
properties.MoveGrid = moveGrid;
properties.GridDeterminationType = gridDeterminationType;
properties.TangentLineDeterminationType = tangentLineDeterminationType;
properties.TangentLineZTop = (RoundedDouble)tangentLineZTop;
properties.TangentLineZBottom = (RoundedDouble)tangentLineZBottom;
properties.TangentLineNumber = tangentLineNumber;
// Then
Assert.AreEqual(moveGrid, input.MoveGrid);
Assert.AreEqual(gridDeterminationType, input.GridDeterminationType);
Assert.AreEqual(tangentLineDeterminationType, input.TangentLineDeterminationType);
Assert.AreEqual(tangentLineZTop, input.TangentLineZTop, input.TangentLineZTop.GetAccuracy());
Assert.AreEqual(tangentLineZBottom, input.TangentLineZBottom, input.TangentLineZBottom.GetAccuracy());
Assert.AreEqual(tangentLineNumber, input.TangentLineNumber);
}
public void CloseForData_NestedViewNotCorrespondingToRemovedAssessmentSection_ReturnsFalse()
{
// Setup
var calculation = new MacroStabilityInwardsCalculationScenario();
var calculationGroup = new CalculationGroup();
calculationGroup.Children.Add(calculation);
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(calculationGroup);
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(section => section.FailureMechanismContribution).Return(null);
assessmentSection.Stub(section => section.GetFailureMechanisms()).Return(new[]
{
failureMechanism
});
mocks.ReplayAll();
using (var view = new MacroStabilityInwardsInputView(new MacroStabilityInwardsCalculationScenario(),
new GeneralMacroStabilityInwardsInput(),
assessmentSection,
GetHydraulicBoundaryLocationCalculation))
{
// Call
bool closeForData = info.CloseForData(view, assessmentSection);
// Assert
Assert.IsFalse(closeForData);
mocks.VerifyAll();
}
}
public void Constructor_WithCalculationWithOutput_PropertiesFromCalculation(double sectionLength)
{
// Setup
var calculation = new MacroStabilityInwardsCalculationScenario
{
Output = MacroStabilityInwardsOutputTestFactory.CreateOutput(new MacroStabilityInwardsOutput.ConstructionProperties
{
FactorOfStability = 0.1
})
};
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
var failureMechanismSection = new FailureMechanismSection("test", new[]
{
new Point2D(0, 0),
new Point2D(sectionLength, 0)
});
// Call
var row = new MacroStabilityInwardsScenarioRow(calculation, failureMechanism, failureMechanismSection);
// Assert
DerivedMacroStabilityInwardsOutput expectedDerivedOutput = DerivedMacroStabilityInwardsOutputFactory.Create(calculation.Output, failureMechanism.GeneralInput.ModelFactor);
Assert.AreEqual(expectedDerivedOutput.MacroStabilityInwardsProbability, row.FailureProbability);
Assert.AreEqual(Math.Min(1.0, expectedDerivedOutput.MacroStabilityInwardsProbability * failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(
failureMechanismSection.Length)),
row.SectionFailureProbability);
}
public void Create_SoilProfileWithMultiplePreconsolidationStressesOnOneLayer_ReturnsPersistableStates()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(
new TestHydraulicBoundaryLocation());
calculation.InputParameters.StochasticSoilProfile = MacroStabilityInwardsStochasticSoilProfileTestFactory.CreateMacroStabilityInwardsStochasticSoilProfile2D(new[]
{
MacroStabilityInwardsPreconsolidationStressTestFactory.CreateMacroStabilityInwardsPreconsolidationStress(new Point2D(2, 1)),
MacroStabilityInwardsPreconsolidationStressTestFactory.CreateMacroStabilityInwardsPreconsolidationStress(new Point2D(2, 2))
});
IMacroStabilityInwardsSoilProfileUnderSurfaceLine soilProfile = calculation.InputParameters.SoilProfileUnderSurfaceLine;
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
PersistableGeometryFactory.Create(soilProfile, idFactory, registry);
// Call
IEnumerable <PersistableState> states = PersistableStateFactory.Create(soilProfile, idFactory, registry);
// Assert
Assert.AreEqual(1, states.Count());
PersistableState state = states.First();
Assert.IsNotNull(state.Id);
CollectionAssert.IsEmpty(state.StateLines);
CollectionAssert.IsEmpty(state.StatePoints);
}
public void GivenPropertiesWithData_WhenChangingProperties_ThenPropertiesSetOnInput()
{
// Given
var calculation = new MacroStabilityInwardsCalculationScenario();
MacroStabilityInwardsInput input = calculation.InputParameters;
var handler = new ObservablePropertyChangeHandler(calculation, input);
var properties = new MacroStabilityInwardsSlipPlaneSettingsProperties(input, handler);
var random = new Random(21);
bool createZones = random.NextBoolean();
var determinationType = random.NextEnumValue <MacroStabilityInwardsZoningBoundariesDeterminationType>();
RoundedDouble boundaryLeft = random.NextRoundedDouble();
RoundedDouble boundaryRight = random.NextRoundedDouble();
// When
properties.CreateZones = createZones;
properties.ZoningBoundariesDeterminationType = determinationType;
properties.ZoneBoundaryLeft = boundaryLeft;
properties.ZoneBoundaryRight = boundaryRight;
// Then
Assert.AreEqual(createZones, input.CreateZones);
Assert.AreEqual(determinationType, input.ZoningBoundariesDeterminationType);
Assert.AreEqual(boundaryLeft, input.ZoneBoundaryLeft, input.ZoneBoundaryLeft.GetAccuracy());
Assert.AreEqual(boundaryRight, input.ZoneBoundaryRight, input.ZoneBoundaryRight.GetAccuracy());
}
public void GivenPropertiesWithData_WhenChangingProperties_ThenPropertiesSetOnGrid()
{
// Given
var calculation = new MacroStabilityInwardsCalculationScenario();
MacroStabilityInwardsInput input = calculation.InputParameters;
MacroStabilityInwardsGrid grid = input.LeftGrid;
var handler = new ObservablePropertyChangeHandler(calculation, input);
var properties = new MacroStabilityInwardsGridProperties(grid, handler, false);
var random = new Random(21);
RoundedDouble xLeft = random.NextRoundedDouble();
var xRight = (RoundedDouble)(1 + random.NextDouble());
var zTop = (RoundedDouble)(1 + random.NextDouble());
RoundedDouble zBottom = random.NextRoundedDouble();
int numberOfHorizontalPoints = random.Next(1, 100);
int numberOfVerticalPoints = random.Next(1, 100);
// When
properties.XLeft = xLeft;
properties.XRight = xRight;
properties.ZTop = zTop;
properties.ZBottom = zBottom;
properties.NumberOfHorizontalPoints = numberOfHorizontalPoints;
properties.NumberOfVerticalPoints = numberOfVerticalPoints;
// Then
Assert.AreEqual(xLeft, grid.XLeft, grid.XLeft.GetAccuracy());
Assert.AreEqual(xRight, grid.XRight, grid.XRight.GetAccuracy());
Assert.AreEqual(zTop, grid.ZTop, grid.ZTop.GetAccuracy());
Assert.AreEqual(zBottom, grid.ZBottom, grid.ZBottom.GetAccuracy());
Assert.AreEqual(numberOfHorizontalPoints, grid.NumberOfHorizontalPoints);
Assert.AreEqual(numberOfVerticalPoints, grid.NumberOfVerticalPoints);
}
public void Create_WithValidData_ReturnsPersistableStates()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
MacroStabilityInwardsStochasticSoilProfile stochasticSoilProfile = MacroStabilityInwardsStochasticSoilProfileTestFactory.CreateMacroStabilityInwardsStochasticSoilProfile2D(new[]
{
MacroStabilityInwardsPreconsolidationStressTestFactory.CreateMacroStabilityInwardsPreconsolidationStress(new Point2D(2, 1))
});
IMacroStabilityInwardsSoilLayer lastLayer = stochasticSoilProfile.SoilProfile.Layers.Last();
lastLayer.Data.UsePop = true;
lastLayer.Data.Pop = new VariationCoefficientLogNormalDistribution
{
Mean = (RoundedDouble)1,
CoefficientOfVariation = (RoundedDouble)2
};
calculation.InputParameters.StochasticSoilProfile = stochasticSoilProfile;
IMacroStabilityInwardsSoilProfileUnderSurfaceLine soilProfile = calculation.InputParameters.SoilProfileUnderSurfaceLine;
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
PersistableGeometryFactory.Create(soilProfile, idFactory, registry);
// Call
IEnumerable <PersistableState> states = PersistableStateFactory.Create(soilProfile, idFactory, registry);
// Assert
PersistableDataModelTestHelper.AssertStates(soilProfile, states);
PersistableState state = states.First();
Assert.AreEqual(registry.States[MacroStabilityInwardsExportStageType.Daily], state.Id);
}
/// <summary>
/// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
/// are clones.
/// </summary>
/// <param name="original">The original object.</param>
/// <param name="clone">The cloned object.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="original"/> and
/// <paramref name="clone"/> are not clones.</exception>
public static void AreClones(MacroStabilityInwardsCalculationScenario original,
MacroStabilityInwardsCalculationScenario clone)
{
Assert.AreEqual(original.Contribution, clone.Contribution);
Assert.AreEqual(original.IsRelevant, clone.IsRelevant);
AreClones((MacroStabilityInwardsCalculation)original, clone);
}
/// <summary>
/// Creates a scenario for which the surface line on the input intersects with <paramref name="section"/> and
/// is marked as not relevant for the assessment.
/// </summary>
/// <param name="section">The section for which an intersection will be created.</param>
/// <returns>A new <see cref="MacroStabilityInwardsCalculationScenario"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="section"/> is <c>null</c>.</exception>
public static MacroStabilityInwardsCalculationScenario CreateIrrelevantMacroStabilityInwardsCalculationScenario(FailureMechanismSection section)
{
MacroStabilityInwardsCalculationScenario scenario = CreateMacroStabilityInwardsCalculationScenario(0.2, section);
scenario.IsRelevant = false;
return(scenario);
}
/// <summary>
/// Creates a scenario for which the surface line on the input intersects with <paramref name="section"/> and
/// the calculation has not been performed.
/// </summary>
/// <param name="section">The section for which an intersection will be created.</param>
/// <returns>A new <see cref="MacroStabilityInwardsCalculationScenario"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="section"/> is <c>null</c>.</exception>
public static MacroStabilityInwardsCalculationScenario CreateNotCalculatedMacroStabilityInwardsCalculationScenario(FailureMechanismSection section)
{
if (section == null)
{
throw new ArgumentNullException(nameof(section));
}
var surfaceLine = new MacroStabilityInwardsSurfaceLine(string.Empty);
Point2D p = section.Points.First();
surfaceLine.SetGeometry(new[]
{
new Point3D(p.X, p.Y, 0),
new Point3D(p.X + 2, p.Y + 2, 0)
});
surfaceLine.ReferenceLineIntersectionWorldPoint = section.Points.First();
var scenario = new MacroStabilityInwardsCalculationScenario
{
IsRelevant = true,
InputParameters =
{
SurfaceLine = surfaceLine
}
};
return(scenario);
}
public void CloseForData_NestedViewNotCorrespondingWithRemovedParentCalculationGroupContext_ReturnsFalse()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculation = new MacroStabilityInwardsCalculationScenario();
var nestedGroup = new CalculationGroup();
nestedGroup.Children.Add(calculation);
var calculationGroup = new CalculationGroup();
calculationGroup.Children.Add(nestedGroup);
var calculationGroupContext = new MacroStabilityInwardsCalculationGroupContext(new CalculationGroup(),
null,
Enumerable.Empty <MacroStabilityInwardsSurfaceLine>(),
Enumerable.Empty <MacroStabilityInwardsStochasticSoilModel>(),
new MacroStabilityInwardsFailureMechanism(),
assessmentSection);
using (var view = new MacroStabilityInwardsInputView(calculation,
new GeneralMacroStabilityInwardsInput(),
assessmentSection,
GetHydraulicBoundaryLocationCalculation))
{
// Call
bool closeForData = info.CloseForData(view, calculationGroupContext);
// Assert
Assert.IsFalse(closeForData);
mocks.VerifyAll();
}
}
public void Run_ValidMacroStabilityInwardsCalculation_PerformMacroStabilityInwardsValidationAndCalculationAndLogStartAndEnd()
{
// Setup
MacroStabilityInwardsCalculationScenario validMacroStabilityInwardsCalculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
var activity = new MacroStabilityInwardsCalculationActivity(validMacroStabilityInwardsCalculation,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel());
// Call
Action call = () => activity.Run();
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(7, msgs.Length);
Assert.AreEqual($"Uitvoeren van berekening '{validMacroStabilityInwardsCalculation.Name}' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
Assert.AreEqual("Validatie van waterspanningen in extreme omstandigheden is gestart.", msgs[2]);
Assert.AreEqual("Validatie van waterspanningen in dagelijkse omstandigheden is gestart.", msgs[3]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[4]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[5]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[6]);
});
Assert.AreEqual(ActivityState.Executed, activity.State);
Assert.IsNotNull(validMacroStabilityInwardsCalculation.Output);
}
}
public void CloseForData_NestedViewCorrespondingToRemovedFailureMechanismContext_ReturnsTrue()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculation = new MacroStabilityInwardsCalculationScenario();
var calculationGroup = new CalculationGroup();
calculationGroup.Children.Add(calculation);
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(calculationGroup);
var context = new MacroStabilityInwardsFailureMechanismContext(failureMechanism, assessmentSection);
using (var view = new MacroStabilityInwardsInputView(calculation,
new GeneralMacroStabilityInwardsInput(),
assessmentSection,
GetHydraulicBoundaryLocationCalculation))
{
// Call
bool closeForData = info.CloseForData(view, context);
// Assert
Assert.IsTrue(closeForData);
mocks.VerifyAll();
}
}
public void Finish_ValidMacroStabilityInwardsCalculationAndRan_NotifyObserversOfMacroStabilityInwardsCalculation()
{
// Setup
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
MacroStabilityInwardsCalculationScenario validMacroStabilityInwardsCalculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
validMacroStabilityInwardsCalculation.Output = null;
validMacroStabilityInwardsCalculation.Attach(observer);
var activity = new MacroStabilityInwardsCalculationActivity(validMacroStabilityInwardsCalculation,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel());
activity.Run();
// Call
activity.Finish();
// Assert
mocks.VerifyAll();
}
public void GivenScenarioRow_WhenOutputSetToNullAndUpdate_ThenDerivedOutputUpdated()
{
// Given
var calculation = new MacroStabilityInwardsCalculationScenario
{
Output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput()
};
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var row = new MacroStabilityInwardsScenarioRow(calculation, failureMechanism, failureMechanismSection);
// Precondition
DerivedMacroStabilityInwardsOutput expectedDerivedOutput = DerivedMacroStabilityInwardsOutputFactory.Create(calculation.Output, failureMechanism.GeneralInput.ModelFactor);
Assert.AreEqual(expectedDerivedOutput.MacroStabilityInwardsProbability, row.FailureProbability);
Assert.AreEqual(expectedDerivedOutput.MacroStabilityInwardsProbability * failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(
failureMechanismSection.Length),
row.SectionFailureProbability);
// When
calculation.Output = null;
row.Update();
// Then
Assert.IsNaN(row.FailureProbability);
Assert.IsNaN(row.SectionFailureProbability);
}
public void Run_InvalidMacroStabilityInwardsCalculation_LogValidationStartAndEndWithErrors()
{
// Setup
MacroStabilityInwardsCalculationScenario invalidMacroStabilityInwardsCalculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithInvalidInput();
var activity = new MacroStabilityInwardsCalculationActivity(invalidMacroStabilityInwardsCalculation,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel());
// Call
Action call = () => activity.Run();
// Assert
TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
{
Tuple <string, Level, Exception>[] tupleArray = messages.ToArray();
string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
Assert.AreEqual(6, msgs.Length);
Assert.AreEqual($"Uitvoeren van berekening '{invalidMacroStabilityInwardsCalculation.Name}' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
Assert.AreEqual(Level.Error, tupleArray[2].Item2);
Assert.AreEqual(Level.Error, tupleArray[3].Item2);
Assert.AreEqual(Level.Error, tupleArray[4].Item2);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[5]);
});
Assert.AreEqual(ActivityState.Failed, activity.State);
}
public void GivenAssessmentSectionResultObserverWithAttachedObserver_WhenMacroStabilityInwardsCalculationScenarioNotified_ThenAttachedObserverNotified()
{
// Given
AssessmentSection assessmentSection = CreateAssessmentSection();
MacroStabilityInwardsCalculationScenario calculation =
MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithInvalidInput();
assessmentSection.MacroStabilityInwards.CalculationsGroup.Children.Add(calculation);
using (var resultObserver = new AssessmentSectionResultObserver(assessmentSection))
{
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
resultObserver.Attach(observer);
// When
calculation.NotifyObservers();
// Then
mocks.VerifyAll();
}
}
public void CreateCalculationFeatures_GivenCalculations_ReturnsCalculationFeaturesCollection()
{
// Setup
MacroStabilityInwardsCalculationScenario calculationA = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new HydraulicBoundaryLocation(1, string.Empty, 5.0, 4.0));
MacroStabilityInwardsCalculationScenario calculationB = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new HydraulicBoundaryLocation(1, string.Empty, 2.2, 3.8));
calculationA.InputParameters.SurfaceLine.ReferenceLineIntersectionWorldPoint = new Point2D(1.0, 3.0);
calculationB.InputParameters.SurfaceLine.ReferenceLineIntersectionWorldPoint = new Point2D(1.0, 4.0);
// Call
IEnumerable <MapFeature> features = MacroStabilityInwardsMapDataFeaturesFactory.CreateCalculationFeatures(new[]
{
calculationA,
calculationB
});
// Assert
Assert.AreEqual(2, features.Count());
Assert.AreEqual(1, features.ElementAt(0).MapGeometries.Count());
Assert.AreEqual(1, features.ElementAt(1).MapGeometries.Count());
AssertEqualPointCollections(new[]
{
new Point2D(1.0, 3.0),
new Point2D(5.0, 4.0)
}, features.ElementAt(0).MapGeometries.ElementAt(0));
AssertEqualPointCollections(new[]
{
new Point2D(1.0, 4.0),
new Point2D(2.2, 3.8)
}, features.ElementAt(1).MapGeometries.ElementAt(0));
}
public void CalculateProfileProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
const double factorOfStability1 = 1.0 / 10.0;
const double factorOfStability2 = 1.0 / 20.0;
MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario1 =
MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenario(factorOfStability1, section);
MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario2 =
MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenario(factorOfStability2, section);
MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario3 =
MacroStabilityInwardsCalculationScenarioTestFactory.CreateIrrelevantMacroStabilityInwardsCalculationScenario(section);
macroStabilityInwardsCalculationScenario1.Contribution = (RoundedDouble)0.2111;
macroStabilityInwardsCalculationScenario2.Contribution = (RoundedDouble)0.7889;
MacroStabilityInwardsCalculationScenario[] calculations =
{
macroStabilityInwardsCalculationScenario1,
macroStabilityInwardsCalculationScenario2,
macroStabilityInwardsCalculationScenario3
};
var strategy = new MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy(
sectionResult, calculations, new MacroStabilityInwardsFailureMechanism());
// Call
double profileProbability = strategy.CalculateProfileProbability();
// Assert
Assert.AreEqual(0.99012835, profileProbability, 1e-8);
}
/// <summary>
/// Asserts whether <paramref name="actual"/> corresponds to the output 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 AssertOutputChartData(MacroStabilityInwardsCalculationScenario calculationScenario, ChartDataCollection actual)
{
Assert.AreEqual(nrOfChartData, actual.Collection.Count());
MacroStabilityInwardsViewChartDataAssert.AssertGridChartData(calculationScenario.Output.SlipPlane.LeftGrid,
(ChartPointData)actual.Collection.ElementAt(leftGridIndex));
MacroStabilityInwardsViewChartDataAssert.AssertGridChartData(calculationScenario.Output.SlipPlane.RightGrid,
(ChartPointData)actual.Collection.ElementAt(rightGridIndex));
AssertTangentLinesChartData(calculationScenario.Output.SlipPlane.TangentLines, calculationScenario.InputParameters.SurfaceLine,
(ChartMultipleLineData)actual.Collection.ElementAt(tangentLinesIndex));
AssertSlicesChartData(calculationScenario.Output.SlidingCurve.Slices,
(ChartMultipleAreaData)actual.Collection.ElementAt(slicesIndex));
AssertSliceParametersChartData(calculationScenario.Output.SlidingCurve.Slices,
(ChartDataCollection)actual.Collection.ElementAt(sliceParameterIndex));
AssertSlipPlaneChartData(calculationScenario.Output.SlidingCurve,
(ChartLineData)actual.Collection.ElementAt(slipPlaneIndex));
AssertCircleRadiusChartData(calculationScenario.Output.SlidingCurve.Slices.First().TopLeftPoint,
calculationScenario.Output.SlidingCurve.LeftCircle,
(ChartLineData)actual.Collection.ElementAt(activeCircleRadiusIndex));
AssertCircleRadiusChartData(calculationScenario.Output.SlidingCurve.Slices.Last().TopRightPoint,
calculationScenario.Output.SlidingCurve.RightCircle,
(ChartLineData)actual.Collection.ElementAt(passiveCircleRadiusIndex));
}
public void Constructor_CalculationWithoutStochasticSoilProfile_ChartDataSetWithDefaultSoilProfileChartDataName()
{
// Setup
MacroStabilityInwardsSurfaceLine surfaceLine = GetSurfaceLineWithGeometry();
var calculation = new MacroStabilityInwardsCalculationScenario
{
InputParameters =
{
SurfaceLine = surfaceLine
}
};
// Call
using (new MacroStabilityInwardsCalculatorFactoryConfig())
using (var control = new MacroStabilityInwardsOutputChartControl(calculation,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel))
{
// Assert
IChartControl chartControl = GetChartControl(control);
ChartDataCollection chartData = chartControl.Data;
MacroStabilityInwardsViewChartDataAssert.AssertSoilProfileChartData(calculation.InputParameters.SoilProfileUnderSurfaceLine,
"Ondergrondschematisatie",
false,
chartData.Collection.ElementAt(soilProfileIndex));
Assert.AreEqual(calculation.Name, chartControl.ChartTitle);
}
}
private static void AssertCalculationsMapData(IEnumerable <MacroStabilityInwardsCalculationScenario> calculations, MapData mapData)
{
Assert.IsInstanceOf <MapLineData>(mapData);
var calculationsMapData = (MapLineData)mapData;
MacroStabilityInwardsCalculationScenario[] calculationsArray = calculations.ToArray();
MapFeature[] calculationsFeatures = calculationsMapData.Features.ToArray();
Assert.AreEqual(calculationsArray.Length, calculationsFeatures.Length);
for (var index = 0; index < calculationsArray.Length; index++)
{
MapGeometry[] geometries = calculationsFeatures[index].MapGeometries.ToArray();
Assert.AreEqual(1, geometries.Length);
MacroStabilityInwardsCalculationScenario calculation = calculationsArray[index];
CollectionAssert.AreEquivalent(new[]
{
calculation.InputParameters.SurfaceLine.ReferenceLineIntersectionWorldPoint,
calculation.InputParameters.HydraulicBoundaryLocation.Location
},
geometries[0].PointCollections.First());
}
Assert.AreEqual("Berekeningen", mapData.Name);
}
public void GivenCalculationWithStochasticSoilProfileAndSurfaceLine_WhenStochasticSoilProfileUpdate_ThenChartDataUpdated()
{
// Given
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))
{
ChartDataCollection chartData = GetChartControl(control).Data;
// Precondition
MacroStabilityInwardsOutputViewChartDataAssert.AssertInputChartData(calculation, chartData);
MacroStabilityInwardsStochasticSoilProfile newSoilProfile = MacroStabilityInwardsStochasticSoilProfileTestFactory.CreateMacroStabilityInwardsStochasticSoilProfile2D();
// When
calculation.InputParameters.StochasticSoilProfile = newSoilProfile;
control.UpdateChartData();
// Then
MacroStabilityInwardsOutputViewChartDataAssert.AssertInputChartData(calculation, chartData);
}
}
/// <summary>
/// Gets a <see cref="MacroStabilityInwardsCalculationScenario"/> with <c>double.NaN</c> values set.
/// </summary>
/// <returns>A <see cref="MacroStabilityInwardsCalculationScenario"/> with <c>double.NaN</c> values.</returns>
public static MacroStabilityInwardsCalculationScenario GetMacroStabilityInwardsCalculationScenarioWithNaNs()
{
MacroStabilityInwardsCalculationScenario calculation = GetMacroStabilityInwardsCalculationScenarioWithAssessmentLevel();
MacroStabilityInwardsInput input = calculation.InputParameters;
input.WaterLevelRiverAverage = RoundedDouble.NaN;
input.XCoordinateDrainageConstruction = RoundedDouble.NaN;
input.ZCoordinateDrainageConstruction = RoundedDouble.NaN;
input.MinimumLevelPhreaticLineAtDikeTopPolder = RoundedDouble.NaN;
input.MinimumLevelPhreaticLineAtDikeTopRiver = RoundedDouble.NaN;
input.LeakageLengthInwardsPhreaticLine3 = RoundedDouble.NaN;
input.LeakageLengthOutwardsPhreaticLine3 = RoundedDouble.NaN;
input.LeakageLengthInwardsPhreaticLine4 = RoundedDouble.NaN;
input.LeakageLengthOutwardsPhreaticLine4 = RoundedDouble.NaN;
input.PiezometricHeadPhreaticLine2Inwards = RoundedDouble.NaN;
input.PiezometricHeadPhreaticLine2Outwards = RoundedDouble.NaN;
input.AssessmentLevel = RoundedDouble.NaN;
input.SlipPlaneMinimumDepth = RoundedDouble.NaN;
input.SlipPlaneMinimumLength = RoundedDouble.NaN;
input.MaximumSliceWidth = RoundedDouble.NaN;
input.TangentLineZTop = RoundedDouble.NaN;
input.TangentLineZBottom = RoundedDouble.NaN;
input.LeftGrid.XLeft = RoundedDouble.NaN;
input.LeftGrid.XRight = RoundedDouble.NaN;
input.LeftGrid.ZTop = RoundedDouble.NaN;
input.LeftGrid.ZBottom = RoundedDouble.NaN;
input.RightGrid.XLeft = RoundedDouble.NaN;
input.RightGrid.XRight = RoundedDouble.NaN;
input.RightGrid.ZTop = RoundedDouble.NaN;
input.RightGrid.ZBottom = RoundedDouble.NaN;
IMacroStabilityInwardsLocationInputDaily inputDaily = input.LocationInputDaily;
inputDaily.WaterLevelPolder = RoundedDouble.NaN;
inputDaily.PhreaticLineOffsetBelowDikeTopAtRiver = RoundedDouble.NaN;
inputDaily.PhreaticLineOffsetBelowDikeTopAtPolder = RoundedDouble.NaN;
inputDaily.PhreaticLineOffsetBelowShoulderBaseInside = RoundedDouble.NaN;
inputDaily.PhreaticLineOffsetBelowDikeToeAtPolder = RoundedDouble.NaN;
IMacroStabilityInwardsLocationInputExtreme inputExtreme = input.LocationInputExtreme;
inputExtreme.PenetrationLength = RoundedDouble.NaN;
inputExtreme.WaterLevelPolder = RoundedDouble.NaN;
inputExtreme.PhreaticLineOffsetBelowDikeTopAtRiver = RoundedDouble.NaN;
inputExtreme.PhreaticLineOffsetBelowDikeTopAtPolder = RoundedDouble.NaN;
inputExtreme.PhreaticLineOffsetBelowShoulderBaseInside = RoundedDouble.NaN;
inputExtreme.PhreaticLineOffsetBelowDikeToeAtPolder = RoundedDouble.NaN;
input.ZoneBoundaryLeft = RoundedDouble.NaN;
input.ZoneBoundaryRight = RoundedDouble.NaN;
return(calculation);
}
public void IsEnabled_CalculationGroupChildIsNestedGroupWithCalculationWithAndWithoutOutput_ReturnTrue()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculation = new MacroStabilityInwardsCalculationScenario
{
Output = MacroStabilityInwardsOutputTestFactory.CreateOutput()
};
var nestedGroup = new CalculationGroup();
nestedGroup.Children.Add(calculation);
nestedGroup.Children.Add(new MacroStabilityInwardsCalculationScenario());
var calculationGroup = new CalculationGroup();
calculationGroup.Children.Add(nestedGroup);
var context = new MacroStabilityInwardsCalculationGroupContext(calculationGroup,
null,
Enumerable.Empty <MacroStabilityInwardsSurfaceLine>(),
Enumerable.Empty <MacroStabilityInwardsStochasticSoilModel>(),
new MacroStabilityInwardsFailureMechanism(),
assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
public void GetInitialFailureMechanismResultProbability_ScenarioWithNaNResults_ReturnsNaN()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var failureMechanismSectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
const double contribution1 = 0.2;
const double contribution2 = 0.8;
MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario1 =
MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithNaNOutput(section);
MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario2 =
MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenario(section);
macroStabilityInwardsCalculationScenario1.IsRelevant = true;
macroStabilityInwardsCalculationScenario1.Contribution = (RoundedDouble)contribution1;
macroStabilityInwardsCalculationScenario2.IsRelevant = true;
macroStabilityInwardsCalculationScenario2.Contribution = (RoundedDouble)contribution2;
MacroStabilityInwardsCalculationScenario[] calculations =
{
macroStabilityInwardsCalculationScenario1,
macroStabilityInwardsCalculationScenario2
};
// Call
double initialFailureMechanismResultProbability = failureMechanismSectionResult.GetInitialFailureMechanismResultProbability(calculations, 0.1);
// Assert
Assert.IsNaN(initialFailureMechanismResultProbability);
}