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);
}
