public void Read_EntityWithOutput_ReturnsCalculationScenarioWithOutput()
{
// Setup
var random = new Random(31);
var tangentLines = new RoundedDouble[0];
var slices = new MacroStabilityInwardsSlice[0];
var calculationOutputEntity = new MacroStabilityInwardsCalculationOutputEntity
{
SlipPlaneTangentLinesXml = new TangentLineCollectionXmlSerializer().ToXml(tangentLines),
SlidingCurveSliceXML = new MacroStabilityInwardsSliceCollectionXmlSerializer().ToXml(slices),
SlipPlaneLeftGridNrOfHorizontalPoints = random.Next(1, 100),
SlipPlaneLeftGridNrOfVerticalPoints = random.Next(1, 100),
SlipPlaneRightGridNrOfHorizontalPoints = random.Next(1, 100),
SlipPlaneRightGridNrOfVerticalPoints = random.Next(1, 100)
};
MacroStabilityInwardsCalculationEntity entity = CreateValidCalculationEntity();
entity.MacroStabilityInwardsCalculationOutputEntities.Add(calculationOutputEntity);
var collector = new ReadConversionCollector();
// Call
MacroStabilityInwardsCalculationScenario calculation = entity.Read(collector);
// Assert
MacroStabilityInwardsOutput output = calculation.Output;
Assert.IsNotNull(output);
MacroStabilityInwardsCalculationOutputEntityTestHelper.AssertOutputPropertyValues(output, calculationOutputEntity);
}
/// <summary>
/// Creates a new instance of <see cref="MacroStabilityInwardsSliceRow"/>.
/// </summary>
/// <param name="slice">The <see cref="MacroStabilityInwardsSlice"/> to use.</param>
/// <param name="index">The index of the slice.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="slice"/>
/// is <c>null</c>.</exception>
public MacroStabilityInwardsSliceRow(MacroStabilityInwardsSlice slice, int index)
{
if (slice == null)
{
throw new ArgumentNullException(nameof(slice));
}
Name = string.Format(Resources.MacroStabilityInwardsSlicesTable_Name_Slice_0, index);
XCenter = slice.XCenter;
ZCenterBottom = slice.ZCenterBottom;
Width = slice.Width;
ArcLength = slice.ArcLength;
BottomAngle = slice.BottomAngle;
TopAngle = slice.TopAngle;
FrictionAngle = slice.FrictionAngle;
Cohesion = slice.Cohesion;
EffectiveStress = slice.EffectiveStress;
TotalPorePressure = slice.TotalPorePressure;
Weight = slice.Weight;
PiezometricPorePressure = slice.PiezometricPorePressure;
PorePressure = slice.PorePressure;
VerticalPorePressure = slice.VerticalPorePressure;
HorizontalPorePressure = slice.HorizontalPorePressure;
OverConsolidationRatio = slice.OverConsolidationRatio;
Pop = slice.Pop;
NormalStress = slice.NormalStress;
ShearStress = slice.ShearStress;
LoadStress = slice.LoadStress;
}
public void Constructor_WithSlice_ExpectedValues()
{
// Setup
var slice = new MacroStabilityInwardsSlice(
new Point2D(0, 10),
new Point2D(10, 8),
new Point2D(0, 2),
new Point2D(10, 1),
new MacroStabilityInwardsSlice.ConstructionProperties
{
Cohesion = double.NaN,
FrictionAngle = 2.0,
EffectiveStress = 3.0,
TotalPorePressure = 4.0,
Weight = 5.0,
PiezometricPorePressure = 6.0,
DegreeOfConsolidationPorePressureSoil = 7.0,
DegreeOfConsolidationPorePressureLoad = 8.0,
PorePressure = 9.0,
VerticalPorePressure = 10.0,
HorizontalPorePressure = 11.0,
ExternalLoad = 12.0,
OverConsolidationRatio = 13.0,
Pop = 14.0,
NormalStress = 15.0,
ShearStress = 16.0,
LoadStress = 17.0
});
// Call
var sliceRow = new MacroStabilityInwardsSliceRow(slice, 3);
// Assert
Assert.AreEqual("Lamel 3", sliceRow.Name);
Assert.AreEqual(5.0, sliceRow.XCenter, sliceRow.XCenter.GetAccuracy());
Assert.AreEqual(1.5, sliceRow.ZCenterBottom, sliceRow.ZCenterBottom.GetAccuracy());
Assert.AreEqual(10.0, sliceRow.Width, sliceRow.Width.GetAccuracy());
Assert.AreEqual(10.05, sliceRow.ArcLength, sliceRow.ArcLength.GetAccuracy());
Assert.AreEqual(-5.71, sliceRow.BottomAngle, sliceRow.BottomAngle.GetAccuracy());
Assert.AreEqual(-11.31, sliceRow.TopAngle, sliceRow.TopAngle.GetAccuracy());
Assert.AreEqual(2.0, sliceRow.FrictionAngle, sliceRow.FrictionAngle.GetAccuracy());
Assert.AreEqual(double.NaN, sliceRow.Cohesion, sliceRow.Cohesion.GetAccuracy());
Assert.AreEqual(3.0, sliceRow.EffectiveStress, sliceRow.EffectiveStress.GetAccuracy());
Assert.AreEqual(4.0, sliceRow.TotalPorePressure, sliceRow.TotalPorePressure.GetAccuracy());
Assert.AreEqual(5.0, sliceRow.Weight, sliceRow.Weight.GetAccuracy());
Assert.AreEqual(6.0, sliceRow.PiezometricPorePressure, sliceRow.PiezometricPorePressure.GetAccuracy());
Assert.AreEqual(9.0, sliceRow.PorePressure, sliceRow.PorePressure.GetAccuracy());
Assert.AreEqual(10.0, sliceRow.VerticalPorePressure, sliceRow.VerticalPorePressure.GetAccuracy());
Assert.AreEqual(11.0, sliceRow.HorizontalPorePressure, sliceRow.HorizontalPorePressure.GetAccuracy());
Assert.AreEqual(13.0, sliceRow.OverConsolidationRatio, sliceRow.OverConsolidationRatio.GetAccuracy());
Assert.AreEqual(14.0, sliceRow.Pop, sliceRow.Pop.GetAccuracy());
Assert.AreEqual(15.0, sliceRow.NormalStress, sliceRow.NormalStress.GetAccuracy());
Assert.AreEqual(16.0, sliceRow.ShearStress, sliceRow.ShearStress.GetAccuracy());
Assert.AreEqual(17.0, sliceRow.LoadStress, sliceRow.LoadStress.GetAccuracy());
}
public void Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
var random = new Random(21);
var properties = new MacroStabilityInwardsSlice.ConstructionProperties
{
Cohesion = random.NextDouble(),
FrictionAngle = random.NextDouble(),
CriticalPressure = random.NextDouble(),
OverConsolidationRatio = random.NextDouble(),
DegreeOfConsolidationPorePressureSoil = random.NextDouble(),
DegreeOfConsolidationPorePressureLoad = random.NextDouble(),
Pop = random.NextDouble(),
Dilatancy = random.NextDouble(),
ExternalLoad = random.NextDouble(),
HydrostaticPorePressure = random.NextDouble(),
LeftForce = random.NextDouble(),
LeftForceAngle = random.NextDouble(),
LeftForceY = random.NextDouble(),
RightForce = random.NextDouble(),
RightForceAngle = random.NextDouble(),
RightForceY = random.NextDouble(),
LoadStress = random.NextDouble(),
NormalStress = random.NextDouble(),
PorePressure = random.NextDouble(),
HorizontalPorePressure = random.NextDouble(),
VerticalPorePressure = random.NextDouble(),
PiezometricPorePressure = random.NextDouble(),
EffectiveStress = random.NextDouble(),
ExcessPorePressure = random.NextDouble(),
ShearStress = random.NextDouble(),
SoilStress = random.NextDouble(),
TotalPorePressure = random.NextDouble(),
TotalStress = random.NextDouble(),
Weight = random.NextDouble()
};
var original = new MacroStabilityInwardsSlice(CreateRandomPoint(random),
CreateRandomPoint(random),
CreateRandomPoint(random),
CreateRandomPoint(random),
properties);
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, MacroStabilityInwardsCloneAssert.AreClones);
}
/// <summary>
/// Asserts whether <paramref name="actual"/> corresponds to <paramref name="slices"/>.
/// </summary>
/// <param name="slices">The original slices.</param>
/// <param name="actual">The actual <see cref="ChartMultipleAreaData"/>.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="actual"/>
/// does not correspond to <paramref name="slices"/>.</exception>
private static void AssertSlicesChartData(IEnumerable <MacroStabilityInwardsSlice> slices, ChartMultipleAreaData actual)
{
MacroStabilityInwardsSlice[] macroStabilityInwardsSlices = slices.ToArray();
CollectionAssert.IsNotEmpty(macroStabilityInwardsSlices);
for (var i = 0; i < macroStabilityInwardsSlices.Length; i++)
{
MacroStabilityInwardsSlice slice = macroStabilityInwardsSlices[i];
Point2D[] expectedPoints =
{
slice.TopLeftPoint,
slice.TopRightPoint,
slice.BottomRightPoint,
slice.BottomLeftPoint
};
CollectionAssert.AreEqual(expectedPoints, actual.Areas.ElementAt(i));
}
}
/// <summary>
/// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
/// are clones.
/// </summary>
/// <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(MacroStabilityInwardsSlice original,
MacroStabilityInwardsSlice clone)
{
CoreCloneAssert.AreObjectClones(original.TopLeftPoint, clone.TopLeftPoint, GeometryCloneAssert.AreClones);
CoreCloneAssert.AreObjectClones(original.TopRightPoint, clone.TopRightPoint, GeometryCloneAssert.AreClones);
CoreCloneAssert.AreObjectClones(original.BottomLeftPoint, clone.BottomLeftPoint, GeometryCloneAssert.AreClones);
CoreCloneAssert.AreObjectClones(original.BottomRightPoint, clone.BottomRightPoint, GeometryCloneAssert.AreClones);
Assert.AreEqual(original.XCenter, clone.XCenter);
Assert.AreEqual(original.ZCenterBottom, clone.ZCenterBottom);
Assert.AreEqual(original.Width, clone.Width);
Assert.AreEqual(original.ArcLength, clone.ArcLength);
Assert.AreEqual(original.BottomAngle, clone.BottomAngle);
Assert.AreEqual(original.TopAngle, clone.TopAngle);
Assert.AreEqual(original.Cohesion, clone.Cohesion);
Assert.AreEqual(original.FrictionAngle, clone.FrictionAngle);
Assert.AreEqual(original.CriticalPressure, clone.CriticalPressure);
Assert.AreEqual(original.OverConsolidationRatio, clone.OverConsolidationRatio);
Assert.AreEqual(original.Pop, clone.Pop);
Assert.AreEqual(original.DegreeOfConsolidationPorePressureSoil, clone.DegreeOfConsolidationPorePressureSoil);
Assert.AreEqual(original.DegreeOfConsolidationPorePressureLoad, clone.DegreeOfConsolidationPorePressureLoad);
Assert.AreEqual(original.Dilatancy, clone.Dilatancy);
Assert.AreEqual(original.ExternalLoad, clone.ExternalLoad);
Assert.AreEqual(original.HydrostaticPorePressure, clone.HydrostaticPorePressure);
Assert.AreEqual(original.LeftForce, clone.LeftForce);
Assert.AreEqual(original.LeftForceAngle, clone.LeftForceAngle);
Assert.AreEqual(original.LeftForceY, clone.LeftForceY);
Assert.AreEqual(original.RightForce, clone.RightForce);
Assert.AreEqual(original.RightForceAngle, clone.RightForceAngle);
Assert.AreEqual(original.RightForceY, clone.RightForceY);
Assert.AreEqual(original.LoadStress, clone.LoadStress);
Assert.AreEqual(original.NormalStress, clone.NormalStress);
Assert.AreEqual(original.PorePressure, clone.PorePressure);
Assert.AreEqual(original.HorizontalPorePressure, clone.HorizontalPorePressure);
Assert.AreEqual(original.VerticalPorePressure, clone.VerticalPorePressure);
Assert.AreEqual(original.PiezometricPorePressure, clone.PiezometricPorePressure);
Assert.AreEqual(original.EffectiveStress, clone.EffectiveStress);
Assert.AreEqual(original.ExcessPorePressure, clone.ExcessPorePressure);
Assert.AreEqual(original.ShearStress, clone.ShearStress);
Assert.AreEqual(original.SoilStress, clone.SoilStress);
Assert.AreEqual(original.TotalPorePressure, clone.TotalPorePressure);
Assert.AreEqual(original.TotalStress, clone.TotalStress);
Assert.AreEqual(original.Weight, clone.Weight);
}
/// <summary>
/// Creates a new instance of <see cref="SerializableMacroStabilityInwardsSlice"/>.
/// </summary>
/// <param name="slice">The <see cref="MacroStabilityInwardsSlice"/> to base the
/// <see cref="SerializableMacroStabilityInwardsSlice"/> on.</param>
public SerializableMacroStabilityInwardsSlice(MacroStabilityInwardsSlice slice)
{
topLeftPointX = slice.TopLeftPoint.X;
topLeftPointY = slice.TopLeftPoint.Y;
topRightPointX = slice.TopRightPoint.X;
topRightPointY = slice.TopRightPoint.Y;
bottomLeftPointX = slice.BottomLeftPoint.X;
bottomLeftPointY = slice.BottomLeftPoint.Y;
bottomRightPointX = slice.BottomRightPoint.X;
bottomRightPointY = slice.BottomRightPoint.Y;
cohesion = slice.Cohesion;
frictionAngle = slice.FrictionAngle;
criticalPressure = slice.CriticalPressure;
overConsolidationRatio = slice.OverConsolidationRatio;
pop = slice.Pop;
degreeOfConsolidationPorePressureSoil = slice.DegreeOfConsolidationPorePressureSoil;
degreeOfConsolidationPorePressureLoad = slice.DegreeOfConsolidationPorePressureLoad;
dilatancy = slice.Dilatancy;
externalLoad = slice.ExternalLoad;
hydrostaticPorePressure = slice.HydrostaticPorePressure;
leftForce = slice.LeftForce;
leftForceAngle = slice.LeftForceAngle;
leftForceY = slice.LeftForceY;
rightForce = slice.RightForce;
rightForceAngle = slice.RightForceAngle;
rightForceY = slice.RightForceY;
loadStress = slice.LoadStress;
normalStress = slice.NormalStress;
porePressure = slice.PorePressure;
horizontalPorePressure = slice.HorizontalPorePressure;
verticalPorePressure = slice.VerticalPorePressure;
piezometricPorePressure = slice.PiezometricPorePressure;
effectiveStress = slice.EffectiveStress;
excessPorePressure = slice.ExcessPorePressure;
shearStress = slice.ShearStress;
soilStress = slice.SoilStress;
totalPorePressure = slice.TotalPorePressure;
totalStress = slice.TotalStress;
weight = slice.Weight;
}
public void Constructor_WithCoordinates_ExpectedValues()
{
// Setup
var topLeftPoint = new Point2D(0, 5);
var topRightPoint = new Point2D(5, 4);
var bottomLeftPoint = new Point2D(0, 0);
var bottomRightPoint = new Point2D(5, 1);
// Call
var slice = new MacroStabilityInwardsSlice(topLeftPoint, topRightPoint, bottomLeftPoint, bottomRightPoint,
new MacroStabilityInwardsSlice.ConstructionProperties());
// Assert
Assert.IsInstanceOf <ICloneable>(slice);
Assert.AreSame(topLeftPoint, slice.TopLeftPoint);
Assert.AreSame(topRightPoint, slice.TopRightPoint);
Assert.AreSame(bottomLeftPoint, slice.BottomLeftPoint);
Assert.AreSame(bottomRightPoint, slice.BottomRightPoint);
Assert.AreEqual(2, slice.XCenter.NumberOfDecimalPlaces);
Assert.AreEqual(2.5, slice.XCenter, slice.XCenter.GetAccuracy());
Assert.AreEqual(2, slice.ZCenterBottom.NumberOfDecimalPlaces);
Assert.AreEqual(0.5, slice.ZCenterBottom, slice.ZCenterBottom.GetAccuracy());
Assert.AreEqual(2, slice.Width.NumberOfDecimalPlaces);
Assert.AreEqual(5.0, slice.Width, slice.Width.GetAccuracy());
Assert.AreEqual(2, slice.ArcLength.NumberOfDecimalPlaces);
Assert.AreEqual(5.1, slice.ArcLength, slice.ArcLength.GetAccuracy());
Assert.AreEqual(2, slice.BottomAngle.NumberOfDecimalPlaces);
Assert.AreEqual(11.31, slice.BottomAngle, slice.BottomAngle.GetAccuracy());
Assert.AreEqual(2, slice.TopAngle.NumberOfDecimalPlaces);
Assert.AreEqual(-11.31, slice.TopAngle, slice.TopAngle.GetAccuracy());
}
public void Constructor_ConstructionPropertiesEmpty_ExpectedValues()
{
// Call
var slice = new MacroStabilityInwardsSlice(new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0),
new MacroStabilityInwardsSlice.ConstructionProperties());
// Assert
Assert.IsNaN(slice.Cohesion);
Assert.IsNaN(slice.FrictionAngle);
Assert.IsNaN(slice.CriticalPressure);
Assert.IsNaN(slice.OverConsolidationRatio);
Assert.IsNaN(slice.Pop);
Assert.IsNaN(slice.DegreeOfConsolidationPorePressureSoil);
Assert.IsNaN(slice.DegreeOfConsolidationPorePressureLoad);
Assert.IsNaN(slice.Dilatancy);
Assert.IsNaN(slice.ExternalLoad);
Assert.IsNaN(slice.HydrostaticPorePressure);
Assert.IsNaN(slice.LeftForce);
Assert.IsNaN(slice.LeftForceAngle);
Assert.IsNaN(slice.LeftForceY);
Assert.IsNaN(slice.RightForce);
Assert.IsNaN(slice.RightForceAngle);
Assert.IsNaN(slice.RightForceY);
Assert.IsNaN(slice.LoadStress);
Assert.IsNaN(slice.NormalStress);
Assert.IsNaN(slice.PorePressure);
Assert.IsNaN(slice.HorizontalPorePressure);
Assert.IsNaN(slice.VerticalPorePressure);
Assert.IsNaN(slice.PiezometricPorePressure);
Assert.IsNaN(slice.EffectiveStress);
Assert.IsNaN(slice.ExcessPorePressure);
Assert.IsNaN(slice.ShearStress);
Assert.IsNaN(slice.SoilStress);
Assert.IsNaN(slice.TotalPorePressure);
Assert.IsNaN(slice.TotalStress);
Assert.IsNaN(slice.Weight);
}
public void Constructor_ConstructionPropertiesSet_ExpectedValues()
{
// Setup
var random = new Random(21);
double cohesion = random.NextDouble();
double frictionAngle = random.NextDouble();
double criticalPressure = random.NextDouble();
double overConsolidationRatio = random.NextDouble();
double pop = random.NextDouble();
double degreeOfConsolidationPorePressureSoil = random.NextDouble();
double degreeOfConsolidationPorePressureLoad = random.NextDouble();
double dilatancy = random.NextDouble();
double externalLoad = random.NextDouble();
double hydrostaticPorePressure = random.NextDouble();
double leftForce = random.NextDouble();
double leftForceAngle = random.NextDouble();
double leftForceY = random.NextDouble();
double rightForce = random.NextDouble();
double rightForceAngle = random.NextDouble();
double rightForceY = random.NextDouble();
double loadStress = random.NextDouble();
double normalStress = random.NextDouble();
double porePressure = random.NextDouble();
double horizontalPorePressure = random.NextDouble();
double verticalPorePressure = random.NextDouble();
double piezometricPorePressure = random.NextDouble();
double effectiveStress = random.NextDouble();
double excessPorePressure = random.NextDouble();
double shearStress = random.NextDouble();
double soilStress = random.NextDouble();
double totalPorePressure = random.NextDouble();
double totalStress = random.NextDouble();
double weight = random.NextDouble();
var properties = new MacroStabilityInwardsSlice.ConstructionProperties
{
Cohesion = cohesion,
FrictionAngle = frictionAngle,
CriticalPressure = criticalPressure,
OverConsolidationRatio = overConsolidationRatio,
DegreeOfConsolidationPorePressureSoil = degreeOfConsolidationPorePressureSoil,
DegreeOfConsolidationPorePressureLoad = degreeOfConsolidationPorePressureLoad,
Pop = pop,
Dilatancy = dilatancy,
ExternalLoad = externalLoad,
HydrostaticPorePressure = hydrostaticPorePressure,
LeftForce = leftForce,
LeftForceAngle = leftForceAngle,
LeftForceY = leftForceY,
RightForce = rightForce,
RightForceAngle = rightForceAngle,
RightForceY = rightForceY,
LoadStress = loadStress,
NormalStress = normalStress,
PorePressure = porePressure,
HorizontalPorePressure = horizontalPorePressure,
VerticalPorePressure = verticalPorePressure,
PiezometricPorePressure = piezometricPorePressure,
EffectiveStress = effectiveStress,
ExcessPorePressure = excessPorePressure,
ShearStress = shearStress,
SoilStress = soilStress,
TotalPorePressure = totalPorePressure,
TotalStress = totalStress,
Weight = weight
};
// Call
var slice = new MacroStabilityInwardsSlice(new Point2D(0, 0), new Point2D(0, 0),
new Point2D(0, 0), new Point2D(0, 0),
properties);
// Assert
Assert.AreEqual(3, slice.Cohesion.NumberOfDecimalPlaces);
Assert.AreEqual(cohesion, slice.Cohesion, slice.Cohesion.GetAccuracy());
Assert.AreEqual(3, slice.FrictionAngle.NumberOfDecimalPlaces);
Assert.AreEqual(frictionAngle, slice.FrictionAngle, slice.FrictionAngle.GetAccuracy());
Assert.AreEqual(3, slice.CriticalPressure.NumberOfDecimalPlaces);
Assert.AreEqual(criticalPressure, slice.CriticalPressure, slice.CriticalPressure.GetAccuracy());
Assert.AreEqual(3, slice.OverConsolidationRatio.NumberOfDecimalPlaces);
Assert.AreEqual(overConsolidationRatio, slice.OverConsolidationRatio, slice.OverConsolidationRatio.GetAccuracy());
Assert.AreEqual(3, slice.Pop.NumberOfDecimalPlaces);
Assert.AreEqual(pop, slice.Pop, slice.Pop.GetAccuracy());
Assert.AreEqual(3, slice.DegreeOfConsolidationPorePressureSoil.NumberOfDecimalPlaces);
Assert.AreEqual(degreeOfConsolidationPorePressureSoil, slice.DegreeOfConsolidationPorePressureSoil, slice.DegreeOfConsolidationPorePressureSoil.GetAccuracy());
Assert.AreEqual(3, slice.DegreeOfConsolidationPorePressureLoad.NumberOfDecimalPlaces);
Assert.AreEqual(degreeOfConsolidationPorePressureLoad, slice.DegreeOfConsolidationPorePressureLoad, slice.DegreeOfConsolidationPorePressureLoad.GetAccuracy());
Assert.AreEqual(3, slice.Dilatancy.NumberOfDecimalPlaces);
Assert.AreEqual(dilatancy, slice.Dilatancy, slice.Dilatancy.GetAccuracy());
Assert.AreEqual(3, slice.ExternalLoad.NumberOfDecimalPlaces);
Assert.AreEqual(externalLoad, slice.ExternalLoad, slice.ExternalLoad.GetAccuracy());
Assert.AreEqual(3, slice.HydrostaticPorePressure.NumberOfDecimalPlaces);
Assert.AreEqual(hydrostaticPorePressure, slice.HydrostaticPorePressure, slice.HydrostaticPorePressure.GetAccuracy());
Assert.AreEqual(3, slice.LeftForce.NumberOfDecimalPlaces);
Assert.AreEqual(leftForce, slice.LeftForce, slice.LeftForce.GetAccuracy());
Assert.AreEqual(3, slice.LeftForceAngle.NumberOfDecimalPlaces);
Assert.AreEqual(leftForceAngle, slice.LeftForceAngle, slice.LeftForceAngle.GetAccuracy());
Assert.AreEqual(3, slice.LeftForceY.NumberOfDecimalPlaces);
Assert.AreEqual(leftForceY, slice.LeftForceY, slice.LeftForceY.GetAccuracy());
Assert.AreEqual(3, slice.RightForce.NumberOfDecimalPlaces);
Assert.AreEqual(rightForce, slice.RightForce, slice.RightForce.GetAccuracy());
Assert.AreEqual(3, slice.RightForceAngle.NumberOfDecimalPlaces);
Assert.AreEqual(rightForceAngle, slice.RightForceAngle, slice.RightForceAngle.GetAccuracy());
Assert.AreEqual(3, slice.RightForceY.NumberOfDecimalPlaces);
Assert.AreEqual(rightForceY, slice.RightForceY, slice.RightForceY.GetAccuracy());
Assert.AreEqual(3, slice.LoadStress.NumberOfDecimalPlaces);
Assert.AreEqual(loadStress, slice.LoadStress, slice.LoadStress.GetAccuracy());
Assert.AreEqual(3, slice.NormalStress.NumberOfDecimalPlaces);
Assert.AreEqual(normalStress, slice.NormalStress, slice.NormalStress.GetAccuracy());
Assert.AreEqual(3, slice.PorePressure.NumberOfDecimalPlaces);
Assert.AreEqual(porePressure, slice.PorePressure, slice.PorePressure.GetAccuracy());
Assert.AreEqual(3, slice.HorizontalPorePressure.NumberOfDecimalPlaces);
Assert.AreEqual(horizontalPorePressure, slice.HorizontalPorePressure, slice.HorizontalPorePressure.GetAccuracy());
Assert.AreEqual(3, slice.VerticalPorePressure.NumberOfDecimalPlaces);
Assert.AreEqual(verticalPorePressure, slice.VerticalPorePressure, slice.VerticalPorePressure.GetAccuracy());
Assert.AreEqual(3, slice.PiezometricPorePressure.NumberOfDecimalPlaces);
Assert.AreEqual(piezometricPorePressure, slice.PiezometricPorePressure, slice.PiezometricPorePressure.GetAccuracy());
Assert.AreEqual(3, slice.EffectiveStress.NumberOfDecimalPlaces);
Assert.AreEqual(effectiveStress, slice.EffectiveStress, slice.EffectiveStress.GetAccuracy());
Assert.AreEqual(3, slice.ExcessPorePressure.NumberOfDecimalPlaces);
Assert.AreEqual(excessPorePressure, slice.ExcessPorePressure, slice.ExcessPorePressure.GetAccuracy());
Assert.AreEqual(3, slice.ShearStress.NumberOfDecimalPlaces);
Assert.AreEqual(shearStress, slice.ShearStress, slice.ShearStress.GetAccuracy());
Assert.AreEqual(3, slice.SoilStress.NumberOfDecimalPlaces);
Assert.AreEqual(soilStress, slice.SoilStress, slice.SoilStress.GetAccuracy());
Assert.AreEqual(3, slice.TotalPorePressure.NumberOfDecimalPlaces);
Assert.AreEqual(totalPorePressure, slice.TotalPorePressure, slice.TotalPorePressure.GetAccuracy());
Assert.AreEqual(3, slice.TotalStress.NumberOfDecimalPlaces);
Assert.AreEqual(totalStress, slice.TotalStress, slice.TotalStress.GetAccuracy());
Assert.AreEqual(3, slice.Weight.NumberOfDecimalPlaces);
Assert.AreEqual(weight, slice.Weight, slice.Weight.GetAccuracy());
}
public void SetData_WithData_ExpectedValuesInTable()
{
// Setup
using (var table = new MacroStabilityInwardsSlicesTable())
{
MacroStabilityInwardsSlice[] slices =
{
MacroStabilityInwardsSliceTestFactory.CreateSlice(),
MacroStabilityInwardsSliceTestFactory.CreateSlice(),
MacroStabilityInwardsSliceTestFactory.CreateSlice()
};
// Call
table.SetData(slices);
// Assert
Assert.AreEqual(slices.Length, table.Rows.Count);
for (var i = 0; i < table.Rows.Count; i++)
{
MacroStabilityInwardsSlice slice = slices[i];
DataGridViewCellCollection rowCells = table.Rows[i].Cells;
Assert.AreEqual("Lamel " + (i + 1),
rowCells[nameColumnIndex].Value);
var xCenter = (RoundedDouble)rowCells[xCenterColumnIndex].Value;
Assert.AreEqual((slice.TopLeftPoint.X + slice.TopRightPoint.X) / 2.0,
xCenter,
xCenter.GetAccuracy());
var zCenter = (RoundedDouble)rowCells[zCenterBottomColumnIndex].Value;
Assert.AreEqual(new Segment2D(slice.BottomLeftPoint, slice.BottomRightPoint).Interpolate(xCenter),
zCenter,
zCenter.GetAccuracy());
var width = (RoundedDouble)rowCells[widthColumnIndex].Value;
Assert.AreEqual(slice.TopRightPoint.X - slice.TopLeftPoint.X,
width,
width.GetAccuracy());
var arcLength = (RoundedDouble)rowCells[arcLengthColumnIndex].Value;
Assert.AreEqual(slice.BottomLeftPoint.GetEuclideanDistanceTo(slice.BottomRightPoint),
arcLength,
arcLength.GetAccuracy());
var bottomAngle = (RoundedDouble)rowCells[bottomAngleColumnIndex].Value;
Assert.AreEqual(Math2D.GetAngleBetween(slice.BottomLeftPoint, slice.BottomRightPoint),
bottomAngle,
bottomAngle.GetAccuracy());
var topAngle = (RoundedDouble)rowCells[topAngleColumnIndex].Value;
Assert.AreEqual(Math2D.GetAngleBetween(slice.TopLeftPoint, slice.TopRightPoint),
topAngle,
topAngle.GetAccuracy());
var frictionAngle = (RoundedDouble)rowCells[frictionAngleColumnIndex].Value;
Assert.AreEqual(slice.FrictionAngle,
frictionAngle,
frictionAngle.GetAccuracy());
var cohesion = (RoundedDouble)rowCells[cohesionColumnIndex].Value;
Assert.AreEqual(slice.Cohesion,
cohesion,
cohesion.GetAccuracy());
var effectiveStress = (RoundedDouble)rowCells[effectiveStressColumnIndex].Value;
Assert.AreEqual(slice.EffectiveStress,
effectiveStress,
effectiveStress.GetAccuracy());
var totalPorePressure = (RoundedDouble)rowCells[totalPorePressureColumnIndex].Value;
Assert.AreEqual(slice.TotalPorePressure,
totalPorePressure,
totalPorePressure.GetAccuracy());
var weight = (RoundedDouble)rowCells[weightColumnIndex].Value;
Assert.AreEqual(slice.Weight,
weight,
weight.GetAccuracy());
var piezometricPorePressure = (RoundedDouble)rowCells[piezometricPorePressureColumnIndex].Value;
Assert.AreEqual(slice.PiezometricPorePressure,
piezometricPorePressure,
piezometricPorePressure.GetAccuracy());
var porePressure = (RoundedDouble)rowCells[porePressureColumnIndex].Value;
Assert.AreEqual(slice.PorePressure,
porePressure,
porePressure.GetAccuracy());
var verticalPorePressure = (RoundedDouble)rowCells[verticalPorePressureColumnIndex].Value;
Assert.AreEqual(slice.VerticalPorePressure,
verticalPorePressure,
verticalPorePressure.GetAccuracy());
var horizontalPorePressure = (RoundedDouble)rowCells[horizontalPorePressureColumnIndex].Value;
Assert.AreEqual(slice.HorizontalPorePressure,
horizontalPorePressure,
horizontalPorePressure.GetAccuracy());
var ocr = (RoundedDouble)rowCells[overConsolidationRatioColumnIndex].Value;
Assert.AreEqual(slice.OverConsolidationRatio,
ocr,
ocr.GetAccuracy());
var pop = (RoundedDouble)rowCells[popColumnIndex].Value;
Assert.AreEqual(slice.Pop,
pop,
pop.GetAccuracy());
var normalStress = (RoundedDouble)rowCells[normalStressColumnIndex].Value;
Assert.AreEqual(slice.NormalStress,
normalStress,
normalStress.GetAccuracy());
var shearStress = (RoundedDouble)rowCells[shearStressColumnIndex].Value;
Assert.AreEqual(slice.ShearStress,
shearStress,
shearStress.GetAccuracy());
var loadStress = (RoundedDouble)rowCells[loadStressColumnIndex].Value;
Assert.AreEqual(slice.LoadStress,
loadStress,
loadStress.GetAccuracy());
}
}
}
