/// <summary>
/// Sets the failure probability structure with erosion.
/// </summary>
/// <param name="readCalculation">The calculation read from the imported file.</param>
/// <param name="calculation">The calculation to configure.</param>
/// <returns><c>false</c> when the orientation is invalid or when there is a failure probability
/// structure with erosion but no structure defined, <c>true</c> otherwise.</returns>
private bool TrySetFailureProbabilityStructureWithErosion(StructuresCalculationConfiguration readCalculation,
StructuresCalculation <ClosingStructuresInput> calculation)
{
if (readCalculation.FailureProbabilityStructureWithErosion.HasValue)
{
double failureProbability = readCalculation.FailureProbabilityStructureWithErosion.Value;
try
{
calculation.InputParameters.FailureProbabilityStructureWithErosion = (RoundedDouble)failureProbability;
}
catch (ArgumentOutOfRangeException e)
{
Log.LogOutOfRangeException(
string.Format(
RiskeerCommonIOResources.TryReadParameter_Value_0_ParameterName_1_is_invalid,
failureProbability,
RiskeerCommonIOResources.CalculationConfigurationImporter_FailureProbabilityStructureWithErosion_DisplayName),
calculation.Name,
e);
return(false);
}
}
return(true);
}
/// <summary>
/// Creates a new instance of <see cref="ClosingStructuresInputContext"/>.
/// </summary>
/// <param name="wrappedData">The calculation input wrapped by the context object.</param>
/// <param name="calculation">The closing structures calculation containing the <see cref="ClosingStructuresInput"/>.</param>
/// <param name="failureMechanism">The failure mechanism which the context belongs to.</param>
/// <param name="assessmentSection">The assessment section which the context belongs to.</param>
/// <exception cref="ArgumentNullException">Thrown when any input argument is <c>null</c>.</exception>
public ClosingStructuresInputContext(ClosingStructuresInput wrappedData,
StructuresCalculation <ClosingStructuresInput> calculation,
ClosingStructuresFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(wrappedData, calculation, failureMechanism, assessmentSection)
{
}
public void SetShouldIllustrationPointsBeCalculated_ValueChanged_UpdateDataAndNotifyObservers()
{
// Setup
var random = new Random(21);
bool newBoolean = random.NextBoolean();
var observer = mockRepository.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
var handler = mockRepository.Stub <IObservablePropertyChangeHandler>();
mockRepository.ReplayAll();
var calculation = new StructuresCalculation <HeightStructuresInput>();
var failureMechanism = new HeightStructuresFailureMechanism();
var inputContext = new HeightStructuresInputContext(calculation.InputParameters,
calculation,
failureMechanism,
assessmentSection);
inputContext.Attach(observer);
var properties = new HeightStructuresInputContextProperties(inputContext, handler);
// Call
properties.ShouldIllustrationPointsBeCalculated = newBoolean;
// Assert
Assert.AreEqual(newBoolean, calculation.InputParameters.ShouldIllustrationPointsBeCalculated);
mockRepository.VerifyAll();
}
public void GetAvailableStructures_SetInputContextInstanceWithStructures_ReturnStructures()
{
// Setup
var handler = mockRepository.Stub <IObservablePropertyChangeHandler>();
mockRepository.ReplayAll();
var failureMechanism = new HeightStructuresFailureMechanism();
failureMechanism.HeightStructures.AddRange(new[]
{
new TestHeightStructure()
}, "some folder");
var calculation = new StructuresCalculation <HeightStructuresInput>();
var inputContext = new HeightStructuresInputContext(calculation.InputParameters,
calculation,
failureMechanism,
assessmentSection);
var properties = new HeightStructuresInputContextProperties(inputContext, handler);
// Call
IEnumerable <HeightStructure> availableStructures = properties.GetAvailableStructures();
// Assert
Assert.AreSame(failureMechanism.HeightStructures, availableStructures);
mockRepository.VerifyAll();
}
public void CreateCalculationActivitiesForFailureMechanism_WithValidCalculations_ReturnsStabilityPointStructuresCalculationActivitiesWithParametersSet()
{
// Setup
var failureMechanism = new StabilityPointStructuresFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
mocks,
validFilePath);
mocks.ReplayAll();
StructuresCalculation <StabilityPointStructuresInput> calculation1 = CreateValidCalculation();
StructuresCalculation <StabilityPointStructuresInput> calculation2 = CreateValidCalculation();
failureMechanism.CalculationsGroup.Children.AddRange(new[]
{
calculation1,
calculation2
});
// Call
IEnumerable <CalculatableActivity> activities = StabilityPointStructuresCalculationActivityFactory.CreateCalculationActivities(
failureMechanism, assessmentSection);
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(StabilityPointStructuresCalculationActivity));
Assert.AreEqual(2, activities.Count());
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertStabilityPointStructuresCalculationActivity(activities.First(), calculation1, hydraulicBoundaryDatabase);
AssertStabilityPointStructuresCalculationActivity(activities.ElementAt(1), calculation2, hydraulicBoundaryDatabase);
mocks.VerifyAll();
}
public void Constructor_WithOrWithoutStructure_CorrectReadOnlyForStructureDependentProperties(bool hasStructure)
{
// Setup
var handler = mockRepository.Stub <IObservablePropertyChangeHandler>();
mockRepository.ReplayAll();
var failureMechanism = new HeightStructuresFailureMechanism();
var calculation = new StructuresCalculation <HeightStructuresInput>();
var inputContext = new HeightStructuresInputContext(calculation.InputParameters,
calculation,
failureMechanism,
assessmentSection);
if (hasStructure)
{
calculation.InputParameters.Structure = new TestHeightStructure();
}
// Call
var properties = new HeightStructuresInputContextProperties(inputContext, handler);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
bool expectedReadOnly = !hasStructure;
PropertyDescriptor failureProbabilityStructureWithErosionProperty = dynamicProperties[failureProbabilityStructureWithErosionPropertyIndex];
Assert.AreEqual(expectedReadOnly, failureProbabilityStructureWithErosionProperty.IsReadOnly);
DistributionPropertiesTestHelper.AssertPropertiesAreReadOnly(properties.LevelCrestStructure, expectedReadOnly, expectedReadOnly);
mockRepository.VerifyAll();
}
/// <summary>
/// Creates a new instance of <see cref="HeightStructuresInputContext"/>.
/// </summary>
/// <param name="wrappedData">The calculation input wrapped by the context object.</param>
/// <param name="calculation">The height structures calculation containing the <see cref="HeightStructuresInput"/>.</param>
/// <param name="failureMechanism">The failure mechanism which the context belongs to.</param>
/// <param name="assessmentSection">The assessment section which the context belongs to.</param>
/// <exception cref="ArgumentNullException">Thrown when any input argument is <c>null</c>.</exception>
public HeightStructuresInputContext(HeightStructuresInput wrappedData,
StructuresCalculation <HeightStructuresInput> calculation,
HeightStructuresFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(wrappedData, calculation, failureMechanism, assessmentSection)
{
}
/// <summary>
/// Creates a new instance of <see cref="StabilityPointStructuresInputContext"/>.
/// </summary>
/// <param name="input">The <see cref="StabilityPointStructuresInput"/> instance wrapped by this context object.</param>
/// <param name="calculation">The calculation item which the <paramref name="input"/> belongs to.</param>
/// <param name="failureMechanism">The failure mechanism which the context belongs to.</param>
/// <param name="assessmentSection">The assessment section which the context belongs to.</param>
/// <exception cref="ArgumentNullException">Thrown when any input argument is <c>null</c>.</exception>
public StabilityPointStructuresInputContext(StabilityPointStructuresInput input,
StructuresCalculation <StabilityPointStructuresInput> calculation,
StabilityPointStructuresFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(input, calculation, failureMechanism, assessmentSection)
{
}
public void SelectedHydraulicBoundaryLocation_InputNoLocation_ReturnsNull()
{
// Setup
mockRepository.ReplayAll();
var calculation = new StructuresCalculation <SimpleStructureInput>();
var inputContext = new SimpleInputContext(calculation.InputParameters,
calculation,
failureMechanism,
assessmentSection);
var properties = new SimpleStructuresInputProperties(
inputContext,
new StructuresInputBaseProperties <TestStructure, SimpleStructureInput, StructuresCalculation <SimpleStructureInput>, IFailureMechanism> .ConstructionProperties(),
handler);
SelectableHydraulicBoundaryLocation selectedHydraulicBoundaryLocation = null;
// Call
TestDelegate call = () => selectedHydraulicBoundaryLocation = properties.SelectedHydraulicBoundaryLocation;
// Assert
Assert.DoesNotThrow(call);
Assert.IsNull(selectedHydraulicBoundaryLocation);
mockRepository.VerifyAll();
}
/// <summary>
/// Sets the structure normal orientation.
/// </summary>
/// <param name="readCalculation">The calculation read from the imported file.</param>
/// <param name="calculation">The calculation to configure.</param>
/// <returns><c>false</c> when the structure normal orientation is invalid or when there
/// is a structure normal orientation but no structure defined, <c>true</c> otherwise.</returns>
private bool TrySetStructureNormalOrientation(StructuresCalculationConfiguration readCalculation,
StructuresCalculation <StabilityPointStructuresInput> calculation)
{
if (readCalculation.StructureNormalOrientation.HasValue)
{
if (calculation.InputParameters.Structure == null)
{
Log.LogCalculationConversionError(string.Format(RiskeerCommonIOResources.CalculationConfigurationImporter_TryParameter_No_Structure_to_assign_Parameter_0_,
RiskeerCommonIOResources.CalculationConfigurationImporter_Orientation_DisplayName),
calculation.Name);
return(false);
}
double orientation = readCalculation.StructureNormalOrientation.Value;
try
{
calculation.InputParameters.StructureNormalOrientation = (RoundedDouble)orientation;
}
catch (ArgumentOutOfRangeException e)
{
Log.LogOutOfRangeException(string.Format(RiskeerCommonIOResources.TryReadParameter_Value_0_ParameterName_1_is_invalid,
orientation,
RiskeerCommonIOResources.CalculationConfigurationImporter_Orientation_DisplayName),
calculation.Name,
e);
return(false);
}
}
return(true);
}
public void Constructor_ValidInputParameters_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculation = new StructuresCalculation <HeightStructuresInput>();
var failureMechanism = new HeightStructuresFailureMechanism();
// Call
var context = new HeightStructuresInputContext(calculation.InputParameters,
calculation,
failureMechanism,
assessmentSection);
// Assert
Assert.IsInstanceOf <InputContextBase <HeightStructuresInput, StructuresCalculation <HeightStructuresInput>, HeightStructuresFailureMechanism> >(context);
Assert.AreSame(calculation.InputParameters, context.WrappedData);
Assert.AreSame(calculation, context.Calculation);
Assert.AreSame(failureMechanism, context.FailureMechanism);
Assert.AreSame(assessmentSection, context.AssessmentSection);
mocks.VerifyAll();
}
public void Assign_SpecificInvalid_ReturnsFalse()
{
// Setup
const string calculationName = "name";
var mocks = new MockRepository();
var configuration = mocks.Stub <StructuresCalculationConfiguration>(calculationName);
mocks.ReplayAll();
var calculation = new StructuresCalculation <SimpleStructuresInput>();
var assigner = new SimpleStructuresCalculationStochastAssigner(
configuration,
calculation)
{
SpecificIsValid = false
};
// Call
bool valid = assigner.Assign();
// Assert
Assert.IsFalse(valid);
mocks.VerifyAll();
}
public void Run_CalculationInvalidInput_LogValidationStartAndEndWithError()
{
// Setup
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike)
{
HydraulicBoundaryDatabase =
{
FilePath = Path.Combine(testDataPath, "notexisting.sqlite")
}
};
var failureMechanism = new HeightStructuresFailureMechanism();
var calculation = new StructuresCalculation <HeightStructuresInput>();
CalculatableActivity activity = HeightStructuresCalculationActivityFactory.CreateCalculationActivity(calculation,
failureMechanism,
assessmentSection);
// Call
Action call = () => activity.Run();
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(4, msgs.Length);
Assert.AreEqual($"Uitvoeren van berekening '{calculation.Name}' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
StringAssert.StartsWith("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt. " +
"Fout bij het lezen van bestand", msgs[2]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[3]);
});
Assert.AreEqual(ActivityState.Failed, activity.State);
}
public void Assign_SpreadDefinedForBaseStochast_LogsErrorAndReturnsFalse(Action <StructuresCalculationConfiguration> modify, string stochastName)
{
// Setup
const string calculationName = "name";
var mocks = new MockRepository();
var configuration = mocks.Stub <StructuresCalculationConfiguration>(calculationName);
mocks.ReplayAll();
var calculation = new StructuresCalculation <SimpleStructuresInput>();
modify(configuration);
var assigner = new SimpleStructuresCalculationStochastAssigner(
configuration,
calculation);
// Call
var valid = true;
Action validate = () => valid = assigner.Assign();
// Assert
string expectedMessage = $"Er kan geen spreiding voor stochast '{stochastName}' opgegeven worden. Berekening '{calculationName}' is overgeslagen.";
TestHelper.AssertLogMessageWithLevelIsGenerated(validate, Tuple.Create(expectedMessage, LogLevelConstant.Error));
Assert.IsFalse(valid);
mocks.VerifyAll();
}
/// <summary>
/// Sets the probability collision secondary structure.
/// </summary>
/// <param name="readCalculation">The calculation read from the imported file.</param>
/// <param name="calculation">The calculation to configure.</param>
/// <returns><c>false</c> when the probability collision secondary structure is invalid or
/// when there is a probability collision secondary structure but no structure defined,
/// <c>true</c> otherwise.</returns>
private bool TrySetProbabilityCollisionSecondaryStructure(StabilityPointStructuresCalculationConfiguration readCalculation,
StructuresCalculation <StabilityPointStructuresInput> calculation)
{
if (readCalculation.ProbabilityCollisionSecondaryStructure.HasValue)
{
if (calculation.InputParameters.Structure == null)
{
Log.LogCalculationConversionError(string.Format(RiskeerCommonIOResources.CalculationConfigurationImporter_TryParameter_No_Structure_to_assign_Parameter_0_,
Resources.CalculationConfigurationImporter_ProbabilityCollisionSecondaryStructure_DisplayName),
calculation.Name);
return(false);
}
double failureProbability = readCalculation.ProbabilityCollisionSecondaryStructure.Value;
try
{
calculation.InputParameters.ProbabilityCollisionSecondaryStructure = (RoundedDouble)failureProbability;
}
catch (ArgumentOutOfRangeException e)
{
Log.LogOutOfRangeException(string.Format(
RiskeerCommonIOResources.TryReadParameter_Value_0_ParameterName_1_is_invalid,
failureProbability,
Resources.CalculationConfigurationImporter_ProbabilityCollisionSecondaryStructure_DisplayName),
calculation.Name,
e);
return(false);
}
}
return(true);
}
private void SetPropertyAndVerifyNotificationsAndOutput(Action <SimpleStructuresInputProperties> setProperty)
{
// Setup
var observable = mockRepository.StrictMock <IObservable>();
observable.Expect(o => o.NotifyObservers());
mockRepository.ReplayAll();
var calculation = new StructuresCalculation <SimpleStructureInput>();
SimpleStructureInput input = calculation.InputParameters;
input.ForeshoreProfile = new TestForeshoreProfile();
input.Structure = new TestStructure();
var customHandler = new SetPropertyValueAfterConfirmationParameterTester(new[]
{
observable
});
var inputContext = new SimpleInputContext(input,
calculation,
failureMechanism,
assessmentSection);
var properties = new SimpleStructuresInputProperties(inputContext, GetRandomConstructionProperties(), customHandler);
// Call
setProperty(properties);
// Assert
mockRepository.VerifyAll();
}
public SimpleInputContext(SimpleStructureInput wrappedData,
StructuresCalculation <SimpleStructureInput> calculation,
IFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(wrappedData, calculation, failureMechanism, assessmentSection)
{
}
private static bool CalculationHasStructureAndHydraulicBoundaryLocation <TStructuresInput, TStructure>(
StructuresCalculation <TStructuresInput> calculation)
where TStructuresInput : StructuresInputBase <TStructure>, new()
where TStructure : StructureBase
{
return(calculation.InputParameters.Structure != null &&
calculation.InputParameters.HydraulicBoundaryLocation != null);
}
/// <summary>
/// Sets the volumic weight water.
/// </summary>
/// <param name="readCalculation">The calculation read from the imported file.</param>
/// <param name="calculation">The calculation to configure.</param>
private void SetVolumicWeightWater(StabilityPointStructuresCalculationConfiguration readCalculation,
StructuresCalculation <StabilityPointStructuresInput> calculation)
{
if (readCalculation.VolumicWeightWater.HasValue)
{
calculation.InputParameters.VolumicWeightWater = (RoundedDouble)readCalculation.VolumicWeightWater.Value;
}
}
/// <summary>
/// Sets the factor storm duration.
/// </summary>
/// <param name="readCalculation">The calculation read from the imported file.</param>
/// <param name="calculation">The calculation to configure.</param>
private void SetFactorStormDurationOpenStructure(ClosingStructuresCalculationConfiguration readCalculation,
StructuresCalculation <ClosingStructuresInput> calculation)
{
if (readCalculation.FactorStormDurationOpenStructure.HasValue)
{
calculation.InputParameters.FactorStormDurationOpenStructure = (RoundedDouble)readCalculation.FactorStormDurationOpenStructure.Value;
}
}
private static void SetShouldIllustrationPointsBeCalculated(HeightStructuresCalculationConfiguration calculationConfiguration,
StructuresCalculation <HeightStructuresInput> calculation)
{
if (calculationConfiguration.ShouldIllustrationPointsBeCalculated.HasValue)
{
calculation.InputParameters.ShouldIllustrationPointsBeCalculated = calculationConfiguration.ShouldIllustrationPointsBeCalculated.Value;
}
}
public void SetStochasts_WithAllStochastsSet_SetExpectedValuesOnInput()
{
// Setup
var configuration = new HeightStructuresCalculationConfiguration("name")
{
StructureId = "some structure",
LevelCrestStructure = new StochastConfiguration
{
Mean = 1.1,
StandardDeviation = 1.5
},
AllowedLevelIncreaseStorage = new StochastConfiguration
{
Mean = 2.1,
StandardDeviation = 2.5
},
FlowWidthAtBottomProtection = new StochastConfiguration
{
Mean = 3.1,
StandardDeviation = 3.5
},
WidthFlowApertures = new StochastConfiguration
{
Mean = 4.1,
StandardDeviation = 4.5
},
ModelFactorSuperCriticalFlow = new StochastConfiguration
{
Mean = 5.1
},
CriticalOvertoppingDischarge = new StochastConfiguration
{
Mean = 6.1,
VariationCoefficient = 0.6
},
StorageStructureArea = new StochastConfiguration
{
Mean = 7.1,
VariationCoefficient = 0.7
},
StormDuration = new StochastConfiguration
{
Mean = 8.1
}
};
var calculation = new StructuresCalculation <HeightStructuresInput>();
var assigner = new HeightStructuresCalculationStochastAssigner(
configuration,
calculation);
// Call
bool valid = assigner.Assign();
// Assert
Assert.IsTrue(valid);
}
private bool TrySetStochasts(StabilityPointStructuresCalculationConfiguration readCalculation,
StructuresCalculation <StabilityPointStructuresInput> calculation)
{
var assigner = new StabilityPointStructuresCalculationStochastAssigner(
readCalculation,
calculation);
return(assigner.Assign());
}
private bool TrySetStochasts(HeightStructuresCalculationConfiguration readCalculation,
StructuresCalculation <HeightStructuresInput> calculation)
{
var assigner = new HeightStructuresCalculationStochastAssigner(
readCalculation,
calculation);
return(assigner.Assign());
}
/// <summary>
/// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
/// are clones.
/// </summary>
/// <typeparam name="TInput">The type of structures input.</typeparam>
/// <typeparam name="TStructure">The type of the structure contained by the structures input.</typeparam>
/// <param name="original">The original object.</param>
/// <param name="clone">The cloned object.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="original"/> and
/// <paramref name="clone"/> are not clones.</exception>
public static void AreClones <TInput, TStructure>(StructuresCalculation <TInput> original, StructuresCalculation <TInput> clone)
where TInput : StructuresInputBase <TStructure>, new()
where TStructure : StructureBase, new()
{
Assert.AreEqual(original.Name, clone.Name);
CoreCloneAssert.AreObjectClones(original.Comments, clone.Comments, AreClones);
CoreCloneAssert.AreObjectClones(original.InputParameters, clone.InputParameters, AreClones);
CoreCloneAssert.AreObjectClones(original.Output, clone.Output, AreClones);
}
private bool TrySetForeshoreProfile(string foreshoreProfileId, StructuresCalculation <HeightStructuresInput> calculation)
{
if (TryReadForeshoreProfile(foreshoreProfileId, calculation.Name, availableForeshoreProfiles, out ForeshoreProfile foreshoreProfile))
{
calculation.InputParameters.ForeshoreProfile = foreshoreProfile;
return(true);
}
return(false);
}
private bool TrySetStructure(string structureId, StructuresCalculation <HeightStructuresInput> calculation)
{
if (TryReadStructure(structureId, calculation.Name, availableStructures, out HeightStructure structure))
{
calculation.InputParameters.Structure = structure;
return(true);
}
return(false);
}
private bool TrySetHydraulicBoundaryLocation(string locationName, StructuresCalculation <HeightStructuresInput> calculation)
{
if (TryReadHydraulicBoundaryLocation(locationName, calculation.Name, availableHydraulicBoundaryLocations, out HydraulicBoundaryLocation location))
{
calculation.InputParameters.HydraulicBoundaryLocation = location;
return(true);
}
return(false);
}
private static void SetStabilityPointStructuresOutputEntity(StructuresCalculation <StabilityPointStructuresInput> calculation,
StabilityPointStructuresCalculationEntity entity)
{
if (calculation.HasOutput)
{
entity.StabilityPointStructuresOutputEntities.Add(calculation
.Output
.Create <StabilityPointStructuresOutputEntity>());
}
}
private static MapCalculationData CreateMapCalculationData <TStructuresInput, TStructure>(
StructuresCalculation <TStructuresInput> calculation)
where TStructuresInput : StructuresInputBase <TStructure>, new()
where TStructure : StructureBase
{
return(new MapCalculationData(
calculation.Name,
calculation.InputParameters.Structure.Location,
calculation.InputParameters.HydraulicBoundaryLocation));
}
