private static void SetPropertyAndVerifyNotificationsAndOutputForCalculation( Action <HeightStructuresCalculationRow> setProperty, StructuresCalculationScenario <HeightStructuresInput> calculation) { // Setup var mocks = new MockRepository(); var observable = mocks.StrictMock <IObservable>(); observable.Expect(o => o.NotifyObservers()); mocks.ReplayAll(); var handler = new SetPropertyValueAfterConfirmationParameterTester( new[] { observable }); var row = new HeightStructuresCalculationRow(calculation, handler); // Call setProperty(row); // Assert Assert.IsTrue(handler.Called); mocks.VerifyAll(); }
public void ForeshoreProfile_OnChangeToNull_CorrectColumnStates() { // Setup var calculation = new StructuresCalculationScenario <HeightStructuresInput> { InputParameters = { ForeshoreProfile = new TestForeshoreProfile() } }; // Call var row = new HeightStructuresCalculationRow(calculation, new ObservablePropertyChangeHandler(calculation, new HeightStructuresInput())) { ForeshoreProfile = new DataGridViewComboBoxItemWrapper <ForeshoreProfile>(null) }; // Assert IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions; DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[useBreakWaterColumnIndex], false); DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[breakWaterTypeColumnIndex], false); DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[breakWaterHeightColumnIndex], false); DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[useForeshoreColumnIndex], false); }
protected override ICalculation ParseReadCalculation(StabilityPointStructuresCalculationConfiguration readCalculation) { var calculation = new StructuresCalculationScenario <StabilityPointStructuresInput> { Name = readCalculation.Name }; if (TrySetStructure(readCalculation.StructureId, calculation) && TrySetHydraulicBoundaryLocation(readCalculation.HydraulicBoundaryLocationName, calculation) && TrySetForeshoreProfile(readCalculation.ForeshoreProfileId, calculation) && TrySetEvaluationLevel(readCalculation, calculation) && TrySetFailureProbabilityRepairClosure(readCalculation, calculation) && TrySetFailureProbabilityStructureWithErosion(readCalculation, calculation) && TrySetInflowModelType(readCalculation, calculation) && TrySetLevellingCount(readCalculation, calculation) && TrySetLoadSchematizationType(readCalculation, calculation) && TrySetProbabilityCollisionSecondaryStructure(readCalculation, calculation) && TrySetStochasts(readCalculation, calculation) && TrySetStructureNormalOrientation(readCalculation, calculation) && TrySetVerticalDistance(readCalculation, calculation) && TrySetScenarioParameters(readCalculation.Scenario, calculation) && readCalculation.WaveReduction.ValidateWaveReduction(calculation.InputParameters.ForeshoreProfile, calculation.Name, Log)) { SetFactorStormDurationOpenStructure(readCalculation, calculation); SetVolumicWeightWater(readCalculation, calculation); SetWaveReductionParameters(readCalculation.WaveReduction, calculation.InputParameters); SetShouldIllustrationPointsBeCalculated(readCalculation, calculation); return(calculation); } return(null); }
/// <summary> /// Configures calculations and adds them to the calculation group. /// </summary> /// <param name="calculationGroup">The calculation group.</param> /// <param name="structures">The collection of structures.</param> /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception> public static void GenerateCalculations <TStructureBase, TInputBase>(CalculationGroup calculationGroup, IEnumerable <TStructureBase> structures) where TStructureBase : StructureBase where TInputBase : StructuresInputBase <TStructureBase>, new() { if (calculationGroup == null) { throw new ArgumentNullException(nameof(calculationGroup)); } if (structures == null) { throw new ArgumentNullException(nameof(structures)); } foreach (TStructureBase structure in structures) { var calculation = new StructuresCalculationScenario <TInputBase> { Name = NamingHelper.GetUniqueName(calculationGroup.Children, structure.Name, c => c.Name), InputParameters = { Structure = structure } }; calculationGroup.Children.Add(calculation); } }
public TestStructuresCalculationScenarioContext(StructuresCalculationScenario <TestStructuresInput> calculation, CalculationGroup parent, TestCalculatableFailureMechanism failureMechanism, IAssessmentSection assessmentSection) : base(calculation, parent, failureMechanism, assessmentSection) { }
/// <summary> /// Creates a new instance of <see cref="StabilityPointStructuresCalculationScenarioContext"/>. /// </summary> /// <param name="calculation">The calculation instance wrapped by this context object.</param> /// <param name="parent">The <see cref="CalculationGroup"/> that owns the wrapped calculation.</param> /// <param name="failureMechanism">The failure mechanism which the context belongs to.</param> /// <param name="assessmentSection">The assessment section which the calculation belongs to.</param> /// <exception cref="ArgumentNullException">Thrown when any input argument is <c>null</c>.</exception> public StabilityPointStructuresCalculationScenarioContext(StructuresCalculationScenario <StabilityPointStructuresInput> calculation, CalculationGroup parent, StabilityPointStructuresFailureMechanism failureMechanism, IAssessmentSection assessmentSection) : base(calculation, parent, failureMechanism, assessmentSection) { }
public void Import_ScenarioWithRelevantSet_DataAddedToModel() { // Setup string filePath = Path.Combine(importerPath, "validConfigurationScenarioRelevantOnly.xml"); var calculationGroup = new CalculationGroup(); var importer = new ClosingStructuresCalculationConfigurationImporter(filePath, calculationGroup, Enumerable.Empty <HydraulicBoundaryLocation>(), Enumerable.Empty <ForeshoreProfile>(), Enumerable.Empty <ClosingStructure>()); // Call var successful = false; Action call = () => successful = importer.Import(); // Assert TestHelper.AssertLogMessageIsGenerated(call, $"Gegevens zijn geïmporteerd vanuit bestand '{filePath}'.", 1); Assert.IsTrue(successful); var expectedCalculation = new StructuresCalculationScenario <ClosingStructuresInput> { Name = "Calculation", IsRelevant = false }; Assert.AreEqual(1, calculationGroup.Children.Count); AssertCalculation(expectedCalculation, (StructuresCalculationScenario <ClosingStructuresInput>)calculationGroup.Children[0]); }
private static void AssertCalculation(StructuresCalculationScenario <ClosingStructuresInput> expectedCalculation, StructuresCalculationScenario <ClosingStructuresInput> actualCalculation) { Assert.AreEqual(expectedCalculation.Name, actualCalculation.Name); Assert.AreEqual(expectedCalculation.IsRelevant, actualCalculation.IsRelevant); Assert.AreEqual(expectedCalculation.Contribution, actualCalculation.Contribution); Assert.AreSame(expectedCalculation.InputParameters.HydraulicBoundaryLocation, actualCalculation.InputParameters.HydraulicBoundaryLocation); Assert.AreEqual(expectedCalculation.InputParameters.StructureNormalOrientation, actualCalculation.InputParameters.StructureNormalOrientation); Assert.AreEqual(expectedCalculation.InputParameters.FactorStormDurationOpenStructure, actualCalculation.InputParameters.FactorStormDurationOpenStructure); Assert.AreEqual(expectedCalculation.InputParameters.FailureProbabilityOpenStructure, actualCalculation.InputParameters.FailureProbabilityOpenStructure); Assert.AreEqual(expectedCalculation.InputParameters.FailureProbabilityReparation, actualCalculation.InputParameters.FailureProbabilityReparation); Assert.AreEqual(expectedCalculation.InputParameters.IdenticalApertures, actualCalculation.InputParameters.IdenticalApertures); Assert.AreEqual(expectedCalculation.InputParameters.InflowModelType, actualCalculation.InputParameters.InflowModelType); Assert.AreEqual(expectedCalculation.InputParameters.ProbabilityOpenStructureBeforeFlooding, actualCalculation.InputParameters.ProbabilityOpenStructureBeforeFlooding); Assert.AreSame(expectedCalculation.InputParameters.ForeshoreProfile, actualCalculation.InputParameters.ForeshoreProfile); Assert.AreEqual(expectedCalculation.InputParameters.ShouldIllustrationPointsBeCalculated, actualCalculation.InputParameters.ShouldIllustrationPointsBeCalculated); Assert.AreSame(expectedCalculation.InputParameters.Structure, actualCalculation.InputParameters.Structure); Assert.AreEqual(expectedCalculation.InputParameters.UseForeshore, actualCalculation.InputParameters.UseForeshore); Assert.AreEqual(expectedCalculation.InputParameters.UseBreakWater, actualCalculation.InputParameters.UseBreakWater); Assert.AreEqual(expectedCalculation.InputParameters.BreakWater.Height, actualCalculation.InputParameters.BreakWater.Height); Assert.AreEqual(expectedCalculation.InputParameters.BreakWater.Type, actualCalculation.InputParameters.BreakWater.Type); DistributionAssert.AreEqual(expectedCalculation.InputParameters.StormDuration, actualCalculation.InputParameters.StormDuration); DistributionAssert.AreEqual(expectedCalculation.InputParameters.ModelFactorSuperCriticalFlow, actualCalculation.InputParameters.ModelFactorSuperCriticalFlow); DistributionAssert.AreEqual(expectedCalculation.InputParameters.FlowWidthAtBottomProtection, actualCalculation.InputParameters.FlowWidthAtBottomProtection); DistributionAssert.AreEqual(expectedCalculation.InputParameters.WidthFlowApertures, actualCalculation.InputParameters.WidthFlowApertures); DistributionAssert.AreEqual(expectedCalculation.InputParameters.StorageStructureArea, actualCalculation.InputParameters.StorageStructureArea); DistributionAssert.AreEqual(expectedCalculation.InputParameters.AllowedLevelIncreaseStorage, actualCalculation.InputParameters.AllowedLevelIncreaseStorage); DistributionAssert.AreEqual(expectedCalculation.InputParameters.CriticalOvertoppingDischarge, actualCalculation.InputParameters.CriticalOvertoppingDischarge); DistributionAssert.AreEqual(expectedCalculation.InputParameters.LevelCrestStructureNotClosing, actualCalculation.InputParameters.LevelCrestStructureNotClosing); DistributionAssert.AreEqual(expectedCalculation.InputParameters.AreaFlowApertures, actualCalculation.InputParameters.AreaFlowApertures); DistributionAssert.AreEqual(expectedCalculation.InputParameters.DrainCoefficient, actualCalculation.InputParameters.DrainCoefficient); DistributionAssert.AreEqual(expectedCalculation.InputParameters.InsideWaterLevel, actualCalculation.InputParameters.InsideWaterLevel); DistributionAssert.AreEqual(expectedCalculation.InputParameters.ThresholdHeightOpenWeir, actualCalculation.InputParameters.ThresholdHeightOpenWeir); }
public void Import_EmptyConfigurations_DataAddedToModel(string file) { // Setup string filePath = Path.Combine(importerPath, file); var calculationGroup = new CalculationGroup(); var structure = new TestClosingStructure("kunstwerk1", "kunstwerk1"); var importer = new ClosingStructuresCalculationConfigurationImporter( filePath, calculationGroup, Enumerable.Empty <HydraulicBoundaryLocation>(), Enumerable.Empty <ForeshoreProfile>(), new[] { structure }); var expectedCalculation = new StructuresCalculationScenario <ClosingStructuresInput> { Name = "Berekening 1" }; // Call bool successful = importer.Import(); // Assert Assert.IsTrue(successful); Assert.AreEqual(1, calculationGroup.Children.Count); AssertCalculation(expectedCalculation, (StructuresCalculationScenario <ClosingStructuresInput>)calculationGroup.Children[0]); }
public void LoadSchematizationType_AlwaysOnChange_CorrectColumnStates(LoadSchematizationType loadSchematizationType) { // Setup var calculation = new StructuresCalculationScenario <StabilityPointStructuresInput> { InputParameters = { LoadSchematizationType = 0 } }; // Call var row = new StabilityPointStructuresCalculationRow(calculation, new ObservablePropertyChangeHandler(calculation, new StabilityPointStructuresInput())) { LoadSchematizationType = loadSchematizationType }; // Assert IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions; DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[constructiveStrengthLinearLoadModelColumnIndex], loadSchematizationType == LoadSchematizationType.Linear); DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[stabilityLinearLoadModelColumnIndex], loadSchematizationType == LoadSchematizationType.Linear); DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[constructiveStrengthQuadraticLoadModelColumnIndex], loadSchematizationType == LoadSchematizationType.Quadratic); DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[stabilityQuadraticLoadModelColumnIndex], loadSchematizationType == LoadSchematizationType.Quadratic); }
/// <summary> /// Creates a new instance of <see cref="ClosingStructuresCalculationScenarioContext"/>. /// </summary> /// <param name="wrappedData">The calculation instance wrapped by this context object.</param> /// <param name="parent">The <see cref="CalculationGroup"/> that owns the wrapped calculation.</param> /// <param name="failureMechanism">The failure mechanism which the calculation belongs to.</param> /// <param name="assessmentSection">The assessment section which the calculation belongs to.</param> /// <exception cref="ArgumentNullException">Thrown when any input argument is <c>null</c>.</exception> public ClosingStructuresCalculationScenarioContext(StructuresCalculationScenario <ClosingStructuresInput> wrappedData, CalculationGroup parent, ClosingStructuresFailureMechanism failureMechanism, IAssessmentSection assessmentSection) : base(wrappedData, parent, failureMechanism, assessmentSection) { }
/// <summary> /// Creates a new instance of <see cref="ClosingStructuresCalculationRow"/>. /// </summary> /// <param name="calculationScenario">The <see cref="StructuresCalculationScenario{ClosingStructuresInput}"/> this row contains.</param> /// <param name="handler">The handler responsible for handling effects of a property change.</param> /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception> internal ClosingStructuresCalculationRow(StructuresCalculationScenario <ClosingStructuresInput> calculationScenario, IObservablePropertyChangeHandler handler) : base(calculationScenario, handler) { ColumnStateDefinitions = new Dictionary <int, DataGridViewColumnStateDefinition> { { useBreakWaterColumnIndex, new DataGridViewColumnStateDefinition() }, { breakWaterTypeColumnIndex, new DataGridViewColumnStateDefinition() }, { breakWaterHeightColumnIndex, new DataGridViewColumnStateDefinition() }, { useForeshoreColumnIndex, new DataGridViewColumnStateDefinition() }, { meanInsideWaterLevelColumnIndex, new DataGridViewColumnStateDefinition() } }; UpdateUseBreakWaterColumnStateDefinitions(); UpdateBreakWaterTypeAndHeightColumnStateDefinitions(); UpdateUseForeshoreColumnStateDefinitions(); UpdateMeanInsideWaterLevelColumnStateDefinitions(); }
protected override ICalculation ParseReadCalculation(ClosingStructuresCalculationConfiguration readCalculation) { var calculation = new StructuresCalculationScenario <ClosingStructuresInput> { Name = readCalculation.Name }; if (TrySetStructure(readCalculation.StructureId, calculation) && TrySetHydraulicBoundaryLocation(readCalculation.HydraulicBoundaryLocationName, calculation) && TrySetForeshoreProfile(readCalculation.ForeshoreProfileId, calculation) && TrySetStochasts(readCalculation, calculation) && TrySetOrientation(readCalculation, calculation) && TrySetFailureProbabilityStructureWithErosion(readCalculation, calculation) && TrySetFailureProbabilityOpenStructure(readCalculation, calculation) && TrySetFailureProbabilityReparation(readCalculation, calculation) && TrySetProbabilityOpenStructureBeforeFlooding(readCalculation, calculation) && TrySetInflowModelType(readCalculation, calculation) && TrySetIdenticalApertures(readCalculation, calculation) && TrySetScenarioParameters(readCalculation.Scenario, calculation) && readCalculation.WaveReduction.ValidateWaveReduction(calculation.InputParameters.ForeshoreProfile, calculation.Name, Log)) { SetFactorStormDurationOpenStructure(readCalculation, calculation); SetWaveReductionParameters(readCalculation.WaveReduction, calculation.InputParameters); SetShouldIllustrationPointsBeCalculated(readCalculation, calculation); return(calculation); } return(null); }
private static void AssertPropertyChangeWithOrWithoutCalculationOutput( Action <HeightStructuresCalculationRow> setProperty, Action <StructuresCalculationScenario <HeightStructuresInput> > assertions, bool hasOutput, bool expectUpdates) { // Setup var mockRepository = new MockRepository(); var inputObserver = mockRepository.StrictMock <IObserver>(); if (expectUpdates) { inputObserver.Expect(o => o.UpdateObserver()); } var calculationObserver = mockRepository.StrictMock <IObserver>(); if (expectUpdates && hasOutput) { calculationObserver.Expect(o => o.UpdateObserver()); } var handler = mockRepository.Stub <IObservablePropertyChangeHandler>(); mockRepository.ReplayAll(); StructuresOutput assignedOutput = null; StructuresCalculationScenario <HeightStructuresInput> calculation = HeightStructuresCalculationScenarioTestFactory.CreateNotCalculatedHeightStructuresCalculationScenario(new FailureMechanismSection("Section 1", new List <Point2D> { new Point2D(0.0, 0.0) })); calculation.InputParameters.HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); if (hasOutput) { assignedOutput = new TestStructuresOutput(); } calculation.Output = assignedOutput; var row = new HeightStructuresCalculationRow(calculation, handler); calculation.Attach(calculationObserver); calculation.InputParameters.Attach(inputObserver); // Call setProperty(row); // Assert assertions(calculation); if (expectUpdates) { Assert.IsNull(calculation.Output); } else { Assert.AreSame(assignedOutput, calculation.Output); } }
public void GivenScenarioRow_WhenOutputChangedAndUpdate_ThenDerivedOutputUpdated() { // Given var calculation = new StructuresCalculationScenario <HeightStructuresInput> { Output = new TestStructuresOutput() }; var row = new HeightStructuresScenarioRow(calculation); // Precondition ProbabilityAssessmentOutput expectedDerivedOutput = ProbabilityAssessmentOutputFactory.Create(calculation.Output.Reliability); Assert.AreEqual(expectedDerivedOutput.Probability, row.FailureProbability); var random = new Random(11); // When calculation.Output = new TestStructuresOutput(random.NextDouble()); row.Update(); // Then ProbabilityAssessmentOutput newExpectedDerivedOutput = ProbabilityAssessmentOutputFactory.Create(calculation.Output.Reliability); Assert.AreEqual(newExpectedDerivedOutput.Probability, row.FailureProbability); }
public void Constructor_ForeshoreProfileWithGeometry_CorrectColumnStates(bool useBreakWater) { // Setup var calculation = new StructuresCalculationScenario <HeightStructuresInput> { InputParameters = { ForeshoreProfile = new TestForeshoreProfile(new[] { new Point2D(0.0, 0.0) }), UseBreakWater = useBreakWater } }; // Call var row = new HeightStructuresCalculationRow(calculation, new ObservablePropertyChangeHandler(calculation, new HeightStructuresInput())); // Assert IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions; DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[useBreakWaterColumnIndex], true); DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[breakWaterTypeColumnIndex], useBreakWater); DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[breakWaterHeightColumnIndex], useBreakWater); DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[useForeshoreColumnIndex], true); }
public void Constructor_ExpectedValues() { // Setup var mocks = new MockRepository(); var handler = mocks.Stub <IObservablePropertyChangeHandler>(); mocks.ReplayAll(); var calculationScenario = new StructuresCalculationScenario <HeightStructuresInput>(); // Call var row = new HeightStructuresCalculationRow(calculationScenario, handler); // Assert Assert.IsInstanceOf <CalculationRow <StructuresCalculationScenario <HeightStructuresInput> > >(row); Assert.IsInstanceOf <IHasColumnStateDefinitions>(row); Assert.AreSame(calculationScenario, row.Calculation); IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions; Assert.AreEqual(4, columnStateDefinitions.Count); DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, useBreakWaterColumnIndex); DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, breakWaterTypeColumnIndex); DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, breakWaterHeightColumnIndex); DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, useForeshoreColumnIndex); mocks.VerifyAll(); }
public DerivedHeightStructuresCalculationScenarioContext(StructuresCalculationScenario <HeightStructuresInput> calculation, CalculationGroup parent, HeightStructuresFailureMechanism failureMechanism, IAssessmentSection assessmentSection) : base(calculation, parent, failureMechanism, assessmentSection) { }
protected override HeightStructuresCalculationConfiguration ToConfiguration(StructuresCalculationScenario <HeightStructuresInput> calculation) { HeightStructuresInput input = calculation.InputParameters; var calculationConfiguration = new HeightStructuresCalculationConfiguration(calculation.Name) { HydraulicBoundaryLocationName = input.HydraulicBoundaryLocation?.Name, ShouldIllustrationPointsBeCalculated = input.ShouldIllustrationPointsBeCalculated, StormDuration = input.StormDuration.ToStochastConfigurationWithMean(), ModelFactorSuperCriticalFlow = input.ModelFactorSuperCriticalFlow.ToStochastConfigurationWithMean(), Scenario = calculation.ToScenarioConfiguration() }; calculationConfiguration.SetConfigurationForeshoreProfileDependentProperties(input); if (input.Structure != null) { calculationConfiguration.StructureId = input.Structure.Id; calculationConfiguration.StructureNormalOrientation = input.StructureNormalOrientation; calculationConfiguration.FailureProbabilityStructureWithErosion = input.FailureProbabilityStructureWithErosion; calculationConfiguration.FlowWidthAtBottomProtection = input.FlowWidthAtBottomProtection.ToStochastConfiguration(); calculationConfiguration.WidthFlowApertures = input.WidthFlowApertures.ToStochastConfiguration(); calculationConfiguration.StorageStructureArea = input.StorageStructureArea.ToStochastConfiguration(); calculationConfiguration.AllowedLevelIncreaseStorage = input.AllowedLevelIncreaseStorage.ToStochastConfiguration(); calculationConfiguration.LevelCrestStructure = input.LevelCrestStructure.ToStochastConfiguration(); calculationConfiguration.CriticalOvertoppingDischarge = input.CriticalOvertoppingDischarge.ToStochastConfiguration(); } return(calculationConfiguration); }
public void UseForeShoreGeometry_AlwaysOnChange_NotifyObserverAndCalculationPropertyChanged() { // Setup var calculation = new StructuresCalculationScenario <HeightStructuresInput>(); // Call & Assert SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.UseForeshoreGeometry = true, calculation); }
/// <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 <TInput, TStructure>(StructuresCalculationScenario <TInput> original, StructuresCalculationScenario <TInput> clone) where TInput : StructuresInputBase <TStructure>, new() where TStructure : StructureBase, new() { Assert.AreEqual(original.Contribution, clone.Contribution); Assert.AreEqual(original.IsRelevant, clone.IsRelevant); AreClones <TInput, TStructure>((StructuresCalculation <TInput>)original, clone); }
public void UseBreakWater_AlwaysOnChange_NotifyObserverAndCalculationPropertyChanged() { // Setup var calculation = new StructuresCalculationScenario <ClosingStructuresInput>(); // Call & Assert SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.UseBreakWater = true, calculation); }
public void Import_StochastWithStandardDeviationOrVariationCoefficientOnly_DataAddedToModel() { // Setup string filePath = Path.Combine(importerPath, "validConfigurationStochastStandardDeviationVariationCoefficientOnly.xml"); var calculationGroup = new CalculationGroup(); var structure = new TestHeightStructure("kunstwerk1", "kunstwerk1"); var importer = new HeightStructuresCalculationConfigurationImporter( filePath, calculationGroup, Enumerable.Empty <HydraulicBoundaryLocation>(), Enumerable.Empty <ForeshoreProfile>(), new[] { structure }); var expectedCalculation = new StructuresCalculationScenario <HeightStructuresInput> { Name = "Berekening 1", InputParameters = { Structure = structure, FlowWidthAtBottomProtection = { StandardDeviation = (RoundedDouble)0.1 }, WidthFlowApertures = { StandardDeviation = (RoundedDouble)0.1 }, StorageStructureArea = { CoefficientOfVariation = (RoundedDouble)0.01 }, AllowedLevelIncreaseStorage = { StandardDeviation = (RoundedDouble)0.01 }, LevelCrestStructure = { StandardDeviation = (RoundedDouble)0.1 }, CriticalOvertoppingDischarge = { CoefficientOfVariation = (RoundedDouble)0.1 } } }; // Call bool successful = importer.Import(); // Assert Assert.IsTrue(successful); Assert.AreEqual(1, calculationGroup.Children.Count); AssertCalculation(expectedCalculation, (StructuresCalculationScenario <HeightStructuresInput>)calculationGroup.Children[0]); }
/// <summary> /// Creates a calculated scenario for which the structure on the input intersects with <paramref name="section"/>. /// </summary> /// <param name="section">The section for which an intersection will be created.</param> /// <returns>A new <see cref="StructuresCalculationScenario{T}"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="section"/> is <c>null</c>.</exception> public static StructuresCalculationScenario <HeightStructuresInput> CreateHeightStructuresCalculationScenario( FailureMechanismSection section) { StructuresCalculationScenario <HeightStructuresInput> scenario = CreateNotCalculatedHeightStructuresCalculationScenario(section); scenario.Output = new TestStructuresOutput(); return(scenario); }
public void MeanInsideWaterLevel_AlwaysOnChange_NotifyObserverAndCalculationPropertyChanged() { // Setup var newValue = new RoundedDouble(4, 0.03); var calculation = new StructuresCalculationScenario <ClosingStructuresInput>(); // Call & Assert SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.MeanInsideWaterLevel = newValue, calculation); }
public void EvaluationLevel_AlwaysOnChange_NotifyObserverAndCalculationPropertyChanged() { // Setup var newValue = new RoundedDouble(4, 0.03); var calculation = new StructuresCalculationScenario <StabilityPointStructuresInput>(); // Call & Assert SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.EvaluationLevel = newValue, calculation); }
private static void AddCalculation(ClosingStructuresCalculationGroupContext context) { var calculation = new StructuresCalculationScenario <ClosingStructuresInput> { Name = NamingHelper.GetUniqueName(context.WrappedData.Children, RiskeerCommonDataResources.Calculation_DefaultName, c => c.Name) }; context.WrappedData.Children.Add(calculation); context.WrappedData.NotifyObservers(); }
public void BreakWaterHeight_AlwaysOnChange_NotifyObserverAndCalculationPropertyChanged() { // Setup var newValue = new RoundedDouble(4, 16); var calculation = new StructuresCalculationScenario <HeightStructuresInput>(); // Call & Assert SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.BreakWaterHeight = newValue, calculation); }
public void CriticalOvertoppingDischarge_AlwaysOnChange_NotifyObserverAndCalculationPropertyChanged() { // Setup var newValue = new RoundedDouble(4, 0.03); var calculation = new StructuresCalculationScenario <HeightStructuresInput>(); // Call & Assert SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.CriticalOvertoppingDischarge = newValue, calculation); }
public void AllowedLevelIncreaseStorage_AlwaysOnChange_NotifyObserverAndCalculationPropertyChanged() { // Setup var newValue = new RoundedDouble(4, 0.03); var calculation = new StructuresCalculationScenario <HeightStructuresInput>(); // Call & Assert SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.AllowedLevelIncreaseStorage = newValue, calculation); }