/// <summary>
/// Creates a <see cref="MacroStabilityInwardsSoilProfileTwoDEntity"/> based on the information
/// of the <see cref="MacroStabilityInwardsSoilProfile2D"/>.
/// </summary>
/// <param name="soilProfile">The soil profile to create a database entity for.</param>
/// <param name="registry">The object keeping track of create operations.</param>
/// <returns>A new <see cref="MacroStabilityInwardsSoilProfileTwoDEntity"/> or one from the
/// <paramref name="registry"/> if it was created for the <see cref="soilProfile"/> earlier.</returns>
/// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
public static MacroStabilityInwardsSoilProfileTwoDEntity Create(this MacroStabilityInwardsSoilProfile2D soilProfile,
PersistenceRegistry registry)
{
if (soilProfile == null)
{
throw new ArgumentNullException(nameof(soilProfile));
}
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
if (registry.Contains(soilProfile))
{
return(registry.Get(soilProfile));
}
var entity = new MacroStabilityInwardsSoilProfileTwoDEntity
{
Name = soilProfile.Name.DeepClone()
};
AddEntitiesForSoilLayers(soilProfile.Layers, entity);
AddEntitiesForPreconsolidationStresses(soilProfile.PreconsolidationStresses, entity);
registry.Register(entity, soilProfile);
return(entity);
}
public void Constructor_WithNameAndLayers_ReturnsInstanceWithPropsAndEquivalentLayerCollection()
{
// Setup
const string name = "Profile";
var layers = new Collection <MacroStabilityInwardsSoilLayer2D>
{
CreateRandomLayer(21)
};
MacroStabilityInwardsPreconsolidationStress[] preconsolidationStresses =
{
CreateRandomPreconsolidationStress(30)
};
// Call
var profile = new MacroStabilityInwardsSoilProfile2D(name, layers, preconsolidationStresses);
// Assert
Assert.IsInstanceOf <IMacroStabilityInwardsSoilProfile <MacroStabilityInwardsSoilLayer2D> >(profile);
Assert.AreNotSame(layers, profile.Layers);
TestHelper.AssertCollectionsAreEqual(layers, profile.Layers,
new ReferenceEqualityComparer <MacroStabilityInwardsSoilLayer2D>());
Assert.AreNotSame(preconsolidationStresses, profile.PreconsolidationStresses);
TestHelper.AssertCollectionsAreEqual(preconsolidationStresses, profile.PreconsolidationStresses,
new ReferenceEqualityComparer <MacroStabilityInwardsPreconsolidationStress>());
Assert.AreEqual(name, profile.Name);
}
private static bool ValidateSurfaceLineIsNearSoilProfile(MacroStabilityInwardsInput inputParameters,
MacroStabilityInwardsSoilProfile2D soilProfile2D)
{
IEnumerable <double> discretizedSurfaceLineXCoordinates = GetClippedDiscretizedXCoordinatesOfSurfaceLine(inputParameters.SurfaceLine.LocalGeometry,
soilProfile2D);
IEnumerable <Point2D> surfaceLineWithInterpolations = GetSurfaceLineWithInterpolations(inputParameters, discretizedSurfaceLineXCoordinates);
IEnumerable <IEnumerable <Segment2D> > layerPolygons = GetLayerPolygons(soilProfile2D);
foreach (Point2D surfaceLinePoint in surfaceLineWithInterpolations)
{
IEnumerable <Point2D> intersectingCoordinates = layerPolygons.SelectMany(lp => Math2D.SegmentsIntersectionWithVerticalLine(lp, surfaceLinePoint.X));
if (!intersectingCoordinates.Any())
{
return(false);
}
double maxYCoordinate = intersectingCoordinates.Select(p => p.Y).Max();
if (Math.Abs(surfaceLinePoint.Y - maxYCoordinate) - withinSurfaceLineLevelLimit >= 1e-5)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Reads the <see cref="MacroStabilityInwardsSoilProfileTwoDEntity"/> and use the information
/// to construct a <see cref="MacroStabilityInwardsSoilProfile2D"/>.
/// </summary>
/// <param name="entity">The <see cref="MacroStabilityInwardsSoilProfileTwoDEntity"/> to
/// create <see cref="MacroStabilityInwardsSoilProfile2D"/> for.</param>
/// <param name="collector">The object keeping track of read operations.</param>
/// <returns>A new <see cref="MacroStabilityInwardsSoilProfile2D"/> or one from the <paramref name="collector"/>
/// if the <see cref="MacroStabilityInwardsSoilProfileTwoDEntity"/> has been read before.</returns>
/// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
public static MacroStabilityInwardsSoilProfile2D Read(this MacroStabilityInwardsSoilProfileTwoDEntity entity,
ReadConversionCollector collector)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
if (collector.Contains(entity))
{
return(collector.Get(entity));
}
IEnumerable <MacroStabilityInwardsSoilLayer2D> layers = entity.MacroStabilityInwardsSoilLayerTwoDEntities
.OrderBy(sl => sl.Order)
.Select(sl => sl.Read())
.ToArray();
IEnumerable <MacroStabilityInwardsPreconsolidationStress> preconsolidationStresses = entity.MacroStabilityInwardsPreconsolidationStressEntities
.OrderBy(stressEntity => stressEntity.Order)
.Select(stressEntity => stressEntity.Read())
.ToArray();
var soilProfile = new MacroStabilityInwardsSoilProfile2D(entity.Name,
layers,
preconsolidationStresses);
collector.Read(entity, soilProfile);
return(soilProfile);
}
public void Validate_SurfaceLineNotNear2DProfile_ReturnsError(MacroStabilityInwardsSoilProfile2D soilProfile)
{
// Setup
var surfaceLine = new MacroStabilityInwardsSurfaceLine("Test");
surfaceLine.SetGeometry(new[]
{
new Point3D(0, 0.0, 10),
new Point3D(1, 0.0, 20),
new Point3D(2, 0.0, 10)
});
input.StochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(0.0,
soilProfile);
input.SurfaceLine = surfaceLine;
// Call
IEnumerable <string> messages = MacroStabilityInwardsInputValidator.Validate(input,
AssessmentSectionTestHelper.GetTestAssessmentLevel()).ToArray();
// Assert
CollectionAssert.AreEqual(new[]
{
"De profielschematisatie moet op de ondergrondschematisatie liggen."
}, messages);
}
public void Create_StringPropertiesDoNotShareReference()
{
// Setup
MacroStabilityInwardsSoilProfile2D soilProfile = CreateMacroStabilityInwardsSoilProfile2D("some name");
var registry = new PersistenceRegistry();
// Call
MacroStabilityInwardsSoilProfileTwoDEntity entity = soilProfile.Create(registry);
// Assert
TestHelper.AssertAreEqualButNotSame(soilProfile.Name, entity.Name);
}
public void Create_PersistenceRegistryNull_ThrowsArgumentNullException()
{
// Setup
MacroStabilityInwardsSoilProfile2D soilProfile = CreateMacroStabilityInwardsSoilProfile2D();
// Call
TestDelegate test = () => soilProfile.Create(null);
// Assert
string parameterName = Assert.Throws <ArgumentNullException>(test).ParamName;
Assert.AreEqual("registry", parameterName);
}
public void GivenCreatedEntity_WhenCreateCalledOnSameObject_ThenSameEntityInstanceReturned()
{
// Given
MacroStabilityInwardsSoilProfile2D soilProfile = CreateMacroStabilityInwardsSoilProfile2D();
var registry = new PersistenceRegistry();
MacroStabilityInwardsSoilProfileTwoDEntity firstEntity = soilProfile.Create(registry);
// When
MacroStabilityInwardsSoilProfileTwoDEntity secondEntity = soilProfile.Create(registry);
// Then
Assert.AreSame(firstEntity, secondEntity);
}
public void ToString_WithName_ReturnsName(string name)
{
// Setup
var profile = new MacroStabilityInwardsSoilProfile2D(name, new[]
{
CreateRandomLayer(2)
}, Enumerable.Empty <MacroStabilityInwardsPreconsolidationStress>());
// Call
var text = profile.ToString();
// Assert
Assert.AreEqual(name, text);
}
public void Validate_SurfaceLineNear2DProfileWithFloatingLayerDefinitions_ReturnsError()
{
// Setup
var surfaceLine = new MacroStabilityInwardsSurfaceLine("Test");
surfaceLine.SetGeometry(new[]
{
new Point3D(0, 0.0, 20),
new Point3D(20, 0.0, 20)
});
var soilProfile = new MacroStabilityInwardsSoilProfile2D(
"profile",
new[]
{
new MacroStabilityInwardsSoilLayer2D(new Ring(new[]
{
new Point2D(0, 20),
new Point2D(5, 20),
new Point2D(5, 15),
new Point2D(20, 15),
new Point2D(20, 10),
new Point2D(0, 10)
})),
new MacroStabilityInwardsSoilLayer2D(new Ring(new[]
{
new Point2D(10, 17),
new Point2D(10, 20),
new Point2D(20, 20),
new Point2D(20, 17)
}))
}, new MacroStabilityInwardsPreconsolidationStress[0]);
input.StochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(0.0,
soilProfile);
input.SurfaceLine = surfaceLine;
// Call
IEnumerable <string> messages = MacroStabilityInwardsInputValidator.Validate(input,
AssessmentSectionTestHelper.GetTestAssessmentLevel()).ToArray();
// Assert
CollectionAssert.AreEqual(new[]
{
"De profielschematisatie moet op de ondergrondschematisatie liggen."
}, messages);
}
public void SoilProfile2DCreate_ProfileWithData_ReturnsSoilProfileUnderSurfaceLine()
{
// Setup
var profile = new MacroStabilityInwardsSoilProfile2D("name",
new[]
{
MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D()
},
Enumerable.Empty <MacroStabilityInwardsPreconsolidationStress>());
// Call
MacroStabilityInwardsSoilProfileUnderSurfaceLine profileUnderSurfaceLine = MacroStabilityInwardsSoilProfileUnderSurfaceLineFactory.Create(profile, new MacroStabilityInwardsSurfaceLine(string.Empty));
// Assert
Assert.AreSame(profile.Layers, profileUnderSurfaceLine.Layers);
Assert.AreSame(profile.PreconsolidationStresses, profileUnderSurfaceLine.PreconsolidationStresses);
}
public void Validate_SurfaceLineNear2DProfileWithLayersWithTriangularXCoordinateDefinitions_ReturnsEmpty()
{
// Setup
var surfaceLine = new MacroStabilityInwardsSurfaceLine("Test");
surfaceLine.SetGeometry(new[]
{
new Point3D(0, 0.0, 10),
new Point3D(10, 0.0, 20),
new Point3D(20, 0.0, 10)
});
var soilProfile = new MacroStabilityInwardsSoilProfile2D(
"profile",
new[]
{
new MacroStabilityInwardsSoilLayer2D(new Ring(new[]
{
new Point2D(0, 10),
new Point2D(10, 20),
new Point2D(20, 10)
})),
new MacroStabilityInwardsSoilLayer2D(new Ring(new[]
{
new Point2D(0, 10),
new Point2D(5, 15),
new Point2D(7.5, 10),
new Point2D(12.5, 10),
new Point2D(15, 15),
new Point2D(20, 10)
}))
}, new MacroStabilityInwardsPreconsolidationStress[0]);
input.StochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(0.0,
soilProfile);
input.SurfaceLine = surfaceLine;
// Call
IEnumerable <string> messages = MacroStabilityInwardsInputValidator.Validate(input,
AssessmentSectionTestHelper.GetTestAssessmentLevel()).ToArray();
// Assert
CollectionAssert.IsEmpty(messages);
}
public void GetProperties_WithSoilProfile2D_ReturnExpectedValues()
{
// Setup
var random = new Random(21);
double probability = random.NextDouble();
MacroStabilityInwardsSoilLayer2D layerOne = CreateMacroStabilityInwardsSoilLayer2D();
MacroStabilityInwardsSoilLayer2D layerTwo = CreateMacroStabilityInwardsSoilLayer2D();
MacroStabilityInwardsSoilLayer2D[] layers =
{
layerOne,
layerTwo
};
MacroStabilityInwardsPreconsolidationStress[] stresses =
{
MacroStabilityInwardsPreconsolidationStressTestFactory.CreateMacroStabilityInwardsPreconsolidationStress()
};
var soilProfile = new MacroStabilityInwardsSoilProfile2D("<some name>", layers, stresses);
var stochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(probability, soilProfile);
// Call
var properties = new MacroStabilityInwardsStochasticSoilProfileProperties(stochasticSoilProfile);
// Assert
Assert.AreEqual(soilProfile.Name, properties.Name);
Assert.AreEqual(soilProfile.Name, properties.ToString());
Assert.AreEqual(layers.Length, properties.Layers2D.Length);
Assert.AreSame(layerOne, properties.Layers2D[0].Data);
Assert.AreSame(layerTwo, properties.Layers2D[1].Data);
CollectionAssert.IsEmpty(properties.Layers1D);
Assert.AreEqual(double.NaN, properties.Bottom);
Assert.AreEqual(2, properties.Probability.NumberOfDecimalPlaces);
Assert.AreEqual(probability * 100, properties.Probability, properties.Probability.GetAccuracy());
Assert.AreEqual("2D profiel", properties.Type);
Assert.AreEqual(stresses.Length, properties.PreconsolidationStresses.Length);
Assert.AreSame(stresses[0], properties.PreconsolidationStresses[0].Data);
}
public void Create_DifferentStochasticSoilProfilesWithSameMacroStabilityInwardsSoilProfile2D_ReturnsEntityWithSameSoilProfileEntitySet()
{
// Setup
var random = new Random(31);
MacroStabilityInwardsSoilProfile2D soilProfile = MacroStabilityInwardsSoilProfile2DTestFactory.CreateMacroStabilityInwardsSoilProfile2D();
var firstStochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(random.NextDouble(), soilProfile);
var secondStochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(random.NextDouble(), soilProfile);
var registry = new PersistenceRegistry();
MacroStabilityInwardsStochasticSoilProfileEntity firstEntity = firstStochasticSoilProfile.Create(registry, 0);
// Call
MacroStabilityInwardsStochasticSoilProfileEntity secondEntity = secondStochasticSoilProfile.Create(registry, 0);
// Assert
Assert.IsNull(firstEntity.MacroStabilityInwardsSoilProfileOneDEntity);
Assert.IsNull(secondEntity.MacroStabilityInwardsSoilProfileOneDEntity);
Assert.AreSame(firstEntity.MacroStabilityInwardsSoilProfileTwoDEntity, secondEntity.MacroStabilityInwardsSoilProfileTwoDEntity);
}
public void GivenReadObject_WhenReadCalledOnSameEntity_ThenSameObjectInstanceReturned()
{
// Given
var entity = new MacroStabilityInwardsSoilProfileTwoDEntity
{
Name = "testName",
MacroStabilityInwardsSoilLayerTwoDEntities =
{
MacroStabilityInwardsSoilLayerTwoDEntityTestFactory.CreateMacroStabilityInwardsSoilLayerTwoDEntity()
}
};
var collector = new ReadConversionCollector();
MacroStabilityInwardsSoilProfile2D profile = entity.Read(collector);
// When
MacroStabilityInwardsSoilProfile2D secondProfile = entity.Read(collector);
// Then
Assert.AreSame(profile, secondProfile);
}
public void Create_WithMacroStabilityInwardsSoilProfile2D_ReturnsStochasticSoilProfileEntityWithPropertiesSet()
{
// Setup
var random = new Random(31);
MacroStabilityInwardsSoilProfile2D soilProfile =
MacroStabilityInwardsSoilProfile2DTestFactory.CreateMacroStabilityInwardsSoilProfile2D();
var stochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(random.NextDouble(), soilProfile);
int order = random.Next();
var registry = new PersistenceRegistry();
// Call
MacroStabilityInwardsStochasticSoilProfileEntity entity = stochasticSoilProfile.Create(registry, order);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(stochasticSoilProfile.Probability, entity.Probability);
Assert.IsNull(entity.MacroStabilityInwardsSoilProfileOneDEntity);
Assert.AreEqual(soilProfile.Name, entity.MacroStabilityInwardsSoilProfileTwoDEntity.Name);
Assert.AreEqual(order, entity.Order);
}
public void Validate_SurfaceLineNear2DProfile_ReturnsEmpty(MacroStabilityInwardsSoilProfile2D soilProfile)
{
// Setup
var surfaceLine = new MacroStabilityInwardsSurfaceLine("Test");
surfaceLine.SetGeometry(new[]
{
new Point3D(0.0, 0.0, 10),
new Point3D(0.1, 0.0, 20),
new Point3D(0.2, 0.0, 10)
});
input.StochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(0.0,
soilProfile);
input.SurfaceLine = surfaceLine;
// Call
IEnumerable <string> messages = MacroStabilityInwardsInputValidator.Validate(input,
AssessmentSectionTestHelper.GetTestAssessmentLevel()).ToArray();
// Assert
CollectionAssert.IsEmpty(messages);
}
public void DynamicVisibleValidationMethod_WithSoilProfile2D_Only2DPropertiesVisible()
{
// Setup
IEnumerable <MacroStabilityInwardsSoilLayer2D> layers = new[]
{
CreateMacroStabilityInwardsSoilLayer2D()
};
var soilProfile = new MacroStabilityInwardsSoilProfile2D("name", layers, Enumerable.Empty <MacroStabilityInwardsPreconsolidationStress>());
var stochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(0.2, soilProfile);
var properties = new MacroStabilityInwardsStochasticSoilProfileProperties(stochasticSoilProfile);
// Call
bool bottomVisible = properties.DynamicVisibleValidationMethod("Bottom");
bool layers1DVisible = properties.DynamicVisibleValidationMethod("Layers1D");
bool layers2DVisible = properties.DynamicVisibleValidationMethod("Layers2D");
bool preconsolidationStressesVisible = properties.DynamicVisibleValidationMethod("PreconsolidationStresses");
// Assert
Assert.IsFalse(bottomVisible);
Assert.IsFalse(layers1DVisible);
Assert.IsTrue(layers2DVisible);
Assert.IsTrue(preconsolidationStressesVisible);
}
public void Create_WithValidProperties_ReturnsEntityWithPropertiesSet()
{
// Setup
var soilProfile = new MacroStabilityInwardsSoilProfile2D("some name", new[]
{
MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D(),
MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D()
}, new[]
{
MacroStabilityInwardsPreconsolidationStressTestFactory.CreateMacroStabilityInwardsPreconsolidationStress()
});
var registry = new PersistenceRegistry();
// Call
MacroStabilityInwardsSoilProfileTwoDEntity entity = soilProfile.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(soilProfile.Layers.Count(), entity.MacroStabilityInwardsSoilLayerTwoDEntities.Count);
Assert.AreEqual(soilProfile.PreconsolidationStresses.Count(), entity.MacroStabilityInwardsPreconsolidationStressEntities.Count);
AssertPreconsolidationStress(soilProfile.PreconsolidationStresses.First(),
entity.MacroStabilityInwardsPreconsolidationStressEntities.First());
}
private static IEnumerable <IEnumerable <Segment2D> > GetLayerPolygons(MacroStabilityInwardsSoilProfile2D soilProfile2D)
{
return(soilProfile2D.Layers
.Select(l => Math2D.ConvertPointsToPolygonSegments(l.OuterRing.Points))
.ToArray());
}
private static IEnumerable <double> GetClippedDiscretizedXCoordinatesOfSurfaceLine(IEnumerable <Point2D> surfaceLinePoints,
MacroStabilityInwardsSoilProfile2D soilProfile2D)
{
IEnumerable <double> surfaceLineXCoordinates = surfaceLinePoints.Select(p => p.X).ToArray();
IEnumerable <double> soilProfileXCoordinates = GetSoilProfile2DXCoordinates(soilProfile2D).ToArray();
double maximumXCoordinateSurfaceLine = surfaceLineXCoordinates.Max();
double maximumXCoordinateSoilProfile = soilProfileXCoordinates.Max();
double maxXCoordinate = Math.Min(maximumXCoordinateSoilProfile, maximumXCoordinateSurfaceLine);
double minimumXCoordinateSurfaceLine = surfaceLineXCoordinates.Min();
double minimumXCoordinateSoilProfile = soilProfileXCoordinates.Min();
double minXCoordinate = Math.Max(minimumXCoordinateSoilProfile, minimumXCoordinateSurfaceLine);
IEnumerable <double> clippedSoilProfileXCoordinates = soilProfileXCoordinates.Where(xCoordinate => IsXCoordinateInRange(xCoordinate, minXCoordinate, maxXCoordinate));
IEnumerable <double> clippedSurfaceLineXCoordinates = surfaceLineXCoordinates.Where(xCoordinate => IsXCoordinateInRange(xCoordinate, minXCoordinate, maxXCoordinate));
double[] uniqueClippedXCoordinates = clippedSoilProfileXCoordinates.Concat(clippedSurfaceLineXCoordinates)
.Distinct()
.OrderBy(xCoordinate => xCoordinate)
.ToArray();
var xCoordinates = new List <double>();
for (var i = 0; i < uniqueClippedXCoordinates.Length - 1; i++)
{
double firstXCoordinate = uniqueClippedXCoordinates[i];
double secondXCoordinate = uniqueClippedXCoordinates[i + 1];
xCoordinates.AddRange(GetDiscretizedXCoordinatesBetweenInterval(firstXCoordinate, secondXCoordinate));
}
xCoordinates.Add(uniqueClippedXCoordinates.Last());
return(xCoordinates);
}
/// <summary>
/// Obtains the <see cref="MacroStabilityInwardsSoilProfileTwoDEntity"/> which was registered for the given
/// <paramref name="model"/>.
/// </summary>
/// <param name="model">The <see cref="MacroStabilityInwardsSoilProfileTwoDEntity"/> for which a create
/// operation has been registered.</param>
/// <returns>The constructed <see cref="MacroStabilityInwardsSoilProfile2D"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="model"/> is <c>null</c>.</exception>
/// <exception cref="InvalidOperationException">Thrown when no create operation
/// has been registered for <paramref name="model"/>.</exception>
/// <remarks>Use <see cref="Contains(MacroStabilityInwardsSoilProfile2D)"/> to find out whether a
/// create operation has been registered for <paramref name="model"/>.</remarks>
internal MacroStabilityInwardsSoilProfileTwoDEntity Get(MacroStabilityInwardsSoilProfile2D model)
{
return(Get(macroStabilityInwardsSoil2DProfiles, model));
}
/// <summary>
/// Checks whether a create operations has been registered for the given <paramref name="model"/>.
/// </summary>
/// <param name="model">The <see cref="MacroStabilityInwardsSoilProfile2D"/> to check for.</param>
/// <returns><c>true</c> if the <see cref="model"/> was registered before, <c>false</c> otherwise.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="model"/> is <c>null</c>.</exception>
internal bool Contains(MacroStabilityInwardsSoilProfile2D model)
{
return(ContainsValue(macroStabilityInwardsSoil2DProfiles, model));
}
/// <summary>
/// Registers a create operation for <paramref name="model"/> and the <paramref name="entity"/>
/// that was constructed with the information.
/// </summary>
/// <param name="entity">The <see cref="MacroStabilityInwardsSoilProfileTwoDEntity"/> to be registered.</param>
/// <param name="model">The <see cref="MacroStabilityInwardsSoilProfile2D"/> to be registered.</param>
/// <exception cref="ArgumentNullException">Thrown when any of the input parameters is <c>null</c>.</exception>
internal void Register(MacroStabilityInwardsSoilProfileTwoDEntity entity, MacroStabilityInwardsSoilProfile2D model)
{
Register(macroStabilityInwardsSoil2DProfiles, entity, model);
}
public void Read_WithCollector_ReturnsSoilProfileWithPropertiesSet()
{
// Setup
Ring outerRingA = RingTestFactory.CreateRandomRing(32);
Ring outerRingB = RingTestFactory.CreateRandomRing(33);
var random = new Random(31);
var preconsolidationStressEntity = new MacroStabilityInwardsPreconsolidationStressEntity
{
CoordinateX = random.NextDouble(),
CoordinateZ = random.NextDouble(),
PreconsolidationStressMean = random.NextDouble(),
PreconsolidationStressCoefficientOfVariation = random.NextDouble(),
Order = 1
};
var point2DXmlSerializer = new Point2DCollectionXmlSerializer();
var entity = new MacroStabilityInwardsSoilProfileTwoDEntity
{
Name = nameof(MacroStabilityInwardsSoilProfileTwoDEntity),
MacroStabilityInwardsSoilLayerTwoDEntities =
{
new MacroStabilityInwardsSoilLayerTwoDEntity
{
MaterialName = "A",
OuterRingXml = point2DXmlSerializer.ToXml(outerRingA.Points),
Order = 1
},
new MacroStabilityInwardsSoilLayerTwoDEntity
{
MaterialName = "B",
OuterRingXml = point2DXmlSerializer.ToXml(outerRingB.Points),
Order = 0
}
},
MacroStabilityInwardsPreconsolidationStressEntities =
{
preconsolidationStressEntity,
new MacroStabilityInwardsPreconsolidationStressEntity
{
Order = 0
}
}
};
var collector = new ReadConversionCollector();
// Call
MacroStabilityInwardsSoilProfile2D profile = entity.Read(collector);
// Assert
Assert.IsNotNull(profile);
Assert.AreEqual(entity.Name, profile.Name);
CollectionAssert.AreEqual(new[]
{
"B",
"A"
}, profile.Layers.Select(l => l.Data.MaterialName));
CollectionAssert.AreEqual(new[]
{
outerRingB,
outerRingA
}, profile.Layers.Select(l => l.OuterRing));
profile.Layers.Select(l => l.NestedLayers).ForEachElementDo(CollectionAssert.IsEmpty);
CollectionAssert.AreEqual(new[]
{
new MacroStabilityInwardsPreconsolidationStress(new Point2D(0, 0),
new VariationCoefficientLogNormalDistribution
{
Mean = RoundedDouble.NaN,
CoefficientOfVariation = RoundedDouble.NaN
}),
new MacroStabilityInwardsPreconsolidationStress(new Point2D(preconsolidationStressEntity.CoordinateX,
preconsolidationStressEntity.CoordinateZ),
new VariationCoefficientLogNormalDistribution
{
Mean = (RoundedDouble)preconsolidationStressEntity.PreconsolidationStressMean.ToNullAsNaN(),
CoefficientOfVariation = (RoundedDouble)preconsolidationStressEntity.PreconsolidationStressCoefficientOfVariation.ToNullAsNaN()
})
}, profile.PreconsolidationStresses);
}
