public void GivenSurfaceLineSet_WhenSurfaceLineNull_ThenEntryAndExitPointsNaN()
{
// Given
var input = new TestPipingInput();
var surfaceLine = new PipingSurfaceLine(string.Empty);
surfaceLine.SetGeometry(new[]
{
new Point3D(0, 0, 0),
new Point3D(1, 0, 2),
new Point3D(2, 0, 3),
new Point3D(3, 0, 0),
new Point3D(4, 0, 2),
new Point3D(5, 0, 3)
});
input.SurfaceLine = surfaceLine;
input.ExitPointL = (RoundedDouble)5;
input.EntryPointL = (RoundedDouble)4;
// When
input.SurfaceLine = null;
// Then
Assert.IsNaN(input.EntryPointL);
Assert.IsNaN(input.ExitPointL);
}
public void GetPiezometricHeadExit_ValidInput_SetsParametersForCalculatorAndReturnsNotNaN()
{
// Setup
var input = new TestPipingInput();
using (new PipingSubCalculatorFactoryConfig())
{
// Setup
var assessmentLevel = (RoundedDouble)1.1;
// Call
RoundedDouble piezometricHead = DerivedSemiProbabilisticPipingInput.GetPiezometricHeadExit(input, assessmentLevel);
// Assert
Assert.AreEqual(2, piezometricHead.NumberOfDecimalPlaces);
Assert.IsFalse(double.IsNaN(piezometricHead));
var factory = (TestPipingSubCalculatorFactory)PipingSubCalculatorFactory.Instance;
PiezoHeadCalculatorStub piezometricHeadAtExitCalculator = factory.LastCreatedPiezometricHeadAtExitCalculator;
Assert.AreEqual(assessmentLevel, piezometricHeadAtExitCalculator.HRiver, assessmentLevel.GetAccuracy());
Assert.AreEqual(PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.PhiPolder,
input.PhreaticLevelExit.GetAccuracy());
Assert.AreEqual(SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(), piezometricHeadAtExitCalculator.RExit,
input.DampingFactorExit.GetAccuracy());
}
}
public void IsEntryAndExitPointInputSynchronized_SurfaceLineAndInputNotInSync_ReturnFalse(Point3D newDikeToeAtRiver, Point3D newDikeToeAtPolder)
{
// Setup
var surfaceLine = new PipingSurfaceLine(string.Empty);
surfaceLine.SetGeometry(new[]
{
new Point3D(0, 0, 0),
new Point3D(1, 0, 2),
new Point3D(2, 0, 3),
new Point3D(3, 0, 0),
new Point3D(4, 0, 2),
new Point3D(5, 0, 3)
});
surfaceLine.SetDikeToeAtRiverAt(new Point3D(2, 0, 3));
surfaceLine.SetDikeToeAtPolderAt(new Point3D(3, 0, 0));
var input = new TestPipingInput
{
SurfaceLine = surfaceLine
};
input.SurfaceLine.SetDikeToeAtRiverAt(newDikeToeAtRiver);
input.SurfaceLine.SetDikeToeAtPolderAt(newDikeToeAtPolder);
// Call
bool synchronized = input.IsEntryAndExitPointInputSynchronized;
// Assert
Assert.IsFalse(synchronized);
}
public void SynchronizeEntryAndExitPointInput_DikeToesBeforeSetEntryPointL_ExitPointLAndEntryPointLUpdated()
{
// Setup
var input = new TestPipingInput();
var surfaceLine = new PipingSurfaceLine(string.Empty);
surfaceLine.SetGeometry(new[]
{
new Point3D(0, 0, 0),
new Point3D(1, 0, 2),
new Point3D(2, 0, 3),
new Point3D(3, 0, 0),
new Point3D(4, 0, 2),
new Point3D(5, 0, 3)
});
surfaceLine.SetDikeToeAtRiverAt(new Point3D(2, 0, 3));
surfaceLine.SetDikeToeAtPolderAt(new Point3D(3, 0, 0));
input.SurfaceLine = surfaceLine;
input.ExitPointL = (RoundedDouble)5;
input.EntryPointL = (RoundedDouble)4;
// Call
input.SynchronizeEntryAndExitPointInput();
// Assert
Assert.AreEqual(2, input.EntryPointL, input.EntryPointL.GetAccuracy());
Assert.AreEqual(3, input.ExitPointL, input.ExitPointL.GetAccuracy());
}
/// <summary>
/// Creates piping input with a single aquifer layer above the surface line.
/// </summary>
/// <param name="deltaAboveSurfaceLine">The distance between the aquifer layer and the surface line.</param>
/// <returns>A new <see cref="PipingInput"/>.</returns>
public static PipingInput CreateInputWithSingleAquiferLayerAboveSurfaceLine(double deltaAboveSurfaceLine)
{
var surfaceLine = new PipingSurfaceLine(string.Empty);
const double surfaceLineTopLevel = 2.0;
surfaceLine.SetGeometry(new[]
{
new Point3D(0, 0, surfaceLineTopLevel),
new Point3D(1.0, 0, surfaceLineTopLevel)
});
var stochasticSoilProfile = new PipingStochasticSoilProfile(
0.0, new PipingSoilProfile(string.Empty, 0, new[]
{
new PipingSoilLayer(surfaceLineTopLevel + deltaAboveSurfaceLine + 2)
{
IsAquifer = false
},
new PipingSoilLayer(surfaceLineTopLevel + deltaAboveSurfaceLine + 1)
{
IsAquifer = true
},
new PipingSoilLayer(surfaceLineTopLevel + deltaAboveSurfaceLine)
{
IsAquifer = false
}
}, SoilProfileType.SoilProfile1D));
var input = new TestPipingInput
{
SurfaceLine = surfaceLine,
StochasticSoilProfile = stochasticSoilProfile,
ExitPointL = (RoundedDouble)0.5
};
return(input);
}
/// <summary>
/// Creates piping input with multiple aquifer layers under the surface line.
/// </summary>
/// <param name="expectedThickness">The expected thickness of the aquifer.</param>
/// <returns>A new <see cref="PipingInput"/>.</returns>
public static PipingInput CreateInputWithMultipleAquiferLayersUnderSurfaceLine(out double expectedThickness)
{
var surfaceLine = new PipingSurfaceLine(string.Empty);
surfaceLine.SetGeometry(new[]
{
new Point3D(0, 0, 3.3),
new Point3D(1.0, 0, 3.3)
});
var stochasticSoilProfile = new PipingStochasticSoilProfile(
0.0, new PipingSoilProfile(string.Empty, 0, new[]
{
new PipingSoilLayer(4.3)
{
IsAquifer = false
},
new PipingSoilLayer(3.3)
{
IsAquifer = true
},
new PipingSoilLayer(1.1)
{
IsAquifer = true
}
}, SoilProfileType.SoilProfile1D));
var input = new TestPipingInput
{
SurfaceLine = surfaceLine,
StochasticSoilProfile = stochasticSoilProfile,
ExitPointL = (RoundedDouble)0.5
};
expectedThickness = 3.3;
return(input);
}
public void Constructor_ExpectedValues()
{
// Setup
var phreaticLevelExit = new NormalDistribution(3)
{
Mean = (RoundedDouble)0,
StandardDeviation = (RoundedDouble)0.1
};
var dampingFactorExit = new LogNormalDistribution(3)
{
Mean = (RoundedDouble)0.7,
StandardDeviation = (RoundedDouble)0.1
};
// Call
var pipingInput = new TestPipingInput();
// Assert
Assert.IsInstanceOf <CloneableObservable>(pipingInput);
Assert.IsInstanceOf <ICalculationInputWithHydraulicBoundaryLocation>(pipingInput);
DistributionAssert.AreEqual(phreaticLevelExit, pipingInput.PhreaticLevelExit);
DistributionAssert.AreEqual(dampingFactorExit, pipingInput.DampingFactorExit);
Assert.IsNull(pipingInput.SurfaceLine);
Assert.IsNull(pipingInput.StochasticSoilModel);
Assert.IsNull(pipingInput.StochasticSoilProfile);
Assert.IsNull(pipingInput.HydraulicBoundaryLocation);
Assert.IsNaN(pipingInput.ExitPointL);
Assert.AreEqual(2, pipingInput.ExitPointL.NumberOfDecimalPlaces);
Assert.IsNaN(pipingInput.EntryPointL);
Assert.AreEqual(2, pipingInput.EntryPointL.NumberOfDecimalPlaces);
}
public void IsEntryAndExitPointInputSynchronized_SurfaceLineNull_ReturnFalse()
{
// Setup
var input = new TestPipingInput();
// Call
bool synchronized = input.IsEntryAndExitPointInputSynchronized;
// Assert
Assert.IsFalse(synchronized);
}
public void EntryPointL_Always_SameNumberOfDecimalsAsSurfaceLineLocalGeometry()
{
// Setup
PipingSurfaceLine surfaceLine = CreateSurfaceLine();
var pipingInput = new TestPipingInput();
// Call
RoundedPoint2DCollection localGeometry = surfaceLine.LocalGeometry;
// Assert
Assert.AreEqual(localGeometry.NumberOfDecimalPlaces, pipingInput.EntryPointL.NumberOfDecimalPlaces);
}
public void GetPhreaticLevelExit_ValidPipingInput_CreateDesignVariableForPhreaticLevelExit()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
DesignVariable <NormalDistribution> phreaticLevelExit = PipingDesignVariableFactory.GetPhreaticLevelExit(pipingInput);
// Assert
Assert.AreSame(pipingInput.PhreaticLevelExit, phreaticLevelExit.Distribution);
AssertPercentile(0.05, phreaticLevelExit);
}
public void Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
var original = new TestPipingInput();
PipingTestDataGenerator.SetRandomDataToPipingInput(original);
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, PipingCloneAssert.AreClones);
}
public void GetDampingFactorExit_ValidPipingInput_CreateDesignVariableForDampingFactorExit()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
DesignVariable <LogNormalDistribution> dampingFactorExit =
SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(pipingInput);
// Assert
Assert.AreSame(pipingInput.DampingFactorExit, dampingFactorExit.Distribution);
AssertPercentile(0.95, dampingFactorExit);
}
public void GetSeepageLength_ValidPipingInput_CreateDesignVariableForSeepageLength()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
VariationCoefficientDesignVariable <VariationCoefficientLogNormalDistribution> seepageLength =
SemiProbabilisticPipingDesignVariableFactory.GetSeepageLength(pipingInput);
// Assert
DistributionAssert.AreEqual(DerivedPipingInput.GetSeepageLength(pipingInput), seepageLength.Distribution);
AssertPercentile(0.05, seepageLength);
}
public void GetDiameter70_ValidPipingInput_CreateDesignVariableForDiameter70()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
VariationCoefficientDesignVariable <VariationCoefficientLogNormalDistribution> d70 =
SemiProbabilisticPipingDesignVariableFactory.GetDiameter70(pipingInput);
// Assert
DistributionAssert.AreEqual(DerivedPipingInput.GetDiameterD70(pipingInput), d70.Distribution);
AssertPercentile(0.05, d70);
}
public void GetDarcyPermeability_ValidPipingInput_CreateDesignVariableForDarcyPermeability()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
VariationCoefficientDesignVariable <VariationCoefficientLogNormalDistribution> darcyPermeability =
SemiProbabilisticPipingDesignVariableFactory.GetDarcyPermeability(pipingInput);
// Assert
DistributionAssert.AreEqual(DerivedPipingInput.GetDarcyPermeability(pipingInput), darcyPermeability.Distribution);
AssertPercentile(0.95, darcyPermeability);
}
public void GetThicknessAquiferLayer_ValidPipingInput_CreateDesignVariableForThicknessAquiferLayer()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
DesignVariable <LogNormalDistribution> thicknessAquiferLayer =
SemiProbabilisticPipingDesignVariableFactory.GetThicknessAquiferLayer(pipingInput);
// Assert
DistributionAssert.AreEqual(DerivedPipingInput.GetThicknessAquiferLayer(pipingInput), thicknessAquiferLayer.Distribution);
AssertPercentile(0.95, thicknessAquiferLayer);
}
public void GetThicknessCoverageLayer_PipingInputWithoutCoverLayer_CreateDeterministicDesignVariableForThicknessCoverageLayer()
{
// Setup
var pipingInput = new TestPipingInput();
// Call
DesignVariable <LogNormalDistribution> thicknessCoverageLayer = SemiProbabilisticPipingDesignVariableFactory.GetThicknessCoverageLayer(pipingInput);
// Assert
Assert.IsInstanceOf <DeterministicDesignVariable <LogNormalDistribution> >(thicknessCoverageLayer);
DistributionAssert.AreEqual(DerivedPipingInput.GetThicknessCoverageLayer(pipingInput), thicknessCoverageLayer.Distribution);
Assert.AreEqual(new RoundedDouble(2), thicknessCoverageLayer.GetDesignValue());
}
public static void CalculatePiezometricHeadAtExit_Always_ReturnsResult()
{
// Setup
var input = new TestPipingInput();
// Call
double result = InputParameterCalculationService.CalculatePiezometricHeadAtExit(
(RoundedDouble)0.0,
SemiProbabilisticPipingDesignVariableFactory.GetDampingFactorExit(input).GetDesignValue(),
PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue());
// Assert
Assert.IsFalse(double.IsNaN(result));
}
public static void CalculateEffectiveThicknessCoverageLayer_WithMultipleCharacteristicTypesOnSamePoint_ReturnsThickness()
{
// Setup
var surfaceLine = new PipingSurfaceLine(string.Empty);
surfaceLine.SetGeometry(new[]
{
new Point3D(0, 0, 10),
new Point3D(20, 0, 10)
});
surfaceLine.SetDikeToeAtRiverAt(surfaceLine.Points.ElementAt(0));
surfaceLine.SetDikeToeAtPolderAt(surfaceLine.Points.ElementAt(0));
surfaceLine.SetDitchDikeSideAt(surfaceLine.Points.ElementAt(0));
surfaceLine.SetBottomDitchPolderSideAt(surfaceLine.Points.ElementAt(1));
surfaceLine.SetBottomDitchDikeSideAt(surfaceLine.Points.ElementAt(1));
surfaceLine.SetDitchPolderSideAt(surfaceLine.Points.ElementAt(1));
var stochasticSoilProfile = new PipingStochasticSoilProfile(
0.0, new PipingSoilProfile(string.Empty, 0, new[]
{
new PipingSoilLayer(5)
{
IsAquifer = true
},
new PipingSoilLayer(20)
{
IsAquifer = false
}
}, SoilProfileType.SoilProfile1D));
var input = new TestPipingInput
{
ExitPointL = (RoundedDouble)10,
SurfaceLine = surfaceLine,
StochasticSoilProfile = stochasticSoilProfile
};
var generalInput = new GeneralPipingInput();
// Call
double thickness = InputParameterCalculationService.CalculateEffectiveThicknessCoverageLayer(
generalInput.WaterVolumetricWeight,
PipingDesignVariableFactory.GetPhreaticLevelExit(input).GetDesignValue(),
input.ExitPointL,
input.SurfaceLine,
input.StochasticSoilProfile.SoilProfile);
// Assert
Assert.AreEqual(5, thickness);
}
public void CreateEntryPointPoint_EntryPointNaN_ReturnsEmptyPointsArray()
{
// Setup
var pipingInput = new TestPipingInput
{
SurfaceLine = GetSurfaceLineWithGeometry(),
EntryPointL = RoundedDouble.NaN
};
// Call
Point2D[] points = PipingChartDataPointsFactory.CreateEntryPointPoint(pipingInput);
// Assert
CollectionAssert.IsEmpty(points);
}
public void SetMatchingStochasticSoilModel_SurfaceLineOverlappingSingleSoilModel_SetsSoilModel()
{
// Setup
PipingStochasticSoilModel soilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel();
var pipingInput = new TestPipingInput();
// Call
PipingInputService.SetMatchingStochasticSoilModel(pipingInput, new[]
{
soilModel
});
// Assert
Assert.AreSame(soilModel, pipingInput.StochasticSoilModel);
}
public void CreateEntryPointPoint_SurfaceLineNull_ReturnsEmptyPointsArray()
{
// Setup
var pipingInput = new TestPipingInput
{
SurfaceLine = null,
EntryPointL = (RoundedDouble)10.0
};
// Call
Point2D[] points = PipingChartDataPointsFactory.CreateEntryPointPoint(pipingInput);
// Assert
CollectionAssert.IsEmpty(points);
}
public void EntryPointL_EntryPointEqualOrGreaterThanExitPoint_ThrowsArgumentOutOfRangeException(double value)
{
// Setup
var pipingInput = new TestPipingInput
{
ExitPointL = (RoundedDouble)3.5
};
// Call
void Call() => pipingInput.EntryPointL = (RoundedDouble)value;
// Assert
const string expectedMessage = "Het uittredepunt moet landwaarts van het intredepunt liggen.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(Call, expectedMessage);
}
public void SynchronizeEntryAndExitPointInput_SurfaceLineNull_EntryPointLAndExitPointLNaN()
{
// Setup
var input = new TestPipingInput
{
EntryPointL = (RoundedDouble)3,
ExitPointL = (RoundedDouble)5
};
// Call
input.SynchronizeEntryAndExitPointInput();
// Assert
Assert.IsNaN(input.EntryPointL);
Assert.IsNaN(input.ExitPointL);
}
public void SetMatchingStochasticSoilModel_SurfaceLineOverlappingMultipleSoilModels_DoesNotSetModel()
{
// Setup
var pipingInput = new TestPipingInput();
PipingStochasticSoilModel soilModel1 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("A");
PipingStochasticSoilModel soilModel2 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("C");
// Call
PipingInputService.SetMatchingStochasticSoilModel(pipingInput, new[]
{
soilModel1,
soilModel2
});
// Assert
Assert.IsNull(pipingInput.StochasticSoilModel);
}
public void Clone_NotAllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
var original = new TestPipingInput();
PipingTestDataGenerator.SetRandomDataToPipingInput(original);
original.SurfaceLine = null;
original.StochasticSoilModel = null;
original.StochasticSoilProfile = null;
original.HydraulicBoundaryLocation = null;
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, PipingCloneAssert.AreClones);
}
public void CreateExitPointPoint_GivenPipingInput_ReturnsExitPointPointsArray()
{
// Setup
var pipingInput = new TestPipingInput
{
SurfaceLine = GetSurfaceLineWithGeometry()
};
// Call
Point2D[] points = PipingChartDataPointsFactory.CreateExitPointPoint(pipingInput);
// Assert
var exitPointOnLine = new Point2D(pipingInput.ExitPointL, pipingInput.SurfaceLine.GetZAtL(pipingInput.ExitPointL));
AssertEqualPointCollections(new[]
{
exitPointOnLine
}, points);
}
public void SyncStochasticSoilProfileWithStochasticSoilModel_MultipleStochasticSoilProfilesInStochasticSoilModel_DoesNotSetStochasticSoilProfile()
{
// Setup
PipingStochasticSoilModel soilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(new[]
{
new PipingStochasticSoilProfile(0.0, PipingSoilProfileTestFactory.CreatePipingSoilProfile()),
new PipingStochasticSoilProfile(1.0, PipingSoilProfileTestFactory.CreatePipingSoilProfile())
});
var pipingInput = new TestPipingInput
{
StochasticSoilModel = soilModel
};
// Call
PipingInputService.SyncStochasticSoilProfileWithStochasticSoilModel(pipingInput);
// Assert
Assert.IsNull(pipingInput.StochasticSoilProfile);
}
public void SyncStochasticSoilProfileWithStochasticSoilModel_SingleStochasticSoilProfileInSoilModelAlreadySet_StochasticSoilProfileDoesNotChange()
{
// Setup
var soilProfile = new PipingStochasticSoilProfile(0.3, PipingSoilProfileTestFactory.CreatePipingSoilProfile());
PipingStochasticSoilModel soilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(new[]
{
soilProfile
});
var pipingInput = new TestPipingInput
{
StochasticSoilModel = soilModel,
StochasticSoilProfile = soilProfile
};
// Call
PipingInputService.SyncStochasticSoilProfileWithStochasticSoilModel(pipingInput);
// Assert
Assert.AreEqual(soilProfile, pipingInput.StochasticSoilProfile);
}
public void SyncStochasticSoilProfileWithStochasticSoilModel_SingleStochasticSoilProfileInStochasticSoilModel_SetsStochasticSoilProfile()
{
// Setup
var soilProfile = new PipingStochasticSoilProfile(1, PipingSoilProfileTestFactory.CreatePipingSoilProfile());
PipingStochasticSoilModel soilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("A", new[]
{
soilProfile
});
var pipingInput = new TestPipingInput
{
StochasticSoilModel = soilModel
};
// Call
PipingInputService.SyncStochasticSoilProfileWithStochasticSoilModel(pipingInput);
// Assert
Assert.AreSame(soilProfile, pipingInput.StochasticSoilProfile);
}
