public void Create_WaternetWithPhreaticLineAndHeadLinesAndWaternetLines_ReturnWaternetCalculatorResult()
{
// Setup
var headLine = new HeadLine
{
Name = "line 1",
Points =
{
new CSharpWrapperPoint2D(0, 0),
new CSharpWrapperPoint2D(1, 1)
}
};
var phreaticLine = new HeadLine
{
Name = "line 2",
Points =
{
new CSharpWrapperPoint2D(2, 2),
new CSharpWrapperPoint2D(3, 3)
}
};
var referenceLine = new ReferenceLine
{
Name = "line 3",
Points =
{
new CSharpWrapperPoint2D(4, 4),
new CSharpWrapperPoint2D(5, 5)
},
AssociatedHeadLine = headLine
};
var waternet = new Waternet
{
HeadLines =
{
headLine
},
PhreaticLine = phreaticLine,
ReferenceLines =
{
referenceLine
}
};
// Call
WaternetCalculatorResult result = WaternetCalculatorResultCreator.Create(waternet);
// Assert
WaternetCalculatorOutputAssert.AssertPhreaticLines(new[]
{
phreaticLine,
headLine
}, result.PhreaticLines.ToArray());
WaternetCalculatorOutputAssert.AssertReferenceLines(new[]
{
referenceLine
}, result.WaternetLines.ToArray());
}
/// <summary>
/// Calculates the Waternet with daily circumstances based on the values
/// of the <see cref="IMacroStabilityInwardsWaternetInput"/>.
/// </summary>
/// <param name="input">The input to get the values from.</param>
/// <param name="generalInput">General calculation parameters that are the same across all calculations.</param>
/// <returns>A calculated <see cref="MacroStabilityInwardsWaternet"/>,
/// or an empty <see cref="MacroStabilityInwardsWaternet"/> when the Waternet
/// could not be calculated.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static MacroStabilityInwardsWaternet CalculateDaily(IMacroStabilityInwardsWaternetInput input, IGeneralMacroStabilityInwardsWaternetInput generalInput)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
IWaternetCalculator calculator = MacroStabilityInwardsCalculatorFactory.Instance
.CreateWaternetDailyCalculator(
CreateDailyCalculatorInput(input, generalInput),
MacroStabilityInwardsKernelWrapperFactory.Instance);
try
{
WaternetCalculatorResult result = calculator.Calculate();
return(MacroStabilityInwardsWaternetConverter.Convert(result));
}
catch (WaternetCalculatorException)
{
return(new MacroStabilityInwardsWaternet(new MacroStabilityInwardsPhreaticLine[0],
new MacroStabilityInwardsWaternetLine[0]));
}
}
public void Convert_WithResult_ReturnMacroStabilityInwardsWaternet()
{
// Setup
WaternetCalculatorResult result = WaternetCalculatorResultTestFactory.Create();
// Call
MacroStabilityInwardsWaternet converted = MacroStabilityInwardsWaternetConverter.Convert(result);
// Assert
CalculatorOutputAssert.AssertWaternet(result, converted);
}
public void Constructor_ExpectedValues()
{
// Setup
var phreaticLines = new WaternetPhreaticLineResult[0];
var waternetLines = new WaternetLineResult[0];
// Call
var result = new WaternetCalculatorResult(phreaticLines, waternetLines);
// Assert
Assert.AreSame(phreaticLines, result.PhreaticLines);
Assert.AreSame(waternetLines, result.WaternetLines);
}
/// <summary>
/// Converts <see cref="WaternetCalculatorResult"/> into <see cref="MacroStabilityInwardsWaternet"/>.
/// </summary>
/// <param name="calculatorResult">The result to convert.</param>
/// <returns>The converted <see cref="MacroStabilityInwardsWaternet"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculatorResult"/>
/// is <c>null</c>.</exception>
public static MacroStabilityInwardsWaternet Convert(WaternetCalculatorResult calculatorResult)
{
if (calculatorResult == null)
{
throw new ArgumentNullException(nameof(calculatorResult));
}
IDictionary <WaternetPhreaticLineResult, MacroStabilityInwardsPhreaticLine> phreaticLineLookup = calculatorResult.PhreaticLines
.ToDictionary(pl => pl, ConvertPhreaticLine);
return(new MacroStabilityInwardsWaternet(phreaticLineLookup.Values.ToArray(),
calculatorResult.WaternetLines
.Select(wl => ConvertWaternetLine(wl, phreaticLineLookup)).ToArray()));
}
/// <summary>
/// Asserts whether <paramref name="actual"/> corresponds to <paramref name="original"/>.
/// </summary>
/// <param name="original">The original <see cref="WaternetCalculatorResult"/>.</param>
/// <param name="actual">The actual <see cref="MacroStabilityInwardsWaternet"/>.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="actual"/>
/// does not correspond to <paramref name="original"/>.</exception>
public static void AssertWaternet(WaternetCalculatorResult original, MacroStabilityInwardsWaternet actual)
{
WaternetPhreaticLineResult[] originalPhreaticLines = original.PhreaticLines.ToArray();
WaternetLineResult[] originalWaternetLines = original.WaternetLines.ToArray();
MacroStabilityInwardsPhreaticLine[] actualPhreaticLines = actual.PhreaticLines.ToArray();
MacroStabilityInwardsWaternetLine[] actualWaternetLines = actual.WaternetLines.ToArray();
Assert.AreEqual(originalPhreaticLines.Length, actualPhreaticLines.Length);
Assert.AreEqual(originalWaternetLines.Length, actualWaternetLines.Length);
for (var i = 0; i < originalPhreaticLines.Length; i++)
{
Assert.AreEqual(originalPhreaticLines[i].Name, actualPhreaticLines[i].Name);
CollectionAssert.AreEqual(originalPhreaticLines[i].Geometry, actualPhreaticLines[i].Geometry);
}
for (var i = 0; i < originalWaternetLines.Length; i++)
{
Assert.AreEqual(originalWaternetLines[i].Name, actualWaternetLines[i].Name);
CollectionAssert.AreEqual(originalWaternetLines[i].Geometry, actualWaternetLines[i].Geometry);
Assert.AreEqual(originalWaternetLines[i].PhreaticLine.Name, actualWaternetLines[i].PhreaticLine.Name);
CollectionAssert.AreEqual(originalWaternetLines[i].PhreaticLine.Geometry, actualWaternetLines[i].PhreaticLine.Geometry);
}
}
