public void Transform_SoilProfile2DWithPreconsolidationStresses_ReturnMacroStabilityInwardsSoilProfile2DWithStresses()
{
// Setup
var random = new Random(21);
var preconsolidationStress = new PreconsolidationStress
{
XCoordinate = random.NextDouble(),
ZCoordinate = random.NextDouble(),
StressDistributionType = SoilLayerConstants.LogNormalDistributionValue,
StressMean = random.NextDouble(),
StressCoefficientOfVariation = random.NextDouble(),
StressShift = 0
};
var profile = new SoilProfile2D(1, "test", new[]
{
SoilLayer2DTestFactory.CreateSoilLayer2D()
}, new[]
{
preconsolidationStress
});
// Call
var transformedProfile = (MacroStabilityInwardsSoilProfile2D)MacroStabilityInwardsSoilProfileTransformer.Transform(profile);
// Assert
AssertPreconsolidationStress(preconsolidationStress, transformedProfile.PreconsolidationStresses.Single());
}
public void ReadSoilProfile_DatabaseWith2DProfileWithPreconsolidationStressesNullValues_ReturnsOneProfileWithDefaultStressValues()
{
// Setup
string dbFile = Path.Combine(testDataPath, "2dprofileWithPreconsolidationStressesNullValues.soil");
using (var reader = new SoilProfile2DReader(dbFile))
{
reader.Initialize();
// Call
SoilProfile2D soilProfile2D = reader.ReadSoilProfile();
// Assert
PreconsolidationStress[] preconsolidationStresses = soilProfile2D.PreconsolidationStresses.ToArray();
Assert.AreEqual(1, preconsolidationStresses.Length);
PreconsolidationStress actualPreconsolidationStress = preconsolidationStresses[0];
Assert.IsNaN(actualPreconsolidationStress.XCoordinate);
Assert.IsNaN(actualPreconsolidationStress.ZCoordinate);
Assert.IsNull(actualPreconsolidationStress.StressDistributionType);
Assert.IsNaN(actualPreconsolidationStress.StressMean);
Assert.IsNaN(actualPreconsolidationStress.StressCoefficientOfVariation);
Assert.IsNaN(actualPreconsolidationStress.StressShift);
}
Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
}
public void ReadSoilProfile_IntersectionXFor2DSoilProfileNull_ReturnOneProfile()
{
// Setup
string dbFile = Path.Combine(testDataPath, "2dProfileWithXNull.soil");
var result = new Collection <SoilProfile2D>();
using (var reader = new SoilProfile2DReader(dbFile))
{
reader.Initialize();
// Call
while (reader.HasNext)
{
result.Add(reader.ReadSoilProfile());
}
}
// Assert
Assert.AreEqual(1, result.Count);
SoilProfile2D soilProfile2D = result[0];
Assert.AreEqual(1, soilProfile2D.Id);
Assert.AreEqual("Profile", soilProfile2D.Name);
Assert.IsNaN(soilProfile2D.IntersectionX);
Assert.AreEqual(3, soilProfile2D.Layers.Count());
Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
}
public void Transform_SoilProfile2DWithInvalidPreconsolidationStress_ThrowsImportedDataException()
{
var random = new Random(21);
var preconsolidationStress = new PreconsolidationStress
{
XCoordinate = double.NaN,
ZCoordinate = random.NextDouble(),
StressDistributionType = SoilLayerConstants.LogNormalDistributionValue,
StressMean = random.NextDouble(),
StressCoefficientOfVariation = random.NextDouble(),
StressShift = 0
};
var profile = new SoilProfile2D(1, "test", new[]
{
SoilLayer2DTestFactory.CreateSoilLayer2D()
}, new[]
{
preconsolidationStress
});
// Call
TestDelegate call = () => MacroStabilityInwardsSoilProfileTransformer.Transform(profile);
// Assert
var exception = Assert.Throws <ImportedDataTransformException>(call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <ImportedDataTransformException>(innerException);
string expectedMessage = CreateExpectedErrorMessage(profile.Name, innerException.Message);
Assert.AreEqual(expectedMessage, exception.Message);
}
public void Transform_SoilProfile2DWithLayerFilledWithOtherLayer_ReturnsProfileWithBottomAndLayers()
{
// Setup
const string profileName = "SomeProfile";
const long pipingSoilProfileId = 1234L;
List <Segment2D> loopHole = Segment2DLoopCollectionHelper.CreateFromString(
string.Join(Environment.NewLine,
"5",
".....",
".4.1.",
".3.2.",
".....",
"....."));
SoilLayer2D soilLayer2D = SoilLayer2DTestFactory.CreateSoilLayer2D(
new[]
{
loopHole
},
Segment2DLoopCollectionHelper.CreateFromString(
string.Join(Environment.NewLine,
"5",
"2...3",
".....",
".....",
".....",
"1...4")));
var profile = new SoilProfile2D(pipingSoilProfileId, profileName,
new List <SoilLayer2D>
{
soilLayer2D,
SoilLayer2DTestFactory.CreateSoilLayer2D(
new List <Segment2D[]>(),
loopHole)
}, Enumerable.Empty <PreconsolidationStress>())
{
IntersectionX = 2.0
};
// Call
PipingSoilProfile transformed = PipingSoilProfileTransformer.Transform(profile);
// Assert
Assert.AreEqual(profileName, transformed.Name);
Assert.AreEqual(SoilProfileType.SoilProfile2D, transformed.SoilProfileSourceType);
Assert.AreEqual(4, transformed.Layers.Count());
CollectionAssert.AreEquivalent(new[]
{
4.0,
3.0,
3.0,
2.0
}, transformed.Layers.Select(rl => rl.Top));
Assert.AreEqual(0, transformed.Bottom);
}
/// <summary>
/// Transforms the generic <paramref name="soilProfile"/> into a
/// <see cref="MacroStabilityInwardsSoilProfile2D"/>.
/// </summary>
/// <param name="soilProfile">The soil profile to use in the transformation.</param>
/// <returns>A <see cref="MacroStabilityInwardsSoilProfile2D"/> based on the given data.</returns>
/// <exception cref="ImportedDataTransformException">Thrown when <paramref name="soilProfile"/> cannot be
/// transformed in a <see cref="MacroStabilityInwardsSoilProfile2D"/>.</exception>
private static MacroStabilityInwardsSoilProfile2D Transform(SoilProfile2D soilProfile)
{
try
{
return(new MacroStabilityInwardsSoilProfile2D(soilProfile.Name,
soilProfile.Layers
.Select(MacroStabilityInwardsSoilLayerTransformer.Transform)
.ToArray(),
TransformPreconsolidationStresses(soilProfile.Name, soilProfile.PreconsolidationStresses)));
}
catch (ArgumentException e)
{
string errorMessage = CreateErrorMessage(soilProfile.Name, e.Message);
throw new ImportedDataTransformException(errorMessage, e);
}
}
public void Transform_InvalidSoilProfile2D_ThrowsImportedDataTransformException()
{
// Setup
var profile = new SoilProfile2D(1, "test", Enumerable.Empty <SoilLayer2D>(), Enumerable.Empty <PreconsolidationStress>());
// Call
TestDelegate call = () => MacroStabilityInwardsSoilProfileTransformer.Transform(profile);
// Assert
var exception = Assert.Throws <ImportedDataTransformException>(call);
Exception innerException = exception.InnerException;
string expectedMessage = CreateExpectedErrorMessage(profile.Name, innerException.Message);
Assert.AreEqual(expectedMessage, exception.Message);
}
public void Transform_ValidSoilProfile2D_ReturnMacroStabilityInwardsSoilProfile2D()
{
// Setup
var profile = new SoilProfile2D(1, "test", new[]
{
SoilLayer2DTestFactory.CreateSoilLayer2D()
}, Enumerable.Empty <PreconsolidationStress>());
// Call
var transformedProfile = (MacroStabilityInwardsSoilProfile2D)MacroStabilityInwardsSoilProfileTransformer.Transform(profile);
// Assert
Assert.AreEqual(profile.Name, transformedProfile.Name);
Assert.AreEqual(profile.Layers.Count(), transformedProfile.Layers.Count());
CollectionAssert.AllItemsAreInstancesOfType(transformedProfile.Layers, typeof(MacroStabilityInwardsSoilLayer2D));
CollectionAssert.IsEmpty(transformedProfile.PreconsolidationStresses);
}
public void Transform_ValidStochasticSoilModelWithSoilProfile2D_ReturnsExpectedPipingStochasticSoilModel()
{
// Setup
var random = new Random(21);
const string name = "name";
const double intersectionX = 1.0;
SoilLayer2D layer = SoilLayer2DTestFactory.CreateSoilLayer2D();
var profile = new SoilProfile2D(0, "SoilProfile2D", new[]
{
layer
}, Enumerable.Empty <PreconsolidationStress>())
{
IntersectionX = intersectionX
};
var transformer = new PipingStochasticSoilModelTransformer();
double probability = random.NextDouble();
var soilModel = new StochasticSoilModel(name, FailureMechanismType.Piping)
{
StochasticSoilProfiles =
{
new StochasticSoilProfile(probability, profile)
},
Geometry =
{
new Point2D(1.0, 0.0),
new Point2D(0.0, 0.0)
}
};
// Call
PipingStochasticSoilModel transformed = transformer.Transform(soilModel);
// Assert
Assert.AreEqual(name, transformed.Name);
Assert.AreEqual(1, transformed.StochasticSoilProfiles.Count());
CollectionAssert.AreEqual(soilModel.Geometry, transformed.Geometry);
var expectedPipingSoilProfile = new[]
{
new PipingStochasticSoilProfile(probability, PipingSoilProfileTransformer.Transform(profile))
};
AssertPipingStochasticSoilProfiles(expectedPipingSoilProfile, transformed.StochasticSoilProfiles.ToArray());
}
public void Transform_SoilProfile2DWithoutIntersection_ThrowsImportedDataTransformException()
{
// Setup
const string name = "name";
var profile = new SoilProfile2D(0, name, new[]
{
new SoilLayer2D(new SoilLayer2DLoop(new Segment2D[0]), Enumerable.Empty <SoilLayer2D>())
}, Enumerable.Empty <PreconsolidationStress>());
// Call
TestDelegate test = () => PipingSoilProfileTransformer.Transform(profile);
// Assert
var exception = Assert.Throws <ImportedDataTransformException>(test);
Assert.AreEqual($"Geen geldige X waarde gevonden om intersectie te maken uit 2D profiel '{name}'.",
exception.Message);
}
public void Constructor_ValidArguments_ReturnsExpectedProperties()
{
// Setup
const long id = 12;
const string name = "some name";
IEnumerable <SoilLayer2D> soilLayer2Ds = Enumerable.Empty <SoilLayer2D>();
IEnumerable <PreconsolidationStress> stresses = Enumerable.Empty <PreconsolidationStress>();
// Call
var soilProfile2D = new SoilProfile2D(id, name, soilLayer2Ds, stresses);
// Assert
Assert.IsInstanceOf <ISoilProfile>(soilProfile2D);
Assert.AreEqual(id, soilProfile2D.Id);
Assert.AreEqual(name, soilProfile2D.Name);
Assert.AreSame(soilLayer2Ds, soilProfile2D.Layers);
Assert.AreSame(stresses, soilProfile2D.PreconsolidationStresses);
Assert.IsNaN(soilProfile2D.IntersectionX);
}
public void Transform_ValidStochasticSoilModelWithSameProfileInTwoStochasticSoilProfiles_ReturnsExpectedPipingStochasticSoilModel()
{
// Setup
const string soilModelName = "name";
const string soilProfileName = "SoilProfile";
const double intersectionX = 1.0;
SoilLayer2D layer = SoilLayer2DTestFactory.CreateSoilLayer2D();
var profile = new SoilProfile2D(0, soilProfileName, new[]
{
layer
}, Enumerable.Empty <PreconsolidationStress>())
{
IntersectionX = intersectionX
};
const double originalProfileOneProbability = 0.2;
const double originalProfileTwoProbability = 0.7;
StochasticSoilModel soilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModelWithGeometry(soilModelName, new[]
{
new StochasticSoilProfile(originalProfileOneProbability, profile),
new StochasticSoilProfile(originalProfileTwoProbability, profile)
});
var transformer = new PipingStochasticSoilModelTransformer();
PipingStochasticSoilModel transformed = null;
// Call
Action call = () => transformed = transformer.Transform(soilModel);
// Assert
string expectedMessage = $"Ondergrondschematisatie '{soilProfileName}' is meerdere keren gevonden in ondergrondmodel '{soilModelName}'. " +
"Kansen van voorkomen worden opgeteld.";
TestHelper.AssertLogMessageWithLevelIsGenerated(call, Tuple.Create(expectedMessage, LogLevelConstant.Warn));
PipingStochasticSoilProfile[] transformedStochasticSoilProfiles = transformed.StochasticSoilProfiles.ToArray();
Assert.AreEqual(1, transformedStochasticSoilProfiles.Length);
const double expectedProbability = originalProfileOneProbability + originalProfileTwoProbability;
Assert.AreEqual(expectedProbability, transformedStochasticSoilProfiles[0].Probability, 1e-6);
}
public void Transform_ValidTwoStochasticSoilModelWithSameProfile_ReturnsExpectedPipingStochasticSoilModel()
{
// Setup
const double intersectionX = 1.0;
SoilLayer2D layer = SoilLayer2DTestFactory.CreateSoilLayer2D();
var profile = new SoilProfile2D(0, "SoilProfile2D", new[]
{
layer
}, Enumerable.Empty <PreconsolidationStress>())
{
IntersectionX = intersectionX
};
var transformer = new PipingStochasticSoilModelTransformer();
StochasticSoilModel soilModel1 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModelWithGeometry(new[]
{
StochasticSoilProfileTestFactory.CreateStochasticSoilProfileWithValidProbability(profile)
});
StochasticSoilModel soilModel2 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModelWithGeometry(new[]
{
StochasticSoilProfileTestFactory.CreateStochasticSoilProfileWithValidProbability(profile)
});
// Call
PipingStochasticSoilModel transformed1 = transformer.Transform(soilModel1);
PipingStochasticSoilModel transformed2 = transformer.Transform(soilModel2);
// Assert
PipingStochasticSoilProfile[] transformedStochasticSoilProfiles1 = transformed1.StochasticSoilProfiles.ToArray();
PipingStochasticSoilProfile[] transformedStochasticSoilProfiles2 = transformed2.StochasticSoilProfiles.ToArray();
Assert.AreEqual(1, transformedStochasticSoilProfiles1.Length);
Assert.AreEqual(1, transformedStochasticSoilProfiles2.Length);
PipingStochasticSoilProfile pipingStochasticSoilProfile1 = transformedStochasticSoilProfiles1[0];
PipingStochasticSoilProfile pipingStochasticSoilProfile2 = transformedStochasticSoilProfiles2[0];
Assert.AreSame(pipingStochasticSoilProfile1.SoilProfile, pipingStochasticSoilProfile2.SoilProfile);
}
public void Transform_ValidStochasticSoilModelWithSimilarProfileInTwoStochasticSoilProfiles_ReturnsExpectedPipingStochasticSoilModel()
{
// Setup
var random = new Random(21);
const string soilProfileName = "SoilProfile";
const double intersectionX = 1.0;
var soilProfile2D = new SoilProfile2D(0, soilProfileName, new[]
{
SoilLayer2DTestFactory.CreateSoilLayer2D()
}, Enumerable.Empty <PreconsolidationStress>())
{
IntersectionX = intersectionX
};
var stochasticSoilProfile2D = new StochasticSoilProfile(random.NextDouble(), soilProfile2D);
var soilProfile1D = new SoilProfile1D(0, soilProfileName, 0, new[]
{
SoilLayer1DTestFactory.CreateSoilLayer1DWithValidAquifer()
});
var stochasticSoilProfile1D = new StochasticSoilProfile(random.NextDouble(), soilProfile1D);
var transformer = new PipingStochasticSoilModelTransformer();
StochasticSoilModel soilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModelWithGeometry(new[]
{
stochasticSoilProfile2D,
stochasticSoilProfile1D
});
// Call
PipingStochasticSoilModel transformed = transformer.Transform(soilModel);
// Assert
PipingStochasticSoilProfile[] transformedStochasticSoilProfiles = transformed.StochasticSoilProfiles.ToArray();
Assert.AreEqual(2, transformedStochasticSoilProfiles.Length);
Assert.AreEqual(stochasticSoilProfile2D.Probability, transformedStochasticSoilProfiles[0].Probability, 1e-6);
Assert.AreEqual(stochasticSoilProfile1D.Probability, transformedStochasticSoilProfiles[1].Probability, 1e-6);
}
public void ReadSoilProfile_Empty2DProfileWithoutLayers_ReturnsSoilProfile()
{
// Setup
string dbFile = Path.Combine(testDataPath, "2dprofileNoLayers.soil");
using (var reader = new SoilProfile2DReader(dbFile))
{
reader.Initialize();
// Call
SoilProfile2D profile = reader.ReadSoilProfile();
// Assert
Assert.AreEqual("Profile", profile.Name);
Assert.AreEqual(1, profile.Id);
Assert.IsNaN(profile.IntersectionX);
CollectionAssert.IsEmpty(profile.Layers);
CollectionAssert.IsEmpty(profile.PreconsolidationStresses);
}
Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
}
public void Transform_InvalidSoilProfile2D_ThrowsImportedDataTransformException()
{
// Setup
var random = new Random(21);
var profile = new SoilProfile2D(0, "A profile name", Enumerable.Empty <SoilLayer2D>(), Enumerable.Empty <PreconsolidationStress>())
{
IntersectionX = random.NextDouble()
};
// Call
TestDelegate test = () => PipingSoilProfileTransformer.Transform(profile);
// Assert
var exception = Assert.Throws <ImportedDataTransformException>(test);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <ArgumentException>(innerException);
string expectedMessage = CreateExpectedErrorMessage(profile.Name, innerException.Message);
Assert.AreEqual(expectedMessage, exception.Message);
}
public void Transform_ValidSoilProfile2D_ReturnsExpectedPipingSoilProfile()
{
// Setup
const string name = "name";
const double bottom = 0.5;
const double intersectionX = 1.0;
SoilLayer2D layer = SoilLayer2DTestFactory.CreateSoilLayer2D(new List <Segment2D[]>(),
new List <Segment2D>
{
new Segment2D(new Point2D(1.0, bottom),
new Point2D(1.2, 1)),
new Segment2D(new Point2D(1.2, 1),
new Point2D(1.0, bottom))
});
var profile = new SoilProfile2D(0, name, new[]
{
layer
}, Enumerable.Empty <PreconsolidationStress>())
{
IntersectionX = intersectionX
};
// Call
PipingSoilProfile transformed = PipingSoilProfileTransformer.Transform(profile);
// Assert
Assert.AreEqual(name, transformed.Name);
Assert.AreEqual(SoilProfileType.SoilProfile2D, transformed.SoilProfileSourceType);
Assert.AreEqual(bottom, transformed.Bottom);
double bottomOut;
IEnumerable <PipingSoilLayer> actualPipingSoilLayers = PipingSoilLayerTransformer.Transform(
layer, intersectionX, out bottomOut);
AssertPipingSoilLayers(actualPipingSoilLayers, transformed.Layers);
}
public void Transform_SoilProfile2DWithSingleLayerOnlyOuterLoop_ReturnsProfileWithBottomAndALayer()
{
// Setup
const string profileName = "SomeProfile";
var firstPoint = new Point2D(-0.5, 1.0);
var secondPoint = new Point2D(0.5, 1.0);
var thirdPoint = new Point2D(0.5, -1.0);
var fourthPoint = new Point2D(-0.5, -1.0);
SoilLayer2D layer = SoilLayer2DTestFactory.CreateSoilLayer2D(
new List <Segment2D[]>(),
new List <Segment2D>
{
new Segment2D(firstPoint, secondPoint),
new Segment2D(secondPoint, thirdPoint),
new Segment2D(thirdPoint, fourthPoint),
new Segment2D(fourthPoint, firstPoint)
});
var profile = new SoilProfile2D(0, profileName, new[]
{
layer
}, Enumerable.Empty <PreconsolidationStress>())
{
IntersectionX = 0.0
};
// Call
PipingSoilProfile transformed = PipingSoilProfileTransformer.Transform(profile);
// Assert
Assert.AreEqual(profileName, transformed.Name);
Assert.AreEqual(1, transformed.Layers.Count());
Assert.AreEqual(1.0, transformed.Layers.ToArray()[0].Top);
Assert.AreEqual(-1.0, transformed.Bottom);
Assert.AreEqual(SoilProfileType.SoilProfile2D, transformed.SoilProfileSourceType);
}
public void Transform_SoilProfile2DLayerWithVerticalLineOnXInXml_ThrowsImportedDataTransformException()
{
// Setup
const string profileName = "SomeProfile";
const double atX = 0.0;
SoilLayer2D layer = SoilLayer2DTestFactory.CreateSoilLayer2D(
new List <Segment2D[]>(),
new List <Segment2D>
{
new Segment2D(new Point2D(atX, 0.0),
new Point2D(atX, 1.0)),
new Segment2D(new Point2D(atX, 1.0),
new Point2D(0.5, 0.5)),
new Segment2D(new Point2D(0.5, 0.5),
new Point2D(atX, 0.0))
});
var profile = new SoilProfile2D(0, profileName, new[]
{
layer
}, Enumerable.Empty <PreconsolidationStress>())
{
IntersectionX = atX
};
// Call
TestDelegate test = () => PipingSoilProfileTransformer.Transform(profile);
// Assert
var exception = Assert.Throws <ImportedDataTransformException>(test);
string message = $"Er is een fout opgetreden bij het inlezen van grondlaag '{layer.MaterialName}': " +
"Er kan geen 1D-profiel bepaald worden wanneer segmenten in een 2D " +
$"laag verticaal lopen op de gekozen positie: x = {atX}.";
Assert.AreEqual(message, exception.Message);
}
public void ReadSoilProfile_DatabaseWith2DSoilProfileContainingNestedLayers_ReturnOneProfile()
{
// Setup
string dbFile = Path.Combine(testDataPath, "2dprofileNestedLayers.soil");
using (var reader = new SoilProfile2DReader(dbFile))
{
reader.Initialize();
// Call
SoilProfile2D soilProfile2D = reader.ReadSoilProfile();
// Assert
Assert.AreEqual(1, soilProfile2D.Id);
Assert.AreEqual("Profile", soilProfile2D.Name);
CollectionAssert.IsEmpty(soilProfile2D.PreconsolidationStresses);
Assert.AreEqual(90.0, soilProfile2D.IntersectionX, 1e-3);
Assert.AreEqual(1, soilProfile2D.Layers.Count());
SoilLayer2D layer = soilProfile2D.Layers.First();
Assert.AreEqual("Material1", layer.MaterialName);
Assert.AreEqual(2, layer.NestedLayers.Count());
SoilLayer2D firstNestedLayer = layer.NestedLayers.First();
Assert.AreEqual("Material4", firstNestedLayer.MaterialName);
Assert.AreEqual(1, firstNestedLayer.NestedLayers.Count());
Assert.AreEqual("Material3", firstNestedLayer.NestedLayers.First().MaterialName);
Assert.AreEqual(0, firstNestedLayer.NestedLayers.First().NestedLayers.Count());
SoilLayer2D secondNestedLayer = layer.NestedLayers.ElementAt(1);
Assert.AreEqual("Material2", secondNestedLayer.MaterialName);
Assert.AreEqual(0, secondNestedLayer.NestedLayers.Count());
}
Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
}
public void Transform_TwoStochasticSoilModelsWithSameProfile_ReturnExpectedMacroStabilityInwardsStochasticSoilModel()
{
// Setup
SoilLayer2D layer = SoilLayer2DTestFactory.CreateSoilLayer2D();
var profile = new SoilProfile2D(2, "test", new[]
{
layer
}, Enumerable.Empty <PreconsolidationStress>());
StochasticSoilModel soilModel1 = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateMacroStabilityInwardsStochasticSoilModelWithGeometry(new[]
{
StochasticSoilProfileTestFactory.CreateStochasticSoilProfileWithValidProbability(profile)
});
StochasticSoilModel soilModel2 = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateMacroStabilityInwardsStochasticSoilModelWithGeometry(new[]
{
StochasticSoilProfileTestFactory.CreateStochasticSoilProfileWithValidProbability(profile)
});
var transformer = new MacroStabilityInwardsStochasticSoilModelTransformer();
// Call
MacroStabilityInwardsStochasticSoilModel transformedModel1 = transformer.Transform(soilModel1);
MacroStabilityInwardsStochasticSoilModel transformedModel2 = transformer.Transform(soilModel2);
// Assert
MacroStabilityInwardsStochasticSoilProfile[] transformedStochasticSoilProfiles1 = transformedModel1.StochasticSoilProfiles.ToArray();
MacroStabilityInwardsStochasticSoilProfile[] transformedStochasticSoilProfiles2 = transformedModel2.StochasticSoilProfiles.ToArray();
Assert.AreEqual(1, transformedStochasticSoilProfiles1.Length);
Assert.AreEqual(1, transformedStochasticSoilProfiles2.Length);
MacroStabilityInwardsStochasticSoilProfile stochasticSoilProfile1 = transformedStochasticSoilProfiles1[0];
MacroStabilityInwardsStochasticSoilProfile stochasticSoilProfile2 = transformedStochasticSoilProfiles2[0];
Assert.AreSame(stochasticSoilProfile1.SoilProfile, stochasticSoilProfile2.SoilProfile);
}
/// <summary>
/// Creates a new instances of the <see cref="PipingSoilProfile"/> based on the <paramref name="soilProfile2D"/>.
/// </summary>
/// <param name="soilProfile2D">The soil profile to use in the transformation.</param>
/// <returns>The created <see cref="PipingSoilProfile"/>.</returns>
/// <exception cref="ImportedDataTransformException">Thrown when:
/// <list type="bullet">
/// <item>The <paramref name="soilProfile2D"/> cannot be used to determine intersections with;</item>
/// <item>Transforming the <paramref name="soilProfile2D"/> failed.</item>
/// </list>
/// </exception>
private static PipingSoilProfile CreatePipingSoilProfile(SoilProfile2D soilProfile2D)
{
string profileName = soilProfile2D.Name;
double intersectionX = soilProfile2D.IntersectionX;
if (double.IsNaN(intersectionX))
{
string message = string.Format(Resources.Error_SoilProfileBuilder_cant_determine_intersect_SoilProfileName_0_at_double_NaN,
profileName);
throw new ImportedDataTransformException(message);
}
var layers = new List <PipingSoilLayer>();
double bottom = double.MaxValue;
foreach (SoilLayer2D soilLayer2D in soilProfile2D.Layers)
{
double newBottom;
layers.AddRange(PipingSoilLayerTransformer.Transform(soilLayer2D,
intersectionX,
out newBottom));
bottom = Math.Min(bottom, newBottom);
}
try
{
return(new PipingSoilProfile(profileName, bottom, layers, SoilProfileType.SoilProfile2D));
}
catch (ArgumentException e)
{
string errorMessage = CreateErrorMessage(soilProfile2D.Name, e.Message);
throw new ImportedDataTransformException(errorMessage, e);
}
}
public void ReadSoilProfile_DatabaseWith2DProfile1LayerWithAllNullValues_ReturnsProfileWithDefaultValues()
{
// Setup
string dbFile = Path.Combine(testDataPath, "2dprofileWithLayerWithNullValuesOnly.soil");
using (var reader = new SoilProfile2DReader(dbFile))
{
reader.Initialize();
// Call
SoilProfile2D profile = reader.ReadSoilProfile();
// Assert
Assert.AreEqual(1, profile.Id);
Assert.AreEqual("Profile", profile.Name);
Assert.AreEqual(85.2, profile.IntersectionX);
CollectionAssert.IsEmpty(profile.PreconsolidationStresses);
SoilLayer2D soilLayer = profile.Layers.Single();
Assert.AreEqual("Material1", soilLayer.MaterialName);
Assert.IsNull(soilLayer.IsAquifer);
Assert.IsNull(soilLayer.Color);
Assert.IsNull(soilLayer.BelowPhreaticLevelDistributionType);
Assert.IsNaN(soilLayer.BelowPhreaticLevelMean);
Assert.IsNaN(soilLayer.BelowPhreaticLevelDeviation);
Assert.IsNaN(soilLayer.BelowPhreaticLevelCoefficientOfVariation);
Assert.IsNaN(soilLayer.BelowPhreaticLevelShift);
Assert.IsNull(soilLayer.DiameterD70DistributionType);
Assert.IsNaN(soilLayer.DiameterD70Mean);
Assert.IsNaN(soilLayer.DiameterD70CoefficientOfVariation);
Assert.IsNaN(soilLayer.DiameterD70Shift);
Assert.IsNull(soilLayer.PermeabilityDistributionType);
Assert.IsNaN(soilLayer.PermeabilityMean);
Assert.IsNaN(soilLayer.PermeabilityCoefficientOfVariation);
Assert.IsNaN(soilLayer.PermeabilityShift);
Assert.IsNull(soilLayer.UsePop);
Assert.IsNull(soilLayer.ShearStrengthModel);
Assert.IsNull(soilLayer.AbovePhreaticLevelDistributionType);
Assert.IsNaN(soilLayer.AbovePhreaticLevelMean);
Assert.IsNaN(soilLayer.AbovePhreaticLevelCoefficientOfVariation);
Assert.IsNaN(soilLayer.AbovePhreaticLevelShift);
Assert.IsNull(soilLayer.CohesionDistributionType);
Assert.IsNaN(soilLayer.CohesionMean);
Assert.IsNaN(soilLayer.CohesionCoefficientOfVariation);
Assert.IsNaN(soilLayer.CohesionShift);
Assert.IsNull(soilLayer.FrictionAngleDistributionType);
Assert.IsNaN(soilLayer.FrictionAngleMean);
Assert.IsNaN(soilLayer.FrictionAngleCoefficientOfVariation);
Assert.IsNaN(soilLayer.FrictionAngleShift);
Assert.IsNull(soilLayer.ShearStrengthRatioDistributionType);
Assert.IsNaN(soilLayer.ShearStrengthRatioMean);
Assert.IsNaN(soilLayer.ShearStrengthRatioCoefficientOfVariation);
Assert.IsNaN(soilLayer.ShearStrengthRatioShift);
Assert.IsNull(soilLayer.StrengthIncreaseExponentDistributionType);
Assert.IsNaN(soilLayer.StrengthIncreaseExponentMean);
Assert.IsNaN(soilLayer.StrengthIncreaseExponentCoefficientOfVariation);
Assert.IsNaN(soilLayer.StrengthIncreaseExponentShift);
Assert.IsNull(soilLayer.PopDistributionType);
Assert.IsNaN(soilLayer.PopMean);
Assert.IsNaN(soilLayer.PopCoefficientOfVariation);
Assert.IsNaN(soilLayer.PopShift);
}
Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
}
public void Transform_SoilProfile2DWithMultipleLayersOnlyOuterLoop_ReturnsProfileWithBottomAndLayers()
{
// Setup
const string profileName = "SomeProfile";
const long pipingSoilProfileId = 1234L;
var profile = new SoilProfile2D(pipingSoilProfileId, profileName,
new List <SoilLayer2D>
{
SoilLayer2DTestFactory.CreateSoilLayer2D(
new List <Segment2D[]>(),
Segment2DLoopCollectionHelper.CreateFromString(
string.Join(Environment.NewLine,
"10",
"...",
"...",
"...",
"...",
"...",
"...",
"...",
"1.2",
"4.3",
"..."))),
SoilLayer2DTestFactory.CreateSoilLayer2D(
new List <Segment2D[]>(),
Segment2DLoopCollectionHelper.CreateFromString(
string.Join(Environment.NewLine,
"10",
"...",
"...",
"...",
"...",
"...",
"4.3",
"...",
"1.2",
"...",
"..."))),
SoilLayer2DTestFactory.CreateSoilLayer2D(
new List <Segment2D[]>(),
Segment2DLoopCollectionHelper.CreateFromString(
string.Join(Environment.NewLine,
"10",
"...",
"1.2",
"...",
"...",
"...",
"4.3",
"...",
"...",
"...",
"...")))
}, Enumerable.Empty <PreconsolidationStress>())
{
IntersectionX = 1.0
};
// Call
PipingSoilProfile transformed = PipingSoilProfileTransformer.Transform(profile);
// Assert
Assert.AreEqual(profileName, transformed.Name);
Assert.AreEqual(SoilProfileType.SoilProfile2D, transformed.SoilProfileSourceType);
Assert.AreEqual(3, transformed.Layers.Count());
CollectionAssert.AreEquivalent(new[]
{
2.0,
4.0,
8.0
}, transformed.Layers.Select(rl => rl.Top));
Assert.AreEqual(1.0, transformed.Bottom);
}
public void ReadSoilProfile_DatabaseWith2DProfileWithPreconsolidationStresses_ReturnOneProfileWithStresses()
{
// Setup
string dbFile = Path.Combine(testDataPath, "2dprofileWithPreconsolidationStresses.soil");
using (var reader = new SoilProfile2DReader(dbFile))
{
reader.Initialize();
// Call
SoilProfile2D soilProfile2D = reader.ReadSoilProfile();
// Assert
Assert.AreEqual(4, soilProfile2D.PreconsolidationStresses.Count());
CollectionAssert.AreEqual(new[]
{
1,
2,
3,
4
}, soilProfile2D.PreconsolidationStresses.Select(stress => stress.XCoordinate));
CollectionAssert.AreEqual(new[]
{
5,
6,
7,
8
}, soilProfile2D.PreconsolidationStresses.Select(stress => stress.ZCoordinate));
CollectionAssert.AreEqual(new[]
{
3,
3,
3,
3
}, soilProfile2D.PreconsolidationStresses.Select(stress => stress.StressDistributionType));
CollectionAssert.AreEqual(new[]
{
1337,
3371,
8.5,
9.3
}, soilProfile2D.PreconsolidationStresses.Select(stress => stress.StressMean));
CollectionAssert.AreEqual(new[]
{
0.0074794315632011965,
0.0029664787896766538,
1.8823529411764706,
0.8064516129032258
}, soilProfile2D.PreconsolidationStresses.Select(stress => stress.StressCoefficientOfVariation));
CollectionAssert.AreEqual(new[]
{
11,
12,
0,
0
}, soilProfile2D.PreconsolidationStresses.Select(stress => stress.StressShift));
}
Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
}
public void ReadSoilProfile_DatabaseWith2DSoilProfile3Layers_ReturnOneProfile()
{
// Setup
string dbFile = Path.Combine(testDataPath, "2dprofile.soil");
using (var reader = new SoilProfile2DReader(dbFile))
{
reader.Initialize();
// Call
SoilProfile2D soilProfile2D = reader.ReadSoilProfile();
// Assert
Assert.AreEqual(1, soilProfile2D.Id);
Assert.AreEqual("Profile", soilProfile2D.Name);
CollectionAssert.IsEmpty(soilProfile2D.PreconsolidationStresses);
Assert.AreEqual(85.2, soilProfile2D.IntersectionX);
Assert.AreEqual(3, soilProfile2D.Layers.Count());
CollectionAssert.AreEqual(new[]
{
1.0,
0.0,
0.0
}, soilProfile2D.Layers.Select(l => l.IsAquifer));
CollectionAssert.AreEqual(new[]
{
-12156236,
-65536,
-8323200
}, soilProfile2D.Layers.Select(l => l.Color));
CollectionAssert.AreEqual(new[]
{
"Material1",
"Material2",
"Material3"
}, soilProfile2D.Layers.Select(l => l.MaterialName));
CollectionAssert.AreEqual(new[]
{
2,
2,
2
}, soilProfile2D.Layers.Select(l => l.BelowPhreaticLevelDistributionType));
CollectionAssert.AreEqual(new[]
{
24,
28,
20
}, soilProfile2D.Layers.Select(l => l.BelowPhreaticLevelMean));
CollectionAssert.AreEqual(new[]
{
0.24,
0.28,
0.2
}, soilProfile2D.Layers.Select(l => l.BelowPhreaticLevelDeviation));
CollectionAssert.AreEqual(new[]
{
0.01,
0.01,
0.01
}, soilProfile2D.Layers.Select(l => l.BelowPhreaticLevelCoefficientOfVariation));
CollectionAssert.AreEqual(new[]
{
0.3,
0.32,
0.4
}, soilProfile2D.Layers.Select(l => l.BelowPhreaticLevelShift));
CollectionAssert.AreEqual(new[]
{
3,
3,
3
}, soilProfile2D.Layers.Select(l => l.DiameterD70DistributionType));
CollectionAssert.AreEqual(new[]
{
0.00017,
0.00017,
0.00016
}, soilProfile2D.Layers.Select(l => l.DiameterD70Mean));
CollectionAssert.AreEqual(new[]
{
0.11764705882352941,
0.11764705882352941,
0.125
}, soilProfile2D.Layers.Select(l => l.DiameterD70CoefficientOfVariation));
CollectionAssert.AreEqual(new[]
{
0,
0,
0
}, soilProfile2D.Layers.Select(l => l.DiameterD70Shift));
CollectionAssert.AreEqual(new[]
{
3,
3,
3
}, soilProfile2D.Layers.Select(l => l.PermeabilityDistributionType));
CollectionAssert.AreEqual(new[]
{
0,
0,
0.000185
}, soilProfile2D.Layers.Select(l => l.PermeabilityMean));
CollectionAssert.AreEqual(new[]
{
double.NaN,
double.NaN,
0
}, soilProfile2D.Layers.Select(l => l.PermeabilityCoefficientOfVariation));
CollectionAssert.AreEqual(new[]
{
0,
0,
0
}, soilProfile2D.Layers.Select(l => l.PermeabilityShift));
CollectionAssert.AreEqual(new double?[]
{
null,
0,
null
}, soilProfile2D.Layers.Select(l => l.UsePop));
CollectionAssert.AreEqual(new double?[]
{
null,
6,
9
}, soilProfile2D.Layers.Select(l => l.ShearStrengthModel));
CollectionAssert.AreEqual(new[]
{
2,
2,
2
}, soilProfile2D.Layers.Select(l => l.AbovePhreaticLevelDistributionType));
CollectionAssert.AreEqual(new[]
{
14,
18,
10
}, soilProfile2D.Layers.Select(l => l.AbovePhreaticLevelMean));
CollectionAssert.AreEqual(new[]
{
0.01,
0,
0.01
}, soilProfile2D.Layers.Select(l => l.AbovePhreaticLevelCoefficientOfVariation));
CollectionAssert.AreEqual(new[]
{
10,
0,
0
}, soilProfile2D.Layers.Select(l => l.AbovePhreaticLevelShift));
CollectionAssert.AreEqual(new[]
{
3,
3,
3
}, soilProfile2D.Layers.Select(l => l.CohesionDistributionType));
CollectionAssert.AreEqual(new[]
{
1,
3,
7
}, soilProfile2D.Layers.Select(l => l.CohesionMean));
CollectionAssert.AreEqual(new[]
{
0.1,
0.09999999999999999,
0.09999999999999999
}, soilProfile2D.Layers.Select(l => l.CohesionCoefficientOfVariation));
CollectionAssert.AreEqual(new[]
{
0.01,
0.03,
0.07
}, soilProfile2D.Layers.Select(l => l.CohesionShift));
CollectionAssert.AreEqual(new[]
{
3,
3,
3
}, soilProfile2D.Layers.Select(l => l.FrictionAngleDistributionType));
CollectionAssert.AreEqual(new[]
{
0.1,
33,
77
}, soilProfile2D.Layers.Select(l => l.FrictionAngleMean));
CollectionAssert.AreEqual(new[]
{
10,
0.01,
0.01
}, soilProfile2D.Layers.Select(l => l.FrictionAngleCoefficientOfVariation));
CollectionAssert.AreEqual(new[]
{
0,
0.03,
0.07
}, soilProfile2D.Layers.Select(l => l.FrictionAngleShift));
CollectionAssert.AreEqual(new[]
{
3,
3,
3
}, soilProfile2D.Layers.Select(l => l.ShearStrengthRatioDistributionType));
CollectionAssert.AreEqual(new[]
{
1,
28,
78
}, soilProfile2D.Layers.Select(l => l.ShearStrengthRatioMean));
CollectionAssert.AreEqual(new[]
{
1,
0.029285714285714283,
0.011153846153846153
}, soilProfile2D.Layers.Select(l => l.ShearStrengthRatioCoefficientOfVariation));
CollectionAssert.AreEqual(new[]
{
1,
0.08,
0.07
}, soilProfile2D.Layers.Select(l => l.ShearStrengthRatioShift));
CollectionAssert.AreEqual(new[]
{
3,
3,
3
}, soilProfile2D.Layers.Select(l => l.StrengthIncreaseExponentDistributionType));
CollectionAssert.AreEqual(new[]
{
1,
2,
3
}, soilProfile2D.Layers.Select(l => l.StrengthIncreaseExponentMean));
CollectionAssert.AreEqual(new[]
{
1,
0.1,
0.09999999999999999
}, soilProfile2D.Layers.Select(l => l.StrengthIncreaseExponentCoefficientOfVariation));
CollectionAssert.AreEqual(new[]
{
0,
0.02,
0.03
}, soilProfile2D.Layers.Select(l => l.StrengthIncreaseExponentShift));
CollectionAssert.AreEqual(new[]
{
3,
3,
3
}, soilProfile2D.Layers.Select(l => l.PopDistributionType));
CollectionAssert.AreEqual(new[]
{
111,
222,
333
}, soilProfile2D.Layers.Select(l => l.PopMean));
CollectionAssert.AreEqual(new[]
{
0.000990990990990991,
0.000990990990990991,
0.000990990990990991
}, soilProfile2D.Layers.Select(l => l.PopCoefficientOfVariation));
CollectionAssert.AreEqual(new[]
{
0.01,
0.02,
0.03
}, soilProfile2D.Layers.Select(l => l.PopShift));
}
Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
}
