/// <summary>
/// Removes the <paramref name="structure"/> and clears all dependent data, either directly or indirectly.
/// </summary>
/// <param name="structure">The structure to be removed.</param>
/// <param name="failureMechanism">The <see cref="ClosingStructuresFailureMechanism"/>
/// to clear the data from.</param>
/// <returns>All objects affected by the removal.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static IEnumerable <IObservable> RemoveStructure(ClosingStructure structure,
ClosingStructuresFailureMechanism failureMechanism)
{
if (structure == null)
{
throw new ArgumentNullException(nameof(structure));
}
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
IEnumerable <StructuresCalculation <ClosingStructuresInput> > calculations =
failureMechanism.Calculations.Cast <StructuresCalculation <ClosingStructuresInput> >();
StructuresCalculation <ClosingStructuresInput>[] calculationWithRemovedStructure = calculations
.Where(c => ReferenceEquals(c.InputParameters.Structure, structure))
.ToArray();
List <IObservable> changedObservables = ClearStructureDependentData(calculationWithRemovedStructure);
StructureCollection <ClosingStructure> structures = failureMechanism.ClosingStructures;
structures.Remove(structure);
changedObservables.Add(structures);
return(changedObservables);
}
public void SynchronizeStructureInput_ChangedStructure_ExpectedValues()
{
// Setup
var differentStructure = new ClosingStructure(new ClosingStructure.ConstructionProperties
{
Id = "Test id",
Name = "Test name",
Location = new Point2D(-1, -1)
});
var input = new ClosingStructuresInput
{
Structure = new TestClosingStructure()
};
input.Structure.CopyProperties(differentStructure);
// Precondition
AssertClosingStructureInput(new TestClosingStructure(), input);
// Call
input.SynchronizeStructureInput();
// Assert
AssertClosingStructureInput(differentStructure, input);
}
public void Import_MissingParametersAndDuplicateIrrelevantParameter_LogWarningAndContinueImportWithDefaultValues()
{
// Setup
var importTarget = new StructureCollection <ClosingStructure>();
string filePath = Path.Combine(testDataPath, nameof(ClosingStructuresImporter),
"MissingAndDuplicateIrrelevantParameters", "Kunstwerken.shp");
var messageProvider = mocks.Stub <IImporterMessageProvider>();
var updateStrategy = mocks.StrictMock <IStructureUpdateStrategy <ClosingStructure> >();
updateStrategy.Expect(u => u.UpdateStructuresWithImportedData(null, null)).IgnoreArguments().WhenCalled(i =>
{
Assert.AreEqual(filePath, i.Arguments[1]);
var defaultStructure = new ClosingStructure(new ClosingStructure.ConstructionProperties
{
Name = "test",
Location = new Point2D(0, 0),
Id = "id"
});
var readStructures = (IEnumerable <ClosingStructure>)i.Arguments[0];
Assert.AreEqual(1, readStructures.Count());
ClosingStructure importedStructure = readStructures.First();
DistributionAssert.AreEqual(defaultStructure.StorageStructureArea, importedStructure.StorageStructureArea);
DistributionAssert.AreEqual(defaultStructure.LevelCrestStructureNotClosing, importedStructure.LevelCrestStructureNotClosing);
DistributionAssert.AreEqual(defaultStructure.AreaFlowApertures, importedStructure.AreaFlowApertures);
Assert.AreEqual(defaultStructure.FailureProbabilityReparation, importedStructure.FailureProbabilityReparation);
});
mocks.ReplayAll();
ReferenceLine referenceLine = CreateReferenceLine();
var structuresImporter = new ClosingStructuresImporter(importTarget, referenceLine,
filePath, messageProvider, updateStrategy);
// Call
var importResult = false;
Action call = () => importResult = structuresImporter.Import();
// Assert
TestHelper.AssertLogMessages(call, msgs =>
{
string[] messages = msgs.ToArray();
Assert.AreEqual(10, messages.Length);
const string structure = "'Coupure Den Oever (90k1)' (KUNST1)";
Assert.AreEqual($"Geen definitie gevonden voor parameter 'KW_BETSLUIT1' van kunstwerk {structure}. Er wordt een standaard waarde gebruikt.", messages[0]);
Assert.AreEqual($"Geen definitie gevonden voor parameter 'KW_BETSLUIT5' van kunstwerk {structure}. Er wordt een standaard waarde gebruikt.", messages[3]);
Assert.AreEqual($"Geen definitie gevonden voor parameter 'KW_BETSLUIT8' van kunstwerk {structure}. Er wordt een standaard waarde gebruikt.", messages[6]);
Assert.AreEqual($"Geen definitie gevonden voor parameter 'KW_BETSLUIT14' van kunstwerk {structure}. Er wordt een standaard waarde gebruikt.", messages[8]);
// Don't care about the other messages.
});
Assert.IsTrue(importResult);
}
public void Import_VarianceValuesNeedConversion_WarnUserAboutConversion()
{
// Setup
var importTarget = new StructureCollection <ClosingStructure>();
string filePath = Path.Combine(testDataPath, "StructuresVarianceValueConversion",
"Kunstwerken.shp");
var messageProvider = mocks.Stub <IImporterMessageProvider>();
var updateStrategy = mocks.StrictMock <IStructureUpdateStrategy <ClosingStructure> >();
updateStrategy.Expect(u => u.UpdateStructuresWithImportedData(null, null)).IgnoreArguments().WhenCalled(i =>
{
Assert.AreEqual(filePath, i.Arguments[1]);
var closingStructures = (IEnumerable <ClosingStructure>)i.Arguments[0];
Assert.AreEqual(1, closingStructures.Count());
ClosingStructure structure = closingStructures.First();
Assert.AreEqual(0.2, structure.StorageStructureArea.CoefficientOfVariation.Value);
Assert.AreEqual(20, structure.AllowedLevelIncreaseStorage.StandardDeviation.Value);
Assert.AreEqual(50, structure.WidthFlowApertures.StandardDeviation.Value);
Assert.AreEqual(2.2, structure.LevelCrestStructureNotClosing.StandardDeviation.Value);
Assert.AreEqual(3.3, structure.InsideWaterLevel.StandardDeviation.Value);
Assert.AreEqual(4.4, structure.ThresholdHeightOpenWeir.StandardDeviation.Value);
Assert.AreEqual(5.5, structure.AreaFlowApertures.StandardDeviation.Value);
Assert.AreEqual(0.1, structure.CriticalOvertoppingDischarge.CoefficientOfVariation.Value);
Assert.AreEqual(6.6, structure.FlowWidthAtBottomProtection.StandardDeviation.Value);
});
mocks.ReplayAll();
ReferenceLine referenceLine = CreateReferenceLine();
var importer = new ClosingStructuresImporter(importTarget, referenceLine, filePath,
messageProvider, updateStrategy);
// Call
var importResult = false;
Action call = () => importResult = importer.Import();
// Assert
string[] expectedMessages =
{
"De variatie voor parameter 'KW_BETSLUIT1' van kunstwerk 'Coupure Den Oever (90k1)' (KUNST1) wordt omgerekend in een variatiecoëfficiënt (regel 10).",
"De variatie voor parameter 'KW_BETSLUIT2' van kunstwerk 'Coupure Den Oever (90k1)' (KUNST1) wordt omgerekend in een standaardafwijking (regel 11).",
"De variatie voor parameter 'KW_BETSLUIT4' van kunstwerk 'Coupure Den Oever (90k1)' (KUNST1) wordt omgerekend in een standaardafwijking (regel 13).",
"De variatie voor parameter 'KW_BETSLUIT5' van kunstwerk 'Coupure Den Oever (90k1)' (KUNST1) wordt omgerekend in een standaardafwijking (regel 14).",
"De variatie voor parameter 'KW_BETSLUIT6' van kunstwerk 'Coupure Den Oever (90k1)' (KUNST1) wordt omgerekend in een standaardafwijking (regel 15).",
"De variatie voor parameter 'KW_BETSLUIT7' van kunstwerk 'Coupure Den Oever (90k1)' (KUNST1) wordt omgerekend in een standaardafwijking (regel 16).",
"De variatie voor parameter 'KW_BETSLUIT8' van kunstwerk 'Coupure Den Oever (90k1)' (KUNST1) wordt omgerekend in een standaardafwijking (regel 17).",
"De variatie voor parameter 'KW_BETSLUIT9' van kunstwerk 'Coupure Den Oever (90k1)' (KUNST1) wordt omgerekend in een variatiecoëfficiënt (regel 18).",
"De variatie voor parameter 'KW_BETSLUIT10' van kunstwerk 'Coupure Den Oever (90k1)' (KUNST1) wordt omgerekend in een standaardafwijking (regel 19)."
};
TestHelper.AssertLogMessagesAreGenerated(call, expectedMessages);
Assert.IsTrue(importResult);
}
/// <summary>
/// Creates a <see cref="ClosingStructureEntity"/> based on the information of the <see cref="ClosingStructure"/>.
/// </summary>
/// <param name="structure">The structure to create a database entity for.</param>
/// <param name="registry">The object keeping track of create operations.</param>
/// <param name="order">The index at which <paramref name="structure"/> resides within its parent.</param>
/// <returns>A new <see cref="ClosingStructureEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="registry"/> is <c>null</c>.</exception>
internal static ClosingStructureEntity Create(this ClosingStructure structure, PersistenceRegistry registry, int order)
{
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
if (registry.Contains(structure))
{
return(registry.Get(structure));
}
var entity = new ClosingStructureEntity
{
Name = structure.Name.DeepClone(),
Id = structure.Id.DeepClone(),
X = structure.Location.X.ToNaNAsNull(),
Y = structure.Location.Y.ToNaNAsNull(),
StructureNormalOrientation = structure.StructureNormalOrientation.ToNaNAsNull(),
StorageStructureAreaMean = structure.StorageStructureArea.Mean.ToNaNAsNull(),
StorageStructureAreaCoefficientOfVariation = structure.StorageStructureArea.CoefficientOfVariation.ToNaNAsNull(),
AllowedLevelIncreaseStorageMean = structure.AllowedLevelIncreaseStorage.Mean.ToNaNAsNull(),
AllowedLevelIncreaseStorageStandardDeviation = structure.AllowedLevelIncreaseStorage.StandardDeviation.ToNaNAsNull(),
WidthFlowAperturesMean = structure.WidthFlowApertures.Mean.ToNaNAsNull(),
WidthFlowAperturesStandardDeviation = structure.WidthFlowApertures.StandardDeviation.ToNaNAsNull(),
LevelCrestStructureNotClosingMean = structure.LevelCrestStructureNotClosing.Mean.ToNaNAsNull(),
LevelCrestStructureNotClosingStandardDeviation = structure.LevelCrestStructureNotClosing.StandardDeviation.ToNaNAsNull(),
InsideWaterLevelMean = structure.InsideWaterLevel.Mean.ToNaNAsNull(),
InsideWaterLevelStandardDeviation = structure.InsideWaterLevel.StandardDeviation.ToNaNAsNull(),
ThresholdHeightOpenWeirMean = structure.ThresholdHeightOpenWeir.Mean.ToNaNAsNull(),
ThresholdHeightOpenWeirStandardDeviation = structure.ThresholdHeightOpenWeir.StandardDeviation.ToNaNAsNull(),
AreaFlowAperturesMean = structure.AreaFlowApertures.Mean.ToNaNAsNull(),
AreaFlowAperturesStandardDeviation = structure.AreaFlowApertures.StandardDeviation.ToNaNAsNull(),
CriticalOvertoppingDischargeMean = structure.CriticalOvertoppingDischarge.Mean.ToNaNAsNull(),
CriticalOvertoppingDischargeCoefficientOfVariation = structure.CriticalOvertoppingDischarge.CoefficientOfVariation.ToNaNAsNull(),
FlowWidthAtBottomProtectionMean = structure.FlowWidthAtBottomProtection.Mean.ToNaNAsNull(),
FlowWidthAtBottomProtectionStandardDeviation = structure.FlowWidthAtBottomProtection.StandardDeviation.ToNaNAsNull(),
ProbabilityOpenStructureBeforeFlooding = structure.ProbabilityOpenStructureBeforeFlooding.ToNaNAsNull(),
FailureProbabilityOpenStructure = structure.FailureProbabilityOpenStructure.ToNaNAsNull(),
IdenticalApertures = structure.IdenticalApertures,
FailureProbabilityReparation = structure.FailureProbabilityReparation.ToNaNAsNull(),
InflowModelType = Convert.ToByte(structure.InflowModelType),
Order = order
};
registry.Register(entity, structure);
return(entity);
}
public void Read_EntityRegistered_ReturnRegisteredStructure()
{
// Setup
var entity = new ClosingStructureEntity();
ClosingStructure registeredStructure = new TestClosingStructure();
var collector = new ReadConversionCollector();
collector.Read(entity, registeredStructure);
// Call
ClosingStructure readStructure = entity.Read(collector);
// Assert
Assert.AreSame(registeredStructure, readStructure);
}
public void CopyProperties_FromStructureNull_ThrowsArgumentNullException()
{
// Setup
var structure = new ClosingStructure(new ClosingStructure.ConstructionProperties
{
Name = "aName",
Id = "anId",
Location = new Point2D(0, 0)
});
// Call
TestDelegate call = () => structure.CopyProperties(null);
// Assert
string paramName = Assert.Throws <ArgumentNullException>(call).ParamName;
Assert.AreEqual("fromStructure", paramName);
}
private static void AssertClosingStructureInput(ClosingStructure expectedClosingStructure, ClosingStructuresInput input)
{
if (expectedClosingStructure == null)
{
Assert.IsNull(input.Structure);
var defaultInput = new ClosingStructuresInput();
AssertAreEqual(defaultInput.StructureNormalOrientation, input.StructureNormalOrientation);
DistributionAssert.AreEqual(defaultInput.LevelCrestStructureNotClosing, input.LevelCrestStructureNotClosing);
DistributionAssert.AreEqual(defaultInput.FlowWidthAtBottomProtection, input.FlowWidthAtBottomProtection);
DistributionAssert.AreEqual(defaultInput.CriticalOvertoppingDischarge, input.CriticalOvertoppingDischarge);
DistributionAssert.AreEqual(defaultInput.WidthFlowApertures, input.WidthFlowApertures);
DistributionAssert.AreEqual(defaultInput.StorageStructureArea, input.StorageStructureArea);
DistributionAssert.AreEqual(defaultInput.AllowedLevelIncreaseStorage, input.AllowedLevelIncreaseStorage);
Assert.AreEqual(defaultInput.InflowModelType, input.InflowModelType);
DistributionAssert.AreEqual(defaultInput.AreaFlowApertures, input.AreaFlowApertures);
Assert.AreEqual(defaultInput.FailureProbabilityOpenStructure, input.FailureProbabilityOpenStructure);
Assert.AreEqual(defaultInput.FailureProbabilityReparation, input.FailureProbabilityReparation);
Assert.AreEqual(defaultInput.IdenticalApertures, input.IdenticalApertures);
DistributionAssert.AreEqual(defaultInput.InsideWaterLevel, input.InsideWaterLevel);
Assert.AreEqual(defaultInput.ProbabilityOpenStructureBeforeFlooding, input.ProbabilityOpenStructureBeforeFlooding);
DistributionAssert.AreEqual(defaultInput.ThresholdHeightOpenWeir, input.ThresholdHeightOpenWeir);
}
else
{
AssertAreEqual(expectedClosingStructure.StructureNormalOrientation, input.StructureNormalOrientation);
DistributionAssert.AreEqual(expectedClosingStructure.LevelCrestStructureNotClosing, input.LevelCrestStructureNotClosing);
DistributionAssert.AreEqual(expectedClosingStructure.FlowWidthAtBottomProtection, input.FlowWidthAtBottomProtection);
DistributionAssert.AreEqual(expectedClosingStructure.CriticalOvertoppingDischarge, input.CriticalOvertoppingDischarge);
DistributionAssert.AreEqual(expectedClosingStructure.WidthFlowApertures, input.WidthFlowApertures);
DistributionAssert.AreEqual(expectedClosingStructure.StorageStructureArea, input.StorageStructureArea);
DistributionAssert.AreEqual(expectedClosingStructure.AllowedLevelIncreaseStorage, input.AllowedLevelIncreaseStorage);
Assert.AreEqual(expectedClosingStructure.InflowModelType, input.InflowModelType);
DistributionAssert.AreEqual(expectedClosingStructure.AreaFlowApertures, input.AreaFlowApertures);
Assert.AreEqual(expectedClosingStructure.FailureProbabilityOpenStructure, input.FailureProbabilityOpenStructure);
Assert.AreEqual(expectedClosingStructure.FailureProbabilityReparation, input.FailureProbabilityReparation);
Assert.AreEqual(expectedClosingStructure.IdenticalApertures, input.IdenticalApertures);
DistributionAssert.AreEqual(expectedClosingStructure.InsideWaterLevel, input.InsideWaterLevel);
Assert.AreEqual(expectedClosingStructure.ProbabilityOpenStructureBeforeFlooding, input.ProbabilityOpenStructureBeforeFlooding);
DistributionAssert.AreEqual(expectedClosingStructure.ThresholdHeightOpenWeir, input.ThresholdHeightOpenWeir);
}
}
public void Read_EntityNotReadBefore_RegisterEntity()
{
// Setup
var entity = new ClosingStructureEntity
{
Name = "name",
Id = "id"
};
var collector = new ReadConversionCollector();
// Precondition
Assert.IsFalse(collector.Contains(entity));
// Call
ClosingStructure calculation = entity.Read(collector);
// Assert
Assert.IsTrue(collector.Contains(entity));
Assert.AreSame(calculation, collector.Get(entity));
}
private static void AssertClosingStructures(ClosingStructure readStructure, ClosingStructure structure)
{
Assert.AreEqual(readStructure.Name, structure.Name);
Assert.AreEqual(readStructure.Location, structure.Location);
Assert.AreEqual(readStructure.StructureNormalOrientation, structure.StructureNormalOrientation);
DistributionAssert.AreEqual(readStructure.AllowedLevelIncreaseStorage, structure.AllowedLevelIncreaseStorage);
DistributionAssert.AreEqual(readStructure.AreaFlowApertures, structure.AreaFlowApertures);
DistributionAssert.AreEqual(readStructure.CriticalOvertoppingDischarge, structure.CriticalOvertoppingDischarge);
Assert.AreEqual(readStructure.FailureProbabilityOpenStructure, structure.FailureProbabilityOpenStructure);
Assert.AreEqual(readStructure.FailureProbabilityReparation, structure.FailureProbabilityReparation);
Assert.AreEqual(readStructure.IdenticalApertures, structure.IdenticalApertures);
Assert.AreEqual(readStructure.InflowModelType, structure.InflowModelType);
Assert.AreEqual(readStructure.ProbabilityOpenStructureBeforeFlooding, structure.ProbabilityOpenStructureBeforeFlooding);
DistributionAssert.AreEqual(readStructure.FlowWidthAtBottomProtection, structure.FlowWidthAtBottomProtection);
DistributionAssert.AreEqual(readStructure.InsideWaterLevel, structure.InsideWaterLevel);
DistributionAssert.AreEqual(readStructure.LevelCrestStructureNotClosing, structure.LevelCrestStructureNotClosing);
DistributionAssert.AreEqual(readStructure.StorageStructureArea, structure.StorageStructureArea);
DistributionAssert.AreEqual(readStructure.ThresholdHeightOpenWeir, structure.ThresholdHeightOpenWeir);
DistributionAssert.AreEqual(readStructure.WidthFlowApertures, structure.WidthFlowApertures);
}
public void Create_NaNValue_ReturnEntityWithNullValue()
{
// Setup
var structure = new ClosingStructure(new ClosingStructure.ConstructionProperties
{
Name = "A",
Id = "B",
Location = new Point2D(double.NaN, double.NaN),
StructureNormalOrientation = RoundedDouble.NaN,
StorageStructureArea =
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
},
AllowedLevelIncreaseStorage =
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
},
WidthFlowApertures =
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
},
LevelCrestStructureNotClosing =
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
},
InsideWaterLevel =
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
},
ThresholdHeightOpenWeir =
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
},
AreaFlowApertures =
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
},
CriticalOvertoppingDischarge =
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
},
FlowWidthAtBottomProtection =
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
},
ProbabilityOpenStructureBeforeFlooding = double.NaN,
FailureProbabilityOpenStructure = double.NaN,
FailureProbabilityReparation = double.NaN
});
var registry = new PersistenceRegistry();
// Call
ClosingStructureEntity entity = structure.Create(registry, 0);
// Assert
Assert.IsNull(entity.X);
Assert.IsNull(entity.Y);
Assert.IsNull(entity.StructureNormalOrientation);
Assert.IsNull(entity.StorageStructureAreaMean);
Assert.IsNull(entity.StorageStructureAreaCoefficientOfVariation);
Assert.IsNull(entity.AllowedLevelIncreaseStorageMean);
Assert.IsNull(entity.AllowedLevelIncreaseStorageStandardDeviation);
Assert.IsNull(entity.WidthFlowAperturesMean);
Assert.IsNull(entity.WidthFlowAperturesStandardDeviation);
Assert.IsNull(entity.LevelCrestStructureNotClosingMean);
Assert.IsNull(entity.LevelCrestStructureNotClosingStandardDeviation);
Assert.IsNull(entity.InsideWaterLevelMean);
Assert.IsNull(entity.InsideWaterLevelStandardDeviation);
Assert.IsNull(entity.ThresholdHeightOpenWeirMean);
Assert.IsNull(entity.ThresholdHeightOpenWeirStandardDeviation);
Assert.IsNull(entity.AreaFlowAperturesMean);
Assert.IsNull(entity.AreaFlowAperturesStandardDeviation);
Assert.IsNull(entity.CriticalOvertoppingDischargeMean);
Assert.IsNull(entity.CriticalOvertoppingDischargeCoefficientOfVariation);
Assert.IsNull(entity.FlowWidthAtBottomProtectionMean);
Assert.IsNull(entity.FlowWidthAtBottomProtectionStandardDeviation);
Assert.IsNull(entity.ProbabilityOpenStructureBeforeFlooding);
Assert.IsNull(entity.FailureProbabilityOpenStructure);
Assert.IsNull(entity.FailureProbabilityReparation);
}
/// <summary>
/// Reads the <see cref="ClosingStructureEntity"/> and use the information to update a
/// <see cref="ClosingStructure"/>.
/// </summary>
/// <param name="entity">The <see cref="ClosingStructureEntity"/> to create <see cref="ClosingStructure"/> for.</param>
/// <param name="collector">The object keeping track of read operations.</param>
/// <returns>A new <see cref="ClosingStructure"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="collector"/> is <c>null</c>.</exception>
internal static ClosingStructure Read(this ClosingStructureEntity entity, ReadConversionCollector collector)
{
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
if (collector.Contains(entity))
{
return(collector.Get(entity));
}
var structure = new ClosingStructure(new ClosingStructure.ConstructionProperties
{
Name = entity.Name,
Id = entity.Id,
Location = new Point2D(entity.X.ToNullAsNaN(), entity.Y.ToNullAsNaN()),
StructureNormalOrientation = (RoundedDouble)entity.StructureNormalOrientation.ToNullAsNaN(),
StorageStructureArea =
{
Mean = (RoundedDouble)entity.StorageStructureAreaMean.ToNullAsNaN(),
CoefficientOfVariation = (RoundedDouble)entity.StorageStructureAreaCoefficientOfVariation.ToNullAsNaN()
},
AllowedLevelIncreaseStorage =
{
Mean = (RoundedDouble)entity.AllowedLevelIncreaseStorageMean.ToNullAsNaN(),
StandardDeviation = (RoundedDouble)entity.AllowedLevelIncreaseStorageStandardDeviation.ToNullAsNaN()
},
WidthFlowApertures =
{
Mean = (RoundedDouble)entity.WidthFlowAperturesMean.ToNullAsNaN(),
StandardDeviation = (RoundedDouble)entity.WidthFlowAperturesStandardDeviation.ToNullAsNaN()
},
LevelCrestStructureNotClosing =
{
Mean = (RoundedDouble)entity.LevelCrestStructureNotClosingMean.ToNullAsNaN(),
StandardDeviation = (RoundedDouble)entity.LevelCrestStructureNotClosingStandardDeviation.ToNullAsNaN()
},
InsideWaterLevel =
{
Mean = (RoundedDouble)entity.InsideWaterLevelMean.ToNullAsNaN(),
StandardDeviation = (RoundedDouble)entity.InsideWaterLevelStandardDeviation.ToNullAsNaN()
},
ThresholdHeightOpenWeir =
{
Mean = (RoundedDouble)entity.ThresholdHeightOpenWeirMean.ToNullAsNaN(),
StandardDeviation = (RoundedDouble)entity.ThresholdHeightOpenWeirStandardDeviation.ToNullAsNaN()
},
AreaFlowApertures =
{
Mean = (RoundedDouble)entity.AreaFlowAperturesMean.ToNullAsNaN(),
StandardDeviation = (RoundedDouble)entity.AreaFlowAperturesStandardDeviation.ToNullAsNaN()
},
CriticalOvertoppingDischarge =
{
Mean = (RoundedDouble)entity.CriticalOvertoppingDischargeMean.ToNullAsNaN(),
CoefficientOfVariation = (RoundedDouble)entity.CriticalOvertoppingDischargeCoefficientOfVariation.ToNullAsNaN()
},
FlowWidthAtBottomProtection =
{
Mean = (RoundedDouble)entity.FlowWidthAtBottomProtectionMean.ToNullAsNaN(),
StandardDeviation = (RoundedDouble)entity.FlowWidthAtBottomProtectionStandardDeviation.ToNullAsNaN()
},
ProbabilityOpenStructureBeforeFlooding = entity.ProbabilityOpenStructureBeforeFlooding.ToNullAsNaN(),
FailureProbabilityOpenStructure = entity.FailureProbabilityOpenStructure.ToNullAsNaN(),
IdenticalApertures = entity.IdenticalApertures,
FailureProbabilityReparation = entity.FailureProbabilityReparation.ToNullAsNaN(),
InflowModelType = (ClosingStructureInflowModelType)entity.InflowModelType
});
collector.Read(entity, structure);
return(structure);
}
public void Constructor_DefaultConstructionProperties_ExpectedValues()
{
// Setup
var location = new Point2D(1.22, 2.333);
// Call
var structure = new ClosingStructure(
new ClosingStructure.ConstructionProperties
{
Name = "aName",
Id = "anId",
Location = location
});
// Assert
Assert.IsInstanceOf <StructureBase>(structure);
Assert.AreEqual("aName", structure.Name);
Assert.AreEqual("anId", structure.Id);
Assert.AreEqual(location.X, structure.Location.X);
Assert.AreEqual(location.Y, structure.Location.Y);
Assert.AreEqual(2, structure.StructureNormalOrientation.NumberOfDecimalPlaces);
Assert.IsNaN(structure.StructureNormalOrientation);
VariationCoefficientLogNormalDistribution storageStructureArea = structure.StorageStructureArea;
Assert.AreEqual(2, storageStructureArea.Mean.NumberOfDecimalPlaces);
Assert.IsNaN(storageStructureArea.Mean);
Assert.AreEqual(2, storageStructureArea.CoefficientOfVariation.NumberOfDecimalPlaces);
Assert.AreEqual(0.1, storageStructureArea.CoefficientOfVariation, storageStructureArea.CoefficientOfVariation.GetAccuracy());
LogNormalDistribution allowedLevelIncreaseStorage = structure.AllowedLevelIncreaseStorage;
Assert.AreEqual(2, allowedLevelIncreaseStorage.Mean.NumberOfDecimalPlaces);
Assert.IsNaN(allowedLevelIncreaseStorage.Mean);
Assert.AreEqual(2, allowedLevelIncreaseStorage.StandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.1, allowedLevelIncreaseStorage.StandardDeviation, allowedLevelIncreaseStorage.StandardDeviation.GetAccuracy());
NormalDistribution widthFlowApertures = structure.WidthFlowApertures;
Assert.AreEqual(2, widthFlowApertures.Mean.NumberOfDecimalPlaces);
Assert.IsNaN(widthFlowApertures.Mean);
Assert.AreEqual(2, widthFlowApertures.StandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.2, widthFlowApertures.StandardDeviation, widthFlowApertures.StandardDeviation.GetAccuracy());
NormalDistribution levelCrestStructureNotClosing = structure.LevelCrestStructureNotClosing;
Assert.AreEqual(2, levelCrestStructureNotClosing.Mean.NumberOfDecimalPlaces);
Assert.IsNaN(levelCrestStructureNotClosing.Mean);
Assert.AreEqual(2, levelCrestStructureNotClosing.StandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.05, levelCrestStructureNotClosing.StandardDeviation, levelCrestStructureNotClosing.StandardDeviation.GetAccuracy());
NormalDistribution insideWaterLevel = structure.InsideWaterLevel;
Assert.AreEqual(2, insideWaterLevel.Mean.NumberOfDecimalPlaces);
Assert.IsNaN(insideWaterLevel.Mean);
Assert.AreEqual(2, insideWaterLevel.StandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.1, insideWaterLevel.StandardDeviation, insideWaterLevel.StandardDeviation.GetAccuracy());
NormalDistribution thresholdHeightOpenWeir = structure.ThresholdHeightOpenWeir;
Assert.AreEqual(2, thresholdHeightOpenWeir.Mean.NumberOfDecimalPlaces);
Assert.IsNaN(thresholdHeightOpenWeir.Mean);
Assert.AreEqual(2, thresholdHeightOpenWeir.StandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.1, thresholdHeightOpenWeir.StandardDeviation, thresholdHeightOpenWeir.StandardDeviation.GetAccuracy());
LogNormalDistribution areaFlowApertures = structure.AreaFlowApertures;
Assert.AreEqual(2, areaFlowApertures.Mean.NumberOfDecimalPlaces);
Assert.IsNaN(areaFlowApertures.Mean);
Assert.AreEqual(2, areaFlowApertures.StandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.01, areaFlowApertures.StandardDeviation, areaFlowApertures.StandardDeviation.GetAccuracy());
VariationCoefficientLogNormalDistribution criticalOvertoppingDischarge = structure.CriticalOvertoppingDischarge;
Assert.AreEqual(2, criticalOvertoppingDischarge.Mean.NumberOfDecimalPlaces);
Assert.IsNaN(criticalOvertoppingDischarge.Mean);
Assert.AreEqual(2, criticalOvertoppingDischarge.CoefficientOfVariation.NumberOfDecimalPlaces);
Assert.AreEqual(0.15, criticalOvertoppingDischarge.CoefficientOfVariation, criticalOvertoppingDischarge.CoefficientOfVariation.GetAccuracy());
LogNormalDistribution flowWidthAtBottomProtection = structure.FlowWidthAtBottomProtection;
Assert.AreEqual(2, flowWidthAtBottomProtection.Mean.NumberOfDecimalPlaces);
Assert.IsNaN(flowWidthAtBottomProtection.Mean);
Assert.AreEqual(2, flowWidthAtBottomProtection.StandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.05, flowWidthAtBottomProtection.StandardDeviation, flowWidthAtBottomProtection.StandardDeviation.GetAccuracy());
Assert.AreEqual(1, structure.ProbabilityOpenStructureBeforeFlooding);
Assert.AreEqual(1, structure.FailureProbabilityOpenStructure);
Assert.AreEqual(1, structure.IdenticalApertures);
Assert.AreEqual(1, structure.FailureProbabilityReparation);
Assert.AreEqual(ClosingStructureInflowModelType.VerticalWall, structure.InflowModelType);
}
public void CopyProperties_FromStructure_UpdatesProperties()
{
// Setup
var random = new Random(123);
var structure = new ClosingStructure(new ClosingStructure.ConstructionProperties
{
Name = "aName",
Id = "anId",
Location = new Point2D(0, 0)
});
var otherStructure = new ClosingStructure(new ClosingStructure.ConstructionProperties
{
Name = "otherName",
Id = "otherId",
Location = new Point2D(1, 1),
StructureNormalOrientation = random.NextRoundedDouble(),
AllowedLevelIncreaseStorage =
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
},
AreaFlowApertures =
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
},
CriticalOvertoppingDischarge =
{
Mean = random.NextRoundedDouble(),
CoefficientOfVariation = random.NextRoundedDouble()
},
FlowWidthAtBottomProtection =
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
},
InsideWaterLevel =
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
},
LevelCrestStructureNotClosing =
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
},
StorageStructureArea =
{
Mean = random.NextRoundedDouble(),
CoefficientOfVariation = random.NextRoundedDouble()
},
ThresholdHeightOpenWeir =
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
},
WidthFlowApertures =
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
},
FailureProbabilityOpenStructure = random.NextDouble(),
FailureProbabilityReparation = random.NextDouble(),
InflowModelType = ClosingStructureInflowModelType.FloodedCulvert,
IdenticalApertures = random.Next(),
ProbabilityOpenStructureBeforeFlooding = random.NextDouble()
});
// Call
structure.CopyProperties(otherStructure);
// Assert
Assert.AreNotEqual(otherStructure.Id, structure.Id);
Assert.AreEqual(otherStructure.Name, structure.Name);
TestHelper.AssertAreEqualButNotSame(otherStructure.Location, structure.Location);
Assert.AreEqual(otherStructure.StructureNormalOrientation, structure.StructureNormalOrientation);
TestHelper.AssertAreEqualButNotSame(otherStructure.AllowedLevelIncreaseStorage, structure.AllowedLevelIncreaseStorage);
TestHelper.AssertAreEqualButNotSame(otherStructure.AreaFlowApertures, structure.AreaFlowApertures);
TestHelper.AssertAreEqualButNotSame(otherStructure.CriticalOvertoppingDischarge, structure.CriticalOvertoppingDischarge);
Assert.AreEqual(otherStructure.FailureProbabilityOpenStructure, structure.FailureProbabilityOpenStructure);
Assert.AreEqual(otherStructure.FailureProbabilityReparation, structure.FailureProbabilityReparation);
Assert.AreEqual(otherStructure.IdenticalApertures, structure.IdenticalApertures);
Assert.AreEqual(otherStructure.ProbabilityOpenStructureBeforeFlooding, structure.ProbabilityOpenStructureBeforeFlooding);
TestHelper.AssertAreEqualButNotSame(otherStructure.FlowWidthAtBottomProtection, structure.FlowWidthAtBottomProtection);
TestHelper.AssertAreEqualButNotSame(otherStructure.InsideWaterLevel, structure.InsideWaterLevel);
TestHelper.AssertAreEqualButNotSame(otherStructure.LevelCrestStructureNotClosing, structure.LevelCrestStructureNotClosing);
TestHelper.AssertAreEqualButNotSame(otherStructure.StorageStructureArea, structure.StorageStructureArea);
TestHelper.AssertAreEqualButNotSame(otherStructure.ThresholdHeightOpenWeir, structure.ThresholdHeightOpenWeir);
TestHelper.AssertAreEqualButNotSame(otherStructure.WidthFlowApertures, structure.WidthFlowApertures);
}
public void IsStructureInputSynchronized_StructureAndInputNotInSync_ReturnFalse(ClosingStructure modifiedStructure)
{
// Setup
var structure = new TestClosingStructure();
var input = new ClosingStructuresInput
{
Structure = structure
};
structure.CopyProperties(modifiedStructure);
// Call
bool isStructureInputSynchronized = input.IsStructureInputSynchronized;
// Assert
Assert.IsFalse(isStructureInputSynchronized);
}
/// <summary>
/// Obtains the <see cref="ClosingStructureEntity"/> which was registered for the
/// given <paramref name="model"/>.
/// </summary>
/// <param name="model">The <see cref="ClosingStructure"/> for which a read operation has been registered.</param>
/// <returns>The constructed <see cref="ClosingStructureEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="model"/> is <c>null</c>.</exception>
/// <exception cref="InvalidOperationException">Thrown when no create operation
/// has been registered for <paramref name="model"/>.</exception>
/// <remarks>Use <see cref="Contains(ClosingStructure)"/> to find out whether a
/// create operation has been registered for <paramref name="model"/>.</remarks>
internal ClosingStructureEntity Get(ClosingStructure model)
{
return(Get(closingStructures, model));
}
/// <summary>
/// Checks whether a create operations has been registered for the given <paramref name="model"/>.
/// </summary>
/// <param name="model">The <see cref="ClosingStructure"/> to check for.</param>
/// <returns><c>true</c> if the <see cref="model"/> was registered before, <c>false</c> otherwise.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="model"/> is <c>null</c>.</exception>
internal bool Contains(ClosingStructure model)
{
return(ContainsValue(closingStructures, model));
}
/// <summary>
/// Registers a create operation for <paramref name="model"/> and the <paramref name="entity"/>
/// that was constructed with the information.
/// </summary>
/// <param name="entity">The <see cref="ClosingStructureEntity"/> to be registered.</param>
/// <param name="model">The <see cref="ClosingStructure"/> to be registered.</param>
/// <exception cref="ArgumentNullException">Thrown when any of the input parameters is <c>null</c>.</exception>
internal void Register(ClosingStructureEntity entity, ClosingStructure model)
{
Register(closingStructures, entity, model);
}
public void Constructor_ValidData_ExpectedValues()
{
// Setup
var location = new Point2D(1.22, 2.333);
// Call
var structure = new ClosingStructure(
new ClosingStructure.ConstructionProperties
{
Name = "aName",
Id = "anId",
Location = location,
StorageStructureArea =
{
Mean = (RoundedDouble)123.456,
CoefficientOfVariation = (RoundedDouble)0.123
},
AllowedLevelIncreaseStorage =
{
Mean = (RoundedDouble)234.567,
StandardDeviation = (RoundedDouble)0.234
},
StructureNormalOrientation = (RoundedDouble)345.678,
WidthFlowApertures =
{
Mean = (RoundedDouble)456.789,
StandardDeviation = (RoundedDouble)0.456
},
LevelCrestStructureNotClosing =
{
Mean = (RoundedDouble)567.890,
StandardDeviation = (RoundedDouble)0.567
},
InsideWaterLevel =
{
Mean = (RoundedDouble)678.901,
StandardDeviation = (RoundedDouble)0.678
},
ThresholdHeightOpenWeir =
{
Mean = (RoundedDouble)789.012,
StandardDeviation = (RoundedDouble)0.789
},
AreaFlowApertures =
{
Mean = (RoundedDouble)890.123,
StandardDeviation = (RoundedDouble)0.890
},
CriticalOvertoppingDischarge =
{
Mean = (RoundedDouble)901.234,
CoefficientOfVariation = (RoundedDouble)0.901
},
FlowWidthAtBottomProtection =
{
Mean = (RoundedDouble)111.222,
StandardDeviation = (RoundedDouble)0.111
},
ProbabilityOpenStructureBeforeFlooding = 321.987,
FailureProbabilityOpenStructure = 654.321,
IdenticalApertures = 42,
FailureProbabilityReparation = 987.654,
InflowModelType = ClosingStructureInflowModelType.LowSill
});
// Assert
Assert.IsInstanceOf <StructureBase>(structure);
Assert.AreEqual("aName", structure.Name);
Assert.AreEqual("anId", structure.Id);
Assert.AreEqual(location.X, structure.Location.X);
Assert.AreEqual(location.Y, structure.Location.Y);
Assert.AreEqual(345.68, structure.StructureNormalOrientation, structure.StructureNormalOrientation.GetAccuracy());
VariationCoefficientLogNormalDistribution storageStructureArea = structure.StorageStructureArea;
Assert.AreEqual(2, storageStructureArea.Mean.NumberOfDecimalPlaces);
Assert.AreEqual(123.46, storageStructureArea.Mean, storageStructureArea.Mean.GetAccuracy());
Assert.AreEqual(2, storageStructureArea.CoefficientOfVariation.NumberOfDecimalPlaces);
Assert.AreEqual(0.12, storageStructureArea.CoefficientOfVariation, storageStructureArea.CoefficientOfVariation.GetAccuracy());
LogNormalDistribution allowedLevelIncreaseStorage = structure.AllowedLevelIncreaseStorage;
Assert.AreEqual(2, allowedLevelIncreaseStorage.Mean.NumberOfDecimalPlaces);
Assert.AreEqual(234.57, allowedLevelIncreaseStorage.Mean, allowedLevelIncreaseStorage.Mean.GetAccuracy());
Assert.AreEqual(2, allowedLevelIncreaseStorage.StandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.23, allowedLevelIncreaseStorage.StandardDeviation, allowedLevelIncreaseStorage.StandardDeviation.GetAccuracy());
NormalDistribution widthFlowApertures = structure.WidthFlowApertures;
Assert.AreEqual(2, widthFlowApertures.Mean.NumberOfDecimalPlaces);
Assert.AreEqual(456.79, widthFlowApertures.Mean, widthFlowApertures.Mean.GetAccuracy());
Assert.AreEqual(2, widthFlowApertures.StandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.46, widthFlowApertures.StandardDeviation, widthFlowApertures.StandardDeviation.GetAccuracy());
NormalDistribution levelCrestStructureNotClosing = structure.LevelCrestStructureNotClosing;
Assert.AreEqual(2, levelCrestStructureNotClosing.Mean.NumberOfDecimalPlaces);
Assert.AreEqual(567.89, levelCrestStructureNotClosing.Mean, levelCrestStructureNotClosing.Mean.GetAccuracy());
Assert.AreEqual(2, levelCrestStructureNotClosing.StandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.57, levelCrestStructureNotClosing.StandardDeviation, levelCrestStructureNotClosing.StandardDeviation.GetAccuracy());
NormalDistribution insideWaterLevel = structure.InsideWaterLevel;
Assert.AreEqual(2, insideWaterLevel.Mean.NumberOfDecimalPlaces);
Assert.AreEqual(678.90, insideWaterLevel.Mean, insideWaterLevel.Mean.GetAccuracy());
Assert.AreEqual(2, insideWaterLevel.StandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.68, insideWaterLevel.StandardDeviation, insideWaterLevel.StandardDeviation.GetAccuracy());
NormalDistribution thresholdHeightOpenWeir = structure.ThresholdHeightOpenWeir;
Assert.AreEqual(2, thresholdHeightOpenWeir.Mean.NumberOfDecimalPlaces);
Assert.AreEqual(789.01, thresholdHeightOpenWeir.Mean, thresholdHeightOpenWeir.Mean.GetAccuracy());
Assert.AreEqual(2, thresholdHeightOpenWeir.StandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.79, thresholdHeightOpenWeir.StandardDeviation, thresholdHeightOpenWeir.StandardDeviation.GetAccuracy());
LogNormalDistribution areaFlowApertures = structure.AreaFlowApertures;
Assert.AreEqual(2, areaFlowApertures.Mean.NumberOfDecimalPlaces);
Assert.AreEqual(890.12, areaFlowApertures.Mean, areaFlowApertures.Mean.GetAccuracy());
Assert.AreEqual(2, areaFlowApertures.StandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.89, areaFlowApertures.StandardDeviation, areaFlowApertures.StandardDeviation.GetAccuracy());
VariationCoefficientLogNormalDistribution criticalOvertoppingDischarge = structure.CriticalOvertoppingDischarge;
Assert.AreEqual(2, criticalOvertoppingDischarge.Mean.NumberOfDecimalPlaces);
Assert.AreEqual(901.23, criticalOvertoppingDischarge.Mean, criticalOvertoppingDischarge.Mean.GetAccuracy());
Assert.AreEqual(2, criticalOvertoppingDischarge.CoefficientOfVariation.NumberOfDecimalPlaces);
Assert.AreEqual(0.90, criticalOvertoppingDischarge.CoefficientOfVariation, criticalOvertoppingDischarge.CoefficientOfVariation.GetAccuracy());
LogNormalDistribution flowWidthAtBottomProtection = structure.FlowWidthAtBottomProtection;
Assert.AreEqual(2, flowWidthAtBottomProtection.Mean.NumberOfDecimalPlaces);
Assert.AreEqual(111.22, flowWidthAtBottomProtection.Mean, flowWidthAtBottomProtection.Mean.GetAccuracy());
Assert.AreEqual(2, flowWidthAtBottomProtection.StandardDeviation.NumberOfDecimalPlaces);
Assert.AreEqual(0.11, flowWidthAtBottomProtection.StandardDeviation, flowWidthAtBottomProtection.StandardDeviation.GetAccuracy());
Assert.AreEqual(321.987, structure.ProbabilityOpenStructureBeforeFlooding);
Assert.AreEqual(654.321, structure.FailureProbabilityOpenStructure);
Assert.AreEqual(42, structure.IdenticalApertures);
Assert.AreEqual(987.654, structure.FailureProbabilityReparation);
Assert.AreEqual(ClosingStructureInflowModelType.LowSill, structure.InflowModelType);
}
public void UpdateStructuresWithImportedData_SingleChange_UpdatesOnlySingleChange(ClosingStructure readStructure)
{
// Setup
ClosingStructure structure = new TestClosingStructure();
var failureMechanism = new ClosingStructuresFailureMechanism();
StructureCollection <ClosingStructure> targetCollection = failureMechanism.ClosingStructures;
targetCollection.AddRange(new[]
{
structure
}, sourceFilePath);
var strategy = new ClosingStructureUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateStructuresWithImportedData(new[]
{
readStructure
},
sourceFilePath);
// Assert
AssertClosingStructures(readStructure, structure);
CollectionAssert.AreEqual(new IObservable[]
{
targetCollection,
structure
}, affectedObjects);
}
public void Read_ValidEntity_ReturnClosingStructure()
{
// Setup
var entity = new ClosingStructureEntity
{
Name = "A",
Id = "B",
X = 1.1,
Y = 2.2,
StructureNormalOrientation = 3.3,
StorageStructureAreaMean = 4.4,
StorageStructureAreaCoefficientOfVariation = 5.5,
AllowedLevelIncreaseStorageMean = 6.6,
AllowedLevelIncreaseStorageStandardDeviation = 7.7,
WidthFlowAperturesMean = 8.8,
WidthFlowAperturesStandardDeviation = 9.9,
LevelCrestStructureNotClosingMean = 10.10,
LevelCrestStructureNotClosingStandardDeviation = 11.11,
InsideWaterLevelMean = 12.12,
InsideWaterLevelStandardDeviation = 13.13,
ThresholdHeightOpenWeirMean = 14.14,
ThresholdHeightOpenWeirStandardDeviation = 15.15,
AreaFlowAperturesMean = 16.16,
AreaFlowAperturesStandardDeviation = 17.17,
CriticalOvertoppingDischargeMean = 18.18,
CriticalOvertoppingDischargeCoefficientOfVariation = 19.19,
FlowWidthAtBottomProtectionMean = 20.20,
FlowWidthAtBottomProtectionStandardDeviation = 21.21,
ProbabilityOpenStructureBeforeFlooding = 22.22,
FailureProbabilityOpenStructure = 23.23,
IdenticalApertures = 24,
FailureProbabilityReparation = 25.25,
InflowModelType = Convert.ToByte(ClosingStructureInflowModelType.FloodedCulvert)
};
var collector = new ReadConversionCollector();
// Call
ClosingStructure structure = entity.Read(collector);
// Assert
Assert.AreEqual(entity.Name, structure.Name);
Assert.AreEqual(entity.Id, structure.Id);
Assert.AreEqual(entity.X, structure.Location.X);
Assert.AreEqual(entity.Y, structure.Location.Y);
Assert.AreEqual(entity.StructureNormalOrientation, structure.StructureNormalOrientation.Value);
Assert.AreEqual(entity.StorageStructureAreaMean, structure.StorageStructureArea.Mean.Value);
Assert.AreEqual(entity.StorageStructureAreaCoefficientOfVariation, structure.StorageStructureArea.CoefficientOfVariation.Value);
Assert.AreEqual(entity.AllowedLevelIncreaseStorageMean, structure.AllowedLevelIncreaseStorage.Mean.Value);
Assert.AreEqual(entity.AllowedLevelIncreaseStorageStandardDeviation, structure.AllowedLevelIncreaseStorage.StandardDeviation.Value);
Assert.AreEqual(entity.WidthFlowAperturesMean, structure.WidthFlowApertures.Mean.Value);
Assert.AreEqual(entity.WidthFlowAperturesStandardDeviation, structure.WidthFlowApertures.StandardDeviation.Value);
Assert.AreEqual(entity.LevelCrestStructureNotClosingMean, structure.LevelCrestStructureNotClosing.Mean.Value);
Assert.AreEqual(entity.LevelCrestStructureNotClosingStandardDeviation, structure.LevelCrestStructureNotClosing.StandardDeviation.Value);
Assert.AreEqual(entity.InsideWaterLevelMean, structure.InsideWaterLevel.Mean.Value);
Assert.AreEqual(entity.InsideWaterLevelStandardDeviation, structure.InsideWaterLevel.StandardDeviation.Value);
Assert.AreEqual(entity.ThresholdHeightOpenWeirMean, structure.ThresholdHeightOpenWeir.Mean.Value);
Assert.AreEqual(entity.ThresholdHeightOpenWeirStandardDeviation, structure.ThresholdHeightOpenWeir.StandardDeviation.Value);
Assert.AreEqual(entity.AreaFlowAperturesMean, structure.AreaFlowApertures.Mean.Value);
Assert.AreEqual(entity.AreaFlowAperturesStandardDeviation, structure.AreaFlowApertures.StandardDeviation.Value);
Assert.AreEqual(entity.CriticalOvertoppingDischargeMean, structure.CriticalOvertoppingDischarge.Mean.Value);
Assert.AreEqual(entity.CriticalOvertoppingDischargeCoefficientOfVariation, structure.CriticalOvertoppingDischarge.CoefficientOfVariation.Value);
Assert.AreEqual(entity.FlowWidthAtBottomProtectionMean, structure.FlowWidthAtBottomProtection.Mean.Value);
Assert.AreEqual(entity.FlowWidthAtBottomProtectionStandardDeviation, structure.FlowWidthAtBottomProtection.StandardDeviation.Value);
Assert.AreEqual(entity.ProbabilityOpenStructureBeforeFlooding, structure.ProbabilityOpenStructureBeforeFlooding);
Assert.AreEqual(entity.FailureProbabilityOpenStructure, structure.FailureProbabilityOpenStructure);
Assert.AreEqual(entity.IdenticalApertures, structure.IdenticalApertures);
Assert.AreEqual(entity.FailureProbabilityReparation, structure.FailureProbabilityReparation);
Assert.AreEqual((ClosingStructureInflowModelType)entity.InflowModelType, structure.InflowModelType);
Assert.IsTrue(collector.Contains(entity));
}
public void UpdateStructuresWithImportedData_MultipleCalculationWithStructureOneWithRemovedStructure_OnlyUpdatesCalculationWithRemovedStructure()
{
// Setup
const string removedId = "affectedId";
const string unaffectedId = "unaffectedId";
const string unaffectedStructureName = "unaffectedStructure";
var removedStructure = new TestClosingStructure(removedId, "Old name");
var unaffectedStructure = new TestClosingStructure(unaffectedId, unaffectedStructureName);
var affectedCalculation = new TestClosingStructuresCalculationScenario
{
InputParameters =
{
Structure = removedStructure
},
Output = new TestStructuresOutput()
};
var unaffectedCalculation = new TestClosingStructuresCalculationScenario
{
InputParameters =
{
Structure = unaffectedStructure
},
Output = new TestStructuresOutput()
};
var failureMechanism = new ClosingStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
affectedCalculation,
unaffectedCalculation
}
}
};
StructureCollection <ClosingStructure> targetDataCollection = failureMechanism.ClosingStructures;
targetDataCollection.AddRange(new[]
{
removedStructure,
unaffectedStructure
}, sourceFilePath);
var strategy = new ClosingStructureUpdateDataStrategy(failureMechanism);
ClosingStructure readUnaffectedStructure = new TestClosingStructure(unaffectedId, unaffectedStructureName);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateStructuresWithImportedData(new[]
{
readUnaffectedStructure
}, sourceFilePath);
// Assert
Assert.IsFalse(affectedCalculation.HasOutput);
Assert.IsNull(affectedCalculation.InputParameters.Structure);
Assert.IsTrue(unaffectedCalculation.HasOutput);
ClosingStructure inputParametersUnaffectedStructure = unaffectedCalculation.InputParameters.Structure;
Assert.AreSame(unaffectedStructure, inputParametersUnaffectedStructure);
AssertClosingStructures(readUnaffectedStructure, inputParametersUnaffectedStructure);
CollectionAssert.AreEquivalent(new IObservable[]
{
affectedCalculation,
affectedCalculation.InputParameters,
targetDataCollection
}, affectedObjects);
}
public void Read_NullValues_ReturnClosingStructureWithNaN()
{
// Setup
var entity = new ClosingStructureEntity
{
Name = "A",
Id = "B",
X = null,
Y = null,
StructureNormalOrientation = null,
StorageStructureAreaMean = null,
StorageStructureAreaCoefficientOfVariation = null,
AllowedLevelIncreaseStorageMean = null,
AllowedLevelIncreaseStorageStandardDeviation = null,
WidthFlowAperturesMean = null,
WidthFlowAperturesStandardDeviation = null,
LevelCrestStructureNotClosingMean = null,
LevelCrestStructureNotClosingStandardDeviation = null,
InsideWaterLevelMean = null,
InsideWaterLevelStandardDeviation = null,
ThresholdHeightOpenWeirMean = null,
ThresholdHeightOpenWeirStandardDeviation = null,
AreaFlowAperturesMean = null,
AreaFlowAperturesStandardDeviation = null,
CriticalOvertoppingDischargeMean = null,
CriticalOvertoppingDischargeCoefficientOfVariation = null,
FlowWidthAtBottomProtectionMean = null,
FlowWidthAtBottomProtectionStandardDeviation = null,
ProbabilityOpenStructureBeforeFlooding = null,
FailureProbabilityOpenStructure = null
};
var collector = new ReadConversionCollector();
// Call
ClosingStructure structure = entity.Read(collector);
// Assert
Assert.IsNaN(structure.Location.X);
Assert.IsNaN(structure.Location.Y);
Assert.IsNaN(structure.StructureNormalOrientation);
Assert.IsNaN(structure.StorageStructureArea.Mean);
Assert.IsNaN(structure.StorageStructureArea.CoefficientOfVariation);
Assert.IsNaN(structure.AllowedLevelIncreaseStorage.Mean);
Assert.IsNaN(structure.AllowedLevelIncreaseStorage.StandardDeviation);
Assert.IsNaN(structure.WidthFlowApertures.Mean);
Assert.IsNaN(structure.WidthFlowApertures.StandardDeviation);
Assert.IsNaN(structure.LevelCrestStructureNotClosing.Mean);
Assert.IsNaN(structure.LevelCrestStructureNotClosing.StandardDeviation);
Assert.IsNaN(structure.InsideWaterLevel.Mean);
Assert.IsNaN(structure.InsideWaterLevel.StandardDeviation);
Assert.IsNaN(structure.ThresholdHeightOpenWeir.Mean);
Assert.IsNaN(structure.ThresholdHeightOpenWeir.StandardDeviation);
Assert.IsNaN(structure.AreaFlowApertures.Mean);
Assert.IsNaN(structure.AreaFlowApertures.StandardDeviation);
Assert.IsNaN(structure.CriticalOvertoppingDischarge.Mean);
Assert.IsNaN(structure.CriticalOvertoppingDischarge.CoefficientOfVariation);
Assert.IsNaN(structure.FlowWidthAtBottomProtection.Mean);
Assert.IsNaN(structure.FlowWidthAtBottomProtection.StandardDeviation);
Assert.IsNaN(structure.ProbabilityOpenStructureBeforeFlooding);
Assert.IsNaN(structure.FailureProbabilityOpenStructure);
Assert.IsNaN(structure.FailureProbabilityReparation);
}
