public bool Export()
{
if (!AreSpecificFailureMechanismsUniquelyNamed())
{
log.Error(Resources.AssemblyExporter_Specific_failure_mechanisms_must_have_a_unique_name);
return(false);
}
ExportableAssessmentSection exportableAssessmentSection = CreateExportableAssessmentSection();
if (exportableAssessmentSection == null)
{
log.Error(Resources.AssemblyExporter_No_AssemblyResult_exported_Check_results_for_details);
return(false);
}
try
{
SerializableAssemblyWriter.WriteAssembly(SerializableAssemblyCreator.Create(exportableAssessmentSection),
filePath);
}
catch (AssemblyCreatorException)
{
log.Error(Resources.AssemblyExporter_No_AssemblyResult_exported_Check_results_for_details);
return(false);
}
catch (CriticalFileWriteException e)
{
log.ErrorFormat(Resources.AssemblyExporter_Error_Exception_0_no_AssemblyResult_exported, e.Message);
return(false);
}
return(true);
}
/// <summary>
/// Gets an id based on <paramref name="assessmentSection"/>.
/// </summary>
/// <param name="assessmentSection">The <see cref="ExportableAssessmentSection"/>
/// to generate an id for.</param>
/// <returns>An id.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/> is <c>null</c>.</exception>
public static string GeneratedId(ExportableAssessmentSection assessmentSection)
{
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
return($"{Resources.SerializableAssessmentSection_IdPrefix}.{assessmentSection.Id}");
}
/// <summary>
/// Creates an instance of <see cref="SerializableAssessmentSection"/>
/// based on <paramref name="assessmentSection"/>.
/// </summary>
/// <param name="assessmentSection">The <see cref="ExportableAssessmentSection"/>
/// to create a <see cref="SerializableAssessmentSection"/> for.</param>
/// <returns>A <see cref="SerializableAssessmentSection"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static SerializableAssessmentSection Create(ExportableAssessmentSection assessmentSection)
{
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
return(new SerializableAssessmentSection(IdentifierGenerator.GeneratedId(assessmentSection),
assessmentSection.Name,
assessmentSection.Geometry));
}
public void GenerateId_WithAssessmentSection_GeneratesId()
{
// Setup
const string assessmentSectionId = "AssessmentSectionId";
ExportableAssessmentSection assessmentSection = CreateAssessmentSection(assessmentSectionId);
// Call
string generatedId = IdentifierGenerator.GeneratedId(assessmentSection);
// Assert
Assert.AreEqual($"Wks.{assessmentSection.Id}", generatedId);
}
/// <summary>
/// Creates an instance of <see cref="SerializableAssembly"/> based
/// on <paramref name="assessmentSection"/>.
/// </summary>
/// <param name="assessmentSection">The <see cref="ExportableAssessmentSection"/>
/// to create a <see cref="SerializableAssembly"/> for.</param>
/// <returns>A <see cref="SerializableAssembly"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/>
/// is <c>null</c>.</exception>
/// <exception cref="AssemblyCreatorException">Thrown when the <paramref name="assessmentSection"/> is invalid
/// to create a serializable counterpart for.</exception>
public static SerializableAssembly Create(ExportableAssessmentSection assessmentSection)
{
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
var idGenerator = new IdentifierGenerator();
string serializableAssemblyId = idGenerator.GetNewId(Resources.SerializableAssembly_IdPrefix);
SerializableAssessmentSection serializableAssessmentSection = SerializableAssessmentSectionCreator.Create(assessmentSection);
SerializableAssessmentProcess serializableAssessmentProcess = SerializableAssessmentProcessCreator.Create(idGenerator, serializableAssessmentSection);
SerializableTotalAssemblyResult serializableTotalAssemblyResult =
SerializableTotalAssemblyResultCreator.Create(
idGenerator,
serializableAssessmentProcess,
SerializableAssemblyMethodCreator.Create(assessmentSection.AssessmentSectionAssembly.ProbabilityAssemblyMethod),
SerializableAssemblyMethodCreator.Create(assessmentSection.AssessmentSectionAssembly.AssemblyGroupAssemblyMethod),
SerializableAssessmentSectionAssemblyGroupCreator.Create(assessmentSection.AssessmentSectionAssembly.AssemblyGroup),
assessmentSection.AssessmentSectionAssembly.Probability);
AggregatedSerializableFailureMechanism[] aggregatedFailureMechanisms = assessmentSection.FailureMechanisms
.Select(fm => AggregatedSerializableFailureMechanismCreator.Create(
idGenerator, serializableTotalAssemblyResult, fm))
.ToArray();
AggregatedSerializableCombinedFailureMechanismSectionAssemblies aggregatedSerializableCombinedFailureMechanismSectionAssemblies =
AggregatedSerializableCombinedFailureMechanismSectionAssembliesCreator.Create(
idGenerator, serializableTotalAssemblyResult, assessmentSection.CombinedSectionAssemblies);
return(new SerializableAssembly(
serializableAssemblyId,
GetLowerCorner(assessmentSection.Geometry),
GetUpperCorner(assessmentSection.Geometry),
serializableAssessmentSection,
serializableAssessmentProcess,
serializableTotalAssemblyResult,
aggregatedFailureMechanisms.Select(afm => afm.FailureMechanism),
aggregatedFailureMechanisms.SelectMany(afm => afm.FailureMechanismSectionAssemblyResults),
aggregatedSerializableCombinedFailureMechanismSectionAssemblies.CombinedFailureMechanismSectionAssemblies,
GetAllSerializableFailureMechanismSectionCollections(
aggregatedFailureMechanisms, aggregatedSerializableCombinedFailureMechanismSectionAssemblies),
aggregatedFailureMechanisms.SelectMany(afm => afm.FailureMechanismSections)
.Concat(aggregatedSerializableCombinedFailureMechanismSectionAssemblies.FailureMechanismSections)));
}
public void Constructor_WithValidArguments_ExpectedValues(string name, string id)
{
// Setup
IEnumerable <Point2D> geometry = Enumerable.Empty <Point2D>();
ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly = ExportableAssessmentSectionAssemblyResultTestFactory.CreateResult();
IEnumerable <ExportableFailureMechanism> failureMechanisms = Enumerable.Empty <ExportableFailureMechanism>();
IEnumerable <ExportableCombinedSectionAssembly> combinedSectionAssemblyResults = Enumerable.Empty <ExportableCombinedSectionAssembly>();
// Call
var assessmentSection = new ExportableAssessmentSection(
name, id, geometry, assessmentSectionAssembly, failureMechanisms, combinedSectionAssemblyResults);
// Assert
Assert.AreEqual(name, assessmentSection.Name);
Assert.AreEqual(id, assessmentSection.Id);
Assert.AreSame(geometry, assessmentSection.Geometry);
Assert.AreSame(assessmentSectionAssembly, assessmentSection.AssessmentSectionAssembly);
Assert.AreSame(failureMechanisms, assessmentSection.FailureMechanisms);
Assert.AreSame(combinedSectionAssemblyResults, assessmentSection.CombinedSectionAssemblies);
}
public void Create_WithAssessmentSection_ReturnsSerializableAssessmentSection()
{
// Setup
const string assessmentSectionName = "Assessment Section Name";
const string assessmentSectionId = "assessmentSectionId";
ExportableAssessmentSection assessmentSection = CreateAssessmentSection(assessmentSectionName,
assessmentSectionId);
// Call
SerializableAssessmentSection serializableAssessmentSection =
SerializableAssessmentSectionCreator.Create(assessmentSection);
// Assert
Assert.AreEqual($"Wks.{assessmentSection.Id}", serializableAssessmentSection.Id);
Assert.AreEqual(assessmentSectionName, serializableAssessmentSection.Name);
IEnumerable <Point2D> expectedGeometry = assessmentSection.Geometry;
Assert.AreEqual(Math2D.Length(expectedGeometry), serializableAssessmentSection.ReferenceLineLength.Value);
Assert.AreEqual(GeometrySerializationFormatter.Format(expectedGeometry),
serializableAssessmentSection.ReferenceLineGeometry.LineString.Geometry);
}
public void CreateSerializableAssembly_WithValidArguments_ReturnsSerializableAssembly()
{
// Setup
const string assessmentSectionName = "assessmentSectionName";
const string assessmentSectionId = "assessmentSectionId";
IEnumerable <Point2D> geometry = CreateGeometry();
ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly =
ExportableAssessmentSectionAssemblyResultTestFactory.CreateResult();
IEnumerable <ExportableFailureMechanism> failureMechanisms =
new[]
{
CreateFailureMechanism(),
CreateFailureMechanism(),
CreateFailureMechanism(),
CreateFailureMechanism()
};
var exportableAssessmentSection = new ExportableAssessmentSection(assessmentSectionName,
assessmentSectionId,
geometry,
assessmentSectionAssembly,
failureMechanisms,
new[]
{
CreateCombinedSectionAssembly(CreateCombinedFailureMechanismSection()),
CreateCombinedSectionAssembly(CreateCombinedFailureMechanismSection())
});
// Call
SerializableAssembly serializableAssembly = SerializableAssemblyCreator.Create(exportableAssessmentSection);
// Assert
Assert.AreEqual("Assemblage.0", serializableAssembly.Id);
AssertSerializableBoundary(exportableAssessmentSection.Geometry, serializableAssembly.Boundary);
SerializableFeatureMember[] serializableAssemblyFeatureMembers = serializableAssembly.FeatureMembers;
Assert.AreEqual(24, serializableAssemblyFeatureMembers.Length);
var serializableAssessmentSection = (SerializableAssessmentSection)serializableAssemblyFeatureMembers[0];
AssertSerializableAssessmentSection($"Wks.{assessmentSectionId}", assessmentSectionName, geometry, serializableAssessmentSection);
var serializableAssessmentProcess = (SerializableAssessmentProcess)serializableAssemblyFeatureMembers[1];
AssertSerializableAssessmentProcess("Bp.0", serializableAssessmentSection, serializableAssessmentProcess);
var serializableTotalAssemblyResult = (SerializableTotalAssemblyResult)serializableAssemblyFeatureMembers[2];
AssertSerializableTotalAssemblyResult("Vo.0",
assessmentSectionAssembly,
serializableAssessmentProcess,
serializableTotalAssemblyResult);
AssertFailureMechanismConnections(3, 0, serializableTotalAssemblyResult, serializableAssemblyFeatureMembers);
AssertFailureMechanismConnections(4, 1, serializableTotalAssemblyResult, serializableAssemblyFeatureMembers);
AssertFailureMechanismConnections(5, 2, serializableTotalAssemblyResult, serializableAssemblyFeatureMembers);
AssertFailureMechanismConnections(6, 3, serializableTotalAssemblyResult, serializableAssemblyFeatureMembers);
var combinedFailureMechanismSectionCollection = (SerializableFailureMechanismSectionCollection)serializableAssemblyFeatureMembers[17];
AssertSerializableFailureMechanismSectionCollection("Vi.4", combinedFailureMechanismSectionCollection);
AssertCombinedFailureMechanismSectionAssemblyConnections(11, 4, 0, combinedFailureMechanismSectionCollection, serializableTotalAssemblyResult, serializableAssemblyFeatureMembers);
AssertCombinedFailureMechanismSectionAssemblyConnections(12, 5, 1, combinedFailureMechanismSectionCollection, serializableTotalAssemblyResult, serializableAssemblyFeatureMembers);
}
public void CreateExportableAssessmentSection_WithAssessmentSectionWithReferenceLine_ReturnsExpectedValues()
{
// Setup
const string name = "assessmentSectionName";
const string id = "assessmentSectionId";
var random = new Random(21);
var assessmentSection = new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>())
{
Name = name,
Id = id
};
ReferenceLineTestFactory.SetReferenceLineGeometry(assessmentSection.ReferenceLine);
assessmentSection.SpecificFailureMechanisms.Add(new SpecificFailureMechanism());
assessmentSection.SpecificFailureMechanisms.Add(new SpecificFailureMechanism());
FailureMechanismTestHelper.AddSections(assessmentSection.Piping, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.MacroStabilityInwards, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverErosionInwards, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.HeightStructures, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.ClosingStructures, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.StabilityPointStructures, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.StabilityStoneCover, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.WaveImpactAsphaltCover, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverErosionOutwards, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.DuneErosion, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.Microstability, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverSlipOffOutwards, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverSlipOffInwards, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.PipingStructure, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.WaterPressureAsphaltCover, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.SpecificFailureMechanisms.First(), random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.SpecificFailureMechanisms.Last(), random.Next(1, 10));
using (new AssemblyToolCalculatorFactoryConfig())
{
// Call
ExportableAssessmentSection exportableAssessmentSection = ExportableAssessmentSectionFactory.CreateExportableAssessmentSection(assessmentSection);
// Assert
Assert.AreEqual(name, exportableAssessmentSection.Name);
Assert.AreEqual(id, exportableAssessmentSection.Id);
CollectionAssert.AreEqual(assessmentSection.ReferenceLine.Points, exportableAssessmentSection.Geometry);
ExportableAssessmentSectionAssemblyResult exportableAssessmentSectionAssemblyResult = exportableAssessmentSection.AssessmentSectionAssembly;
Assert.AreEqual(ExportableAssemblyMethod.BOI2A1, exportableAssessmentSectionAssemblyResult.ProbabilityAssemblyMethod);
Assert.AreEqual(ExportableAssemblyMethod.BOI2B1, exportableAssessmentSectionAssemblyResult.AssemblyGroupAssemblyMethod);
Assert.AreEqual(AssessmentSectionAssemblyGroup.APlus, exportableAssessmentSectionAssemblyResult.AssemblyGroup);
Assert.AreEqual(0.14, exportableAssessmentSectionAssemblyResult.Probability);
AssertExportableFailureMechanisms(exportableAssessmentSection.FailureMechanisms, assessmentSection);
Assert.AreEqual(1, exportableAssessmentSection.CombinedSectionAssemblies.Count());
ExportableCombinedSectionAssembly exportableCombinedSectionAssembly = exportableAssessmentSection.CombinedSectionAssemblies.ElementAt(0);
Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Zero, exportableCombinedSectionAssembly.CombinedSectionAssemblyResult.AssemblyGroup);
Assert.AreEqual(ExportableAssemblyMethod.BOI3C1, exportableCombinedSectionAssembly.CombinedSectionAssemblyResult.AssemblyGroupAssemblyMethod);
Assert.AreEqual(0.0, exportableCombinedSectionAssembly.CombinedSectionAssemblyResult.FailureMechanismSection.StartDistance);
Assert.AreEqual(1.0, exportableCombinedSectionAssembly.CombinedSectionAssemblyResult.FailureMechanismSection.EndDistance);
AssertExportableFailureMechanismCombinedSectionAssemblyResults(exportableCombinedSectionAssembly.FailureMechanismResults, assessmentSection);
Assert.AreEqual(ExportableAssemblyMethod.BOI3A1, exportableCombinedSectionAssembly.Section.AssemblyMethod);
Assert.AreEqual(0.0, exportableCombinedSectionAssembly.Section.StartDistance);
Assert.AreEqual(1.0, exportableCombinedSectionAssembly.Section.EndDistance);
}
}
