public void Finish_ValidPipingCalculationAndRan_NotifyObserversOfPipingCalculation()
{
// Setup
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var validPipingCalculation =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>(
new TestHydraulicBoundaryLocation());
validPipingCalculation.Output = null;
validPipingCalculation.Attach(observer);
var activity = new SemiProbabilisticPipingCalculationActivity(validPipingCalculation,
new GeneralPipingInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel());
activity.Run();
// Call
activity.Finish();
// Assert
mocks.VerifyAll();
}
public void SemiProbabilisticGetInitialFailureMechanismResultProbability_ScenarioWithNaNResults_ReturnsNaN()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var failureMechanismSectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
const double contribution1 = 0.2;
const double contribution2 = 0.8;
var pipingCalculationScenario1 =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
var pipingCalculationScenario2 =
SemiProbabilisticPipingCalculationTestFactory.CreateNotCalculatedCalculation <SemiProbabilisticPipingCalculationScenario>(section);
pipingCalculationScenario1.IsRelevant = true;
pipingCalculationScenario1.Contribution = (RoundedDouble)contribution1;
pipingCalculationScenario2.IsRelevant = true;
pipingCalculationScenario2.Contribution = (RoundedDouble)contribution2;
pipingCalculationScenario2.Output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties());
SemiProbabilisticPipingCalculationScenario[] calculations =
{
pipingCalculationScenario1,
pipingCalculationScenario2
};
// Call
double initialFailureMechanismResultProbability = failureMechanismSectionResult.GetInitialFailureMechanismResultProbability(calculations, 0.1);
// Assert
Assert.IsNaN(initialFailureMechanismResultProbability);
}
public void Run_InvalidPipingCalculation_LogValidationStartAndEndWithErrors()
{
// Setup
var invalidPipingCalculation =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithInvalidInput <TestSemiProbabilisticPipingCalculation>();
var activity = new SemiProbabilisticPipingCalculationActivity(invalidPipingCalculation,
new GeneralPipingInput(),
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(8, msgs.Length);
Assert.AreEqual($"Uitvoeren van berekening '{invalidPipingCalculation.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);
Assert.AreEqual(Level.Error, tupleArray[5].Item2);
Assert.AreEqual(Level.Error, tupleArray[6].Item2);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[7]);
});
Assert.AreEqual(ActivityState.Failed, activity.State);
}
private static SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy CreateStrategyForMultipleScenarios(FailureMechanismSection section)
{
var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var calculationScenario1 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
var calculationScenario2 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
var calculationScenario3 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
calculationScenario1.IsRelevant = true;
calculationScenario1.Contribution = (RoundedDouble)0.2111;
calculationScenario1.Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(0.01, 0.02, 0.03);
calculationScenario2.IsRelevant = true;
calculationScenario2.Contribution = (RoundedDouble)0.7889;
calculationScenario2.Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(0.04, 0.05, 0.06);
calculationScenario3.IsRelevant = false;
SemiProbabilisticPipingCalculationScenario[] calculations =
{
calculationScenario1,
calculationScenario2,
calculationScenario3
};
return(new SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
sectionResult, calculations, new PipingFailureMechanism(), new AssessmentSectionStub()));
}
public static void CalculateEffectiveThicknessCoverageLayer_CompleteInput_InputSetOnSubCalculator()
{
// Setup
var validPipingCalculation =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>(
new TestHydraulicBoundaryLocation());
PipingInput input = validPipingCalculation.InputParameters;
var generalInput = new GeneralPipingInput();
using (new PipingSubCalculatorFactoryConfig())
{
// Call
PipingInput inputParameters = validPipingCalculation.InputParameters;
InputParameterCalculationService.CalculateEffectiveThicknessCoverageLayer(
generalInput.WaterVolumetricWeight,
PipingDesignVariableFactory.GetPhreaticLevelExit(inputParameters).GetDesignValue(),
inputParameters.ExitPointL,
inputParameters.SurfaceLine,
inputParameters.StochasticSoilProfile.SoilProfile);
// Assert
var testFactory = (TestPipingSubCalculatorFactory)PipingSubCalculatorFactory.Instance;
EffectiveThicknessCalculatorStub effectiveThicknessCalculator = testFactory.LastCreatedEffectiveThicknessCalculator;
Assert.AreEqual(input.ExitPointL.Value, effectiveThicknessCalculator.ExitPointXCoordinate);
Assert.AreEqual(PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(),
effectiveThicknessCalculator.PhreaticLevel,
input.PhreaticLevelExit.GetAccuracy());
AssertEqualSoilProfiles(input.StochasticSoilProfile.SoilProfile, effectiveThicknessCalculator.SoilProfile);
AssertEqualSurfaceLines(input.SurfaceLine, effectiveThicknessCalculator.SurfaceLine);
Assert.AreEqual(generalInput.WaterVolumetricWeight, effectiveThicknessCalculator.VolumicWeightOfWater);
}
}
public static void CalculatePiezometricHeadAtExit_CompleteInput_InputSetOnSubCalculator()
{
// Setup
RoundedDouble assessmentLevel = new Random(21).NextRoundedDouble();
var validPipingCalculation =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>(
new TestHydraulicBoundaryLocation());
PipingInput input = validPipingCalculation.InputParameters;
using (new PipingSubCalculatorFactoryConfig())
{
// Call
InputParameterCalculationService.CalculatePiezometricHeadAtExit(
assessmentLevel,
SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(),
PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue());
// Assert
var testFactory = (TestPipingSubCalculatorFactory)PipingSubCalculatorFactory.Instance;
PiezoHeadCalculatorStub piezometricHeadAtExitCalculator = testFactory.LastCreatedPiezometricHeadAtExitCalculator;
Assert.AreEqual(assessmentLevel.Value, piezometricHeadAtExitCalculator.HRiver);
Assert.AreEqual(PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(),
piezometricHeadAtExitCalculator.PhiPolder,
input.PhreaticLevelExit.GetAccuracy());
Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(),
piezometricHeadAtExitCalculator.RExit,
input.DampingFactorExit.GetAccuracy());
}
}
public void GivenAssessmentSectionResultObserverWithAttachedObserver_WhenPipingCalculationScenarioNotified_ThenAttachedObserverNotified()
{
// Given
AssessmentSection assessmentSection = CreateAssessmentSection();
var calculationScenario =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithInvalidInput <SemiProbabilisticPipingCalculationScenario>();
assessmentSection.Piping.CalculationsGroup.Children.Add(calculationScenario);
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
calculationScenario.NotifyObservers();
// Then
mocks.VerifyAll();
}
}
public void Run_ValidPipingCalculation_PerformPipingValidationAndCalculationAndLogStartAndEnd()
{
// Setup
var validPipingCalculation =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>(
new TestHydraulicBoundaryLocation());
var activity = new SemiProbabilisticPipingCalculationActivity(validPipingCalculation,
new GeneralPipingInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel());
// Call
Action call = () => activity.Run();
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(5, msgs.Length);
Assert.AreEqual($"Uitvoeren van berekening '{validPipingCalculation.Name}' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[4]);
});
Assert.AreEqual(ActivityState.Executed, activity.State);
Assert.IsNotNull(validPipingCalculation.Output);
}
public void GivenViewWithCalculationGroupData_WhenCalculationGroupUpdatedAndNotified_ThenMapDataUpdated()
{
// Given
var failureMechanism = new PipingFailureMechanism();
PipingFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub());
IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl;
var surfaceLineA = new PipingSurfaceLine(string.Empty);
surfaceLineA.SetGeometry(new[]
{
new Point3D(0.0, 0.0, 1.0),
new Point3D(3.0, 0.0, 1.7)
});
var surfaceLineB = new PipingSurfaceLine(string.Empty);
surfaceLineB.SetGeometry(new[]
{
new Point3D(0.0, 0.0, 1.5),
new Point3D(3.0, 0.0, 1.8)
});
surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3);
surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5);
var calculationA =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>(
new TestHydraulicBoundaryLocation());
var calculationB =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>(
new TestHydraulicBoundaryLocation());
calculationA.InputParameters.SurfaceLine = surfaceLineA;
calculationB.InputParameters.SurfaceLine = surfaceLineB;
failureMechanism.CalculationsGroup.Children.Add(calculationA);
failureMechanism.CalculationsGroup.Children.Add(calculationB);
var probabilisticCalculationMapData = (MapLineData)map.Data.Collection.ElementAt(probabilisticCalculationsIndex);
var semiProbabilisticCalculationMapData = (MapLineData)map.Data.Collection.ElementAt(semiProbabilisticCalculationsIndex);
var mocks = new MockRepository();
IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection);
observers[semiProbabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver());
observers[probabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver());
mocks.ReplayAll();
// When
failureMechanism.CalculationsGroup.Children.Add(calculationB);
failureMechanism.CalculationsGroup.NotifyObservers();
// Then
AssertSemiProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType <SemiProbabilisticPipingCalculationScenario>(), semiProbabilisticCalculationMapData);
AssertProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType <ProbabilisticPipingCalculationScenario>(), probabilisticCalculationMapData);
mocks.VerifyAll();
}
private static void AddSemiProbabilisticPipingCalculationScenario(AssessmentSection assessmentSection,
HydraulicBoundaryLocation hydraulicBoundaryLocation)
{
var pipingCalculationScenario =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
pipingCalculationScenario.InputParameters.UseAssessmentLevelManualInput = true;
pipingCalculationScenario.InputParameters.AssessmentLevel = new Random(39).NextRoundedDouble();
assessmentSection.Piping.CalculationsGroup.Children.Add(pipingCalculationScenario);
}
public void FailureMechanismResultsView_AllDataSet_DataGridViewCorrectlyInitialized(
PipingScenarioConfigurationType scenarioConfigurationType,
PipingScenarioConfigurationPerFailureMechanismSectionType scenarioConfigurationPerFailureMechanismSectionType,
string probability)
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection("Section 1");
var failureMechanism = new PipingFailureMechanism
{
ScenarioConfigurationType = scenarioConfigurationType
};
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
section
});
failureMechanism.ScenarioConfigurationsPerFailureMechanismSection.First().ScenarioConfigurationType = scenarioConfigurationPerFailureMechanismSectionType;
failureMechanism.CalculationsGroup.Children.Add(
SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section));
failureMechanism.CalculationsGroup.Children.Add(
ProbabilisticPipingCalculationTestFactory.CreateCalculation <ProbabilisticPipingCalculationScenario>(section));
// Call
using (new AssemblyToolCalculatorFactoryConfig())
using (ShowFailureMechanismResultsView(failureMechanism))
{
DataGridView dataGridView = GetDataGridView();
// Assert
DataGridViewRowCollection rows = dataGridView.Rows;
Assert.AreEqual(1, rows.Count);
DataGridViewCellCollection cells = rows[0].Cells;
Assert.AreEqual(columnCount, cells.Count);
Assert.AreEqual("Section 1", cells[nameColumnIndex].FormattedValue);
Assert.AreEqual(true, cells[isRelevantIndex].Value);
Assert.AreEqual(AdoptableInitialFailureMechanismResultType.Adopt, cells[initialFailureMechanismResultTypeIndex].Value);
Assert.AreEqual(probability, cells[initialFailureMechanismResultProfileProbabilityIndex].FormattedValue);
Assert.AreEqual(probability, cells[initialFailureMechanismResultSectionProbabilityIndex].FormattedValue);
Assert.AreEqual(FailureMechanismSectionResultFurtherAnalysisType.NotNecessary, cells[furtherAnalysisTypeIndex].Value);
Assert.AreEqual(ProbabilityRefinementType.Section, cells[probabilityRefinementTypeIndex].Value);
Assert.AreEqual("<afgeleid>", cells[refinedProfileProbabilityIndex].FormattedValue);
Assert.AreEqual("-", cells[refinedSectionProbabilityIndex].FormattedValue);
Assert.AreEqual("1/100", cells[profileProbabilityIndex].FormattedValue);
Assert.AreEqual("1/10", cells[sectionProbabilityIndex].FormattedValue);
Assert.AreEqual("10,00", cells[sectionNIndex].FormattedValue);
Assert.AreEqual("+I", cells[assemblyGroupIndex].FormattedValue);
}
}
public void SemiProbabilisticGetInitialFailureMechanismResultProbability_ScenarioNotCalculated_ReturnsNaN()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var failureMechanismSectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var pipingCalculationScenario =
SemiProbabilisticPipingCalculationTestFactory.CreateNotCalculatedCalculation <SemiProbabilisticPipingCalculationScenario>(section);
// Call
double initialFailureMechanismResultProbability = failureMechanismSectionResult.GetInitialFailureMechanismResultProbability(new[]
{
pipingCalculationScenario
}, 0.1);
// Assert
Assert.IsNaN(initialFailureMechanismResultProbability);
}
public void SemiProbabilisticGetInitialFailureMechanismResultProbability_NoRelevantScenarios_ReturnsNaN()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var failureMechanismSectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var calculationScenario = SemiProbabilisticPipingCalculationTestFactory.CreateNotCalculatedCalculation <SemiProbabilisticPipingCalculationScenario>(section);
calculationScenario.IsRelevant = false;
SemiProbabilisticPipingCalculationScenario[] calculationScenarios =
{
calculationScenario
};
// Call
double initialFailureMechanismResultProbability = failureMechanismSectionResult.GetInitialFailureMechanismResultProbability(calculationScenarios, 0.1);
// Assert
Assert.IsNaN(initialFailureMechanismResultProbability);
}
public void CreateSemiProbabilisticPipingCalculationActivity_WithValidCalculation_ReturnsActivityWithParametersSet()
{
// Setup
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
var assessmentSection = new AssessmentSectionStub
{
FailureMechanismContribution =
{
NormativeProbabilityType = NormativeProbabilityType.MaximumAllowableFloodingProbability
}
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
var random = new Random(39);
HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation = assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.Single();
hydraulicBoundaryLocationCalculation.Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble());
var calculation =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>(
hydraulicBoundaryLocation);
var generalPipingInput = new GeneralPipingInput();
// Call
CalculatableActivity activity = PipingCalculationActivityFactory.CreateSemiProbabilisticPipingCalculationActivity(calculation,
generalPipingInput,
assessmentSection);
// Assert
Assert.IsInstanceOf <SemiProbabilisticPipingCalculationActivity>(activity);
AssertSemiProbabilisticPipingCalculationActivity(activity, calculation, hydraulicBoundaryLocationCalculation);
}
public static void CalculateEffectiveThicknessCoverageLayer_InvalidPipingCalculationWithOutput_ReturnsNaN()
{
// Setup
var invalidPipingCalculation =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>(
new TestHydraulicBoundaryLocation());
// Make invalid by having surface line partially above soil profile:
double highestLevelSurfaceLine = invalidPipingCalculation.InputParameters.SurfaceLine.Points.Max(p => p.Z);
double soilProfileTop = highestLevelSurfaceLine - 0.5;
double soilProfileBottom = soilProfileTop - 0.5;
invalidPipingCalculation.InputParameters.StochasticSoilProfile = new PipingStochasticSoilProfile(
0.0,
new PipingSoilProfile("A", soilProfileBottom, new[]
{
new PipingSoilLayer(soilProfileTop)
{
IsAquifer = true
}
}, SoilProfileType.SoilProfile1D));
var generalInput = new GeneralPipingInput();
// Call
PipingInput input = invalidPipingCalculation.InputParameters;
double result = InputParameterCalculationService.CalculateEffectiveThicknessCoverageLayer(
generalInput.WaterVolumetricWeight,
PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(),
input.ExitPointL,
input.SurfaceLine,
input.StochasticSoilProfile.SoilProfile);
// Assert
Assert.IsNaN(result);
}
public void SemiProbabilisticGetInitialFailureMechanismResultProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var failureMechanismSectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var pipingCalculationScenario1 =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
var pipingCalculationScenario2 =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
var pipingCalculationScenario3 =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
pipingCalculationScenario1.IsRelevant = true;
pipingCalculationScenario1.Contribution = (RoundedDouble)0.2111;
pipingCalculationScenario1.Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(1.1, 2.2, 3.3);
pipingCalculationScenario2.IsRelevant = true;
pipingCalculationScenario2.Contribution = (RoundedDouble)0.7889;
pipingCalculationScenario2.Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(4.4, 5.5, 6.6);
pipingCalculationScenario3.IsRelevant = false;
SemiProbabilisticPipingCalculationScenario[] calculations =
{
pipingCalculationScenario1,
pipingCalculationScenario2,
pipingCalculationScenario3
};
// Call
double initialFailureMechanismResultProbability = failureMechanismSectionResult.GetInitialFailureMechanismResultProbability(calculations, 0.1);
// Assert
Assert.AreEqual(4.2467174336864661e-7, initialFailureMechanismResultProbability);
}
public void CalculateProfileProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var calculationScenario1 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
var calculationScenario2 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
var calculationScenario3 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
calculationScenario1.IsRelevant = true;
calculationScenario1.Contribution = (RoundedDouble)0.2111;
calculationScenario1.Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(1.1, 2.2, 3.3);
calculationScenario2.IsRelevant = true;
calculationScenario2.Contribution = (RoundedDouble)0.7889;
calculationScenario2.Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(4.4, 5.5, 6.6);
calculationScenario3.IsRelevant = false;
SemiProbabilisticPipingCalculationScenario[] calculations =
{
calculationScenario1,
calculationScenario2,
calculationScenario3
};
var strategy = new SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
sectionResult, calculations, new PipingFailureMechanism(), new AssessmentSectionStub());
// Call
double profileProbability = strategy.CalculateProfileProbability();
// Assert
Assert.AreEqual(9.2969543564512289E-16, profileProbability);
}
public void SemiProbabilisticGetInitialFailureMechanismResultProbability_RelevantScenarioContributionsDoNotAddUpTo1_ReturnNaN(double contributionA, double contributionB)
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var pipingCalculationScenarioA =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
var pipingCalculationScenarioB =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
pipingCalculationScenarioA.Contribution = (RoundedDouble)contributionA;
pipingCalculationScenarioB.Contribution = (RoundedDouble)contributionB;
var result = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
// Call
double initialFailureMechanismResultProbability = result.GetInitialFailureMechanismResultProbability(new[]
{
pipingCalculationScenarioA,
pipingCalculationScenarioB
}, 0.1);
// Assert
Assert.IsNaN(initialFailureMechanismResultProbability);
}
public void CreateCalculationActivitiesForFailureMechanism_WithValidCalculations_ReturnsPipingCalculationActivitiesWithParametersSet()
{
// Setup
var assessmentSection = new AssessmentSectionStub
{
FailureMechanismContribution =
{
NormativeProbabilityType = NormativeProbabilityType.MaximumAllowableFloodingProbability
}
};
var hydraulicBoundaryLocation1 = new TestHydraulicBoundaryLocation();
var hydraulicBoundaryLocation2 = new TestHydraulicBoundaryLocation();
TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation1,
hydraulicBoundaryLocation2
});
assessmentSection.HydraulicBoundaryDatabase.FilePath = validHydraulicBoundaryDatabaseFilePath;
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
var random = new Random(39);
HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation1 = assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.First();
hydraulicBoundaryLocationCalculation1.Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble());
HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation2 = assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.ElementAt(1);
hydraulicBoundaryLocationCalculation2.Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble());
var calculation1 =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>(
hydraulicBoundaryLocation1);
var calculation2 =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>(
hydraulicBoundaryLocation1);
var calculation3 =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>(
hydraulicBoundaryLocation2);
var calculation4 =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>(
hydraulicBoundaryLocation2);
failureMechanism.CalculationsGroup.Children.AddRange(new IPipingCalculation <PipingInput>[]
{
calculation1,
calculation2,
calculation3,
calculation4
});
// Call
IEnumerable <CalculatableActivity> activities = PipingCalculationActivityFactory.CreateCalculationActivities(
failureMechanism, assessmentSection);
// Assert
Assert.AreEqual(4, activities.Count());
CalculatableActivity activity1 = activities.ElementAt(0);
Assert.IsInstanceOf <SemiProbabilisticPipingCalculationActivity>(activity1);
AssertSemiProbabilisticPipingCalculationActivity(activity1, calculation1, hydraulicBoundaryLocationCalculation1);
CalculatableActivity activity2 = activities.ElementAt(1);
Assert.IsInstanceOf <ProbabilisticPipingCalculationActivity>(activity2);
AssertProbabilisticPipingCalculationActivity(activity2, calculation2, hydraulicBoundaryLocation1);
CalculatableActivity activity3 = activities.ElementAt(2);
Assert.IsInstanceOf <SemiProbabilisticPipingCalculationActivity>(activity3);
AssertSemiProbabilisticPipingCalculationActivity(activity3, calculation3, hydraulicBoundaryLocationCalculation2);
CalculatableActivity activity4 = activities.ElementAt(3);
Assert.IsInstanceOf <ProbabilisticPipingCalculationActivity>(activity4);
AssertProbabilisticPipingCalculationActivity(activity4, calculation4, hydraulicBoundaryLocation2);
}
public void ContextMenuStrip_ClickOnCalculateAllItem_ScheduleAllChildCalculations()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var assessmentSection = new AssessmentSectionStub();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels();
assessmentSection.HydraulicBoundaryDatabase.FilePath = validHydraulicBoundaryDatabaseFilePath;
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
}, true);
var calculationA =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
var calculationB =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
var calculationC =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
var calculationD =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
calculationA.Name = "A";
calculationB.Name = "B";
calculationC.Name = "C";
calculationD.Name = "D";
failureMechanism.CalculationsGroup.Children.Add(calculationA);
failureMechanism.CalculationsGroup.Children.Add(calculationC);
failureMechanism.CalculationsGroup.Children.Add(calculationB);
failureMechanism.CalculationsGroup.Children.Add(calculationD);
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder);
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Stub(cf => cf.CreatePipingCalculator(null))
.IgnoreArguments()
.Return(new TestPipingCalculator());
mocks.ReplayAll();
plugin.Gui = gui;
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (new PipingSubCalculatorFactoryConfig())
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Call
void Call() => contextMenu.Items[contextMenuCalculateAllIndex].PerformClick();
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(28, msgs.Length);
Assert.AreEqual("Uitvoeren van berekening 'A' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[4]);
Assert.AreEqual("Uitvoeren van berekening 'A' is gelukt.", msgs[5]);
Assert.AreEqual("Uitvoeren van berekening 'C' is gestart.", msgs[6]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[7]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[8]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[9]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[12]);
Assert.AreEqual("Uitvoeren van berekening 'C' is gelukt.", msgs[13]);
Assert.AreEqual("Uitvoeren van berekening 'B' is gestart.", msgs[14]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[15]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[16]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[17]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[18]);
Assert.AreEqual("Uitvoeren van berekening 'B' is gelukt.", msgs[19]);
Assert.AreEqual("Uitvoeren van berekening 'D' is gestart.", msgs[20]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[21]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[22]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[23]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[26]);
Assert.AreEqual("Uitvoeren van berekening 'D' is gelukt.", msgs[27]);
});
}
}
}
public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
{
// Setup
PipingStochasticSoilModel stochasticSoilModel1 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("name1", new[]
{
new Point2D(1.0, 2.0),
new Point2D(1.1, 2.2)
});
PipingStochasticSoilModel stochasticSoilModel2 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("name2", new[]
{
new Point2D(3.0, 4.0),
new Point2D(3.3, 4.4)
});
var surfaceLineA = new PipingSurfaceLine("Line A");
surfaceLineA.SetGeometry(new[]
{
new Point3D(0.0, 0.0, 1.0),
new Point3D(3.0, 0.0, 1.7)
});
var surfaceLineB = new PipingSurfaceLine("Name B");
surfaceLineB.SetGeometry(new[]
{
new Point3D(0.0, 0.0, 1.5),
new Point3D(3.0, 0.0, 1.8)
});
surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3);
surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5);
var failureMechanism = new PipingFailureMechanism();
const string arbitraryFilePath = "path";
var geometryPoints = new[]
{
new Point2D(0.0, 0.0),
new Point2D(2.0, 0.0),
new Point2D(4.0, 4.0),
new Point2D(6.0, 4.0)
};
failureMechanism.SurfaceLines.AddRange(new[]
{
surfaceLineA,
surfaceLineB
}, arbitraryFilePath);
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
new FailureMechanismSection("A", geometryPoints.Take(2)),
new FailureMechanismSection("B", geometryPoints.Skip(1).Take(2)),
new FailureMechanismSection("C", geometryPoints.Skip(2).Take(2))
});
failureMechanism.StochasticSoilModels.AddRange(new[]
{
stochasticSoilModel1,
stochasticSoilModel2
}, arbitraryFilePath);
var hydraulicBoundaryLocation1 = new HydraulicBoundaryLocation(1, "test", 1.0, 2.0);
var hydraulicBoundaryLocation2 = new HydraulicBoundaryLocation(2, "test", 3.0, 4.0);
var calculationA =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation1);
var calculationB =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation2);
calculationA.InputParameters.SurfaceLine = surfaceLineA;
calculationB.InputParameters.SurfaceLine = surfaceLineB;
failureMechanism.CalculationsGroup.Children.Add(calculationA);
failureMechanism.CalculationsGroup.Children.Add(calculationB);
var referenceLine = new ReferenceLine();
referenceLine.SetGeometry(new[]
{
new Point2D(0.0, 3.0),
new Point2D(3.0, 0.0)
});
var assessmentSection = new AssessmentSectionStub
{
ReferenceLine = referenceLine
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation1,
hydraulicBoundaryLocation2
});
using (new AssemblyToolCalculatorFactoryConfig())
{
// Call
PipingFailureMechanismView view = CreateView(failureMechanism, assessmentSection);
IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl;
// Assert
MapDataCollection mapData = map.Data;
Assert.IsInstanceOf <MapDataCollection>(mapData);
List <MapData> mapDataList = mapData.Collection.ToList();
Assert.AreEqual(8, mapDataList.Count);
MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, mapDataList[referenceLineIndex]);
AssertSurfaceLinesMapData(failureMechanism.SurfaceLines, mapDataList[surfaceLinesIndex]);
IEnumerable <MapData> sectionsCollection = ((MapDataCollection)mapDataList[sectionsCollectionIndex]).Collection;
MapDataTestHelper.AssertFailureMechanismSectionsMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsIndex));
MapDataTestHelper.AssertFailureMechanismSectionsStartPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsStartPointIndex));
MapDataTestHelper.AssertFailureMechanismSectionsEndPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsEndPointIndex));
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]);
AssertStochasticSoilModelsMapData(failureMechanism.StochasticSoilModels, mapDataList[stochasticSoilModelsIndex]);
AssertProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType <ProbabilisticPipingCalculationScenario>(), mapDataList[probabilisticCalculationsIndex]);
AssertSemiProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType <SemiProbabilisticPipingCalculationScenario>(), mapDataList[semiProbabilisticCalculationsIndex]);
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
MapDataTestHelper.AssertAssemblyMapData(failureMechanism, calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, mapDataList[assemblyResultsIndex]);
}
}
public void ContextMenuStrip_ClickOnValidateAllItem_ValidateAllChildCalculations()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var assessmentSection = new AssessmentSectionStub();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels();
assessmentSection.HydraulicBoundaryDatabase.FilePath = validHydraulicBoundaryDatabaseFilePath;
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
}, true);
var validSemiProbabilisticCalculation =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
var invalidSemiProbabilisticCalculation =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithInvalidInput <SemiProbabilisticPipingCalculationScenario>();
var validProbabilisticCalculation =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
var invalidProbabilisticCalculation =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithInvalidInput <ProbabilisticPipingCalculationScenario>();
failureMechanism.CalculationsGroup.Children.Add(validSemiProbabilisticCalculation);
failureMechanism.CalculationsGroup.Children.Add(invalidProbabilisticCalculation);
failureMechanism.CalculationsGroup.Children.Add(validProbabilisticCalculation);
failureMechanism.CalculationsGroup.Children.Add(invalidSemiProbabilisticCalculation);
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(cmp => cmp.MainWindow).Return(mocks.Stub <IMainWindow>());
mocks.ReplayAll();
plugin.Gui = gui;
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Call
void Call() => contextMenu.Items[contextMenuValidateAllIndex].PerformClick();
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(18, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[1]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[2]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[8]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[9]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[10]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[11]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[17]);
});
}
}
}
