public void CreateExtremeWaternetForUpliftVan_ValidData_ReturnMacroStabilityInput()
{
// Setup
UpliftVanCalculatorInput input = UpliftVanCalculatorInputTestFactory.Create();
LayerWithSoil[] layersWithSoil = LayerWithSoilCreator.Create(input.SoilProfile, out IDictionary <SoilLayer, LayerWithSoil> _);
List <Soil> soils = layersWithSoil.Select(lws => lws.Soil).ToList();
SurfaceLine surfaceLine = SurfaceLineCreator.Create(input.SurfaceLine);
SoilProfile soilProfile = SoilProfileCreator.Create(layersWithSoil);
// Call
MacroStabilityInput macroStabilityInput = MacroStabilityInputCreator.CreateExtremeWaternetForUpliftVan(
input, soils, surfaceLine, soilProfile);
// Assert
CollectionAssert.AreEqual(soils, macroStabilityInput.StabilityModel.Soils, new SoilComparer());
Assert.AreSame(soilProfile, macroStabilityInput.StabilityModel.ConstructionStages.Single().SoilProfile);
PreConstructionStage preConstructionStage = macroStabilityInput.PreprocessingInput.PreConstructionStages.Single();
Assert.AreSame(surfaceLine, preConstructionStage.SurfaceLine);
Assert.IsTrue(preConstructionStage.CreateWaternet);
KernelInputAssert.AssertWaternetCreatorInput(UpliftVanWaternetCreatorInputCreator.CreateExtreme(input), preConstructionStage.WaternetCreatorInput);
}
public void CreateUpliftVan_ValidDataWithManualTangentLines_ReturnMacroStabilityInput()
{
// Setup
var random = new Random(21);
double tangentZTop = random.NextDouble();
double tangentZBottom = random.NextDouble();
int tangentLineNumber = random.Next();
UpliftVanCalculatorInput input = UpliftVanCalculatorInputTestFactory.Create(tangentZTop, tangentZBottom, tangentLineNumber);
LayerWithSoil[] layersWithSoil = LayerWithSoilCreator.Create(input.SoilProfile, out IDictionary <SoilLayer, LayerWithSoil> layerLookup);
List <Soil> soils = layersWithSoil.Select(lws => lws.Soil).ToList();
SurfaceLine surfaceLine = SurfaceLineCreator.Create(input.SurfaceLine);
SoilProfile soilProfile = SoilProfileCreator.Create(layersWithSoil);
var dailyWaternet = new Waternet();
var extremeWaternet = new Waternet();
// Call
MacroStabilityInput macroStabilityInput = MacroStabilityInputCreator.CreateUpliftVan(
input, soils, layerLookup, surfaceLine, soilProfile, dailyWaternet, extremeWaternet);
// Assert
SearchAreaConditions searchAreaConditions = macroStabilityInput.PreprocessingInput.SearchAreaConditions;
Assert.AreEqual(input.SlipPlane.TangentLinesAutomaticAtBoundaries, searchAreaConditions.AutoTangentLines);
Assert.AreEqual(input.SlipPlane.TangentLineNumber, searchAreaConditions.TangentLineNumber);
Assert.AreEqual(input.SlipPlane.TangentZTop, searchAreaConditions.TangentLineZTop);
Assert.AreEqual(input.SlipPlane.TangentZBottom, searchAreaConditions.TangentLineZBottom);
}
private static void AssertConstructionStages(
UpliftVanCalculatorInput input, StabilityInput stabilityModel, SoilProfile soilProfile,
Waternet dailyWaternet, Waternet extremeWaternet, IDictionary <SoilLayer, LayerWithSoil> layerLookup)
{
Assert.AreEqual(2, stabilityModel.ConstructionStages.Count);
ConstructionStage dailyConstructionStage = stabilityModel.ConstructionStages.ElementAt(0);
Assert.AreSame(soilProfile, dailyConstructionStage.SoilProfile);
Assert.AreSame(dailyWaternet, dailyConstructionStage.Waternet);
CollectionAssert.AreEqual(FixedSoilStressCreator.Create(layerLookup),
dailyConstructionStage.FixedSoilStresses, new FixedSoilStressComparer());
CollectionAssert.AreEqual(PreconsolidationStressCreator.Create(input.SoilProfile.PreconsolidationStresses),
dailyConstructionStage.PreconsolidationStresses, new PreconsolidationStressComparer());
AssertMultiplicationFactors(dailyConstructionStage.MultiplicationFactorsCPhiForUplift.Single());
AssertIrrelevantValues(dailyConstructionStage);
ConstructionStage extremeConstructionStage = stabilityModel.ConstructionStages.ElementAt(1);
Assert.AreSame(soilProfile, extremeConstructionStage.SoilProfile);
Assert.AreSame(extremeWaternet, extremeConstructionStage.Waternet);
CollectionAssert.IsEmpty(extremeConstructionStage.FixedSoilStresses);
CollectionAssert.IsEmpty(extremeConstructionStage.PreconsolidationStresses);
AssertMultiplicationFactors(extremeConstructionStage.MultiplicationFactorsCPhiForUplift.Single());
AssertIrrelevantValues(extremeConstructionStage);
}
private IUpliftVanKernel CreateUpliftVanKernel()
{
LayerWithSoil[] layersWithSoil = LayerWithSoilCreator.Create(input.SoilProfile, out IDictionary <SoilLayer, LayerWithSoil> layerLookup);
List <Soil> soils = layersWithSoil.Select(lws => lws.Soil).ToList();
SurfaceLine surfaceLine = SurfaceLineCreator.Create(input.SurfaceLine);
SoilProfile soilProfile = SoilProfileCreator.Create(layersWithSoil);
MacroStabilityInput waternetDailyKernelInput = MacroStabilityInputCreator.CreateDailyWaternetForUpliftVan(input, soils, surfaceLine, soilProfile);
MacroStabilityInput waternetExtremeKernelInput = MacroStabilityInputCreator.CreateExtremeWaternetForUpliftVan(input, soils, surfaceLine, soilProfile);
IWaternetKernel waternetDailyKernel = factory.CreateWaternetDailyKernel(waternetDailyKernelInput);
waternetDailyKernel.Calculate();
IWaternetKernel waternetExtremeKernel = factory.CreateWaternetExtremeKernel(waternetExtremeKernelInput);
waternetExtremeKernel.Calculate();
MacroStabilityInput kernelInput = MacroStabilityInputCreator.CreateUpliftVan(input, soils, layerLookup,
surfaceLine, soilProfile,
waternetDailyKernel.Waternet,
waternetExtremeKernel.Waternet);
return(factory.CreateUpliftVanKernel(kernelInput));
}
private static MacroStabilityInput CreateWaternet(ICollection <Soil> soils, SurfaceLine surfaceLine,
SoilProfile soilProfile, WaternetCreatorInput waternetCreatorInput)
{
return(new MacroStabilityInput
{
StabilityModel =
{
ConstructionStages =
{
new ConstructionStage
{
SoilProfile = soilProfile
}
},
Soils = soils
},
PreprocessingInput =
{
PreConstructionStages =
{
new PreConstructionStage
{
SurfaceLine = surfaceLine,
CreateWaternet = true,
WaternetCreatorInput = waternetCreatorInput
}
}
}
});
}
public void Calculate_CalculatorWithCompleteInput_InputCorrectlySetToKernel()
{
// Setup
UpliftVanCalculatorInput input = UpliftVanCalculatorInputTestFactory.Create();
using (new MacroStabilityInwardsKernelFactoryConfig())
{
var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance;
UpliftVanKernelStub upliftVanKernel = factory.LastCreatedUpliftVanKernel;
WaternetKernelStub waternetDailyKernel = factory.LastCreatedWaternetDailyKernel;
WaternetKernelStub waternetExtremeKernel = factory.LastCreatedWaternetExtremeKernel;
SetValidKernelOutput(waternetDailyKernel);
SetValidKernelOutput(waternetExtremeKernel);
SetValidKernelOutput(upliftVanKernel);
LayerWithSoil[] layersWithSoil = LayerWithSoilCreator.Create(input.SoilProfile, out IDictionary <SoilLayer, LayerWithSoil> layerLookup);
List <Soil> soils = layersWithSoil.Select(lws => lws.Soil).ToList();
SurfaceLine surfaceLine = SurfaceLineCreator.Create(input.SurfaceLine);
CSharpWrapperSoilProfile soilProfile = SoilProfileCreator.Create(layersWithSoil);
// Call
new UpliftVanCalculator(input, factory).Calculate();
// Assert
WaternetKernelInputAssert.AssertMacroStabilityInput(
MacroStabilityInputCreator.CreateDailyWaternetForUpliftVan(input, soils, surfaceLine, soilProfile),
waternetDailyKernel.KernelInput);
WaternetKernelInputAssert.AssertMacroStabilityInput(
MacroStabilityInputCreator.CreateExtremeWaternetForUpliftVan(input, soils, surfaceLine, soilProfile),
waternetExtremeKernel.KernelInput);
UpliftVanKernelInputAssert.AssertMacroStabilityInput(
MacroStabilityInputCreator.CreateUpliftVan(
input, soils, layerLookup, surfaceLine, soilProfile,
waternetDailyKernel.Waternet, waternetExtremeKernel.Waternet),
upliftVanKernel.KernelInput);
}
}
private static ConstructionStage AddConstructionStage(
SoilProfile soilProfile,
Waternet waternet,
List <FixedSoilStress> fixedSoilStresses = null,
List <KernelPreconsolidationStress> preconsolidationStresses = null)
{
return(new ConstructionStage
{
SoilProfile = soilProfile,
Waternet = waternet,
FixedSoilStresses = fixedSoilStresses ?? new List <FixedSoilStress>(),
PreconsolidationStresses = preconsolidationStresses ?? new List <KernelPreconsolidationStress>(),
MultiplicationFactorsCPhiForUplift =
{
new MultiplicationFactorsCPhiForUplift
{
MultiplicationFactor = 0.0,
UpliftFactor = 1.2
}
}
});
}
public void CreateUpliftVan_ValidData_ReturnMacroStabilityInput()
{
// Setup
UpliftVanCalculatorInput input = UpliftVanCalculatorInputTestFactory.Create();
LayerWithSoil[] layersWithSoil = LayerWithSoilCreator.Create(input.SoilProfile, out IDictionary <SoilLayer, LayerWithSoil> layerLookup);
List <Soil> soils = layersWithSoil.Select(lws => lws.Soil).ToList();
SurfaceLine surfaceLine = SurfaceLineCreator.Create(input.SurfaceLine);
SoilProfile soilProfile = SoilProfileCreator.Create(layersWithSoil);
var dailyWaternet = new Waternet();
var extremeWaternet = new Waternet();
// Call
MacroStabilityInput macroStabilityInput = MacroStabilityInputCreator.CreateUpliftVan(
input, soils, layerLookup, surfaceLine, soilProfile, dailyWaternet, extremeWaternet);
// Assert
StabilityInput stabilityModel = macroStabilityInput.StabilityModel;
Assert.AreEqual(Orientation.Inwards, stabilityModel.Orientation);
Assert.AreEqual(SearchAlgorithm.Grid, stabilityModel.SearchAlgorithm);
Assert.AreEqual(StabilityModelOptionType.UpliftVan, stabilityModel.ModelOption);
CollectionAssert.AreEqual(soils, stabilityModel.Soils, new SoilComparer());
Assert.AreEqual(input.MoveGrid, stabilityModel.MoveGrid);
Assert.AreEqual(input.MaximumSliceWidth, stabilityModel.MaximumSliceWidth);
UpliftVanKernelInputAssert.AssertUpliftVanCalculationGrid(
UpliftVanCalculationGridCreator.Create(input.SlipPlane), stabilityModel.UpliftVanCalculationGrid);
UpliftVanKernelInputAssert.AssertSlipPlaneConstraints(
SlipPlaneConstraintsCreator.Create(input.SlipPlaneConstraints), stabilityModel.SlipPlaneConstraints);
AssertConstructionStages(input, stabilityModel, soilProfile, dailyWaternet, extremeWaternet, layerLookup);
Assert.AreEqual(input.SlipPlane.GridNumberOfRefinements, stabilityModel.NumberOfRefinementsGrid);
Assert.AreEqual(input.SlipPlane.TangentLineNumberOfRefinements, stabilityModel.NumberOfRefinementsTangentLines);
SearchAreaConditions searchAreaConditions = macroStabilityInput.PreprocessingInput.SearchAreaConditions;
Assert.AreEqual(0.8, searchAreaConditions.MaxSpacingBetweenBoundaries);
Assert.IsTrue(searchAreaConditions.OnlyAbovePleistoceen);
Assert.AreEqual(input.SlipPlane.GridAutomaticDetermined, searchAreaConditions.AutoSearchArea);
Assert.AreEqual(input.SlipPlane.TangentLinesAutomaticAtBoundaries, searchAreaConditions.AutoTangentLines);
Assert.AreEqual(1, searchAreaConditions.TangentLineNumber);
Assert.AreEqual(0, searchAreaConditions.TangentLineZTop);
Assert.AreEqual(0, searchAreaConditions.TangentLineZBottom);
Assert.AreEqual(input.SlipPlaneConstraints.AutomaticForbiddenZones, searchAreaConditions.AutomaticForbiddenZones);
Assert.AreEqual(2, macroStabilityInput.PreprocessingInput.PreConstructionStages.Count);
foreach (PreConstructionStage preConstructionStage in macroStabilityInput.PreprocessingInput.PreConstructionStages)
{
Assert.IsFalse(preConstructionStage.CreateWaternet);
Assert.AreSame(surfaceLine, preConstructionStage.SurfaceLine);
Assert.IsNull(preConstructionStage.WaternetCreatorInput); // Not needed as Waternet is already calculated
}
AssertIrrelevantValues(stabilityModel, searchAreaConditions);
}
/// <summary>
/// Creates <see cref="MacroStabilityInput"/> objects based on the given input for the Uplift Van calculation.
/// </summary>
/// <param name="upliftVanInput">The <see cref="UpliftVanCalculatorInput"/> containing all the values required
/// for performing the Uplift Van calculation.</param>
/// <param name="soils">The collection of <see cref="Soil"/>.</param>
/// <param name="layerLookup">The lookup between <see cref="Soil"/> and <see cref="SoilLayer"/>.</param>
/// <param name="surfaceLine">The <see cref="SurfaceLine"/>.</param>
/// <param name="soilProfile">The <see cref="SoilProfile"/>.</param>
/// <param name="dailyWaternet">The calculated <see cref="Waternet"/> for daily circumstances.</param>
/// <param name="extremeWaternet">The calculated <see cref="Waternet"/> for extreme circumstances.</param>
/// <returns>The created <see cref="MacroStabilityInput"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static MacroStabilityInput CreateUpliftVan(UpliftVanCalculatorInput upliftVanInput, ICollection <Soil> soils,
IDictionary <SoilLayer, LayerWithSoil> layerLookup, SurfaceLine surfaceLine,
SoilProfile soilProfile, Waternet dailyWaternet, Waternet extremeWaternet)
{
if (upliftVanInput == null)
{
throw new ArgumentNullException(nameof(upliftVanInput));
}
if (soils == null)
{
throw new ArgumentNullException(nameof(soils));
}
if (layerLookup == null)
{
throw new ArgumentNullException(nameof(layerLookup));
}
if (surfaceLine == null)
{
throw new ArgumentNullException(nameof(surfaceLine));
}
if (soilProfile == null)
{
throw new ArgumentNullException(nameof(soilProfile));
}
if (dailyWaternet == null)
{
throw new ArgumentNullException(nameof(dailyWaternet));
}
if (extremeWaternet == null)
{
throw new ArgumentNullException(nameof(extremeWaternet));
}
var macroStabilityInput = new MacroStabilityInput
{
StabilityModel =
{
Orientation = Orientation.Inwards,
SearchAlgorithm = SearchAlgorithm.Grid,
ModelOption = StabilityModelOptionType.UpliftVan,
ConstructionStages =
{
AddConstructionStage(soilProfile, dailyWaternet, FixedSoilStressCreator.Create(layerLookup).ToList(),
PreconsolidationStressCreator.Create(upliftVanInput.SoilProfile.PreconsolidationStresses).ToList()),
AddConstructionStage(soilProfile, extremeWaternet)
},
Soils = soils,
MoveGrid = upliftVanInput.MoveGrid,
MaximumSliceWidth = upliftVanInput.MaximumSliceWidth,
UpliftVanCalculationGrid = UpliftVanCalculationGridCreator.Create(upliftVanInput.SlipPlane),
SlipPlaneConstraints = SlipPlaneConstraintsCreator.Create(upliftVanInput.SlipPlaneConstraints),
NumberOfRefinementsGrid = upliftVanInput.SlipPlane.GridNumberOfRefinements,
NumberOfRefinementsTangentLines = upliftVanInput.SlipPlane.TangentLineNumberOfRefinements
},
PreprocessingInput =
{
SearchAreaConditions =
{
MaxSpacingBetweenBoundaries = 0.8,
OnlyAbovePleistoceen = true,
AutoSearchArea = upliftVanInput.SlipPlane.GridAutomaticDetermined,
AutoTangentLines = upliftVanInput.SlipPlane.TangentLinesAutomaticAtBoundaries,
AutomaticForbiddenZones = upliftVanInput.SlipPlaneConstraints.AutomaticForbiddenZones
},
PreConstructionStages =
{
AddPreConstructionStage(surfaceLine),
AddPreConstructionStage(surfaceLine)
}
}
};
SetTangentLineProperties(upliftVanInput, macroStabilityInput);
return(macroStabilityInput);
}
/// <summary>
/// Creates <see cref="MacroStabilityInput"/> objects based on the given input for the extreme Waternet calculation.
/// </summary>
/// <param name="upliftVanInput">The <see cref="UpliftVanCalculatorInput"/> containing all the values required
/// for performing the Waternet calculation.</param>
/// <param name="soils">The collection of <see cref="Soil"/>.</param>
/// <param name="surfaceLine">The <see cref="SurfaceLine"/>.</param>
/// <param name="soilProfile">The <see cref="SoilProfile"/>.</param>
/// <returns>The created <see cref="MacroStabilityInput"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static MacroStabilityInput CreateExtremeWaternetForUpliftVan(UpliftVanCalculatorInput upliftVanInput, ICollection <Soil> soils,
SurfaceLine surfaceLine, SoilProfile soilProfile)
{
if (upliftVanInput == null)
{
throw new ArgumentNullException(nameof(upliftVanInput));
}
if (soils == null)
{
throw new ArgumentNullException(nameof(soils));
}
if (surfaceLine == null)
{
throw new ArgumentNullException(nameof(surfaceLine));
}
if (soilProfile == null)
{
throw new ArgumentNullException(nameof(soilProfile));
}
return(CreateWaternet(soils, surfaceLine, soilProfile, UpliftVanWaternetCreatorInputCreator.CreateExtreme(upliftVanInput)));
}
