/// <summary>
/// Adds target probability related meta data to the given <paramref name="feature"/>.
/// </summary>
/// <param name="feature">The feature to add the meta data to.</param>
/// <param name="targetProbabilities">The collection of target probabilities to add.</param>
/// <param name="displayNameFormat">The display name format of the meta data.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
/// <exception cref="FormatException">Thrown when <paramref name="displayNameFormat"/> is invalid;
/// or the index of a format item is not zero.</exception>
public static void AddTargetProbabilityMetaData(MapFeature feature, IEnumerable <Tuple <double, RoundedDouble> > targetProbabilities, string displayNameFormat)
{
if (feature == null)
{
throw new ArgumentNullException(nameof(feature));
}
if (targetProbabilities == null)
{
throw new ArgumentNullException(nameof(targetProbabilities));
}
if (displayNameFormat == null)
{
throw new ArgumentNullException(nameof(displayNameFormat));
}
var addedMetaDataItems = new List <string>();
foreach (Tuple <double, RoundedDouble> calculationOutputForTargetProbability in targetProbabilities)
{
string uniqueName = NamingHelper.GetUniqueName(
addedMetaDataItems, string.Format(displayNameFormat, ProbabilityFormattingHelper.Format(calculationOutputForTargetProbability.Item1)),
v => v);
feature.MetaData[uniqueName] = calculationOutputForTargetProbability.Item2.ToString();
addedMetaDataItems.Add(uniqueName);
}
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
PartialProbabilisticFaultTreePipingOutput output = PipingTestDataGenerator.GetRandomPartialProbabilisticFaultTreePipingOutput();
// Call
var properties = new ProbabilisticFaultTreePipingOutputProperties(output);
// Assert
Assert.AreEqual(ProbabilityFormattingHelper.Format(StatisticsConverter.ReliabilityToProbability(output.Reliability)), properties.Probability);
Assert.AreEqual(output.Reliability, properties.Reliability, properties.Reliability.GetAccuracy());
GeneralResult <TopLevelFaultTreeIllustrationPoint> generalResult = output.GeneralResult;
Assert.AreEqual(generalResult.GoverningWindDirection.Name, properties.WindDirection);
int nrOfExpectedStochasts = generalResult.Stochasts.Count();
Assert.AreEqual(nrOfExpectedStochasts, properties.AlphaValues.Length);
Assert.AreEqual(nrOfExpectedStochasts, properties.Durations.Length);
Stochast expectedStochast = generalResult.Stochasts.First();
Assert.AreEqual(expectedStochast.Alpha, properties.AlphaValues[0].Alpha);
Assert.AreEqual(expectedStochast.Duration, properties.Durations[0].Duration);
int nrOfExpectedTopLevelIllustrationPoints = generalResult.TopLevelIllustrationPoints.Count();
Assert.AreEqual(nrOfExpectedTopLevelIllustrationPoints, properties.IllustrationPoints.Length);
CollectionAssert.AreEqual(generalResult.TopLevelIllustrationPoints, properties.IllustrationPoints.Select(i => i.Data));
}
public void Constructor_DataGridViewCorrectlyInitialized()
{
// Call
ShowFullyConfiguredScenariosView(new CalculationGroup(), new TestCalculatableFailureMechanism());
var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject;
// Assert
Assert.IsFalse(dataGridView.AutoGenerateColumns);
Assert.AreEqual(4, dataGridView.ColumnCount);
Assert.AreEqual("In oordeel", dataGridView.Columns[isRelevantColumnIndex].HeaderText);
Assert.AreEqual("Bijdrage aan\r\nscenario\r\n[%]", dataGridView.Columns[contributionColumnIndex].HeaderText);
Assert.AreEqual("Naam", dataGridView.Columns[nameColumnIndex].HeaderText);
Assert.AreEqual("Faalkans\r\n[1/jaar]", dataGridView.Columns[failureProbabilityColumnIndex].HeaderText);
DataGridViewRowCollection rows = dataGridView.Rows;
Assert.AreEqual(2, rows.Count);
DataGridViewCellCollection cells = rows[0].Cells;
Assert.AreEqual(4, cells.Count);
Assert.IsTrue(Convert.ToBoolean(cells[isRelevantColumnIndex].FormattedValue));
Assert.AreEqual(new RoundedDouble(2, 100).ToString(), cells[contributionColumnIndex].FormattedValue);
Assert.AreEqual("Calculation 1", cells[nameColumnIndex].FormattedValue);
Assert.AreEqual(ProbabilityFormattingHelper.Format(1), cells[failureProbabilityColumnIndex].FormattedValue);
cells = rows[1].Cells;
Assert.AreEqual(4, cells.Count);
Assert.IsFalse(Convert.ToBoolean(cells[isRelevantColumnIndex].FormattedValue));
Assert.AreEqual(new RoundedDouble(2, 100).ToString(), cells[contributionColumnIndex].FormattedValue);
Assert.AreEqual("Calculation 2", cells[nameColumnIndex].FormattedValue);
Assert.AreEqual(ProbabilityFormattingHelper.Format(1), cells[failureProbabilityColumnIndex].FormattedValue);
}
public void CreateHydraulicBoundaryLocationFeatures_WithLocations_ReturnsLocationFeaturesCollection(bool setOutput)
{
// Setup
var assessmentSection = new AssessmentSectionStub();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "location1", 1, 1),
new HydraulicBoundaryLocation(2, "location2", 2, 2)
}, setOutput);
Dictionary <IObservableEnumerable <HydraulicBoundaryLocationCalculation>, string> waterLevels =
assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.ToDictionary(
tp => (IObservableEnumerable <HydraulicBoundaryLocationCalculation>)tp.HydraulicBoundaryLocationCalculations,
tp => $"h - {ProbabilityFormattingHelper.Format(tp.TargetProbability)}");
waterLevels.Add(assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability, "h - 1/30.000");
waterLevels.Add(assessmentSection.WaterLevelCalculationsForSignalFloodingProbability, "h - 1/30.000 (1)");
IEnumerable <AggregatedHydraulicBoundaryLocation> locations = AggregatedHydraulicBoundaryLocationFactory.CreateAggregatedHydraulicBoundaryLocations(
assessmentSection.HydraulicBoundaryDatabase.Locations,
waterLevels,
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.ToDictionary(
tp => (IObservableEnumerable <HydraulicBoundaryLocationCalculation>)tp.HydraulicBoundaryLocationCalculations,
tp => $"Hs - {ProbabilityFormattingHelper.Format(tp.TargetProbability)}"));
// Call
IEnumerable <MapFeature> features = RiskeerMapDataFeaturesFactory.CreateHydraulicBoundaryLocationFeatures(locations);
// Assert
MapFeaturesTestHelper.AssertHydraulicBoundaryFeaturesData(assessmentSection, features);
}
public void GrassCoverErosionInwardsScenarioView_CalculationsWithAllDataSet_DataGridViewCorrectlyInitialized()
{
// Call
ShowFullyConfiguredGrassCoverErosionInwardsScenariosView();
var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject;
// Assert
DataGridViewRowCollection rows = dataGridView.Rows;
Assert.AreEqual(2, rows.Count);
DataGridViewCellCollection cells = rows[0].Cells;
Assert.AreEqual(4, cells.Count);
Assert.IsTrue(Convert.ToBoolean(cells[isRelevantColumnIndex].FormattedValue));
Assert.AreEqual(new RoundedDouble(2, 100).ToString(), cells[contributionColumnIndex].FormattedValue);
Assert.AreEqual("Calculation 1", cells[nameColumnIndex].FormattedValue);
Assert.AreEqual("-", cells[failureProbabilityColumnIndex].FormattedValue);
cells = rows[1].Cells;
Assert.AreEqual(4, cells.Count);
Assert.IsTrue(Convert.ToBoolean(cells[isRelevantColumnIndex].FormattedValue));
Assert.AreEqual(new RoundedDouble(2, 100).ToString(), cells[contributionColumnIndex].FormattedValue);
Assert.AreEqual("Calculation 2", cells[nameColumnIndex].FormattedValue);
Assert.AreEqual(ProbabilityFormattingHelper.Format(0.5), cells[failureProbabilityColumnIndex].FormattedValue);
}
public void Format_ProbabilityIsZero_ReturnOneOverInfinity()
{
// Call
string text = ProbabilityFormattingHelper.Format(0);
// Assert
Assert.AreEqual("1/Oneindig", text);
}
public void Format_ProbabilityNotZero_ReturnOneOverReturnPeriod(double probability, string expectedText)
{
// Call
string text = ProbabilityFormattingHelper.Format(probability);
// Assert
Assert.AreEqual(expectedText, text);
}
public void GivenMapLayerWithHydraulicBoundaryLocationsData_WhenSelectedWaveHeightTargetProbabilityIndexUpdatedAndCollectionNotified_ThenMapDataAndSelectedMetaDataAttributeUpdated(
Action <ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> > shiftItemAction,
string selectedTargetProbabilityFormat, string expectedSelectedTargetProbabilityFormat)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
const double targetProbability = 0.001;
var assessmentSection = new AssessmentSectionStub();
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.Clear();
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.AddRange(new[]
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(targetProbability),
new HydraulicBoundaryLocationCalculationsForTargetProbability(targetProbability),
new HydraulicBoundaryLocationCalculationsForTargetProbability(targetProbability)
});
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0);
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection))
{
string targetProbabilityString = ProbabilityFormattingHelper.Format(targetProbability);
string selectedProbabilityString = string.Format(selectedTargetProbabilityFormat, targetProbabilityString);
mapLayer.MapData.SelectedMetaDataAttribute = string.Format(waveHeightDisplayNameFormat, selectedProbabilityString);
mapLayer.MapData.NotifyObservers();
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
// When
ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> waveHeightCalculationsForUserDefinedTargetProbabilities =
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities;
shiftItemAction(waveHeightCalculationsForUserDefinedTargetProbabilities);
waveHeightCalculationsForUserDefinedTargetProbabilities.NotifyObservers();
// Then
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
string expectedSelectedProbabilityString = string.Format(expectedSelectedTargetProbabilityFormat, targetProbabilityString);
Assert.AreEqual(string.Format(waveHeightDisplayNameFormat, expectedSelectedProbabilityString),
mapLayer.MapData.SelectedMetaDataAttribute);
}
mocks.VerifyAll();
}
public void GivenMapLayerWithDuneLocations_WhenSelectedTargetProbabilityIndexUpdatedAndCollectionNotified_ThenMapDataAndSelectedMetaDataAttributeUpdated(
Action <ObservableList <DuneLocationCalculationsForTargetProbability> > shiftItemAction,
string selectedMetaDataAttributeFormat, string expectedSelectedMetadataAttributeFormat)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
const double targetProbability = 0.1;
var failureMechanism = new DuneErosionFailureMechanism
{
DuneLocationCalculationsForUserDefinedTargetProbabilities =
{
new DuneLocationCalculationsForTargetProbability(targetProbability),
new DuneLocationCalculationsForTargetProbability(targetProbability),
new DuneLocationCalculationsForTargetProbability(targetProbability)
}
};
failureMechanism.SetDuneLocations(new[]
{
new TestDuneLocation("test1")
});
using (var mapLayer = new DuneErosionLocationsMapLayer(failureMechanism))
{
string targetProbabilityString = ProbabilityFormattingHelper.Format(targetProbability);
string selectedProbabilityAttribute = string.Format(selectedMetaDataAttributeFormat, targetProbabilityString);
mapLayer.MapData.SelectedMetaDataAttribute = selectedProbabilityAttribute;
mapLayer.MapData.NotifyObservers();
mapLayer.MapData.Attach(observer);
// Precondition
AssertDuneLocationsMapData(failureMechanism, mapLayer.MapData);
// When
ObservableList <DuneLocationCalculationsForTargetProbability> duneLocationCalculationsForUserDefinedTargetProbabilities =
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities;
shiftItemAction(duneLocationCalculationsForUserDefinedTargetProbabilities);
duneLocationCalculationsForUserDefinedTargetProbabilities.NotifyObservers();
// Then
AssertDuneLocationsMapData(failureMechanism, mapLayer.MapData);
Assert.AreEqual(string.Format(expectedSelectedMetadataAttributeFormat, targetProbabilityString),
mapLayer.MapData.SelectedMetaDataAttribute);
}
mocks.VerifyAll();
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
PartialProbabilisticPipingOutput <TestTopLevelIllustrationPoint> output = PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput();
// Call
var properties = new TestProbabilisticPipingOutputProperties(output);
// Assert
Assert.AreEqual(ProbabilityFormattingHelper.Format(StatisticsConverter.ReliabilityToProbability(output.Reliability)), properties.Probability);
Assert.AreEqual(output.Reliability, properties.Reliability, properties.Reliability.GetAccuracy());
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
var random = new Random(39);
double waveHeight = random.NextDouble();
bool isOvertoppingDominant = random.NextBoolean();
double reliability = random.NextDouble();
var generalResult = new TestGeneralResultFaultTreeIllustrationPoint();
var overtoppingOutput = new OvertoppingOutput(waveHeight,
isOvertoppingDominant,
reliability,
generalResult);
// Call
var properties = new OvertoppingOutputProperties(overtoppingOutput);
// Assert
Assert.AreEqual(2, properties.WaveHeight.NumberOfDecimalPlaces);
Assert.AreEqual(waveHeight, properties.WaveHeight, properties.WaveHeight.GetAccuracy());
Assert.AreEqual(reliability, properties.Reliability, properties.Reliability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(0.5), properties.Probability);
Assert.AreEqual(isOvertoppingDominant, properties.IsOvertoppingDominant);
Assert.AreEqual(generalResult.GoverningWindDirection.Name, properties.WindDirection);
TestHelper.AssertTypeConverter <StructuresOutputProperties, KeyValueExpandableArrayConverter>(
nameof(StructuresOutputProperties.AlphaValues));
TestHelper.AssertTypeConverter <StructuresOutputProperties, KeyValueExpandableArrayConverter>(
nameof(StructuresOutputProperties.Durations));
int nrOfExpectedStochasts = generalResult.Stochasts.Count();
Assert.AreEqual(nrOfExpectedStochasts, properties.AlphaValues.Length);
Assert.AreEqual(nrOfExpectedStochasts, properties.Durations.Length);
Stochast expectedStochast = generalResult.Stochasts.First();
Assert.AreEqual(expectedStochast.Alpha, properties.AlphaValues[0].Alpha);
Assert.AreEqual(expectedStochast.Duration, properties.Durations[0].Duration);
TestHelper.AssertTypeConverter <StructuresOutputProperties, ExpandableArrayConverter>(
nameof(StructuresOutputProperties.IllustrationPoints));
int nrOfExpectedTopLevelIllustrationPoints = generalResult.TopLevelIllustrationPoints.Count();
Assert.AreEqual(nrOfExpectedTopLevelIllustrationPoints, properties.IllustrationPoints.Length);
CollectionAssert.AreEqual(generalResult.TopLevelIllustrationPoints, properties.IllustrationPoints.Select(i => i.Data));
}
private static void AssertMetaData(IEnumerable <HydraulicBoundaryLocationCalculation> calculations, HydraulicBoundaryLocation hydraulicBoundaryLocation,
MapFeature mapFeature, double targetProbability, string displayName, List <string> presentedMetaDataItems)
{
string uniqueName = NamingHelper.GetUniqueName(
presentedMetaDataItems, string.Format(displayName, ProbabilityFormattingHelper.Format(targetProbability)),
v => v);
MapFeaturesMetaDataTestHelper.AssertMetaData(
GetExpectedResult(calculations, hydraulicBoundaryLocation),
mapFeature, uniqueName);
presentedMetaDataItems.Add(uniqueName);
}
public void ConvertTo_NumberToString_ReturnStringInLocalEnglishCulture(double value)
{
// Setup
var converter = new NoProbabilityValueDoubleConverter();
// Call
var text = (string)converter.ConvertTo(value, typeof(string));
// Assert
string expectedText = ProbabilityFormattingHelper.Format(value);
Assert.AreEqual(expectedText, text);
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
const double norm = 0.1;
var random = new Random(22);
double upliftEffectiveStress = random.NextDouble();
double heaveGradient = random.NextDouble();
double sellmeijerCreepCoefficient = random.NextDouble();
double sellmeijerCriticalFall = random.NextDouble();
double sellmeijerReducedFall = random.NextDouble();
double upliftFactorOfSafety = random.NextDouble();
double heaveFactorOfSafety = random.NextDouble();
double sellmeijerFactorOfSafety = random.NextDouble();
var output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties
{
UpliftEffectiveStress = upliftEffectiveStress,
HeaveGradient = heaveGradient,
SellmeijerCreepCoefficient = sellmeijerCreepCoefficient,
SellmeijerCriticalFall = sellmeijerCriticalFall,
SellmeijerReducedFall = sellmeijerReducedFall,
UpliftFactorOfSafety = upliftFactorOfSafety,
HeaveFactorOfSafety = heaveFactorOfSafety,
SellmeijerFactorOfSafety = sellmeijerFactorOfSafety
});
// Call
var properties = new SemiProbabilisticPipingOutputProperties(output, norm);
// Assert
DerivedSemiProbabilisticPipingOutput expectedDerivedOutput = DerivedSemiProbabilisticPipingOutputFactory.Create(output, norm);
Assert.AreEqual(upliftFactorOfSafety, properties.UpliftFactorOfSafety, properties.UpliftFactorOfSafety.GetAccuracy());
Assert.AreEqual(expectedDerivedOutput.UpliftReliability, properties.UpliftReliability, properties.UpliftReliability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.UpliftProbability), properties.UpliftProbability);
Assert.AreEqual(heaveFactorOfSafety, properties.HeaveFactorOfSafety, properties.HeaveFactorOfSafety.GetAccuracy());
Assert.AreEqual(expectedDerivedOutput.HeaveReliability, properties.HeaveReliability, properties.HeaveReliability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.HeaveProbability), properties.HeaveProbability);
Assert.AreEqual(sellmeijerFactorOfSafety, properties.SellmeijerFactorOfSafety, properties.SellmeijerFactorOfSafety.GetAccuracy());
Assert.AreEqual(expectedDerivedOutput.SellmeijerReliability, properties.SellmeijerReliability, properties.SellmeijerReliability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.SellmeijerProbability), properties.SellmeijerProbability);
Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.PipingProbability), properties.PipingProbability);
Assert.AreEqual(expectedDerivedOutput.PipingReliability, properties.PipingReliability, properties.PipingReliability.GetAccuracy());
Assert.AreEqual(upliftEffectiveStress, properties.UpliftEffectiveStress, properties.UpliftEffectiveStress.GetAccuracy());
Assert.AreEqual(heaveGradient, properties.HeaveGradient, properties.HeaveGradient.GetAccuracy());
Assert.AreEqual(sellmeijerCreepCoefficient, properties.SellmeijerCreepCoefficient, properties.SellmeijerCreepCoefficient.GetAccuracy());
Assert.AreEqual(sellmeijerCriticalFall, properties.SellmeijerCriticalFall, properties.SellmeijerCriticalFall.GetAccuracy());
Assert.AreEqual(sellmeijerReducedFall, properties.SellmeijerReducedFall, properties.SellmeijerReducedFall.GetAccuracy());
}
private static string CreateGraphNodeContent(RoundedDouble beta)
{
double probability = StatisticsConverter.ReliabilityToProbability(beta);
if (probability == 0)
{
return(string.Format(Resources.GraphNodeConverter_GraphNodeContent_Probability_0_Beta_1, probability, beta));
}
return(string.Format(Resources.GraphNodeConverter_GraphNodeContent_Probability_0_Beta_1,
probability >= 0.00001
? ProbabilityFormattingHelper.Format(StatisticsConverter.ReliabilityToProbability(beta))
: probability.ToString("0.#####E+0", CultureInfo.CurrentCulture), beta));
}
public void Data_SetNewHeightStructureInstance_ReturnCorrectPropertyValues()
{
// Setup
var structure = new TestHeightStructure();
var properties = new HeightStructureProperties();
// Call
properties.Data = structure;
// Assert
Assert.AreEqual(structure.Id, properties.Id);
Assert.AreEqual(structure.Name, properties.Name);
Assert.AreEqual(structure.Location, properties.Location);
Assert.AreEqual(structure.StructureNormalOrientation, properties.StructureNormalOrientation);
Assert.AreEqual("Lognormaal", properties.FlowWidthAtBottomProtection.DistributionType);
Assert.AreEqual(structure.FlowWidthAtBottomProtection, properties.FlowWidthAtBottomProtection.Data);
Assert.IsTrue(properties.FlowWidthAtBottomProtection.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.FlowWidthAtBottomProtection.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Normaal", properties.WidthFlowApertures.DistributionType);
Assert.AreEqual(structure.WidthFlowApertures, properties.WidthFlowApertures.Data);
Assert.IsTrue(properties.WidthFlowApertures.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.WidthFlowApertures.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Lognormaal", properties.StorageStructureArea.DistributionType);
Assert.AreEqual(structure.StorageStructureArea, properties.StorageStructureArea.Data);
Assert.IsTrue(properties.StorageStructureArea.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.StorageStructureArea.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual("Lognormaal", properties.AllowedLevelIncreaseStorage.DistributionType);
Assert.AreEqual(structure.AllowedLevelIncreaseStorage, properties.AllowedLevelIncreaseStorage.Data);
Assert.IsTrue(properties.AllowedLevelIncreaseStorage.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.AllowedLevelIncreaseStorage.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Normaal", properties.LevelCrestStructure.DistributionType);
Assert.AreEqual(structure.LevelCrestStructure, properties.LevelCrestStructure.Data);
Assert.IsTrue(properties.LevelCrestStructure.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.LevelCrestStructure.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Lognormaal", properties.CriticalOvertoppingDischarge.DistributionType);
Assert.AreEqual(structure.CriticalOvertoppingDischarge, properties.CriticalOvertoppingDischarge.Data);
Assert.IsTrue(properties.CriticalOvertoppingDischarge.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.CriticalOvertoppingDischarge.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual(ProbabilityFormattingHelper.Format(structure.FailureProbabilityStructureWithErosion), properties.FailureProbabilityStructureWithErosion);
}
public void GivenMapLayerWithDuneLocations_WhenNotSelectedTargetProbabilityRemovedAndNotified_ThenMapDataUpdated(string displayName)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var failureMechanism = new DuneErosionFailureMechanism();
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Add(
new DuneLocationCalculationsForTargetProbability(0.1));
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Add(
new DuneLocationCalculationsForTargetProbability(0.001));
failureMechanism.SetDuneLocations(new[]
{
new TestDuneLocation("test1")
});
using (var mapLayer = new DuneErosionLocationsMapLayer(failureMechanism))
{
DuneLocationCalculationsForTargetProbability calculationsForTargetProbabilityToRemove = failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.First();
DuneLocationCalculationsForTargetProbability calculationsForTargetProbability = failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Last();
mapLayer.MapData.SelectedMetaDataAttribute = string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability));
mapLayer.MapData.NotifyObservers();
mapLayer.MapData.Attach(observer);
// Precondition
AssertDuneLocationsMapData(failureMechanism, mapLayer.MapData);
// When
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Remove(calculationsForTargetProbabilityToRemove);
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.NotifyObservers();
// Then
AssertDuneLocationsMapData(failureMechanism, mapLayer.MapData);
Assert.AreEqual(string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability)),
mapLayer.MapData.SelectedMetaDataAttribute);
}
mocks.VerifyAll();
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
PartialProbabilisticSubMechanismPipingOutput output = PipingTestDataGenerator.GetRandomPartialProbabilisticSubMechanismPipingOutput();
// Call
var properties = new ProbabilisticSubMechanismPipingOutputProperties(output);
// Assert
Assert.AreEqual(ProbabilityFormattingHelper.Format(StatisticsConverter.ReliabilityToProbability(output.Reliability)), properties.Probability);
Assert.AreEqual(output.Reliability, properties.Reliability, properties.Reliability.GetAccuracy());
GeneralResult <TopLevelSubMechanismIllustrationPoint> generalResult = output.GeneralResult;
CollectionAssert.AreEqual(generalResult.Stochasts, properties.AlphaValues);
CollectionAssert.AreEqual(generalResult.Stochasts, properties.Durations);
CollectionAssert.AreEqual(generalResult.TopLevelIllustrationPoints, properties.IllustrationPoints.Select(ip => ip.Data));
Assert.AreEqual(generalResult.GoverningWindDirection.Name, properties.WindDirection);
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
const double modelFactor = 1.1;
MacroStabilityInwardsOutput output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput();
// Call
var properties = new MacroStabilityInwardsOutputProperties(output, modelFactor);
// Assert
DerivedMacroStabilityInwardsOutput expectedDerivedOutput = DerivedMacroStabilityInwardsOutputFactory.Create(output, modelFactor);
Assert.AreEqual(expectedDerivedOutput.FactorOfStability, properties.MacroStabilityInwardsFactorOfStability,
properties.MacroStabilityInwardsFactorOfStability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.MacroStabilityInwardsProbability), properties.MacroStabilityInwardsProbability);
Assert.AreEqual(expectedDerivedOutput.MacroStabilityInwardsReliability, properties.MacroStabilityInwardsReliability, properties.MacroStabilityInwardsReliability.GetAccuracy());
}
public void GivenMapLayerWithHydraulicBoundaryLocationsData_WhenNotSelectedTargetProbabilityRemovedAndNotified_ThenMapDataUpdated(
Func <IAssessmentSection, ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> > getTargetProbabilitiesFunc, string displayName)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0);
var assessmentSection = new AssessmentSectionStub();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection))
{
ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> targetProbabilities = getTargetProbabilitiesFunc(assessmentSection);
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbabilityToRemove = targetProbabilities.First();
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbability = targetProbabilities.Last();
mapLayer.MapData.SelectedMetaDataAttribute = string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability));
mapLayer.MapData.NotifyObservers();
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
// When
targetProbabilities.Remove(calculationsForTargetProbabilityToRemove);
targetProbabilities.NotifyObservers();
// Then
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
Assert.AreEqual(string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability)),
mapLayer.MapData.SelectedMetaDataAttribute);
}
mocks.VerifyAll();
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
var generalResult = new TestGeneralResultFaultTreeIllustrationPoint();
var structuresOutput = new TestStructuresOutput(generalResult);
// Call
var properties = new StructuresOutputProperties(structuresOutput);
// Assert
Assert.AreEqual(generalResult.GoverningWindDirection.Name, properties.WindDirection);
Assert.AreEqual(ProbabilityFormattingHelper.Format(0.5), properties.Probability);
Assert.AreEqual(0, properties.Reliability, properties.Reliability.GetAccuracy());
TestHelper.AssertTypeConverter <StructuresOutputProperties, KeyValueExpandableArrayConverter>(
nameof(StructuresOutputProperties.AlphaValues));
TestHelper.AssertTypeConverter <StructuresOutputProperties, KeyValueExpandableArrayConverter>(
nameof(StructuresOutputProperties.Durations));
int nrOfExpectedStochasts = generalResult.Stochasts.Count();
Assert.AreEqual(nrOfExpectedStochasts, properties.AlphaValues.Length);
Assert.AreEqual(nrOfExpectedStochasts, properties.Durations.Length);
Stochast expectedStochast = generalResult.Stochasts.First();
Assert.AreEqual(expectedStochast.Alpha, properties.AlphaValues[0].Alpha);
Assert.AreEqual(expectedStochast.Duration, properties.Durations[0].Duration);
TestHelper.AssertTypeConverter <StructuresOutputProperties, ExpandableArrayConverter>(
nameof(StructuresOutputProperties.IllustrationPoints));
int nrOfExpectedTopLevelIllustrationPoints = generalResult.TopLevelIllustrationPoints.Count();
Assert.AreEqual(nrOfExpectedTopLevelIllustrationPoints, properties.IllustrationPoints.Length);
CollectionAssert.AreEqual(generalResult.TopLevelIllustrationPoints, properties.IllustrationPoints.Select(i => i.Data));
}
/// <summary>
/// Tries to create the <see cref="AssessmentSection"/>.
/// </summary>
/// <param name="selectedItem">The selected <see cref="ReferenceLineMeta"/>.</param>
/// <param name="maximumAllowableFloodingProbability">The maximum allowable flooding probability of the assessment section.</param>
/// <param name="signalFloodingProbability">The signal flooding probability of the assessment section.</param>
/// <param name="normativeProbabilityType">The normative probability type of the assessment section.</param>
/// <returns>The created <see cref="AssessmentSection"/>.</returns>
/// <exception cref="CriticalFileValidationException">Thrown when:
/// <list type="bullet">
/// <item><paramref name="maximumAllowableFloodingProbability"/> is not in the interval [0.000001, 0.1] or is <see cref="double.NaN"/>;</item>
/// <item><paramref name="signalFloodingProbability"/> is not in the interval [0.000001, 0.1] or is <see cref="double.NaN"/>;</item>
/// <item>The <paramref name="signalFloodingProbability"/> is larger than <paramref name="maximumAllowableFloodingProbability"/>.</item>
/// </list>
/// </exception>
private AssessmentSection TryCreateAssessmentSection(ReferenceLineMeta selectedItem,
double maximumAllowableFloodingProbability,
double signalFloodingProbability,
NormativeProbabilityType normativeProbabilityType)
{
try
{
return(CreateAssessmentSection(selectedItem,
maximumAllowableFloodingProbability,
signalFloodingProbability,
normativeProbabilityType));
}
catch (ArgumentOutOfRangeException exception)
{
var normValidityRange = new Range <double>(1.0 / 1000000, 1.0 / 10);
string message = string.Format(Resources.AssessmentSectionFromFileCommandHandler_Unable_to_create_assessmentSection_with_MaximumAllowableFloodingProbability_0_and_SignalFloodingProbability_1_Probabilities_should_be_in_Range_2_,
ProbabilityFormattingHelper.Format(maximumAllowableFloodingProbability),
ProbabilityFormattingHelper.Format(signalFloodingProbability),
normValidityRange.ToString(FormattableConstants.ShowAtLeastOneDecimal, CultureInfo.CurrentCulture));
throw new CriticalFileValidationException(message, exception);
}
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
var random = new Random(39);
double waveHeight = random.NextDouble();
bool isOvertoppingDominant = Convert.ToBoolean(random.Next(0, 2));
double reliability = random.NextDouble();
double dikeHeight = random.NextDouble();
double dikeHeightTargetProbability = random.NextDouble();
double dikeHeightTargetReliability = random.NextDouble();
double dikeHeightCalculatedProbability = random.NextDouble();
double dikeHeightCalculatedReliability = random.NextDouble();
var dikeHeightConvergence = random.NextEnumValue <CalculationConvergence>();
double overtoppingRate = random.NextDouble();
double overtoppingRateTargetProbability = random.NextDouble();
double overtoppingRateTargetReliability = random.NextDouble();
double overtoppingRateCalculatedProbability = random.NextDouble();
double overtoppingRateCalculatedReliability = random.NextDouble();
var overtoppingRateConvergence = random.NextEnumValue <CalculationConvergence>();
var resultOutput = new OvertoppingOutput(waveHeight,
isOvertoppingDominant,
reliability,
null);
var dikeHeightOutput = new DikeHeightOutput(dikeHeight,
dikeHeightTargetProbability,
dikeHeightTargetReliability,
dikeHeightCalculatedProbability,
dikeHeightCalculatedReliability,
dikeHeightConvergence,
null);
var overtoppingRateOutput = new OvertoppingRateOutput(overtoppingRate,
overtoppingRateTargetProbability,
overtoppingRateTargetReliability,
overtoppingRateCalculatedProbability,
overtoppingRateCalculatedReliability,
overtoppingRateConvergence,
null);
var output = new GrassCoverErosionInwardsOutput(resultOutput, dikeHeightOutput, overtoppingRateOutput);
// Call
var properties = new GrassCoverErosionInwardsOutputProperties(output);
// Assert
Assert.AreEqual(2, properties.WaveHeight.NumberOfDecimalPlaces);
Assert.AreEqual(waveHeight, properties.WaveHeight, properties.WaveHeight.GetAccuracy());
Assert.AreEqual(reliability, properties.Reliability, properties.Reliability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(0.5), properties.Probability);
Assert.AreEqual(isOvertoppingDominant, properties.IsOvertoppingDominant);
Assert.AreEqual(2, properties.DikeHeight.NumberOfDecimalPlaces);
Assert.AreEqual(dikeHeight, properties.DikeHeight, properties.DikeHeight.GetAccuracy());
Assert.AreEqual(dikeHeightTargetProbability, properties.DikeHeightTargetProbability);
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightTargetProbability));
Assert.AreEqual(dikeHeightTargetReliability, properties.DikeHeightTargetReliability, properties.DikeHeightTargetReliability.GetAccuracy());
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightTargetReliability));
Assert.AreEqual(dikeHeightCalculatedProbability, properties.DikeHeightCalculatedProbability);
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightCalculatedProbability));
Assert.AreEqual(dikeHeightCalculatedReliability, properties.DikeHeightCalculatedReliability, properties.DikeHeightCalculatedReliability.GetAccuracy());
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightCalculatedReliability));
string dikeHeightConvergenceValue = EnumDisplayNameHelper.GetDisplayName(dikeHeightConvergence);
Assert.AreEqual(dikeHeightConvergenceValue, properties.DikeHeightConvergence);
Assert.AreEqual(2, properties.OvertoppingRate.NumberOfDecimalPlaces);
Assert.AreEqual(overtoppingRate * 1000, properties.OvertoppingRate, properties.OvertoppingRate.GetAccuracy());
Assert.AreEqual(overtoppingRateTargetProbability, properties.OvertoppingRateTargetProbability);
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateTargetProbability));
Assert.AreEqual(overtoppingRateTargetReliability, properties.OvertoppingRateTargetReliability, properties.OvertoppingRateTargetReliability.GetAccuracy());
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateTargetReliability));
Assert.AreEqual(overtoppingRateCalculatedProbability, properties.OvertoppingRateCalculatedProbability);
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateCalculatedProbability));
Assert.AreEqual(overtoppingRateCalculatedReliability, properties.OvertoppingRateCalculatedReliability, properties.OvertoppingRateCalculatedReliability.GetAccuracy());
TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateCalculatedReliability));
string overtoppingRateConvergenceValue = EnumDisplayNameHelper.GetDisplayName(overtoppingRateConvergence);
Assert.AreEqual(overtoppingRateConvergenceValue, properties.OvertoppingRateConvergence);
}
public void Data_SetNewStabilityPointStructureInstance_ReturnCorrectPropertyValues()
{
// Setup
StabilityPointStructure structure = new TestStabilityPointStructure();
var properties = new StabilityPointStructureProperties();
// Call
properties.Data = structure;
// Assert
Assert.AreEqual(structure.Id, properties.Id);
Assert.AreEqual(structure.Name, properties.Name);
var expectedLocation = new Point2D(new RoundedDouble(0, structure.Location.X),
new RoundedDouble(0, structure.Location.Y));
Assert.AreEqual(expectedLocation, properties.Location);
Assert.AreEqual("Normaal", properties.InsideWaterLevel.DistributionType);
Assert.AreEqual(structure.InsideWaterLevel, properties.InsideWaterLevel.Data);
Assert.IsTrue(properties.InsideWaterLevel.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.InsideWaterLevel.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Normaal", properties.InsideWaterLevelFailureConstruction.DistributionType);
Assert.AreEqual(structure.InsideWaterLevelFailureConstruction, properties.InsideWaterLevelFailureConstruction.Data);
Assert.IsTrue(properties.InsideWaterLevelFailureConstruction.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.InsideWaterLevelFailureConstruction.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual(structure.StructureNormalOrientation, properties.StructureNormalOrientation);
Assert.AreEqual(structure.InflowModelType, properties.InflowModelType);
Assert.AreEqual("Normaal", properties.WidthFlowApertures.DistributionType);
Assert.AreEqual(structure.WidthFlowApertures, properties.WidthFlowApertures.Data);
Assert.IsTrue(properties.WidthFlowApertures.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.WidthFlowApertures.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Lognormaal", properties.AreaFlowApertures.DistributionType);
Assert.AreEqual(structure.AreaFlowApertures, properties.AreaFlowApertures.Data);
Assert.IsTrue(properties.AreaFlowApertures.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.AreaFlowApertures.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Lognormaal", properties.FlowWidthAtBottomProtection.DistributionType);
Assert.AreEqual(structure.FlowWidthAtBottomProtection, properties.FlowWidthAtBottomProtection.Data);
Assert.IsTrue(properties.FlowWidthAtBottomProtection.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.FlowWidthAtBottomProtection.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Lognormaal", properties.StorageStructureArea.DistributionType);
Assert.AreEqual(structure.StorageStructureArea, properties.StorageStructureArea.Data);
Assert.IsTrue(properties.StorageStructureArea.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.StorageStructureArea.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual("Lognormaal", properties.AllowedLevelIncreaseStorage.DistributionType);
Assert.AreEqual(structure.AllowedLevelIncreaseStorage, properties.AllowedLevelIncreaseStorage.Data);
Assert.IsTrue(properties.AllowedLevelIncreaseStorage.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.AllowedLevelIncreaseStorage.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Normaal", properties.LevelCrestStructure.DistributionType);
Assert.AreEqual(structure.LevelCrestStructure, properties.LevelCrestStructure.Data);
Assert.IsTrue(properties.LevelCrestStructure.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.LevelCrestStructure.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Normaal", properties.ThresholdHeightOpenWeir.DistributionType);
Assert.AreEqual(structure.ThresholdHeightOpenWeir, properties.ThresholdHeightOpenWeir.Data);
Assert.IsTrue(properties.ThresholdHeightOpenWeir.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.ThresholdHeightOpenWeir.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Lognormaal", properties.CriticalOvertoppingDischarge.DistributionType);
Assert.AreEqual(structure.CriticalOvertoppingDischarge, properties.CriticalOvertoppingDischarge.Data);
Assert.IsTrue(properties.CriticalOvertoppingDischarge.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.CriticalOvertoppingDischarge.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual("Lognormaal", properties.ConstructiveStrengthLinearLoadModel.DistributionType);
Assert.AreEqual(structure.ConstructiveStrengthLinearLoadModel, properties.ConstructiveStrengthLinearLoadModel.Data);
Assert.IsTrue(properties.ConstructiveStrengthLinearLoadModel.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.ConstructiveStrengthLinearLoadModel.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual("Lognormaal", properties.ConstructiveStrengthQuadraticLoadModel.DistributionType);
Assert.AreEqual(structure.ConstructiveStrengthQuadraticLoadModel, properties.ConstructiveStrengthQuadraticLoadModel.Data);
Assert.IsTrue(properties.ConstructiveStrengthQuadraticLoadModel.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.ConstructiveStrengthQuadraticLoadModel.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual("Normaal", properties.BankWidth.DistributionType);
Assert.AreEqual(structure.BankWidth, properties.BankWidth.Data);
Assert.IsTrue(properties.BankWidth.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.BankWidth.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual(structure.EvaluationLevel, properties.EvaluationLevel);
Assert.AreEqual(structure.VerticalDistance, properties.VerticalDistance);
Assert.AreEqual(ProbabilityFormattingHelper.Format(structure.FailureProbabilityRepairClosure), properties.FailureProbabilityRepairClosure);
Assert.AreEqual("Lognormaal", properties.FailureCollisionEnergy.DistributionType);
Assert.AreEqual(structure.FailureCollisionEnergy, properties.FailureCollisionEnergy.Data);
Assert.IsTrue(properties.FailureCollisionEnergy.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.FailureCollisionEnergy.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual("Normaal", properties.ShipMass.DistributionType);
Assert.AreEqual(structure.ShipMass, properties.ShipMass.Data);
Assert.IsTrue(properties.ShipMass.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.ShipMass.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual("Normaal", properties.ShipVelocity.DistributionType);
Assert.AreEqual(structure.ShipVelocity, properties.ShipVelocity.Data);
Assert.IsTrue(properties.ShipVelocity.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.ShipVelocity.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual(structure.LevellingCount, properties.LevellingCount);
Assert.AreEqual(ProbabilityFormattingHelper.Format(structure.ProbabilityCollisionSecondaryStructure), properties.ProbabilityCollisionSecondaryStructure);
Assert.AreEqual("Normaal", properties.FlowVelocityStructureClosable.DistributionType);
Assert.AreEqual(structure.FlowVelocityStructureClosable, properties.FlowVelocityStructureClosable.Data);
Assert.IsTrue(properties.FlowVelocityStructureClosable.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.FlowVelocityStructureClosable.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual("Lognormaal", properties.StabilityLinearLoadModel.DistributionType);
Assert.AreEqual(structure.StabilityLinearLoadModel, properties.StabilityLinearLoadModel.Data);
Assert.IsTrue(properties.StabilityLinearLoadModel.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.StabilityLinearLoadModel.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual("Lognormaal", properties.StabilityQuadraticLoadModel.DistributionType);
Assert.AreEqual(structure.StabilityQuadraticLoadModel, properties.StabilityQuadraticLoadModel.Data);
Assert.IsTrue(properties.StabilityQuadraticLoadModel.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.StabilityQuadraticLoadModel.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
}
public void Data_SetNewClosingStructureInstance_ReturnCorrectPropertyValues()
{
// Setup
ClosingStructure structure = new TestClosingStructure();
var properties = new ClosingStructureProperties();
// Call
properties.Data = structure;
// Assert
Assert.AreEqual(structure.Id, properties.Id);
Assert.AreEqual(structure.Name, properties.Name);
Assert.AreEqual(Math.Round(structure.Location.X), properties.Location.X);
Assert.AreEqual(Math.Round(structure.Location.Y), properties.Location.Y);
Assert.AreEqual(structure.StructureNormalOrientation, properties.StructureNormalOrientation);
Assert.AreEqual(structure.InflowModelType, properties.InflowModelType);
Assert.AreEqual("Normaal", properties.WidthFlowApertures.DistributionType);
Assert.AreEqual(structure.WidthFlowApertures, properties.WidthFlowApertures.Data);
Assert.IsTrue(properties.WidthFlowApertures.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.WidthFlowApertures.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Lognormaal", properties.AreaFlowApertures.DistributionType);
Assert.AreEqual(structure.AreaFlowApertures, properties.AreaFlowApertures.Data);
Assert.IsTrue(properties.AreaFlowApertures.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.AreaFlowApertures.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual(structure.IdenticalApertures, properties.IdenticalApertures);
Assert.AreEqual("Lognormaal", properties.FlowWidthAtBottomProtection.DistributionType);
Assert.AreEqual(structure.FlowWidthAtBottomProtection, properties.FlowWidthAtBottomProtection.Data);
Assert.IsTrue(properties.FlowWidthAtBottomProtection.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.FlowWidthAtBottomProtection.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Lognormaal", properties.StorageStructureArea.DistributionType);
Assert.AreEqual(structure.StorageStructureArea, properties.StorageStructureArea.Data);
Assert.IsTrue(properties.StorageStructureArea.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.StorageStructureArea.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual("Lognormaal", properties.AllowedLevelIncreaseStorage.DistributionType);
Assert.AreEqual(structure.AllowedLevelIncreaseStorage, properties.AllowedLevelIncreaseStorage.Data);
Assert.IsTrue(properties.AllowedLevelIncreaseStorage.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.AllowedLevelIncreaseStorage.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Normaal", properties.LevelCrestStructureNotClosing.DistributionType);
Assert.AreEqual(structure.LevelCrestStructureNotClosing, properties.LevelCrestStructureNotClosing.Data);
Assert.IsTrue(properties.LevelCrestStructureNotClosing.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.LevelCrestStructureNotClosing.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Normaal", properties.ThresholdHeightOpenWeir.DistributionType);
Assert.AreEqual(structure.ThresholdHeightOpenWeir, properties.ThresholdHeightOpenWeir.Data);
Assert.IsTrue(properties.ThresholdHeightOpenWeir.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.ThresholdHeightOpenWeir.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Normaal", properties.InsideWaterLevel.DistributionType);
Assert.AreEqual(structure.InsideWaterLevel, properties.InsideWaterLevel.Data);
Assert.IsTrue(properties.InsideWaterLevel.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.InsideWaterLevel.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Lognormaal", properties.CriticalOvertoppingDischarge.DistributionType);
Assert.AreEqual(structure.CriticalOvertoppingDischarge, properties.CriticalOvertoppingDischarge.Data);
Assert.IsTrue(properties.CriticalOvertoppingDischarge.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.CriticalOvertoppingDischarge.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual(ProbabilityFormattingHelper.Format(structure.ProbabilityOpenStructureBeforeFlooding), properties.ProbabilityOpenStructureBeforeFlooding);
Assert.AreEqual(ProbabilityFormattingHelper.Format(structure.FailureProbabilityOpenStructure), properties.FailureProbabilityOpenStructure);
Assert.AreEqual(ProbabilityFormattingHelper.Format(structure.FailureProbabilityReparation), properties.FailureProbabilityReparation);
}