private static void SetPropertyToInvalidValueAndVerifyException(
Action <PipingCalculationRow> setProperty,
IPipingCalculationScenario <PipingInput> calculation,
string expectedMessage)
{
// Setup
var mocks = new MockRepository();
var observable = mocks.StrictMock <IObservable>();
mocks.ReplayAll();
var handler = new SetPropertyValueAfterConfirmationParameterTester(
new[]
{
observable
});
var row = new PipingCalculationRow(calculation, string.Empty, handler);
// Call
void Call() => setProperty(row);
// Assert
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(Call, expectedMessage);
Assert.IsTrue(handler.Called);
mocks.VerifyAll();
}
/// <summary>
/// Assigns the stochastic soil model.
/// </summary>
/// <param name="calculationConfiguration">The calculation read from the imported file.</param>
/// <param name="pipingCalculation">The calculation to configure.</param>
/// <returns><c>false</c> when
/// <list type="bullet">
/// <item>the <paramref name="calculationConfiguration"/> has a <see cref="PipingStochasticSoilModel"/> set
/// which is not available in the failure mechanism.</item>
/// <item>The <see cref="PipingStochasticSoilModel"/> does not intersect with the <see cref="PipingSurfaceLine"/>
/// when this is set.</item>
/// </list>
/// <c>true</c> otherwise.</returns>
private bool TrySetStochasticSoilModel(PipingCalculationConfiguration calculationConfiguration,
IPipingCalculationScenario <PipingInput> pipingCalculation)
{
if (calculationConfiguration.StochasticSoilModelName != null)
{
PipingStochasticSoilModel soilModel = failureMechanism.StochasticSoilModels
.FirstOrDefault(ssm => ssm.Name == calculationConfiguration.StochasticSoilModelName);
if (soilModel == null)
{
Log.LogCalculationConversionError(string.Format(
Resources.PipingCalculationConfigurationImporter_ReadStochasticSoilModel_Stochastische_soil_model_0_does_not_exist,
calculationConfiguration.StochasticSoilModelName),
pipingCalculation.Name);
return(false);
}
if (pipingCalculation.InputParameters.SurfaceLine != null &&
!soilModel.IntersectsWithSurfaceLineGeometry(pipingCalculation.InputParameters.SurfaceLine))
{
Log.LogCalculationConversionError(string.Format(
Resources.PipingCalculationConfigurationImporter_ReadStochasticSoilModel_Stochastische_soil_model_0_does_not_intersect_with_surfaceLine_1,
calculationConfiguration.StochasticSoilModelName,
calculationConfiguration.SurfaceLineName),
pipingCalculation.Name);
return(false);
}
pipingCalculation.InputParameters.StochasticSoilModel = soilModel;
}
return(true);
}
private static void SetPropertyAndVerifyNotificationsAndOutputForCalculation(
Action <PipingCalculationRow> setProperty,
IPipingCalculationScenario <PipingInput> calculation)
{
// Setup
var mocks = new MockRepository();
var observable = mocks.StrictMock <IObservable>();
observable.Expect(o => o.NotifyObservers());
mocks.ReplayAll();
var handler = new SetPropertyValueAfterConfirmationParameterTester(
new[]
{
observable
});
var row = new PipingCalculationRow(calculation, string.Empty, handler);
// Call
setProperty(row);
// Assert
Assert.IsTrue(handler.Called);
mocks.VerifyAll();
}
public void CreateCalculationFeatures_GivenCalculations_ReturnsCalculationFeaturesCollection()
{
// Setup
IPipingCalculationScenario <PipingInput> calculationA =
PipingCalculationScenarioTestFactory.CreateCalculationWithValidInput(
new HydraulicBoundaryLocation(1, string.Empty, 5.0, 4.0));
IPipingCalculationScenario <PipingInput> calculationB =
PipingCalculationScenarioTestFactory.CreateCalculationWithValidInput(
new HydraulicBoundaryLocation(1, string.Empty, 2.2, 3.8));
calculationA.InputParameters.SurfaceLine.ReferenceLineIntersectionWorldPoint = new Point2D(1.0, 3.0);
calculationB.InputParameters.SurfaceLine.ReferenceLineIntersectionWorldPoint = new Point2D(1.0, 4.0);
// Call
IEnumerable <MapFeature> features = PipingMapDataFeaturesFactory.CreateCalculationFeatures(new[]
{
calculationA,
calculationB
});
// Assert
Assert.AreEqual(2, features.Count());
Assert.AreEqual(1, features.ElementAt(0).MapGeometries.Count());
Assert.AreEqual(1, features.ElementAt(1).MapGeometries.Count());
AssertEqualPointCollections(new[]
{
new Point2D(1.0, 3.0),
new Point2D(5.0, 4.0)
}, features.ElementAt(0).MapGeometries.ElementAt(0));
AssertEqualPointCollections(new[]
{
new Point2D(1.0, 4.0),
new Point2D(2.2, 3.8)
}, features.ElementAt(1).MapGeometries.ElementAt(0));
}
/// <summary>
/// Assigns the hydraulic boundary location.
/// </summary>
/// <param name="pipingCalculation">The calculation to configure.</param>
/// <param name="location">The <see cref="HydraulicBoundaryLocation"/> to assign.</param>
private static void SetLocation(IPipingCalculationScenario <PipingInput> pipingCalculation, HydraulicBoundaryLocation location)
{
if (location != null)
{
pipingCalculation.InputParameters.HydraulicBoundaryLocation = location;
}
}
/// <summary>
/// Assigns the stochastic soil profile.
/// </summary>
/// <param name="calculationConfiguration">The calculation read from the imported file.</param>
/// <param name="pipingCalculation">The calculation to configure.</param>
/// <returns><c>false</c> when the <paramref name="calculationConfiguration"/> has:
/// <list type="bullet">
/// <item>a <see cref="PipingStochasticSoilProfile"/> set but no <see cref="PipingStochasticSoilModel"/> is specified;</item>
/// <item>a <see cref="PipingStochasticSoilProfile"/> set which is not available in the <see cref="PipingStochasticSoilModel"/>.</item>
/// </list>
/// <c>true</c> otherwise.</returns>
private bool TrySetStochasticSoilProfile(PipingCalculationConfiguration calculationConfiguration,
IPipingCalculationScenario <PipingInput> pipingCalculation)
{
if (calculationConfiguration.StochasticSoilProfileName != null)
{
if (pipingCalculation.InputParameters.StochasticSoilModel == null)
{
Log.LogCalculationConversionError(string.Format(
Resources.PipingCalculationConfigurationImporter_ReadStochasticSoilProfile_No_soil_model_provided_for_soil_profile_with_name_0,
calculationConfiguration.StochasticSoilProfileName),
pipingCalculation.Name);
return(false);
}
PipingStochasticSoilProfile soilProfile = pipingCalculation.InputParameters
.StochasticSoilModel
.StochasticSoilProfiles
.FirstOrDefault(ssp => ssp.SoilProfile.Name == calculationConfiguration.StochasticSoilProfileName);
if (soilProfile == null)
{
Log.LogCalculationConversionError(string.Format(
Resources.PipingCalculationConfigurationImporter_ReadStochasticSoilProfile_Stochastic_soil_profile_0_does_not_exist_within_soil_model_1,
calculationConfiguration.StochasticSoilProfileName,
calculationConfiguration.StochasticSoilModelName),
pipingCalculation.Name);
return(false);
}
pipingCalculation.InputParameters.StochasticSoilProfile = soilProfile;
}
return(true);
}
/// <summary>
/// Creates a new instance of <see cref="PipingCalculationRow"/>.
/// </summary>
/// <param name="calculationScenario">The <see cref="IPipingCalculationScenario{TPipingInput}"/> this row contains.</param>
/// <param name="calculationType">The description of the type of calculation scenario that is presented in the row.</param>
/// <param name="handler">The handler responsible for handling effects of a property change.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationScenario"/> or
/// <paramref name="handler"/> is <c>null</c>.</exception>
internal PipingCalculationRow(IPipingCalculationScenario <PipingInput> calculationScenario,
string calculationType,
IObservablePropertyChangeHandler handler)
: base(calculationScenario, handler)
{
CalculationType = calculationType;
}
private static void AssertCalculationScenario(IPipingCalculationScenario <PipingInput> calculationScenario,
PipingStochasticSoilProfile stochasticSoilProfile, PipingSurfaceLine surfaceLine)
{
PipingInput input = calculationScenario.InputParameters;
Assert.AreSame(stochasticSoilProfile, input.StochasticSoilProfile);
Assert.AreSame(surfaceLine, input.SurfaceLine);
Assert.AreEqual((RoundedDouble)stochasticSoilProfile.Probability, calculationScenario.Contribution);
}
public void ExitPointL_OnValidChange_NotifyObserverAndCalculationPropertyChanged()
{
// Setup
IPipingCalculationScenario <PipingInput> calculation =
PipingCalculationScenarioTestFactory.CreateCalculationWithValidInput(new TestHydraulicBoundaryLocation());
var exitPointL = (RoundedDouble)0.3;
// Call & Assert
SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.ExitPointL = exitPointL, calculation);
}
private bool TrySetGenericData(PipingCalculationConfiguration readCalculation,
IPipingCalculationScenario <PipingInput> pipingCalculation)
{
return(TrySetSurfaceLine(readCalculation, pipingCalculation) &&
TrySetEntryExitPoint(readCalculation, pipingCalculation) &&
TrySetStochasticSoilModel(readCalculation, pipingCalculation) &&
TrySetStochasticSoilProfile(readCalculation, pipingCalculation) &&
TrySetStochasts(readCalculation, pipingCalculation) &&
TrySetScenarioParameters(readCalculation.Scenario, pipingCalculation));
}
private bool TrySetPhreaticLevelExit(PipingCalculationConfiguration calculationConfiguration,
IPipingCalculationScenario <PipingInput> pipingCalculation)
{
return(ConfigurationImportHelper.TrySetStandardDeviationStochast(
PipingCalculationConfigurationSchemaIdentifiers.PhreaticLevelExitStochastName,
pipingCalculation.Name,
pipingCalculation.InputParameters,
calculationConfiguration.PhreaticLevelExit,
i => i.PhreaticLevelExit,
(i, s) => i.PhreaticLevelExit = s,
Log));
}
public void ExitPointL_NotOnSurfaceLine_ThrowsArgumentOutOfRangeExceptionAndDoesNotNotifyObservers()
{
// Setup
IPipingCalculationScenario <PipingInput> calculation =
PipingCalculationScenarioTestFactory.CreateCalculationWithValidInput(new TestHydraulicBoundaryLocation());
var exitPointL = (RoundedDouble)3.0;
// Call & Assert
const string expectedMessage = "Het gespecificeerde punt moet op het profiel liggen (bereik [0,0, 1,0]).";
SetPropertyToInvalidValueAndVerifyException(row => row.ExitPointL = exitPointL, calculation,
expectedMessage);
}
public void ExitPointL_ExitPointNotBeyondEntryPoint_ThrowsArgumentOutOfRangeExceptionDoesNotNotifyObservers(double newValue)
{
// Setup
IPipingCalculationScenario <PipingInput> calculation =
PipingCalculationScenarioTestFactory.CreateCalculationWithValidInput(new TestHydraulicBoundaryLocation());
var exitPointL = (RoundedDouble)newValue;
// Call & Assert
const string expectedMessage = "Het uittredepunt moet landwaarts van het intredepunt liggen.";
SetPropertyToInvalidValueAndVerifyException(row => row.ExitPointL = exitPointL, calculation,
expectedMessage);
}
private static void AssertPropertyChangeWithOrWithoutCalculationOutput(
Action <PipingCalculationRow> setProperty,
Action <IPipingCalculationScenario <PipingInput> > assertions,
bool hasOutput,
bool expectUpdates)
{
// Setup
var mockRepository = new MockRepository();
var inputObserver = mockRepository.StrictMock <IObserver>();
if (expectUpdates)
{
inputObserver.Expect(o => o.UpdateObserver());
}
var calculationObserver = mockRepository.StrictMock <IObserver>();
if (expectUpdates && hasOutput)
{
calculationObserver.Expect(o => o.UpdateObserver());
}
var handler = mockRepository.Stub <IObservablePropertyChangeHandler>();
mockRepository.ReplayAll();
IPipingCalculationScenario <PipingInput> calculation =
PipingCalculationScenarioTestFactory.CreateCalculationWithValidInput(new TestHydraulicBoundaryLocation(), hasOutput);
var row = new PipingCalculationRow(calculation, string.Empty, handler);
calculation.Attach(calculationObserver);
calculation.InputParameters.Attach(inputObserver);
// Call
setProperty(row);
// Assert
assertions(calculation);
if (expectUpdates)
{
Assert.IsFalse(calculation.HasOutput);
}
else
{
Assert.AreEqual(hasOutput, calculation.HasOutput);
}
mockRepository.VerifyAll();
}
/// <summary>
/// Assigns the entry point and exit point.
/// </summary>
/// <param name="calculationConfiguration">The calculation read from the imported file.</param>
/// <param name="pipingCalculation">The calculation to configure.</param>
/// <returns><c>false</c> when entry or exit point is set without <see cref="PipingSurfaceLine"/>,
/// or when entry or exit point is invalid, <c>true</c> otherwise.</returns>
private bool TrySetEntryExitPoint(PipingCalculationConfiguration calculationConfiguration,
IPipingCalculationScenario <PipingInput> pipingCalculation)
{
bool hasEntryPoint = calculationConfiguration.EntryPointL.HasValue;
bool hasExitPoint = calculationConfiguration.ExitPointL.HasValue;
if (calculationConfiguration.SurfaceLineName == null && (hasEntryPoint || hasExitPoint))
{
Log.LogCalculationConversionError(Resources.PipingCalculationConfigurationImporter_ReadSurfaceLine_EntryPointL_or_ExitPointL_defined_without_SurfaceLine,
pipingCalculation.Name);
return(false);
}
if (hasEntryPoint)
{
double entryPoint = calculationConfiguration.EntryPointL.Value;
try
{
pipingCalculation.InputParameters.EntryPointL = (RoundedDouble)entryPoint;
}
catch (ArgumentOutOfRangeException e)
{
Log.LogOutOfRangeException(string.Format(Resources.PipingCalculationConfigurationImporter_ReadEntryExitPoint_Entry_point_invalid, entryPoint),
pipingCalculation.Name,
e);
return(false);
}
}
if (hasExitPoint)
{
double exitPoint = calculationConfiguration.ExitPointL.Value;
try
{
pipingCalculation.InputParameters.ExitPointL = (RoundedDouble)exitPoint;
}
catch (ArgumentOutOfRangeException e)
{
Log.LogOutOfRangeException(string.Format(Resources.PipingCalculationConfigurationImporter_ReadEntryExitPoint_Exit_point_invalid, exitPoint),
pipingCalculation.Name,
e);
return(false);
}
}
return(true);
}
/// <inheritdoc/>
/// <exception cref="NotSupportedException">Thrown when <paramref name="calculation"/> is of a type that is not supported.</exception>
protected override PipingCalculationRow CreateRow(IPipingCalculationScenario <PipingInput> calculation)
{
string calculationType;
switch (calculation)
{
case SemiProbabilisticPipingCalculationScenario _:
calculationType = RiskeerPipingDataResources.SemiProbabilistic_DisplayName;
break;
case ProbabilisticPipingCalculationScenario _:
calculationType = RiskeerPipingDataResources.Probabilistic_DisplayName;
break;
default:
throw new NotSupportedException();
}
return(new PipingCalculationRow(calculation, calculationType, new ObservablePropertyChangeHandler(calculation, calculation.InputParameters)));
}
/// <summary>
/// Assigns the surface line.
/// </summary>
/// <param name="calculationConfiguration">The calculation read from the imported file.</param>
/// <param name="pipingCalculation">The calculation to configure.</param>
/// <returns><c>false</c> when the <paramref name="calculationConfiguration"/> has a <see cref="PipingSurfaceLine"/>
/// set which is not available in <see cref="PipingFailureMechanism.SurfaceLines"/>, <c>true</c> otherwise.</returns>
private bool TrySetSurfaceLine(PipingCalculationConfiguration calculationConfiguration,
IPipingCalculationScenario <PipingInput> pipingCalculation)
{
if (calculationConfiguration.SurfaceLineName != null)
{
PipingSurfaceLine surfaceLine = failureMechanism.SurfaceLines
.FirstOrDefault(sl => sl.Name == calculationConfiguration.SurfaceLineName);
if (surfaceLine == null)
{
Log.LogCalculationConversionError(string.Format(
Resources.PipingCalculationConfigurationImporter_ReadSurfaceLine_SurfaceLine_0_does_not_exist,
calculationConfiguration.SurfaceLineName),
pipingCalculation.Name);
return(false);
}
pipingCalculation.InputParameters.SurfaceLine = surfaceLine;
}
return(true);
}
/// <inheritdoc/>
/// <exception cref="NotSupportedException">Thrown when <paramref name="calculation"/>
/// is of an unsupported type.</exception>
protected override PipingCalculationConfiguration ToConfiguration(IPipingCalculationScenario <PipingInput> calculation)
{
PipingInput input = calculation.InputParameters;
PipingCalculationConfigurationType calculationConfigurationType = GetCalculationConfigurationType(calculation);
var calculationConfiguration = new PipingCalculationConfiguration(calculation.Name, calculationConfigurationType)
{
DampingFactorExit = input.DampingFactorExit.ToStochastConfiguration(),
PhreaticLevelExit = input.PhreaticLevelExit.ToStochastConfiguration(),
Scenario = calculation.ToScenarioConfiguration()
};
if (input.SurfaceLine != null)
{
calculationConfiguration.SurfaceLineName = input.SurfaceLine.Name;
calculationConfiguration.EntryPointL = input.EntryPointL;
calculationConfiguration.ExitPointL = input.ExitPointL;
}
if (input.StochasticSoilModel != null)
{
calculationConfiguration.StochasticSoilModelName = input.StochasticSoilModel.Name;
calculationConfiguration.StochasticSoilProfileName = input.StochasticSoilProfile?.SoilProfile.Name;
}
if (calculationConfigurationType == PipingCalculationConfigurationType.SemiProbabilistic)
{
ToSemiProbabilisticConfiguration(calculationConfiguration, (SemiProbabilisticPipingInput)calculation.InputParameters);
}
if (calculationConfigurationType == PipingCalculationConfigurationType.Probabilistic)
{
ToProbabilisticConfiguration(calculationConfiguration, (ProbabilisticPipingInput)calculation.InputParameters);
}
return(calculationConfiguration);
}
/// <summary>
/// Gets the <see cref="PipingCalculationConfigurationType"/> based on the type of <paramref name="calculation"/>.
/// </summary>
/// <param name="calculation">The calculation scenario to get the type for.</param>
/// <returns>The <see cref="PipingCalculationConfigurationType"/>.</returns>
/// <exception cref="NotSupportedException">Thrown when <paramref name="calculation"/>
/// is of an unsupported type.</exception>
private static PipingCalculationConfigurationType GetCalculationConfigurationType(IPipingCalculationScenario <PipingInput> calculation)
{
switch (calculation)
{
case SemiProbabilisticPipingCalculationScenario _:
return(PipingCalculationConfigurationType.SemiProbabilistic);
case ProbabilisticPipingCalculationScenario _:
return(PipingCalculationConfigurationType.Probabilistic);
default:
throw new NotSupportedException();
}
}
/// <summary>
/// Assigns the stochasts.
/// </summary>
/// <param name="calculationConfiguration">The calculation read from the imported file.</param>
/// <param name="pipingCalculation">The calculation to configure.</param>
/// <returns><c>false</c> when a stochast value (mean or standard deviation) is invalid, <c>true</c> otherwise.</returns>
private bool TrySetStochasts(PipingCalculationConfiguration calculationConfiguration,
IPipingCalculationScenario <PipingInput> pipingCalculation)
{
return(TrySetPhreaticLevelExit(calculationConfiguration, pipingCalculation) &&
TrySetDampingFactorExit(calculationConfiguration, pipingCalculation));
}
